feat: complete first geodesic 3D raytracing

33 files changed, 755 insertions, 705 deletions

diff --git a/assets/shaders/compute_texture_quad.glsl b/assets/shaders/compute_texture_quad.glsl
new file mode 100644
index 0000000..1b83f8a
--- /dev/null
+++ b/assets/shaders/compute_texture_quad.glsl
@@ -0,0 +1,27 @@
+#type vertex
+
+#version 330 core
+layout (location = 0) in vec2 a_Pos;
+layout (location = 1) in vec2 a_TexCoord;
+
+out vec2 v_TexCoord;
+
+void main() 
+{
+    gl_Position = vec4(a_Pos, 0.0, 1.0);
+    v_TexCoord = a_TexCoord;
+}
+
+#type fragment
+
+#version 330 core
+
+in vec2 v_TexCoord;
+out vec4 o_FragColor;
+
+uniform sampler2D u_ScreenTexture;
+
+void main() 
+{
+    o_FragColor = texture(u_ScreenTexture, v_TexCoord);
+}
diff --git a/assets/shaders/geodesic.glsl b/assets/shaders/geodesic.glsl
index 6b077be..88cc2a1 100644
--- a/assets/shaders/geodesic.glsl
+++ b/assets/shaders/geodesic.glsl
@@ -2,16 +2,15 @@
 layout(local_size_x = 16, local_size_y = 16) in;
 
 layout(binding = 0, rgba8) writeonly uniform image2D outImage;
-
 layout(std140, binding = 1) uniform Camera 
 {
-    vec3 camPos;     float _pad0;
-    vec3 camRight;   float _pad1;
-    vec3 camUp;      float _pad2;
-    vec3 camForward; float _pad3;
+    vec3  camPos;     float _pad0;
+    vec3  camRight;   float _pad1;
+    vec3  camUp;      float _pad2;
+    vec3  camForward; float _pad3;
     float tanHalfFov;
     float aspect;
-    bool moving;
+    bool  moving;
     int   _pad4;
 } cam;
 
@@ -25,65 +24,83 @@ layout(std140, binding = 2) uniform Disk
 
 layout(std140, binding = 3) uniform Objects 
 {
-    int numObjects;
-    vec4 objPosRadius[16];
-    vec4 objColor[16];
-    float mass[16]; 
+    int    numObjects;
+    vec4   objPosRadius[16];
+    vec4   objColor[16];
+    float  mass[16]; 
 };
 
-const float SagA_rs = 1.269e10;
-const float D_LAMBDA = 1e7;
+const float  SagA_rs  = 1.269e10;
+const float  D_LAMBDA = 1e7;
 const double ESCAPE_R = 1e30;
 
+const int   MAX_STEPS_MOVING   = 60000;
+const int   MAX_STEPS_STATIC   = 30000;
+const float EARLY_EXIT_DISTANCE = 5e11;
+
 vec4 objectColor = vec4(0.0);
 vec3 hitCenter = vec3(0.0);
 float hitRadius = 0.0;
 
 struct Ray 
 {
-    float x, y, z, radius, theta, phi;
-    float dRadius, dTheta, dPhi;
-    float energy, angularMomentum;
+    float x, y, z;
+    float r, theta, phi;
+    float dr, dtheta, dphi;
+    float E, L;
 };
 
-Ray InitRay(vec3 position, vec3 direction) 
+Ray InitRay(vec3 pos, vec3 dir) 
 {
     Ray ray;
-    ray.x = position.x; 
-    ray.y = position.y; 
-    ray.z = position.z;
-    ray.radius = length(position);
-    ray.theta = acos(position.z / ray.radius);
-    ray.phi = atan(position.y, position.x);
+    ray.x     = pos.x; 
+    ray.y     = pos.y; 
+    ray.z     = pos.z;
+    ray.r     = length(pos);
+    ray.theta = acos(pos.z / ray.r);
+    ray.phi   = atan(pos.y, pos.x);
+
+    float dx = dir.x;
+    float dy = dir.y;
+    float dz = dir.z;
+
+    ray.dr     = sin(ray.theta)*cos(ray.phi)*dx + 
+                 sin(ray.theta)*sin(ray.phi)*dy + 
+                 cos(ray.theta)*dz;
+
+    ray.dtheta = (cos(ray.theta)*cos(ray.phi)*dx + 
+                  cos(ray.theta)*sin(ray.phi)*dy - 
+                  sin(ray.theta)*dz) / ray.r;
 
-    float dx = direction.x, dy = direction.y, dz = direction.z;
-    ray.dRadius = sin(ray.theta) * cos(ray.phi) * dx + sin(ray.theta) * sin(ray.phi) * dy + cos(ray.theta) * dz;
-    ray.dTheta = (cos(ray.theta) * cos(ray.phi) * dx + cos(ray.theta) * sin(ray.phi) * dy - sin(ray.theta) * dz) / ray.radius;
-    ray.dPhi = (-sin(ray.phi) * dx + cos(ray.phi) * dy) / (ray.radius * sin(ray.theta));
+    ray.dphi   = (-sin(ray.phi)*dx + cos(ray.phi)*dy) / 
+                 (ray.r * sin(ray.theta));
 
-    ray.angularMomentum = ray.radius * ray.radius * sin(ray.theta) * ray.dPhi;
-    float f = 1.0 - SagA_rs / ray.radius;
-    float dt_dL = sqrt((ray.dRadius * ray.dRadius) / f + ray.radius * ray.radius * (ray.dTheta * ray.dTheta + sin(ray.theta) * sin(ray.theta) * ray.dPhi * ray.dPhi));
-    ray.energy = f * dt_dL;
+    ray.L = ray.r * ray.r * sin(ray.theta) * ray.dphi;
+    float f = 1.0 - SagA_rs / ray.r;
+    float dt_dL = sqrt((ray.dr*ray.dr)/f + 
+                       ray.r*ray.r*(ray.dtheta*ray.dtheta + 
+                       sin(ray.theta)*sin(ray.theta)*
+                       ray.dphi*ray.dphi));
+    ray.E = f * dt_dL;
 
     return ray;
 }
 
-bool Intercept(Ray ray, float schwarzschildRadius) 
+bool Intercept(Ray ray, float rs) 
 {
-    return ray.radius <= schwarzschildRadius;
+    return ray.r <= rs;
 }
 
 bool InterceptObject(Ray ray) 
 {
-    vec3 position = vec3(ray.x, ray.y, ray.z);
+    vec3 P = vec3(ray.x, ray.y, ray.z);
     
     for (int i = 0; i < numObjects; ++i) 
     {
-        vec3 center = objPosRadius[i].xyz;
+        vec3  center = objPosRadius[i].xyz;
         float radius = objPosRadius[i].w;
-        
-        if (distance(position, center) <= radius) 
+
+        if (distance(P, center) <= radius)
         {
             objectColor = objColor[i];
             hitCenter = center;
@@ -91,75 +108,94 @@ bool InterceptObject(Ray ray)
             return true;
         }
     }
-    
+
     return false;
 }
 
-void GeodesicRHS(Ray ray, out vec3 derivatives1, out vec3 derivatives2) 
+void GeodesicRHS(Ray ray, out vec3 d1, out vec3 d2) 
 {
-    float radius = ray.radius, theta = ray.theta;
-    float dRadius = ray.dRadius, dTheta = ray.dTheta, dPhi = ray.dPhi;
-    float f = 1.0 - SagA_rs / radius;
-    float dt_dL = ray.energy / f;
+    float r      = ray.r;
+    float theta  = ray.theta;
+    float dr     = ray.dr;
+    float dtheta = ray.dtheta;
+    float dphi   = ray.dphi;
+    float f      = 1.0 - SagA_rs / r;
+    float dt_dL  = ray.E / f;
 
-    derivatives1 = vec3(dRadius, dTheta, dPhi);
-    derivatives2.x = -(SagA_rs / (2.0 * radius * radius)) * f * dt_dL * dt_dL
-         + (SagA_rs / (2.0 * radius * radius * f)) * dRadius * dRadius
-         + radius * (dTheta * dTheta + sin(theta) * sin(theta) * dPhi * dPhi);
-    derivatives2.y = -2.0 * dRadius * dTheta / radius + sin(theta) * cos(theta) * dPhi * dPhi;
-    derivatives2.z = -2.0 * dRadius * dPhi / radius - 2.0 * cos(theta) / sin(theta) * dTheta * dPhi;
+    d1 = vec3(dr, dtheta, dphi);
+    d2.x = - (SagA_rs / (2.0 * r*r)) * f * dt_dL * dt_dL
+           + (SagA_rs / (2.0 * r*r * f)) * dr * dr
+           + r * (dtheta*dtheta + sin(theta)*sin(theta)*dphi*dphi);
+    d2.y = -2.0*dr*dtheta/r + sin(theta)*cos(theta)*dphi*dphi;
+    d2.z = -2.0*dr*dphi/r - 2.0*cos(theta)/(sin(theta)) * dtheta * dphi;
 }
 
-void RK4Step(inout Ray ray, float deltaLambda) 
+void RK4Step(inout Ray ray, float dL) 
 {
     vec3 k1a, k1b;
     GeodesicRHS(ray, k1a, k1b);
 
-    ray.radius += deltaLambda * k1a.x;
-    ray.theta += deltaLambda * k1a.y;
-    ray.phi += deltaLambda * k1a.z;
-    ray.dRadius += deltaLambda * k1b.x;
-    ray.dTheta += deltaLambda * k1b.y;
-    ray.dPhi += deltaLambda * k1b.z;
+    ray.r      += dL * k1a.x;
+    ray.theta  += dL * k1a.y;
+    ray.phi    += dL * k1a.z;
+    ray.dr     += dL * k1b.x;
+    ray.dtheta += dL * k1b.y;
+    ray.dphi   += dL * k1b.z;
 
-    ray.x = ray.radius * sin(ray.theta) * cos(ray.phi);
-    ray.y = ray.radius * sin(ray.theta) * sin(ray.phi);
-    ray.z = ray.radius * cos(ray.theta);
+    ray.x = ray.r * sin(ray.theta) * cos(ray.phi);
+    ray.y = ray.r * sin(ray.theta) * sin(ray.phi);
+    ray.z = ray.r * cos(ray.theta);
 }
 
