Complete prototype

.gitignore

@@ -21,3 +21,8 @@ dist/freetype-test*
 scenes/show-meshes*
 scenes/show-scene*
 *.blend[0-9]
+CMakeLists.txt
+cmake-build-debug/
+.idea/
+.vscode/
+.DS_STORE

ECS/Component.cpp

@@ -0,0 +1 @@
+#include "Component.hpp"

ECS/Component.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <cstdlib>
+#include <unordered_map>
+
+template<typename T>
+struct Component {
+    static std::unordered_map<uint32_t, T> &get_map() {
+        static std::unordered_map<uint32_t, T> map;
+        return map;
+    };
+};

ECS/Components/EventHandler.cpp

@@ -0,0 +1,9 @@
+#include <functional>
+#include "EventHandler.hpp"
+
+EventHandler::EventHandler(const std::function<bool(const SDL_Event &, const glm::uvec2 &)> &f)
+        : handler(f) {}
+
+bool EventHandler::handle_event(const SDL_Event &evt, const glm::uvec2 &move) {
+    return handler(evt, move);
+}

ECS/Components/EventHandler.hpp

@@ -0,0 +1,23 @@
+/*
+ * Created by Nellie Tonev on 10/27/23.
+ * Author(s): Nellie Tonev, Russell Emerine
+ *
+ * Component that corresponds to PlayMode::handle_event
+ */
+#pragma once
+
+#include <cstdlib>
+#include <unordered_map>
+
+#include <SDL.h>
+#include <glm/glm.hpp>
+#include "../Component.hpp"
+
+struct EventHandler : Component<EventHandler> {
+    explicit EventHandler(const std::function<bool(SDL_Event const &, glm::uvec2 const &)> &f);
+
+    bool handle_event(SDL_Event const &evt, glm::uvec2 const &window_size);
+
+private:
+    const std::function<bool(SDL_Event const &, glm::uvec2 const &)> &handler;
+};

ECS/Entity.cpp

@@ -0,0 +1,21 @@
+/*
+ * Created by Matei Budiu on 10/26/23.
+ * Author(s): Nellie Tonev
+ *
+ * Adapted from Entity code covered in class on 10/24/23.
+ */
+
+#include "Entity.hpp"
+
+Entity::Entity() {
+    /* create unique id for entity lookup */
+    static uint32_t unique_id = 0;
+    id = unique_id;
+    unique_id++;
+}
+
+Entity::~Entity() {
+    for (auto &[_, f]: to_delete) {
+        f();
+    }
+}

ECS/Entity.hpp

@@ -0,0 +1,73 @@
+/*
+ * Created by Matei Budiu on 10/26/23.
+ * Author(s): Matei Budiu, Russell Emerine, Nellie Tonev
+ */
+#pragma once
+
+#include <cstdlib>
+#include <unordered_map>
+#include <typeindex>
+#include <iostream>
+#include <functional>
+
+struct Entity {
+    Entity();
+
+    /*
+     * Destruct the entity by removing all components that haven't yet been removed
+     */
+    ~Entity();
+
+    /*
+     * Unique identity for querying and deleting entities, generated uniquely in the constructor
+     */
+    uint32_t id;
+
+    /*
+     * Associate a component with this entity, update map of entities with component T
+     */
+    template<typename T, typename... Args>
+    T &add_component(Args &&... args) {
+        to_delete[std::type_index(typeid(T))] = [this]() {
+            // I don't just call remove_component because that invalidates the iterator in ~Entity
+            std::unordered_map<uint32_t, T> &entity_to_component = T::get_map();
+            entity_to_component.erase(id);
+        };
+
+        std::unordered_map<uint32_t, T> &entity_to_component = T::get_map();
+        // this call to emplace looks weird but I'm pretty sure it's correct
+        return entity_to_component.emplace(
+                std::piecewise_construct,
+                std::forward_as_tuple(id),
+                std::forward_as_tuple(args...)
+        ).first->second;
+    }
+
+    /*
+     * Look up a component associated with this entity
+     */
+    template<typename T>
+    T *get_component() {
+        std::unordered_map<uint32_t, T> &entity_to_component = T::get_map();
+        auto f = entity_to_component.find(id);
+        if (f == entity_to_component.end()) return nullptr;
+        else return &f->second;
+    }
+
+    /*
+     * Remove a component associated with this entity (if the entity has the component)
+     */
+    template<typename T>
+    void remove_component() {
+        to_delete.erase(std::type_index(typeid(T)));
+
+        std::unordered_map<uint32_t, T> &entity_to_component = T::get_map();
+        entity_to_component.erase(id);
+    }
+
+private:
+    /*
+     * Keep track of what components to delete upon destruction
+     */
+    std::unordered_map<std::type_index, std::function<void()>> to_delete;
+};

