hachem.wtf
aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/application.cpp327
-rw-r--r--src/core/application.h36
-rw-r--r--src/core/state.h18
-rw-r--r--src/core/state_manager.cpp82
-rw-r--r--src/core/state_manager.h39
-rw-r--r--src/states/config_state.cpp29
-rw-r--r--src/states/config_state.h21
-rw-r--r--src/states/simulation_state.cpp331
-rw-r--r--src/states/simulation_state.h56
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;
+ };
+};
<im@hachem.wtf>