-bool CrossesEquatorialPlane(vec3 oldPosition, vec3 newPosition) 
+bool CrossesEquatorialPlane(vec3 oldPos, vec3 newPos) 
 {
-    bool crossed = (oldPosition.y * newPosition.y < 0.0);
-    float radius = length(vec2(newPosition.x, newPosition.z));
-    return crossed && (radius >= disk_r1 && radius <= disk_r2);
+    bool crossed = (oldPos.y * newPos.y < 0.0);
+    float r = length(vec2(newPos.x, newPos.z));
+    return crossed && (r >= disk_r1 && r <= disk_r2);
 }
 
 void main() 
 {
-    ivec2 pixel = ivec2(gl_GlobalInvocationID.xy);
-    int width = imageSize(outImage).x;
-    int height = imageSize(outImage).y;
-    
-    if (pixel.x >= width || pixel.y >= height) 
+    ivec2 pix  = ivec2(gl_GlobalInvocationID.xy);
+    int WIDTH  = imageSize(outImage).x;
+    int HEIGHT = imageSize(outImage).y;
+
+    if (pix.x >= WIDTH || 
+        pix.y >= HEIGHT) 
         return;
 
-    float u = (2.0 * (pixel.x + 0.5) / width - 1.0) * cam.aspect * cam.tanHalfFov;
-    float v = (1.0 - 2.0 * (pixel.y + 0.5) / height) * cam.tanHalfFov;
-    vec3 direction = normalize(u * cam.camRight - v * cam.camUp + cam.camForward);
-    Ray ray = InitRay(cam.camPos, direction);
+    float u = (2.0 * (pix.x + 0.5) / WIDTH - 1.0) * 
+              cam.aspect * cam.tanHalfFov;
+    float v = (1.0 - 2.0 * (pix.y + 0.5) / HEIGHT) * 
+               cam.tanHalfFov;
+    vec3 dir = normalize(u * cam.camRight - 
+                         v * cam.camUp    + 
+                         cam.camForward);
+    Ray ray = InitRay(cam.camPos, dir);
 
-    vec4 color = vec4(0.0);
-    vec3 prevPosition = vec3(ray.x, ray.y, ray.z);
-    float lambda = 0.0;
+    vec4  color   = vec4(0.0);
+    vec3  prevPos = vec3(ray.x, ray.y, ray.z);
+    float lambda  = 0.0;
 
     bool hitBlackHole = false;
-    bool hitDisk = false;
-    bool hitObject = false;
+    bool hitDisk      = false;
+    bool hitObject    = false;
 
-    int steps = cam.moving ? 60000 : 60000;
+    int maxSteps = cam.moving ? MAX_STEPS_MOVING : MAX_STEPS_STATIC;
+    
+    float cameraDistance = length(cam.camPos);
+    if (cameraDistance > 1e12)
+        maxSteps = maxSteps / 4;
+    else if (cameraDistance > 5e11)
+        maxSteps = maxSteps / 2;
 
-    for (int i = 0; i < steps; ++i) 
+    for (int i = 0; i < maxSteps; ++i) 
     {
+        if (ray.r > EARLY_EXIT_DISTANCE) 
+            break;
+        if (ray.r > ESCAPE_R) 
+            break;
+        
         if (Intercept(ray, SagA_rs)) 
         { 
             hitBlackHole = true; 
@@ -169,9 +205,9 @@ void main()
         RK4Step(ray, D_LAMBDA);
         lambda += D_LAMBDA;
 
-        vec3 newPosition = vec3(ray.x, ray.y, ray.z);
+        vec3 newPos = vec3(ray.x, ray.y, ray.z);
         
-        if (CrossesEquatorialPlane(prevPosition, newPosition)) 
+        if (CrossesEquatorialPlane(prevPos, newPos)) 
         { 
             hitDisk = true; 
             break; 
@@ -183,33 +219,31 @@ void main()
             break; 
         }
         
-        prevPosition = newPosition;
-        
-        if (ray.radius > ESCAPE_R) 
-            break;
+        prevPos = newPos;
     }
 
     if (hitDisk) 
     {
-        double radius = length(vec3(ray.x, ray.y, ray.z)) / disk_r2;
-        vec3 diskColor = vec3(1.0, radius, 0.2);
-        color = vec4(diskColor, radius);
-    } 
-    else if (hitBlackHole) 
+        double r = length(vec3(ray.x, ray.y, ray.z)) / disk_r2;
+        vec3 diskColor = vec3(1.0, r, 0.2);
+        color = vec4(diskColor, r);
+
+    } else if (hitBlackHole)
         color = vec4(0.0, 0.0, 0.0, 1.0);
     else if (hitObject) 
     {
-        vec3 position = vec3(ray.x, ray.y, ray.z);
-        vec3 normal = normalize(position - hitCenter);
-        vec3 viewDirection = normalize(cam.camPos - position);
-        float ambient = 0.1;
-        float diffuse = max(dot(normal, viewDirection), 0.0);
-        float intensity = ambient + (1.0 - ambient) * diffuse;
-        vec3 shaded = objectColor.rgb * intensity;
+        vec3 P = vec3(ray.x, ray.y, ray.z);
+        vec3 N = normalize(P - hitCenter);
+        vec3 V = normalize(cam.camPos - P);
+
+        float ambient   = 0.1;
+        float diff      = max(dot(N, V), 0.0);
+        float intensity = ambient + (1.0 - ambient) * diff;
+        vec3  shaded    = objectColor.rgb * intensity;
+
         color = vec4(shaded, objectColor.a);
-    } 
-    else 
+    } else
         color = vec4(0.0);
 
-    imageStore(outImage, pixel, color);
+    imageStore(outImage, pix, color);
 }
diff --git a/assets/shaders/grid.glsl b/assets/shaders/grid.glsl
deleted file mode 100644
index 66096c4..0000000
--- a/assets/shaders/grid.glsl
+++ /dev/null
@@ -1,19 +0,0 @@
-#type vertex
-#version 330 core
-layout (location = 0) in vec3 aPos;
-
-uniform mat4 viewProj;
-
-void main()
-{
-    gl_Position = viewProj * vec4(aPos, 1.0);
-}
-
-#type fragment
-#version 330 core
-out vec4 FragColor;
-
-void main()
-{
-    FragColor = vec4(0.5, 0.5, 0.5, 0.3);
-}
diff --git a/assets/shaders/quad.glsl b/assets/shaders/quad.glsl
deleted file mode 100644
index 57693a6..0000000
--- a/assets/shaders/quad.glsl
+++ /dev/null
@@ -1,25 +0,0 @@
-#type vertex
-#version 330 core
-layout(location = 0) in vec2 a_Pos;
-layout(location = 1) in vec2 a_TexCoord;
-
-out vec2 v_TexCoord;
-
-void main()
-{
-    gl_Position = vec4(a_Pos.xy, 0.0, 1.0);
-    v_TexCoord = a_TexCoord;
-}
-
-#type fragment
-#version 330 core
-out vec4 FragColor;
-
-in vec2 v_TexCoord;
-
-uniform sampler2D screenTexture;
-
-void main()
-{
-    FragColor = texture(screenTexture, v_TexCoord);
-}
diff --git a/src/core/camera.cpp b/src/core/camera.cpp
index 43cb1ee..bba6ee2 100644
--- a/src/core/camera.cpp
+++ b/src/core/camera.cpp
@@ -1,6 +1,7 @@
 #include "camera.h"
 
 #include <glm/gtc/quaternion.hpp>
+#include <GLFW/glfw3.h>
 
 namespace Donut
 {
@@ -50,8 +51,10 @@ namespace Donut
         else if (m_camera_mode == CameraMode::Orbital)
         {
             glm::vec3 position = get_orbital_position();
-            glm::vec3 world_up(0.0f, 1.0f, 0.0f);
-            m_view_matrix = glm::lookAt(position, m_target, world_up);
+            glm::vec3 target = m_orbital_target;
+            glm::vec3 up(0.0f, 1.0f, 0.0f);
+            
+            m_view_matrix = glm::lookAt(position, target, up);
             m_view_projection_matrix = m_projection_matrix * m_view_matrix;
         }
     }
@@ -158,76 +161,65 @@ namespace Donut
         }
     }
 
-    void Camera::set_orbital_mode(bool enabled)
-    {
-        m_camera_mode = enabled ? CameraMode::Orbital : CameraMode::FPS;
-        recalculate_view_matrix();
-    }
-
     glm::vec3 Camera::get_orbital_position() const
     {
         float clamped_elevation = glm::clamp(m_elevation, 0.01f, float(M_PI) - 0.01f);
-        return glm::vec3(
-            m_radius * sin(clamped_elevation) * cos(m_azimuth),
-            m_radius * cos(clamped_elevation),
-            m_radius * sin(clamped_elevation) * sin(m_azimuth)
+        return glm::vec3
+        (
+            m_orbital_radius * sin(clamped_elevation) * cos(m_azimuth),
+            m_orbital_radius * cos(clamped_elevation),
+            m_orbital_radius * sin(clamped_elevation) * sin(m_azimuth)
         );
     }
 
+    void Camera::update_orbital()
+    {
+        m_orbital_target = glm::vec3(0.0f, 0.0f, 0.0f);
+        if (m_dragging || m_panning)
+            m_moving = true;
+        else
+            m_moving = false;
+        recalculate_view_matrix();
+    }
+
     void Camera::process_orbital_mouse_move(double x, double y)
     {
-        if (m_dragging && !m_panning) 
+        if (m_dragging && !m_panning)
         {
-            float dx = float(x - m_orbital_last_x);
-            float dy = float(y - m_orbital_last_y);
+            float dx = float(x - m_last_x_orbital);
+            float dy = float(y - m_last_y_orbital);
             
-            m_azimuth += dx * m_orbit_speed;
-            m_elevation -= dy * m_orbit_speed;
+            m_azimuth   += dx * m_orbital_speed;
+            m_elevation -= dy * m_orbital_speed;
             m_elevation = glm::clamp(m_elevation, 0.01f, float(M_PI) - 0.01f);
         }
         
-        m_orbital_last_x = x;
-        m_orbital_last_y = y;
-        update_orbital_state();
-        recalculate_view_matrix();
+        m_last_x_orbital = x;
+        m_last_y_orbital = y;
+        update_orbital();
     }
 
     void Camera::process_orbital_mouse_button(int button, int action, int mods)
     {
-        if (button == GLFW_MOUSE_BUTTON_LEFT) 
+        if (button == GLFW_MOUSE_BUTTON_LEFT)
         {
-            if (action == GLFW_PRESS) 
+            if (action == GLFW_PRESS)
             {
                 m_dragging = true;
                 m_panning = false;
-            } 
-            else if (action == GLFW_RELEASE) 
+            }
+            else if (action == GLFW_RELEASE)
             {
                 m_dragging = false;
                 m_panning = false;
             }
         }
-        update_orbital_state();
     }
 
     void Camera::process_orbital_scroll(double x_offset, double y_offset)
     {
-        m_radius -= y_offset * m_zoom_speed;
-        m_radius = glm::clamp(m_radius, m_min_radius, m_max_radius);
-        update_orbital_state();
-        recalculate_view_matrix();
-    }
-
-    void Camera::update_orbital_state()
-    {
-        m_target = glm::vec3(0.0f, 0.0f, 0.0f);
-        if (m_dragging || m_panning) 
-        {
-            m_moving = true;
-        } 
-        else 
-        {
-            m_moving = false;
-        }
+        m_orbital_radius -= y_offset * m_zoom_speed;
+        m_orbital_radius = glm::clamp(m_orbital_radius, m_orbital_min_radius, m_orbital_max_radius);
+        update_orbital();
     }
 }
