ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/shaders/post_process/ssr/frag.glsl

@@ -0,0 +1,118 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform sampler2D screenTexture;
+uniform sampler2D depthTexture;
+uniform sampler2D normalTexture;
+uniform samplerCube skyboxCubemap;
+
+uniform mat4 inverseVP;
+uniform mat4 viewProj;
+uniform vec3 cameraPos;
+
+uniform int maxSteps;
+uniform float maxRayDistance;
+uniform float thickness;
+uniform float rayOffset;
+uniform float nearPlane;
+uniform float farPlane;
+
+float linearizeDepth(float d) {
+    return nearPlane * farPlane / (farPlane - d * (farPlane - nearPlane));
+}
+
+vec3 worldPosFromDepth(vec2 uv, float depth) {
+    vec4 ndc = vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
+    vec4 world = inverseVP * ndc;
+    return world.xyz / world.w;
+}
+
+void main() {
+    float depth = texture(depthTexture, TexCoords).r;
+
+    // No reflection for skybox
+    if (depth >= 1.0) {
+        FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    vec4 normalRough = texture(normalTexture, TexCoords);
+    float roughness = normalRough.a;
+
+    // No reflection for fully rough surfaces
+    if (roughness >= 1.0) {
+        FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    vec3 worldPos = worldPosFromDepth(TexCoords, depth);
+    vec3 normal = normalize(normalRough.rgb * 2.0 - 1.0);
+    vec3 viewDir = normalize(worldPos - cameraPos);
+    vec3 reflectDir = reflect(viewDir, normal);
+
+    // Project ray start/end to screen space once
+    vec3 rayStart = worldPos + reflectDir * rayOffset;
+    vec3 rayEnd = worldPos + reflectDir * maxRayDistance;
+
+    vec4 clipStart = viewProj * vec4(rayStart, 1.0);
+    vec4 clipEnd = viewProj * vec4(rayEnd, 1.0);
+
+    if (clipEnd.w < 0.0) {
+        float t = clipStart.w / (clipStart.w - clipEnd.w);
+        clipEnd = mix(clipStart, clipEnd, t);
+    }
+
+    vec3 screenStart = clipStart.xyz / clipStart.w;
+    vec3 screenEnd = clipEnd.xyz / clipEnd.w;
+
+    screenStart.xy = screenStart.xy * 0.5 + 0.5;
+    screenEnd.xy = screenEnd.xy * 0.5 + 0.5;
+    screenStart.z = screenStart.z * 0.5 + 0.5;
+    screenEnd.z = screenEnd.z * 0.5 + 0.5;
+
+    // Ray march in screen space with perspective-correct depth
+    float linearDepthStart = linearizeDepth(screenStart.z);
+    float linearDepthEnd = linearizeDepth(screenEnd.z);
+
+    bool hitFound = false;
+    vec2 hitUV;
+
+    for (int i = 0; i < maxSteps; i++) {
+        float t = float(i) / float(maxSteps - 1);
+
+        vec2 screenPos = mix(screenStart.xy, screenEnd.xy, t);
+
+        if (screenPos.x < 0.0 || screenPos.x > 1.0 ||
+            screenPos.y < 0.0 || screenPos.y > 1.0) {
+            break;
+        }
+
+        float rayLinearDepth = (linearDepthStart * linearDepthEnd) /
+                                mix(linearDepthEnd, linearDepthStart, t);
+
+        float sceneDepthRaw = texture(depthTexture, screenPos).r;
+        if (sceneDepthRaw >= 1.0) continue;
+
+        float sceneLinearDepth = linearizeDepth(sceneDepthRaw);
+        float depthDiff = rayLinearDepth - sceneLinearDepth;
+
+        if (depthDiff > 0.0 && depthDiff < thickness) {
+            hitFound = true;
+            hitUV = screenPos;
+            break;
+        }
+    }
+
+    float reflectivity = 1.0 - roughness;
+
+    // Output: RGB = reflection color, A = reflectivity
+    if (hitFound) {
+        vec3 reflectionColor = texture(screenTexture, hitUV).rgb;
+        FragColor = vec4(reflectionColor, reflectivity);
+    } else {
+        vec3 skyColor = texture(skyboxCubemap, reflectDir).rgb;
+        FragColor = vec4(skyColor, reflectivity);
+    }
+}

data/lib/engine/shaders/post_process/tint_frag.glsl

@@ -0,0 +1,14 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+uniform vec4 tintColor; // rgba, alpha controls intensity
+
+void main()
+{
+    vec4 texColor = texture(screenTexture, TexCoords);
+    vec3 tinted = mix(texColor.rgb, texColor.rgb * tintColor.rgb, tintColor.a);
+    color = vec4(tinted, texColor.a);
+}

data/lib/engine/shaders/shadow_frag.glsl

@@ -0,0 +1,6 @@
+#version 330 core
+
+void main()
+{
+    // Depth is written automatically
+}

data/lib/engine/shaders/shadow_vertex.glsl

@@ -0,0 +1,11 @@
+#version 330 core
+
+layout (location = 0) in vec3 vertex;
+layout (location = 7) in mat4 model;
+
+uniform mat4 lightSpaceMatrix;
+
+void main()
+{
+    gl_Position = lightSpaceMatrix * model * vec4(vertex, 1.0);
+}

data/lib/engine/shaders/skybox_cubemap_frag.glsl

@@ -0,0 +1,46 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform vec3 groundColour = vec3(0.2, 0.2, 0.2);  // neutral grey
+uniform vec3 horizonColour = vec3(0.7, 0.8, 0.9); // light hazy blue
+uniform vec3 skyColour = vec3(0.3, 0.5, 0.8);     // deeper blue
+uniform float groundY = -0.1;   // ground gradient ends here
+uniform float horizonY = 0;  // horizon line
+uniform float skyY = 0.2;       // sky gradient completes here
+uniform int faceIndex;
+
+vec3 getDirection(vec2 uv, int face) {
+    vec2 st = uv * 2.0 - 1.0;
+    vec3 dir;
+
+    switch(face) {
+        case 0: dir = vec3( 1.0, -st.y, -st.x); break;  // +X
+        case 1: dir = vec3(-1.0, -st.y,  st.x); break;  // -X
+        case 2: dir = vec3( st.x,  1.0,  st.y); break;  // +Y
+        case 3: dir = vec3( st.x, -1.0, -st.y); break;  // -Y
+        case 4: dir = vec3( st.x, -st.y,  1.0); break;  // +Z
+        case 5: dir = vec3(-st.x, -st.y, -1.0); break;  // -Z
+        default: dir = vec3(0.0, 1.0, 0.0); break;
+    }
+
+    return normalize(dir);
+}
+
+void main() {
+    vec3 dir = getDirection(TexCoords, faceIndex);
+
+    vec3 color;
+    if (dir.y >= horizonY) {
+        // Above horizon: blend horizon -> sky
+        float mixFactor = clamp((dir.y - horizonY) / (skyY - horizonY), 0.0, 1.0);
+        color = mix(horizonColour, skyColour, mixFactor);
+    } else {
+        // Below horizon: blend ground -> horizon
+        float mixFactor = clamp((dir.y - groundY) / (horizonY - groundY), 0.0, 1.0);
+        color = mix(groundColour, horizonColour, mixFactor);
+    }
+
+    FragColor = vec4(color, 1.0);
+}

data/lib/engine/shaders/vertex_lit_frag.glsl

@@ -1,4 +1,4 @@
-#version 330 core
+#version 400 core
 
 in vec3 Normal;
 in vec3 FragPos;
@@ -7,83 +7,27 @@ in vec3 Diffuse;
 in vec3 Specular;
 in vec3 Albedo;
 
-out vec4 color;
+layout(location = 0) out vec4 FragColour;
+layout(location = 1) out vec4 normalRoughness;
 
 uniform vec3 cameraPos;
+uniform float roughness;
 uniform float diffuseStrength;
 uniform float specularStrength;
 uniform float specularPower;
-uniform vec3 ambientLight;
 
-struct DirectionalLight {
-    vec3 direction;
-    vec3 colour;
-};
-#define NR_DIRECTIONAL_LIGHTS 4
-uniform DirectionalLight directionalLights[NR_DIRECTIONAL_LIGHTS];
-
-struct PointLight {
-    vec3 position;
-    float sqrRange;
-    vec3 colour;
-};
-#define NR_POINT_LIGHTS 16
-uniform PointLight pointLights[NR_POINT_LIGHTS];
-
-vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
-{
-    vec3 lightOffset = light.position - fragPos;
-    float sqrDistance = dot(lightOffset, lightOffset);
-    vec3 lightDir = normalize(lightOffset);
-    float diff = max(dot(normal, lightDir), 0.0);
-
-    vec3 reflectDir = reflect(lightDir, normal);
-    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
-
-    float attenuation = light.sqrRange / sqrDistance;
-
-    float diffuse = diff * diffuseStrength;
-    float specular = spec * specularStrength;
-
-    return light.colour * (diffuse + specular) * attenuation;
-}
-
-vec3 CalcDirectionalLight(DirectionalLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
-{
-    float diff = max(dot(normal, -light.direction), 0.0);
-
-    vec3 reflectDir = reflect(-light.direction, normal);
-    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
-
-    float diffuse = diff * diffuseStrength;
-    float specular = spec * specularStrength;
-
-    return light.colour * (diffuse + specular);
-}
+#include "lighting/lighting.glsl"
 
 void main()
 {
     vec3 norm = normalize(Normal);
     vec3 viewDir = normalize(cameraPos - FragPos);
 
-    vec3 result = ambientLight;
-
-    for (int i = 0; i < NR_POINT_LIGHTS; i++) {
-        if (pointLights[i].sqrRange == 0.0)
-        {
-            break;
-        }
-        result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);
-    }
-
-    for (int i = 0; i < NR_DIRECTIONAL_LIGHTS; i++) {
-        if (directionalLights[i].colour == vec3(0.0))
-        {
-            break;
-        }
-        result += CalcDirectionalLight(directionalLights[i], norm, FragPos, viewDir);
-    }
+    vec3 result = CalcAllLights(norm, FragPos, viewDir, diffuseStrength, specularStrength, specularPower);
 
     vec4 c = vec4(Diffuse, 1.0);
-    color = c * vec4(result, 1.0);
+    FragColour = c * vec4(result, 1.0);
+
+    // Output world-space normal (encoded to 0-1) and roughness in alpha
+    normalRoughness = vec4(norm * 0.5 + 0.5, roughness);
 }

data/lib/engine/shaders/vertex_lit_vertex.glsl

@@ -1,4 +1,4 @@
-#version 330 core
+#version 400 core
 
 // <vec2 position, vec2 texCoords, vec3 normal, vec3 tangent>
 layout (location = 0) in vec3 vertex;

data/lib/engine/standard_meshes/quad_mesh.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Engine
+  class QuadMesh
+    # Vertex format: pos(3) + uv(2) + normal(3) + tangent(3) + bitangent(3) + extra(6) = 20 floats
+    def vertex_data
+      @vertex_data ||= [
+        # top-left
+        -0.5,  0.5, 0.0,   0.0, 0.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+        # top-right
+         0.5,  0.5, 0.0,   1.0, 0.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+        # bottom-right
+         0.5, -0.5, 0.0,   1.0, 1.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+        # bottom-left
+        -0.5, -0.5, 0.0,   0.0, 1.0,   0.0, 0.0, 1.0,   1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 0.0,   0.0, 0.0, 0.0,
+      ]
+    end
+
+    def index_data
+      @index_data ||= [
+        0, 2, 1,
+        2, 0, 3
+      ]
+    end
+  end
+end

data/lib/engine/standard_objects/cube.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    module Cube
+      def self.create(pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], material: nil)
+        Engine::GameObject.create(
+          name: "Cube",
+          pos: pos,
+          rotation: rotation,
+          scale: scale,
+          components: [
+            Engine::Components::MeshRenderer.create(
+              mesh: Engine::Mesh.for("cube", source: :engine),
+              material: material || StandardObjects.default_material
+            ),
+            *components
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/engine/standard_objects/default_material.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    def self.default_material
+      @default_material ||= begin
+        mat = Engine::Material.create(shader: Engine::Shader.default)
+        mat.set_vec3("baseColour", Vector[1.0, 1.0, 1.0])
+        mat.set_texture("image", nil)
+        mat.set_texture("normalMap", nil)
+        mat.set_float("diffuseStrength", 0.5)
+        mat.set_float("specularStrength", 0.5)
+        mat.set_float("specularPower", 32.0)
+        mat.set_vec3("ambientLight", Vector[0.02, 0.02, 0.02])
+        mat.set_float("roughness", 0.5)
+        mat
+      end
+    end
+  end
+end

data/lib/engine/standard_objects/plane.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    module Plane
+      def self.create(pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], material: nil)
+        Engine::GameObject.create(
+          name: "Plane",
+          pos: pos,
+          rotation: rotation,
+          scale: scale,
+          components: [
+            Engine::Components::MeshRenderer.create(
+              mesh: Engine::Mesh.for("plane", source: :engine),
+              material: material || StandardObjects.default_material
+            ),
+            *components
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/engine/standard_objects/sphere.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Engine
+  module StandardObjects
+    module Sphere
+      def self.create(pos: Vector[0, 0, 0], rotation: 0, scale: Vector[1, 1, 1], components: [], material: nil)
+        Engine::GameObject.create(
+          name: "Sphere",
+          pos: pos,
+          rotation: rotation,
+          scale: scale,
+          components: [
+            Engine::Components::MeshRenderer.create(
+              mesh: Engine::Mesh.for("sphere", source: :engine),
+              material: material || StandardObjects.default_material
+            ),
+            *components
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/engine/texture.rb

@@ -2,44 +2,53 @@ require 'chunky_png'
 
 module Engine
   class Texture
-    attr_reader :texture
-    private_class_method :new
+    include Serializable
 
-    def initialize(file_path, flip)
-      @file_path = file_path
-      @flip = flip
+    attr_reader :texture, :source
+
+    def self.from_serializable_data(data)
+      self.for(data[:path], flip: data[:flip] || false, source: (data[:source] || :game).to_sym)
+    end
+
+    def serializable_data
+      { path: @relative_path, flip: @flip, source: @source }
+    end
+
+    def awake
       @texture = ' ' * 4
       load_texture
     end
 
-    def self.for(path, flip: false)
-      full_path = File.expand_path(File.join(GAME_DIR, path))
-      texture_cache[[full_path, flip]]
+    def self.for(path, flip: false, source: :game)
+      full_path = if source == :engine
+        File.expand_path(File.join(ENGINE_DIR, "assets", path))
+      else
+        File.expand_path(File.join(GAME_DIR, path))
+      end
+      texture_cache[[path, flip, source]] ||= create(relative_path: path, file_path: full_path, flip: flip, source: source)
     end
 
     def self.texture_cache
-      @texture_cache ||= Hash.new do |hash, key|
-        hash[key] = new(key[0], key[1])
-      end
+      @texture_cache ||= {}
     end
 
     def load_texture
       tex = ' ' * 4
-      GL.GenTextures(1, tex)
+      Engine::GL.GenTextures(1, tex)
       @texture = tex.unpack('L')[0]
-      GL.BindTexture(GL::TEXTURE_2D, @texture)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_S, GL::REPEAT)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::REPEAT)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::LINEAR)
-      GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
+      Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, @texture)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_S, Engine::GL::REPEAT)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_T, Engine::GL::REPEAT)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MIN_FILTER, Engine::GL::LINEAR)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::LINEAR)
 
       image = read_image
       image_data = image.to_rgba_stream
       image_width = image.width
       image_height = image.height
 
