Upload a1

29 files changed, 0 insertions, 2011 deletions

diff --git a/dev/a6-harold/.gitignore b/dev/a6-harold/.gitignore
deleted file mode 100644
index dd1a9a8..0000000
--- a/dev/a6-harold/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-config.h
-build
diff --git a/dev/a6-harold/CMakeLists.txt b/dev/a6-harold/CMakeLists.txt
deleted file mode 100644
index 83ca82d..0000000
--- a/dev/a6-harold/CMakeLists.txt
+++ /dev/null
@@ -1,209 +0,0 @@
-# Original Author(s) of this File: 
-#   Daniel Keefe, 2017, University of Minnesota
-#  
-# Author(s) of Significant Updates/Modifications to the File:
-#   ... 
-
-
-
-# You are encouraged to copy this example, move it outside of the MinGfx directory, and use
-# it as a starting point for your project.  When you do this, you'll have to edit the
-# following line as needed to point to the MinGfx install prefix used on your system.
-
-# !!!!!!!!!!!!! EDIT THE FOLLOWING LINE AS NEEDED !!!!!!!!!!!!! 
-list(APPEND CMAKE_PREFIX_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../build/install ../..)
-
-
-
-#### BASIC PROJECT SETUP ####
-
-project(a6-harold)
-
-# Using 3.9 to get a modern version of FindOpenGL.cmake
-cmake_minimum_required (VERSION 3.9) 
-
-# Dependencies that are auto-downloaded, built, and installed for you will go in the 
-# directory pointed to by the CMAKE_INSTALL_PREFIX.  It defaults to a location inside
-# the build directory.
-if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT OR "${CMAKE_INSTALL_PREFIX}" STREQUAL "")
-    set (CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "default install path" FORCE )
-endif()
-
-# Add to paths cmake uses to search for scripts, modules, and config packages
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_INSTALL_PREFIX})
-list(INSERT CMAKE_PREFIX_PATH 0 ${CMAKE_INSTALL_PREFIX})
-
-include(MessageMacros)
-h1("Building ${PROJECT_NAME}")
-h2("Configuring paths")
-
-message(STATUS "Module path: ${CMAKE_MODULE_PATH}")
-message(STATUS "Prefix path: ${CMAKE_PREFIX_PATH}")
-message(STATUS "Install prefix: ${CMAKE_INSTALL_PREFIX}")
-
-set(DATA_DIR_BUILD ${CMAKE_CURRENT_SOURCE_DIR}/data)
-set(DATA_DIR_INSTALL ${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/data)
-
-message(STATUS "Data dir (in build tree): ${DATA_DIR_BUILD}")
-message(STATUS "Data dir (in install tree): ${DATA_DIR_INSTALL}")
-
-set(SHADERS_DIR_BUILD ${CMAKE_CURRENT_SOURCE_DIR}/shaders)
-set(SHADERS_DIR_INSTALL ${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/shaders)
-
-message(STATUS "Shaders dir (in build tree): ${SHADERS_DIR_BUILD}")
-message(STATUS "Shaders dir (in install tree): ${SHADERS_DIR_INSTALL}")
-
-
-# Configure a header file to pass some of the CMake settings to the source code
-configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
-    ${CMAKE_CURRENT_SOURCE_DIR}/config.h
-)
-
-#### SOURCE FOR THIS PROJECT ####
-h2("Configuring source files")
-
-set(SOURCEFILES
-    billboards.cc
-    harold_app.cc
-    edge_mesh.cc
-    ground.cc
-    main.cc
-    sky.cc
-)
-
-set(HEADERFILES
-    billboards.h
-    harold_app.h
-    config.h
-    edge_mesh.h
-    ground.h
-    sky.h
-)
-
-set(EXTRAFILES
-    config.h.in
-    README.md
-)
-
-set(SHADERFILES
-    shaders/artsy.vert
-    shaders/artsy.frag
-    shaders/outline.vert
-    shaders/outline.frag
-    shaders/stroke2d.vert
-    shaders/stroke2d.frag
-    shaders/stroke3d.vert
-    shaders/stroke3d.frag
-)
-
-set_source_files_properties(${EXTRAFILES} PROPERTIES HEADER_FILE_ONLY TRUE)
-set_source_files_properties(${SHADERFILES} PROPERTIES HEADER_FILE_ONLY TRUE)
-
-source_group("Shaders" FILES ${SHADERFILES})
-
-
-#### COMPILE OPTIONS ####
-
-h2("Configuring Compiler Options")
-
-
-
-message(STATUS "Building for " ${CMAKE_SYSTEM_NAME} ".")
-
-# Linux specific
-if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-  add_definitions(-DLINUX)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
-endif()
-
-
-# Apple specific
-if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-  add_definitions(-DOSX)
-
-  # RPATH settings, see https://cmake.org/Wiki/CMake_RPATH_handling
-  set(CMAKE_MACOSX_RPATH ON)
-
-  # use, i.e. don't skip the full RPATH for the build tree
-  SET(CMAKE_SKIP_BUILD_RPATH  FALSE)
-
-  # when building, don't use the install RPATH already
-  # (but later on when installing)
-  SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) 
-
-  SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
-
-  # add the automatically determined parts of the RPATH
-  # which point to directories outside the build tree to the install RPATH
-  SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-
-  # the RPATH to be used when installing, but only if it's not a system directory
-  LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
-  IF("${isSystemDir}" STREQUAL "-1")
-     SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
-  ENDIF("${isSystemDir}" STREQUAL "-1")
-
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
-endif()
-
-
-# Windows specific
-if (WIN32)
-  add_definitions(-DWIN32)
-
-  if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-    message(FATAL_ERROR
-        "You must use the 64 bit version of the compiler. Be sure to set the correct generator when configuring through CMake.")
-  endif()
-endif()
-
-
-
-
-#### DEFINE TARGET(S) ####
-
-h2("Defining Target(s)")
-
-add_executable(${PROJECT_NAME} ${SOURCEFILES} ${HEADERFILES} ${EXTRAFILES} ${SHADERFILES})
-
-
-
-#### FIND AND ADD DEPENDENCIES ####
-
-h2("Adding Dependencies")
-set(EXTERNAL_DIR external)
-
-
-# MinGfx (linked with an imported cmake target so no need to specify include dirs)
-# This will try to find MinGfxConfig.cmake, which should have been installed under
-# CMAKE_INSTALL_PREFIX/lib/cmake/MinGfx when you installed the MinGfx Toolkit.
-find_package(MinGfx REQUIRED)
-target_link_libraries(${PROJECT_NAME} PUBLIC MinGfx::MinGfx)
-
-
-# Add dependency on OpenGL
-include(UseOpenGL)
-UseOpenGL(${PROJECT_NAME} PUBLIC ${EXTERNAL_DIR})
-
-
-
-#### INSTALL TARGET(S) ####
-
-h2("Configuring Install Target")
-
-# The install locations are relative to the CMAKE_INSTALL_PREFIX variable
-install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
-
-install(
-    DIRECTORY data/
-    DESTINATION ${DATA_DIR_INSTALL}
-    OPTIONAL
-)
-
-install(
-    DIRECTORY shaders/
-    DESTINATION ${SHADERS_DIR_INSTALL}
-    OPTIONAL
-)
diff --git a/dev/a6-harold/README.md b/dev/a6-harold/README.md
deleted file mode 100644
index e69de29..0000000
--- a/dev/a6-harold/README.md
+++ /dev/null
diff --git a/dev/a6-harold/billboards.cc b/dev/a6-harold/billboards.cc
deleted file mode 100644
index 5ec508a..0000000
--- a/dev/a6-harold/billboards.cc
+++ /dev/null
@@ -1,206 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#include "billboards.h"
-
-Billboards::Billboards() {
-    
-}
-
-
-Billboards::~Billboards() {
-    
-}
-
-
-void Billboards::Init(ShaderProgram *stroke3d_shaderprog) {
-    stroke3d_shaderprog_ = stroke3d_shaderprog;
-}
-
-
-/// Projects a 2D normalized screen point (e.g., the mouse position in normalized
-/// device coordinates) to a 3D point on a plane defined by an "origin", which can
-/// really be any point coincident with the plane, and the plane normal.  Returns
-/// true if the screen point projects onto the plane and stores the result in
-/// plane_point.  Returns false if the screen point does not project onto the plane.
-bool Billboards::ScreenPtHitsPlane(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                                 const Point3 &plane_origin, const Vector3 &plane_normal,
-                                 const Point2 &normalized_screen_pt, Point3 *plane_point)
-{
-    Matrix4 camera_matrix = view_matrix.Inverse();
-    Point3 eye = camera_matrix.ColumnToPoint3(3);
-    
-    Point3 pt3d = GfxMath::ScreenToNearPlane(view_matrix, proj_matrix, normalized_screen_pt);
-    Ray ray(eye, (pt3d - eye).ToUnit());
-    float t;
-    return ray.IntersectPlane(plane_origin, plane_normal, &t, plane_point);
-}
-
-
-/// Checks to see if a ray starting at the eye point and passing through 2D
-/// normalized screen point projects onto any of the billboards in the scene. If
-/// so, returns the id of the closest billboard intersected.  If not, returns -1.
-int Billboards::IntersectBillboard(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                                   const Point2 &normalized_screen_pt)
-{
-    Matrix4 camera_matrix = view_matrix.Inverse();
-    Point3 eye = camera_matrix.ColumnToPoint3(3);
-    
-    int id = -1;
-    float best_i_time = -1.0;
-    
-    Point3 pt3d = GfxMath::ScreenToNearPlane(view_matrix, proj_matrix, normalized_screen_pt);
-    Ray ray(eye, (pt3d - eye).ToUnit());
-    
-    Point3 i_point;
-    float i_time;
-    int i_tri_id;
-    for (int i=0; i<billboards_.size(); i++) {
-        Matrix4 to_billboard_space = billboards_[i].transform.Inverse();
-        Ray ray_billboard_space = to_billboard_space * ray;
-        if ((ray_billboard_space.IntersectAABB(billboards_[i].bounding_box, &i_time)) &&
-            (ray_billboard_space.IntersectMesh(billboards_[i].mesh, &i_time, &i_point, &i_tri_id)) &&
-            ((best_i_time == -1.0) || (i_time < best_i_time))) {
-            id = i;
-        }
-    }
-    
-    return id;
-}
-
-
-/// Adds a new stroke as a billboard by projecting it onto a plane parallel
-/// to the filmplane that intersects with the base point, which should lie
-/// on the ground.
-void Billboards::AddBillboardStroke(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                                    const std::vector<Point2> &stroke2d, const Mesh &stroke2d_mesh,
-                                    const Color &stroke_color, Ground *ground_ptr)
-{
-    Matrix4 camera_matrix = view_matrix.Inverse();
-    Point3 eye = camera_matrix.ColumnToPoint3(3);
-    
-    // Create a new billboard
-    Billboard b;
-    b.color = stroke_color;
-    b.transform = Matrix4();
-    b.mesh = stroke2d_mesh;
-    
-    // find the base point for the billboard
-    ground_ptr->ScreenPtHitsGround(view_matrix, proj_matrix, stroke2d[0], &b.anchor_pt);
-    Vector3 norm = (eye - b.anchor_pt);
-    norm[1] = 0.0;    // with 0 change in Y so the billboard does not tilt
-    norm.Normalize(); // convert to a unit vector
-    
-    // project the stroke into 3D to lie on the projection plane
-    std::vector<Point3> verts;
-    for (int i=0; i<b.mesh.num_vertices(); i++) {
-        Point2 pscreen = Point2(b.mesh.read_vertex_data(i)[0], b.mesh.read_vertex_data(i)[1]);
-        Point3 pplane;
-        ScreenPtHitsPlane(view_matrix, proj_matrix, b.anchor_pt, norm, pscreen, &pplane);
-        verts.push_back(pplane);
-    }
-    
-    Matrix4 to_canonical_billboard = Matrix4::Align(b.anchor_pt, Vector3::UnitY(), norm,
-                                                    Point3::Origin(), Vector3::UnitY(), Vector3::UnitZ());
-    
-    for (int i=0; i<verts.size(); i++) {
-        verts[i] = to_canonical_billboard * verts[i];
-    }
-    
-    b.mesh.SetVertices(verts);
-    
-    for (int i=0; i<b.mesh.num_vertices(); i++) {
-        b.bounding_box = b.bounding_box + AABB(b.mesh.read_vertex_data(i));
-    }
-    b.bounding_box.set_user_data((int)billboards_.size());
-    
-    billboards_.push_back(b);
-}
-
-
-/// Edits an existing billboard by adding an additional stroke to it.
-void Billboards::AddToBillboard(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                                int billboard_id, const Mesh &stroke2d_mesh,
-                                const Color &stroke_color)
-{
-    Matrix4 camera_matrix = view_matrix.Inverse();
-    Point3 eye = camera_matrix.ColumnToPoint3(3);
-    
-    // Really what this does is add a new billboard that lies in the same plane
-    // as the one we are "editing" and has the same anchor point so that they
-    // will both rotate the same way.
-    Billboard b;
-    b.color = stroke_color;
-    b.transform = Matrix4();
-    b.mesh = stroke2d_mesh;
-    
-    b.anchor_pt = billboards_[billboard_id].anchor_pt;
-    
-    
-    Vector3 norm = (eye - b.anchor_pt);
-    norm[1] = 0.0;    // with 0 change in Y so the billboard does not tilt
-    norm.Normalize(); // convert to a unit vector
-    
-    // project the stroke into 3D to lie on the projection plane
-    std::vector<Point3> verts;
-    for (int i=0; i<b.mesh.num_vertices(); i++) {
-        Point2 pscreen = Point2(b.mesh.read_vertex_data(i)[0], b.mesh.read_vertex_data(i)[1]);
-        Point3 pplane;
-        ScreenPtHitsPlane(view_matrix, proj_matrix, b.anchor_pt, norm, pscreen, &pplane);
-        verts.push_back(pplane);
-    }
-    
-    Matrix4 to_canonical_billboard = Matrix4::Align(b.anchor_pt, Vector3::UnitY(), norm,
-                                                    Point3::Origin(), Vector3::UnitY(), Vector3::UnitZ());
-    
-    for (int i=0; i<verts.size(); i++) {
-        verts[i] = to_canonical_billboard * verts[i];
-    }
-    
-    b.mesh.SetVertices(verts);
-    
-    for (int i=0; i<b.mesh.num_vertices(); i++) {
-        b.bounding_box = b.bounding_box + AABB(b.mesh.read_vertex_data(i));
-    }
-    b.bounding_box.set_user_data((int)billboards_.size());
-    
-    billboards_.push_back(b);
-}
-
-
-void Billboards::UpdateBillboardRotations(const Point3 &current_eye_point) {
-    // Whenver the camera moves, we also need to rotate the billboards so
-    // that they always face the viewer.
-    for (int i=0; i<billboards_.size(); i++) {
-        // billboards are stored in a coordinate system where the base is
-        // at (0,0,0), rotation happens about the Y axis, and the billboard's
-        // normal is +Z.
-        Point3 a_p = Point3(0,0,0);        // 'anchor point' in billboard coordinates
-        Vector3 a_v1 = Vector3::UnitY();   // 'up' in billboard coordinates
-        Vector3 a_v2 = Vector3::UnitZ();   // 'normal' in billboard coordinates
-        
-        Point3 b_p = billboards_[i].anchor_pt;    // 'anchor point' in world coordinates
-        Vector3 b_v1 = Vector3::UnitY();          // 'up' in world coordinates
-        Vector3 b_v2 = (current_eye_point - b_p); // 'normal' in world coordinates
-        b_v2[1] = 0.0;    // force 0 change in Y so the billboard does not tilt
-        b_v2.Normalize(); // convert to a unit vector
-        
-        billboards_[i].transform = Matrix4::Align(a_p,a_v1,a_v2, b_p,b_v1,b_v2);
-    }
-}
-
-
-void Billboards::Draw(const Matrix4 &view_matrix, const Matrix4 &proj_matrix) {
-    // Draw billboard meshes
-    stroke3d_shaderprog_->UseProgram();
-    stroke3d_shaderprog_->SetUniform("projectionMatrix", proj_matrix);
-    for (int i=0; i<billboards_.size(); i++) {
-        Matrix4 model_matrix = billboards_[i].transform;
-        Matrix4 modelview_matrix = view_matrix * model_matrix;
-        stroke3d_shaderprog_->SetUniform("modelViewMatrix", modelview_matrix);
-        stroke3d_shaderprog_->SetUniform("strokeColor", billboards_[i].color);
-        billboards_[i].mesh.Draw();
-    }
-    stroke3d_shaderprog_->StopProgram();
-}
-
diff --git a/dev/a6-harold/billboards.h b/dev/a6-harold/billboards.h
deleted file mode 100644
index 7de2799..0000000
--- a/dev/a6-harold/billboards.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#ifndef BILLBOARDS_H_
-#define BILLBOARDS_H_
-
-#include <mingfx.h>
-using namespace mingfx;
-
-#include "ground.h"
-
-/** Billboards are strokes planted in the ground that rotate automatically to
- face the viewer.  This class holds the entire collection of billboard strokes.
- */
-class Billboards {
-public:
-    Billboards();
-    virtual ~Billboards();
-    
-    void Init(ShaderProgram *stroke3d_shaderprog);
-    
-    /// Projects a 2D normalized screen point (e.g., the mouse position in normalized
-    /// device coordinates) to a 3D point on a plane defined by an "origin", which can
-    /// really be any point coincident with the plane, and the plane normal.  Returns
-    /// true if the screen point projects onto the plane and stores the result in
-    /// plane_point.  Returns false if the screen point does not project onto the plane.
-    bool ScreenPtHitsPlane(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                         const Point3 &plane_origin, const Vector3 &plane_normal,
-                         const Point2 &normalized_screen_pt, Point3 *plane_point);
-    
-    
-    /// Checks to see if a ray starting at the eye point and passing through 2D
-    /// normalized screen point projects onto any of the billboards in the scene. If
-    /// so, returns the id of the closest billboard intersected.  If not, returns -1.
-    int IntersectBillboard(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                           const Point2 &normalized_screen_pt);
-    
-    
-    /// Adds a new stroke as a billboard by projecting it onto a plane parallel
-    /// to the filmplane that intersects with the anchor point, which should lie
-    /// on the ground.
-    void AddBillboardStroke(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                            const std::vector<Point2> &stroke2d, const Mesh &stroke2d_mesh,
-                            const Color &stroke_color, Ground *ground_ptr);
-    
-    /// Edits an existing billboard by adding an additional stroke to it.
-    void AddToBillboard(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                        int billboard_id, const Mesh &stroke2d_mesh,
-                        const Color &stroke_color);
-    
-    
-    /// Adjusts the transformation matrix used to draw each billboard so that the
-    /// billboard will face the camera.  Needs to be called each time the camera
-    /// is moved within the scene.
-    void UpdateBillboardRotations(const Point3 &current_eye_point);
-    
-    
-    /// Draws all of the billboards
-    void Draw(const Matrix4 &view_matrix, const Matrix4 &proj_matrix);
-    
-private:
-
-    // each billboard stores the following
-    struct Billboard {
-        Mesh mesh;
-        Color color;
-        Point3 anchor_pt;
-        AABB bounding_box;
-        Matrix4 transform;
-    };
-
-    // the array of all active billboards
-    std::vector<Billboard> billboards_;
-    
-    ShaderProgram *stroke3d_shaderprog_;
-};
-
-#endif
diff --git a/dev/a6-harold/cmake/DownloadHelper.txt.in b/dev/a6-harold/cmake/DownloadHelper.txt.in
deleted file mode 100644
index fb29bff..0000000
--- a/dev/a6-harold/cmake/DownloadHelper.txt.in
+++ /dev/null
@@ -1,26 +0,0 @@
-# This file is part of the MinGfx cmake build system.  
-# See the main MinGfx/CMakeLists.txt file for authors, copyright, and license info.
-
-# This is a "helper" cmake project -- the only thing this project does is download
-# the external project.  So, the configure, build, install, and test commands for 
-# ExternalProject_Add() are intentionally set as NOPs.  
-
-cmake_minimum_required (VERSION 3.9) 
-
-project(@EXT_PROJECT_NAME@-download)
-
-include(ExternalProject)
-ExternalProject_Add(
-  @EXT_PROJECT_NAME@
-  SOURCE_DIR "@DOWNLOAD_DIR@/@EXT_PROJECT_NAME@/src"
-  BINARY_DIR "@DOWNLOAD_DIR@/@EXT_PROJECT_NAME@/download-helper"
-  @DOWNLOAD_OPTIONS@
-  CONFIGURE_COMMAND ""
-  BUILD_COMMAND ""
-  INSTALL_COMMAND ""
-  TEST_COMMAND ""
-  LOG_DOWNLOAD ON
-  GIT_PROGRESS 1
-)
-
-
diff --git a/dev/a6-harold/cmake/ExternalProjectDownloadBuildInstall.cmake b/dev/a6-harold/cmake/ExternalProjectDownloadBuildInstall.cmake
deleted file mode 100644
index ce12d1d..0000000
--- a/dev/a6-harold/cmake/ExternalProjectDownloadBuildInstall.cmake
+++ /dev/null
@@ -1,98 +0,0 @@
-# This file is part of the MinGfx cmake build system.  
-# See the main MinGfx/CMakeLists.txt file for authors, copyright, and license info.
-
-
-# Calling CMAKE_CURRENT_LIST_DIR inside a function returns the list dir of the calling script
-# but we want the list dir of this file in order to find the DownloadHelper.txt.in file, which
-# should be stored right next to this one.  So, defining this variable outside the scope of the
-# functions below.
-set(DIR_OF_THIS_FILE ${CMAKE_CURRENT_LIST_DIR})  
-
-
-
-# Usage:  
-# ExternalProject_Download(
-#     # This first argument is the name of the project to download.  It is required:
-#     glm
-#
-#     # Additional arguments specify how to download the project using GIT, SVN, CVS, or URL.
-#     # These can be any of the arguments used for the downloading step of the cmake builtin
-#     # ExternalProject_Add command. 
-#     GIT_REPOSITORY "https://github.com/g-truc/glm.git"
-#     GIT_TAG master
-#     etc..
-# )
-function(ExternalProject_Download EXT_PROJECT_NAME DOWNLOAD_DIR)
-
-    include(MessageMacros)
-    h1("BEGIN EXTERNAL PROJECT DOWNLOAD (${EXT_PROJECT_NAME}).")
-
-    h2("Creating a download helper project for ${EXT_PROJECT_NAME}.")
-
-    set(DOWNLOAD_OPTIONS ${ARGN})
-    string (REGEX REPLACE "(^|[^\\\\]);" "\\1 " DOWNLOAD_OPTIONS "${DOWNLOAD_OPTIONS}")
-
-
-    file(MAKE_DIRECTORY ${DOWNLOAD_DIR}/${EXT_PROJECT_NAME})
-    configure_file(
-        ${DIR_OF_THIS_FILE}/DownloadHelper.txt.in 
-        ${DOWNLOAD_DIR}/${EXT_PROJECT_NAME}/download-helper/CMakeLists.txt
-    )
-
-    h2("Generating build files for the ${EXT_PROJECT_NAME} download helper project.")
-    execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY "${DOWNLOAD_DIR}/${EXT_PROJECT_NAME}/download-helper")
-
-    h2("Building the ${EXT_PROJECT_NAME} download helper project.  (This actually performs the download and may take some time...)")
-    execute_process(COMMAND "${CMAKE_COMMAND}" --build . WORKING_DIRECTORY "${DOWNLOAD_DIR}/${EXT_PROJECT_NAME}/download-helper")
-
-    h2("Completed download of external project ${EXT_PROJECT_NAME}.")
-
-endfunction()
-
-
-# Usage:  
-# ExternalProject_BuildAndInstallNow(
-#     # This first argument is the name of the external project to download.  It is required:
-#     VRPN
-#     # This second argument is the relative path from ${EXTERNAL_DIR_NAME}/projectname/ to the project's
-#     # main CMakeLists.txt file:
-#     src
-#
-#     # Additional arguments are passed on as options to the cmake build file generator
-#     -DVRPN_BUILD_DIRECTSHOW_VIDEO_SERVER=OFF
-#     -DVRPN_BUILD_HID_GUI=OFF
-#     etc..
-# )
-function(ExternalProject_BuildAndInstallNow EXT_PROJECT_NAME DOWNLOAD_DIR RELPATH_TO_CMAKELISTS)
-
-    include(MessageMacros)
-    h1("BEGIN EXTERNAL PROJECT BUILD AND INSTALL (${EXT_PROJECT_NAME}).")
-
-    # any extra args to the function are interpreted as arguments for the cmake config process
-    set(CMAKE_CONFIG_OPTIONS ${ARGN})
-
-    # always set the install prefix to be the same as for the main project
-    list(APPEND CMAKE_CONFIG_OPTIONS -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX})
-
-    #string (REGEX REPLACE "(^|[^\\\\]);" "\\1 " CMAKE_CONFIG_OPTIONS "${CMAKE_CONFIG_OPTIONS}")
-
-
-    set(SRC_DIR "${DOWNLOAD_DIR}/${EXT_PROJECT_NAME}/${RELPATH_TO_CMAKELISTS}")
-    set(BUILD_DIR "${CMAKE_BINARY_DIR}/external/${EXT_PROJECT_NAME}")
-
-    file(MAKE_DIRECTORY ${BUILD_DIR})
-
-    h2("Generating build files for external project ${EXT_PROJECT_NAME}.")
-    message(STATUS "Using source dir: ${SRC_DIR}")
-    message(STATUS "Using build dir: ${BUILD_DIR}")
-    message(STATUS "Config options: ${CMAKE_CONFIG_OPTIONS}")
-
-    execute_process(COMMAND "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" ${SRC_DIR} ${CMAKE_CONFIG_OPTIONS} WORKING_DIRECTORY ${BUILD_DIR})
-
-    h2("Building external project ${EXT_PROJECT_NAME}.  (This may take some time...)")
-    execute_process(COMMAND "${CMAKE_COMMAND}" --build ${BUILD_DIR} --target install)
-
-    h2("Completed external build of ${EXT_PROJECT_NAME}.")
-
-endfunction()
-
diff --git a/dev/a6-harold/cmake/MessageMacros.cmake b/dev/a6-harold/cmake/MessageMacros.cmake
deleted file mode 100644
index 4628e5c..0000000
--- a/dev/a6-harold/cmake/MessageMacros.cmake
+++ /dev/null
@@ -1,17 +0,0 @@
-# This file is part of the MinVR cmake build system.  
-# See the main MinVR/CMakeLists.txt file for authors, copyright, and license info.
-
-
-macro(h1 TITLE)
-  string(TOUPPER ${TITLE} TITLE)
-  message(STATUS "\n\n==== ${TITLE} ====")
-endmacro()
-
-macro(h2 TITLE)
-  message(STATUS "\n* ${TITLE}")
-endmacro()
-
-macro(h3 TITLE)
-  message(STATUS "- ${TITLE}")
-endmacro()
-
diff --git a/dev/a6-harold/cmake/UseOpenGL.cmake b/dev/a6-harold/cmake/UseOpenGL.cmake
deleted file mode 100644
index 2ec5ffb..0000000
--- a/dev/a6-harold/cmake/UseOpenGL.cmake
+++ /dev/null
@@ -1,52 +0,0 @@
-# This file is part of the MinGfx cmake build system.  
-# See the main MinGfx/CMakeLists.txt file for authors, copyright, and license info.
-
-# Either finds a pre-installed version or complains.
-
-# Usage: In your CMakeLists.txt, somewhere after you define the target that depends
-# on the OpenGL library (typical with something like add_executable(${PROJECT_NAME} ...) 
-# or add_library(${PROJECT_NAME} ...)), add the following two lines:
-
-#    include(UseOpenGL)
-#    UseOpenGL(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/external)
-
-# The second argument can be either PUBLIC, PRIVATE, or INTERFACE, following the keyword
-# usage described here: 
-# https://cmake.org/cmake/help/latest/command/target_include_directories.html
-
-# The third argument is the directory to use for downloading the external project if
-# autobuild is used.
-
-
-
-macro(UseOpenGL YOUR_TARGET INTERFACE_PUBLIC_OR_PRIVATE DOWNLOAD_DIR)
-
-    message(STATUS "Searching for OpenGL...")
-
-	# Check to see if the library is already installed on the system    
-    # CMake ships with FindOpenGL.cmake and in CMake 3.9+ it defines
-    # the imported targets OpenGL::GL and OpenGL::GLU.  Using these is
-    # now the preferred way to link with OpenGL and all of its dependencies.
-	# See https://cmake.org/cmake/help/v3.9/module/FindOpenGL.html
-	find_package(OpenGL)
-
-	if (NOT ${OPENGL_FOUND})
-	    message(FATAL_ERROR "OpenGL was not found on the system.  MinGfx can auto-download and build many dependencies for you, but not OpenGL. It should come pre-installed on your system.")
-	endif()
-
-    message(STATUS "Ok: OpenGL Found.")
-    message(STATUS "OpenGL headers: ${OPENGL_INCLUDE_DIR}")
-    message(STATUS "OpenGL libs: ${OPENGL_LIBRARIES}")
-
-
-    message(STATUS "Linking target ${YOUR_TARGET} with ${INTERFACE_PUBLIC_OR_PRIVATE} dependency OpenGL::GL.")
-    target_link_libraries(${YOUR_TARGET} ${INTERFACE_PUBLIC_OR_PRIVATE} OpenGL::GL)
-
-    if (${OPENGL_GLU_FOUND})
-        message(STATUS "Linking target ${YOUR_TARGET} with ${INTERFACE_PUBLIC_OR_PRIVATE} dependency OpenGL::GLU.")
-        target_link_libraries(${YOUR_TARGET} ${INTERFACE_PUBLIC_OR_PRIVATE} OpenGL::GLU)
-    endif()
-
-	target_compile_definitions(${YOUR_TARGET} ${INTERFACE_PUBLIC_OR_PRIVATE} -DUSE_OPENGL)
-
-endmacro()
diff --git a/dev/a6-harold/config.h.in b/dev/a6-harold/config.h.in
deleted file mode 100644
index 9798f4c..0000000
--- a/dev/a6-harold/config.h.in
+++ /dev/null
@@ -1,15 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-
-// The file config.h.in is processed by cmake to produce config.h.  This
-// replaces strings of the form "at"CMAKE_VARIABLE_NAME"at" with the value
-// of the corresponding cmake variable, allowing us to pass directory paths
-// and other information configured with cmake into our C++ code.
-
-
-#define DATA_DIR_BUILD "@DATA_DIR_BUILD@"
-#define DATA_DIR_INSTALL "@DATA_DIR_INSTALL@"
-
-#define SHADERS_DIR_BUILD "@SHADERS_DIR_BUILD@"
-#define SHADERS_DIR_INSTALL "@SHADERS_DIR_INSTALL@"
diff --git a/dev/a6-harold/data/toonDiffuse.png b/dev/a6-harold/data/toonDiffuse.png
deleted file mode 100644
index d2e40d9..0000000
--- a/dev/a6-harold/data/toonDiffuse.png
+++ /dev/null
diff --git a/dev/a6-harold/data/toonSpecular.png b/dev/a6-harold/data/toonSpecular.png
deleted file mode 100644
index c13a32f..0000000
--- a/dev/a6-harold/data/toonSpecular.png
+++ /dev/null
diff --git a/dev/a6-harold/edge_mesh.cc b/dev/a6-harold/edge_mesh.cc
deleted file mode 100644
index 1abe2e0..0000000
--- a/dev/a6-harold/edge_mesh.cc
+++ /dev/null
@@ -1,235 +0,0 @@
-/** CSci-4611 Assignment 5:  Art Render
- */
-
-#include "edge_mesh.h"
-
-EdgeMesh::EdgeMesh() : gpuDirty_(true) {
-    
-}
-
-EdgeMesh::~EdgeMesh() {
-}
-
-
-
-void EdgeMesh::CreateFromMesh(const Mesh &mesh) {
-    verts_.clear();
-    norms_.clear();
-    indices_.clear();
-    leftNorms_.clear();
-    rightNorms_.clear();
-    
-    // temp data holders for use while constructing the mesh in an indexed primitives mode
-    std::vector<Point3> vertices;                   // vertex positions
-    std::vector<Vector3> normals;                   // vertex normals
-    std::vector<Vector3> leftNormals, rightNormals; // normals of adj. faces
-    std::vector< std::vector<unsigned int> > triangles;      // fin triangles
-
-    for (int t = 0; t < mesh.num_triangles(); t++) {
-        std::vector<unsigned int> tri = mesh.read_triangle_indices_data(t);
-        Point3 a = mesh.read_vertex_data(tri[0]);
-        Point3 b = mesh.read_vertex_data(tri[1]);
-        Point3 c = mesh.read_vertex_data(tri[2]);
-        Vector3 e1 = b-a;
-        e1.Normalize();
-        Vector3 e2 = c-a;
-        e2.Normalize();
-        Vector3 n = e1.Cross(e2);
-        
-        //Vector3 n = ((b-a).cross(c-a)).to_unit();
-        //std::cout << n << std::endl;
-        addEdge(&vertices, &normals, &leftNormals, &rightNormals, &triangles, mesh, tri[0], tri[1], n);
-        addEdge(&vertices, &normals, &leftNormals, &rightNormals, &triangles, mesh, tri[1], tri[2], n);
-        addEdge(&vertices, &normals, &leftNormals, &rightNormals, &triangles, mesh, tri[2], tri[0], n);
-    }
-    
-    // now transfer data to the member variable data holders
-    for (int i=0; i<vertices.size(); i++) {
-        verts_.push_back(vertices[i][0]);
-        verts_.push_back(vertices[i][1]);
-        verts_.push_back(vertices[i][2]);
-        norms_.push_back(normals[i][0]);
-        norms_.push_back(normals[i][1]);
-        norms_.push_back(normals[i][2]);
-        leftNorms_.push_back(leftNormals[i][0]);
-        leftNorms_.push_back(leftNormals[i][1]);
-        leftNorms_.push_back(leftNormals[i][2]);
-        rightNorms_.push_back(rightNormals[i][0]);
-        rightNorms_.push_back(rightNormals[i][1]);
-        rightNorms_.push_back(rightNormals[i][2]);
-    }
-    
-    for (int i=0; i<triangles.size(); i++) {
-        indices_.push_back(triangles[i][0]);
-        indices_.push_back(triangles[i][1]);
-        indices_.push_back(triangles[i][2]);
-    }
-    gpuDirty_ = true;
-}
-
-
-void EdgeMesh::addEdge(std::vector<Point3> *vertices,
-                       std::vector<Vector3> *normals,
-                       std::vector<Vector3> *leftNormals,
-                       std::vector<Vector3> *rightNormals,
-                       std::vector< std::vector<unsigned int> > *triangles,
-                       const Mesh &mesh, int v0, int v1, Vector3 n)
-{
-    // edgeMap contains the index of the first of four consecutive vertices
-    // that form the quad fin
-
-    EdgeMap::iterator it = edgeMap.find(std::make_pair(v1, v0));
-    if (it != edgeMap.end()) { // found
-        int v = it->second;
-        (*rightNormals)[v+0]
-            = (*rightNormals)[v+1]
-            = (*rightNormals)[v+2]
-            = (*rightNormals)[v+3]
-            = n;
-    }
-    else {
-        int v = (int)vertices->size();
-        edgeMap[std::make_pair(v0, v1)] = v;
-        
-        vertices->push_back(mesh.read_vertex_data(v0));
-        vertices->push_back(mesh.read_vertex_data(v0));
-        vertices->push_back(mesh.read_vertex_data(v1));
-        vertices->push_back(mesh.read_vertex_data(v1));
-        
-        normals->push_back(Vector3());
-        normals->push_back(mesh.read_normal_data(v0));
-        normals->push_back(Vector3());
-        normals->push_back(mesh.read_normal_data(v1));
-        
-        leftNormals->push_back(n);
-        leftNormals->push_back(n);
-        leftNormals->push_back(n);
-        leftNormals->push_back(n);
-        
-        rightNormals->push_back(-n);
-        rightNormals->push_back(-n);
-        rightNormals->push_back(-n);
-        rightNormals->push_back(-n);
-
-        std::vector<unsigned int> tri1;
-        tri1.push_back(v+0);
-        tri1.push_back(v+2);
-        tri1.push_back(v+3);
-        triangles->push_back(tri1);
-        
-        std::vector<unsigned int> tri2;
-        tri2.push_back(v+0);
-        tri2.push_back(v+3);
-        tri2.push_back(v+1);
-        triangles->push_back(tri2);
-    }
-}
-
-
-
-void EdgeMesh::UpdateGPUMemory() {
-    if (gpuDirty_) {
-        // sanity check -- for each attribute that is added make sure the number
-        // of triangles is equal to the number of tris in the verts array.
-        if (norms_.size() / 3 != num_vertices()) {
-            std::cerr << "EdgeMesh::UpdateGPUMemory() -- warning: the number of per vertex normals in the mesh is not equal to the number vertices in the mesh. (N = " << norms_.size() / 3 << ", V = " << num_vertices() << ")" << std::endl;
-        }
-        if (leftNorms_.size() / 3 != num_vertices()) {
-            std::cerr << "EdgeMesh::UpdateGPUMemory() -- warning: the number of per vertex left-normals in the mesh is not equal to the number vertices in the mesh. (LN = " << leftNorms_.size() / 3 << ", V = " << num_vertices() << ")" << std::endl;
-        }
-        if (rightNorms_.size() / 3 != num_vertices()) {
-            std::cerr << "EdgeMesh::UpdateGPUMemory() -- warning: the number of per vertex right-normals in the mesh is not equal to the number vertices in the mesh. (RN = " << rightNorms_.size() / 3 << ", V = " << num_vertices() << ")" << std::endl;
-        }
-        
-        GLsizeiptr totalMemSize = 0;
-        
-        GLsizeiptr vertsMemSize = verts_.size() * sizeof(float);
-        GLsizeiptr vertsMemOffset = 0;
-        totalMemSize += vertsMemSize;
-        
-        GLsizeiptr normsMemSize = norms_.size() * sizeof(float);
-        GLsizeiptr normsMemOffset = totalMemSize;
-        totalMemSize += normsMemSize;
-        
-        GLsizeiptr leftNormsMemSize = leftNorms_.size() * sizeof(float);
-        GLsizeiptr leftNormsMemOffset = totalMemSize;
-        totalMemSize += leftNormsMemSize;
-
-        GLsizeiptr rightNormsMemSize = rightNorms_.size() * sizeof(float);
-        GLsizeiptr rightNormsMemOffset = totalMemSize;
-        totalMemSize += rightNormsMemSize;
-
-        glGenBuffers(1, &vertexBuffer_);
-        glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer_);
-        glBufferData(GL_ARRAY_BUFFER, totalMemSize, NULL, GL_STATIC_DRAW);
-        
-        glBufferSubData(GL_ARRAY_BUFFER, vertsMemOffset, vertsMemSize, &verts_[0]);
-        glBufferSubData(GL_ARRAY_BUFFER, normsMemOffset, normsMemSize, &norms_[0]);
-        glBufferSubData(GL_ARRAY_BUFFER, leftNormsMemOffset, leftNormsMemSize, &leftNorms_[0]);
-        glBufferSubData(GL_ARRAY_BUFFER, rightNormsMemOffset, rightNormsMemSize, &rightNorms_[0]);
-        
-        glGenVertexArrays(1, &vertexArray_);
-        glBindVertexArray(vertexArray_);
-        glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer_);
-        
-        // attribute 0 = vertices (required)
-        int attribID = 0;
-        int nComponents = 3;
-        glEnableVertexAttribArray(attribID);
-        glVertexAttribPointer(attribID, nComponents, GL_FLOAT, GL_FALSE, nComponents*sizeof(GLfloat), (char*)0 + vertsMemOffset);
-        
-        // attribute 1 = normals (required)
-        attribID = 1;
-        nComponents = 3;
-        glEnableVertexAttribArray(attribID);
-        glVertexAttribPointer(attribID, nComponents, GL_FLOAT, GL_TRUE, nComponents*sizeof(GLfloat), (char*)0 + normsMemOffset);
-
-        // attribute 2 = left normals (required)
-        attribID = 2;
-        nComponents = 3;
-        glEnableVertexAttribArray(attribID);
-        glVertexAttribPointer(attribID, nComponents, GL_FLOAT, GL_TRUE, nComponents*sizeof(GLfloat), (char*)0 + leftNormsMemOffset);
-
-        // attribute 3 = right normals (required)
-        attribID = 3;
-        nComponents = 3;
-        glEnableVertexAttribArray(attribID);
-        glVertexAttribPointer(attribID, nComponents, GL_FLOAT, GL_TRUE, nComponents*sizeof(GLfloat), (char*)0 + rightNormsMemOffset);
-        
-        glBindVertexArray(0);
-        
-        
-        glGenBuffers(1, &elementBuffer_);
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer_);
-        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_.size() * sizeof(unsigned int), &indices_[0], GL_STATIC_DRAW);
-        
-        
-        gpuDirty_ = false;
-    }
-}
-
-
-void EdgeMesh::Draw() {
-    if (gpuDirty_) {
-        UpdateGPUMemory();
-    }
-    
-    // set defaults to pass to shaders any for optional attribs
-    glVertexAttrib3f(1, 0.0, 0.0, 1.0);      // normal = +Z
-    glVertexAttrib3f(2, 0.0, 0.0, 1.0);      // left-normal = +Z
-    glVertexAttrib3f(3, 0.0, 0.0, 1.0);      // right-normal = +Z
-    
-    glBindVertexArray(vertexArray_);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer_);
-    glDrawElements(GL_TRIANGLES, (GLsizei)indices_.size(), GL_UNSIGNED_INT, (void*)0);
-    glBindVertexArray(0);
-}
-
-
-int EdgeMesh::num_vertices() const {
-    return (int)verts_.size()/3;
-}
-
-int EdgeMesh::num_triangles() const {
-    return (int)indices_.size()/3;
-}
diff --git a/dev/a6-harold/edge_mesh.h b/dev/a6-harold/edge_mesh.h
deleted file mode 100644
index 5120d0b..0000000
--- a/dev/a6-harold/edge_mesh.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/** CSci-4611 Assignment 5:  Art Render
- */
-
-#ifndef EDGE_MESH_H
-#define EDGE_MESH_H
-
-#include <mingfx.h>
-using namespace mingfx;
-
-#include <vector>
-
-
-/** This special kind of mesh stores two triangles that form a quadralateral
- along each edge of an existing mesh.  The quad initially has a width=0, but
- when rendered, two of the vertices are extended along the surfaces normal
- direction, which creates a "fin" that can be drawn as a thick border.  This
- can be used to create a silhouette edge renderer if the shader only extends
- the edges that lie along a silhouette of the mesh.
- */
-class EdgeMesh {
-public:
-    EdgeMesh();
-    virtual ~EdgeMesh();
-
-    /// Creates two triangles along each edge of the mesh passed in.
-    void CreateFromMesh(const Mesh &mesh);
-
-    /// Saves the mesh data to the GPU - must be called with InitOpenGL or Draw.
-    void UpdateGPUMemory();
-    
-    /// Num vertices in the edge mesh
-    int num_vertices() const;
-    
-    /// Num triangles in the edge mesh
-    int num_triangles() const;
-    
-    /// Access to vertex position by vertex number
-    Point3 vertex(int vertexID) const;
-
-    /// Access to vertex normal by vertex number
-    Vector3 normal(int vertexID) const;
-
-    /// Access to vertex color by vertex number
-    Color color(int vertexID) const;
-
-    /// Access to vertex texture coords by vertex number
-    Point2 tex_coords(int textureUnit, int vertexID) const;
-    
-
-    /// Draws the mesh assuming a shader has already been bound.
-    void Draw();
-    
-private:
-    
-    // Some routines and variables are needed internally to construct the edge
-    // mesh from a regular mesh.
-    
-    typedef std::map<std::pair<int,int>,int> EdgeMap;
-    EdgeMap edgeMap;
-
-    void addEdge(std::vector<Point3> *vertices,
-                 std::vector<Vector3> *normals,
-                 std::vector<Vector3> *leftNormals,
-                 std::vector<Vector3> *rightNormals,
-                 std::vector< std::vector<unsigned int> > *triangles,
-                 const Mesh &mesh, int v0, int v1, Vector3 n);
-
-    std::vector<float> verts_;          // vertex positions
-    std::vector<float> norms_;          // normals
-    std::vector<unsigned int> indices_; // indices
-    std::vector<float> leftNorms_;      // normals of adjacent triangles
-    std::vector<float> rightNorms_;
-
-    GLuint vertexBuffer_;
-    GLuint vertexArray_;
-    GLuint elementBuffer_;
-
-    bool gpuDirty_;
-};
-
-#endif
-
diff --git a/dev/a6-harold/ground.cc b/dev/a6-harold/ground.cc
deleted file mode 100644
index 51d4d92..0000000
--- a/dev/a6-harold/ground.cc
+++ /dev/null
@@ -1,283 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#include "ground.h"
-
-
-Ground::Ground() : diffuse_ramp_(GL_CLAMP_TO_EDGE),
-    specular_ramp_(GL_CLAMP_TO_EDGE), light_pos_(30,30,30)
-{
-    
-}
-
-Ground::~Ground() {
-    
-}
-
-Mesh* Ground::mesh_ptr() { return &ground_mesh_; }
-
-
-void Ground::Init(const std::vector<std::string> &search_path) {
-    // init ground geometry, a simple grid is used.  if it is running too slow,
-    // you can turn down the resolution by decreasing nx and ny, but this will
-    // make the hills look more jaggy.
-    const int nx = 150;
-    const int ny = 150;
-    const float size = 100.0;
-    std::vector<Point3> verts;
-    std::vector<Vector3> norms;
-    for (int j = 0; j <= ny; j++) {
-        for (int i = 0; i <= nx; i++) {
-            float x = size*(float)j/nx - size/2.0f;
-            float y = size*(float)i/ny - size/2.0f;
-            verts.push_back(Point3(x, 0, y));
-            norms.push_back(Vector3(0,1,0));
-        }
-    }
-    std::vector<unsigned int> indices;
-    for (int j = 0; j < ny; j++) {
-        for (int i = 0; i < nx; i++) {
-            // L\ triangle
-            indices.push_back((i+0)+(j+0)*(nx+1));
-            indices.push_back((i+1)+(j+0)*(nx+1));
-            indices.push_back((i+0)+(j+1)*(nx+1));
-            // \7 triangle
-            indices.push_back((i+1)+(j+0)*(nx+1));
-            indices.push_back((i+1)+(j+1)*(nx+1));
-            indices.push_back((i+0)+(j+1)*(nx+1));
-        }
-    }
-    ground_mesh_.SetIndices(indices);
-    ground_mesh_.SetVertices(verts);
-    ground_mesh_.SetNormals(norms);
-    ground_mesh_.UpdateGPUMemory();
-    ground_edge_mesh_.CreateFromMesh(ground_mesh_);
-
-    
-    // load textures and shaders
-    diffuse_ramp_.InitFromFile(Platform::FindFile("toonDiffuse.png", search_path));
-    specular_ramp_.InitFromFile(Platform::FindFile("toonSpecular.png", search_path));
-    
-    artsy_shaderprog_.AddVertexShaderFromFile(Platform::FindFile("artsy.vert", search_path));
-    artsy_shaderprog_.AddFragmentShaderFromFile(Platform::FindFile("artsy.frag", search_path));
-    artsy_shaderprog_.LinkProgram();
-    
-    outline_shaderprog_.AddVertexShaderFromFile(Platform::FindFile("outline.vert", search_path));
-    outline_shaderprog_.AddFragmentShaderFromFile(Platform::FindFile("outline.frag", search_path));
-    outline_shaderprog_.LinkProgram();
-}
-
-
-
-
-// Projects a 2D normalized screen point (e.g., the mouse position in normalized
-// device coordinates) to a 3D point on the ground.  Returns true and sets ground_point
-// to be equal to the result if the conversion is successful.  Returns false if
-// the screen point does not project onto the ground.
-bool Ground::ScreenPtHitsGround(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                              const Point2 &normalized_screen_pt, Point3 *ground_point)
-{
-    Matrix4 camera_matrix = view_matrix.Inverse();
-    Point3 eye = camera_matrix.ColumnToPoint3(3);
-    
-    Point3 pt3d = GfxMath::ScreenToNearPlane(view_matrix, proj_matrix, normalized_screen_pt);
-    Ray ray(eye, (pt3d - eye).ToUnit());
-    float i_time;
-    int i_tri;
-    return ray.FastIntersectMesh(&ground_mesh_, &i_time, ground_point, &i_tri);
-}
-
-
-
-
-/** This implements the "h" term used in the equations described in section 4.5 of the
- paper. Three arguments are needed:
- 1. projection_plane_normal: We need to know where the projection plane is in 3-space
-    Since a plane can be defined by a point within the plane and a normal, we use
-    this normal together with the 3rd argument to the function to define the projection
-    plane described in the paper.
- 2. silhouette_curve: As described in the paper, the silhouette curve is a 3D version
-    of the curve the user draws with the mouse.  It is formed by projecting the
-    original 2D screen-space curve onto the 3D projection plane.
- 3. closest_pt_in_plane: As described in the paper, this is the closest point within
-    the projection plane to the vertex of the mesh that we want to modify.  In other
-    words, it is the perpendicular projection of the vertex we want to modify onto
-    the projection plane.
- */
-float hfunc(const Vector3 projection_plane_normal, const std::vector<Point3> &silhouette_curve, const Point3 &closest_pt_in_plane) {
-    // define the y axis for a "plane space" coordinate system as a world space vector
-    Vector3 plane_y = Vector3(0,1,0);
-    // define the x axis for a "plane space" coordinate system as a world space vector
-    Vector3 plane_x = plane_y.Cross(projection_plane_normal).ToUnit();
-    // define the origin for a "plane space" coordinate system as the first point in the curve
-    Point3 origin = silhouette_curve[0];
-    
-    // loop over line segments in the curve, find the one that lies over the point by
-    // comparing the "plane space" x value for the start and end of the line segment
-    // to the "plane space" x value for the closest point to the vertex that lies
-    // in the projection plane.
-    float x_target = (closest_pt_in_plane - origin).Dot(plane_x);
-    for (int i=1; i<silhouette_curve.size(); i++) {
-        float x_start = (silhouette_curve[(size_t)i-1] - origin).Dot(plane_x);
-        float x_end = (silhouette_curve[i] - origin).Dot(plane_x);
-        if ((x_start <= x_target) && (x_target <= x_end)) {
-            float alpha = (x_target - x_start) / (x_end - x_start);
-            float y_curve = silhouette_curve[(size_t)i-1][1] + alpha*(silhouette_curve[i][1] - silhouette_curve[(size_t)i-1][1]);
-            return y_curve - closest_pt_in_plane[1];
-        }
-        else if ((x_end <= x_target) && (x_target <= x_start)) {
-            float alpha = (x_target - x_end) / (x_start - x_end);
-            float y_curve = silhouette_curve[i][1] + alpha*(silhouette_curve[(size_t)i-1][1] - silhouette_curve[i][1]);
-            return y_curve - closest_pt_in_plane[1];
-        }
-    }
-    
-    // here return 0 because the point does not lie under the curve.
-    return 0.0;
-}
-
-
-
-
-/// Modifies the vertices of the ground mesh to create a hill or valley based
-/// on the input stroke.  The 2D path of the stroke on the screen is passed
-/// in, this is the centerline of the stroke mesh that is actually drawn on
-/// the screen while the user is drawing.
-void Ground::ReshapeGround(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                           const std::vector<Point2> &stroke2d)
-{
-    // TODO: Deform the 3D ground mesh according to the algorithm described in the
-    // Cohen et al. Harold paper.
-    
-    // You might need the eye point and the look vector, these can be determined
-    // from the view matrix as follows:
-    Matrix4 camera_matrix = view_matrix.Inverse();
-    Point3 eye = camera_matrix.ColumnToPoint3(3);
-    Vector3 look = -camera_matrix.ColumnToVector3(2);
-    
-    
-    
-    // There are 3 major steps to the algorithm, outlined here:
-    
-    // 1. Define a plane to project the stroke onto.  The first and last points
-    // of the stroke are guaranteed to project onto the ground plane.  The plane
-    // should pass through these two points on the ground.  The plane should also
-    // have a normal vector that points toward the camera and is parallel to the
-    // ground plane.
-
-    
-    
-    
-    
-    // 2. Project the 2D stroke into 3D so that it lies on the "projection plane"
-    // defined in step 1.
-    
-    
-    
-    
-    
-    // 3. Loop through all of the vertices of the ground mesh, and adjust the
-    // height of each based on the equations in section 4.5 of the paper, also
-    // repeated in the assignment handout.  The equations rely upon a function
-    // h(), and we have implemented that for you as hfunc() defined above in
-    // this file.  The basic structure of the loop you will need is here:
-    std::vector<Point3> new_verts;
-    for (int i=0; i<ground_mesh_.num_vertices(); i++) {
-        Point3 P = ground_mesh_.read_vertex_data(i); // original vertex
-
-        // adjust P according to equations...
-        
-        
-        
-        
-        
-        new_verts.push_back(P);
-    }
-    ground_mesh_.SetVertices(new_verts);
-    ground_mesh_.CalcPerVertexNormals();
-    ground_mesh_.UpdateGPUMemory();
-    ground_edge_mesh_.CreateFromMesh(ground_mesh_);
-}
-
-
-
-
-/// Draws the ground mesh with toon shading
-void Ground::Draw(const Matrix4 &view_matrix, const Matrix4 &proj_matrix, const Color &ground_color) {
-    // Lighting parameters
-    Color Ia(1.0f, 1.0f, 1.0f, 1.0f);
-    Color Id(1.0f, 1.0f, 1.0f, 1.0f);
-    Color Is(1.0f, 1.0f, 1.0f, 1.0f);
-    
-    // Material parameters
-    Color ka = ground_color;
-    Color kd(0.4f, 0.4f, 0.4f, 1.0f);
-    Color ks(0.6f, 0.6f, 0.6f, 1.0f);
-    float s = 50.0f;
-    
-    // Precompute matrices needed in the shader
-    Matrix4 model_matrix; // identity
-    Matrix4 modelview_matrix = view_matrix * model_matrix;
-    Matrix4 normal_matrix = modelview_matrix.Inverse().Transpose();
-    Point3 light_in_eye_space = view_matrix * light_pos_;
-    
-    // Make sure the default option to only draw front facing triangles is set
-    glEnable(GL_CULL_FACE);
-    
-    
-    // Draw the ground using the artsy shader
-    artsy_shaderprog_.UseProgram();
-    artsy_shaderprog_.SetUniform("modelViewMatrix", modelview_matrix);
-    artsy_shaderprog_.SetUniform("normalMatrix", normal_matrix);
-    artsy_shaderprog_.SetUniform("projectionMatrix", proj_matrix);
-    artsy_shaderprog_.SetUniform("ka", ka);
-    artsy_shaderprog_.SetUniform("kd", kd);
-    artsy_shaderprog_.SetUniform("ks", ks);
-    artsy_shaderprog_.SetUniform("s", s);
-    artsy_shaderprog_.SetUniform("lightPosition", light_in_eye_space);
-    artsy_shaderprog_.SetUniform("Ia", Ia);
-    artsy_shaderprog_.SetUniform("Id", Id);
-    artsy_shaderprog_.SetUniform("Is", Is);
-    artsy_shaderprog_.BindTexture("diffuseRamp", diffuse_ramp_);
-    artsy_shaderprog_.BindTexture("specularRamp", specular_ramp_);
-    ground_mesh_.Draw();
-    artsy_shaderprog_.StopProgram();
-    
-    // And, draw silhouette edges for the ground using the outline shader
-    glDisable(GL_CULL_FACE);
-    glEnable(GL_POLYGON_OFFSET_FILL);
-    glPolygonOffset(1,1);
-    static const float thickness = 0.2f;
-    outline_shaderprog_.UseProgram();
-    outline_shaderprog_.SetUniform("modelViewMatrix", modelview_matrix);
-    outline_shaderprog_.SetUniform("normalMatrix", normal_matrix);
-    outline_shaderprog_.SetUniform("projectionMatrix", proj_matrix);
-    outline_shaderprog_.SetUniform("thickness", thickness);
-    ground_edge_mesh_.Draw();
-    outline_shaderprog_.StopProgram();
-    
-
-    
-    // This can be useful for debugging, but it is extremely slow to draw.
-    // Before uncommenting this, it's recommended to turn down the resolution
-    // of the ground mesh by adjusting the nx and ny constants inside Init().
-    /**
-     // draw lines around each triangle
-     for (int t=0; t<ground_mesh_.num_triangles(); t++) {
-         std::vector<unsigned int> indices = ground_mesh_.triangle_vertices(t);
-         std::vector<Point3> loop;
-         loop.push_back(ground_mesh_.vertex(indices[0]));
-         loop.push_back(ground_mesh_.vertex(indices[1]));
-         loop.push_back(ground_mesh_.vertex(indices[2]));
-         qs_.DrawLines(model_matrix, view_matrix, proj_matrix, Color(0.7,0.7,0.7), loop, QuickShapes::LinesType::LINE_LOOP, 0.01);
-     }
-     
-     // draw normals
-     for (int i=0; i<ground_mesh_.num_vertices(); i++) {
-         Point3 p1 = ground_mesh_.vertex(i);
-         Point3 p2 = p1 + 0.5*ground_mesh_.normal(i);
-         qs_.DrawLineSegment(model_matrix, view_matrix, proj_matrix, Color(0.7,0.7,0.7), p1, p2, 0.01);
-     }
-    **/
-}
-
diff --git a/dev/a6-harold/ground.h b/dev/a6-harold/ground.h
deleted file mode 100644
index 0cc18dd..0000000
--- a/dev/a6-harold/ground.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#ifndef GROUND_H_
-#define GROUND_H_
-
-#include <mingfx.h>
-using namespace mingfx;
-
-#include "edge_mesh.h"
-
-/** The ground is represented with a triangle mesh.  2D "screen space" strokes
- are used to modify the vertices based on user input so that the user can create
- a 3D landscape of hills and valleys.
- */
-class Ground {
-public:
-    Ground();
-    virtual ~Ground();
-    
-    /// Call from InitOpenGL() to initialize shaders, etc.
-    void Init(const std::vector<std::string> &search_path);
-    
-    /// Projects a 2D normalized screen point (e.g., the mouse position in normalized
-    /// device coordinates) to a 3D point on the ground.  Returns true and sets ground_point
-    /// to be equal to the result if the conversion is successful.  Returns false if
-    /// the screen point does not project onto the ground.
-    bool ScreenPtHitsGround(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                          const Point2 &normalized_screen_pt, Point3 *ground_point);
-
-    /// Modifies the vertices of the ground mesh to create a hill or valley based
-    /// on the input stroke.  The 2D path of the stroke on the screen is passed
-    /// in, this is the centerline of the stroke mesh that is actually drawn on
-    /// the screen while the user is drawing.
-    void ReshapeGround(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                       const std::vector<Point2> &stroke2d);
-    
-    /// Draws the ground mesh with toon shading
-    void Draw(const Matrix4 &view_matrix, const Matrix4 &proj_matrix, const Color &ground_color);
-    
-    
-    Mesh* mesh_ptr();
-    
-private:
-    
-    // This is the actual triangle mesh for the ground
-    Mesh ground_mesh_;
-    // We also maintain a corresponding "edge mesh" in order to do the
-    // silhouette outlines like in assignment 5
-    EdgeMesh ground_edge_mesh_;
-    
-    // The ground rendering is based on the artsy shader from assignment 5
-    ShaderProgram artsy_shaderprog_;
-    ShaderProgram outline_shaderprog_;
-    Texture2D diffuse_ramp_;
-    Texture2D specular_ramp_;
-    Point3 light_pos_;
-    
-    // for debugging only
-    QuickShapes qs_;
-};
-
-#endif
diff --git a/dev/a6-harold/harold_app.cc b/dev/a6-harold/harold_app.cc
deleted file mode 100644
index abf5c4d..0000000
--- a/dev/a6-harold/harold_app.cc
+++ /dev/null
@@ -1,278 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#include "harold_app.h"
-#include "config.h"
-
-#include <iostream>
-#include <sstream>
-
-
-HaroldApp::HaroldApp() : GraphicsApp(1024,768, "Harold"),
-    drawing_state_(DRAWING_NONE),
-    sky_color_(1,1,1), ground_color_(0.25, 0, 0.25), crayon_color_(0.5,0,0.5)
-{
-    // Define a search path for finding data files (images and shaders)
-    search_path_.push_back(".");
-    search_path_.push_back("./data");
-    search_path_.push_back("./shaders");
-    search_path_.push_back(DATA_DIR_INSTALL);
-    search_path_.push_back(DATA_DIR_BUILD);
-    search_path_.push_back(SHADERS_DIR_INSTALL);
-    search_path_.push_back(SHADERS_DIR_BUILD);
-}
-
-
-HaroldApp::~HaroldApp() {
-}
-
-
-void HaroldApp::InitNanoGUI() {
-    // Setup the GUI window
-    nanogui::Window *window = new nanogui::Window(screen(), "Harold's Crayons");
-    window->setPosition(Eigen::Vector2i(10, 10));
-    window->setSize(Eigen::Vector2i(200,100));
-    window->setLayout(new nanogui::GroupLayout());
-
-    new nanogui::Label(window, "Crayon Color", "sans-bold");
-    auto cp1 = new nanogui::ColorPicker(window,
-        nanogui::Color((int)(255.0*crayon_color_[0]),
-                       (int)(255.0*crayon_color_[1]),
-                       (int)(255.0*crayon_color_[2]), 255)
-    );
-    cp1->setFixedSize({100, 20});
-    cp1->setFinalCallback([this](const nanogui::Color &c) {
-        crayon_color_ = Color(c.r(), c.g(), c.b(), c.w());
-    });
-
-    new nanogui::Label(window, "Sky Color", "sans-bold");
-    auto cp2 = new nanogui::ColorPicker(window,
-        nanogui::Color((int)(255.0*sky_color_[0]),
-                       (int)(255.0*sky_color_[1]),
-                       (int)(255.0*sky_color_[2]), 255)
-    );
-    cp2->setFixedSize({100, 20});
-    cp2->setFinalCallback([this](const nanogui::Color &c) {
-        sky_color_ = Color(c.r(), c.g(), c.b(), c.w());
-    });
-
-    new nanogui::Label(window, "Ground Color", "sans-bold");
-    auto cp3 = new nanogui::ColorPicker(window,
-        nanogui::Color((int)(255.0*ground_color_[0]),
-                       (int)(255.0*ground_color_[1]),
-                       (int)(255.0*ground_color_[2]), 255)
-    );
-    cp3->setFixedSize({100, 20});
-    cp3->setFinalCallback([this](const nanogui::Color &c) {
-        ground_color_ = Color(c.r(), c.g(), c.b(), c.w());
-    });
-
-    screen()->performLayout();
-}
-
-
-void HaroldApp::InitOpenGL() {
-    // Set up the camera in a good position to see the entire field
-    cam_.set_view_matrix(Matrix4::LookAt(Point3(0,2,10), Point3(0,2,0), Vector3(0,1,0)));
-    proj_matrix_ = Matrix4::Perspective(60, aspect_ratio(), 0.1f, 1600.0f);
-    glClearColor(0.7f, 0.7f, 0.7f, 1.0f);
-    
-    stroke2d_shaderprog_.AddVertexShaderFromFile(Platform::FindFile("stroke2d.vert", search_path_));
-    stroke2d_shaderprog_.AddFragmentShaderFromFile(Platform::FindFile("stroke2d.frag", search_path_));
-    stroke2d_shaderprog_.LinkProgram();
-    
-    stroke3d_shaderprog_.AddVertexShaderFromFile(Platform::FindFile("stroke3d.vert", search_path_));
-    stroke3d_shaderprog_.AddFragmentShaderFromFile(Platform::FindFile("stroke3d.frag", search_path_));
-    stroke3d_shaderprog_.LinkProgram();
-    
-    ground_.Init(search_path_);
-    sky_.Init(&stroke3d_shaderprog_);
-    billboards_.Init(&stroke3d_shaderprog_);
-}
-
-
-
-void HaroldApp::AddToStroke(const Point2 &normalized_screen_pt) {
-    // the stroke2d_ array stores the raw 2D screen coordinates of the
-    // centerline of the stroke
-    stroke2d_.push_back(normalized_screen_pt);
-    
-    // the mesh is a triangle strip that follows the centerline
-    // we need at least 2 samples before we can create triangles
-    if (stroke2d_.size() >= 2) {
-        const float half_stroke_width = 0.01f;
-        std::vector<Point3> verts;
-        std::vector<unsigned int> indices;
-        Point3 last_pt = Point3(stroke2d_[0][0], stroke2d_[0][1], 0);
-        Point3 pt = Point3(stroke2d_[1][0], stroke2d_[1][1], 0);
-        Vector3 tangent = (pt - last_pt).ToUnit();
-        Vector3 cotangent = tangent.Cross(Vector3::UnitZ());
-        verts.push_back(last_pt - half_stroke_width*cotangent);
-        verts.push_back(last_pt + half_stroke_width*cotangent);
-        for (int i=1; i<stroke2d_.size(); i++) {
-            pt = Point3(stroke2d_[i][0], stroke2d_[i][1], 0);
-            tangent = (pt - last_pt).ToUnit();
-            cotangent = tangent.Cross(Vector3::UnitZ());
-            
-            verts.push_back(pt - half_stroke_width*cotangent);
-            verts.push_back(pt + half_stroke_width*cotangent);
-            
-            indices.push_back((int)verts.size()-4);
-            indices.push_back((int)verts.size()-3);
-            indices.push_back((int)verts.size()-2);
-
-            indices.push_back((int)verts.size()-3);
-            indices.push_back((int)verts.size()-1);
-            indices.push_back((int)verts.size()-2);
-            
-            last_pt = pt;
-        }
-        stroke2d_mesh_.SetVertices(verts);
-        stroke2d_mesh_.SetIndices(indices);
-        stroke2d_mesh_.UpdateGPUMemory();
-    }
-}
-
-
-
-// This function is called at the start of each new crayon stroke
-void HaroldApp::OnLeftMouseDown(const Point2 &mouse_in_pixels) {
-    // Add to the stroke_mesh_, which is a 2D triangle strip used to draw the user's
-    // crayon stroke on the screen.
-    Point2 mouse_in_ndc = PixelsToNormalizedDeviceCoords(mouse_in_pixels);
-    AddToStroke(mouse_in_ndc);
-    
-    
-    // Next, try to figure out what we are drawing based on where the stroke originated.
-    Point3 i_point;
-    edit_billboard_id_ = billboards_.IntersectBillboard(cam_.view_matrix(), proj_matrix_, mouse_in_ndc);
-    if (edit_billboard_id_ >= 0) {
-        // If the mouse starts on an existing billboard, then we are editing the billboard.
-        drawing_state_ = DrawingState::DRAWING_BILLBOARD_EDIT;
-    }
-    else if (ground_.ScreenPtHitsGround(cam_.view_matrix(), proj_matrix_, mouse_in_ndc, &i_point)) {
-        // If the mouse starts on the ground, then we could be about to edit the
-        // ground, OR we might be creating a new billboard.  We won't know for sure
-        // until the user releases the mouse and we can check to see whether the
-        // stroke also ends on the ground.
-        drawing_state_ = DrawingState::DRAWING_GROUND_OR_BILLBOARD;
-    }
-    else {
-        // Otherwise, we must be drawing a stroke in the sky.
-        drawing_state_ = DrawingState::DRAWING_SKY;
-    }
-}
-
-
-// This function is called once each frame while the user is drawing with the crayon
-void HaroldApp::OnLeftMouseDrag(const Point2 &mouse_in_pixels, const Vector2 &delta_in_pixels) {
-    // Add to the stroke_mesh_, which is a 2D triangle strip used to draw the user's
-    // crayon stroke on the screen.
-    Point2 mouse_in_ndc = PixelsToNormalizedDeviceCoords(mouse_in_pixels);
-    AddToStroke(mouse_in_ndc);
-}
-
-
-// This function is called at the end of each stroke
-void HaroldApp::OnLeftMouseUp(const Point2 &mouse_in_pixels) {
-    
-    // If we are in the temporary drawing_ground_or_billboard state, then we need
-    // to do a final check now to see if the stroke ended on the ground or not.
-    // If it did, then we interpret the stroke as drawing_ground.  Otherwise, we
-    // treat it as creating a new billboard.
-    if (drawing_state_ == DrawingState::DRAWING_GROUND_OR_BILLBOARD) {
-        // The stroke was started on the ground, does it also end on the ground?
-        Point2 mouse_in_ndc = PixelsToNormalizedDeviceCoords(mouse_in_pixels);
-        Point3 i_point;
-        if (ground_.ScreenPtHitsGround(cam_.view_matrix(), proj_matrix_, mouse_in_ndc, &i_point)) {
-            drawing_state_ = DrawingState::DRAWING_GROUND;
-        }
-        else {
-            drawing_state_ = DrawingState::DRAWING_BILLBOARD;
-        }
-    }
-    
-    
-    // Now, the action to take in terms of what geometry to add or modify in
-    // the scene depends entirely on the drawing state:
-    if (drawing_state_ == DrawingState::DRAWING_SKY) {
-        sky_.AddSkyStroke(cam_.view_matrix(), proj_matrix_, stroke2d_mesh_, crayon_color_);
-    }
-    else if (drawing_state_ == DrawingState::DRAWING_BILLBOARD) {
-        billboards_.AddBillboardStroke(cam_.view_matrix(), proj_matrix_, stroke2d_, stroke2d_mesh_, crayon_color_, &ground_);
-    }
-    else if (drawing_state_ == DrawingState::DRAWING_BILLBOARD_EDIT) {
-        billboards_.AddToBillboard(cam_.view_matrix(), proj_matrix_, edit_billboard_id_, stroke2d_mesh_, crayon_color_);
-    }
-    else if (drawing_state_ == DrawingState::DRAWING_GROUND) {
-        if (stroke2d_.size() < 6) {
-            std::cout << "Stroke is too short, try again." << std::endl;
-        }
-        else {
-            ground_.ReshapeGround(cam_.view_matrix(), proj_matrix_, stroke2d_);
-        }
-    }
-    
-    
-    // Done with this stroke.  Clear the 2d stroke and its mesh and reset the drawing state
-    stroke2d_.clear();
-    stroke2d_mesh_ = Mesh();
-    drawing_state_ = DrawingState::DRAWING_NONE;
-}
-
-
-// You can look around, like in minecraft, by dragging with the right mouse button.
-void HaroldApp::OnRightMouseDrag(const Point2 &mouse_in_pixels, const Vector2 &delta_in_pixels) {
-    Vector2 delta_in_ndc = PixelsToNormalizedDeviceCoords(delta_in_pixels);
-    cam_.OnMouseMove(delta_in_ndc);
-}
-
-
-void HaroldApp::UpdateSimulation(double dt)  {
-    if (drawing_state_ == DrawingState::DRAWING_NONE) {
-        // When walking around using the arrow keys we need to adjust the height
-        // of the virtual camera when we walk up a hill.  To do that, we shoot
-        // a ray straight down from the eye point to the ground, find the point
-        // of intersection on the ground, and then set the camera height to be
-        // 2.0 meters above this.
-        Ray ray(cam_.eye(), -Vector3::UnitY());
-        float i_time;
-        Point3 i_pt;
-        int i_tri;
-        if (ray.FastIntersectMesh(ground_.mesh_ptr(), &i_time, &i_pt, &i_tri)) {
-            float height = 2.0f + i_pt[1]; // 2 meters above the gound
-            cam_.UpdateHeight(height);
-        }
-        cam_.UpdateSimulation(dt, window());
-        
-        
-        // The billboards also need to be updated to face the current camera
-        billboards_.UpdateBillboardRotations(cam_.eye());
-    }
-}
-
-
-void HaroldApp::DrawUsingOpenGL() {
-    // Clear the screen using the current sky color
-    glClearColor(sky_color_[0], sky_color_[1], sky_color_[2], 1);
-    
-    // Draw the sky strokes
-    sky_.Draw(cam_.view_matrix(), proj_matrix_);
-    
-    // Draw the ground mesh
-    ground_.Draw(cam_.view_matrix(), proj_matrix_, ground_color_);
-    
-    // Draw the billboards
-    billboards_.Draw(cam_.view_matrix(), proj_matrix_);
-
-    
-    // If we are currently drawing (indicated by the stroke mesh containing >0
-    // triangles), then draw the 2D triangle strip mesh for the crayon stroke
-    if (stroke2d_mesh_.num_triangles() > 0) {
-        stroke2d_shaderprog_.UseProgram();
-        stroke2d_shaderprog_.SetUniform("strokeColor", crayon_color_);
-        stroke2d_mesh_.Draw();
-        stroke2d_shaderprog_.StopProgram();
-    }
-}
-
diff --git a/dev/a6-harold/harold_app.h b/dev/a6-harold/harold_app.h
deleted file mode 100644
index 801a49a..0000000
--- a/dev/a6-harold/harold_app.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#ifndef HAROLD_APP_H_
-#define HAROLD_APP_H_
-
-#include <mingfx.h>
-using namespace mingfx;
-
-#include "billboards.h"
-#include "edge_mesh.h"
-#include "ground.h"
-#include "sky.h"
-
-#include <string>
-#include <vector>
-
-
-/** Main application class for the Harold assignment, which is a partial
- implementation of the Cohen et al. paper.
- */
-class HaroldApp : public GraphicsApp {
-public:
-    
-    HaroldApp();
-    virtual ~HaroldApp();
-    
-    // These are used for drawing
-    void OnLeftMouseDown(const Point2 &pos);
-    void OnLeftMouseDrag(const Point2 &pos, const Vector2 &delta);
-    void OnLeftMouseUp(const Point2 &pos);
-    
-    // These are used for walking around and looking (i.e., camera movement)
-    void OnRightMouseDrag(const Point2 &pos, const Vector2 &delta);
-    void UpdateSimulation(double dt);
-    
-    // Adds the 2D point to stroke2d_, which holds the centerline of the user's
-    // drawn stroke.  Also updates stroke2d_mesh_, which is a 2D triangle strip
-    // used to actually draw the stroke on the screen.
-    void AddToStroke(const Point2 &normalized_screen_pt);
-
-    void InitNanoGUI();
-    void InitOpenGL();
-    
-    void DrawUsingOpenGL();
-    
-private:
-    
-    // user input from the mouse is interpreted differently based upon where the
-    // stroke originates and where it ends.  we can model this as a simple state
-    // machine
-    enum DrawingState {
-        // left mouse button is up, not currently drawing
-        DRAWING_NONE,
-        
-        // stroke started in the sky, currently adding a sky stroke
-        DRAWING_SKY,
-        
-        // stroke started on a billboard, currently editing that billboard
-        DRAWING_BILLBOARD_EDIT,
-
-        // temporary state for between mouse down and mouse up -- here, we know
-        // the stroke started on the ground, but not yet sure if it will end on
-        // the ground or in the sky
-        DRAWING_GROUND_OR_BILLBOARD,
- 
-        // stroke ended on the ground, currently editing the ground
-        DRAWING_GROUND,
-        
-        // stroke ended in the sky, currently creating a new billboard
-        DRAWING_BILLBOARD,
-    };
-    DrawingState drawing_state_;
-    
-    // the centerline of the stroke dragged out by the mouse on the screen
-    std::vector<Point2> stroke2d_;
-
-    // a 2d triangle strip mesh for drawing the stroke on the filmplane
-    Mesh stroke2d_mesh_;
-    
-    // The ground mesh and functionality to draw and edit the ground.
-    Ground ground_;
-    
-    // Sky strokes and functionality to add more strokes to the sky
-    Sky sky_;
-    
-    // Billboard strokes and functionality to add more billboards, including
-    // editing them by adding on to an existing billboard
-    Billboards billboards_;
-    
-    // when in the DRAWING_BILLBOARD_EDIT state, this holds the id of the
-    // billboard that is currently being edited.
-    int edit_billboard_id_;
-    
-
-    // Stroke shaders do not use any lighting, just transform vertices and then
-    // render the triangle strip for the stroke in the appropriate color. The
-    // 2D shader program is used in this class.  The 3D is created here so that
-    // there is only one copy for the whole application, but it is used both the
-    // sky and billboard classes.
-    ShaderProgram stroke2d_shaderprog_;
-    ShaderProgram stroke3d_shaderprog_;
-
-    // This implements something like the camera controls in minecraft.  You can
-    // walk around using the arrow keys or ASWZ keys.  You can also move your
-    // head to look around by dragging with the right mouse button.  Internally,
-    // the camera creates a view matrix.
-    CraftCam cam_;
-    Matrix4 proj_matrix_;
-    
-    // A list of paths to search for data files (images and shaders)
-    std::vector<std::string> search_path_;
-    
-    // Current colors set by the GUI
-    Color sky_color_;
-    Color ground_color_;
-    Color crayon_color_;
-};
-
-#endif
\ No newline at end of file
diff --git a/dev/a6-harold/main.cc b/dev/a6-harold/main.cc
deleted file mode 100644
index b672b01..0000000
--- a/dev/a6-harold/main.cc
+++ /dev/null
@@ -1,10 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#include "harold_app.h"
-
-int main(int argc, const char *argv[]) {
-    HaroldApp app;
-    app.Run();
-    return 0;
-}
diff --git a/dev/a6-harold/shaders/artsy.frag b/dev/a6-harold/shaders/artsy.frag
deleted file mode 100644
index 403009d..0000000
--- a/dev/a6-harold/shaders/artsy.frag
+++ /dev/null
@@ -1,29 +0,0 @@
-#version 330
-
-in vec3 Position;
-in vec3 Normal;
-
-out vec4 color;
-
-uniform vec3 lightPosition;
-uniform vec4 Ia, Id, Is;
-
-uniform vec4 ka, kd, ks;
-uniform float s;
-
-uniform sampler2D diffuseRamp;
-uniform sampler2D specularRamp;
-
-
-void main() {
-    vec3 l = normalize(lightPosition.xyz - Position);
-    vec3 n = normalize(Normal);
-    vec3 e = normalize(-Position);
-    vec3 h = normalize(e + l);
-    float diffuse = (dot(l,n) + 1)/2;
-    float specular = pow(max(dot(n,h),0), s);
-    color = ka*Ia
-          + kd*Id*texture(diffuseRamp, vec2(diffuse,0))
-          + ks*Is*texture(specularRamp, vec2(specular,0));
-    color.a = 1;
-}
diff --git a/dev/a6-harold/shaders/artsy.vert b/dev/a6-harold/shaders/artsy.vert
deleted file mode 100644
index cd9b998..0000000
--- a/dev/a6-harold/shaders/artsy.vert
+++ /dev/null
@@ -1,17 +0,0 @@
-#version 330
-
-uniform mat4 modelViewMatrix;
-uniform mat4 normalMatrix;
-uniform mat4 projectionMatrix;
-
-layout(location = 0) in vec3 vertex;
-layout(location = 1) in vec3 normal;
-
-out vec3 Position;
-out vec3 Normal;
-
-void main() {
-    Position = (modelViewMatrix * vec4(vertex,1)).xyz;
-    Normal = normalize((normalMatrix * vec4(normal,0)).xyz);
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(vertex,1);
-}
diff --git a/dev/a6-harold/shaders/outline.frag b/dev/a6-harold/shaders/outline.frag
deleted file mode 100644
index 096721d..0000000
--- a/dev/a6-harold/shaders/outline.frag
+++ /dev/null
@@ -1,7 +0,0 @@
-#version 330
-
-out vec4 color;
-
-void main() {
-    color = vec4(0,0,0, 1);
-}
diff --git a/dev/a6-harold/shaders/outline.vert b/dev/a6-harold/shaders/outline.vert
deleted file mode 100644
index a6073e5..0000000
--- a/dev/a6-harold/shaders/outline.vert
+++ /dev/null
@@ -1,23 +0,0 @@
-#version 330
-
-uniform mat4 modelViewMatrix;
-uniform mat4 normalMatrix;
-uniform mat4 projectionMatrix;
-uniform float thickness;
-
-layout(location = 0) in vec3 vertex;
-layout(location = 1) in vec3 normal;
-layout(location = 2) in vec3 leftNormal;
-layout(location = 3) in vec3 rightNormal;
-
-void main() {
-    vec3 p = (modelViewMatrix * vec4(vertex,1)).xyz;
-    vec3 e = -p;
-    vec3 nl = (normalMatrix * vec4(leftNormal,0)).xyz;
-    vec3 nr = (normalMatrix * vec4(rightNormal,0)).xyz;
-    vec3 v = vertex;
-    if (dot(e,nl) * dot(e,nr) < 0.0) {
-       v += thickness*normal;
-    }
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(v,1);
-}
diff --git a/dev/a6-harold/shaders/stroke2d.frag b/dev/a6-harold/shaders/stroke2d.frag
deleted file mode 100644
index 2dd7efa..0000000
--- a/dev/a6-harold/shaders/stroke2d.frag
+++ /dev/null
@@ -1,9 +0,0 @@
-#version 330
-
-uniform vec4 strokeColor;
-
-out vec4 color;
-
-void main() {
-    color = strokeColor;
-}
diff --git a/dev/a6-harold/shaders/stroke2d.vert b/dev/a6-harold/shaders/stroke2d.vert
deleted file mode 100644
index e40fdec..0000000
--- a/dev/a6-harold/shaders/stroke2d.vert
+++ /dev/null
@@ -1,7 +0,0 @@
-#version 330
-
-layout(location = 0) in vec3 vertex;
-
-void main() {
-    gl_Position = vec4(vertex,1);
-}
diff --git a/dev/a6-harold/shaders/stroke3d.frag b/dev/a6-harold/shaders/stroke3d.frag
deleted file mode 100644
index 2dd7efa..0000000
--- a/dev/a6-harold/shaders/stroke3d.frag
+++ /dev/null
@@ -1,9 +0,0 @@
-#version 330
-
-uniform vec4 strokeColor;
-
-out vec4 color;
-
-void main() {
-    color = strokeColor;
-}
diff --git a/dev/a6-harold/shaders/stroke3d.vert b/dev/a6-harold/shaders/stroke3d.vert
deleted file mode 100644
index d333c4f..0000000
--- a/dev/a6-harold/shaders/stroke3d.vert
+++ /dev/null
@@ -1,10 +0,0 @@
-#version 330
-
-uniform mat4 modelViewMatrix;
-uniform mat4 projectionMatrix;
-
-layout(location = 0) in vec3 vertex;
-
-void main() {
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(vertex,1);
-}
diff --git a/dev/a6-harold/sky.cc b/dev/a6-harold/sky.cc
deleted file mode 100644
index 0819ebe..0000000
--- a/dev/a6-harold/sky.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#include "sky.h"
-
-
-Sky::Sky() {
-    
-}
-
-
-Sky::~Sky() {
-    
-}
-
-void Sky::Init(ShaderProgram *stroke3d_shaderprog) {
-    stroke3d_shaderprog_ = stroke3d_shaderprog;
-}
-
-
-/// Projects a 2D normalized screen point (e.g., the mouse position in normalized
-/// device coordinates) to a 3D point on the "sky", which is really a huge sphere
-/// (radius = 1500) that the viewer is inside.  This function should always return
-/// true since any screen point can successfully be projected onto the sphere.
-/// sky_point is set to the resulting 3D point.  Note, this function only checks
-/// to see if the ray passing through the screen point intersects the sphere; it
-/// does not check to see if the ray hits the ground or anything else first.
-bool Sky::ScreenPtHitsSky(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                        const Point2 &normalized_screen_pt, Point3 *sky_point)
-{
-    // TODO: Stitch together your worksheet implementation of this method
-    return true;
-}
-
-
-
-
-/// Creates a new sky stroke mesh by projecting each vertex of the 2D mesh
-/// onto the sky dome and saving the result as a new 3D mesh.
-void Sky::AddSkyStroke(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                       const Mesh &stroke2d_mesh, const Color &stroke_color)
-{
-    // TODO: Create a new SkyStroke and add it to the strokes_ array.
-
-
-
-
-
-
-
-
-
-
-}
-
-
-/// Draws all of the sky strokes
-void Sky::Draw(const Matrix4 &view_matrix, const Matrix4 &proj_matrix) {
-
-    // Precompute matrices needed in the shader
-    Matrix4 model_matrix; // identity
-    Matrix4 modelview_matrix = view_matrix * model_matrix;
-    
-    // Draw sky meshes
-    stroke3d_shaderprog_->UseProgram();
-    stroke3d_shaderprog_->SetUniform("modelViewMatrix", modelview_matrix);
-    stroke3d_shaderprog_->SetUniform("projectionMatrix", proj_matrix);
-    for (int i=0; i<strokes_.size(); i++) {
-        stroke3d_shaderprog_->SetUniform("strokeColor", strokes_[i].color);
-        strokes_[i].mesh.Draw();
-    }
-    stroke3d_shaderprog_->StopProgram();
-}
-
diff --git a/dev/a6-harold/sky.h b/dev/a6-harold/sky.h
deleted file mode 100644
index 06fcca1..0000000
--- a/dev/a6-harold/sky.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/** CSci-4611 Assignment 6: Harold
- */
-
-#ifndef SKY_H_
-#define SKY_H_
-
-#include <mingfx.h>
-using namespace mingfx;
-
-/** Creates, holds, and draws all of the strokes on the sky.
- */
-class Sky {
-public:
-    Sky();
-    virtual ~Sky();
-    
-    void Init(ShaderProgram *stroke3d_shaderprog);
-    
-    /// Projects a 2D normalized screen point (e.g., the mouse position in normalized
-    /// device coordinates) to a 3D point on the "sky", which is really a huge sphere
-    /// (radius = 1500) that the viewer is inside.  This function should always return
-    /// true since any screen point can successfully be projected onto the sphere.
-    /// sky_point is set to the resulting 3D point.  Note, this function only checks
-    /// to see if the ray passing through the screen point intersects the sphere; it
-    /// does not check to see if the ray hits the ground or anything else first.
-    bool ScreenPtHitsSky(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                       const Point2 &normalized_screen_pt, Point3 *sky_point);
-
-    /// Creates a new sky stroke mesh by projecting each vertex of the 2D mesh
-    /// onto the sky dome and saving the result as a new 3D mesh.
-    void AddSkyStroke(const Matrix4 &view_matrix, const Matrix4 &proj_matrix,
-                      const Mesh &stroke2d_mesh, const Color &stroke_color);
-    
-    /// Draws all of the sky strokes
-    void Draw(const Matrix4 &view_matrix, const Matrix4 &proj_matrix);
-    
-private:
-
-    // Each stroke has a 3D mesh and a color
-    struct SkyStroke {
-        Mesh mesh;
-        Color color;
-    };
-    
-    // To store a new stroke to draw, add it to this array
-    std::vector<SkyStroke> strokes_;
-
-    
-    ShaderProgram *stroke3d_shaderprog_;
-};
-
-#endif