diff --git a/src/core/camera.h b/src/core/camera.h
index 7ea5472..809be48 100644
--- a/src/core/camera.h
+++ b/src/core/camera.h
@@ -2,7 +2,6 @@
 
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
-#include <GLFW/glfw3.h>
 
 #define _USE_MATH_DEFINES
 #ifndef M_PI
@@ -54,20 +53,23 @@ namespace Donut
         void set_movement_speed(float speed) { m_movement_speed = speed;   }
         float get_movement_speed()    const  { return m_movement_speed;    }
 
-        void set_orbital_mode(bool enabled);
-        bool is_orbital_mode() const { return m_camera_mode == CameraMode::Orbital; }
+        void set_orbital_target(const glm::vec3& target) { m_orbital_target = target; }
+        const glm::vec3& get_orbital_target()      const { return m_orbital_target;   }
         
-        void set_target(const glm::vec3& target) { m_target = target; }
-        const glm::vec3& get_target() const { return m_target; }
+        void set_orbital_radius(double radius) { m_orbital_radius = radius; }
+        double get_orbital_radius() const { return m_orbital_radius; }
         
-        void set_radius(double radius) { m_radius = radius; }
-        double get_radius() const { return m_radius; }
+        void set_orbital_limits(double min_radius, double max_radius) 
+        { 
+            m_orbital_min_radius = min_radius; 
+            m_orbital_max_radius = max_radius; 
+        }
         
-        void set_min_radius(double min_radius) { m_min_radius = min_radius; }
-        double get_min_radius() const { return m_min_radius; }
+        void set_orbital_speed(float speed) { m_orbital_speed = speed; }
+        float get_orbital_speed() const { return m_orbital_speed; }
         
-        void set_max_radius(double max_radius) { m_max_radius = max_radius; }
-        double get_max_radius() const { return m_max_radius; }
+        void set_zoom_speed(double speed) { m_zoom_speed = speed; }
+        double get_zoom_speed() const { return m_zoom_speed; }
         
         void set_azimuth(float azimuth) { m_azimuth = azimuth; }
         float get_azimuth() const { return m_azimuth; }
@@ -75,30 +77,27 @@ namespace Donut
         void set_elevation(float elevation) { m_elevation = elevation; }
         float get_elevation() const { return m_elevation; }
         
-        void set_orbit_speed(float orbit_speed) { m_orbit_speed = orbit_speed; }
-        float get_orbit_speed() const { return m_orbit_speed; }
-        
-        void set_zoom_speed(double zoom_speed) { m_zoom_speed = zoom_speed; }
-        double get_zoom_speed() const { return m_zoom_speed; }
-        
         glm::vec3 get_orbital_position() const;
-        
+        void update_orbital();
         void process_orbital_mouse_move(double x, double y);
         void process_orbital_mouse_button(int button, int action, int mods);
         void process_orbital_scroll(double x_offset, double y_offset);
         
-        bool is_dragging() const { return m_dragging; }
-        bool is_panning() const { return m_panning; }
-        bool is_moving() const { return m_moving; }
+        void       set_camera_mode(CameraMode mode) { m_camera_mode = mode; }
+        CameraMode get_camera_mode()          const { return m_camera_mode; }
+        
+        bool  is_dragging() const { return m_dragging; }
+        bool  is_panning()  const { return m_panning;  }
+        bool  is_moving()   const { return m_moving;   }
+        double get_last_x()  const { return m_last_x;    }
+        double get_last_y()  const { return m_last_y;    }
 
     private:
         void recalculate_view_matrix();
         void recalculate_projection_matrix();
-        void update_orbital_state();
-
     private:
         CameraMode m_camera_mode = CameraMode::FPS;
-
+        
         glm::mat4 m_projection_matrix;
         glm::mat4 m_view_matrix;
         glm::mat4 m_view_projection_matrix;
@@ -116,19 +115,19 @@ namespace Donut
         bool  m_first_mouse       = true;
         float m_last_x            = 0.0f;
         float m_last_y            = 0.0f;
-
-        glm::vec3 m_target = glm::vec3(0.0f, 0.0f, 0.0f);
-        double m_radius = 6.34194e10;
-        double m_min_radius = 1e10;
-        double m_max_radius = 1e12;
-        float m_azimuth = 0.0f;
-        float m_elevation = static_cast<float>(M_PI) / 2.0f;
-        float m_orbit_speed = 0.01f;
-        double m_zoom_speed = 25e9f;
-        bool m_dragging = false;
-        bool m_panning = false;
-        bool m_moving = false;
-        double m_orbital_last_x = 0.0;
-        double m_orbital_last_y = 0.0;
+        
+        glm::vec3 m_orbital_target    = glm::vec3(0.0f, 0.0f, 0.0f);
+        double    m_orbital_radius    = 6.34194e10;
+        double    m_orbital_min_radius = 1e10;
+        double    m_orbital_max_radius = 1e12;
+        float     m_azimuth          = 0.0f;
+        float     m_elevation        = static_cast<float>(M_PI) / 2.0f;
+        float     m_orbital_speed     = 0.01f;
+        double    m_zoom_speed        = 25e9f;
+        bool      m_dragging         = false;
+        bool      m_panning          = false;
+        bool      m_moving           = false;
+        double    m_last_x_orbital    = 0.0;
+        double    m_last_y_orbital    = 0.0;
     };
 }
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
index 29fa65a..c2a84a8 100644
--- a/src/engine/engine.cpp
+++ b/src/engine/engine.cpp
@@ -1,251 +1,144 @@
-#include "engine.h"
-#include <GLFW/glfw3.h>
-#include <glad/glad.h>
 #include <iostream>
 #include <fstream>
 #include <sstream>