-      GL.TexImage2D(GL::TEXTURE_2D, 0, GL::RGBA, image_width, image_height, 0, GL::RGBA, GL::UNSIGNED_BYTE, image_data)
-      GL.GenerateMipmap(GL::TEXTURE_2D)
+      Engine::GL.TexImage2D(Engine::GL::TEXTURE_2D, 0, Engine::GL::RGBA32F, image_width, image_height, 0, Engine::GL::RGBA, Engine::GL::UNSIGNED_BYTE, image_data)
+      Engine::GL.GenerateMipmap(Engine::GL::TEXTURE_2D)
     end
 
     def read_image

data/lib/engine/ui/rect.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Engine
+  module UI
+    Rect = Struct.new(:left, :bottom, :right, :top, keyword_init: true) do
+      def width
+        right - left
+      end
+
+      def height
+        # Y-down: bottom > top
+        bottom - top
+      end
+    end
+  end
+end

data/lib/engine/window.rb

@@ -109,8 +109,8 @@ module Engine
       end
 
       def set_opengl_version
-        GLFW.WindowHint(GLFW::CONTEXT_VERSION_MAJOR, 3)
-        GLFW.WindowHint(GLFW::CONTEXT_VERSION_MINOR, 3)
+        GLFW.WindowHint(GLFW::CONTEXT_VERSION_MAJOR, 4)
+        GLFW.WindowHint(GLFW::CONTEXT_VERSION_MINOR, OS.mac? ? 1 : 3)
         GLFW.WindowHint(GLFW::OPENGL_PROFILE, GLFW::OPENGL_CORE_PROFILE)
         GLFW.WindowHint(GLFW::OPENGL_FORWARD_COMPAT, GLFW::TRUE)
       end

