feat: engine as library

engine/CMakeLists.txt

@@ -0,0 +1,89 @@
+add_library(${ENGINE_TARGET} STATIC
+  src/IO/parser.cpp
+  src/IO/file_manager.cpp
+
+  src/window/window.cpp
+
+  src/components/batch.cpp
+
+  src/renderer/debug.cpp
+  src/renderer/mesh.cpp
+  src/renderer/shader.cpp
+  src/renderer/texture.cpp
+  src/renderer/wavefront.cpp
+  src/renderer/engine.cpp
+  src/renderer/renderer.cpp
+
+  src/main.cpp
+)
+
+set_target_properties(${ENGINE_TARGET} PROPERTIES
+  CXX_STANDARD 17
+  CXX_STANDARD_REQUIRED ON
+  CXX_VISIBILITY_PRESET hidden
+  VISIBILITY_INLINES_HIDDEN YES
+)
+
+target_include_directories(${ENGINE_TARGET} PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/contrib
+)
+target_link_libraries(${ENGINE_TARGET} PUBLIC
+  SDL3::SDL3
+  OpenGL::GL
+  GLEW::GLEW
+  glm::glm
+  EnTT::EnTT
+)
+
+if (MSVC)
+  target_compile_options(${ENGINE_TARGET} PRIVATE $<$<CONFIG:Debug>:/Zi>)
+  target_link_options(${ENGINE_TARGET}    PRIVATE $<$<CONFIG:Debug>:/DEBUG:FULL>)
+else()
+  target_compile_options(${ENGINE_TARGET} PRIVATE $<$<CONFIG:Debug>:-ggdb>)
+endif()
+
+# Release flags
+if (MSVC)
+  # /O2: optimize speed, /GL: whole program opt (LTCG), /DNDEBUG: disable asserts
+  target_compile_options(${ENGINE_TARGET} PRIVATE
+    $<$<CONFIG:Release>:/O2>
+    $<$<CONFIG:Release>:/DNDEBUG>
+    $<$<CONFIG:RelWithDebInfo>:/O2>
+  )
+  # Link-time codegen & extra linker opts for smaller/faster binaries
+  target_link_options(${ENGINE_TARGET} PRIVATE
+    $<$<CONFIG:Release>:/LTCG /OPT:ICF /OPT:REF>
+    $<$<CONFIG:RelWithDebInfo>:/LTCG /OPT:ICF /OPT:REF>
+  )
+else()
+  # GCC/Clang
+  # -O3 for max opts, -ffast-math optional but can be risky; we keep it OFF by default.
+  option(CODINGGAME_USE_MARCH_NATIVE "Enable -march=native on Release for this machine" ON)
+  target_compile_options(${ENGINE_TARGET} PRIVATE
+    $<$<CONFIG:Release>:-O3>
+    $<$<AND:$<CONFIG:Release>,$<BOOL:${CODINGGAME_USE_MARCH_NATIVE}>>:-march=native>
+    $<$<CONFIG:Release>:-DNDEBUG>
+    $<$<CONFIG:RelWithDebInfo>:-O3 -g>
+  )
+  # Linker: enable LTO when available; optionally strip symbols on non-Apple
+  include(CheckIPOSupported)  # IPO == LTO in CMake terms
+  check_ipo_supported(RESULT ipo_supported OUTPUT ipo_msg)
+  if(ipo_supported)
+    set_property(TARGET ${ENGINE_TARGET} PROPERTY INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
+    set_property(TARGET ${ENGINE_TARGET} PROPERTY INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE)
+  endif()
+
+  if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT APPLE)
+    # -s strips symbols at link stage (use only for pure Release)
+    target_link_options(${ENGINE_TARGET} PRIVATE $<$<CONFIG:Release>:-s>)
+  endif()
+endif()
+
+# ---------- Windows: copy runtime DLLs ----------
+if (WIN32)
+  add_custom_command(TARGET ${ENGINE_TARGET} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+      $<TARGET_RUNTIME_DLLS:${ENGINE_TARGET}> $<TARGET_FILE_DIR:${ENGINE_TARGET}>
+    COMMAND_EXPAND_LISTS)
+endif()

engine/include/engine/IO/file_manager.h

@@ -0,0 +1,15 @@
+#ifndef FILE_MANAGER_H
+#define FILE_MANAGER_H
+
+#include <string>
+
+class FileManager
+{
+public:
+    FileManager();
+    ~FileManager();
+
+    static std::string read(const std::string &filename);
+};
+
+#endif // FILE_MANAGER_H

engine/include/engine/IO/parser.h

@@ -0,0 +1,20 @@
+#ifndef PARSER_H_
+#define PARSER_H_
+
+// Very fast OBJ/MTL line parser
+class Parser {
+private:
+    char* m_sv;
+public:
+    Parser(char* sv) : m_sv(sv) {}
+public:
+    void SkipSpaces();
+    char* TakeWord();
+    float TakeFloat();
+    int TakeInt();
+    bool TakeFaceIndices(int& vi, int& ti, int& ni);
+    char* TakeUntil(char d);
+    int TakeIndex(int baseCount);
+};
+
+#endif // PARSER_H_

engine/include/engine/app/app.h

@@ -0,0 +1,17 @@
+#ifndef APPLICATION_H_
+#define APPLICATION_H_
+
+class IApplication {
+public:
+    virtual ~IApplication() = default;
+
+    virtual void OnInit() {};
+    virtual void OnUpdate() {};
+    virtual void OnRender() {};
+    virtual void OnShutdown() {};
+    
+    virtual void OnEvent() {};
+    virtual void OnWindowResized(const WindowResized& e) {};
+};
+
+#endif // APPLICATION_H_

engine/include/engine/components/batch.h

@@ -0,0 +1,27 @@
+#ifndef COMPONENT_BATCH_H_
+#define COMPONENT_BATCH_H_
+
+#include "engine/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_

engine/include/engine/components/camera.h

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

engine/include/engine/components/light.h

@@ -0,0 +1,26 @@
+#ifndef COMPONENTS_LIGHT_H_
+#define COMPONENTS_LIGHT_H_
+
+#include <glm/glm.hpp>
+#include "engine/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_

engine/include/engine/components/mesh.h

@@ -0,0 +1,11 @@
+#ifndef COMPONENTS_MESH_H_
+#define COMPONENTS_MESH_H_
+
+#include <memory>
+#include "engine/renderer/wavefront.h"
+
+struct mesh {
+    std::shared_ptr<Object> object;
+};
+
+#endif // COMPONENTS_MESH_H_

engine/include/engine/components/rotate.h

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

engine/include/engine/components/transform.h

@@ -0,0 +1,12 @@
+#ifndef COMPONENTS_TRANSFORM_H_
+#define COMPONENTS_TRANSFORM_H_
+
+#include <glm/glm.hpp>
+
+struct transform {
+    glm::vec3 position;
+    glm::vec3 rotation;
+    glm::vec3 scale;
+};
+
+#endif // COMPONENTS_TRANSFORM_H_

engine/include/engine/renderer/basics.h

@@ -0,0 +1,21 @@
+#ifndef RENDERER_BASICS_H
+#define RENDERER_BASICS_H
+
+#include <glm/glm.hpp>
+
+#include "engine/renderer/mesh.h"
+
+class Vertex {
+    friend class Mesh;
+private:
+    glm::vec3 m_position;
+    glm::vec3 m_normal;
+    glm::vec2 m_texCoord;
+public:
+    Vertex(glm::vec3 position, glm::vec3 normal, glm::vec2 texCoord)
+        : m_position(position), m_normal(normal), m_texCoord(texCoord) {}
+public:
+    static void DefineAttrib();
+};
+
+#endif // RENDERER_BASICS_H

engine/include/engine/renderer/debug.h

@@ -0,0 +1,14 @@
+#ifndef RENDERER_DEBUG_
+#define RENDERER_DEBUG_
+
+#include <GL/glew.h>
+
+void MessageCallback(GLenum source,
+                     GLenum type,
+                     GLuint id,
+                     GLenum severity,
+                     GLsizei length,
+                     const GLchar* message,
+                     const void* userParam);
+
+#endif // RENDERER_DEBUG_

engine/include/engine/renderer/engine.h

@@ -0,0 +1,22 @@
+#ifndef ENGINE_H_
+#define ENGINE_H_
+
+#include <memory>
+#include <glm/glm.hpp>
+
+#include "engine/window/window.h"
+#include "engine/window/events/window.h"
+
+#include "engine/app/app.h"
+
+class Engine {
+public:
+    static void Run(std::unique_ptr<IApplication> app);
+private:
+    static std::unique_ptr<IApplication> s_app;
+    static std::shared_ptr<Window> s_window;
+    static bool s_running;
+};
+
+
+#endif // ENGINE_H_

engine/include/engine/renderer/material.h