-#include <limits>
+
+#include <GLFW/glfw3.h>
+
+#include "engine.h"
 #include "rendering/vertex_buffer.h"
 #include "rendering/index_buffer.h"
 
 namespace Donut
 {
-    Engine::Engine() 
-        : m_sag_a(glm::vec3(0.0f, 0.0f, 0.0f), 
-          static_cast<float>(8.54e36)) 
+    Engine::Engine()
+        : m_sag_a(glm::vec3(0.0f, 0.0f, 0.0f), 8.54e36f)
     {
         GLFWwindow* window = static_cast<GLFWwindow*>(Application::get().get_window().get_native_window());
         glfwGetFramebufferSize(window, &m_width, &m_height);
-        m_compute_height = 420;
-        m_compute_width = (m_width * 420) / m_height;
         
-        m_camera.set_orbital_mode(true);
-        m_camera.set_radius(6.34194e10);
-        m_camera.set_min_radius(1e10);
-        m_camera.set_max_radius(1e12);
-        m_camera.set_orbit_speed(0.01f);
+        m_camera.set_camera_mode(CameraMode::Orbital);
+        m_camera.set_orbital_radius(6.34194e10);
+        m_camera.set_orbital_limits(1e10, 1e12);
+        m_camera.set_orbital_speed(0.01f);
         m_camera.set_zoom_speed(25e9f);
         
         m_objects = 
         {
-            { glm::vec4(4e11f, 0.0f, 0.0f, 4e10f), glm::vec4(1,1,0,1), static_cast<float>(1.98892e30) },
-            { glm::vec4(0.0f, 0.0f, 4e11f, 4e10f), glm::vec4(1,0,0,1), static_cast<float>(1.98892e30) },
-            { glm::vec4(0.0f, 0.0f, 0.0f, m_sag_a.m_rs), glm::vec4(0,0,0,1), static_cast<float>(m_sag_a.m_mass) }
+            { glm::vec4(4e11f, 0.00f, 0.00f, 4e10f),       glm::vec4(1, 1, 0, 1), static_cast<float>(1.98892e30)    },
+            { glm::vec4(0.00f, 0.00f, 4e11f, 4e10f),       glm::vec4(1, 0, 0, 1), static_cast<float>(1.98892e30)    },
+            { glm::vec4(0.00f, 0.00f, 0.00f, m_sag_a.m_rs), glm::vec4(0, 0, 0, 1), static_cast<float>(m_sag_a.m_mass) }
         };
 
-        m_quad_shader    = Shader::create("assets/shaders/quad.glsl");
-        m_grid_shader    = Shader::create("assets/shaders/grid.glsl");
-        m_compute_shader = Shader::create_compute("Geodesic", load_compute_shader("assets/shaders/geodesic.glsl"));
+        m_shader_program  = Ref<Shader>(Shader::create("assets/shaders/compute_texture_quad.glsl"));
+        m_compute_program = create_compute_program("assets/shaders/geodesic.glsl");
         
         m_camera_ubo = UniformBuffer::create(128, 1);
-        m_disk_ubo = UniformBuffer::create(sizeof(float) * 4, 2);
+        m_disk_ubo   = UniformBuffer::create(sizeof(float) * 4, 2);
         
         uint32_t obj_ubo_size = sizeof(int) + 3 * sizeof(float)
             + 16 * (sizeof(glm::vec4) + sizeof(glm::vec4))
             + 16 * sizeof(float);
         m_objects_ubo = UniformBuffer::create(obj_ubo_size, 3);
 
-        float quad_vertices[] = 
-        {
-            -1.0f,  1.0f,  0.0f, 1.0f,
-            -1.0f, -1.0f,  0.0f, 0.0f,
-             1.0f, -1.0f,  1.0f, 0.0f,
-            
-            -1.0f,  1.0f,  0.0f, 1.0f,
-             1.0f, -1.0f,  1.0f, 0.0f,
-             1.0f,  1.0f,  1.0f, 1.0f
-        };
-
-        m_quad_vao = VertexArray::create();
-        
-        auto vertex_buffer = VertexBuffer::create(quad_vertices, static_cast<uint32_t>(sizeof(quad_vertices)));
-        VertexBufferLayout layout;
-        layout.push<float>(2);
-        layout.push<float>(2);
-        vertex_buffer->set_layout(layout);
-        m_quad_vao->add_vertex_buffer(vertex_buffer);
-
-        m_texture = Texture2D::create(m_width, m_height);
+        auto result = quad_vao();
+        m_quad_vao = result.first;
+        m_texture = result.second;
     }
 
-    void Engine::generate_grid(const std::vector<ObjectData>& objects) 
+    void Engine::update_window_dimensions()
     {
-        const int grid_size = 25;
-        const float spacing = 1e10f;
-
-        std::vector<glm::vec3> vertices;
-        std::vector<uint32_t> indices;
-
-        for (int z = 0; z <= grid_size; ++z) 
-        {
-            for (int x = 0; x <= grid_size; ++x) 
-            {
-                float world_x = (x - grid_size / 2) * spacing;
-                float world_z = (z - grid_size / 2) * spacing;
-                float y = 0.0f;
-
-                for (const auto& obj : objects) 
-                {
-                    glm::vec3 obj_pos = glm::vec3(obj.m_pos_radius);
-                    double mass = obj.m_mass;
-                    double radius = obj.m_pos_radius.w;
-
-                    double r_s = 2.0 * G * mass / (c * c);
-                    double dx = world_x - obj_pos.x;
-                    double dz = world_z - obj_pos.z;
-                    double dist = sqrt(dx * dx + dz * dz);
-
-                    if (dist > r_s) 
-                    {
-                        double delta_y = 2.0 * sqrt(r_s * (dist - r_s));
-                        y += static_cast<float>(delta_y) - 3e10f;
-                    } 
-                    else 
-                    {
-                        y += 2.0f * static_cast<float>(sqrt(r_s * r_s)) - 3e10f;
-                    }
-                }
-
-                vertices.emplace_back(world_x, y, world_z);
-            }
-        }
-
-        for (int z = 0; z < grid_size; ++z) 
-        {
-            for (int x = 0; x < grid_size; ++x) 
-            {
-                int i = z * (grid_size + 1) + x;
-                indices.push_back(i);
-                indices.push_back(i + 1);
-                indices.push_back(i);
-                indices.push_back(i + grid_size + 1);
-            }
-        }
-
-        if (!m_grid_vao)
-        {
-            m_grid_vao = Ref<VertexArray>(VertexArray::create());
-            
-            auto vertex_buffer = Ref<VertexBuffer>(VertexBuffer::create(vertices.data(), static_cast<uint32_t>(vertices.size() * sizeof(glm::vec3))));
-            VertexBufferLayout layout;
-            layout.push<float>(3);
-            vertex_buffer->set_layout(layout);
-            m_grid_vao->add_vertex_buffer(vertex_buffer);
-
-            auto index_buffer = Ref<IndexBuffer>(IndexBuffer::create(indices.data(), static_cast<uint32_t>(indices.size())));
-            m_grid_vao->set_index_buffer(index_buffer);
-        }
-        else
-        {
-            auto vertex_buffer = m_grid_vao->get_vertex_buffers()[0];
-            vertex_buffer->set_data(vertices.data(), static_cast<uint32_t>(vertices.size() * sizeof(glm::vec3)));
-        }
-
-        m_grid_index_count = static_cast<int>(indices.size());
+        GLFWwindow* window = static_cast<GLFWwindow*>(Application::get().get_window().get_native_window());
+        int old_width = m_width;
+        int old_height = m_height;
+        int old_compute_height = m_compute_height;
+        
+        glfwGetFramebufferSize(window, &m_width, &m_height);
+        
+        if (old_width         != m_width  || 
+            old_height        != m_height || 
+            old_compute_height != m_compute_height)
+            update_compute_dimensions();
     }
 
-    void Engine::draw_grid(const glm::mat4& view_proj) 
+    void Engine::update_performance(float delta_time)
     {
-        if (!m_grid_shader || !m_grid_vao) 
-            return;
-        
-        m_grid_shader->bind();
-        m_grid_shader->set_mat4("viewProj", view_proj);
-        
-        RenderCommand::disable_depth_test();
-        RenderCommand::enable_blending();
-        
-        m_grid_vao->bind();
-        glDrawElements(GL_LINES, m_grid_index_count, GL_UNSIGNED_INT, nullptr);
-        
-        RenderCommand::enable_depth_test();
+        if (delta_time > 0.0f)
+            m_current_fps = 1.0f / delta_time;
     }
 
-    void Engine::update_window_dimensions() 
+    void Engine::update_compute_dimensions()
     {
-        GLFWwindow* window = static_cast<GLFWwindow*>(Application::get().get_window().get_native_window());
-        int old_width = m_width;
-        int old_height = m_height;
-        glfwGetFramebufferSize(window, &m_width, &m_height);
-        m_compute_height = 420;
-        m_compute_width = (m_width * 420) / m_height;
-        
-        if (old_width != m_width || old_height != m_height)
-            m_texture = Texture2D::create(m_width, m_height);
+        m_texture = Texture2D::create(get_compute_width(), m_compute_height);
     }
 
-    void Engine::draw_full_screen_quad() 
+    void Engine::draw_full_screen_quad()
     {
         RenderCommand::set_viewport(0, 0, m_width, m_height);
         
-        m_quad_shader->bind();
-        std::cout << "Texture ID: " << m_texture->get_renderer_id() << ", Size: " << m_texture->get_width() << "x" << m_texture->get_height() << std::endl;
+        m_shader_program->bind();
+        m_quad_vao->bind();
+
         m_texture->bind(0);
-        m_quad_shader->set_int("screenTexture", 0);
-        std::cout << "Set screenTexture uniform to slot 0\n";
+        m_shader_program->set_int("u_ScreenTexture", 0);
 
         RenderCommand::disable_depth_test();
-        RenderCommand::draw_indexed(m_quad_vao, 6);
+        RenderCommand::draw_arrays(6);
         RenderCommand::enable_depth_test();
     }
 
-    void Engine::dispatch_compute(const Camera& cam) 
+    void Engine::dispatch_compute(const Camera& cam)
     {
-        int cw = m_compute_width;
+        int cw = get_compute_width();
         int ch = m_compute_height;
 
-        if (m_texture->get_width() != cw || m_texture->get_height() != ch) 
-            m_texture = Texture2D::create(cw, ch);
+        m_texture->set_data(nullptr, cw * ch * 4);
 
-        m_compute_shader->bind();
+        m_compute_program->bind();
         upload_camera_ubo(cam);
         upload_disk_ubo();
         upload_objects_ubo(m_objects);
-
         m_texture->bind_as_image(0, false);
 
-        uint32_t groups_x = (uint32_t)std::ceil(cw / 16.0f);
-        uint32_t groups_y = (uint32_t)std::ceil(ch / 16.0f);
-        m_compute_shader->dispatch(groups_x, groups_y, 1);
-        m_compute_shader->memory_barrier(IMAGE_ACCESS_BARRIER_BIT);
-        
-        glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
-        glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
+        uint32_t groups_x = static_cast<uint32_t>(std::ceil(cw / 16.0f));
+        uint32_t groups_y = static_cast<uint32_t>(std::ceil(ch / 16.0f));
+        m_compute_program->dispatch(groups_x, groups_y, 1);
+        m_compute_program->memory_barrier(IMAGE_ACCESS_BARRIER_BIT);
     }
 
-    void Engine::upload_camera_ubo(const Camera& cam) 
+    void Engine::upload_camera_ubo(const Camera& cam)
     {
-        struct UBOData 
+        struct UBOData
         {
-            glm::vec3 pos; float _pad0;
-            glm::vec3 right; float _pad1;
-            glm::vec3 up; float _pad2;
+            glm::vec3 pos;     float _pad0;
+            glm::vec3 right;   float _pad1;
+            glm::vec3 up;      float _pad2;
             glm::vec3 forward; float _pad3;
             float tan_half_fov;
             float aspect;
-            bool moving;
-            int _pad4;
+            bool  moving;
+            int   _pad4;
         } data;
 
-        glm::vec3 fwd = glm::normalize(cam.get_target() - cam.get_orbital_position());
-        glm::vec3 up = glm::vec3(0, 1, 0);
+        glm::vec3 fwd   = glm::normalize(cam.get_orbital_target() - cam.get_orbital_position());
+        glm::vec3 up    = glm::vec3(0, 1, 0);
         glm::vec3 right = glm::normalize(glm::cross(fwd, up));
         up = glm::cross(right, fwd);
 
-        data.pos = cam.get_orbital_position();
-        data.right = right;
-        data.up = up;
-        data.forward = fwd;
+        data.pos        = cam.get_orbital_position();
+        data.right      = right;
+        data.up         = up;
+        data.forward    = fwd;
         data.tan_half_fov = static_cast<float>(tan(glm::radians(60.0f * 0.5f)));
-        data.aspect = static_cast<float>(m_width) / static_cast<float>(m_height);
-        data.moving = cam.is_dragging() || cam.is_panning();
+        data.aspect     = static_cast<float>(get_compute_width()) / static_cast<float>(m_compute_height);
+        data.moving     = cam.is_dragging() || cam.is_panning();
 
         m_camera_ubo->set_data(&data, sizeof(UBOData));
+        m_camera_ubo->bind(1);
     }
 
-    void Engine::upload_objects_ubo(const std::vector<ObjectData>& objs) 
+    void Engine::upload_objects_ubo(const std::vector<ObjectData>& objs)
     {
-        struct UBOData 
+        struct UBOData
         {
             int num_objects;
             float _pad0, _pad1, _pad2;
@@ -257,7 +150,7 @@ namespace Donut
         size_t count = std::min(objs.size(), size_t(16));
         data.num_objects = static_cast<int>(count);
 
-        for (size_t i = 0; i < count; ++i) 
+        for (size_t i = 0; i < count; ++i)
         {
             data.pos_radius[i] = objs[i].m_pos_radius;
             data.color[i] = objs[i].m_color;
@@ -265,9 +158,10 @@ namespace Donut
         }
 
         m_objects_ubo->set_data(&data, sizeof(data));
+        m_objects_ubo->bind(3);
     }
 
-    void Engine::upload_disk_ubo() 
+    void Engine::upload_disk_ubo()
     {
         float r1 = static_cast<float>(m_sag_a.m_rs * 2.2);
         float r2 = static_cast<float>(m_sag_a.m_rs * 5.2);
@@ -276,28 +170,28 @@ namespace Donut
         float disk_data[4] = { r1, r2, num, thickness };
 
         m_disk_ubo->set_data(disk_data, sizeof(disk_data));
+        m_disk_ubo->bind(2);
     }
 
-    void Engine::update_physics(float delta_time) 
+    void Engine::update_physics(float delta_time)
     {
-        for (auto& obj : m_objects) 
+        for (auto& obj : m_objects)
         {
-            for (auto& obj2 : m_objects) 
+            for (auto& obj2 : m_objects)
             {
                 if (&obj == &obj2) continue;
                 float dx = obj2.m_pos_radius.x - obj.m_pos_radius.x;
                 float dy = obj2.m_pos_radius.y - obj.m_pos_radius.y;
                 float dz = obj2.m_pos_radius.z - obj.m_pos_radius.z;
                 float distance = sqrt(dx * dx + dy * dy + dz * dz);
-
-                if (distance > 0) 
+                if (distance > 0)
                 {
                     std::vector<double> direction = {dx / distance, dy / distance, dz / distance};
                     double Gforce = (G * obj.m_mass * obj2.m_mass) / (distance * distance);
                     double acc1 = Gforce / obj.m_mass;
                     std::vector<double> acc = {direction[0] * acc1, direction[1] * acc1, direction[2] * acc1};
-
-                    if (m_gravity) 
+                    
+                    if (m_gravity)
                     {
                         obj.m_velocity.x += static_cast<float>(acc[0]);
                         obj.m_velocity.y += static_cast<float>(acc[1]);
@@ -314,34 +208,49 @@ namespace Donut
 
     void Engine::render_scene()
     {
-        glm::mat4 view = glm::lookAt(m_camera.get_orbital_position(), m_camera.get_target(), glm::vec3(0,1,0));
-        glm::mat4 proj = glm::perspective(glm::radians(60.0f), float(m_width)/m_height, 1e9f, 1e14f);
-        glm::mat4 view_proj = proj * view;
-        
-        generate_grid(m_objects);
-        draw_grid(view_proj);
-        
-        RenderCommand::set_viewport(0, 0, m_width, m_height);
-        dispatch_compute(m_camera);
-        draw_full_screen_quad();
+        RenderCommand::clear();
+        m_shader_program->bind();
+        m_quad_vao->bind();
+        m_texture->bind(0);
+        RenderCommand::draw_arrays(6);
     }
 
-    std::string Engine::load_compute_shader(const std::string& path)
+    Ref<Shader> Engine::create_compute_program(const char* path)
     {
         std::ifstream in(path);
-        if(!in.is_open()) 
+        if(!in.is_open())
         {
             std::cerr << "Failed to open compute shader: " << path << "\n";
-            return "";
+            return nullptr;
         }
-
         std::stringstream ss;
         ss << in.rdbuf();
-        std::string result = ss.str();
-        if (result.empty()) 
-            std::cerr << "Warning: Compute shader file is empty: " << path << "\n";
-        else 
-            std::cout << "Successfully loaded compute shader: " << path << " (size: " << result.size() << " bytes)\n";
-        return result;
+        std::string src_str = ss.str();
+        return Ref<Shader>(Shader::create_compute("ComputeShader", src_str));
+    }
+
+    std::pair<Ref<VertexArray>, Ref<Texture2D>> Engine::quad_vao()
+    {
+        float quad_vertices[] = 
+        {
+            -1.0f,  1.0f,  0.0f, 1.0f,
+            -1.0f, -1.0f,  0.0f, 0.0f,
+             1.0f, -1.0f,  1.0f, 0.0f,
+            -1.0f,  1.0f,  0.0f, 1.0f,
+             1.0f, -1.0f,  1.0f, 0.0f,
+             1.0f,  1.0f,  1.0f, 1.0f
+        };
+
+        auto vertex_buffer = Ref<VertexBuffer>(VertexBuffer::create(quad_vertices, static_cast<uint32_t>(sizeof(quad_vertices))));
+        VertexBufferLayout layout;
+        layout.push<float>(2);
+        layout.push<float>(2);
+        vertex_buffer->set_layout(layout);
+
+        auto vertex_array = Ref<VertexArray>(VertexArray::create());
+        vertex_array->add_vertex_buffer(vertex_buffer);
+        auto texture = Texture2D::create(get_compute_width(), m_compute_height);
+        
+        return { vertex_array, texture };
     }
 }
diff --git a/src/engine/engine.h b/src/engine/engine.h
index 6f90efb..39791c1 100644
--- a/src/engine/engine.h
+++ b/src/engine/engine.h
@@ -2,10 +2,6 @@
 
 #include <vector>
 #include <iostream>
-#include <GLFW/glfw3.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
 #include <fstream>
 #include <sstream>
 #include <chrono>
@@ -15,16 +11,27 @@
 #include "core/camera.h"
 #include "rendering/renderer.h"
 #include "rendering/shader.h"
-#include "rendering/texture.h"
 #include "rendering/vertex_array.h"
+#include "rendering/texture.h"
 #include "rendering/uniform_buffer.h"
+#include "rendering/texture_manager.h"
+
+#include <GLFW/glfw3.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#define _USE_MATH_DEFINES
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
 namespace Donut
 {
     const double c = 299792458.0;
     const double G = 6.67430e-11;
 
-    struct BlackHole 
+    struct BlackHole
     {
         glm::vec3 m_position;
         double m_mass;
@@ -32,13 +39,12 @@ namespace Donut
         double m_rs;
 
         BlackHole(glm::vec3 pos, float mass) 
-            : m_position(pos),
-              m_mass(mass) 
+            : m_position(pos), m_mass(mass)
         {
             m_rs = 2.0 * G * m_mass / (c * c);
         }
 
-        bool intercept(float px, float py, float pz) const 
+        bool intercept(float px, float py, float pz) const
         {
             double dx = double(px) - double(m_position.x);
             double dy = double(py) - double(m_position.y);
@@ -48,11 +54,11 @@ namespace Donut
         }
     };
 
-    struct ObjectData 
+    struct ObjectData
     {
         glm::vec4 m_pos_radius;
         glm::vec4 m_color;
-        float m_mass;
+        float     m_mass;
         glm::vec3 m_velocity = glm::vec3(0.0f, 0.0f, 0.0f);
     };
 
@@ -62,8 +68,6 @@ namespace Donut
         Engine();
         ~Engine() = default;
 
-        void generate_grid(const std::vector<ObjectData>& objects);
-        void draw_grid(const glm::mat4& view_proj);
         void draw_full_screen_quad();
         void dispatch_compute(const Camera& cam);
         void upload_camera_ubo(const Camera& cam);
@@ -73,46 +77,47 @@ namespace Donut
         void update_physics(float delta_time);
         void update_window_dimensions();
 
-              Camera& get_camera()       { return m_camera; }
-        const Camera& get_camera() const { return m_camera; }
-        
-        const std::vector<ObjectData>& get_objects() const { return m_objects; }
-              std::vector<ObjectData>& get_objects()       { return m_objects; }
-        
-        bool get_gravity() const       { return m_gravity;    }
-        void set_gravity(bool gravity) { m_gravity = gravity; }
-        
-        int get_width()         const { return m_width;         }
-        int get_height()        const { return m_height;        }
-        int get_compute_width()  const { return m_compute_width;  }
-        int get_compute_height() const { return m_compute_height; }
+        int get_width()  const { return m_width;  }
+        int get_height() const { return m_height; }
+
+        std::vector<ObjectData>& get_objects() { return m_objects; }
+        BlackHole&               get_sag_a()    { return m_sag_a;    }
+        Camera&                  get_camera()  { return m_camera;  }
+        bool&                    get_gravity() { return m_gravity; }
 
+        void  update_performance(float delta_time);
+        void  set_target_fps(int fps)        { m_target_fps = fps;                             }
+        int   get_target_fps()         const { return m_target_fps;                            }
+        float get_current_fps()        const { return m_current_fps;                           }
+        void  set_compute_height(int height) { m_compute_height = height;                      }
+        int   get_compute_height()     const { return m_compute_height;                        }
+        int   get_compute_width()      const { return (m_width * m_compute_height) / m_height; }
+        void  update_compute_dimensions();
     private:
-        std::string create_basic_vertex_shader();
-        std::string create_basic_fragment_shader();
-        std::string load_compute_shader(const std::string& path);
+        Ref<Shader> create_compute_program(const char* path);
+        std::pair<Ref<VertexArray>, Ref<Texture2D>> quad_vao();
     private:
-        Ref<Shader>        m_grid_shader;
-        Ref<Shader>        m_quad_shader;
-        Ref<Shader>        m_compute_shader;
-        Ref<Texture2D>     m_texture;
         Ref<VertexArray>   m_quad_vao;
-        Ref<VertexArray>   m_grid_vao;
+        Ref<Texture2D>     m_texture;
+        Ref<Shader>        m_shader_program;
+        Ref<Shader>        m_compute_program;
         Ref<UniformBuffer> m_camera_ubo;
         Ref<UniformBuffer> m_disk_ubo;
         Ref<UniformBuffer> m_objects_ubo;
-        
-        int   m_grid_index_count = 0;
+
         int   m_width;
         int   m_height;
-        int   m_compute_width;
-        int   m_compute_height;
-        float m_width_scale = 100000000000.0f;
-        float m_height_scale = 75000000000.0f;
+        float m_width_f = 100*10e10f;
+        float m_height_f = 75*10e10f;
+
+        int   m_target_fps     = 60;
+        float m_current_fps    = 60.0f;
+        float m_last_frame_time = 0.0f;
+        int   m_compute_height = 320;
 
         std::vector<ObjectData> m_objects;
         BlackHole               m_sag_a;
         Camera                  m_camera;
         bool                    m_gravity = false;
     };
-}
+};
diff --git a/src/engine/object.cpp b/src/engine/object.cpp
deleted file mode 100644
index 2e76b16..0000000
--- a/src/engine/object.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "object.h"
-
-namespace Donut
-{
-    Ray::Ray(glm::vec3 o, glm::vec3 d) 
-        : m_origin(o), 
-          m_direction(glm::normalize(d)) { }
-
-    Material::Material(glm::vec3 c, float s, float e)
-        : m_color(c), 
-          m_specular(s), 
-          m_emission(e) { }
-
-    Object::Object(glm::vec3 c, float r, Material m) 
-        : m_centre(c), 
-          m_radius(r), 
-          m_material(m) { }
-
-    bool Object::intersect(Ray &ray, float &t)
-    {
-        glm::vec3 oc = ray.m_origin - m_centre;
-        float a = glm::dot(ray.m_direction, ray.m_direction); 
-        float b = 2.0f * glm::dot(oc, ray.m_direction);
-        float c = glm::dot(oc, oc) - m_radius * m_radius;
-        double discriminant = b*b - 4*a*c;
-
-        if(discriminant < 0)
-            return false;
-
-        float intercept = (-b - sqrt(discriminant)) / (2.0f*a);
-        if(intercept < 0)
-        {
-            intercept = (-b + sqrt(discriminant)) / (2.0f*a);
-            if(intercept<0)
-                return false;
-        }
-
-        t = intercept;
-        return true;
-    }
-
-    glm::vec3 Object::get_normal(glm::vec3 &point) const
-    {
-        return glm::normalize(point - m_centre);
-    }
-}
diff --git a/src/engine/object.h b/src/engine/object.h
index 5f5d86f..c45815b 100644
--- a/src/engine/object.h
+++ b/src/engine/object.h
@@ -10,7 +10,9 @@ namespace Donut
         glm::vec3 m_direction;
         glm::vec3 m_origin;
 
-        Ray(glm::vec3 o, glm::vec3 d);
+        Ray(glm::vec3 o, glm::vec3 d) 
+            : m_origin(o), 
+              m_direction(glm::normalize(d)) { }
     };
 
     class Material
@@ -20,7 +22,10 @@ namespace Donut
         float     m_specular;
         float     m_emission;
 
-        Material(glm::vec3 c, float s, float e);
+        Material(glm::vec3 c, float s, float e)
+            : m_color(c), 
+              m_specular(s), 
+              m_emission(e) { }
     };
 
     class Object
@@ -30,9 +35,37 @@ namespace Donut
         float     m_radius;
         Material  m_material;
     
-        Object(glm::vec3 c, float r, Material m);
+        Object(glm::vec3 c, float r, Material m) 
+            : m_centre(c), 
+              m_radius(r), 
+              m_material(m) { }
     
-        bool intersect(Ray &ray, float &t);
-        glm::vec3 get_normal(glm::vec3 &point) const;
+        bool intersect(Ray &ray, float &t)
+        {
+            glm::vec3 oc = ray.m_origin - m_centre;
+            float a = glm::dot(ray.m_direction, ray.m_direction); 
+            float b = 2.0f * glm::dot(oc, ray.m_direction);
+            float c = glm::dot(oc, oc) - m_radius * m_radius;
+            double discriminant = b*b - 4*a*c;
+
+            if(discriminant < 0)
+                return false;
+    
+            float intercept = (-b - sqrt(discriminant)) / (2.0f*a);
+            if(intercept < 0)
+            {
+                intercept = (-b + sqrt(discriminant)) / (2.0f*a);
+                if(intercept<0)
+                    return false;
+            }
+
+            t = intercept;
+            return true;
+        }
+    
+        glm::vec3 get_normal(glm::vec3 &point) const
+        {
+            return glm::normalize(point - m_centre);
+        }
     };
 };
