feat: initialize all vars in shaders

.vscode/settings.json

@@ -61,6 +61,14 @@
         "typeindex": "cpp",
         "ranges": "cpp",
         "list": "cpp",
-        "unordered_set": "cpp"
+        "unordered_set": "cpp",
+        "bitset": "cpp",
+        "condition_variable": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "regex": "cpp",
+        "semaphore": "cpp",
+        "shared_mutex": "cpp",
+        "stop_token": "cpp"
     }
 }

CMakeLists.txt

@@ -31,6 +31,7 @@ elseif (MSVC) # vcpkg
   find_package(OpenGL REQUIRED)
   find_package(GLEW CONFIG REQUIRED)
   find_package(glm CONFIG REQUIRED)
+  find_package(EnTT CONFIG REQUIRED)
 endif()
 
 add_executable(CodingGame
@@ -39,8 +40,9 @@ add_executable(CodingGame
 
   src/window/window.cpp
 
+  src/components/batch.cpp
+
   src/renderer/debug.cpp
-  src/renderer/basics.cpp
   src/renderer/mesh.cpp
   src/renderer/shader.cpp
   src/renderer/texture.cpp

assets/grass_block/grass_block.mtl

@@ -1,4 +1,4 @@
-# Blender 4.3.2 MTL File: 'untitled.blend'
+# Blender 4.3.2 MTL File: 'None'
 # www.blender.org
 
 newmtl Grass_Bottom

assets/grass_block/grass_block.obj

@@ -2,25 +2,25 @@
 # www.blender.org
 mtllib grass_block.mtl
 o Cube
-v -1.000000 -1.000000 1.000000
+v -0.389000 -0.389000 0.389000
-v -1.000000 1.000000 1.000000
+v -0.389000 0.389000 0.389000
-v -1.000000 -1.000000 -1.000000
+v -0.389000 -0.389000 -0.389000
-v -1.000000 1.000000 -1.000000
+v -0.389000 0.389000 -0.389000
-v 1.000000 -1.000000 1.000000
+v 0.389000 -0.389000 0.389000
-v 1.000000 1.000000 1.000000
+v 0.389000 0.389000 0.389000
-v 1.000000 -1.000000 -1.000000
+v 0.389000 -0.389000 -0.389000
-v 1.000000 1.000000 -1.000000
+v 0.389000 0.389000 -0.389000
 vn -1.0000 -0.0000 -0.0000
 vn -0.0000 -0.0000 -1.0000
 vn 1.0000 -0.0000 -0.0000
 vn -0.0000 -0.0000 1.0000
-vn -0.0000 -1.0000 -0.0000
 vn -0.0000 1.0000 -0.0000
+vn -0.0000 -1.0000 -0.0000
 vt 0.000000 1.000000
 vt 1.000000 0.000000
 vt 0.000000 0.000000
 vt 1.000000 1.000000
-s 0
+s 1
 usemtl Grass_Side
 f 2/1/1 3/2/1 1/3/1
 f 4/1/2 7/2/2 3/3/2
@@ -31,8 +31,8 @@ f 4/1/2 8/4/2 7/2/2
 f 8/4/3 6/1/3 5/3/3
 f 6/4/4 2/1/4 1/3/4
 usemtl Grass_Top
-f 4/1/6 6/2/6 8/4/6
+f 4/1/5 6/2/5 8/4/5
-f 4/1/6 2/3/6 6/2/6
+f 4/1/5 2/3/5 6/2/5
 usemtl Grass_Bottom
-f 7/4/5 1/3/5 3/1/5
+f 7/4/6 1/3/6 3/1/6
-f 7/4/5 5/2/5 1/3/5
+f 7/4/6 5/2/6 1/3/6

include/components/batch.h

@@ -0,0 +1,27 @@
+#ifndef COMPONENT_BATCH_H_
+#define COMPONENT_BATCH_H_
+
+#include "renderer/renderer.h"
+
+// requires mesh component
+struct batch {
+    friend class Renderer;
+public:
+    // requires transform component
+    struct item {
+        unsigned int batchId;
+    };
+
+    batch();
+
+    inline const unsigned int id() const { return m_id; }
+protected:
+    static unsigned int LastID;
+private:
+    unsigned int m_id;
+    unsigned int m_instance_vbo { 0 };
+private:
+    void prepare(glm::mat4 *instances, unsigned int count);
+};
+
+#endif // COMPONENT_BATCH_H_

include/components/light.h

@@ -2,10 +2,25 @@
 #define COMPONENTS_LIGHT_H_
 
 #include <glm/glm.hpp>
+#include "renderer/renderer.h"
 
 struct light {
+    friend class Renderer;
+public:
+    enum LightType {
+        DIRECTIONAL = 0,
+    };
+    LightType type;
     glm::vec3 color;
     float intensity;
+
+    light(LightType t, const glm::vec3& c, float i)
+        : type(t), color(c), intensity(i),
+          shadowMap(0), fbo(0), lightSpace(1.0f) {}
+private:
+    unsigned int shadowMap;
+    unsigned int fbo;
+    glm::mat4 lightSpace;
 };
 
 #endif // COMPONENTS_LIGHT_H_

include/components/mesh.h

@@ -5,7 +5,7 @@
 #include "renderer/wavefront.h"
 
 struct mesh {
-    std::unique_ptr<Object> object;
+    std::shared_ptr<Object> object;
 };
 
 #endif // COMPONENTS_MESH_H_

include/components/rotate.h

@@ -0,0 +1,6 @@
+#ifndef COMPONENT_ROTATE_H_
+#define COMPONENT_ROTATE_H_
+
+struct rotate {};
+
+#endif // COMPONENT_ROTATE_H_

include/renderer/basics.h

@@ -3,7 +3,10 @@
 
 #include <glm/glm.hpp>
 
+#include "renderer/mesh.h"
+
 class Vertex {
+    friend class Mesh;
 private:
     glm::vec3 m_position;
     glm::vec3 m_normal;

include/renderer/mesh.h

@@ -21,7 +21,7 @@ public:
 public:
     Mesh();
 public:
-    void Render();
+    void Render(unsigned int count);
 };
 
 #endif // MESH_H_

include/renderer/renderer.h

@@ -9,25 +9,25 @@
 // TODO: make static or singleton
 class Renderer {
 public:
-    Renderer();
+    Renderer(entt::registry& registry);
 
-    void Render(entt::registry& registry);
+    void Render();
-    void GenerateShadowMaps(entt::registry& registry);
+    void Init();
+    void GenerateShadowMaps();
 
     void OnWindowResized(int w, int h);
 private:
-    void ApplyLights(entt::registry& registry);
+    void ApplyLights(Shader &shader);
-    void UpdateView(entt::registry& registry);
+    void UpdateView();
-    void RenderScene(entt::registry& registry);
+    void RenderScene(Shader &shader);
-
-    void SwitchShader(Shader* newShader);
 private:
     Shader m_shader;
     Shader m_depthShader;
 
-    Shader* m_currentShader;
+    entt::registry& m_registry;
-    unsigned int m_depth_fbo;
+
-    unsigned int m_depthMap;
+    // unsigned int m_depth_fbo;
+    // unsigned int m_depthMap;
 
     glm::mat4 m_model;
     glm::mat4 m_proj;

include/renderer/wavefront.h

@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "shader.h"
+#include "renderer/renderer.h"
 #include "renderer/material.h"
 #include "renderer/mesh.h"
 
@@ -15,6 +16,7 @@ enum ObjElement { OHASH, MTLLIB, USEMTL, O, V, VN, VT, F, OUNKNOWN };
 enum MtlElement { MHASH, NEWMTL, NS, KA, KS, KD, NI, D, ILLUM, MAP_KD, MAP_KA, MUNKNOWN };
 
 class Object {
+    friend class Renderer;
 private:
     static inline int NormalizeIndex(int idx, int baseCount);
 
@@ -34,8 +36,10 @@ private:
     Mesh& GetLastMesh();
     void CreateNewMesh(const std::string& materialName);
 public:
-    void Render(Shader& shader);
+    void Render(Shader& shader, unsigned int count);
     [[nodiscard]] inline const std::string Name() const { return m_name; }
+protected:
+    void EnableBatch(unsigned int instanceVBO);
 private:
     std::string m_name;
     std::vector<glm::vec3> m_vertices;

out.txt

@@ -1,66 +0,0 @@
-GL_VENDOR:   NVIDIA Corporation
-GL_RENDERER: NVIDIA GeForce RTX 3050 Ti Laptop GPU/PCIe/SSE2
-GL_VERSION:  4.6.0 NVIDIA 550.163.01
-Object name: Sphere
-Vertices count: 482
-Normals count: 530
-TexCoords count: 559
-Meshes count: 2
-Materials count: 2
-GL CALLBACK:  type = 0x33361, severity = 0x33387, message = Buffer detailed info: Buffer object 3 (bound to GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (0), GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (1), GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (2), and GL_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations.
-GL CALLBACK:  type = 0x33361, severity = 0x33387, message = Buffer detailed info: Buffer object 4 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations.
-Object name: Cube
-Vertices count: 8
-Normals count: 6
-TexCoords count: 14
-Meshes count: 1
-Materials count: 1
-GL CALLBACK:  type = 0x33361, severity = 0x33387, message = Buffer detailed info: Buffer object 5 (bound to GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (0), GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (1), GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (2), and GL_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations.
-GL CALLBACK:  type = 0x33361, severity = 0x33387, message = Buffer detailed info: Buffer object 6 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations.
-Object name: Plane
-Vertices count: 4
-Normals count: 1
-TexCoords count: 4
-Meshes count: 1
-Materials count: 1
-GL CALLBACK:  type = 0x33361, severity = 0x33387, message = Buffer detailed info: Buffer object 7 (bound to GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (0), GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (1), GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (2), and GL_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations.
-GL CALLBACK:  type = 0x33361, severity = 0x33387, message = Buffer detailed info: Buffer object 8 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations.
-Game initialized
-GL CALLBACK: ** GL ERROR ** type = 0x33356, severity = 0x37190, message = GL_INVALID_OPERATION error generated. <location> is invalid.
-GL CALLBACK: ** GL ERROR ** type = 0x33356, severity = 0x37190, message = GL_INVALID_OPERATION error generated. <location> is invalid.
-GL CALLBACK: ** GL ERROR ** type = 0x33356, severity = 0x37190, message = GL_INVALID_OPERATION error generated. <location> is invalid.
-GL CALLBACK: ** GL ERROR ** type = 0x33356, severity = 0x37190, message = GL_INVALID_OPERATION error generated. <location> is invalid.
-GL CALLBACK: ** GL ERROR ** type = 0x33356, severity = 0x37190, message = GL_INVALID_OPERATION error generated. <location> is invalid.
-GL CALLBACK: ** GL ERROR ** type = 0x33356, severity = 0x37190, message = GL_INVALID_OPERATION error generated. <location> is invalid.
-GL CALLBACK: ** GL ERROR ** type = 0x33356, severity = 0x37190, message = GL_INVALID_OPERATION error generated. <location> is invalid.
-GL CALLBACK:  type = 0x33360, severity = 0x37191, message = Program/shader state performance warning: Vertex shader in program 6 is being recompiled based on GL state.
-GL CALLBACK:  type = 0x33360, severity = 0x37191, message = Program/shader state performance warning: Vertex shader in program 3 is being recompiled based on GL state.
-FPS: 160.359
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165.01
-FPS: 165
-FPS: 164.835
-FPS: 165.01
-FPS: 165
-FPS: 165.174
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165.174
-FPS: 164.835
-FPS: 165.174
-FPS: 164.835
-FPS: 165
-FPS: 165
-FPS: 165
-FPS: 165.01
-FPS: 165
-FPS: 165.174

src/components/batch.cpp

@@ -0,0 +1,19 @@
+#include <GL/glew.h>
+
+#include "components/batch.h"
+
+unsigned int batch::LastID = 0;
+
+batch::batch() {
+    m_id = ++LastID;
+}
+
+void batch::prepare(glm::mat4 *instances, unsigned int count) {
+    if (m_instance_vbo == 0) {
+        glGenBuffers(1, &m_instance_vbo);
+    }
+    
+    glBindBuffer(GL_ARRAY_BUFFER, m_instance_vbo);
+        glBufferData(GL_ARRAY_BUFFER, sizeof(glm::mat4) * count, reinterpret_cast<void*>(instances), GL_DYNAMIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+}

src/main.cpp

@@ -23,34 +23,55 @@
 #include "components/light.h"
 #include "components/camera.h"
 #include "components/mesh.h"
+#include "components/rotate.h"
+#include "components/batch.h"
 
 class Game : public IApplication {
 public:
-    Game() {
+    Game() : m_renderer(m_registry) {
         Object* lightObj = Object::LoadFile("./assets/sphere.obj");
-        // const auto lightEntity = m_registry.create();
+        const auto lght = m_registry.create();
-        // m_registry.emplace<transform>(lightEntity, glm::vec3(-5.f, 5.f, 5.f), glm::vec3(0.f));
+        m_registry.emplace<transform>(lght, glm::vec3(5.f, 5.f, 5.f), glm::vec3(0.f));
-        // m_registry.emplace<light>(lightEntity, glm::vec3(1.f, 0.f, 0.f), 1.f);
+        m_registry.emplace<light>(lght, light::LightType::DIRECTIONAL, glm::vec3(1.f, 1.f, 1.f), 1.5f);
-        // m_registry.emplace<mesh>(lightEntity, std::unique_ptr<Object>(lightObj));
+        m_registry.emplace<mesh>(lght, std::shared_ptr<Object>(lightObj));
-
-        const auto lEntt2 = m_registry.create();
-        m_registry.emplace<transform>(lEntt2, glm::vec3(5.f, 5.f, 5.f), glm::vec3(0.f));
-        m_registry.emplace<light>(lEntt2, glm::vec3(1.f, 1.f, 1.f), 1.5f);
-        m_registry.emplace<mesh>(lEntt2, std::unique_ptr<Object>(lightObj));
 
         const auto cameraEntity = m_registry.create();
         m_registry.emplace<transform>(cameraEntity, glm::vec3(0.f, 2.f, 2.f));
         m_registry.emplace<camera>(cameraEntity);
 
-        Object* targetObj = Object::LoadFile("./assets/cube.obj");
+        Object* targetObj = Object::LoadFile("./assets/wizard/wizard.obj");
         const auto targetEntity = m_registry.create();
-        m_registry.emplace<transform>(targetEntity, glm::vec3(0.f, 0.5f, 0.f));
+        m_registry.emplace<transform>(targetEntity, glm::vec3(0.f, 0.0f, 0.f));
-        m_registry.emplace<mesh>(targetEntity, std::unique_ptr<Object>(targetObj));
+        m_registry.emplace<mesh>(targetEntity, std::shared_ptr<Object>(targetObj));
+
+        Object* grass = Object::LoadFile("./assets/grass_block/grass_block.obj");
+        const auto cubeEntity = m_registry.create();
+        m_registry.emplace<transform>(cubeEntity, glm::vec3(-1.5f, 0.4f, 0.f));
+        m_registry.emplace<mesh>(cubeEntity, std::shared_ptr<Object>(grass));
+
+        // Cube template (use shared object to avoid reloading 1000 times)
+        std::shared_ptr<Object> cubeObj = std::shared_ptr<Object>(Object::LoadFile("./assets/grass_block/grass_block.obj"));
+        const auto batchEntt = m_registry.create();
+        m_registry.emplace<batch>(batchEntt);
+        m_registry.emplace<mesh>(batchEntt, cubeObj);
+        auto cubeBatch = m_registry.get<batch>(batchEntt);
+        // Generate 1000 random cubes
+        for (int i = 0; i < 1000; ++i) {
+            const auto cubeEntity = m_registry.create();
+
+            float x = static_cast<float>(rand()) / RAND_MAX * 200.f - 100.f; // range [-100, 100]
+            float y = static_cast<float>(rand()) / RAND_MAX * 10.f;          // range [0, 10]
+            float z = static_cast<float>(rand()) / RAND_MAX * 200.f - 100.f; // range [-100, 100]
+
+            m_registry.emplace<transform>(cubeEntity, glm::vec3(x, y, z));
+            m_registry.emplace<rotate>(cubeEntity);
+            m_registry.emplace<batch::item>(cubeEntity, cubeBatch.id());
+        }
 
         Object* floorObj = Object::LoadFile("./assets/plane.obj");
         const auto floorEntt = m_registry.create();
         m_registry.emplace<transform>(floorEntt, glm::vec3(0.f));
-        m_registry.emplace<mesh>(floorEntt, std::unique_ptr<Object>(floorObj));
+        m_registry.emplace<mesh>(floorEntt, std::shared_ptr<Object>(floorObj));
     }
     ~Game() override {}
 
@@ -69,7 +90,8 @@ public:
         m_startTicks = SDL_GetTicks();
         m_frameCount = 0;
 
-        m_renderer.GenerateShadowMaps(m_registry);
+        m_renderer.Init();
+        m_renderer.GenerateShadowMaps();
     }
 
     void OnWindowResized(const WindowResized& event) override {
@@ -131,17 +153,51 @@ public:
             }
         }
 
-        // auto rotateEntts = m_registry.view<transform, const mesh>();
+        // ---- Day-night simulation ----
-        // for (auto [entity, transform, mesh] : rotateEntts.each()) {
+        m_dayTime += deltaTime;
-        //     // auto targetTransform = rotateEntts.get<transform>(entity);
+        if (m_dayTime > m_dayLength)
-        //     if (!m_registry.all_of<light>(entity)) {
+            m_dayTime -= m_dayLength; // loop every "day"
-        //         transform.rotation.y = m_angle;
+
-        //     }
+        float dayProgress = m_dayTime / m_dayLength; // 0.0 -> 1.0
-        // }
+        float sunAngle = dayProgress * glm::two_pi<float>(); // radians through the sky
+
+        // Compute sun direction (rotating around X axis)
+        // At t=0.0 sun at east horizon, at π/2 overhead, at π west horizon
+        glm::vec3 sunDir = glm::normalize(glm::vec3(0.0f, sin(sunAngle), cos(sunAngle)));
+
+        // Compute intensity: bright at noon, dim at dusk/dawn, dark at night
+        float intensity = glm::max(sin(sunAngle), (double)0.0f); // 0 at night, 1 at noon
+        intensity = glm::mix(0.05f, 1.5f, intensity);    // keep some ambient even at night
+
+        // Optional: tint color (warm at sunrise/sunset)
+        glm::vec3 dayColor   = glm::vec3(1.0f, 0.95f, 0.9f);
+        glm::vec3 sunsetColor= glm::vec3(1.0f, 0.6f, 0.3f);
+        float sunsetFactor = glm::clamp(1.0f - abs(sin(sunAngle)) * 2.0f, 0.0f, 1.0f);
+        glm::vec3 sunColor = glm::mix(dayColor, sunsetColor, sunsetFactor);
+
+        // Update the directional light in the registry
+        auto lightsView = m_registry.view<light, transform>();
+        for (auto [entity, l, t] : lightsView.each()) {
+            if (l.type == light::LightType::DIRECTIONAL) {
+                // "position" for directional light often stores direction vector
+                // If your system instead uses transform.rotation, adjust accordingly
+                t.position = sunDir * 15.f;       // use this as light direction
+                l.color = sunColor;
+                l.intensity = intensity;
+            }
+        }
+
+        auto rotateEntts = m_registry.view<transform, rotate>();
+        for (auto [entity, t] : rotateEntts.each()) {
+            // auto targetTransform = rotateEntts.get<transform>(entity);
+            if (!m_registry.all_of<light>(entity)) {
+                t.rotation.y = m_angle;
+            }
+        }
     }
 
     void OnRender() override {
-        m_renderer.Render(m_registry);
+        m_renderer.Render();
 
         m_frameCount++;
         m_currentTicks = SDL_GetTicks();
@@ -161,6 +217,9 @@ private:
     float m_angle;
     Uint64 m_lastTicks;
 
+    float m_dayTime = 0.0f;       // accumulates time for day-night cycle
+    float m_dayLength = 60.0f;    // seconds per full day cycle
+
     bool m_paused = false;
 
     float m_yaw   = -90.0f; // looking along -Z initially

src/renderer/basics.cpp

@@ -1,15 +0,0 @@
-#include <GL/glew.h>
-
-#include "renderer/basics.h"
-
-void Vertex::DefineAttrib()
-{
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_position)));
-    glEnableVertexAttribArray(0);
-
-    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_normal)));
-    glEnableVertexAttribArray(1);
-    
-    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_texCoord)));
-    glEnableVertexAttribArray(2);
-}