data/lib/ruby_rpg.rb

@@ -1,14 +1,43 @@
 # frozen_string_literal: true
 
-require 'opengl'
-require 'glfw'
+# Preload vendored DLLs on Windows before loading native extensions
+if RUBY_PLATFORM =~ /mingw|mswin/
+  require 'fiddle'
+  glew_dll = File.expand_path('../vendor/glew-2.2.0-win32/bin/Release/x64/glew32.dll', __dir__)
+  Fiddle.dlopen(glew_dll)
+end
+
+require_relative 'engine/gl'
+require_relative 'engine/glfw'
 require 'concurrent'
 require 'os'
 require 'native_audio'
 
 require_relative 'engine/autoloader'
+require_relative 'engine/serialization/serializable'
+require_relative 'engine/serialization/object_serializer'
+require_relative 'engine/serialization/graph_serializer'
+require_relative 'engine/serialization/yaml_persistence'
+require_relative 'engine/matrix_helpers'
 require_relative "engine/debugging"
+require_relative 'engine/rendering/render_texture'
+require_relative 'engine/rendering/shadow_map_array'
+require_relative 'engine/rendering/cubemap_shadow_map_array'
+require_relative 'engine/rendering/screen_quad'
+require_relative 'engine/rendering/post_processing/post_processing_effect'
+require_relative 'engine/rendering/post_processing/effect'
+require_relative 'engine/rendering/post_processing/single_pass_effect'
+require_relative 'engine/rendering/post_processing/bloom_effect'
+require_relative 'engine/rendering/post_processing/tint_effect'
+require_relative 'engine/rendering/post_processing/depth_of_field_effect'
+require_relative 'engine/rendering/post_processing/depth_debug_effect'
+require_relative 'engine/rendering/post_processing/ssr_effect'
+require_relative 'engine/rendering/post_processing/ssao_effect'
+require_relative 'engine/rendering/skybox_cubemap'
+require_relative 'engine/rendering/skybox_renderer'
+require_relative 'engine/rendering/gpu_timer'
 require_relative 'engine/rendering/render_pipeline'