diff --git a/src/engine/scene.cpp b/src/engine/scene.cpp
deleted file mode 100644
index bfac1aa..0000000
--- a/src/engine/scene.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "scene.h"
-
-namespace Donut
-{
-    Scene::Scene() 
-        : m_light_pos(5.0f, 5.0f, 5.0f) { }
-
-    glm::vec3 Scene::trace(Ray &ray)
-    {
-        float closest = std::numeric_limits<float>::infinity();
-        const Object* hit_obj = nullptr;
-
-        for(auto& obj : objs)
-        {
-            float t;
-
-            if(obj.intersect(ray, t))
-                if(t < closest) 
-                {
-                    closest = t;
-                    hit_obj = &obj;
-                }
-        }
-        
-        if(hit_obj)
-        {
-            glm::vec3 hit_point = ray.m_origin + ray.m_direction * closest;
-            glm::vec3 normal = hit_obj->get_normal(hit_point);
-            glm::vec3 light_dir = glm::normalize(m_light_pos - hit_point);
-
-            float diff = std::max(glm::dot(normal, light_dir), 0.0f);
-
-            Ray shadow_ray(hit_point + normal * 0.001f, light_dir);
-            bool in_shadow = false;
-            
-            for(auto& obj : objs) 
-            {
-                float t;
-
-                if(obj.intersect(shadow_ray, t)) 
-                {
-                    in_shadow = true;
-                    break;
-                }
-            }
-
-            glm::vec3 color = hit_obj->m_material.m_color;
-            float ambient = 0.1f;
-
-            if (in_shadow) 
-                return color * ambient;
-            return color * (ambient + diff * 0.9f);
-        }
-
-        return glm::vec3(0.0f, 0.0f, 0.1f); 
-    }
-}
diff --git a/src/engine/scene.h b/src/engine/scene.h
index abe582e..2ac9cd8 100644
--- a/src/engine/scene.h
+++ b/src/engine/scene.h
@@ -2,7 +2,6 @@
 
 #include <vector>
 #include <limits>
