work on object system

src/include/utils/Objects/Body.h

@@ -0,0 +1,30 @@
+#ifndef BODY_H
+#define BODY_H
+
+#include "pch.hpp"
+
+#include "extratools.h"
+
+#include "Object.h"
+
+namespace Archimedes {
+
+    class Body : public Object {
+    
+        public:
+            Body(RenderTarget rt, glm::mat4 t = glm::mat4(1.0f)) : mesh(rt), Object(t) {};
+
+            Body(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s, glm::mat4 t = glm::mat4(1.0f)) 
+                : mesh(vb, ia, vl, s), Object(t) {}
+
+            Body() {}
+
+            ~Body() {};
+        
+        private:
+
+            RenderTarget mesh;
+    };
+}
+
+#endif

src/include/utils/Objects/Camera.h

@@ -0,0 +1,25 @@
+#ifndef CAMERA_H
+#define CAMERA_H
+
+#include "pch.hpp"
+
+#include "extratools.h"
+
+#include "Object.h"
+
+namespace Archimedes {
+
+    class Camera : public Object {
+    
+        public:
+            Camera() {}
+
+            Camera(glm::mat4 t) 
+                : Object(t) {}
+
+            ~Camera() {};
+        
+    };
+}
+
+#endif

src/include/utils/Objects/Object.h