+require_relative 'engine/rendering/ui/stencil_manager'
 require_relative 'engine/rendering/instance_renderer'
 require_relative 'engine/screenshoter'
 require_relative 'engine/input'
@@ -17,6 +46,11 @@ require_relative 'engine/game_object'
 require_relative 'engine/texture'
 require_relative 'engine/material'
 require_relative 'engine/mesh'
+require_relative 'engine/standard_meshes/quad_mesh'
+require_relative 'engine/standard_objects/default_material'
+require_relative 'engine/standard_objects/cube'
+require_relative 'engine/standard_objects/sphere'
+require_relative 'engine/standard_objects/plane'
 require_relative "engine/font"
 require_relative 'engine/path'
 require_relative 'engine/polygon_mesh'
@@ -29,15 +63,22 @@ require_relative "engine/window"
 require_relative "engine/video_mode"
 require_relative "engine/cursor"
 
+require_relative "engine/ui/rect"
+require_relative "engine/components/ui/rect"
+require_relative "engine/components/ui/flex"
+require_relative "engine/components/ui/sprite_renderer"
+require_relative "engine/components/ui/sprite_clickbox"
 require_relative "engine/components/orthographic_camera"
 require_relative "engine/components/perspective_camera"
-require_relative "engine/components/sprite_renderer"
-require_relative "engine/components/ui_sprite_renderer"
-require_relative "engine/components/mesh_renderer"
-require_relative "engine/components/font_renderer"
-require_relative "engine/components/ui_font_renderer"
+require_relative "engine/components/renderers/sprite_renderer"
+require_relative "engine/components/sprite_animator"
+require_relative "engine/components/renderers/mesh_renderer"
+require_relative "engine/components/renderers/font_renderer_base"
+require_relative "engine/components/renderers/font_renderer"
+require_relative "engine/components/ui/font_renderer"
 require_relative "engine/components/point_light"
 require_relative "engine/components/direction_light"