@@ -0,0 +1,42 @@
+#ifndef MATERIAL_H_
+#define MATERIAL_H_
+
+#include <glm/glm.hpp>
+#include <memory>
+
+#include "engine/renderer/texture.h"
+
+class Material {
+private:
+    glm::vec3 m_ambient { 0.2f, 0.2f, 0.2f };
+    glm::vec3 m_diffuse { 0.8f, 0.8f, 0.8f };
+    glm::vec3 m_specular { 1.0f, 1.0f, 1.0f };
+    float m_shininess { 32.0f };
+    float m_opacity { 1.0f };
+    int m_illum { 2 };
+
+    std::unique_ptr<Texture> m_diffuse_tex { nullptr };
+public:
+    Material() = default;
+    Material(const Material& other) = default; // copy constructor
+    Material& operator=(const Material& other) = default;
+public:
+    inline const glm::vec3 GetAmbientColor() const { return m_ambient; }
+    inline const glm::vec3 GetDiffuseColor() const { return m_diffuse; }
+    inline const glm::vec3 GetSpecularColor() const { return m_specular; }
+    inline const float GetSpecularWeight() const { return m_shininess; }
+    inline const bool HasDiffuseTexture() const { return m_diffuse_tex != nullptr; }
+    inline const Texture* GetDiffuseTexture() const { return m_diffuse_tex.get(); }
+    inline const float GetOpacity() const { return m_opacity; }
+    inline const int GetIllumination() const { return m_illum; }
+public:
+    inline void SetAmbientColor(glm::vec3 ambient) { m_ambient = ambient; }
+    inline void SetDiffuseColor(glm::vec3 diffuse) { m_diffuse = diffuse; }
+    inline void SetSpecularColor(glm::vec3 specular) { m_specular = specular; }
+    inline void SetSpecularWeight(float weight) { m_shininess = weight; }
+    inline void SetDiffuseTexture(std::unique_ptr<Texture>&& texture) { m_diffuse_tex = std::move(texture); }
+    inline void SetOpacity(float opacity) { m_opacity = opacity; }
+    inline void SetIllumination(float illum) { m_illum = illum; }
+};
+
+#endif // MATERIAL_H_

engine/include/engine/renderer/mesh.h

@@ -0,0 +1,27 @@
+#ifndef MESH_H_
+#define MESH_H_
+
+#include <vector>
+#include <string>
+#include <GL/glew.h>
+
+#include "engine/renderer/basics.h"
+
+class Mesh {
+public: // TODO: abstract away
+    unsigned int m_vao, m_vbo, m_ebo;
+    std::vector<Vertex> m_vertexBuffer;
+    std::vector<unsigned int> m_indexBuffer;
+public: // TODO: abstract away
+    void Bind() const { glBindVertexArray(m_vao); }
+    void Unbind() { glBindVertexArray(0); }
+    void Upload() const;
+public:
+    std::string materialName;
+public:
+    Mesh();
+public:
+    void Render(unsigned int count);
+};
+
+#endif // MESH_H_

engine/include/engine/renderer/renderer.h

@@ -0,0 +1,37 @@
+#ifndef RENDERER_H_
+#define RENDERER_H_
+
+#include <glm/glm.hpp>
+#include <entt/entity/registry.hpp>
+
+#include "engine/renderer/shader.h"
+
+// TODO: make static or singleton
+class Renderer {
+public:
+    Renderer(entt::registry& registry);
+
+    void Render();
+    void Init();
+    void GenerateShadowMaps();
+
+    void OnWindowResized(int w, int h);
+private:
+    void ApplyLights(Shader &shader);
+    void UpdateView();
+    void RenderScene(Shader &shader);
+private:
+    Shader m_shader;
+    Shader m_depthShader;
+
+    entt::registry& m_registry;
+
+    // unsigned int m_depth_fbo;
+    // unsigned int m_depthMap;
+
+    glm::mat4 m_model;
+    glm::mat4 m_proj;
+    glm::mat4 m_view;
+};
+
+#endif // RENDERER_H_

engine/include/engine/renderer/shader.h

@@ -0,0 +1,46 @@
+#ifndef SHADER_H
+#define SHADER_H
+
+#include <string>
+
+#include <glm/glm.hpp>
+
+class Shader
+{
+public:
+    Shader();
+    ~Shader();
+
+    unsigned int m_id;
+
+    void init(const std::string &vertexCode, const std::string &fragmentCode);
+    void use();
+
+    void setBool(const std::string &name, bool value) const;
+    void setInt(const std::string &name, int value) const;
+    void setFloat(const std::string &name, float value) const;
+    void setVec2(const std::string &name, const glm::vec2 &value) const;
+    void setVec2(const std::string &name, float x, float y) const;
+    void setVec3(const std::string &name, const glm::vec3 &value) const;
+    void setVec3(const std::string &name, float x, float y, float z) const;
+    void setVec4(const std::string &name, const glm::vec4 &value) const;
+    void setVec4(const std::string &name, float x, float y, float z, float w) const;
+    void setMat2(const std::string &name, const glm::mat2 &mat) const;
+    void setMat3(const std::string &name, const glm::mat3 &mat) const;
+    void setMat4(const std::string &name, const glm::mat4 &mat) const;
+
+private:
+    unsigned int m_vertexId;
+    unsigned int m_fragmentId;
+
+    std::string m_vertexCode;
+    std::string m_fragmentCode;
+
+    void compile();
+    void link();
+
+    void checkCompileError(unsigned int shader, const std::string type);
+    void checkLinkingError();
+};
+
+#endif // SHADER_H

engine/include/engine/renderer/texture.h

@@ -0,0 +1,16 @@
+#ifndef TEXTURE_H_
+#define TEXTURE_H_
+#include <string>
+#include <memory>
+
+class Texture {
+public:
+    Texture() : m_id(0) {}
+    static std::unique_ptr<Texture> LoadFile(const std::string& filename);
+public:
+    [[nodiscard]] unsigned int GetID() const { return m_id; }
+private:
+    unsigned int m_id;
+};
+
+#endif // TEXTURE_H_

engine/include/engine/renderer/wavefront.h

@@ -0,0 +1,54 @@
+#ifndef MODEL_H_
+#define MODEL_H_
+#include <vector>
+#include <string>
+#include <filesystem>
+#include <unordered_map>
+#include <glm/glm.hpp>
+#include <memory>
+
+#include "engine/renderer/shader.h"
+#include "engine/renderer/renderer.h"
+#include "engine/renderer/material.h"
+#include "engine/renderer/mesh.h"
+
+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);
+
+private:
+    Object();
+public:
+    ~Object() = default;
+public:
+    static Object* LoadFile(const std::string& filename);
+
+private:
+    void LoadMaterials(const std::filesystem::path& filename);
+private:
+    void AddMaterial(std::string name, std::shared_ptr<Material> material);
+    std::shared_ptr<Material> GetMaterial(std::string name);
+private:
+    Mesh& GetLastMesh();
+    void CreateNewMesh(const std::string& materialName);
+public:
+    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;
+    std::vector<glm::vec3> m_normals;
+    std::vector<glm::vec2> m_texCoords;
+
+    std::vector<Mesh> m_meshes;
+
+    std::unordered_map<std::string, std::shared_ptr<Material>> m_materials;
+};
+
+#endif // MODEL_H_

engine/include/engine/window/event.h

@@ -0,0 +1,57 @@
+#ifndef EVENT_H_
+#define EVENT_H_
+
+#include <functional>
+#include <algorithm>
+#include <typeindex>
+#include <unordered_map>
+#include <vector>
+
+class EventDispatcher {
+    using Type = std::type_index;
+    using RawFn = std::function<void(const void*)>;
+
+    struct Slot { std::size_t id; RawFn fn; };
+
+    std::unordered_map<Type, std::vector<Slot>> subs_;
+    std::size_t next_id_ = 1;
+
+public:
+    struct Handle {
+        std::type_index type{typeid(void)};
+        std::size_t id{0};
+        explicit operator bool() const { return id != 0; }
+    };
+
+    template<class E, class F>
+    Handle Subscribe(F&& f) {
+        auto& vec = subs_[Type(typeid(E))];
+        Handle h{ Type(typeid(E)), next_id_++ };
+        // Wrap strongly typed callback into type-erased RawFn
+        RawFn wrapper = [fn = std::function<void(const E&)>(std::forward<F>(f))](const void* p){
+            fn(*static_cast<const E*>(p));
+        };
+        vec.push_back(Slot{h.id, std::move(wrapper)});
+        return h;
+    }
+
+    // Unsubscribe with handle
+    void Unsubscribe(const Handle& h) {
+        auto it = subs_.find(h.type);
+        if (it == subs_.end()) return;
+        auto& vec = it->second;
+        vec.erase(std::remove_if(vec.begin(), vec.end(),
+                  [&](const Slot& s){ return s.id == h.id; }),
+                  vec.end());
+    }
+
+    // Publish immediately
+    template<class E>
+    void Dispatch(const E& e) const {
+        auto it = subs_.find(Type(typeid(E)));
+        if (it == subs_.end()) return;
+        for (auto& slot : it->second) slot.fn(&e);
+    }
+};
+
+#endif // EVENT_H_