src/renderer/debug.cpp

@@ -10,6 +10,43 @@ void MessageCallback(GLenum source,
                      const GLchar* message,
                      const void* userParam)
 {
+    if(id == 131169 || id == 131185 || id == 131218 || id == 131204) return; 
+
+    std::cout << "---------------" << std::endl;
+    std::cout << "Debug message (" << id << "): " <<  message << std::endl;
+
+    switch (source)
+    {
+        case GL_DEBUG_SOURCE_API:             std::cout << "Source: API"; break;
+        case GL_DEBUG_SOURCE_WINDOW_SYSTEM:   std::cout << "Source: Window System"; break;
+        case GL_DEBUG_SOURCE_SHADER_COMPILER: std::cout << "Source: Shader Compiler"; break;
+        case GL_DEBUG_SOURCE_THIRD_PARTY:     std::cout << "Source: Third Party"; break;
+        case GL_DEBUG_SOURCE_APPLICATION:     std::cout << "Source: Application"; break;
+        case GL_DEBUG_SOURCE_OTHER:           std::cout << "Source: Other"; break;
+    } std::cout << std::endl;
+
+    switch (type)
+    {
+        case GL_DEBUG_TYPE_ERROR:               std::cout << "Type: Error"; break;
+        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: std::cout << "Type: Deprecated Behaviour"; break;
+        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:  std::cout << "Type: Undefined Behaviour"; break; 
+        case GL_DEBUG_TYPE_PORTABILITY:         std::cout << "Type: Portability"; break;
+        case GL_DEBUG_TYPE_PERFORMANCE:         std::cout << "Type: Performance"; break;
+        case GL_DEBUG_TYPE_MARKER:              std::cout << "Type: Marker"; break;
+        case GL_DEBUG_TYPE_PUSH_GROUP:          std::cout << "Type: Push Group"; break;
+        case GL_DEBUG_TYPE_POP_GROUP:           std::cout << "Type: Pop Group"; break;
+        case GL_DEBUG_TYPE_OTHER:               std::cout << "Type: Other"; break;
+    } std::cout << std::endl;
+    
+    switch (severity)
+    {
+        case GL_DEBUG_SEVERITY_HIGH:         std::cout << "Severity: high"; break;
+        case GL_DEBUG_SEVERITY_MEDIUM:       std::cout << "Severity: medium"; break;
+        case GL_DEBUG_SEVERITY_LOW:          std::cout << "Severity: low"; break;
+        case GL_DEBUG_SEVERITY_NOTIFICATION: std::cout << "Severity: notification"; break;
+    } std::cout << std::endl;
+    std::cout << std::endl;
+    return;
     (void) source;
     (void) id;
     (void) length;

src/renderer/engine.cpp

@@ -28,9 +28,6 @@ void Engine::Run(std::unique_ptr<IApplication> app) {
         s_window->ProcessEvents();
 
         s_app->OnUpdate();
-        
-        glClearColor(0x18/255.0f, 0x18/255.0f, 0x18/255.0f, 1);
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
         s_app->OnRender();
 

src/renderer/mesh.cpp

@@ -1,3 +1,5 @@
+#include <cstddef>
+
 #include "renderer/mesh.h"
 
 Mesh::Mesh() {
@@ -13,13 +15,21 @@ Mesh::Mesh() {
 
     // VBO (vertex buffer)
     glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-    glBufferData(GL_ARRAY_BUFFER, 0, nullptr, GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, 0, nullptr, GL_DYNAMIC_DRAW);
 
     // EBO (index buffer)
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 0, nullptr, GL_STATIC_DRAW);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 0, nullptr, GL_DYNAMIC_DRAW);
 
-    Vertex::DefineAttrib();
+    // attributes
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_position)));
+    glEnableVertexAttribArray(0);
+
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_normal)));
+    glEnableVertexAttribArray(1);
+    
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(offsetof(Vertex, m_texCoord)));
+    glEnableVertexAttribArray(2);
 
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
@@ -29,18 +39,22 @@ void Mesh::Upload() const {
     glBindVertexArray(m_vao);
 
     glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-    glBufferData(GL_ARRAY_BUFFER, m_vertexBuffer.size() * sizeof(Vertex), m_vertexBuffer.data(), GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, m_vertexBuffer.size() * sizeof(Vertex), m_vertexBuffer.data(), GL_DYNAMIC_DRAW);
 
     // Upload indices
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer.size() * sizeof(unsigned int), m_indexBuffer.data(), GL_STATIC_DRAW);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer.size() * sizeof(unsigned int), m_indexBuffer.data(), GL_DYNAMIC_DRAW);
 
     glBindVertexArray(0);
 }
 