@@ -12,24 +12,25 @@ namespace Archimedes {
     class Object {
     
         public:
-            Object(RenderTarget rt) : mesh(rt) {};
 
-            Object(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s, glm::mat4 t) 
+            Object() {};
-                : mesh(vb, ia, vl, s), worldTransform(t) {}
 
-            Object() {}
+            Object(glm::mat4 t) 
+                : worldTransform(t) {}
 
             ~Object() {};
 
             ///scales an object absolutely
-            void scaleTo() {}
+            //void scaleTo() {}
-            void scaleRel() {}
+            void scaleRel(float scale) { worldTransform = glm::scale(worldTransform, glm::vec3(scale)); }
 
-            void moveTo() {}
+            //void moveTo(glm::vec3 pos) { worldTransform = glm::translate(worldTransform, pos); }
-            void moveRel() {}
+            void moveRel(glm::vec3 pos) { worldTransform = glm::translate(worldTransform, pos); }
 
-            void rotateTo() {}
+            //void rotateTo() {}
-            void rotateRel() {}
+            void rotateRel(float radians, glm::vec3 axis) { worldTransform = glm::rotate(worldTransform, radians, axis); }
+
+            const glm::mat4& getTransform() { return worldTransform; }
         
         private:
 
@@ -38,8 +39,6 @@ namespace Archimedes {
 
             glm::mat4 worldTransform = glm::mat4(1.0f);
 
-            RenderTarget mesh;
-            
     };
 }
 

src/include/utils/Renderer/Renderer.h

@@ -16,6 +16,8 @@ namespace Archimedes {
             enum class RenderMode {
                 Triangles,
                 Lines,
+                ConnectedLines,
+                ConnectedLinesLooped,
                 Points
             };
 
@@ -42,9 +44,13 @@ namespace Archimedes {
                     Shader& s
             ) = 0;
 
-            virtual void useRenderTarget(RenderTarget& rt) = 0;
+            virtual void setupRenderTarget(RenderTarget& rt) = 0;
             
-            virtual void draw(const RenderTarget& rt, RenderMode mode = RenderMode::Triangles) = 0;
+            virtual void updateRenderTarget(RenderTarget& rt) = 0;
+            
+            virtual void freeRenderTarget(RenderTarget& rt) = 0;
+            
+            virtual void draw(const RenderTarget& rt, glm::vec4 color = { 1.0f, 0.0f, 1.0f, 1.0f }, RenderMode mode = RenderMode::Triangles) = 0;
 
             virtual Renderer* getRendererImpl() = 0;
 

src/include/utils/Renderer/RendererImpl/RendererOpenGL/RendererOpenGL.h

@@ -173,28 +173,29 @@ namespace Archimedes {
                 return rt;
             };
 
-
+            void setupRenderTarget(RenderTarget& rt) override {
-            void useRenderTarget(RenderTarget& rt) override {
                
                 glGenVertexArrays(1, &rt.vertexArray.id);
 
                 glGenBuffers(1, &rt.vertexBuffer.id);
 
+                glGenBuffers(1, &rt.indexArray.id);
+                
+                updateRenderTarget(rt);
+            };
+
+            void updateRenderTarget(RenderTarget& rt) override {
+               
                 glBindVertexArray(rt.vertexArray.id);
 
                 glBindBuffer(GL_ARRAY_BUFFER, rt.vertexBuffer.id);
                 glBufferData(GL_ARRAY_BUFFER, rt.vertexBuffer.getSize(), rt.vertexBuffer.getData(), GL_STATIC_DRAW);
 
-
-                glGenBuffers(1, &rt.indexArray.id);
-
                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.id);
                 glBufferData(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.getCount() * sizeof(unsigned int), rt.indexArray.getIndicies(), GL_STATIC_DRAW);
 
-
                 glUseProgram(rt.shader.id);
                 
-                
                 glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
                 glEnableVertexAttribArray(0);
 
@@ -203,7 +204,14 @@ namespace Archimedes {
 
             };
 
-            void draw(const RenderTarget& rt, RenderMode mode) override {
+            void freeRenderTarget(RenderTarget& rt) override {
+               
+                glDeleteVertexArrays(1, &rt.vertexArray.id);
+                glDeleteBuffers(1, &rt.vertexBuffer.id);
+                glDeleteBuffers(1, &rt.indexArray.id);
+            };
+
+            void draw(const RenderTarget& rt, glm::vec4 color = { 1.0f, 0.0f, 1.0f, 1.0f }, RenderMode mode = RenderMode::Triangles) override {
                 
                 glUseProgram(rt.shader.id);
 
@@ -214,18 +222,27 @@ namespace Archimedes {
                 unsigned int resLoc = glGetUniformLocation(rt.shader.id, "res");
                 glUniform2ui(resLoc, w, h);
 
-                unsigned int ccLoc = glGetUniformLocation(rt.shader.id, "clearColor");
+                unsigned int colorLoc = glGetUniformLocation(rt.shader.id, "color");
-                glUniform4f(ccLoc, clearColor.r, clearColor.g, clearColor.b, clearColor.a);
+                glUniform4f(colorLoc, color.r, color.g, color.b, color.a);
 
                 glBindVertexArray(rt.vertexArray.id);
 
                 switch(mode) {
                     case RenderMode::Triangles:
                         glDrawElements(GL_TRIANGLES, rt.indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
+                        break;
                     case RenderMode::Lines:
                         glDrawElements(GL_LINES, rt.indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
+                        break;
+                    case RenderMode::ConnectedLines:
+                        glDrawElements(GL_LINE_STRIP, rt.indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
+                        break;
+                    case RenderMode::ConnectedLinesLooped:
+                        glDrawElements(GL_LINE_LOOP, rt.indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
+                        break;
                     case RenderMode::Points:
                         glDrawElements(GL_POINTS, rt.indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
+                        break;
                     default:
                         break;
                 }

src/modules/Archimedes-Modules/Sandbox/Sandbox.cpp

@@ -51,19 +51,6 @@ void Sandbox::onLoad() {
     
     window->getRenderer()->clearColor = { 0.2, 0.2, 0.4, 0.7 };
 
-    gridShader = Archimedes::Shader(cubeVS, gridFS, Archimedes::Shader::LoadType::FromSource);
-
-    window->getRenderer()->useShader(gridShader);
-
-    grid = Archimedes::RenderTarget(
-        Archimedes::VertexBuffer(gridVertices, 12 * sizeof(float)),
-        Archimedes::IndexArray(gridIndices, 6),
-        Archimedes::VertexLayout(), 
-        gridShader
-    );
-
-    window->getRenderer()->useRenderTarget(grid);
-
 
     cubeShader = Archimedes::Shader(cubeVS, cubeFS, Archimedes::Shader::LoadType::FromSource);
 
@@ -76,7 +63,17 @@ void Sandbox::onLoad() {
         cubeShader
     );
 
-    window->getRenderer()->useRenderTarget(cube);
+    window->getRenderer()->setupRenderTarget(cube);
+    
+    grid = Archimedes::RenderTarget(
+        Archimedes::VertexBuffer(gridVertices, 12 * sizeof(float)),
+        Archimedes::IndexArray(gridIndices, 6),
+        Archimedes::VertexLayout(), 
+        cubeShader
+    );
+
+    window->getRenderer()->setupRenderTarget(grid);
+
 
     int w, h;
     window->getSize(w, h);
@@ -90,18 +87,12 @@ void Sandbox::run() {
 
     static glm::vec3 pos(0), rot(0);
 
+    static glm::vec4 color = { 0.4f, 0.0f, 0.3f, 1.0f };
+    
     static glm::vec3 camPos(0.0f, 0.0f, 3.0f), camRot(0.0f, glm::pi<float>(), 0.0f);
 
     static glm::mat4 orthoCamera, perspCamera, cameraTransform;
 
-    std::vector<glm::vec3> otf = {
-        glm::vec3(0.5f, 0.5f, 0.0f),
-        glm::vec3(-0.5f, -0.5f, 0.0f),
-        
-        glm::vec3(-0.5f, 0.5f, 0.0f),
-        glm::vec3(0.5f, -0.5f, 0.0f)
-    };
-
 /*
     cameraTransform = glm::mat4(1.0f);
     cameraTransform = glm::translate(cameraTransform, camPos);
@@ -159,7 +150,7 @@ void Sandbox::run() {
 
 
     //window->getRenderer()->draw(grid);
-    window->getRenderer()->draw(cube);
+    window->getRenderer()->draw(cube, color, Archimedes::Renderer::RenderMode::Triangles);
 
 
     {
@@ -187,6 +178,11 @@ void Sandbox::run() {
         ImGui::SliderFloat("y", &pos.y, -10.0f, 10.0f);
         ImGui::SliderFloat("z", &pos.z, -10.0f, 10.0f);
 
+        ImGui::SliderFloat("cube r", &color.r, 0.0f, 1.0f);
+        ImGui::SliderFloat("cube g", &color.g, 0.0f, 1.0f);
+        ImGui::SliderFloat("cube b", &color.b, 0.0f, 1.0f);
+        ImGui::SliderFloat("cube a", &color.a, 0.0f, 1.0f);
+
         ImGui::Text("Camera Properties");
     
         ImGui::SliderFloat("c_pitch", &camRot.x, -glm::pi<float>(), glm::pi<float>());
@@ -210,5 +206,28 @@ void Sandbox::run() {
 }
 
 bool Sandbox::onEvent(const Archimedes::Event& e) {
+
+    unsigned int type = app->getEventType(e);
+
+
+    if(type == app->getEventType(Archimedes::KeyPressedWindowEvent())) {
+
+        return false;
+    } else if(type == app->getEventType(Archimedes::KeyReleasedWindowEvent())) {
+
+        return false;
+    } else if(type == app->getEventType(Archimedes::MouseButtonPressedWindowEvent())) {
+
+        return false;
+    } else if(type == app->getEventType(Archimedes::MouseButtonReleasedWindowEvent())) {
+
+        return false;
+    } else if(type == app->getEventType(Archimedes::ScrollWindowEvent())) {
+
+        return false;
+    } else if(type == app->getEventType(Archimedes::MouseMovedWindowEvent())) {
+
+        return false;
+    }
     return false;
 }

src/modules/Archimedes-Modules/Sandbox/Sandbox.h

@@ -29,46 +29,22 @@ class Sandbox : public Archimedes::Module {
             "layout (location = 0) in vec3 aPos;\n"
             "uniform mat4 model;\n"
             "uniform uvec2 res;\n"
-            "uniform vec4 clearColor;\n"
+            "uniform vec4 color;\n"
             "void main()\n"
             "{\n"
             "   gl_Position = model * vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
             "}\0";
+        
         std::string cubeFS = "#version 330 core\n"
             "out vec4 FragColor;\n"
             "uniform mat4 model;\n"
             "uniform uvec2 res;\n"
-            "uniform vec4 clearColor;\n"
+            "uniform vec4 color;\n"
             "void main()\n"
             "{\n"
-            "   FragColor = vec4(0.6f, 0.1f, 0.1f, 1.0f);\n"
+            "   FragColor = color;\n"
             "}\n\0";
 
-        std::string gridFS = "#version 330 core\n"
-            "out vec4 FragColor;\n"
-            "uniform mat4 model;\n"
-            "uniform uvec2 res;\n"
-            "uniform vec4 clearColor;\n"
-            "vec2 pos = gl_FragCoord.xy - res / 2.0f;\n"
-            "int gridSpacing = 50;"
-            "void main()\n"
-            "{\n"
-            "   switch((int(pos.x)) * (int(pos.y))) {\n"
-            "       case 0:\n"
-            "           FragColor = vec4(1.0f);\n"
-            "           break;\n"
-            "       default:\n"
-            "           switch((int(pos.x) % gridSpacing) * (int(pos.y) % gridSpacing)) {\n"
-            "               case 0:\n"
-            "                   FragColor = vec4(0.7f, 0.7f, 0.7f, 1.0f);\n"
-            "                   break;\n"
-            "               default:\n"
-            "                   discard;\n"
-            "                   break;\n"
-            "           }\n"
-            "           break;\n"
-            "   }\n"
-            "}\n\0";
 
         Archimedes::Shader cubeShader, gridShader;
         Archimedes::RenderTarget cube, grid;

src/modules/ImguiModule/ImguiModule.cpp

@@ -112,5 +112,29 @@ void ImguiModule::run() {
 
 bool ImguiModule::onEvent(const Archimedes::Event &e) {
 
+    unsigned int type = app->getEventType(e);
+
+    ImGuiIO& io = ImGui::GetIO(); (void)io;
+
+    if(type == app->getEventType(Archimedes::KeyPressedWindowEvent())) {
+
+        return io.WantCaptureKeyboard;
+    } else if(type == app->getEventType(Archimedes::KeyReleasedWindowEvent())) {
+
+        return io.WantCaptureKeyboard;
+    } else if(type == app->getEventType(Archimedes::MouseButtonPressedWindowEvent())) {
+
+        return io.WantCaptureMouse;
+    } else if(type == app->getEventType(Archimedes::MouseButtonReleasedWindowEvent())) {
+
+        return io.WantCaptureMouse;
+    } else if(type == app->getEventType(Archimedes::ScrollWindowEvent())) {
+
+        return io.WantCaptureMouse;
+    } else if(type == app->getEventType(Archimedes::MouseMovedWindowEvent())) {
+
+        return io.WantCaptureMouse;
+    }
+
     return false;
 }