engine/include/engine/window/events/window.h

@@ -0,0 +1,7 @@
+#ifndef WINDOW_EVENTS_H_
+#define WINDOW_EVENTS_H_
+
+struct WindowResized { int w, h; };
+struct WindowCloseRequested {};
+
+#endif // WINDOW_EVENTS_H_

engine/include/engine/window/window.h

@@ -0,0 +1,51 @@
+#ifndef WINDOW_H_
+#define WINDOW_H_
+#include <SDL3/SDL.h>
+#include <memory>
+
+#include "engine/window/event.h"
+
+#define ENGINE_GL_MAJOR_VERSION 4
+#define ENGINE_GL_MINOR_VERSION 6
+#define ENGINE_GL_MULTISAMPLE_BUFFERS 1
+#define ENGINE_GL_MULTISAMPLE_SAMPLES 8
+
+#define DEFAULT_WIDTH 1024
+#define DEFAULT_HEIGHT 768
+
+class Window : public EventDispatcher {
+    friend class Engine;
+private:
+    Window();
+    Window(const char* title, int width, int height);
+    ~Window();
+
+    struct WindowDeleter {
+        void operator()(Window* w) const { delete w; };
+    };
+public:
+    static std::shared_ptr<Window> GetInstance();
+
+    Window(Window&& window) noexcept;
+    Window& operator=(Window&& window) noexcept;
+
+    Window(const Window& window) noexcept = delete;
+    Window& operator=(const Window& window) noexcept = delete;
+public:
+    [[nodiscard]] static inline int GetWidth() { return Window::GetInstance()->m_width; }
+    [[nodiscard]] static inline int GetHeight() { return Window::GetInstance()->m_height; }
+private:
+    void ProcessEvents();
+    void SwapBuffers() const;
+    void Destroy() const;
+private:
+    static std::shared_ptr<Window> s_instance;
+    
+    SDL_Window *m_handle;
+    SDL_GLContext m_context;
+
+    int m_width;
+    int m_height;
+};
+
+#endif //WINDOW_H_

engine/src/IO/file_manager.cpp

@@ -0,0 +1,33 @@
+#include "engine/IO/file_manager.h"
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+FileManager::FileManager()
+{
+}
+
+FileManager::~FileManager()
+{
+}
+
+std::string FileManager::read(const std::string &filename)
+{
+    std::ifstream file;
+    file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+
+    std::stringstream fileStream;
+    try
+    {
+        file.open(filename.c_str());
+        fileStream << file.rdbuf();
+        file.close();
+    }
+    catch (std::ifstream::failure e)
+    {
+        std::cout << "FileManager: error reading file: " << filename << std::endl;
+    }
+
+    return fileStream.str();
+}

engine/src/IO/parser.cpp

@@ -0,0 +1,123 @@
+#include <charconv>   // for std::from_chars (C++17+)
+#include <cstdlib>    // for strtof (fallback)
+#include <cstring>
+
+#include "engine/IO/parser.h"
+
+// Skip whitespace
+void Parser::SkipSpaces() {
+    while (*m_sv == ' ' || *m_sv == '\t') ++m_sv;
+}
+
+int Parser::TakeIndex(int baseCount) {
+    if (!m_sv || *m_sv == '\0') return -1;
+
+    bool neg = (*m_sv == '-');
+    if (neg) ++m_sv;
+
+    int idx = 0;
+    while (*m_sv >= '0' && *m_sv <= '9') {
+        idx = idx * 10 + (*m_sv - '0');
+        ++m_sv;
+    }
+
+    if (neg) return baseCount + (-idx);
+    return idx > 0 ? idx - 1 : -1;
+}
+
+// Get next whitespace-delimited word
+char* Parser::TakeWord() {
+    SkipSpaces();
+    if (*m_sv == '\0' || *m_sv == '\n' || *m_sv == '\r') return nullptr;
+
+    char* start = m_sv;
+    while (*m_sv && *m_sv != ' ' && *m_sv != '\t' && *m_sv != '\n' && *m_sv != '\r')
+        ++m_sv;
+
+    if (*m_sv) { *m_sv = '\0'; ++m_sv; }
+    return start;
+}
+
+// Parse a float quickly
+float Parser::TakeFloat() {
+    SkipSpaces();
+    if (*m_sv == '\0') return 0.0f;
+
+#if __cpp_lib_to_chars >= 201611L
+    float value = 0.0f;
+    auto result = std::from_chars(m_sv, m_sv + std::strlen(m_sv), value);
+    m_sv = const_cast<char*>(result.ptr);
+    return value;
+#else
+    char* end;
+    float value = std::strtof(m_sv, &end);
+    m_sv = end;
+    return value;
+#endif
+}
+
+// Parse an integer quickly
+int Parser::TakeInt() {
+    SkipSpaces();
+    if (*m_sv == '\0') return 0;
+
+#if __cpp_lib_to_chars >= 201611L
+    int value = 0;
+    auto result = std::from_chars(m_sv, m_sv + std::strlen(m_sv), value);
+    m_sv = const_cast<char*>(result.ptr);
+    return value;
+#else
+    char* end;
+    int value = static_cast<int>(std::strtol(m_sv, &end, 10));
+    m_sv = end;
+    return value;
+#endif
+}
+
+// Take everything until delimiter (mutates buffer)
+char* Parser::TakeUntil(char d) {
+    SkipSpaces();
+    if (*m_sv == '\0') return nullptr;
+
+    char* start = m_sv;
+    while (*m_sv && *m_sv != d && *m_sv != '\n' && *m_sv != '\r')
+        ++m_sv;
+
+    if (*m_sv) { *m_sv = '\0'; ++m_sv; }
+    return start;
+}
+
+// Parser.h (or Parser.cpp)
+// Parse one face element at current position.
+// Accepts formats: "v", "v/t", "v//n", "v/t/n"
+// Returns true if a token was parsed, false if no more tokens on the line.
+bool Parser::TakeFaceIndices(int &vi, int &ti, int &ni) {
+    SkipSpaces();
+    if (*m_sv == '\0' || *m_sv == '\n' || *m_sv == '\r') {
+        vi = ti = ni = 0; // sentinel raw value meaning "no token"
+        return false;
+    }
+
+    // parse vertex index (may be negative)
+    vi = static_cast<int>(std::strtol(m_sv, &m_sv, 10));
+
+    ti = ni = 0; // 0 = not present (raw)
+    if (*m_sv == '/') {
+        ++m_sv; // skip '/'
+        // texcoord index (optional)
+        if (*m_sv != '/' && *m_sv != ' ' && *m_sv != '\0' && *m_sv != '\n' && *m_sv != '\r') {
+            ti = static_cast<int>(std::strtol(m_sv, &m_sv, 10));
+        }
+        if (*m_sv == '/') {
+            ++m_sv; // skip second '/'
+            // normal index (optional)
+            if (*m_sv != ' ' && *m_sv != '\0' && *m_sv != '\n' && *m_sv != '\r') {
+                ni = static_cast<int>(std::strtol(m_sv, &m_sv, 10));
+            }
+        }
+    }
+
+    // At this point m_sv is either at whitespace, end, or next token char.
+    // Do NOT mutate indices (leave them raw). Let NormalizeIndex handle conversion.
+    return true;
+}

engine/src/components/batch.cpp

@@ -0,0 +1,19 @@
+#include <GL/glew.h>
+
+#include "engine/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);
+}

engine/src/main.cpp

