feat: state manager

9 files changed, 609 insertions, 330 deletions

diff --git a/src/core/application.cpp b/src/core/application.cpp
index c4c0e71..f878c71 100644
--- a/src/core/application.cpp
+++ b/src/core/application.cpp
@@ -1,15 +1,9 @@
 #include "application.h"
-
 #include "rendering/renderer.h"
-#include "rendering/vertex_array.h"
-#include "rendering/vertex_buffer.h"
-#include "rendering/index_buffer.h"
-#include "rendering/shader.h"
-#include "rendering/texture.h"
 
-#include <iostream>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
+#include "states/config_state.h"
+#include "states/simulation_state.h"
+
 #include <GLFW/glfw3.h>
 
 namespace Donut
@@ -22,7 +16,6 @@ namespace Donut
         s_instance = this;
 
         m_window = std::make_unique<Window>(name, width, height);
-        
         m_window->set_event_callback([this](Event& event) 
         {
             on_event(event);
@@ -69,90 +62,40 @@ namespace Donut
         dispatcher.dispatch<WindowResizeEvent>([this, &event](WindowResizeEvent& e) 
         {
             if (e.get_width() == 0 || e.get_height() == 0)
-            {
                 m_minimized = true;
-            }
             else
-            {
                 m_minimized = false;
-            }
             
             Renderer::on_window_resize(e.get_width(), e.get_height());
-            
-            if (m_camera)
-                m_camera->set_projection(45.0f, (float)e.get_width() / (float)e.get_height(), 0.1f, 100.0f);
-            
-            event.handled = true;
-            return true;
-        });
-        
-        dispatcher.dispatch<WindowFocusEvent>([this, &event](WindowFocusEvent& e) 
-        {
-            m_first_mouse = true;
-            m_mouse_dragging = false;
-            event.handled = true;
-            return true;
-        });
-        
-        dispatcher.dispatch<WindowLostFocusEvent>([this, &event](WindowLostFocusEvent& e) 
-        {
-            m_mouse_dragging = false;
             event.handled = true;
             return true;
         });
         
         dispatcher.dispatch<KeyPressedEvent>([this, &event](KeyPressedEvent& e) 
         {
-            m_keys[e.get_key_code()] = true;
-            return true;
-        });
-        
-        dispatcher.dispatch<KeyReleasedEvent>([this, &event](KeyReleasedEvent& e) 
-        {
-            m_keys[e.get_key_code()] = false;
-            return true;
-        });
-        
-        dispatcher.dispatch<MouseMovedEvent>([this, &event](MouseMovedEvent& e) 
-        {
-            if (!m_mouse_dragging)
+            if (e.get_key_code() == GLFW_KEY_1)
+            {
+                m_state_manager->switch_to_state("Config");
+                event.handled = true;
                 return true;
-                
-            if (m_first_mouse)
+            }
+            else if (e.get_key_code() == GLFW_KEY_2)
             {
-                m_last_x = e.get_x();
-                m_last_y = e.get_y();
-                m_first_mouse = false;
+                m_state_manager->switch_to_state("Simulation");
+                event.handled = true;
+                return true;
             }
-
-            float x_offset = m_last_x - e.get_x();
-            float y_offset = e.get_y() - m_last_y;
-
-            m_last_x = e.get_x();
-            m_last_y = e.get_y();
-
-            if (m_camera)
-                m_camera->on_mouse_move(x_offset, y_offset);
-            
-            return true;
-        });
-        
-        dispatcher.dispatch<MouseButtonPressedEvent>([this, &event](MouseButtonPressedEvent& e) 
-        {
-            if (e.get_mouse_button() == GLFW_MOUSE_BUTTON_LEFT)
+            else if (e.get_key_code() == GLFW_KEY_3)
             {
-                m_mouse_dragging = true;
-                m_first_mouse = true;
+                m_state_manager->switch_to_state("Menu");
+                event.handled = true;
+                return true;
             }
+            
             return true;
         });
         
-        dispatcher.dispatch<MouseButtonReleasedEvent>([this, &event](MouseButtonReleasedEvent& e) 
-        {
-            if (e.get_mouse_button() == GLFW_MOUSE_BUTTON_LEFT)
-                m_mouse_dragging = false;
-            return true;
-        });
+        m_state_manager->on_event(event);
     }
 
     void Application::on_init()     
@@ -163,93 +106,17 @@ namespace Donut
         Renderer::on_window_resize(1280, 720);
         RenderCommand::set_face_culling(false);
 
-        m_camera = std::make_unique<Camera>(45.0f, 1280.0f / 720.0f, 0.1f, 100.0f);
-        m_camera->set_position({ 0.0f, 0.0f, 3.0f });
-        m_camera->set_mouse_sensitivity(0.1f);
-        m_camera->set_movement_speed(5.0f);
-
-        float vertices[] = 
-        {
-            -0.5f, -0.5f, -0.5f,  1.0f, 0.0f, 0.0f, 1.0f,  0.0f, 0.0f,
-             0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f, 1.0f,  1.0f, 0.0f,
-             0.5f,  0.5f, -0.5f,  0.0f, 0.0f, 1.0f, 1.0f,  1.0f, 1.0f,
-            -0.5f,  0.5f, -0.5f,  1.0f, 1.0f, 0.0f, 1.0f,  0.0f, 1.0f,
-            -0.5f, -0.5f,  0.5f,  1.0f, 0.0f, 1.0f, 1.0f,  0.0f, 0.0f,
-             0.5f, -0.5f,  0.5f,  0.0f, 1.0f, 1.0f, 1.0f,  1.0f, 0.0f,
-             0.5f,  0.5f,  0.5f,  0.5f, 0.5f, 0.5f, 1.0f,  1.0f, 1.0f,
-            -0.5f,  0.5f,  0.5f,  1.0f, 1.0f, 1.0f, 1.0f,  0.0f, 1.0f
-        };
-
-        uint32_t indices[] = 
-        {
-            0, 1, 2,  2, 3, 0,
-            1, 5, 6,  6, 2, 1,
-            5, 4, 7,  7, 6, 5,
-            4, 0, 3,  3, 7, 4,
-            3, 2, 6,  6, 7, 3,
-            4, 5, 1,  1, 0, 4
-        };
-
-        m_vertex_array = std::shared_ptr<VertexArray>(VertexArray::create());
-        m_vertex_buffer = std::shared_ptr<VertexBuffer>(VertexBuffer::create(vertices, sizeof(vertices)));
-        
-        VertexBufferLayout layout;
-        layout.push<float>(3);
-        layout.push<float>(4);
-        layout.push<float>(2);
-        m_vertex_buffer->set_layout(layout);
-
-        m_vertex_array->add_vertex_buffer(m_vertex_buffer);
-
-        m_index_buffer = std::shared_ptr<IndexBuffer>(IndexBuffer::create(indices, 36));
-        m_vertex_array->set_index_buffer(m_index_buffer);
-
-        m_shader = std::shared_ptr<Shader>(Shader::create("assets/textured.glsl"));
-
-        m_texture = Texture2D::create(256, 256);
-        
-        uint32_t* pixel_data = new uint32_t[256 * 256];
-        for (int y = 0; y < 256; y++)
-        {
-            for (int x = 0; x < 256; x++)
-            {
-                float u = (float)x / 256.0f;
-                float v = (float)y / 256.0f;
-                
-                float wave = sin(u * 10.0f) * cos(v * 10.0f);
-                wave = (wave + 1.0f) * 0.5f;
-                
-                uint8_t r = (uint8_t)(wave * 255);
-                uint8_t g = (uint8_t)((1.0f - wave) * 255);
-                uint8_t b = (uint8_t)((u + v) * 0.5f * 255);
-                uint8_t a = 255;
-                
-                pixel_data[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
-            }
-        }
-        
-        m_texture->set_data(pixel_data, 256 * 256 * 4);
-        delete[] pixel_data;
-
-        m_compute_shader = std::shared_ptr<Shader>(Shader::create("assets/texture_processor.glsl"));
-        
-        if (!m_compute_shader)
-        {
-            DONUT_WARN("Failed to create compute shader! Falling back to CPU texture generation.");
-            m_use_compute_shader = false;
-        }
-        else
-            DONUT_INFO("Compute shader created successfully!");
-        
-        m_processed_texture = Texture2D::create(256, 256);
-        m_compute_brightness = 0.0f;
-        m_compute_contrast = 1.0f;
-        m_compute_saturation = 1.0f;
-        m_use_compute_shader = true;
+        m_state_manager = std::make_unique<StateManager>();
+        m_state_manager->register_state("Config", std::make_unique<ConfigState>());
+        m_state_manager->register_state("Simulation", std::make_unique<SimulationState>());
+        m_state_manager->switch_to_state("Config");
     }
 
     void Application::on_shutdown() 
     { 
+        if (m_state_manager)
+            m_state_manager->shutdown();
+            
         Renderer::shutdown();
         Logger::shutdown();
     }
@@ -260,149 +127,11 @@ namespace Donut
         m_delta_time = current_frame - m_last_frame;
         m_last_frame = current_frame;
 
-        if (m_camera)
-        {
-            if (m_keys[GLFW_KEY_W])
-                m_camera->move_forward(m_delta_time);
-            if (m_keys[GLFW_KEY_S])
-                m_camera->move_backward(m_delta_time);
-            if (m_keys[GLFW_KEY_A])
-                m_camera->move_left(m_delta_time);
-            if (m_keys[GLFW_KEY_D])
-                m_camera->move_right(m_delta_time);
-            if (m_keys[GLFW_KEY_SPACE]) 
-                m_camera->move_up(m_delta_time);
-            if (m_keys[GLFW_KEY_LEFT_SHIFT])
-                m_camera->move_down(m_delta_time);    
-        }
-        
-        static bool c_key_pressed = false;
-        if (m_keys[GLFW_KEY_C] && !c_key_pressed)
-        {
-            m_use_compute_shader = !m_use_compute_shader;
-            DONUT_INFO("Compute shader: {}", (m_use_compute_shader ? "ON" : "OFF"));
-            c_key_pressed = true;
-        }
-        if (!m_keys[GLFW_KEY_C])
-            c_key_pressed = false;
-        if (m_keys[GLFW_KEY_UP])
-            m_compute_brightness += m_delta_time * 0.5f;
-        if (m_keys[GLFW_KEY_DOWN])
-            m_compute_brightness -= m_delta_time * 0.5f;
-        if (m_keys[GLFW_KEY_LEFT])
-            m_compute_contrast -= m_delta_time * 0.5f;
-        if (m_keys[GLFW_KEY_RIGHT])
-            m_compute_contrast += m_delta_time * 0.5f;
-        if (m_keys[GLFW_KEY_Q])
-            m_compute_saturation -= m_delta_time * 0.5f;
-        if (m_keys[GLFW_KEY_E])
-            m_compute_saturation += m_delta_time * 0.5f;
-        
-        m_compute_brightness = glm::clamp(m_compute_brightness, -1.0f, 1.0f);
-        m_compute_contrast = glm::clamp(m_compute_contrast, 0.1f, 3.0f);
-        m_compute_saturation = glm::clamp(m_compute_saturation, 0.0f, 2.0f);
-        
-        static float status_timer = 0.0f;
-        status_timer += m_delta_time;
-        if (status_timer > 2.0f)
-        {
-            DONUT_INFO("Compute Shader Status:\nBrightness: {}\nContrast: {}\nSaturation: {}",
-                       m_compute_brightness, m_compute_contrast, m_compute_saturation);
-            status_timer = 0.0f;
-        }
-        
-        update_texture();
+        m_state_manager->update(m_delta_time);
     }
 
     void Application::on_render()
     {
-        Renderer::set_clear_color({ 0.0f, 0.0f, 0.0f, 1.0f });
-        Renderer::clear();
-
-        if (m_use_compute_shader && 
-            m_processed_texture)
-        {
-            m_processed_texture->bind(0);
-            m_shader->set_int("u_Texture", 0);
-        }
-        else if (m_texture)
-        {
-            m_texture->bind(0);
-            m_shader->set_int("u_Texture", 0);
-        }
-
-        glm::mat4 view_projection = m_camera ? m_camera->get_view_projection_matrix() : glm::mat4(1.0f);
-        
-        glm::vec3 center_pos(0.0f, 0.0f, 0.0f);
-        glm::vec3 right_pos(2.0f, 0.0f, 0.0f);
-        glm::vec3 left_pos(-2.0f, 0.0f, 0.0f);
-        glm::vec3 up_pos(0.0f, 2.0f, 0.0f);
-        glm::vec3 down_pos(0.0f, -2.0f, 0.0f);
-        glm::vec3 forward_pos(0.0f, 0.0f, 2.0f);
-        glm::vec3 back_pos(0.0f, 0.0f, -2.0f);
-        
-        glm::mat4 transform = glm::translate(glm::mat4(1.0f), center_pos);
-        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
-        transform = glm::translate(glm::mat4(1.0f), right_pos);
-        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
-        transform = glm::translate(glm::mat4(1.0f), left_pos);
-        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
-        transform = glm::translate(glm::mat4(1.0f), up_pos);
-        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
-        transform = glm::translate(glm::mat4(1.0f), down_pos);
-        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
-        transform = glm::translate(glm::mat4(1.0f), forward_pos);
-        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
-        transform = glm::translate(glm::mat4(1.0f), back_pos);
-        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
-    }
-
-    void Application::update_texture()
-    {
-        if (!m_texture)
-            return;
-            
-        m_texture_time += m_delta_time;
-        
-        if (m_use_compute_shader && m_compute_shader && m_processed_texture)
-        {
-            m_compute_shader->bind();
-            m_texture->bind(0);
-            m_compute_shader->set_int("u_InputTexture", 0);
-            m_processed_texture->bind_as_image(1, false);
-            m_compute_shader->set_float2("u_TextureSize", glm::vec2(256.0f, 256.0f));
-            m_compute_shader->set_float("u_Time", m_texture_time);
-            m_compute_shader->set_float("u_Brightness", m_compute_brightness);
-            m_compute_shader->set_float("u_Contrast", m_compute_contrast);
-            m_compute_shader->set_float("u_Saturation", m_compute_saturation);
-            m_compute_shader->dispatch(16, 16, 1);
-            m_compute_shader->memory_barrier(IMAGE_ACCESS_BARRIER_BIT);
-        }
-        else
-        {
-            uint32_t* pixel_data = new uint32_t[256 * 256];
-            for (int y = 0; y < 256; y++)
-            {
-                for (int x = 0; x < 256; x++)
-                {
-                    float time = m_texture_time * 2.0f;
-                    float u = (float)x / 256.0f;
-                    float v = (float)y / 256.0f;
-                    
-                    float wave = sin(u * 10.0f + time) * cos(v * 10.0f + time * 0.5f);
-                    wave = (wave + 1.0f) * 0.5f;
-                    
-                    uint8_t r = (uint8_t)(wave * 255);
-                    uint8_t g = (uint8_t)((1.0f - wave) * 255);
-                    uint8_t b = (uint8_t)((u + v) * 0.5f * 255);
-                    uint8_t a = 255;
-                    
-                    pixel_data[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
-                }
-            }
-            
-            m_texture->set_data(pixel_data, 256 * 256 * 4);
-            delete[] pixel_data;
-        }
+        m_state_manager->render();
     }
-}
+};
diff --git a/src/core/application.h b/src/core/application.h
index fe04ff7..326e541 100644
--- a/src/core/application.h
+++ b/src/core/application.h
@@ -5,15 +5,9 @@
 
 #include "window.h"
 #include "event.h"