ECS/README.md

@@ -0,0 +1,17 @@
+# ECS Documentation
+## **Entity**
+A container of components corresponding to objects and elements of the game. 
+Classes for game objects (e.g., Player) should include a function to create an entity
+representing the data that the main game loop needs.
+
+## **Components**
+Define a new component type for any functionality that is shared between game objects 
+of different classes. Keep track of component definitions and 
+any implementation notes below.
+
+### EventHandler
+Add to any entities that handle user inputs (e.g., Player and Terminal). 
+After attaching the EventHandler component, make sure to update its handle_event() function appropriately.
+Edit the main loop to check if the event is handled across any of the entities with this component.
+
+## **Systems**

LitColorTextureProgram.cpp

@@ -14,6 +14,7 @@ Load< LitColorTextureProgram > lit_color_texture_program(LoadTagEarly, []() -> L
 	lit_color_texture_program_pipeline.OBJECT_TO_CLIP_mat4 = ret->OBJECT_TO_CLIP_mat4;
 	lit_color_texture_program_pipeline.OBJECT_TO_LIGHT_mat4x3 = ret->OBJECT_TO_LIGHT_mat4x3;
 	lit_color_texture_program_pipeline.NORMAL_TO_LIGHT_mat3 = ret->NORMAL_TO_LIGHT_mat3;
+	lit_color_texture_program_pipeline.draw_frame = ret->draw_frame;
 
 	/* This will be used later if/when we build a light loop into the Scene:
 	lit_color_texture_program_pipeline.LIGHT_TYPE_int = ret->LIGHT_TYPE_int;
@@ -80,6 +81,7 @@ LitColorTextureProgram::LitColorTextureProgram() {
 		"in vec4 color;\n"
 		"in vec2 texCoord;\n"
 		"out vec4 fragColor;\n"
+		"uniform bool wireframe;\n"
 		"void main() {\n"
 		"	vec3 n = normalize(normal);\n"
 		"	vec3 e;\n"
@@ -103,7 +105,12 @@ LitColorTextureProgram::LitColorTextureProgram() {
 		"		e = max(0.0, dot(n,-LIGHT_DIRECTION)) * LIGHT_ENERGY;\n"
 		"	}\n"
 		"	vec4 albedo = texture(TEX, texCoord) * color;\n"
-		"	fragColor = vec4(e*albedo.rgb, albedo.a);\n"
+		"   if(wireframe){\n"
+		"   	fragColor = vec4(0.0,0.0,0.0,1.0);\n"
+		"	}\n"
+		"	else{\n"
+		"		fragColor = vec4(e*albedo.rgb, 1.0);\n"
+		"	}\n"
 		"}\n"
 	);
 	//As you can see above, adjacent strings in C/C++ are concatenated.
@@ -126,6 +133,8 @@ LitColorTextureProgram::LitColorTextureProgram() {
 	LIGHT_ENERGY_vec3 = glGetUniformLocation(program, "LIGHT_ENERGY");
 	LIGHT_CUTOFF_float = glGetUniformLocation(program, "LIGHT_CUTOFF");
 
+	draw_frame = glGetUniformLocation(program,"wireframe");
+
 
 	GLuint TEX_sampler2D = glGetUniformLocation(program, "TEX");
 

LitColorTextureProgram.hpp

@@ -28,6 +28,9 @@ struct LitColorTextureProgram {
 	GLuint LIGHT_DIRECTION_vec3 = -1U;
 	GLuint LIGHT_ENERGY_vec3 = -1U;
 	GLuint LIGHT_CUTOFF_float = -1U;
+
+	//Wireframe drawing
+	GLuint draw_frame = -1U;
 
 	//Textures:
 	//TEXTURE0 - texture that is accessed by TexCoord