-#include <glm/glm.hpp>
 
 #include "object.h"
 
@@ -14,7 +13,57 @@ namespace Donut
         std::vector<Object> objs;
         glm::vec3 m_light_pos;
 
-        Scene();
-        glm::vec3 trace(Ray &ray);
+        Scene() 
+            : m_light_pos(5.0f, 5.0f, 5.0f) { }
+    
+        glm::vec3 trace(Ray &ray)
+        {
+            float closest = std::numeric_limits<float>::infinity();
+            const Object* hit_obj = nullptr;
+    
+            for(auto& obj : objs)
+            {
+                float t;
+
+                if(obj.intersect(ray, t))
+                    if(t < closest) 
+                    {
+                        closest = t;
+                        hit_obj = &obj;
+                    }
+            }
+            
+            if(hit_obj)
+            {
+                glm::vec3 hit_point = ray.m_origin + ray.m_direction * closest;
+                glm::vec3 normal = hit_obj->get_normal(hit_point);
+                glm::vec3 light_dir = glm::normalize(m_light_pos - hit_point);
+    
+                float diff = std::max(glm::dot(normal, light_dir), 0.0f);
+    
+                Ray shadow_ray(hit_point + normal * 0.001f, light_dir);
+                bool in_shadow = false;
+                
+                for(auto& obj : objs) 
+                {
+                    float t;
+
+                    if(obj.intersect(shadow_ray, t)) 
+                    {
+                        in_shadow = true;
+                        break;
+                    }
+                }
+    
+                glm::vec3 color = hit_obj->m_material.m_color;
+                float ambient = 0.1f;
+    
+                if (in_shadow) 
+                    return color * ambient;
+                return color * (ambient + diff * 0.9f);
+            }
+    
+            return glm::vec3(0.0f, 0.0f, 0.1f); 
+        }
     };
 };
diff --git a/src/platform/opengl/opengl_renderer_api.cpp b/src/platform/opengl/opengl_renderer_api.cpp
index 628c0af..bfb79ac 100644
--- a/src/platform/opengl/opengl_renderer_api.cpp
+++ b/src/platform/opengl/opengl_renderer_api.cpp
@@ -83,4 +83,27 @@ namespace Donut
         glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, nullptr);
         glBindTexture(GL_TEXTURE_2D, 0);
     }
+
+    void OpenGLRendererAPI::draw_arrays(uint32_t vertex_count, uint32_t first)
+    {
+        glDrawArrays(GL_TRIANGLES, first, vertex_count);
+    }
+
+    void OpenGLRendererAPI::draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count)
+    {
+        uint32_t count = index_count ? index_count : vertex_array->get_index_buffer()->get_count();
+        glDrawElements(GL_LINES, count, GL_UNSIGNED_INT, nullptr);
+    }
+
+    void OpenGLRendererAPI::bind_texture(uint32_t texture_id, uint32_t slot)
+    {
+        glActiveTexture(GL_TEXTURE0 + slot);
+        glBindTexture(GL_TEXTURE_2D, texture_id);
+    }
+
+    void OpenGLRendererAPI::bind_image_texture(uint32_t texture_id, uint32_t slot, bool read_only)
+    {
+        glBindImageTexture(slot, texture_id, 0, GL_FALSE, 0, 
+                          read_only ? GL_READ_ONLY : GL_WRITE_ONLY, GL_RGBA8);
+    }
 };
diff --git a/src/platform/opengl/opengl_renderer_api.h b/src/platform/opengl/opengl_renderer_api.h
index fd446c6..45e6a7b 100644
--- a/src/platform/opengl/opengl_renderer_api.h
+++ b/src/platform/opengl/opengl_renderer_api.h
@@ -26,5 +26,15 @@ namespace Donut
 
         virtual void draw_indexed(const Ref<VertexArray>& vertex_array, 
                                  uint32_t index_count = 0)         override;
+        
+        virtual void draw_arrays(uint32_t vertex_count, 
+                                uint32_t first = 0)               override;
+        virtual void draw_lines(const Ref<VertexArray>& vertex_array, 
+                               uint32_t index_count = 0)           override;
+        virtual void bind_texture(uint32_t texture_id, 
+                                 uint32_t slot = 0)               override;
+        virtual void bind_image_texture(uint32_t texture_id, 
+                                      uint32_t slot = 0, 
+                                      bool read_only = false)      override;
     };
 };
diff --git a/src/platform/opengl/opengl_uniform_buffer.h b/src/platform/opengl/opengl_uniform_buffer.h
index 2a9131f..ae99a56 100644
--- a/src/platform/opengl/opengl_uniform_buffer.h
+++ b/src/platform/opengl/opengl_uniform_buffer.h
@@ -12,11 +12,10 @@ namespace Donut
         virtual ~OpenGLUniformBuffer();
 
         virtual void set_data(const void* data, uint32_t size, uint32_t offset = 0) override;
-        virtual void bind(uint32_t binding) override;
-
+        virtual void bind(uint32_t binding)                                        override;
     private:
         uint32_t m_renderer_id = 0;
-        uint32_t m_size = 0;
-        uint32_t m_binding = 0;
+        uint32_t m_size       = 0;
+        uint32_t m_binding    = 0;
     };
 };
diff --git a/src/platform/vulkan/vulkan_renderer_api.cpp b/src/platform/vulkan/vulkan_renderer_api.cpp
index 6273d31..8a3069e 100644
--- a/src/platform/vulkan/vulkan_renderer_api.cpp
+++ b/src/platform/vulkan/vulkan_renderer_api.cpp
@@ -2,43 +2,59 @@
 
 namespace Donut
 {
-	void VulkanRendererAPI::init()
-	{
-	}
+    void VulkanRendererAPI::init()
+    {
+    }
 
-	void VulkanRendererAPI::set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
-	{
-	}
+    void VulkanRendererAPI::set_viewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
+    {
+    }
 
-	void VulkanRendererAPI::set_clear_color(const glm::vec4& color)
-	{
-	}
+    void VulkanRendererAPI::set_clear_color(const glm::vec4& color)
+    {
+    }
 
-	void VulkanRendererAPI::clear()
-	{
-	}
+    void VulkanRendererAPI::clear()
+    {
+    }
 
-	void VulkanRendererAPI::enable_depth_test()
-	{
-	}
+    void VulkanRendererAPI::enable_depth_test()
+    {
+    }
 
-	void VulkanRendererAPI::disable_depth_test()
-	{
-	}
+    void VulkanRendererAPI::disable_depth_test()
+    {
+    }
 
-	void VulkanRendererAPI::set_face_culling(bool enabled)
-	{
-	}
+    void VulkanRendererAPI::set_face_culling(bool enabled)
+    {
+    }
 
-	void VulkanRendererAPI::enable_blending()
-	{
-	}
+    void VulkanRendererAPI::enable_blending()
+    {
+    }
 
-	void VulkanRendererAPI::disable_blending()
-	{
-	}
+    void VulkanRendererAPI::disable_blending()
+    {
+    }
 
-	void VulkanRendererAPI::draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count)
-	{
-	}
+    void VulkanRendererAPI::draw_indexed(const Ref<VertexArray>& vertex_array, uint32_t index_count)
+    {
+    }
+
+    void VulkanRendererAPI::draw_arrays(uint32_t vertex_count, uint32_t first)
+    {
+    }
+
+    void VulkanRendererAPI::draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count)
+    {
+    }
+
+    void VulkanRendererAPI::bind_texture(uint32_t texture_id, uint32_t slot)
+    {
+    }
+
+    void VulkanRendererAPI::bind_image_texture(uint32_t texture_id, uint32_t slot, bool read_only)
+    {
+    }
 };