@@ -0,0 +1,238 @@
+#ifndef WIN32
+#define GLEW_STATIC
+#endif
+
+#include <iostream>
+#include <memory>
+
+#ifdef WIN32
+#include <corecrt_math_defines.h>
+#endif
+#include <glm/glm.hpp>
+#include <glm/ext/matrix_clip_space.hpp>
+#include <glm/ext/matrix_transform.hpp>
+
+#include "engine/renderer/shader.h"
+#include "engine/renderer/wavefront.h"
+#include "engine/renderer/engine.h"
+#include "engine/renderer/renderer.h"
+
+#include "engine/IO/file_manager.h"
+
+#include "engine/components/transform.h"
+#include "engine/components/light.h"
+#include "engine/components/camera.h"
+#include "engine/components/mesh.h"
+#include "engine/components/rotate.h"
+#include "engine/components/batch.h"
+
+class Game : public IApplication {
+public:
+    Game() : m_renderer(m_registry) {
+        Object* lightObj = Object::LoadFile("./assets/sphere.obj");
+        const auto lght = m_registry.create();
+        m_registry.emplace<transform>(lght, glm::vec3(5.f, 5.f, 5.f), glm::vec3(0.f));
+        m_registry.emplace<light>(lght, light::LightType::DIRECTIONAL, glm::vec3(1.f, 1.f, 1.f), 1.5f);
+        m_registry.emplace<mesh>(lght, std::shared_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/wizard/wizard.obj");
+        const auto targetEntity = m_registry.create();
+        m_registry.emplace<transform>(targetEntity, glm::vec3(0.f, 0.0f, 0.f));
+        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::shared_ptr<Object>(floorObj));
+    }
+    ~Game() override {}
+
+    void OnInit() override {
+        std::cout << "Game initialized" << std::endl;
+
+        m_angle = 3.45f;
+        m_lastTicks = SDL_GetTicks();
+
+        m_paused = false;
+
+        m_yaw   = -90.0f; // looking along -Z initially
+        m_pitch = 0.0f;   // no vertical tilt
+
+        // FPS tracking
+        m_startTicks = SDL_GetTicks();
+        m_frameCount = 0;
+
+        m_renderer.Init();
+        m_renderer.GenerateShadowMaps();
+    }
+
+    void OnWindowResized(const WindowResized& event) override {
+        m_renderer.OnWindowResized(event.w, event.h);
+    }
+
+    void OnUpdate() override {
+        m_currentTicks = SDL_GetTicks();
+        float deltaTime = static_cast<float>(m_currentTicks - m_lastTicks) / 1000.0f; // seconds
+
+        m_lastTicks = m_currentTicks;
+
+        float mouseXRel, mouseYRel;
+        SDL_GetRelativeMouseState(&mouseXRel, &mouseYRel);
+
+        float sensitivity = 0.1f; // tweak as needed
+        m_yaw   += mouseXRel * sensitivity;
+        m_pitch -= mouseYRel * sensitivity; // invert Y for typical FPS control
+
+        // clamp pitch to avoid flipping
+        // if (pitch > 89.0f)  pitch = 89.0f;
+        // if (pitch < -89.0f) pitch = -89.0f;
+        m_pitch = glm::clamp(m_pitch, -89.0f, 89.0f);
+
+        // convert to direction vector
+        glm::vec3 cameraViewDirection(0.f, 0.f, -1.f);
+        cameraViewDirection.x = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
+        cameraViewDirection.y = sin(glm::radians(m_pitch));
+        cameraViewDirection.z = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
+        cameraViewDirection = glm::normalize(cameraViewDirection);
+
+        glm::vec3 velocity(0.f);
+
+        const bool* state = SDL_GetKeyboardState(nullptr);
+
+        if (state[SDL_SCANCODE_P]) m_paused = !m_paused;
+
+        glm::vec3 front = glm::normalize(glm::vec3(cameraViewDirection.x, 0.f, cameraViewDirection.z));
+        glm::vec3 right = glm::normalize(glm::cross(front, glm::vec3(0.f, 1.f, 0.f)));
+
+        if (state[SDL_SCANCODE_W]) velocity += front;
+        if (state[SDL_SCANCODE_S]) velocity -= front;
+        if (state[SDL_SCANCODE_A]) velocity -= right;
+        if (state[SDL_SCANCODE_D]) velocity += right;
+        if (state[SDL_SCANCODE_SPACE]) velocity.y += 1.f;
+        if (state[SDL_SCANCODE_LSHIFT]) velocity.y -= 1.f;
+
+        auto view = m_registry.view<camera, transform>();
+        for (auto [cam, camTransform] : view.each()) {
+            camTransform.position += velocity * deltaTime * 2.5f; // speed is e.g. 2.5f
+            camTransform.rotation = cameraViewDirection;
+        }
+
+        // update rotation
+        if (!m_paused) {
+            m_angle += glm::radians(45.0f) * deltaTime; // 72° per second
+            if (m_angle > glm::two_pi<float>()) {
+                m_angle -= glm::two_pi<float>(); // keep value small
+            }
+        }
+
+        // ---- Day-night simulation ----
+        m_dayTime += deltaTime;
+        if (m_dayTime > m_dayLength)
+            m_dayTime -= m_dayLength; // loop every "day"
+
+        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_frameCount++;
+        m_currentTicks = SDL_GetTicks();
+        Uint64 elapsed = m_currentTicks - m_startTicks;
+
+        if (elapsed >= 1000) { // one second passed
+            double fps = static_cast<double>(m_frameCount) / (static_cast<double>(elapsed) / 1000.0);
+            std::cout << "FPS: " << fps << std::endl;
+            m_frameCount = 0;
+            m_startTicks = m_currentTicks;
+        }
+    }
+private:
+    Renderer m_renderer;
+    entt::registry m_registry;
+
+    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
+    float m_pitch = 0.0f;   // no vertical tilt
+
+    // FPS tracking
+    Uint64 m_startTicks;
+    int m_frameCount;
+
+    Uint64 m_currentTicks;
+};
+
+int main() {
+    Engine::Run(std::make_unique<Game>());
+    return 0;
+}

engine/src/renderer/debug.cpp

@@ -0,0 +1,61 @@
+#include "engine/renderer/debug.h"
+
+#include <iostream>
+
+void MessageCallback(GLenum source,
+                     GLenum type,
+                     GLuint id,
+                     GLenum severity,
+                     GLsizei length,
+                     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;
+    (void) userParam;
+    std::cerr << "GL CALLBACK: " << (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : "")
+              << " type = 0x" << type
+              << ", severity = 0x" << severity
+              << ", message = " << message << std::endl;
+    // std::cerr << "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
+    //         (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""),
+    //         type, severity, message);
+}

engine/src/renderer/engine.cpp

@@ -0,0 +1,42 @@
+#include <memory>
+
+#include "engine/renderer/engine.h"
+#include "engine/window/event.h"
+
+#include "engine/renderer/wavefront.h"
+
+std::unique_ptr<IApplication> Engine::s_app = nullptr;
+std::shared_ptr<Window> Engine::s_window = nullptr;
+bool Engine::s_running = false;
+
+void Engine::Run(std::unique_ptr<IApplication> app) {
+    s_app = std::move(app);
+    s_window = Window::GetInstance();
+    s_running = true;
+
+    s_app->OnInit();
+
+    s_window->Subscribe<WindowCloseRequested>([](const WindowCloseRequested& e) {
+        Engine::s_running = false;
+    });
+
+    s_window->Subscribe<WindowResized>([](const WindowResized& e) {
+        Engine::s_app->OnWindowResized(e);
+    });
+
+    while (s_running) {
+        s_window->ProcessEvents();
+
+        s_app->OnUpdate();
+
+        s_app->OnRender();
+
+        s_window->SwapBuffers();
+    }
+
+    s_app->OnShutdown();
+
+    s_window->Destroy();
+    s_app.reset();
+}
+

engine/src/renderer/mesh.cpp

@@ -0,0 +1,60 @@
+#include <cstddef>
+
+#include "engine/renderer/mesh.h"
+
+Mesh::Mesh() {
+    m_vao = 0;
+    m_vbo = 0;
+    m_ebo = 0;
+    
+    glGenVertexArrays(1, &m_vao);
+    glGenBuffers(1, &m_vbo);
+    glGenBuffers(1, &m_ebo);
+
+    glBindVertexArray(m_vao);
+
+    // VBO (vertex buffer)
+    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
+    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_DYNAMIC_DRAW);
+
+    // 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);
+}
+
+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_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_DYNAMIC_DRAW);
+
+    glBindVertexArray(0);
+}
+
+void Mesh::Render(unsigned int count)
+{
+    Bind();
+    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();
+}

engine/src/renderer/renderer.cpp

