diff options
Diffstat (limited to 'dev')
29 files changed, 2011 insertions, 0 deletions
diff --git a/dev/a6-harold/.gitignore b/dev/a6-harold/.gitignore new file mode 100644 index 0000000..dd1a9a8 --- /dev/null +++ b/dev/a6-harold/.gitignore @@ -0,0 +1,2 @@ +config.h +build diff --git a/dev/a6-harold/CMakeLists.txt b/dev/a6-harold/CMakeLists.txt new file mode 100644 index 0000000..83ca82d --- /dev/null +++ b/dev/a6-harold/CMakeLists.txt @@ -0,0 +1,209 @@ +# 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 new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/dev/a6-harold/README.md diff --git a/dev/a6-harold/billboards.cc b/dev/a6-harold/billboards.cc new file mode 100644 index 0000000..5ec508a --- /dev/null +++ b/dev/a6-harold/billboards.cc @@ -0,0 +1,206 @@ +/** 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 ¤t_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 new file mode 100644 index 0000000..7de2799 --- /dev/null +++ b/dev/a6-harold/billboards.h @@ -0,0 +1,78 @@ +/** 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 ¤t_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 new file mode 100644 index 0000000..fb29bff --- /dev/null +++ b/dev/a6-harold/cmake/DownloadHelper.txt.in @@ -0,0 +1,26 @@ +# 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 new file mode 100644 index 0000000..ce12d1d --- /dev/null +++ b/dev/a6-harold/cmake/ExternalProjectDownloadBuildInstall.cmake @@ -0,0 +1,98 @@ +# 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 new file mode 100644 index 0000000..4628e5c --- /dev/null +++ b/dev/a6-harold/cmake/MessageMacros.cmake @@ -0,0 +1,17 @@ +# 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 new file mode 100644 index 0000000..2ec5ffb --- /dev/null +++ b/dev/a6-harold/cmake/UseOpenGL.cmake @@ -0,0 +1,52 @@ +# 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 new file mode 100644 index 0000000..9798f4c --- /dev/null +++ b/dev/a6-harold/config.h.in @@ -0,0 +1,15 @@ +/** 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 Binary files differnew file mode 100644 index 0000000..d2e40d9 --- /dev/null +++ b/dev/a6-harold/data/toonDiffuse.png diff --git a/dev/a6-harold/data/toonSpecular.png b/dev/a6-harold/data/toonSpecular.png Binary files differnew file mode 100644 index 0000000..c13a32f --- /dev/null +++ b/dev/a6-harold/data/toonSpecular.png diff --git a/dev/a6-harold/edge_mesh.cc b/dev/a6-harold/edge_mesh.cc new file mode 100644 index 0000000..1abe2e0 --- /dev/null +++ b/dev/a6-harold/edge_mesh.cc @@ -0,0 +1,235 @@ +/** 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 new file mode 100644 index 0000000..5120d0b --- /dev/null +++ b/dev/a6-harold/edge_mesh.h @@ -0,0 +1,82 @@ +/** 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 new file mode 100644 index 0000000..51d4d92 --- /dev/null +++ b/dev/a6-harold/ground.cc @@ -0,0 +1,283 @@ +/** 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 new file mode 100644 index 0000000..0cc18dd --- /dev/null +++ b/dev/a6-harold/ground.h @@ -0,0 +1,63 @@ +/** 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 new file mode 100644 index 0000000..abf5c4d --- /dev/null +++ b/dev/a6-harold/harold_app.cc @@ -0,0 +1,278 @@ +/** 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 new file mode 100644 index 0000000..801a49a --- /dev/null +++ b/dev/a6-harold/harold_app.h @@ -0,0 +1,120 @@ +/** 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 new file mode 100644 index 0000000..b672b01 --- /dev/null +++ b/dev/a6-harold/main.cc @@ -0,0 +1,10 @@ +/** 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 new file mode 100644 index 0000000..403009d --- /dev/null +++ b/dev/a6-harold/shaders/artsy.frag @@ -0,0 +1,29 @@ +#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 new file mode 100644 index 0000000..cd9b998 --- /dev/null +++ b/dev/a6-harold/shaders/artsy.vert @@ -0,0 +1,17 @@ +#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 new file mode 100644 index 0000000..096721d --- /dev/null +++ b/dev/a6-harold/shaders/outline.frag @@ -0,0 +1,7 @@ +#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 new file mode 100644 index 0000000..a6073e5 --- /dev/null +++ b/dev/a6-harold/shaders/outline.vert @@ -0,0 +1,23 @@ +#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 new file mode 100644 index 0000000..2dd7efa --- /dev/null +++ b/dev/a6-harold/shaders/stroke2d.frag @@ -0,0 +1,9 @@ +#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 new file mode 100644 index 0000000..e40fdec --- /dev/null +++ b/dev/a6-harold/shaders/stroke2d.vert @@ -0,0 +1,7 @@ +#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 new file mode 100644 index 0000000..2dd7efa --- /dev/null +++ b/dev/a6-harold/shaders/stroke3d.frag @@ -0,0 +1,9 @@ +#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 new file mode 100644 index 0000000..d333c4f --- /dev/null +++ b/dev/a6-harold/shaders/stroke3d.vert @@ -0,0 +1,10 @@ +#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 new file mode 100644 index 0000000..0819ebe --- /dev/null +++ b/dev/a6-harold/sky.cc @@ -0,0 +1,74 @@ +/** 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 new file mode 100644 index 0000000..06fcca1 --- /dev/null +++ b/dev/a6-harold/sky.h @@ -0,0 +1,52 @@ +/** 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 |