-void Mesh::Render()
+void Mesh::Render(unsigned int count)
 {
     Bind();
-    glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(m_indexBuffer.size()), GL_UNSIGNED_INT, 0);
+    if (count > 1) {
+        glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(m_indexBuffer.size()), GL_UNSIGNED_INT, 0, count);
+    } else {
+        glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(m_indexBuffer.size()), GL_UNSIGNED_INT, 0);
+    }
     Unbind();
 }

src/renderer/renderer.cpp

@@ -1,7 +1,12 @@
 #include <iostream>
+#include <cassert>
 #include <glm/glm.hpp>
 #include <glm/ext/matrix_clip_space.hpp>
+#ifdef WIN32
+#include <corecrt_math_defines.h>
+#endif
 #include <glm/ext/matrix_transform.hpp>
+#define GLM_ENABLE_EXPERIMENTAL
 #include <glm/gtx/euler_angles.hpp>
 
 #include "renderer/renderer.h"
@@ -12,8 +17,9 @@
 #include "components/camera.h"
 #include "components/light.h"
 #include "components/mesh.h"
+#include "components/batch.h"
 
-Renderer::Renderer()
+Renderer::Renderer(entt::registry& registry) : m_registry(registry)
 {
     m_proj = glm::perspective(
         static_cast<float>(M_PI_2),
@@ -23,7 +29,7 @@ Renderer::Renderer()
     );
 
     m_shader.init(
-        FileManager::read("./src/shaders/simple.vs"),
+        FileManager::read("./src/shaders/main.vs"),
         FileManager::read("./src/shaders/pbr.fs")
     );
 
@@ -34,14 +40,20 @@ Renderer::Renderer()
 
     m_model = glm::mat4(1.f);
 
-    SwitchShader(&m_shader);
+    m_shader.use();
-
     m_shader.setMat4("u_projection", m_proj);
 }
 