@@ -0,0 +1,246 @@
+#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 "engine/renderer/renderer.h"
+#include "engine/window/window.h"
+#include "engine/IO/file_manager.h"
+
+#include "engine/components/transform.h"
+#include "engine/components/camera.h"
+#include "engine/components/light.h"
+#include "engine/components/mesh.h"
+#include "engine/components/batch.h"
+
+Renderer::Renderer(entt::registry& registry) : m_registry(registry)
+{
+    m_proj = glm::perspective(
+        static_cast<float>(M_PI_2),
+        static_cast<float>(Window::GetWidth()) / static_cast<float>(Window::GetHeight()),
+        0.01f,
+        100.0f
+    );
+
+    m_shader.init(
+        FileManager::read("./src/shaders/main.vs"),
+        FileManager::read("./src/shaders/pbr.fs")
+    );
+
+    m_depthShader.init(
+        FileManager::read("./src/shaders/depth.vs"),
+        FileManager::read("./src/shaders/depth.fs")
+    );
+
+    m_model = glm::mat4(1.f);
+
+    m_shader.use();
+    m_shader.setMat4("u_projection", m_proj);
+}
+
+void Renderer::Init() {
+    // auto view = m_registry.view<batch, mesh>();
+    // 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) {
+    m_proj = glm::perspective(
+        static_cast<float>(M_PI_2),
+        static_cast<float>(w) / static_cast<float>(h),
+        0.01f,
+        100.0f
+    );
+}
+
+void Renderer::ApplyLights(Shader &shader) {
+    auto lights = m_registry.view<light>();
+    // TODO: Pass Lights Data to depth shader as well
+    shader.setInt("lightsCount", static_cast<int>(lights.size()));
+    size_t lightIndex = 0;
+    for (auto entity : lights) {
+        auto &l = m_registry.get<light>(entity);
+        auto &transf = m_registry.get<transform>(entity);
+        
+        shader.setInt("lights[" + std::to_string(lightIndex) + "].type", static_cast<int>(l.type));
+        shader.setVec3("lights[" + std::to_string(lightIndex) + "].position", transf.position);
+        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() {
+    auto cam = m_registry.view<transform, camera>().back();
+    auto camTransform = m_registry.get<transform>(cam);
+
+    m_view = glm::lookAt(
+        camTransform.position,
+        camTransform.position + camTransform.rotation,
+        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(Shader &shader) {
+    std::unordered_map<unsigned int, std::vector<entt::entity>> batches;
+
+    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 (m_registry.all_of<light>(entity)) {
+            auto &l = m_registry.get<light>(entity);
+            shader.setBool("isLight", true);
+            shader.setVec3("currentLightColor", l.color);
+        } else {
+            shader.setBool("isLight", false);
+            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;
+
+        shader.setMat4("u_model", m_model);
+
+        mesh.object->Render(shader, 1);
+    }
+}
+
+void Renderer::GenerateShadowMaps() {
+    const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
+
+    m_depthShader.use();
+
+    auto lights = m_registry.view<light>();
+
+    for (auto [lEntt, l] : lights.each()) {
+        // TODO: support other light types when ready
+        if (l.type != light::LightType::DIRECTIONAL) return;
+
+        glGenFramebuffers(1, &l.fbo);
+        glGenTextures(1, &l.shadowMap);
+        glBindTexture(GL_TEXTURE_2D, l.shadowMap);
+        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); 
+        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() {
+    const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
+
+    m_depthShader.use();
+
+    auto lights = m_registry.view<light, transform>();
+
+    for (auto [lEntt, l, t] : lights.each()) {
+        // TODO: support other light types when ready
+        if (l.type != light::LightType::DIRECTIONAL) return;
+
+        glClearColor(0x18/255.0f, 0x18/255.0f, 0x18/255.0f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        float near_plane = 0.1f, far_plane = 50.0f;
+        glm::vec3 target   = glm::vec3(0.0f, 0.5f, 0.0f);
+        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;
+
+        m_depthShader.setMat4("u_lightSpace", lightSpaceMatrix);
+        l.lightSpace = lightSpaceMatrix;
+
+        glCullFace(GL_FRONT);
+        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);
+    
+    m_shader.use();
+
+    ApplyLights(m_shader);
+    UpdateView();
+
+    RenderScene(m_shader);
+}

engine/src/renderer/shader.cpp

@@ -0,0 +1,135 @@
+#include <iostream>
+#include <GL/glew.h>
+#include "engine/renderer/shader.h"
+
+Shader::Shader()
+{
+}
+
+Shader::~Shader()
+{
+}
+
+void Shader::init(const std::string &vertexCode, const std::string &fragmentCode)
+{
+    m_vertexCode = vertexCode;
+    m_fragmentCode = fragmentCode;
+    compile();
+    link();
+}
+
+void Shader::use()
+{
+    glUseProgram(m_id);
+}
+
+void Shader::setBool(const std::string &name, bool value) const
+{
+    glUniform1i(glGetUniformLocation(m_id, name.c_str()), (int)value);
+}
+
+void Shader::setInt(const std::string &name, int value) const
+{
+    glUniform1i(glGetUniformLocation(m_id, name.c_str()), value);
+}
+
+void Shader::setFloat(const std::string &name, float value) const
+{
+    glUniform1f(glGetUniformLocation(m_id, name.c_str()), value);
+}
+
+void Shader::setVec2(const std::string &name, const glm::vec2 &value) const
+{
+    glUniform2fv(glGetUniformLocation(m_id, name.c_str()), 1, &value[0]);
+}
+void Shader::setVec2(const std::string &name, float x, float y) const
+{
+    glUniform2f(glGetUniformLocation(m_id, name.c_str()), x, y);
+}
+
+void Shader::setVec3(const std::string &name, const glm::vec3 &value) const
+{
+    glUniform3fv(glGetUniformLocation(m_id, name.c_str()), 1, &value[0]);
+}
+void Shader::setVec3(const std::string &name, float x, float y, float z) const
+{
+    glUniform3f(glGetUniformLocation(m_id, name.c_str()), x, y, z);
+}
+
+void Shader::setVec4(const std::string &name, const glm::vec4 &value) const
+{
+    glUniform4fv(glGetUniformLocation(m_id, name.c_str()), 1, &value[0]);
+}
+void Shader::setVec4(const std::string &name, float x, float y, float z, float w) const
+{
+    glUniform4f(glGetUniformLocation(m_id, name.c_str()), x, y, z, w);
+}
+
+void Shader::setMat2(const std::string &name, const glm::mat2 &mat) const
+{
+    glUniformMatrix2fv(glGetUniformLocation(m_id, name.c_str()), 1, GL_FALSE, &mat[0][0]);
+}
+
+void Shader::setMat3(const std::string &name, const glm::mat3 &mat) const
+{
+    glUniformMatrix3fv(glGetUniformLocation(m_id, name.c_str()), 1, GL_FALSE, &mat[0][0]);
+}
+
+void Shader::setMat4(const std::string &name, const glm::mat4 &mat) const
+{
+    glUniformMatrix4fv(glGetUniformLocation(m_id, name.c_str()), 1, GL_FALSE, &mat[0][0]);
+}
+
+void Shader::compile()
+{
+    const char *vsCode = m_vertexCode.c_str();
+    m_vertexId = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(m_vertexId, 1, &vsCode, NULL);
+    glCompileShader(m_vertexId);
+    checkCompileError(m_vertexId, "Vertex Shader");
+
+    const char *fsCode = m_fragmentCode.c_str();
+    m_fragmentId = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(m_fragmentId, 1, &fsCode, NULL);
+    glCompileShader(m_fragmentId);
+    checkCompileError(m_fragmentId, "Fragment Shader");
+}
+
+void Shader::link()
+{
+    m_id = glCreateProgram();
+    glAttachShader(m_id, m_vertexId);
+    glAttachShader(m_id, m_fragmentId);
+    glLinkProgram(m_id);
+    checkLinkingError();
+    glDeleteShader(m_vertexId);
+    glDeleteShader(m_fragmentId);
+}
+
+void Shader::checkCompileError(unsigned int shader, const std::string type)
+{
+    int success;
+    char infoLog[1024];
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+    if (!success)
+    {
+        glGetShaderInfoLog(shader, 1024, NULL, infoLog);
+        std::cout << "Shader: Error compiling " << type << ":" << std::endl
+                  << infoLog
+                  << std::endl;
+    }
+}
+
+void Shader::checkLinkingError()
+{
+    int success;
+    char infoLog[1024];
+    glGetProgramiv(m_id, GL_LINK_STATUS, &success);
+    if (!success)
+    {
+        glGetProgramInfoLog(m_id, 1024, NULL, infoLog);
+        std::cout << "Shader: Error linking shader program: " << std::endl
+                  << infoLog
+                  << std::endl;
+    }
+}

engine/src/renderer/texture.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+#include <memory>
+
+#include <GL/glew.h>
+#include "engine/renderer/texture.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+std::unique_ptr<Texture> Texture::LoadFile(const std::string& filename) {
+    auto texture = std::make_unique<Texture>();
+
+    int w, h, c;
+    unsigned char *data = stbi_load(filename.c_str(), &w, &h, &c, 4);
+    if (!data) {
+        std::cerr << "ERROR: Failed to load texture under '" << filename << "'" << std::endl;
+        std::exit(1);
+    }
+
+    glGenTextures(1, &texture.get()->m_id);
+    glBindTexture(GL_TEXTURE_2D, texture.get()->m_id);
+
+    // TODO: configure properly
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+    glGenerateMipmap(GL_TEXTURE_2D);
+
+    std::cout << "Loaded texture under '" << filename << "' with size of " << sizeof(data) << " bytes" << std::endl;
+    stbi_image_free(data);
+
+    return std::move(texture);
+}

engine/src/renderer/wavefront.cpp

@@ -0,0 +1,509 @@
+#include <iostream>
+#include <fstream>
+#include <cstring>
+#include <memory>
+#include <filesystem>
+#include <GL/glew.h>
+
+#include "engine/IO/parser.h"
+#include "engine/renderer/mesh.h"
+#include "engine/renderer/wavefront.h"
+
+#define DEFAULT_MATERIAL_NAME "default"
+
+// ObjElement toElement(const std::string &s) {
+//     if (s == "#") return ObjElement::OHASH;
+//     if (s == "mtllib") return ObjElement::MTLLIB;
+//     if (s == "usemtl") return ObjElement::USEMTL;
+//     if (s == "o") return ObjElement::O;
+//     if (s == "v") return ObjElement::V;
+//     if (s == "vn") return ObjElement::VN;
+//     if (s == "vt") return ObjElement::VT;
+//     if (s == "f") return ObjElement::F;
+//     return ObjElement::OUNKNOWN;
+// }
+
+inline ObjElement toElement(const char* s) {
+    switch (s[0]) {
+        case '#': return ObjElement::OHASH;
+        case 'm': if (strcmp(s, "mtllib") == 0) return ObjElement::MTLLIB; break;
+        case 'u': if (strcmp(s, "usemtl") == 0) return ObjElement::USEMTL; break;
+        case 'o': if (s[1] == '\0') return ObjElement::O; break;
+        case 'v':
+            if (s[1] == '\0') return ObjElement::V;
+            if (s[1] == 'n' && s[2] == '\0') return ObjElement::VN;
+            if (s[1] == 't' && s[2] == '\0') return ObjElement::VT;
+            break;
+        case 'f': if (s[1] == '\0') return ObjElement::F; break;
+    }
+    return ObjElement::OUNKNOWN;
+}
+
+// MtlElement toMtlElement(const std::string &s) {
+//     if (s == "#") return MtlElement::MHASH;
+//     if (s == "newmtl") return MtlElement::NEWMTL;
+//     if (s == "Ns") return MtlElement::NS;
+//     if (s == "Ka") return MtlElement::KA;
+//     if (s == "Ks") return MtlElement::KS;
+//     if (s == "Kd") return MtlElement::KD;
+//     if (s == "Ni") return MtlElement::NI;
+//     if (s == "d") return MtlElement::D;
+//     if (s == "illum") return MtlElement::ILLUM;
+//     if (s == "map_Kd") return MtlElement::MAP_KD;
+//     if (s == "map_Ka") return MtlElement::MAP_KA;
+//     // if (s == "map_Ke") return MtlElement::MAP_KE;
+//     return MtlElement::MUNKNOWN;
+// }
+
+inline MtlElement toMtlElement(const char* s) {
+    switch (s[0]) {
+        case '#': return MtlElement::MHASH;
+        case 'n':
+            if (strcmp(s, "newmtl") == 0) return MtlElement::NEWMTL;
+            break;
+        case 'N':
+            if (s[1] == 's' && s[2] == '\0') return MtlElement::NS;
+            if (s[1] == 'i' && s[2] == '\0') return MtlElement::NI;
+            break;
+        case 'K':
+            if (s[1] == 'a' && s[2] == '\0') return MtlElement::KA;
+            if (s[1] == 's' && s[2] == '\0') return MtlElement::KS;
+            if (s[1] == 'd' && s[2] == '\0') return MtlElement::KD;
+            break;
+        case 'd':
+            if (s[1] == '\0') return MtlElement::D;
+            break;
+        case 'i':
+            if (strcmp(s, "illum") == 0) return MtlElement::ILLUM;
+            break;
+        case 'm':
+            if (strcmp(s, "map_Kd") == 0) return MtlElement::MAP_KD;
+            if (strcmp(s, "map_Ka") == 0) return MtlElement::MAP_KA;
+            // if (strcmp(s, "map_Ke") == 0) return MtlElement::MAP_KE;
+            break;
+    }
+    return MtlElement::MUNKNOWN;
+}
+
+inline int Object::NormalizeIndex(int idx, int baseCount) {
+    // idx is the raw value returned by parser:
+    //  0 -> means "not present" or invalid in our convention
+    // >0 -> 1-based index -> convert to 0-based
+    // <0 -> negative index -> relative to baseCount: baseCount + idx
+    if (idx == 0) return -1;          // absent / invalid
+    if (idx > 0) return idx - 1;      // 1-based -> 0-based
+    return baseCount + idx;           // negative -> count from end
+}
+
+Object::Object() {
+    m_vertices = std::vector<glm::vec3>();
+    m_normals = std::vector<glm::vec3>();
+    m_texCoords = std::vector<glm::vec2>();
+}
+
+void Object::LoadMaterials(const std::filesystem::path& filename) {
+    std::ifstream file(filename);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open MTL file: " << filename << std::endl;
+        return;
+    }
+
+    std::string currentMaterialName;
+    std::shared_ptr<Material> currentMaterial;
+
+    char line[1024]; // buffer per line
+
+    while (file.getline(line, sizeof(line))) {
+        Parser p(line);
+        char* prefix = p.TakeWord();
+        if (!prefix) continue;
+
+        switch (toMtlElement(prefix)) {
+        case MtlElement::MHASH: // comment
+            continue;
+
+        case MtlElement::NEWMTL:
+        {
+            // If a material was being built, commit it first
+            if (currentMaterial) {
+                AddMaterial(currentMaterialName, std::move(currentMaterial));
+                currentMaterial = nullptr;
+            }
+
+            char* materialName = p.TakeWord();
+            if (materialName) {
+                currentMaterialName = materialName;
+                currentMaterial = std::make_shared<Material>();
+            }
+            break;
+        }
+
+        case MtlElement::NS: // specular weight
+        {
+            float weight = p.TakeFloat();
+            if (currentMaterial) currentMaterial->SetSpecularWeight(weight);
+            break;
+        }
+
+        case MtlElement::KA: // ambient color
+        {
+            float r = p.TakeFloat();
+            float g = p.TakeFloat();
+            float b = p.TakeFloat();
+            if (currentMaterial) currentMaterial->SetAmbientColor(glm::vec3(r, g, b));
+            break;
+        }
+
+        case MtlElement::KS: // specular color
+        {
+            float r = p.TakeFloat();
+            float g = p.TakeFloat();
+            float b = p.TakeFloat();
+            if (currentMaterial) currentMaterial->SetSpecularColor(glm::vec3(r, g, b));
+            break;
+        }
+
+        case MtlElement::KD: // diffuse color
+        {
+            float r = p.TakeFloat();
+            float g = p.TakeFloat();
+            float b = p.TakeFloat();
+            if (currentMaterial) currentMaterial->SetDiffuseColor(glm::vec3(r, g, b));
+            break;
+        }
+
+        case MtlElement::D: // opacity
+        {
+            float d = p.TakeFloat();
+            if (currentMaterial) currentMaterial->SetOpacity(d);
+            break;
+        }
+
+        case MtlElement::ILLUM: // illumination model
+        {
+            int illum = p.TakeInt();
+            if (currentMaterial) currentMaterial->SetIllumination(illum);
+            break;
+        }
+
+        case MtlElement::MAP_KD: // diffuse texture map
+        {
+            // take rest of line as texture path (can contain spaces)
+            char* texPath = p.TakeUntil('\0');
+            if (texPath && currentMaterial) {
+                // trim trailing spaces
+                size_t len = std::strlen(texPath);
+                while (len > 0 && (texPath[len - 1] == ' ' || texPath[len - 1] == '\t'))
+                    texPath[--len] = '\0';
+
+                currentMaterial->SetDiffuseTexture(Texture::LoadFile(texPath));
+            }
+            break;
+        }
+
+        case MtlElement::MAP_KA: // ambient texture map
+        {
+            char* texPath = p.TakeUntil('\0');
+            if (texPath && currentMaterial) {
+                size_t len = std::strlen(texPath);
+                while (len > 0 && (texPath[len - 1] == ' ' || texPath[len - 1] == '\t'))
+                    texPath[--len] = '\0';
+
+                // optional: handle ambient texture
+                // currentMaterial->SetAmbientTexture(Texture::LoadFile(texPath));
+            }
+            break;
+        }
+
+        default:
+            // ignore unknown tokens
+            break;
+        }
+    }
+
+    // Commit last material if pending
+    if (currentMaterial) {
+        AddMaterial(currentMaterialName, std::move(currentMaterial));
+    }
+
+    file.close();
+}
+
+void Object::AddMaterial(std::string name, std::shared_ptr<Material> material)
+{
+    m_materials.insert(std::make_pair(std::move(name), std::move(material)));
+}
+
+std::shared_ptr<Material> Object::GetMaterial(std::string name)
+{
+    auto material = m_materials.find(name);
+    if (material == m_materials.end()) return nullptr;
+    return material->second;
+}
+
+void Object::CreateNewMesh(const std::string& materialName)
+{
+    Mesh mesh;
+    mesh.materialName = materialName;
+    m_meshes.push_back(mesh);
+}
+
+Mesh& Object::GetLastMesh()
+{
+    if (m_meshes.empty()) {
+        auto material = std::make_shared<Material>();
+        material->SetAmbientColor(glm::vec3(0.52f, 0.52f, 0.52f));
+        AddMaterial(DEFAULT_MATERIAL_NAME, std::move(material));
+        CreateNewMesh(DEFAULT_MATERIAL_NAME);
+    }
+    return m_meshes.back();
+}
+
+Object* Object::LoadFile(const std::string& filename) {
+    std::ifstream file(filename);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open OBJ file: " << filename << std::endl;
+        return {};
+    }
+
+    Object* obj = new Object();
+    char line[1024]; // static buffer for each line (enough for OBJ lines)
+
+    while (file.getline(line, sizeof(line))) {
+        Parser p(line);
+        char* prefix = p.TakeWord();
+        if (!prefix) continue;
+
+        switch (toElement(prefix)) {
+        case ObjElement::OHASH: // comment
+            continue;
+
+        case ObjElement::MTLLIB:
+        {
+            char* mtlFile = p.TakeWord();
+            if (mtlFile) {
+                std::filesystem::path fullPath = filename;
+                std::filesystem::path mtlPath = fullPath.replace_filename(mtlFile);
+                obj->LoadMaterials(mtlPath);
+            }
+            break;
+        }
+
+        case ObjElement::USEMTL:
+        {
+            char* materialName = p.TakeWord();
+            if (materialName) {
+                auto& mesh = obj->GetLastMesh();
+                if (mesh.materialName != materialName) {
+                    Mesh newMesh;
+                    newMesh.materialName = materialName;
+                    obj->m_meshes.push_back(newMesh);
+                }
+            }
+            break;
+        }
+
+        case ObjElement::O: // object name
+        {
+            char* name = p.TakeWord();
+            if (name) obj->m_name = name;
+            break;
+        }
+
+        case ObjElement::V: // vertex
+        {
+            float x = p.TakeFloat();
+            float y = p.TakeFloat();
+            float z = p.TakeFloat();
+            float w = p.TakeFloat();
+
+            if (w != 0.0f && w != 1.0f) {
+                x /= w; y /= w; z /= w;
+            }
+            obj->m_vertices.emplace_back(x, y, z);
+            break;
+        }
+
+        case ObjElement::VN: // normal
+        {
+            float x = p.TakeFloat();
+            float y = p.TakeFloat();
+            float z = p.TakeFloat();
+            obj->m_normals.emplace_back(x, y, z);
+            break;
+        }
+
+        case ObjElement::VT: // texcoord
+        {
+            float u = p.TakeFloat();
+            float v = p.TakeFloat();
+            obj->m_texCoords.emplace_back(u, 1.0f - v);
+            break;
+        }
+
+        case ObjElement::F: // face
+        {
+            auto& mesh = obj->GetLastMesh();
+            int raw_vi, raw_ti, raw_ni;
+
+            while (p.TakeFaceIndices(raw_vi, raw_ti, raw_ni)) {
+                // Convert raw OBJ indices to 0-based / -1 sentinel
+                int vi = Object::NormalizeIndex(raw_vi, (int)obj->m_vertices.size());
+                int ti = Object::NormalizeIndex(raw_ti, (int)obj->m_texCoords.size());
+                int ni = Object::NormalizeIndex(raw_ni, (int)obj->m_normals.size());
+
+                if (vi < 0) {
+                    // malformed token (no vertex) — skip
+                    continue;
+                }
+
+                glm::vec3 vert = obj->m_vertices[vi];
+                glm::vec3 norm(0.0f);
+                glm::vec2 texCoord(0.0f);
+
+                if (ni >= 0) norm = obj->m_normals[ni];
+                if (ti >= 0) texCoord = obj->m_texCoords[ti];
+
+                mesh.m_vertexBuffer.emplace_back(vert, norm, texCoord);
+                mesh.m_indexBuffer.push_back(mesh.m_vertexBuffer.size() - 1);
+            }
+            break;
+        }
+
+        default:
+            // ignore unknown tokens
+            break;
+        }
+    }
+
+    std::cout << "Object name: " << obj->m_name << std::endl;
+    std::cout << "Vertices count: " << obj->m_vertices.size() << std::endl;
+    std::cout << "Normals count: " << obj->m_normals.size() << std::endl;
+    std::cout << "TexCoords count: " << obj->m_texCoords.size() << std::endl;
+    std::cout << "Meshes count: " << obj->m_meshes.size() << std::endl;
+    std::cout << "Materials count: " << obj->m_materials.size() << std::endl;
+
+    file.close();
+
+    for (auto &mesh : obj->m_meshes) {
+        mesh.Upload();
+    }
+
+    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)
+// {
+//     for (auto &mesh : m_meshes) {
+//         auto material = GetMaterial(mesh.materialName);
+        
+//         shader.setFloat("ambientStrength", 0.2f);
+//         shader.setFloat("shininess", material->GetSpecularWeight());
+//         shader.setFloat("opacity", material->GetOpacity());
+//         shader.setBool("useSpecular", material->GetIllumination() >= 2);
+//         shader.setFloat("specularStrength", 1.0f);
+//         shader.setVec3("ambientColor", material->GetAmbientColor());
+//         shader.setVec3("diffuseColor", material->GetDiffuseColor());
+//         shader.setVec3("specularColor", material->GetSpecularColor());
+
+//         if (material->HasDiffuseTexture()) {
+//             shader.setBool("useTexture", true);
+//             glActiveTexture(GL_TEXTURE0);
+//             glBindTexture(GL_TEXTURE_2D, material->GetDiffuseTexture()->GetID());
+//             shader.setInt("diffuseTex", 0);
+//         } else {
+//             shader.setBool("useTexture", false);
+//         }
+
+//         mesh.Render();
+//     }
+// }
+
+void Object::Render(Shader& shader, unsigned int count)
+{
+    for (auto &mesh : m_meshes)
+    {
+        auto material = GetMaterial(mesh.materialName);
+
+        // --- Basic material properties ---
+        shader.setFloat("opacity", material->GetOpacity());
+
+        // Albedo (base color)
+        shader.setVec3("albedo", material->GetDiffuseColor());
+
+        // Metallic and roughness (defaults)
+        shader.setFloat("metallic", 0.8f);
+        shader.setFloat("roughness", 0.5f);
+        shader.setFloat("ao", 1.0f); // default ambient occlusion if none
+
+        // --- Optional textures ---
+        int texUnit = 0;
+
+        // Albedo texture
+        if (material->HasDiffuseTexture()) {
+            shader.setBool("useAlbedoMap", true);
+            glActiveTexture(GL_TEXTURE0 + texUnit);
+            glBindTexture(GL_TEXTURE_2D, material->GetDiffuseTexture()->GetID());
+            shader.setInt("albedoTex", texUnit++);
+        } else {
+            shader.setBool("useAlbedoMap", false);
+        }
+
+        // Metallic texture
+        // if (material->HasMetallicTexture()) {
+        if (false) {
+            shader.setBool("useMetallicMap", true);
+            glActiveTexture(GL_TEXTURE0 + texUnit);
+            // glBindTexture(GL_TEXTURE_2D, material->GetMetallicTexture()->GetID());
+            shader.setInt("metallicTex", texUnit++);
+        } else {
+            shader.setBool("useMetallicMap", false);
+        }
+
+        // Roughness texture
+        // if (material->HasRoughnessTexture()) {
+        if (false) {
+            shader.setBool("useRoughnessMap", true);
+            glActiveTexture(GL_TEXTURE0 + texUnit);
+            // glBindTexture(GL_TEXTURE_2D, material->GetRoughnessTexture()->GetID());
+            shader.setInt("roughnessTex", texUnit++);
+        } else {
+            shader.setBool("useRoughnessMap", false);
+        }
+
+        // AO texture
+        // if (material->HasAoTexture()) {
+        if (false) {
+            shader.setBool("useAoMap", true);
+            glActiveTexture(GL_TEXTURE0 + texUnit);
+            // glBindTexture(GL_TEXTURE_2D, material->GetAoTexture()->GetID());
+            shader.setInt("aoTex", texUnit++);
+        } else {
+            shader.setBool("useAoMap", false);
+        }
+
+        // --- Render mesh ---
+        mesh.Render(count);
+    }
+}
+
+

engine/src/shaders/depth.fs

@@ -0,0 +1,6 @@
+#version 410 core
+
+void main()
+{
+    // gl_FragDepth = gl_FragCoord.z;
+}

engine/src/shaders/depth.vs

@@ -0,0 +1,13 @@
+#version 410 core
+
+// Input vertex attributes
+layout (location = 0) in vec3 position;  // Vertex position in local space (model space)
+
+// Uniforms for transformation matrices
+uniform mat4 u_model;       // Model matrix: transforms from local space to world space
+uniform mat4 u_lightSpace;
+
+void main()
+{
+    gl_Position = u_lightSpace * u_model * vec4(position, 1.0);
+}

engine/src/shaders/main.vs

@@ -0,0 +1,36 @@
+#version 460 core
+
+// Input vertex attributes
+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;
+out vec3 vertexNormal;
+out vec2 TexCoords;
+out vec4 fragPosLightSpace;
+
+// Uniforms for transformation matrices
+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 bool u_isInstanced;
+
+void main()
+{
+    mat4 model = u_isInstanced ? instanceModel : 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);
+
+    gl_Position = u_projection * u_view * vec4(vertexPos, 1.0);
+}

engine/src/shaders/pbr.fs

@@ -0,0 +1,203 @@
+#version 410 core
+out vec4 FragColor;
+
+in vec3 vertexPos;    // must be world-space position
+in vec3 vertexNormal;
+in vec2 TexCoords;
+
+uniform vec3 viewPos;
+
+// Lights
+struct Light {
+    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;
+uniform Light lights[MAX_LIGHTS];
+
+uniform bool isLight;
+uniform vec3 currentLightColor;
+
+// Material parameters
+uniform vec3 albedo;
+uniform float metallic;
+uniform float roughness;
+uniform float ao;
+
+uniform sampler2D albedoTex;
+uniform sampler2D metallicTex;
+uniform sampler2D roughnessTex;
+uniform sampler2D aoTex;
+uniform bool useAlbedoMap;
+uniform bool useMetallicMap;
+uniform bool useRoughnessMap;
+uniform bool useAoMap;
+
+uniform float opacity;
+
+#define PI 3.14159265359
+#define LIGHT_COLOR vec3(1.0, 1.0, 1.0)
+
+// -------------------------------------------------------------
+// Improved ShadowCalculation: returns [0,1] shadow factor (1 = fully in shadow)
+float ShadowCalculation(sampler2D shadowMap, mat4 lightSpace, vec3 N, vec3 L)
+{
+    // 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 the light's orthographic frustum (xy outside or z > 1), consider unshadowed
+    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;
+    }
+
+    float currentDepth = projCoords.z;
+    // basic bias (slope-dependent)
+    float bias = max(0.001 * (1.0 - dot(N, L)), 0.0005);
+
+    // PCF (3x3)
+    float shadow = 0.0;
+    vec2 texelSize = 1.0 / textureSize(shadowMap, 0);
+    for (int x = -1; x <= 1; ++x) {
+        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 /= 9.0;
+
+    // clamp to [0,1]
+    shadow = clamp(shadow, 0.0, 1.0);
+    return shadow;
+}
+
+// ----------------------------------------------------------------------------
+// PBR helpers (unchanged)
+float DistributionGGX(vec3 N, vec3 H, float roughness)
+{
+    float a      = roughness * roughness;
+    float a2     = a * a;
+    float NdotH  = max(dot(N, H), 0.0);
+    float NdotH2 = NdotH * NdotH;
+
+    float num   = a2;
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+
+    return num / denom;
+}
+
+float GeometrySchlickGGX(float NdotV, float roughness)
+{
+    float r = roughness + 1.0;
+    float k = (r * r) / 8.0;
+
+    float num   = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+    return num / denom;
+}
+
+float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
+{
+    float ggx1 = GeometrySchlickGGX(max(dot(N,L),0.0), roughness);
+    float ggx2 = GeometrySchlickGGX(max(dot(N,V),0.0), roughness);
+    return ggx1 * ggx2;
+}
+
+vec3 fresnelSchlick(float cosTheta, vec3 F0)
+{
+    return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+// ----------------------------------------------------------------------------
+// Main
+void main()
+{
+    if (isLight) {
+        vec3 emissive = currentLightColor * 10.0;
+        FragColor = vec4(emissive, 1.0);
+        return;
+    }
+
+    vec3 N = normalize(vertexNormal);
+    vec3 V = normalize(viewPos - vertexPos);
+
+    vec3 baseColor = useAlbedoMap ? texture(albedoTex, TexCoords).rgb : albedo;
+    float metal   = useMetallicMap  ? texture(metallicTex, TexCoords).r : metallic;
+    float rough   = useRoughnessMap ? texture(roughnessTex, TexCoords).r : roughness;
+    float aoValue = useAoMap        ? texture(aoTex, TexCoords).r        : ao;
+
+    vec3 F0 = mix(vec3(0.04), baseColor, metal);
+
+    vec3 Lo = vec3(0.0);
+
+    // Loop over all lights
+    for (int i = 0; i < lightsCount; i++)
+    {
+        // 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);
+
+        // 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;
+        vec3 specular = numerator / denominator;
+
+        vec3 kS = F;
+        vec3 kD = vec3(1.0) - kS;
+        kD *= 1.0 - metal;
+
+        float NdotL = max(dot(N,L), 0.0);
+
+        vec3 radiance = lights[i].color * lights[i].intensity;
+
+        // 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 (unshadowed by design)
+    vec3 ambient = vec3(0.03) * baseColor * aoValue;
+
+    vec3 color = ambient + Lo;
+
+    // HDR tonemapping + gamma
+    color = color / (color + vec3(1.0));
+    color = pow(color, vec3(1.0/2.2));
+
+    FragColor = vec4(color, opacity);
+}

engine/src/window/window.cpp

@@ -0,0 +1,145 @@
+#include <SDL3/SDL.h>
+
+#include "engine/window/window.h"
+#include "engine/window/events/window.h"
+
+#include <iostream>
+#include <GL/glew.h>
+
+#include "engine/renderer/debug.h"
+
+std::shared_ptr<Window> Window::s_instance = nullptr;
+
+Window::Window(const char* title, int width, int height) {
+    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
+
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, ENGINE_GL_MAJOR_VERSION);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, ENGINE_GL_MINOR_VERSION);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, ENGINE_GL_MULTISAMPLE_BUFFERS);
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, ENGINE_GL_MULTISAMPLE_SAMPLES);
+
+    m_width = width;
+    m_height = height;
+
+    m_handle = SDL_CreateWindow(title, m_width, m_height, SDL_WINDOW_OPENGL|SDL_WINDOW_ALWAYS_ON_TOP|SDL_WINDOW_RESIZABLE);
+
+    if (!m_handle) {
+        std::cerr << "Failed to create window" << std::endl;
+        std::exit(1);
+    }
+
+    SDL_SetWindowRelativeMouseMode(m_handle, true);
+
+    m_context = SDL_GL_CreateContext(m_handle);
+
+    if (!SDL_GL_MakeCurrent(m_handle, m_context)) {
+        std::cerr << "SDL_GL_MakeCurrent failed: " << SDL_GetError() << "\n";
+        SDL_DestroyWindow(m_handle);
+        std::exit(1);
+    }
+
+    glewExperimental = GL_TRUE;
+    if (GLEW_OK != glewInit()) {
+        std::cerr << "Could not initialize GLEW!" << std::endl;
+        SDL_GL_DestroyContext(m_context);
+        SDL_DestroyWindow(m_handle);
+        std::exit(1);
+    }
+
+    std::cout << "GL_VENDOR:   " << glGetString(GL_VENDOR) << std::endl;
+    std::cout << "GL_RENDERER: " << glGetString(GL_RENDERER) << std::endl;
+    std::cout << "GL_VERSION:  " << glGetString(GL_VERSION) << std::endl;
+
+    glEnable(GL_DEBUG_OUTPUT);
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+    glDebugMessageCallback(MessageCallback, nullptr);
+
+    glViewport(0, 0, m_width, m_height);
+}
+
+Window::Window() : Window("OpenGL Test", DEFAULT_WIDTH, DEFAULT_HEIGHT) {}
+
+std::shared_ptr<Window> Window::GetInstance() {
+    if (!s_instance) {
+        s_instance = std::shared_ptr<Window>(new Window(), WindowDeleter{});
+    }
+    return s_instance;
+}
+
+Window::Window(Window&& window) noexcept
+    : m_handle(window.m_handle), m_context(window.m_context), m_width(window.m_width), m_height(window.m_height)
+{
+    window.m_handle = nullptr;
+    window.m_context = (SDL_GLContext)nullptr;
+    window.m_width = 0;
+    window.m_height = 0;
+}
+
+Window& Window::operator=(Window&& window) noexcept
+{
+    if (this == &window) return *this;
+
+    // Destroy();
+
+    this->m_handle = window.m_handle;
+    this->m_context = window.m_context;
+    this->m_width = window.m_width;
+    this->m_height = window.m_height;
+
+    return *this;
+}
+
+void Window::ProcessEvents() {
+    SDL_Event event;
+    while(SDL_PollEvent(&event)) {
+        switch (event.type) {
+            case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
+            case SDL_EVENT_QUIT:
+                Dispatch(WindowCloseRequested());
+                break;
+            case SDL_EVENT_KEY_DOWN:
+                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;
+                    m_height = height;
+                    glViewport(
+                        0,
+                        0,
+                        width,
+                        height);
+                    Dispatch(WindowResized{ m_width, m_height });
+                }
+                break;
+            default: break;
+        };
+    }
+}
+
+void Window::SwapBuffers() const {
+    SDL_GL_SwapWindow(m_handle);
+}
+
+Window::~Window() {
+    Destroy();
+}
+
+void Window::Destroy() const {
+    if (m_context)
+        SDL_GL_DestroyContext(m_context);
+    if (m_handle)
+        SDL_DestroyWindow(m_handle);
+}
+