-#include "camera.h"
+#include "state_manager.h"
 #include "log.h"
 
-#include "rendering/vertex_array.h"
-#include "rendering/vertex_buffer.h"
-#include "rendering/index_buffer.h"
-#include "rendering/shader.h"
-#include "rendering/texture.h"
-
 namespace Donut
 {
     class Application
@@ -34,35 +28,15 @@ namespace Donut
         void on_update();
         void on_render();
         void on_event(Event& event);
-        void update_texture();
     private:
+        std::unique_ptr<StateManager> m_state_manager;
         std::unique_ptr<Window> m_window;
+
         bool m_running;
         bool m_minimized;
-
-        std::shared_ptr<VertexArray>  m_vertex_array;
-        std::shared_ptr<VertexBuffer> m_vertex_buffer;
-        std::shared_ptr<IndexBuffer>  m_index_buffer;
-        std::shared_ptr<Shader>       m_shader;
-        std::shared_ptr<Texture2D>    m_texture;
-        
-        std::shared_ptr<Shader>    m_compute_shader;
-        std::shared_ptr<Texture2D> m_processed_texture;
-        float m_compute_brightness;
-        float m_compute_contrast;
-        float m_compute_saturation;
-        bool  m_use_compute_shader;
-        
-        std::unique_ptr<Camera> m_camera;
         
-        bool  m_keys[1024]    = { false };
-        bool  m_first_mouse    = true;
-        float m_last_x         = 0.0f;
-        float m_last_y         = 0.0f;
-        float m_delta_time     = 0.0f;
-        float m_last_frame     = 0.0f;
-        bool  m_mouse_dragging = false;
-        float m_texture_time   = 0.0f;
+        float m_delta_time = 0.0f;
+        float m_last_frame = 0.0f;
 
         static Application* s_instance;
     };