diff --git a/src/platform/vulkan/vulkan_renderer_api.h b/src/platform/vulkan/vulkan_renderer_api.h
index c0075a2..e1d4566 100644
--- a/src/platform/vulkan/vulkan_renderer_api.h
+++ b/src/platform/vulkan/vulkan_renderer_api.h
@@ -5,22 +5,32 @@
 
 namespace Donut
 {
-	class VulkanRendererAPI 
-		: public RendererAPI
-	{
-	public:
-		virtual void init()                                       override;
-		virtual void set_viewport(uint32_t x, uint32_t y,
-								 uint32_t width, uint32_t height) override;
-		virtual void set_clear_color(const glm::vec4& color)        override;
-		virtual void clear()                                      override;
-		virtual void enable_depth_test()                            override;
-		virtual void disable_depth_test()                           override;
-		virtual void set_face_culling(bool enabled)                 override;
-		virtual void enable_blending()                             override;
-		virtual void disable_blending()                            override;
+    class VulkanRendererAPI 
+        : public RendererAPI
+    {
+    public:
+        virtual void init()                                       override;
+        virtual void set_viewport(uint32_t x,     uint32_t y, 
+                                 uint32_t width, uint32_t height) override;
+        virtual void set_clear_color(const glm::vec4& color)        override;
+        virtual void clear()                                      override;
+        virtual void enable_depth_test()                            override;
+        virtual void disable_depth_test()                           override;
+        virtual void set_face_culling(bool enabled)                 override;
+        virtual void enable_blending()                             override;
+        virtual void disable_blending()                            override;
 
-		virtual void draw_indexed(const Ref<VertexArray>& vertex_array, 
-								 uint32_t index_count = 0) override;
-	};
+        virtual void draw_indexed(const Ref<VertexArray>& vertex_array, 
+                                 uint32_t index_count = 0)         override;
+        
+        virtual void draw_arrays(uint32_t vertex_count, 
+                                uint32_t first = 0)               override;
+        virtual void draw_lines(const Ref<VertexArray>& vertex_array, 
+                               uint32_t index_count = 0)           override;
+        virtual void bind_texture(uint32_t texture_id, 
+                                 uint32_t slot = 0)               override;
+        virtual void bind_image_texture(uint32_t texture_id, 
+                                      uint32_t slot = 0, 
+                                      bool read_only = false)      override;
+    };
 };
diff --git a/src/platform/vulkan/vulkan_uniform_buffer.h b/src/platform/vulkan/vulkan_uniform_buffer.h
index e3c9196..8dd7686 100644
--- a/src/platform/vulkan/vulkan_uniform_buffer.h
+++ b/src/platform/vulkan/vulkan_uniform_buffer.h
@@ -11,10 +11,9 @@ namespace Donut
         virtual ~VulkanUniformBuffer();
 
         virtual void set_data(const void* data, uint32_t size, uint32_t offset = 0) override;
-        virtual void bind(uint32_t binding) override;
-
+        virtual void bind(uint32_t binding)                                        override;
     private:
-        uint32_t m_size = 0;
-        uint32_t m_binding = 0;
+        uint32_t m_size;
+        uint32_t m_binding;
     };
 };
diff --git a/src/rendering/index_buffer.cpp b/src/rendering/index_buffer.cpp
index 3271a5a..1095e3b 100644
--- a/src/rendering/index_buffer.cpp
+++ b/src/rendering/index_buffer.cpp
@@ -6,14 +6,14 @@
 
 namespace Donut 
 {
-    Ref<IndexBuffer> IndexBuffer::create(const uint32_t* indices, uint32_t count) 
+    IndexBuffer* IndexBuffer::create(const uint32_t* indices, uint32_t count) 
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLIndexBuffer>(indices, count);
+                return new OpenGLIndexBuffer(indices, count);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanIndexBuffer>((uint32_t*)indices, count);
+                return new VulkanIndexBuffer((uint32_t*)indices, count);
             default:
                 return nullptr;
         }
diff --git a/src/rendering/index_buffer.h b/src/rendering/index_buffer.h
index 9859c20..856559a 100644
--- a/src/rendering/index_buffer.h
+++ b/src/rendering/index_buffer.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "core/memory.h"
 #include <cstdint>
 
 namespace Donut
@@ -14,6 +13,6 @@ namespace Donut
         virtual void     unbind()   const = 0;
         virtual uint32_t get_count() const = 0;
 
-        static Ref<IndexBuffer> create(const uint32_t* indices, uint32_t count);
+        static IndexBuffer* create(const uint32_t* indices, uint32_t count);
     };
 };
diff --git a/src/rendering/renderer.cpp b/src/rendering/renderer.cpp
index f34e2b0..5e4682c 100644
--- a/src/rendering/renderer.cpp
+++ b/src/rendering/renderer.cpp
@@ -7,14 +7,14 @@
 
 namespace Donut 
 {
-    Ref<RendererAPI> RendererAPI::create()
+    Scope<RendererAPI> RendererAPI::create()
      {
         switch (s_api)
         {
             case API::OpenGL:
-                return create_ref<OpenGLRendererAPI>();
+                return create_scope<OpenGLRendererAPI>();
             case API::Vulkan:
-                return create_ref<VulkanRendererAPI>();
+                return create_scope<VulkanRendererAPI>();
             default:
                 return nullptr;
         }
@@ -50,7 +50,7 @@ namespace Donut
         RenderCommand::draw_indexed(vertex_array);
     }
 
-    Ref<RendererAPI> RenderCommand::s_renderer_api = RendererAPI::create();
+    Scope<RendererAPI> RenderCommand::s_renderer_api = RendererAPI::create();
 
     void Renderer::set_clear_color(const glm::vec4& color)
     {
diff --git a/src/rendering/renderer.h b/src/rendering/renderer.h
index 4a028e5..67ad998 100644
--- a/src/rendering/renderer.h
+++ b/src/rendering/renderer.h
@@ -20,23 +20,31 @@ namespace Donut
     public:
         virtual ~RendererAPI() = default;
 
-        virtual void init()                                       = 0;
+        virtual void init()                                               = 0;
         virtual void set_viewport(uint32_t x, uint32_t y, 
-                                 uint32_t width, uint32_t height) = 0;
-        virtual void set_clear_color(const glm::vec4& color)        = 0;
-        virtual void clear()                                      = 0;
-        virtual void enable_depth_test()                            = 0;
-        virtual void disable_depth_test()                           = 0;
-        virtual void set_face_culling(bool enabled)                 = 0;
-        virtual void enable_blending()                             = 0;
-        virtual void disable_blending()                            = 0;
+                                 uint32_t width, uint32_t height)         = 0;
+        virtual void set_clear_color(const glm::vec4& color)                = 0;
+        virtual void clear()                                              = 0;
+        virtual void enable_depth_test()                                    = 0;
+        virtual void disable_depth_test()                                   = 0;
+        virtual void set_face_culling(bool enabled)                         = 0;
+        virtual void enable_blending()                                     = 0;
+        virtual void disable_blending()                                    = 0;
 
         virtual void draw_indexed(const Ref<VertexArray>& vertex_array, 
-                                 uint32_t index_count = 0)         = 0;
+                                 uint32_t index_count = 0)                 = 0;
+        
+        virtual void draw_arrays(uint32_t vertex_count, uint32_t first = 0) = 0;
+        virtual void draw_lines(const Ref<VertexArray>& vertex_array, 
+                               uint32_t index_count = 0)                   = 0;
+        virtual void bind_texture(uint32_t texture_id, uint32_t slot = 0)   = 0;
+        virtual void bind_image_texture(uint32_t texture_id, 
+                                      uint32_t slot = 0, 
+                                      bool read_only = false)              = 0;
 
         inline static API get_api()         { return s_api; }
         inline static void set_api(API api) { s_api = api;  }
-        static Ref<RendererAPI> create();
+        static Scope<RendererAPI> create();
     private:
         static API s_api;
     };
@@ -94,8 +102,28 @@ namespace Donut
             s_renderer_api->draw_indexed(vertex_array, index_count);
         }
 
+        inline static void draw_arrays(uint32_t vertex_count, uint32_t first = 0)
+        {
+            s_renderer_api->draw_arrays(vertex_count, first);
+        }
+
+        inline static void draw_lines(const Ref<VertexArray>& vertex_array, uint32_t index_count = 0)
+        {
+            s_renderer_api->draw_lines(vertex_array, index_count);
+        }
+
+        inline static void bind_texture(uint32_t texture_id, uint32_t slot = 0)
+        {
+            s_renderer_api->bind_texture(texture_id, slot);
+        }
+
+        inline static void bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false)
+        {
+            s_renderer_api->bind_image_texture(texture_id, slot, read_only);
+        }
+
     private:
-        static Ref<RendererAPI> s_renderer_api;
+        static Scope<RendererAPI> s_renderer_api;
     };
 
     class Renderer 
diff --git a/src/rendering/shader.cpp b/src/rendering/shader.cpp
index 833b719..1bbd0fc 100644
--- a/src/rendering/shader.cpp
+++ b/src/rendering/shader.cpp
@@ -6,40 +6,40 @@
 
 namespace Donut
 {
-    Ref<Shader> Shader::create(const std::string& filepath) 
+    Shader* Shader::create(const std::string& filepath) 
     {
         switch (Renderer::get_api())
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLShader>(filepath);
+                return new OpenGLShader(filepath);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanShader>(filepath);
+                return new VulkanShader(filepath);
             default:
                 return nullptr;
         }
     }
 
-    Ref<Shader> Shader::create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src)
+    Shader* Shader::create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src)
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLShader>(name, vertex_src, fragment_src);
+                return new OpenGLShader(name, vertex_src, fragment_src);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanShader>(name, vertex_src, fragment_src);
+                return new VulkanShader(name, vertex_src, fragment_src);
             default:
                 return nullptr;
         }
     }
 
-    Ref<Shader> Shader::create_compute(const std::string& name, const std::string& compute_src)
+    Shader* Shader::create_compute(const std::string& name, const std::string& compute_src)
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLShader>(name, compute_src);
+                return new OpenGLShader(name, compute_src);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanShader>(name, compute_src);
+                return new VulkanShader(name, compute_src);
             default:
                 return nullptr;
         }
@@ -58,14 +58,14 @@ namespace Donut
 
     Ref<Shader> ShaderLibrary::load(const std::string& filepath)
     {
-        auto shader = Shader::create(filepath);
+        auto shader = Ref<Shader>(Shader::create(filepath));
         add(shader);
         return shader;
     }
 
     Ref<Shader> ShaderLibrary::load(const std::string& name, const std::string& filepath)
     {
-        auto shader = Shader::create(filepath);
+        auto shader = Ref<Shader>(Shader::create(filepath));
         add(name, shader);
         return shader;
     }
diff --git a/src/rendering/shader.h b/src/rendering/shader.h
index 7f024bd..814f0cf 100644
--- a/src/rendering/shader.h
+++ b/src/rendering/shader.h
@@ -35,9 +35,9 @@ namespace Donut
 
         virtual const std::string& get_name() const = 0;
 
-        static Ref<Shader> create(const std::string& filepath);
-        static Ref<Shader> create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src);
-        static Ref<Shader> create_compute(const std::string& name, const std::string& compute_src);
+        static Shader* create(const std::string& filepath);
+        static Shader* create(const std::string& name, const std::string& vertex_src, const std::string& fragment_src);
+        static Shader* create_compute(const std::string& name, const std::string& compute_src);
     };
 
     class ShaderLibrary
