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/StateManager.cpp82
-rw-r--r--src/Core/StateManager.h39
-rw-r--r--src/States/ConfigState.cpp29
-rw-r--r--src/States/ConfigState.h21
-rw-r--r--src/States/SimulationState.cpp331
-rw-r--r--src/States/SimulationState.h56
9 files changed, 609 insertions, 330 deletions
diff --git a/src/Core/Application.cpp b/src/Core/Application.cpp
index 3a58001..70868ca 100644
--- a/src/Core/Application.cpp
+++ b/src/Core/Application.cpp
@@ -1,15 +1,9 @@
#include "Application.h"
-
#include "Rendering/Renderer.h"
-#include "Rendering/VertexArray.h"
-#include "Rendering/VertexBuffer.h"
-#include "Rendering/IndexBuffer.h"
-#include "Rendering/Shader.h"
-#include "Rendering/Texture.h"
-#include <iostream>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
+#include "States/ConfigState.h"
+#include "States/SimulationState.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->SetEventCallback([this](Event& event)
{
OnEvent(event);
@@ -69,90 +62,40 @@ namespace Donut
dispatcher.Dispatch<WindowResizeEvent>([this, &event](WindowResizeEvent& e)
{
if (e.GetWidth() == 0 || e.GetHeight() == 0)
- {
m_Minimized = true;
- }
else
- {
m_Minimized = false;
- }
Renderer::OnWindowResize(e.GetWidth(), e.GetHeight());
-
- if (m_Camera)
- m_Camera->SetProjection(45.0f, (float)e.GetWidth() / (float)e.GetHeight(), 0.1f, 100.0f);
-
- event.Handled = true;
- return true;
- });
-
- dispatcher.Dispatch<WindowFocusEvent>([this, &event](WindowFocusEvent& e)
- {
- m_FirstMouse = true;
- m_MouseDragging = false;
- event.Handled = true;
- return true;
- });
-
- dispatcher.Dispatch<WindowLostFocusEvent>([this, &event](WindowLostFocusEvent& e)
- {
- m_MouseDragging = false;
event.Handled = true;
return true;
});
dispatcher.Dispatch<KeyPressedEvent>([this, &event](KeyPressedEvent& e)
{
- m_Keys[e.GetKeyCode()] = true;
- return true;
- });
-
- dispatcher.Dispatch<KeyReleasedEvent>([this, &event](KeyReleasedEvent& e)
- {
- m_Keys[e.GetKeyCode()] = false;
- return true;
- });
-
- dispatcher.Dispatch<MouseMovedEvent>([this, &event](MouseMovedEvent& e)
- {
- if (!m_MouseDragging)
+ if (e.GetKeyCode() == GLFW_KEY_1)
+ {
+ m_StateManager->SwitchToState("Config");
+ event.Handled = true;
return true;
-
- if (m_FirstMouse)
+ }
+ else if (e.GetKeyCode() == GLFW_KEY_2)
{
- m_LastX = e.GetX();
- m_LastY = e.GetY();
- m_FirstMouse = false;
+ m_StateManager->SwitchToState("Simulation");
+ event.Handled = true;
+ return true;
}
-
- float xOffset = m_LastX - e.GetX();
- float yOffset = e.GetY() - m_LastY;
-
- m_LastX = e.GetX();
- m_LastY = e.GetY();
-
- if (m_Camera)
- m_Camera->OnMouseMove(xOffset, yOffset);
-
- return true;
- });
-
- dispatcher.Dispatch<MouseButtonPressedEvent>([this, &event](MouseButtonPressedEvent& e)
- {
- if (e.GetMouseButton() == GLFW_MOUSE_BUTTON_LEFT)
+ else if (e.GetKeyCode() == GLFW_KEY_3)
{
- m_MouseDragging = true;
- m_FirstMouse = true;
+ m_StateManager->SwitchToState("Menu");
+ event.Handled = true;
+ return true;
}
+
return true;
});
- dispatcher.Dispatch<MouseButtonReleasedEvent>([this, &event](MouseButtonReleasedEvent& e)
- {
- if (e.GetMouseButton() == GLFW_MOUSE_BUTTON_LEFT)
- m_MouseDragging = false;
- return true;
- });
+ m_StateManager->OnEvent(event);
}
void Application::OnInit()
@@ -163,93 +106,17 @@ namespace Donut
Renderer::OnWindowResize(1280, 720);
RenderCommand::SetFaceCulling(false);
- m_Camera = std::make_unique<Camera>(45.0f, 1280.0f / 720.0f, 0.1f, 100.0f);
- m_Camera->SetPosition({ 0.0f, 0.0f, 3.0f });
- m_Camera->SetMouseSensitivity(0.1f);
- m_Camera->SetMovementSpeed(5.0f);
-
- float vertices[] =
- {
- // Position (3) | Color (4) | TexCoords (2)
- -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_VertexArray = std::shared_ptr<VertexArray>(VertexArray::Create());
- m_VertexBuffer = std::shared_ptr<VertexBuffer>(VertexBuffer::Create(vertices, sizeof(vertices)));
-
- VertexBufferLayout layout;
- layout.Push<float>(3);
- layout.Push<float>(4);
- layout.Push<float>(2);
- m_VertexBuffer->SetLayout(layout);
-
- m_VertexArray->AddVertexBuffer(m_VertexBuffer);
-
- m_IndexBuffer = std::shared_ptr<IndexBuffer>(IndexBuffer::Create(indices, 36));
- m_VertexArray->SetIndexBuffer(m_IndexBuffer);
-
- m_Shader = std::shared_ptr<Shader>(Shader::Create("Assets/Textured.glsl"));
- m_Texture = Texture2D::Create(256, 256);
-
- uint32_t* pixelData = 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;
-
- pixelData[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
- }
- }
-
- m_Texture->SetData(pixelData, 256 * 256 * 4);
- delete[] pixelData;
-
- m_ComputeShader = std::shared_ptr<Shader>(Shader::Create("Assets/TextureProcessor.glsl"));
-
- if (!m_ComputeShader)
- {
- DONUT_WARN("Failed to create compute shader! Falling back to CPU texture generation.");
- m_UseComputeShader = false;
- }
- else
- DONUT_INFO("Compute shader created successfully!");
-
- m_ProcessedTexture = Texture2D::Create(256, 256);
- m_ComputeBrightness = 0.0f;
- m_ComputeContrast = 1.0f;
- m_ComputeSaturation = 1.0f;
- m_UseComputeShader = true;
+ m_StateManager = std::make_unique<StateManager>();
+ m_StateManager->RegisterState("Config", std::make_unique<ConfigState>());
+ m_StateManager->RegisterState("Simulation", std::make_unique<SimulationState>());
+ m_StateManager->SwitchToState("Config");
}
void Application::OnShutdown()
{
+ if (m_StateManager)
+ m_StateManager->Shutdown();
+
Renderer::Shutdown();
Logger::Shutdown();
}
@@ -260,149 +127,11 @@ namespace Donut
m_DeltaTime = currentFrame - m_LastFrame;
m_LastFrame = currentFrame;
- if (m_Camera)
- {
- if (m_Keys[GLFW_KEY_W])
- m_Camera->MoveForward(m_DeltaTime);
- if (m_Keys[GLFW_KEY_S])
- m_Camera->MoveBackward(m_DeltaTime);
- if (m_Keys[GLFW_KEY_A])
- m_Camera->MoveLeft(m_DeltaTime);
- if (m_Keys[GLFW_KEY_D])
- m_Camera->MoveRight(m_DeltaTime);
- if (m_Keys[GLFW_KEY_SPACE])
- m_Camera->MoveUp(m_DeltaTime);
- if (m_Keys[GLFW_KEY_LEFT_SHIFT])
- m_Camera->MoveDown(m_DeltaTime);
- }
-
- static bool cKeyPressed = false;
- if (m_Keys[GLFW_KEY_C] && !cKeyPressed)
- {
- m_UseComputeShader = !m_UseComputeShader;
- DONUT_INFO("Compute shader: {}", (m_UseComputeShader ? "ON" : "OFF"));
- cKeyPressed = true;
- }
- if (!m_Keys[GLFW_KEY_C])
- cKeyPressed = false;
- if (m_Keys[GLFW_KEY_UP])
- m_ComputeBrightness += m_DeltaTime * 0.5f;
- if (m_Keys[GLFW_KEY_DOWN])
- m_ComputeBrightness -= m_DeltaTime * 0.5f;
- if (m_Keys[GLFW_KEY_LEFT])
- m_ComputeContrast -= m_DeltaTime * 0.5f;
- if (m_Keys[GLFW_KEY_RIGHT])
- m_ComputeContrast += m_DeltaTime * 0.5f;
- if (m_Keys[GLFW_KEY_Q])
- m_ComputeSaturation -= m_DeltaTime * 0.5f;
- if (m_Keys[GLFW_KEY_E])
- m_ComputeSaturation += m_DeltaTime * 0.5f;
-
- m_ComputeBrightness = glm::clamp(m_ComputeBrightness, -1.0f, 1.0f);
- m_ComputeContrast = glm::clamp(m_ComputeContrast, 0.1f, 3.0f);
- m_ComputeSaturation = glm::clamp(m_ComputeSaturation, 0.0f, 2.0f);
-
- static float statusTimer = 0.0f;
- statusTimer += m_DeltaTime;
- if (statusTimer > 2.0f)
- {
- DONUT_INFO("Compute Shader Status:\nBrightness: {}\nContrast: {}\nSaturation: {}",
- m_ComputeBrightness, m_ComputeContrast, m_ComputeSaturation);
- statusTimer = 0.0f;
- }
-
- UpdateTexture();
+ m_StateManager->Update(m_DeltaTime);
}
void Application::OnRender()
{
- Renderer::SetClearColor({ 0.0f, 0.0f, 0.0f, 1.0f });
- Renderer::Clear();
-
- if (m_UseComputeShader &&
- m_ProcessedTexture)
- {
- m_ProcessedTexture->Bind(0);
- m_Shader->SetInt("u_Texture", 0);
- }
- else if (m_Texture)
- {
- m_Texture->Bind(0);
- m_Shader->SetInt("u_Texture", 0);
- }
-
- glm::mat4 viewProjection = m_Camera ? m_Camera->GetViewProjectionMatrix() : glm::mat4(1.0f);
-
- glm::vec3 centerPos(0.0f, 0.0f, 0.0f);
- glm::vec3 rightPos(2.0f, 0.0f, 0.0f);
- glm::vec3 leftPos(-2.0f, 0.0f, 0.0f);
- glm::vec3 upPos(0.0f, 2.0f, 0.0f);
- glm::vec3 downPos(0.0f, -2.0f, 0.0f);
- glm::vec3 forwardPos(0.0f, 0.0f, 2.0f);
- glm::vec3 backPos(0.0f, 0.0f, -2.0f);
-
- glm::mat4 transform = glm::translate(glm::mat4(1.0f), centerPos);
- Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
- transform = glm::translate(glm::mat4(1.0f), rightPos);
- Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
- transform = glm::translate(glm::mat4(1.0f), leftPos);
- Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
- transform = glm::translate(glm::mat4(1.0f), upPos);
- Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
- transform = glm::translate(glm::mat4(1.0f), downPos);
- Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
- transform = glm::translate(glm::mat4(1.0f), forwardPos);
- Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
- transform = glm::translate(glm::mat4(1.0f), backPos);
- Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
- }
-
- void Application::UpdateTexture()
- {
- if (!m_Texture)
- return;
-
- m_TextureTime += m_DeltaTime;
-
- if (m_UseComputeShader && m_ComputeShader && m_ProcessedTexture)
- {
- m_ComputeShader->Bind();
- m_Texture->Bind(0);
- m_ComputeShader->SetInt("u_InputTexture", 0);
- m_ProcessedTexture->BindAsImage(1, false);
- m_ComputeShader->SetFloat2("u_TextureSize", glm::vec2(256.0f, 256.0f));
- m_ComputeShader->SetFloat("u_Time", m_TextureTime);
- m_ComputeShader->SetFloat("u_Brightness", m_ComputeBrightness);
- m_ComputeShader->SetFloat("u_Contrast", m_ComputeContrast);
- m_ComputeShader->SetFloat("u_Saturation", m_ComputeSaturation);
- m_ComputeShader->Dispatch(16, 16, 1);
- m_ComputeShader->MemoryBarrier(IMAGE_ACCESS_BARRIER_BIT);
- }
- else
- {
- uint32_t* pixelData = new uint32_t[256 * 256];
- for (int y = 0; y < 256; y++)
- {
- for (int x = 0; x < 256; x++)
- {
- float time = m_TextureTime * 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;
-
- pixelData[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
- }
- }
-
- m_Texture->SetData(pixelData, 256 * 256 * 4);
- delete[] pixelData;
- }
+ m_StateManager->Render();
}
-}
+};
diff --git a/src/Core/Application.h b/src/Core/Application.h
index 890df0f..92ab781 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 "StateManager.h"
#include "Log.h"
-#include "Rendering/VertexArray.h"
-#include "Rendering/VertexBuffer.h"
-#include "Rendering/IndexBuffer.h"
-#include "Rendering/Shader.h"
-#include "Rendering/Texture.h"
-
namespace Donut
{
class Application
@@ -34,35 +28,15 @@ namespace Donut
void OnUpdate();
void OnRender();
void OnEvent(Event& event);
- void UpdateTexture();
private:
+ std::unique_ptr<StateManager> m_StateManager;
std::unique_ptr<Window> m_Window;
+
bool m_Running;
bool m_Minimized;
-
- std::shared_ptr<VertexArray> m_VertexArray;
- std::shared_ptr<VertexBuffer> m_VertexBuffer;
- std::shared_ptr<IndexBuffer> m_IndexBuffer;
- std::shared_ptr<Shader> m_Shader;
- std::shared_ptr<Texture2D> m_Texture;
-
- std::shared_ptr<Shader> m_ComputeShader;
- std::shared_ptr<Texture2D> m_ProcessedTexture;
- float m_ComputeBrightness;
- float m_ComputeContrast;
- float m_ComputeSaturation;
- bool m_UseComputeShader;
-
- std::unique_ptr<Camera> m_Camera;
- bool m_Keys[1024] = { false };
- bool m_FirstMouse = true;
- float m_LastX = 0.0f;
- float m_LastY = 0.0f;
- float m_DeltaTime = 0.0f;
- float m_LastFrame = 0.0f;
- bool m_MouseDragging = false;
- float m_TextureTime = 0.0f;
+ float m_DeltaTime = 0.0f;
+ float m_LastFrame = 0.0f;
static Application* s_Instance;
};
diff --git a/src/Core/State.h b/src/Core/State.h
new file mode 100644
index 0000000..2d368d7
--- /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 OnEnter() = 0;
+ virtual void OnExit() = 0;
+ virtual void OnUpdate(float deltaTime) = 0;
+ virtual void OnRender() = 0;
+ virtual void OnEvent(Event& event) = 0;
+ };
+}; \ No newline at end of file
diff --git a/src/Core/StateManager.cpp b/src/Core/StateManager.cpp
new file mode 100644
index 0000000..30d6b1d
--- /dev/null
+++ b/src/Core/StateManager.cpp
@@ -0,0 +1,82 @@
+#include "StateManager.h"
+#include "Log.h"
+
+namespace Donut
+{
+ void StateManager::Shutdown()
+ {
+ if (m_CurrentState)
+ m_CurrentState->OnExit();
+
+ DestroyStates();
+ DONUT_INFO("StateManager shutdown");
+ }
+
+ void StateManager::DestroyStates()
+ {
+ m_States.clear();
+ m_CurrentState = nullptr;
+ m_CurrentStateName = "";
+ }
+
+ void StateManager::RegisterState(const std::string& stateName, std::unique_ptr<State> state)
+ {
+ if (m_States.find(stateName) != m_States.end())
+ DONUT_WARN("State '{}' already exists, overwriting", stateName);
+ m_States[stateName] = std::move(state);
+ DONUT_INFO("Registered state: {}", stateName);
+ }
+
+ void StateManager::SwitchToState(const std::string& stateName)
+ {
+ auto it = m_States.find(stateName);
+ if (it == m_States.end())
+ {
+ DONUT_ERROR("Attempted to switch to unknown state: {}", stateName);
+ return;
+ }
+
+ State* newState = it->second.get();
+ if (newState == m_CurrentState)
+ return;
+
+ if (m_CurrentState)
+ m_CurrentState->OnExit();
+
+ m_CurrentState = newState;
+ m_CurrentStateName = stateName;
+ m_CurrentState->OnEnter();
+ DONUT_INFO("Switched to state: {}", stateName);
+ }
+
+ State* StateManager::GetState(const std::string& stateName)
+ {
+ auto it = m_States.find(stateName);
+ if (it != m_States.end())
+ return it->second.get();
+ return nullptr;
+ }
+
+ bool StateManager::HasState(const std::string& stateName) const
+ {
+ return m_States.find(stateName) != m_States.end();
+ }
+
+ void StateManager::Update(float deltaTime)
+ {
+ if (m_CurrentState)
+ m_CurrentState->OnUpdate(deltaTime);
+ }
+
+ void StateManager::Render()
+ {
+ if (m_CurrentState)
+ m_CurrentState->OnRender();
+ }
+
+ void StateManager::OnEvent(Event& event)
+ {
+ if (m_CurrentState)
+ m_CurrentState->OnEvent(event);
+ }
+}
diff --git a/src/Core/StateManager.h b/src/Core/StateManager.h
new file mode 100644
index 0000000..06370f3
--- /dev/null
+++ b/src/Core/StateManager.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 deltaTime);
+ void Render();
+ void OnEvent(Event& event);
+
+ void RegisterState(const std::string& stateName, std::unique_ptr<State> state);
+ void SwitchToState(const std::string& stateName);
+
+ std::string GetCurrentStateName() const { return m_CurrentStateName; }
+ State* GetCurrentState() const { return m_CurrentState; }
+
+ State* GetState(const std::string& stateName);
+ bool HasState(const std::string& stateName) const;
+ private:
+ void CreateStates();
+ void DestroyStates();
+
+ private:
+ State* m_CurrentState = nullptr;
+ std::string m_CurrentStateName = "";
+
+ std::unordered_map<std::string, std::unique_ptr<State>> m_States;
+ };
+}
diff --git a/src/States/ConfigState.cpp b/src/States/ConfigState.cpp
new file mode 100644
index 0000000..5d2e0aa
--- /dev/null
+++ b/src/States/ConfigState.cpp
@@ -0,0 +1,29 @@
+#include "ConfigState.h"
+#include "Rendering/Renderer.h"
+
+namespace Donut
+{
+ void ConfigState::OnEnter()
+ {
+ DONUT_INFO("Entering Config State");
+ }
+
+ void ConfigState::OnExit()
+ {
+ DONUT_INFO("Exiting Config State");
+ }
+
+ void ConfigState::OnUpdate(float deltaTime)
+ {
+ }
+
+ void ConfigState::OnRender()
+ {
+ Renderer::SetClearColor({ 0.1f, 0.1f, 0.2f, 1.0f });
+ Renderer::Clear();
+ }
+
+ void ConfigState::OnEvent(Event& event)
+ {
+ }
+}
diff --git a/src/States/ConfigState.h b/src/States/ConfigState.h
new file mode 100644
index 0000000..756e143
--- /dev/null
+++ b/src/States/ConfigState.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 OnEnter() override;
+ void OnExit() override;
+ void OnUpdate(float deltaTime) override;
+ void OnRender() override;
+ void OnEvent(Event& event) override;
+ };
+}; \ No newline at end of file
diff --git a/src/States/SimulationState.cpp b/src/States/SimulationState.cpp
new file mode 100644
index 0000000..103fd0f
--- /dev/null
+++ b/src/States/SimulationState.cpp
@@ -0,0 +1,331 @@
+#include "SimulationState.h"
+#include "Rendering/Renderer.h"
+#include "Rendering/VertexArray.h"
+#include "Rendering/VertexBuffer.h"
+#include "Rendering/IndexBuffer.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::OnEnter()
+ {
+ m_Camera = std::make_unique<Camera>(45.0f, 1280.0f / 720.0f, 0.1f, 100.0f);
+ m_Camera->SetPosition({ 0.0f, 0.0f, 3.0f });
+ m_Camera->SetMouseSensitivity(0.1f);
+ m_Camera->SetMovementSpeed(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_VertexArray = std::shared_ptr<VertexArray>(VertexArray::Create());
+ m_VertexBuffer = std::shared_ptr<VertexBuffer>(VertexBuffer::Create(vertices, sizeof(vertices)));
+
+ VertexBufferLayout layout;
+ layout.Push<float>(3);
+ layout.Push<float>(4);
+ layout.Push<float>(2);
+ m_VertexBuffer->SetLayout(layout);
+
+ m_VertexArray->AddVertexBuffer(m_VertexBuffer);
+
+ m_IndexBuffer = std::shared_ptr<IndexBuffer>(IndexBuffer::Create(indices, 36));
+ m_VertexArray->SetIndexBuffer(m_IndexBuffer);
+
+ m_Shader = std::shared_ptr<Shader>(Shader::Create("Assets/Textured.glsl"));
+ m_Texture = Texture2D::Create(256, 256);
+
+ uint32_t* pixelData = 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;
+
+ pixelData[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
+ }
+ }
+
+ m_Texture->SetData(pixelData, 256 * 256 * 4);
+ delete[] pixelData;
+
+ m_ComputeShader = std::shared_ptr<Shader>(Shader::Create("Assets/TextureProcessor.glsl"));
+
+ if (!m_ComputeShader)
+ {
+ DONUT_WARN("Failed to create compute shader! Falling back to CPU texture generation.");
+ m_UseComputeShader = false;
+ }
+ else
+ DONUT_INFO("Compute shader created successfully!");
+
+ m_ProcessedTexture = Texture2D::Create(256, 256);
+ }
+
+ void SimulationState::OnExit()
+ {
+ }
+
+ void SimulationState::OnUpdate(float deltaTime)
+ {
+ m_DeltaTime = deltaTime;
+ HandleKeyInput(deltaTime);
+ UpdateTexture();
+ }
+
+ void SimulationState::OnRender()
+ {
+ Renderer::SetClearColor({ 0.0f, 0.0f, 0.0f, 1.0f });
+ Renderer::Clear();
+
+ if (m_UseComputeShader && m_ProcessedTexture)
+ {
+ m_ProcessedTexture->Bind(0);
+ m_Shader->SetInt("u_Texture", 0);
+ }
+ else if (m_Texture)
+ {
+ m_Texture->Bind(0);
+ m_Shader->SetInt("u_Texture", 0);
+ }
+
+ glm::mat4 viewProjection = m_Camera ? m_Camera->GetViewProjectionMatrix() : glm::mat4(1.0f);
+
+ glm::vec3 centerPos(0.0f, 0.0f, 0.0f);
+ glm::vec3 rightPos(2.0f, 0.0f, 0.0f);
+ glm::vec3 leftPos(-2.0f, 0.0f, 0.0f);
+ glm::vec3 upPos(0.0f, 2.0f, 0.0f);
+ glm::vec3 downPos(0.0f, -2.0f, 0.0f);
+ glm::vec3 forwardPos(0.0f, 0.0f, 2.0f);
+ glm::vec3 backPos(0.0f, 0.0f, -2.0f);
+
+ glm::mat4 transform = glm::translate(glm::mat4(1.0f), centerPos);
+ Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
+ transform = glm::translate(glm::mat4(1.0f), rightPos);
+ Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
+ transform = glm::translate(glm::mat4(1.0f), leftPos);
+ Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
+ transform = glm::translate(glm::mat4(1.0f), upPos);
+ Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
+ transform = glm::translate(glm::mat4(1.0f), downPos);
+ Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
+ transform = glm::translate(glm::mat4(1.0f), forwardPos);
+ Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
+ transform = glm::translate(glm::mat4(1.0f), backPos);
+ Renderer::Submit(m_Shader, m_VertexArray, transform, viewProjection);
+ }
+
+ void SimulationState::OnEvent(Event& event)
+ {
+ EventDispatcher dispatcher(event);
+
+ dispatcher.Dispatch<WindowResizeEvent>([this](WindowResizeEvent& e)
+ {
+ if (m_Camera)
+ m_Camera->SetProjection(45.0f, (float)e.GetWidth() / (float)e.GetHeight(), 0.1f, 100.0f);
+ return true;
+ });
+
+ dispatcher.Dispatch<WindowFocusEvent>([this](WindowFocusEvent& e)
+ {
+ m_FirstMouse = true;
+ m_MouseDragging = false;
+ return true;
+ });
+
+ dispatcher.Dispatch<WindowLostFocusEvent>([this](WindowLostFocusEvent& e)
+ {
+ m_MouseDragging = false;
+ return true;
+ });
+
+ dispatcher.Dispatch<KeyPressedEvent>([this](KeyPressedEvent& e)
+ {
+ m_Keys[e.GetKeyCode()] = true;
+ return true;
+ });
+
+ dispatcher.Dispatch<KeyReleasedEvent>([this](KeyReleasedEvent& e)
+ {
+ m_Keys[e.GetKeyCode()] = false;
+ return true;
+ });
+
+ dispatcher.Dispatch<MouseMovedEvent>([this](MouseMovedEvent& e)
+ {
+ if (!m_MouseDragging)
+ return true;
+
+ if (m_FirstMouse)
+ {
+ m_LastX = e.GetX();
+ m_LastY = e.GetY();
+ m_FirstMouse = false;
+ }
+
+ float xOffset = m_LastX - e.GetX();
+ float yOffset = e.GetY() - m_LastY;
+
+ m_LastX = e.GetX();
+ m_LastY = e.GetY();
+
+ if (m_Camera)
+ m_Camera->OnMouseMove(xOffset, yOffset);
+
+ return true;
+ });
+
+ dispatcher.Dispatch<MouseButtonPressedEvent>([this](MouseButtonPressedEvent& e)
+ {
+ if (e.GetMouseButton() == GLFW_MOUSE_BUTTON_LEFT)
+ {
+ m_MouseDragging = true;
+ m_FirstMouse = true;
+ }
+ return true;
+ });
+
+ dispatcher.Dispatch<MouseButtonReleasedEvent>([this](MouseButtonReleasedEvent& e)
+ {
+ if (e.GetMouseButton() == GLFW_MOUSE_BUTTON_LEFT)
+ m_MouseDragging = false;
+ return true;
+ });
+ }
+
+ void SimulationState::HandleKeyInput(float deltaTime)
+ {
+ if (m_Camera)
+ {
+ if (m_Keys[GLFW_KEY_W])
+ m_Camera->MoveForward(deltaTime);
+ if (m_Keys[GLFW_KEY_S])
+ m_Camera->MoveBackward(deltaTime);
+ if (m_Keys[GLFW_KEY_A])
+ m_Camera->MoveLeft(deltaTime);
+ if (m_Keys[GLFW_KEY_D])
+ m_Camera->MoveRight(deltaTime);
+ if (m_Keys[GLFW_KEY_SPACE])
+ m_Camera->MoveUp(deltaTime);
+ if (m_Keys[GLFW_KEY_LEFT_SHIFT])
+ m_Camera->MoveDown(deltaTime);
+ }
+
+ static bool cKeyPressed = false;
+ if (m_Keys[GLFW_KEY_C] && !cKeyPressed)
+ {
+ m_UseComputeShader = !m_UseComputeShader;
+ DONUT_INFO("Compute shader: {}", (m_UseComputeShader ? "ON" : "OFF"));
+ cKeyPressed = true;
+ }
+ if (!m_Keys[GLFW_KEY_C])
+ cKeyPressed = false;
+ if (m_Keys[GLFW_KEY_UP])
+ m_ComputeBrightness += deltaTime * 0.5f;
+ if (m_Keys[GLFW_KEY_DOWN])
+ m_ComputeBrightness -= deltaTime * 0.5f;
+ if (m_Keys[GLFW_KEY_LEFT])
+ m_ComputeContrast -= deltaTime * 0.5f;
+ if (m_Keys[GLFW_KEY_RIGHT])
+ m_ComputeContrast += deltaTime * 0.5f;
+ if (m_Keys[GLFW_KEY_Q])
+ m_ComputeSaturation -= deltaTime * 0.5f;
+ if (m_Keys[GLFW_KEY_E])
+ m_ComputeSaturation += deltaTime * 0.5f;
+
+ m_ComputeBrightness = glm::clamp(m_ComputeBrightness, -1.0f, 1.0f);
+ m_ComputeContrast = glm::clamp(m_ComputeContrast, 0.1f, 3.0f);
+ m_ComputeSaturation = glm::clamp(m_ComputeSaturation, 0.0f, 2.0f);
+
+ static float statusTimer = 0.0f;
+ statusTimer += deltaTime;
+ if (statusTimer > 2.0f)
+ {
+ DONUT_INFO("Compute Shader Status:\nBrightness: {}\nContrast: {}\nSaturation: {}",
+ m_ComputeBrightness, m_ComputeContrast, m_ComputeSaturation);
+ statusTimer = 0.0f;
+ }
+ }
+
+ void SimulationState::UpdateTexture()
+ {
+ if (!m_Texture)
+ return;
+
+ m_TextureTime += m_DeltaTime;
+
+ if (m_UseComputeShader && m_ComputeShader && m_ProcessedTexture)
+ {
+ m_ComputeShader->Bind();
+ m_Texture->Bind(0);
+ m_ComputeShader->SetInt("u_InputTexture", 0);
+ m_ProcessedTexture->BindAsImage(1, false);
+ m_ComputeShader->SetFloat2("u_TextureSize", glm::vec2(256.0f, 256.0f));
+ m_ComputeShader->SetFloat("u_Time", m_TextureTime);
+ m_ComputeShader->SetFloat("u_Brightness", m_ComputeBrightness);
+ m_ComputeShader->SetFloat("u_Contrast", m_ComputeContrast);
+ m_ComputeShader->SetFloat("u_Saturation", m_ComputeSaturation);
+ m_ComputeShader->Dispatch(16, 16, 1);
+ m_ComputeShader->MemoryBarrier(IMAGE_ACCESS_BARRIER_BIT);
+ }
+ else
+ {
+ uint32_t* pixelData = new uint32_t[256 * 256];
+ for (int y = 0; y < 256; y++)
+ {
+ for (int x = 0; x < 256; x++)
+ {
+ float time = m_TextureTime * 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;
+
+ pixelData[y * 256 + x] = (a << 24) | (b << 16) | (g << 8) | r;
+ }
+ }
+
+ m_Texture->SetData(pixelData, 256 * 256 * 4);
+ delete[] pixelData;
+ }
+ }
+};
diff --git a/src/States/SimulationState.h b/src/States/SimulationState.h
new file mode 100644
index 0000000..d2f0106
--- /dev/null
+++ b/src/States/SimulationState.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/VertexArray.h"
+#include "Rendering/VertexBuffer.h"
+#include "Rendering/IndexBuffer.h"
+#include "Rendering/Shader.h"
+#include "Rendering/Texture.h"
+
+namespace Donut
+{
+ class SimulationState
+ : public State
+ {
+ public:
+ ~SimulationState() = default;
+
+ void OnEnter() override;
+ void OnExit() override;
+ void OnUpdate(float deltaTime) override;
+ void OnRender() override;
+ void OnEvent(Event& event) override;
+ private:
+ void HandleKeyInput(float deltaTime);
+ void UpdateTexture();
+ private:
+ std::unique_ptr<Camera> m_Camera;
+
+ std::shared_ptr<VertexArray> m_VertexArray;
+ std::shared_ptr<VertexBuffer> m_VertexBuffer;
+ std::shared_ptr<IndexBuffer> m_IndexBuffer;
+ std::shared_ptr<Shader> m_Shader;
+ std::shared_ptr<Texture2D> m_Texture;
+
+ std::shared_ptr<Shader> m_ComputeShader;
+ std::shared_ptr<Texture2D> m_ProcessedTexture;
+
+ float m_ComputeBrightness = 0.0f;
+ float m_ComputeContrast = 1.0f;
+ float m_ComputeSaturation = 1.0f;
+ bool m_UseComputeShader = true;
+
+ bool m_Keys[1024] = { false };
+ bool m_FirstMouse = true;
+ float m_LastX = 0.0f;
+ float m_LastY = 0.0f;
+ float m_DeltaTime = 0.0f;
+ float m_LastFrame = 0.0f;
+ bool m_MouseDragging = false;
+ float m_TextureTime = 0.0f;
+ };
+};