diff --git a/src/core/state.h b/src/core/state.h
new file mode 100644
index 0000000..f5d808a
--- /dev/null
+++ b/src/core/state.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "event.h"
+
+namespace Donut
+{
+    class State
+    {
+    public:
+        virtual ~State() = default;
+        
+        virtual void on_enter()                 = 0;
+        virtual void on_exit()                  = 0;
+        virtual void on_update(float delta_time) = 0;
+        virtual void on_render()                = 0;
+        virtual void on_event(Event& event)     = 0;
+    };
+};
diff --git a/src/core/state_manager.cpp b/src/core/state_manager.cpp
new file mode 100644
index 0000000..5da601c
--- /dev/null
+++ b/src/core/state_manager.cpp
@@ -0,0 +1,82 @@
+#include "state_manager.h"
+#include "log.h"
+
+namespace Donut
+{
+    void StateManager::shutdown()
+    {
+        if (m_current_state)
+            m_current_state->on_exit();
+            
+        destroy_states();
+        DONUT_INFO("StateManager shutdown");
+    }
+
+    void StateManager::destroy_states()
+    {
+        m_states.clear();
+        m_current_state = nullptr;
+        m_current_state_name = "";
+    }
+
+    void StateManager::register_state(const std::string& state_name, std::unique_ptr<State> state)
+    {
+        if (m_states.find(state_name) != m_states.end())
+            DONUT_WARN("State '{}' already exists, overwriting", state_name);
+        m_states[state_name] = std::move(state);
+        DONUT_INFO("Registered state: {}", state_name);
+    }
+
+    void StateManager::switch_to_state(const std::string& state_name)
+    {
+        auto it = m_states.find(state_name);
+        if (it == m_states.end())
+        {
+            DONUT_ERROR("Attempted to switch to unknown state: {}", state_name);
+            return;
+        }
+
+        State* new_state = it->second.get();
+        if (new_state == m_current_state)
+            return;
+
+        if (m_current_state)
+            m_current_state->on_exit();
+
+        m_current_state = new_state;
+        m_current_state_name = state_name;
+        m_current_state->on_enter();
+        DONUT_INFO("Switched to state: {}", state_name);
+    }
+
+    State* StateManager::get_state(const std::string& state_name)
+    {
+        auto it = m_states.find(state_name);
+        if (it != m_states.end())
+            return it->second.get();
+        return nullptr;
+    }
+
+    bool StateManager::has_state(const std::string& state_name) const
+    {
+        return m_states.find(state_name) != m_states.end();
+    }
+
+    void StateManager::update(float delta_time)
+    {
+        if (m_current_state)
+            m_current_state->on_update(delta_time);
+    }
+
+    void StateManager::render()
+    {
+        if (m_current_state)
+            m_current_state->on_render();
+    }
+
+    void StateManager::on_event(Event& event)
+    {
+        if (m_current_state)
+            m_current_state->on_event(event);
+    }
+}
diff --git a/src/core/state_manager.h b/src/core/state_manager.h
new file mode 100644
index 0000000..7d5e734
--- /dev/null
+++ b/src/core/state_manager.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "state.h"
+
+namespace Donut
+{
+    class StateManager
+    {
+    public:
+        ~StateManager() = default;
+        void shutdown();
+        
+        void update(float delta_time);
+        void render();
+        void on_event(Event& event);
+        
+        void register_state(const std::string& state_name, std::unique_ptr<State> state);
+        void switch_to_state(const std::string& state_name);
+
+        std::string get_current_state_name() const { return m_current_state_name; }
+        State* get_current_state()          const { return m_current_state; }
+        
+        State* get_state(const std::string& state_name);
+        bool   has_state(const std::string& state_name) const;
+    private:
+        void create_states();
+        void destroy_states();
+
+    private:
+        State*      m_current_state     = nullptr;
+        std::string m_current_state_name = "";
+        
+        std::unordered_map<std::string, std::unique_ptr<State>> m_states;
+    };
+}
diff --git a/src/states/config_state.cpp b/src/states/config_state.cpp
new file mode 100644
index 0000000..8ea33ca
--- /dev/null
+++ b/src/states/config_state.cpp
@@ -0,0 +1,29 @@
+#include "config_state.h"
+#include "rendering/renderer.h"
+
+namespace Donut
+{
+    void ConfigState::on_enter()
+    {
+        DONUT_INFO("Entering Config State");
+    }
+    
+    void ConfigState::on_exit()
+    {
+        DONUT_INFO("Exiting Config State");
+    }
+    
+    void ConfigState::on_update(float delta_time)
+    {
+    }
+    
+    void ConfigState::on_render()
+    {
+        Renderer::set_clear_color({ 0.1f, 0.1f, 0.2f, 1.0f });
+        Renderer::clear();
+    }
+    
+    void ConfigState::on_event(Event& event)
+    {
+    }
+}
diff --git a/src/states/config_state.h b/src/states/config_state.h
new file mode 100644
index 0000000..35a3001
--- /dev/null
+++ b/src/states/config_state.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "core/state.h"
+#include "core/event.h"
+#include "core/log.h"
+
+namespace Donut
+{
+    class ConfigState
+        : public State
+    {
+    public:
+        ~ConfigState() = default;
+        
+        void on_enter()                 override;
+        void on_exit()                  override;
+        void on_update(float delta_time) override;
+        void on_render()                override;
+        void on_event(Event& event)     override;
+    };
+};
diff --git a/src/states/simulation_state.cpp b/src/states/simulation_state.cpp
new file mode 100644
index 0000000..c925cd7
--- /dev/null
+++ b/src/states/simulation_state.cpp
@@ -0,0 +1,331 @@
+#include "simulation_state.h"
+#include "rendering/renderer.h"
+#include "rendering/vertex_array.h"
+#include "rendering/vertex_buffer.h"
+#include "rendering/index_buffer.h"
+#include "rendering/shader.h"
+#include "rendering/texture.h"
+
+#include <iostream>
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <GLFW/glfw3.h>
+
+namespace Donut
+{
+    void SimulationState::on_enter()
+    {
+        m_camera = std::make_unique<Camera>(45.0f, 1280.0f / 720.0f, 0.1f, 100.0f);
+        m_camera->set_position({ 0.0f, 0.0f, 3.0f });
+        m_camera->set_mouse_sensitivity(0.1f);
+        m_camera->set_movement_speed(5.0f);
+
+        float vertices[] = 
+        {
+            -0.5f, -0.5f, -0.5f,  1.0f, 0.0f, 0.0f, 1.0f,  0.0f, 0.0f,
+             0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f, 1.0f,  1.0f, 0.0f,
+             0.5f,  0.5f, -0.5f,  0.0f, 0.0f, 1.0f, 1.0f,  1.0f, 1.0f,
+            -0.5f,  0.5f, -0.5f,  1.0f, 1.0f, 0.0f, 1.0f,  0.0f, 1.0f,
+            -0.5f, -0.5f,  0.5f,  1.0f, 0.0f, 1.0f, 1.0f,  0.0f, 0.0f,
+             0.5f, -0.5f,  0.5f,  0.0f, 1.0f, 1.0f, 1.0f,  1.0f, 0.0f,
+             0.5f,  0.5f,  0.5f,  0.5f, 0.5f, 0.5f, 1.0f,  1.0f, 1.0f,
+            -0.5f,  0.5f,  0.5f,  1.0f, 1.0f, 1.0f, 1.0f,  0.0f, 1.0f
+        };
+
+        uint32_t indices[] = 
+        {
+            0, 1, 2,  2, 3, 0,
+            1, 5, 6,  6, 2, 1,
+            5, 4, 7,  7, 6, 5,
+            4, 0, 3,  3, 7, 4,
+            3, 2, 6,  6, 7, 3,
+            4, 5, 1,  1, 0, 4
+        };
+
+        m_vertex_array = std::shared_ptr<VertexArray>(VertexArray::create());
+        m_vertex_buffer = std::shared_ptr<VertexBuffer>(VertexBuffer::create(vertices, sizeof(vertices)));
+        
+        VertexBufferLayout layout;
+        layout.push<float>(3);
+        layout.push<float>(4);
+        layout.push<float>(2);
+        m_vertex_buffer->set_layout(layout);
+
+        m_vertex_array->add_vertex_buffer(m_vertex_buffer);
+
+        m_index_buffer = std::shared_ptr<IndexBuffer>(IndexBuffer::create(indices, 36));
+        m_vertex_array->set_index_buffer(m_index_buffer);
+
+        m_shader = std::shared_ptr<Shader>(Shader::create("assets/textured.glsl"));
+        m_texture = Texture2D::create(256, 256);
+        
+        uint32_t* pixel_data = new uint32_t[256 * 256];
+        for (int y = 0; y < 256; y++)
+        {
+            for (int x = 0; x < 256; x++)
+            {
+                float u = (float)x / 256.0f;
+                float v = (float)y / 256.0f;
+                
+                float wave = sin(u * 10.0f) * cos(v * 10.0f);
+                wave = (wave + 1.0f) * 0.5f;
+                
+                uint8_t r = (uint8_t)(wave * 255);
+                uint8_t g = (uint8_t)((1.0f - wave) * 255);
+                uint8_t b = (uint8_t)((u + v) * 0.5f * 255);
+                uint8_t a = 255;
+                
+                pixel_data[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
+            }
+        }
+        
+        m_texture->set_data(pixel_data, 256 * 256 * 4);
+        delete[] pixel_data;
+
+        m_compute_shader = std::shared_ptr<Shader>(Shader::create("assets/texture_processor.glsl"));
+        
+        if (!m_compute_shader)
+        {
+            DONUT_WARN("Failed to create compute shader! Falling back to CPU texture generation.");
+            m_use_compute_shader = false;
+        }
+        else
+            DONUT_INFO("Compute shader created successfully!");
+        
+        m_processed_texture = Texture2D::create(256, 256);
+    }
+    
+    void SimulationState::on_exit()
+    {
+    }
+    
+    void SimulationState::on_update(float delta_time)
+    {
+        m_delta_time = delta_time;
+        handle_key_input(delta_time);
+        update_texture();
+    }
+    
+    void SimulationState::on_render()
+    {
+        Renderer::set_clear_color({ 0.0f, 0.0f, 0.0f, 1.0f });
+        Renderer::clear();
+
+        if (m_use_compute_shader && m_processed_texture)
+        {
+            m_processed_texture->bind(0);
+            m_shader->set_int("u_Texture", 0);
+        }
+        else if (m_texture)
+        {
+            m_texture->bind(0);
+            m_shader->set_int("u_Texture", 0);
+        }
+
+        glm::mat4 view_projection = m_camera ? m_camera->get_view_projection_matrix() : glm::mat4(1.0f);
+        
+        glm::vec3 center_pos(0.0f, 0.0f, 0.0f);
+        glm::vec3 right_pos(2.0f, 0.0f, 0.0f);
+        glm::vec3 left_pos(-2.0f, 0.0f, 0.0f);
+        glm::vec3 up_pos(0.0f, 2.0f, 0.0f);
+        glm::vec3 down_pos(0.0f, -2.0f, 0.0f);
+        glm::vec3 forward_pos(0.0f, 0.0f, 2.0f);
+        glm::vec3 back_pos(0.0f, 0.0f, -2.0f);
+        
+        glm::mat4 transform = glm::translate(glm::mat4(1.0f), center_pos);
+        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
+        transform = glm::translate(glm::mat4(1.0f), right_pos);
+        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
+        transform = glm::translate(glm::mat4(1.0f), left_pos);
+        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
+        transform = glm::translate(glm::mat4(1.0f), up_pos);
+        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
+        transform = glm::translate(glm::mat4(1.0f), down_pos);
+        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
+        transform = glm::translate(glm::mat4(1.0f), forward_pos);
+        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
+        transform = glm::translate(glm::mat4(1.0f), back_pos);
+        Renderer::submit(m_shader, m_vertex_array, transform, view_projection);
+    }
+    
+    void SimulationState::on_event(Event& event)
+    {
+        EventDispatcher dispatcher(event);
+        
+        dispatcher.dispatch<WindowResizeEvent>([this](WindowResizeEvent& e) 
+        {
+            if (m_camera)
+                m_camera->set_projection(45.0f, (float)e.get_width() / (float)e.get_height(), 0.1f, 100.0f);
+            return true;
+        });
+        
+        dispatcher.dispatch<WindowFocusEvent>([this](WindowFocusEvent& e) 
+        {
+            m_first_mouse = true;
+            m_mouse_dragging = false;
+            return true;
+        });
+        
+        dispatcher.dispatch<WindowLostFocusEvent>([this](WindowLostFocusEvent& e) 
+        {
+            m_mouse_dragging = false;
+            return true;
+        });
+        
+        dispatcher.dispatch<KeyPressedEvent>([this](KeyPressedEvent& e) 
+        {
+            m_keys[e.get_key_code()] = true;
+            return true;
+        });
+        
+        dispatcher.dispatch<KeyReleasedEvent>([this](KeyReleasedEvent& e) 
+        {
+            m_keys[e.get_key_code()] = false;
+            return true;
+        });
+        
+        dispatcher.dispatch<MouseMovedEvent>([this](MouseMovedEvent& e) 
+        {
+            if (!m_mouse_dragging)
+                return true;
+                
+            if (m_first_mouse)
+            {
+                m_last_x = e.get_x();
+                m_last_y = e.get_y();
+                m_first_mouse = false;
+            }
+
+            float x_offset = m_last_x - e.get_x();
+            float y_offset = e.get_y() - m_last_y;
+
+            m_last_x = e.get_x();
+            m_last_y = e.get_y();
+
+            if (m_camera)
+                m_camera->on_mouse_move(x_offset, y_offset);
+            
+            return true;
+        });
+        
+        dispatcher.dispatch<MouseButtonPressedEvent>([this](MouseButtonPressedEvent& e) 
+        {
+            if (e.get_mouse_button() == GLFW_MOUSE_BUTTON_LEFT)
+            {
+                m_mouse_dragging = true;
+                m_first_mouse = true;
+            }
+            return true;
+        });
+        
+        dispatcher.dispatch<MouseButtonReleasedEvent>([this](MouseButtonReleasedEvent& e) 
+        {
+            if (e.get_mouse_button() == GLFW_MOUSE_BUTTON_LEFT)
+                m_mouse_dragging = false;
+            return true;
+        });
+    }
+    
+    void SimulationState::handle_key_input(float delta_time)
+    {
+        if (m_camera)
+        {
+            if (m_keys[GLFW_KEY_W])
+                m_camera->move_forward(delta_time);
+            if (m_keys[GLFW_KEY_S])
+                m_camera->move_backward(delta_time);
+            if (m_keys[GLFW_KEY_A])
+                m_camera->move_left(delta_time);
+            if (m_keys[GLFW_KEY_D])
+                m_camera->move_right(delta_time);
+            if (m_keys[GLFW_KEY_SPACE]) 
+                m_camera->move_up(delta_time);
+            if (m_keys[GLFW_KEY_LEFT_SHIFT])
+                m_camera->move_down(delta_time);    
+        }
+        
+        static bool c_key_pressed = false;
+        if (m_keys[GLFW_KEY_C] && !c_key_pressed)
+        {
+            m_use_compute_shader = !m_use_compute_shader;
+            DONUT_INFO("Compute shader: {}", (m_use_compute_shader ? "ON" : "OFF"));
+            c_key_pressed = true;
+        }
+        if (!m_keys[GLFW_KEY_C])
+            c_key_pressed = false;
+        if (m_keys[GLFW_KEY_UP])
+            m_compute_brightness += delta_time * 0.5f;
+        if (m_keys[GLFW_KEY_DOWN])
+            m_compute_brightness -= delta_time * 0.5f;
+        if (m_keys[GLFW_KEY_LEFT])
+            m_compute_contrast -= delta_time * 0.5f;
+        if (m_keys[GLFW_KEY_RIGHT])
+            m_compute_contrast += delta_time * 0.5f;
+        if (m_keys[GLFW_KEY_Q])
+            m_compute_saturation -= delta_time * 0.5f;
+        if (m_keys[GLFW_KEY_E])
+            m_compute_saturation += delta_time * 0.5f;
+        
+        m_compute_brightness = glm::clamp(m_compute_brightness, -1.0f, 1.0f);
+        m_compute_contrast = glm::clamp(m_compute_contrast, 0.1f, 3.0f);
+        m_compute_saturation = glm::clamp(m_compute_saturation, 0.0f, 2.0f);
+        
+        static float status_timer = 0.0f;
+        status_timer += delta_time;
+        if (status_timer > 2.0f)
+        {
+            DONUT_INFO("Compute Shader Status:\nBrightness: {}\nContrast: {}\nSaturation: {}",
+                       m_compute_brightness, m_compute_contrast, m_compute_saturation);
+            status_timer = 0.0f;
+        }
+    }
+    
+    void SimulationState::update_texture()
+    {
+        if (!m_texture)
+            return;
+            
+        m_texture_time += m_delta_time;
+        
+        if (m_use_compute_shader && m_compute_shader && m_processed_texture)
+        {
+            m_compute_shader->bind();
+            m_texture->bind(0);
+            m_compute_shader->set_int("u_InputTexture", 0);
+            m_processed_texture->bind_as_image(1, false);
+            m_compute_shader->set_float2("u_TextureSize", glm::vec2(256.0f, 256.0f));
+            m_compute_shader->set_float("u_Time", m_texture_time);
+            m_compute_shader->set_float("u_Brightness", m_compute_brightness);
+            m_compute_shader->set_float("u_Contrast", m_compute_contrast);
+            m_compute_shader->set_float("u_Saturation", m_compute_saturation);
+            m_compute_shader->dispatch(16, 16, 1);
+            m_compute_shader->memory_barrier(IMAGE_ACCESS_BARRIER_BIT);
+        }
+        else
+        {
+            uint32_t* pixel_data = new uint32_t[256 * 256];
+            for (int y = 0; y < 256; y++)
+            {
+                for (int x = 0; x < 256; x++)
+                {
+                    float time = m_texture_time * 2.0f;
+                    float u = (float)x / 256.0f;
+                    float v = (float)y / 256.0f;
+                    
+                    float wave = sin(u * 10.0f + time) * cos(v * 10.0f + time * 0.5f);
+                    wave = (wave + 1.0f) * 0.5f;
+                    
+                    uint8_t r = (uint8_t)(wave * 255);
+                    uint8_t g = (uint8_t)((1.0f - wave) * 255);
+                    uint8_t b = (uint8_t)((u + v) * 0.5f * 255);
+                    uint8_t a = 255;
+                    
+                    pixel_data[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
+                }
+            }
+            
+            m_texture->set_data(pixel_data, 256 * 256 * 4);
+            delete[] pixel_data;
+        }
+    }
+};
diff --git a/src/states/simulation_state.h b/src/states/simulation_state.h
new file mode 100644
index 0000000..a0d9e73
--- /dev/null
+++ b/src/states/simulation_state.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "core/state.h"
+#include "core/event.h"
+#include "core/camera.h"
+#include "core/log.h"
+
+#include "rendering/vertex_array.h"
+#include "rendering/vertex_buffer.h"
+#include "rendering/index_buffer.h"
+#include "rendering/shader.h"
+#include "rendering/texture.h"
+
+namespace Donut
+{
+    class SimulationState
+        : public State
+    {
+    public:
+        ~SimulationState() = default;
+        
+        void on_enter()                 override;
+        void on_exit()                  override;
+        void on_update(float delta_time) override;
+        void on_render()                override;
+        void on_event(Event& event)     override;
+    private:
+        void handle_key_input(float delta_time);
+        void update_texture();
+    private:
+        std::unique_ptr<Camera> m_camera;
+        
+        std::shared_ptr<VertexArray>  m_vertex_array;
+        std::shared_ptr<VertexBuffer> m_vertex_buffer;
+        std::shared_ptr<IndexBuffer>  m_index_buffer;
+        std::shared_ptr<Shader>       m_shader;
+        std::shared_ptr<Texture2D>    m_texture;
+        
+        std::shared_ptr<Shader>    m_compute_shader;
+        std::shared_ptr<Texture2D> m_processed_texture;
+        
+        float m_compute_brightness = 0.0f;
+        float m_compute_contrast   = 1.0f;
+        float m_compute_saturation = 1.0f;
+        bool  m_use_compute_shader  = true;
+        
+        bool  m_keys[1024]    = { false };
+        bool  m_first_mouse    = true;
+        float m_last_x         = 0.0f;
+        float m_last_y         = 0.0f;
+        float m_delta_time     = 0.0f;
+        float m_last_frame     = 0.0f;
+        bool  m_mouse_dragging = false;
+        float m_texture_time   = 0.0f;
+    };
+};