-void Renderer::SwitchShader(Shader *newShader) {
+void Renderer::Init() {
-    m_currentShader = newShader;
+    // auto view = m_registry.view<batch, mesh>();
-    m_currentShader->use();
+    // for (auto [_, b, m] : m_registry.view<batch, mesh>().each()) {
+    //     unsigned int items = 0;
+    //     for (auto [entt, item] : m_registry.view<batch::item>().each()) {
+    //         if (item.batchId == b.id()) ++items;
+    //     }
+    //     b.prepare()
+    //     m.object->EnableBatch(b.m_instance_vbo);
+    // }
 }
 
 void Renderer::OnWindowResized(int w, int h) {
@@ -51,30 +63,33 @@ void Renderer::OnWindowResized(int w, int h) {
         0.01f,
         100.0f
     );
-    m_shader.setMat4("u_projection", m_proj);
-    m_depthShader.setMat4("u_projection", m_proj);
 }
 
-void Renderer::ApplyLights(entt::registry& registry) {
+void Renderer::ApplyLights(Shader &shader) {
-    auto lights = registry.view<light>();
+    auto lights = m_registry.view<light>();
     // TODO: Pass Lights Data to depth shader as well
-    m_shader.setInt("lightsCount", static_cast<int>(lights.size()));
+    shader.setInt("lightsCount", static_cast<int>(lights.size()));
     size_t lightIndex = 0;
     for (auto entity : lights) {
-        auto &comp = registry.get<light>(entity);
+        auto &l = m_registry.get<light>(entity);
-        auto &transf = registry.get<transform>(entity);
+        auto &transf = m_registry.get<transform>(entity);
-
+        
-        m_shader.setVec3("lights[" + std::to_string(lightIndex) + "].position", transf.position);
+        shader.setInt("lights[" + std::to_string(lightIndex) + "].type", static_cast<int>(l.type));
-        m_shader.setVec3("lights[" + std::to_string(lightIndex) + "].color", comp.color);
+        shader.setVec3("lights[" + std::to_string(lightIndex) + "].position", transf.position);
-        m_shader.setFloat("lights[" + std::to_string(lightIndex) + "].intensity", comp.intensity);
+        shader.setVec3("lights[" + std::to_string(lightIndex) + "].color", l.color);
+        shader.setFloat("lights[" + std::to_string(lightIndex) + "].intensity", l.intensity);
+        shader.setMat4("lights[" + std::to_string(lightIndex) + "].lightSpace", l.lightSpace);
+        shader.setInt("lights[" + std::to_string(lightIndex) + "].shadowMap", 10 + lightIndex);
+        glActiveTexture(GL_TEXTURE10 + lightIndex);
+        glBindTexture(GL_TEXTURE_2D, l.shadowMap);
 
         ++lightIndex;
     }
 }
 
-void Renderer::UpdateView(entt::registry& registry) {
+void Renderer::UpdateView() {
-    auto cam = registry.view<transform, camera>().back();
+    auto cam = m_registry.view<transform, camera>().back();
-    auto camTransform = registry.get<transform>(cam);
+    auto camTransform = m_registry.get<transform>(cam);
 
     m_view = glm::lookAt(
         camTransform.position,
@@ -82,108 +97,150 @@ void Renderer::UpdateView(entt::registry& registry) {
         glm::vec3(0.f, 1.f, 0.f)
     );
     m_shader.setMat4("u_view", m_view);
+    m_shader.setMat4("u_projection", m_proj);
 
     m_shader.setVec3("viewPos", camTransform.position);
 }
 
-void Renderer::RenderScene(entt::registry& registry) {
+void Renderer::RenderScene(Shader &shader) {
-    auto view = registry.view<transform, mesh>();
+    std::unordered_map<unsigned int, std::vector<entt::entity>> batches;
 
-    for (auto [entity, transf, mesh] : view.each()) {
+    for (auto [entt, item] : m_registry.view<batch::item>().each()) {
+        if (batches.find(item.batchId) == batches.end())
+            batches.insert(std::make_pair(item.batchId, std::vector<entt::entity>()));
+
+        batches[item.batchId].push_back(entt);
+    }
+
+    shader.setBool("u_isInstanced", true);
+    shader.setBool("isLight", false);
+    shader.setVec3("currentLightColor", glm::vec3(0.f));
+    for (auto [entt, b, m] : m_registry.view<batch, mesh>().each()) {
+        // check if have items for batch render
+        if (batches.find(b.id()) == batches.end()) continue;
+
+        auto &batchItems = batches[b.id()];
+
+        std::vector<glm::mat4> models;
+        models.reserve(batchItems.size());
+
+        for (auto item : batchItems) {
+            auto &t = m_registry.get<transform>(item);
+            glm::mat4 rotation = glm::yawPitchRoll(t.rotation.y, t.rotation.x, t.rotation.z);
+            auto itemModel = glm::translate(glm::mat4(1.f), t.position) * rotation;
+            models.push_back(itemModel);
+        }
+
+        auto prevInstanceVBO = b.m_instance_vbo;
+        b.prepare(models.data(), models.size());
+        if (prevInstanceVBO <= 0) {
+            std::cout << "[DEBUG] enabling batch"<<std::endl;
+            m.object->EnableBatch(b.m_instance_vbo);
+        }
+        m.object->Render(shader, batchItems.size());
+    }
+    shader.setBool("u_isInstanced", false);
+
+    for (auto [entity, transf, mesh] : m_registry.view<transform, mesh>(entt::exclude<batch, batch::item>).each()) {
         if (mesh.object == nullptr) {
             std::cerr << "WARN: Entity doesn't have a mesh to render" << std::endl;
             return;
         }
 
-        if (registry.all_of<light>(entity)) {
+        if (m_registry.all_of<light>(entity)) {
-            auto &comp = registry.get<light>(entity);
+            auto &l = m_registry.get<light>(entity);
-            m_currentShader->setBool("isLight", true);
+            shader.setBool("isLight", true);
-            m_currentShader->setVec3("currentLightColor", comp.color);
+            shader.setVec3("currentLightColor", l.color);
         } else {
-            m_currentShader->setBool("isLight", false);
+            shader.setBool("isLight", false);
-            m_currentShader->setVec3("currentLightColor", glm::vec3(0.f));
+            shader.setVec3("currentLightColor", glm::vec3(0.f));
         }
 
         glm::mat4 rotation = glm::yawPitchRoll(transf.rotation.y, transf.rotation.x, transf.rotation.z);
         m_model = glm::translate(glm::mat4(1.f), transf.position) * rotation;
 
-        m_currentShader->setMat4("u_model", m_model);
+        shader.setMat4("u_model", m_model);
 
-        mesh.object->Render(*m_currentShader);
+        mesh.object->Render(shader, 1);
     }
 }
 
-void Renderer::GenerateShadowMaps(entt::registry& registry) {
+void Renderer::GenerateShadowMaps() {
-    SwitchShader(&m_depthShader);
-
-    ApplyLights(registry);
-    UpdateView(registry);
-    
-    glGenFramebuffers(1, &m_depth_fbo);
-
     const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
 
-    glGenTextures(1, &m_depthMap);
+    m_depthShader.use();
-    glBindTexture(GL_TEXTURE_2D, m_depthMap);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, 
-                SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); 
+    auto lights = m_registry.view<light>();
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
 
-    float borderColor[] = {1.0f, 1.0f, 1.0f, 1.0f};
+    for (auto [lEntt, l] : lights.each()) {
-    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
+        // TODO: support other light types when ready
+        if (l.type != light::LightType::DIRECTIONAL) return;
 
-    glBindFramebuffer(GL_FRAMEBUFFER, m_depth_fbo);
+        glGenFramebuffers(1, &l.fbo);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthMap, 0);
+        glGenTextures(1, &l.shadowMap);
-    glDrawBuffer(GL_NONE);
+        glBindTexture(GL_TEXTURE_2D, l.shadowMap);
-    glReadBuffer(GL_NONE);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, 
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+                    SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
-    m_shader.setInt("shadowMap", 31);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); 
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+
+        float borderColor[] = {1.0f, 1.0f, 1.0f, 1.0f};
+        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
+
+        glBindFramebuffer(GL_FRAMEBUFFER, l.fbo);
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, l.shadowMap, 0);
+        glDrawBuffer(GL_NONE);
+        glReadBuffer(GL_NONE);
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    }
 }
 
-void Renderer::Render(entt::registry& registry) {
+void Renderer::Render() {
     const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
 
-    glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
+    m_depthShader.use();
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    auto shadowLight = registry.view<light, transform>().back();
+    auto lights = m_registry.view<light, transform>();
-    auto &comp = registry.get<transform>(shadowLight);
 
-    float near_plane = -10.0f, far_plane = 20.0f;
+    for (auto [lEntt, l, t] : lights.each()) {
-    glm::mat4 lightProjection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_plane, far_plane);
+        // TODO: support other light types when ready
+        if (l.type != light::LightType::DIRECTIONAL) return;
 
-    glm::mat4 lightView = glm::lookAt(comp.position, 
+        glClearColor(0x18/255.0f, 0x18/255.0f, 0x18/255.0f, 1.0f);
-            glm::vec3( 0.0f, 0.0f,  0.0f), 
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-            glm::vec3( 0.0f, 1.0f,  0.0f));
 
-    glm::mat4 lightSpaceMatrix = lightProjection * lightView;
+        float near_plane = 0.1f, far_plane = 50.0f;
-    SwitchShader(&m_depthShader);
+        glm::vec3 target   = glm::vec3(0.0f, 0.5f, 0.0f);
-    m_currentShader->setMat4("u_lightSpace", lightSpaceMatrix);
+        glm::mat4 lightView = glm::lookAt(t.position, target, glm::vec3(0.0f, 1.0f, 0.0f));
+        glm::mat4 lightProjection = glm::ortho(-6.0f, 6.0f, -6.0f, 6.0f, 1.0f, 20.0f);
+        glm::mat4 lightSpaceMatrix = lightProjection * lightView;
 
-    glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
+        m_depthShader.setMat4("u_lightSpace", lightSpaceMatrix);
-    glBindFramebuffer(GL_FRAMEBUFFER, m_depth_fbo);
+        l.lightSpace = lightSpaceMatrix;
-        glClear(GL_DEPTH_BUFFER_BIT);
+
-        RenderScene(registry);
+        glCullFace(GL_FRONT);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
+        glBindFramebuffer(GL_FRAMEBUFFER, l.fbo);
+            glClear(GL_DEPTH_BUFFER_BIT);
+            RenderScene(m_depthShader);
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glCullFace(GL_BACK);
+    }
+
+    // actual rendering
 
     glViewport(0, 0, Window::GetWidth(), Window::GetHeight());
+
+    glClearColor(0x18/255.0f, 0x18/255.0f, 0x18/255.0f, 1);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     
-    SwitchShader(&m_shader);
+    m_shader.use();
 
-    ApplyLights(registry);
+    ApplyLights(m_shader);
+    UpdateView();
 
-    UpdateView(registry);
+    RenderScene(m_shader);
-
-    m_currentShader->setMat4("u_lightSpace", lightSpaceMatrix);
-
-    glActiveTexture(GL_TEXTURE31);
-    glBindTexture(GL_TEXTURE_2D, m_depthMap);
-
-    RenderScene(registry);
 }

src/renderer/wavefront.cpp

@@ -392,6 +392,24 @@ Object* Object::LoadFile(const std::string& filename) {
     return obj;
 }
 
+void Object::EnableBatch(unsigned int instanceVBO) {
+    for (auto &mesh : m_meshes) {
+        mesh.Bind();
+
+        glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
+        std::size_t vec4Size = sizeof(glm::vec4);
+        for (int i = 0; i < 4; ++i) {
+            glEnableVertexAttribArray(3 + i); // use locations 3,4,5,6 for instance matrix
+            glVertexAttribPointer(3 + i, 4, GL_FLOAT, GL_FALSE,
+                                sizeof(glm::mat4), (void*)(i * vec4Size));
+            glVertexAttribDivisor(3 + i, 1); // IMPORTANT: one per instance, not per vertex
+        }
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        
+        mesh.Unbind();
+    }
+}
+
 
 // void Object::Render(Shader& shader)
 // {
@@ -420,7 +438,7 @@ Object* Object::LoadFile(const std::string& filename) {
 //     }
 // }
 
-void Object::Render(Shader& shader)
+void Object::Render(Shader& shader, unsigned int count)
 {
     for (auto &mesh : m_meshes)
     {
@@ -484,7 +502,7 @@ void Object::Render(Shader& shader)
         }
 
         // --- Render mesh ---
-        mesh.Render();
+        mesh.Render(count);
     }
 }
 

src/shaders/main.vs

@@ -4,6 +4,7 @@
 layout (location = 0) in vec3 position;  // Vertex position in local space (model space)
 layout (location = 1) in vec3 normal;    // vertex normal
 layout (location = 2) in vec2 texCoord;     // Vertex texture uv
+layout (location = 3) in mat4 instanceModel;     // Vertex texture uv
 
 // Output to fragment shader
 out vec3 vertexPos;
@@ -15,19 +16,21 @@ out vec4 fragPosLightSpace;
 uniform mat4 u_model;       // Model matrix: transforms from local space to world space
 uniform mat4 u_view;        // View matrix: transforms from world space to camera space (view space)
 uniform mat4 u_projection;  // Projection matrix: transforms from camera space to clip space
-uniform mat4 u_lightSpace;
+uniform bool u_isInstanced;
 
 void main()
 {
-    vertexPos = vec3(u_model * vec4(position, 1.0));
+    mat4 model = u_isInstanced ? instanceModel : u_model;
 
-    mat3 normalMatrix = mat3(transpose(inverse(u_model)));
+    vertexPos = vec3(model * vec4(position, 1.0));
+
+    mat3 normalMatrix = mat3(transpose(inverse(model)));
     vertexNormal = normalMatrix * normal;
     // vertexNormal = normal;
 
     TexCoords = texCoord;
 
-    fragPosLightSpace = u_lightSpace * vec4(vertexPos, 1.0);
+    // fragPosLightSpace = u_lightSpace * vec4(vertexPos, 1.0);
 
     gl_Position = u_projection * u_view * vec4(vertexPos, 1.0);
 }

src/shaders/pbr.fs

@@ -1,18 +1,20 @@
 #version 410 core
 out vec4 FragColor;
 
-in vec3 vertexPos;
+in vec3 vertexPos;    // must be world-space position
 in vec3 vertexNormal;
 in vec2 TexCoords;
-in vec4 fragPosLightSpace;
 
 uniform vec3 viewPos;
 
 // Lights
 struct Light {
-    vec3 position;
+    int type;          // 0 = directional (shadowed), other = non-directional (no shadow)
+    vec3 position;     // for directional: encode light direction (see note)
     vec3 color;
     float intensity;
+    mat4 lightSpace;
+    sampler2D shadowMap;
 };
 #define MAX_LIGHTS 10
 uniform int lightsCount;
@@ -36,50 +38,53 @@ uniform bool useMetallicMap;
 uniform bool useRoughnessMap;
 uniform bool useAoMap;
 
-// Shadows
-uniform sampler2D shadowMap;
-
 uniform float opacity;
-// uniform int currentLight;
 
 #define PI 3.14159265359
 #define LIGHT_COLOR vec3(1.0, 1.0, 1.0)
 
-float ShadowCalculation(vec4 fragPosLightSpace, vec3 N, vec3 L)
+// -------------------------------------------------------------
+// Improved ShadowCalculation: returns [0,1] shadow factor (1 = fully in shadow)
+float ShadowCalculation(sampler2D shadowMap, mat4 lightSpace, vec3 N, vec3 L)
 {
-    // transform to [0,1]
+    // Transform fragment position to light's clip / NDC space
+    vec4 fragPosLightSpace = lightSpace * vec4(vertexPos, 1.0);
+
+    // perspective divide
     vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
+    // to [0,1]
     projCoords = projCoords * 0.5 + 0.5;
 
-    // if outside light's orthographic frustum => not in shadow
+    // if outside the light's orthographic frustum (xy outside or z > 1), consider unshadowed
-    if (projCoords.z > 1.0 || projCoords.x < 0.0 || projCoords.x > 1.0 || projCoords.y < 0.0 || projCoords.y > 1.0)
+    if (projCoords.z > 1.0) {
         return 0.0;
+    }
+    if (projCoords.x < 0.0 || projCoords.x > 1.0 || projCoords.y < 0.0 || projCoords.y > 1.0) {
+        return 0.0;
+    }
 
-    // get depth from shadow map
-    float closestDepth = texture(shadowMap, projCoords.xy).r;
     float currentDepth = projCoords.z;
-
+    // basic bias (slope-dependent)
-    // bias to prevent self-shadowing (depend on slope)
+    float bias = max(0.001 * (1.0 - dot(N, L)), 0.0005);
-    float bias = max(0.05 * (1.0 - dot(N, L)), 0.005);
 
     // PCF (3x3)
     float shadow = 0.0;
     vec2 texelSize = 1.0 / textureSize(shadowMap, 0);
-    for(int x = -1; x <= 1; ++x)
+    for (int x = -1; x <= 1; ++x) {
-    {
+        for (int y = -1; y <= 1; ++y) {
-        for(int y = -1; y <= 1; ++y)
-        {
             float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r;
-            shadow += (currentDepth - bias > pcfDepth ? 1.0 : 0.0);
+            shadow += (currentDepth - bias) > pcfDepth ? 1.0 : 0.0;
         }
     }
     shadow /= 9.0;
 
+    // clamp to [0,1]
+    shadow = clamp(shadow, 0.0, 1.0);
     return shadow;
 }
 
 // ----------------------------------------------------------------------------
-// Helper functions (GGX, Fresnel, Geometry)
+// PBR helpers (unchanged)
 float DistributionGGX(vec3 N, vec3 H, float roughness)
 {
     float a      = roughness * roughness;
@@ -137,22 +142,33 @@ void main()
     vec3 F0 = mix(vec3(0.04), baseColor, metal);
 
     vec3 Lo = vec3(0.0);
-    // FragColor = vec4(1.0 - shadow, 1.0 - shadow, 1.0 - shadow, 1.0);
-    // return;
-
-    float shadow = 0.0;
 
     // Loop over all lights
     for (int i = 0; i < lightsCount; i++)
     {
-        vec3 L = normalize(lights[i].position - vertexPos);
+        // compute light vector L depending on type
+        vec3 L = vec3(0);
+        if (lights[i].type == 0) {
+            // directional light: convention here is that lights[i].position stores the direction
+            // *towards* the light (for example, for sun direction you may upload -sunDir).
+            // Adjust according to your CPU-side convention.
+            L = normalize(lights[i].position); // expect this to be a direction
+        } else {
+            // point / spot style light: position is world-space point
+            L = normalize(lights[i].position - vertexPos);
+        }
+
         vec3 H = normalize(V + L);
 
         float NDF = DistributionGGX(N, H, rough);
         float G   = GeometrySmith(N, V, L, rough);
         vec3  F   = fresnelSchlick(max(dot(H,V),0.0), F0);
 
-        shadow = ShadowCalculation(fragPosLightSpace, N, L);
+        // compute shadow only for directional (type==0) lights that have shadow maps
+        float shadow_i = 0.0;
+        if (lights[i].type == 0) {
+            shadow_i = ShadowCalculation(lights[i].shadowMap, lights[i].lightSpace, N, L);
+        }
 
         vec3 numerator = NDF * G * F;
         float denominator = 4.0 * max(dot(N,V),0.0) * max(dot(N,L),0.0) + 0.001;
@@ -165,14 +181,19 @@ void main()
         float NdotL = max(dot(N,L), 0.0);
 
         vec3 radiance = lights[i].color * lights[i].intensity;
-        Lo += (kD * baseColor / PI + specular) * radiance * NdotL;
+
+        // Apply shadow_i only to this light's contribution:
+        // when shadow_i == 1.0 -> this light contributes 0
+        // when shadow_i == 0.0 -> full contribution
+        vec3 contrib = (kD * baseColor / PI + specular) * radiance * NdotL * (1.0 - shadow_i);
+
+        Lo += contrib;
     }
 
-    // Ambient
+    // Ambient (unshadowed by design)
     vec3 ambient = vec3(0.03) * baseColor * aoValue;
 
-    // TODO: apply shadow
+    vec3 color = ambient + Lo;
-    vec3 color = ambient + (1.0 - shadow) * Lo;
 
     // HDR tonemapping + gamma
     color = color / (color + vec3(1.0));

src/shaders/simple.fs

@@ -1,81 +0,0 @@
-#version 410 core
-
-// Output color of the fragment (pixel)
-out vec4 FragColor;  // RGBA color for the fragment, where A is the alpha (opacity)
-
-in vec3 vertexPos;
-in vec3 vertexNormal;
-in vec2 TexCoords;
-
-uniform vec3 viewPos;
-
-// Lights
-struct Light {
-    vec3 position;
-    vec3 color;
-    float intensity;
-};
-
-#define MAX_LIGHTS 10
-uniform int lightsCount;
-uniform Light lights[MAX_LIGHTS];
-
-// From Object Renderer
-
-uniform vec3 ambientColor;
-uniform vec3 diffuseColor;
-uniform vec3 specularColor;
-
-uniform float ambientStrength;
-
-uniform float specularStrength;
-uniform float shininess;
-uniform bool useSpecular;
-
-uniform float opacity;
-
-uniform sampler2D diffuseTex;
-uniform bool useTexture;
-
-uniform bool isLight;
-
-void main()
-{
-    // Lighting vectors
-    vec3 norm = normalize(vertexNormal);
-    vec3 viewDir = normalize(viewPos - vertexPos);
-    // vec3 viewDir = normalize(-vertexPos);
-
-    vec3 ambient = ambientStrength * ambientColor;
-    vec3 texColor = (useTexture)
-        ? texture(diffuseTex, TexCoords).rgb
-        : diffuseColor;
-
-    vec3 result = ambient;
-
-    for (int i = 0; i < lightsCount; i++) {
-        vec3 lightDir = normalize(lights[i].position - vertexPos);
-        vec3 halfDir = normalize(lightDir + viewDir);
-        
-        // Blinn Phong
-        float diff = max(dot(norm, lightDir), 0.0);
-        vec3 diffuse = diff * diffuseColor * lights[i].color * lights[i].intensity;
-
-        float spec = pow(max(dot(norm, halfDir), 0.0), clamp(shininess, 2.0, 256.0));
-        vec3 specular = (useSpecular) ?
-            specularStrength * spec * specularColor * lights[i].color * lights[i].intensity
-            : vec3(0.0);
-
-        result += (diffuse + specular);
-    }
-
-    result *= texColor;
-
-    if (isLight) {
-        vec3 emissive = vec3(1.0, 1.0, 1.0) * 10.0; // big intensity
-        FragColor = vec4(emissive, 1.0);
-        return;
-    }
-
-    FragColor = vec4(result, opacity);
-}

src/window/window.cpp

@@ -54,6 +54,7 @@ Window::Window(const char* title, int width, int height) {
 
     glEnable(GL_DEBUG_OUTPUT);
     glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
     glDebugMessageCallback(MessageCallback, nullptr);
 
     glViewport(0, 0, m_width, m_height);
@@ -103,8 +104,13 @@ void Window::ProcessEvents() {
                 if (event.key.scancode == SDL_SCANCODE_ESCAPE) {
                     Dispatch(WindowCloseRequested());
                 }
+                if (event.key.scancode == SDL_SCANCODE_F11) {
+                    bool isFullscreen = SDL_GetWindowFlags(m_handle) & SDL_WINDOW_FULLSCREEN;
+                    SDL_SetWindowFullscreen(m_handle, !isFullscreen);
+                }
                 break;
             case SDL_EVENT_WINDOW_RESIZED:
+            case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
                 int width, height;
                 if (SDL_GetWindowSizeInPixels(m_handle, &width, &height)) {
                     m_width = width;