diff --git a/src/rendering/texture_manager.cpp b/src/rendering/texture_manager.cpp
new file mode 100644
index 0000000..fff5dda
--- /dev/null
+++ b/src/rendering/texture_manager.cpp
@@ -0,0 +1,34 @@
+#include "texture_manager.h"
+#include "platform/opengl/opengl_texture.h"
+#include "platform/opengl/opengl_renderer_api.h"
+#include <glad/glad.h>
+
+namespace Donut
+{
+    Ref<Texture2D> TextureManager::create_texture(uint32_t width, uint32_t height)
+    {
+        return create_ref<OpenGLTexture2D>(width, height);
+    }
+
+    void TextureManager::bind_texture(uint32_t texture_id, uint32_t slot)
+    {
+        RenderCommand::bind_texture(texture_id, slot);
+    }
+
+    void TextureManager::bind_image_texture(uint32_t texture_id, uint32_t slot, bool read_only)
+    {
+        RenderCommand::bind_image_texture(texture_id, slot, read_only);
+    }
+
+    void TextureManager::set_texture_data(uint32_t texture_id, void* data, uint32_t width, uint32_t height)
+    {
+        glBindTexture(GL_TEXTURE_2D, texture_id);
+        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
+    }
+
+    void TextureManager::resize_texture(uint32_t texture_id, uint32_t width, uint32_t height)
+    {
+        glBindTexture(GL_TEXTURE_2D, texture_id);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    }
+};
diff --git a/src/rendering/texture_manager.h b/src/rendering/texture_manager.h
new file mode 100644
index 0000000..902a27d
--- /dev/null
+++ b/src/rendering/texture_manager.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "core/memory.h"
+#include "rendering/texture.h"
+#include <cstdint>
+
+namespace Donut
+{
+    class TextureManager
+    {
+    public:
+        static Ref<Texture2D> create_texture(uint32_t width, uint32_t height);
+        
+        static void bind_texture(uint32_t texture_id, uint32_t slot = 0);
+        static void bind_image_texture(uint32_t texture_id, uint32_t slot = 0, bool read_only = false);
+        static void set_texture_data(uint32_t texture_id, void* data, uint32_t width, uint32_t height);
+        static void resize_texture(uint32_t texture_id, uint32_t width, uint32_t height);
+    };
+};
diff --git a/src/rendering/vertex_array.cpp b/src/rendering/vertex_array.cpp
index d0cd4b0..bb92ff3 100644
--- a/src/rendering/vertex_array.cpp
+++ b/src/rendering/vertex_array.cpp
@@ -17,14 +17,14 @@ namespace Donut
         }
     }
 
-    Ref<VertexArray> VertexArray::create() 
+    VertexArray* VertexArray::create() 
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLVertexArray>();
+                return new OpenGLVertexArray();
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanVertexArray>();
+                return new VulkanVertexArray();
             default:
                 return nullptr;
         }
diff --git a/src/rendering/vertex_array.h b/src/rendering/vertex_array.h
index 3729167..a39849f 100644
--- a/src/rendering/vertex_array.h
+++ b/src/rendering/vertex_array.h
@@ -23,6 +23,6 @@ namespace Donut
         virtual const std::vector<Ref<VertexBuffer>>& get_vertex_buffers() const = 0;
         virtual const Ref<IndexBuffer>& get_index_buffer()                 const = 0;
 
-        static Ref<VertexArray> create();
+        static VertexArray* create();
     };
 };
diff --git a/src/rendering/vertex_buffer.cpp b/src/rendering/vertex_buffer.cpp
index ef2b288..4929711 100644
--- a/src/rendering/vertex_buffer.cpp
+++ b/src/rendering/vertex_buffer.cpp
@@ -6,14 +6,14 @@
 
 namespace Donut
 {
-    Ref<VertexBuffer> VertexBuffer::create(const void* data, uint32_t size)
+    VertexBuffer* VertexBuffer::create(const void* data, uint32_t size)
     {
         switch (Renderer::get_api()) 
         {
             case RendererAPI::API::OpenGL:
-                return create_ref<OpenGLVertexBuffer>(data, size);
+                return new OpenGLVertexBuffer(data, size);
             case RendererAPI::API::Vulkan:
-                return create_ref<VulkanVertexBuffer>((float*)data, size);
+                return new VulkanVertexBuffer((float*)data, size);
             default:
                 return nullptr;
         }
diff --git a/src/rendering/vertex_buffer.h b/src/rendering/vertex_buffer.h
index 39f43ba..77a76c9 100644
--- a/src/rendering/vertex_buffer.h
+++ b/src/rendering/vertex_buffer.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "core/memory.h"
-
 #include <cstdint>
 #include <vector>
 
@@ -24,7 +22,7 @@ namespace Donut
         ~VertexBufferLayout() = default;
 
         template<typename T>
-        void push(uint32_t count)
+        void push(uint32_t count) 
         {
             static_assert(false);
         }
@@ -70,6 +68,6 @@ namespace Donut
         virtual const VertexBufferLayout& get_layout()      const = 0;
         virtual void set_layout(const VertexBufferLayout& layout) = 0;
 
-        static Ref<VertexBuffer> create(const void* data, uint32_t size);
+        static VertexBuffer* create(const void* data, uint32_t size);
     };
 };
diff --git a/src/states/config_state.cpp b/src/states/config_state.cpp
index 403f667..d29408b 100644
--- a/src/states/config_state.cpp
+++ b/src/states/config_state.cpp
@@ -22,7 +22,7 @@ namespace Donut
     
     void ConfigState::on_render()
     {
-        Renderer::set_clear_color({ 0.1f, 0.1f, 0.2f, 1.0f });
+        Renderer::set_clear_color({ 0.1f, 0.1f, 0.1f, 1.0f });
         Renderer::clear();
     }
     
diff --git a/src/states/simulation_state.cpp b/src/states/simulation_state.cpp
index fc235ff..e59f1fa 100644
--- a/src/states/simulation_state.cpp
+++ b/src/states/simulation_state.cpp
@@ -22,11 +22,11 @@ namespace Donut
     
     void SimulationState::on_update(float delta_time)
     {
-        
+        m_engine.update_performance(delta_time);
         m_engine.update_window_dimensions();
         m_engine.update_physics(delta_time);
-        
-        if (m_engine.get_camera().is_dragging()) 
+
+        if (m_engine.get_camera().is_dragging())
         {
             GLFWwindow* window = static_cast<GLFWwindow*>(Application::get().get_window().get_native_window());
             double xpos, ypos;
@@ -37,34 +37,28 @@ namespace Donut
     
     void SimulationState::on_render()
     {
-        if (!m_initialized) return;
-        
         RenderCommand::set_clear_color(glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
         RenderCommand::clear();
-        
-        m_engine.generate_grid(m_engine.get_objects());
-        
-        glm::mat4 view = glm::lookAt(m_engine.get_camera().get_orbital_position(), m_engine.get_camera().get_target(), glm::vec3(0,1,0));
-        glm::mat4 proj = glm::perspective(glm::radians(60.0f), float(m_engine.get_width())/m_engine.get_height(), 1e9f, 1e14f);
-        glm::mat4 view_proj = proj * view;
-        
-        m_engine.draw_grid(view_proj);
-        
         RenderCommand::set_viewport(0, 0, m_engine.get_width(), m_engine.get_height());
+
         m_engine.dispatch_compute(m_engine.get_camera());
         m_engine.draw_full_screen_quad();
     }
     
     void SimulationState::on_event(Event& event)
     {
-        if (!m_initialized) return;
-        
         if (event.get_event_type() == EventType::MouseButtonPressed)
         {
             MouseButtonPressedEvent& e = (MouseButtonPressedEvent&)event;
             int button = e.get_mouse_button();
             
-            m_engine.get_camera().process_orbital_mouse_button(button, GLFW_PRESS, 0);
+            GLFWwindow* window = static_cast<GLFWwindow*>(Application::get().get_window().get_native_window());
+            Camera& camera = m_engine.get_camera();
+            double last_x = camera.get_last_x();
+            double last_y = camera.get_last_y();
+            glfwGetCursorPos(window, &last_x, &last_y);
+            
+            camera.process_orbital_mouse_button(button, GLFW_PRESS, 0);
         }
         else if (event.get_event_type() == EventType::MouseButtonReleased)
         {
@@ -84,7 +78,7 @@ namespace Donut
             KeyPressedEvent& e = (KeyPressedEvent&)event;
             if (e.get_key_code() == GLFW_KEY_G)
             {
-                m_engine.set_gravity(!m_engine.get_gravity());
+                m_engine.get_gravity() = !m_engine.get_gravity();
                 DONUT_INFO("Gravity turned {}", m_engine.get_gravity() ? "ON" : "OFF");
             }
         }
@@ -109,6 +103,27 @@ namespace Donut
         
         ImGui::Separator();
         
+        ImGui::Text("Performance:");
+        ImGui::Text("Engine FPS: %.1f", m_engine.get_current_fps());
+        ImGui::Text("Target FPS: %d", m_engine.get_target_fps());
+        
+        int target_fps = m_engine.get_target_fps();
+        if (ImGui::SliderInt("Target FPS", &target_fps, 30, 120))
+        {
+            m_engine.set_target_fps(target_fps);
+        }
+        
+        int compute_height = m_engine.get_compute_height();
+        if (ImGui::SliderInt("Compute Height", &compute_height, 64, 2048))
+        {
+            m_engine.set_compute_height(compute_height);
+            m_engine.update_compute_dimensions();
+        }
+        
+        ImGui::Text("Compute Width: %d (auto-calculated)", m_engine.get_compute_width());
+        
+        ImGui::Separator();
+        
         ImGui::Text("Controls:");
         ImGui::Text("Left Mouse: Orbit camera");
         ImGui::Text("Scroll: Zoom in/out");
@@ -118,16 +133,15 @@ namespace Donut
         ImGui::Separator();
         
         ImGui::Text("Physics:");
-        bool gravity = m_engine.get_gravity();
-        if (ImGui::Checkbox("Gravity Enabled", &gravity))
-            m_engine.set_gravity(gravity);
+        bool& gravity = m_engine.get_gravity();
+        ImGui::Checkbox("Gravity Enabled", &gravity);
         
         ImGui::Text("Camera:");
         ImGui::Text("Position: (%.2e, %.2e, %.2e)", 
                    m_engine.get_camera().get_orbital_position().x, 
                    m_engine.get_camera().get_orbital_position().y, 
                    m_engine.get_camera().get_orbital_position().z);
-        ImGui::Text("Radius: %.2e", m_engine.get_camera().get_radius());
+        ImGui::Text("Radius: %.2e", m_engine.get_camera().get_orbital_radius());
         ImGui::Text("Azimuth: %.2f", m_engine.get_camera().get_azimuth());
         ImGui::Text("Elevation: %.2f", m_engine.get_camera().get_elevation());
         
diff --git a/src/states/simulation_state.h b/src/states/simulation_state.h
index 68788e8..cc55901 100644
--- a/src/states/simulation_state.h
+++ b/src/states/simulation_state.h
@@ -23,6 +23,6 @@ namespace Donut
     
     private:
         Engine m_engine;
-        bool   m_initialized = false;
+        bool m_initialized = false;
     };
 };