+require_relative "engine/components/spot_light"
 require_relative "engine/components/audio_source"
 
 require_relative "engine/physics/physics_resolver"
@@ -46,10 +87,29 @@ require_relative "engine/physics/components/sphere_collider"
 require_relative "engine/physics/components/cube_collider"
 require_relative "engine/physics/components/rigidbody"
 
+# Platform-specific compute shader implementations
+if OS.mac?
+  # Metal compute shaders (Mac)
+  require_relative "engine/metal/metal_bindings"
+  require_relative "engine/metal/device"
+  require_relative "engine/metal/compute_shader"
+  require_relative "engine/metal/compute_texture"
+else
+  # OpenGL compute shaders (Windows/Linux)
+  require_relative "engine/opengl/compute_shader"
+  require_relative "engine/opengl/compute_texture"
+end
+
+# Platform-agnostic compute shader factories
+require_relative "engine/compute_shader"
+require_relative "engine/compute_texture"
+
 if OS.windows?
-  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "glfw-3.4.bin.WIN64", "lib-static-ucrt", "glfw3.dll")))
+  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "vendor", "glfw-3.4.bin.WIN64", "lib-static-ucrt", "glfw3.dll")))
 elsif OS.mac?
-  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "glfw-3.3.9.bin.MACOS", "lib-arm64", "libglfw.3.dylib")))
+  GLFW.load_lib(File.expand_path(File.join(__dir__, "..", "vendor", "glfw-3.3.9.bin.MACOS", "lib-arm64", "libglfw.3.dylib")))
+elsif OS.linux?
+  GLFW.load_lib("libglfw.so.3")
 end
 GLFW.Init