ruby_rpg 0.0.5 → 0.1.0

data/lib/engine/rendering/instance_renderer.rb

@@ -1,153 +1,232 @@
-# frozen_string_literal: true
-
-module Rendering
-  class InstanceRenderer
-    attr_reader :mesh, :material
-
-    def initialize(mesh, material)
-      @mesh = mesh
-      @material = material
-      @mesh_renderers = []
-      @mesh_matrix_data = []
-
-      setup_vertex_attribute_buffer
-      setup_vertex_buffer
-      setup_index_buffer
-      generate_instance_vbo_buf
-    end
-
-    def add_instance(mesh_renderer)
-      @mesh_renderers << mesh_renderer
-      @mesh_matrix_data += mesh_renderer.game_object.model_matrix.to_a.flatten
-    end
-
-    def remove_instance(mesh_renderer)
-      index = @mesh_renderers.index(mesh_renderer)
-      @mesh_renderers.delete_at(index)
-      @mesh_matrix_data[index * 16, 16] = []
-    end
-
-    def update_instance(mesh_renderer)
-      index = @mesh_renderers.index(mesh_renderer)
-      @mesh_matrix_data[index * 16, 16] = mesh_renderer.game_object.model_matrix.to_a.flatten
-    end
-
-    def draw_all
-      set_material_per_frame_data
-
-      GL.BindVertexArray(@vao)
-      update_vbo_buf
-      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
-      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
-
-      GL.DrawElementsInstanced(GL::TRIANGLES, mesh.index_data.length, GL::UNSIGNED_INT, 0, @mesh_renderers.count)
-      GL.BindVertexArray(0)
-      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, 0)
-    end
-
-    private
-
-    def set_material_per_frame_data
-      material.set_mat4("camera", Engine::Camera.instance.matrix)
-      material.set_vec3("cameraPos", Engine::Camera.instance.game_object.pos)
-
-      update_light_data
-      material.update_shader
-    end
-
-    def update_light_data
-      Engine::Components::PointLight.point_lights.each_with_index do |light, i|
-        material.set_float("pointLights[#{i}].sqrRange", light.range * light.range)
-        material.set_vec3("pointLights[#{i}].position", light.game_object.pos)
-        material.set_vec3("pointLights[#{i}].colour", light.colour)
-      end
-      Engine::Components::DirectionLight.direction_lights.each_with_index do |light, i|
-        material.set_vec3("directionalLights[#{i}].direction", light.game_object.forward)
-        material.set_vec3("directionalLights[#{i}].colour", light.colour)
-      end
-    end
-
-    def setup_index_buffer
-      indices = mesh.index_data
-
-      ebo_buf = ' ' * 4
-      GL.GenBuffers(1, ebo_buf)
-      @ebo = ebo_buf.unpack('L')[0]
-      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
-      GL.BufferData(
-        GL::ELEMENT_ARRAY_BUFFER, indices.length * Fiddle::SIZEOF_INT,
-        indices.pack('I*'), GL::STATIC_DRAW
-      )
-    end
-
-    def setup_vertex_attribute_buffer
-      vao_buf = ' ' * 4
-      GL.GenVertexArrays(1, vao_buf)
-      @vao = vao_buf.unpack('L')[0]
-      GL.BindVertexArray(@vao)
-    end
-
-    def setup_vertex_buffer
-      vbo_buf = ' ' * 4
-      GL.GenBuffers(1, vbo_buf)
-      vbo = vbo_buf.unpack('L')[0]
-      points = mesh.vertex_data
-
-      GL.BindBuffer(GL::ARRAY_BUFFER, vbo)
-      GL.BufferData(
-        GL::ARRAY_BUFFER, @mesh.vertex_data.length * Fiddle::SIZEOF_FLOAT,
-        points.pack('F*'), GL::STATIC_DRAW
-      )
-      vertex_data_size = 20 * Fiddle::SIZEOF_FLOAT
-
-      GL.VertexAttribPointer(0, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 0)
-      GL.VertexAttribPointer(1, 2, GL::FLOAT, GL::FALSE, vertex_data_size, 3 * Fiddle::SIZEOF_FLOAT)
-      GL.VertexAttribPointer(2, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 5 * Fiddle::SIZEOF_FLOAT)
-      GL.VertexAttribPointer(3, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 8 * Fiddle::SIZEOF_FLOAT)
-      GL.VertexAttribPointer(4, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 11 * Fiddle::SIZEOF_FLOAT)
-      GL.VertexAttribPointer(5, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 14 * Fiddle::SIZEOF_FLOAT)
-      GL.VertexAttribPointer(6, 3, GL::FLOAT, GL::FALSE, vertex_data_size, 17 * Fiddle::SIZEOF_FLOAT)
-      GL.EnableVertexAttribArray(0)
-      GL.EnableVertexAttribArray(1)
-      GL.EnableVertexAttribArray(2)
-      GL.EnableVertexAttribArray(3)
-      GL.EnableVertexAttribArray(4)
-      GL.EnableVertexAttribArray(5)
-      GL.EnableVertexAttribArray(6)
-    end
-
-    def generate_instance_vbo_buf
-      instance_vbo_buf = ' ' * 4
-      GL.GenBuffers(1, instance_vbo_buf)
-      @instance_vbo = instance_vbo_buf.unpack('L')[0]
-      update_vbo_buf
-    end
-
-    def update_vbo_buf
-      vertex_data = @mesh_matrix_data
-
-      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
-      GL.BufferData(
-        GL::ARRAY_BUFFER, vertex_data.length * Fiddle::SIZEOF_FLOAT,
-        vertex_data.pack('F*'), GL::STATIC_DRAW
-      )
-
-      vec4_size = Fiddle::SIZEOF_FLOAT * 4
-
-      GL.EnableVertexAttribArray(7)
-      GL.EnableVertexAttribArray(8)
-      GL.EnableVertexAttribArray(9)
-      GL.EnableVertexAttribArray(10)
-
-      GL.VertexAttribPointer(7, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 0)
-      GL.VertexAttribPointer(8, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 1 * vec4_size)
-      GL.VertexAttribPointer(9, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 2 * vec4_size)
-      GL.VertexAttribPointer(10, 4, GL::FLOAT, GL::FALSE, 4 * vec4_size, 3 * vec4_size)
-
-      GL.VertexAttribDivisor(7, 1)
-      GL.VertexAttribDivisor(8, 1)
-      GL.VertexAttribDivisor(9, 1)
-      GL.VertexAttribDivisor(10, 1)
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Rendering
+  class InstanceRenderer
+    attr_reader :mesh, :material
+
+    FLOATS_PER_MATRIX = 16
+    BYTES_PER_MATRIX = FLOATS_PER_MATRIX * Fiddle::SIZEOF_FLOAT
+
+    def initialize(mesh, material)
+      @mesh = mesh
+      @material = material
+      @mesh_renderers = []
+      @packed_data = String.new(encoding: Encoding::BINARY)
+
+      setup_vertex_attribute_buffer
+      setup_vertex_buffer
+      setup_index_buffer
+      generate_instance_vbo_buf
+      Engine::GL.BindVertexArray(0)
+    end
+
+    def add_instance(mesh_renderer)
+      @mesh_renderers << mesh_renderer
+      floats = mesh_renderer.game_object.model_matrix.to_a.flatten
+      @packed_data << floats.pack('F*')
+    end
+
+    def remove_instance(mesh_renderer)
+      index = @mesh_renderers.index(mesh_renderer)
+      @mesh_renderers.delete_at(index)
+      # Remove this instance's bytes from packed data
+      byte_offset = index * BYTES_PER_MATRIX
+      @packed_data[byte_offset, BYTES_PER_MATRIX] = ''
+    end
+
+    def update_instance(mesh_renderer)
+      index = @mesh_renderers.index(mesh_renderer)
+      floats = mesh_renderer.game_object.model_matrix.to_a.flatten
+      byte_offset = index * BYTES_PER_MATRIX
+      @packed_data[byte_offset, BYTES_PER_MATRIX] = floats.pack('F*')
+    end
+
+    def draw_all
+      set_material_per_frame_data
+
+      Engine::GL.BindVertexArray(@vao)
+      update_vbo_buf
+      Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @instance_vbo)
+
+      Engine::GL.DrawElementsInstanced(Engine::GL::TRIANGLES, mesh.index_data.length, Engine::GL::UNSIGNED_INT, 0, @mesh_renderers.count)
+    end
+
+    def draw_depth_only(light_space_matrix)
+      return if @mesh_renderers.empty?
+
+      shadow_shader = Engine::Shader.shadow
+      shadow_shader.use
+      shadow_shader.set_mat4("lightSpaceMatrix", light_space_matrix)
+
+      Engine::GL.BindVertexArray(@vao)
+      update_vbo_buf
+      Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @instance_vbo)
+
+      Engine::GL.DrawElementsInstanced(Engine::GL::TRIANGLES, mesh.index_data.length, Engine::GL::UNSIGNED_INT, 0, @mesh_renderers.count)
+    end
+
+    def draw_point_light_depth(light_space_matrix, light_pos, far_plane)
+      return if @mesh_renderers.empty?
+
+      shader = Engine::Shader.point_shadow
+      shader.use
+      shader.set_mat4("lightSpaceMatrix", light_space_matrix)
+      shader.set_vec3("lightPos", light_pos)
+      shader.set_float("farPlane", far_plane)
+
+      Engine::GL.BindVertexArray(@vao)
+      update_vbo_buf
+      Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @instance_vbo)
+
+      Engine::GL.DrawElementsInstanced(Engine::GL::TRIANGLES, mesh.index_data.length, Engine::GL::UNSIGNED_INT, 0, @mesh_renderers.count)
+    end
+
+    private
+
+    def set_material_per_frame_data
+      material.set_mat4("camera", Engine::Camera.instance.matrix)
+      material.set_vec3("cameraPos", Engine::Camera.instance.game_object.pos)
+      material.set_cubemap("skybox", nil)
+
+      update_light_data
+      material.update_shader
+    end
+
+    def update_light_data
+      Engine::Components::PointLight.point_lights.each_with_index do |light, i|
+        break if i >= 16
+        material.set_float("pointLights[#{i}].sqrRange", light.range * light.range)
+        material.set_vec3("pointLights[#{i}].position", light.position)
+        material.set_vec3("pointLights[#{i}].colour", light.colour)
+        has_shadow = light.cast_shadows && !light.shadow_layer_index.nil?
+        material.set_int("pointLights[#{i}].castsShadows", has_shadow ? 1 : 0)
+        if has_shadow
+          material.set_int("pointLights[#{i}].shadowLayerIndex", light.shadow_layer_index)
+          material.set_float("pointLights[#{i}].shadowFar", light.shadow_far)
+        end
+      end
+      # Set shared point shadow map cubemap array
+      material.set_cubemap_array("pointShadowMaps", RenderPipeline.point_shadow_map_array.depth_texture)
+
+      Engine::Components::DirectionLight.direction_lights.each_with_index do |light, i|
+        break if i >= 4
+        material.set_vec3("directionalLights[#{i}].direction", light.direction)
+        material.set_vec3("directionalLights[#{i}].colour", light.colour)
+        has_shadow = light.cast_shadows && !light.shadow_layer_index.nil?
+        material.set_int("directionalLights[#{i}].castsShadows", has_shadow ? 1 : 0)
+
+        if has_shadow
+          material.set_mat4("directionalLights[#{i}].lightSpaceMatrix", light.light_space_matrix)
+        end
+      end
+      # Set shared directional shadow map array
+      material.set_texture_array("directionalShadowMaps", RenderPipeline.directional_shadow_map_array.depth_texture)
+
+      Engine::Components::SpotLight.spot_lights.each_with_index do |light, i|
+        break if i >= 8
+        material.set_vec3("spotLights[#{i}].position", light.position)
+        material.set_vec3("spotLights[#{i}].direction", light.direction)
+        material.set_float("spotLights[#{i}].sqrRange", light.range * light.range)
+        material.set_vec3("spotLights[#{i}].colour", light.colour)
+        material.set_float("spotLights[#{i}].innerCutoff", light.inner_cutoff)
+        material.set_float("spotLights[#{i}].outerCutoff", light.outer_cutoff)
+        has_shadow = light.cast_shadows && !light.shadow_layer_index.nil?
+        material.set_int("spotLights[#{i}].castsShadows", has_shadow ? 1 : 0)
+
+        if has_shadow
+          material.set_mat4("spotLights[#{i}].lightSpaceMatrix", light.light_space_matrix)
+          material.set_float("spotLights[#{i}].shadowNear", light.shadow_near)
+          material.set_float("spotLights[#{i}].shadowFar", light.shadow_far)
+        end
+      end
+      # Set shared spot shadow map array
+      material.set_texture_array("spotShadowMaps", RenderPipeline.spot_shadow_map_array.depth_texture)
+    end
+
+    def setup_index_buffer
+      indices = mesh.index_data
+
+      ebo_buf = ' ' * 4
+      Engine::GL.GenBuffers(1, ebo_buf)
+      @ebo = ebo_buf.unpack('L')[0]
+      Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      Engine::GL.BufferData(
+        Engine::GL::ELEMENT_ARRAY_BUFFER, indices.length * Fiddle::SIZEOF_INT,
+        indices.pack('I*'), Engine::GL::STATIC_DRAW
+      )
+    end
+
+    def setup_vertex_attribute_buffer
+      vao_buf = ' ' * 4
+      Engine::GL.GenVertexArrays(1, vao_buf)
+      @vao = vao_buf.unpack('L')[0]
+      Engine::GL.BindVertexArray(@vao)
+    end
+
+    def setup_vertex_buffer
+      vbo_buf = ' ' * 4
+      Engine::GL.GenBuffers(1, vbo_buf)
+      vbo = vbo_buf.unpack('L')[0]
+      points = mesh.vertex_data
+
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, vbo)
+      Engine::GL.BufferData(
+        Engine::GL::ARRAY_BUFFER, @mesh.vertex_data.length * Fiddle::SIZEOF_FLOAT,
+        points.pack('F*'), Engine::GL::STATIC_DRAW
+      )
+      vertex_data_size = 20 * Fiddle::SIZEOF_FLOAT
+
+      Engine::GL.VertexAttribPointer(0, 3, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_data_size, 0)
+      Engine::GL.VertexAttribPointer(1, 2, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_data_size, 3 * Fiddle::SIZEOF_FLOAT)
+      Engine::GL.VertexAttribPointer(2, 3, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_data_size, 5 * Fiddle::SIZEOF_FLOAT)
+      Engine::GL.VertexAttribPointer(3, 3, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_data_size, 8 * Fiddle::SIZEOF_FLOAT)
+      Engine::GL.VertexAttribPointer(4, 3, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_data_size, 11 * Fiddle::SIZEOF_FLOAT)
+      Engine::GL.VertexAttribPointer(5, 3, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_data_size, 14 * Fiddle::SIZEOF_FLOAT)
+      Engine::GL.VertexAttribPointer(6, 3, Engine::GL::FLOAT, Engine::GL::FALSE, vertex_data_size, 17 * Fiddle::SIZEOF_FLOAT)
+      Engine::GL.EnableVertexAttribArray(0)
+      Engine::GL.EnableVertexAttribArray(1)
+      Engine::GL.EnableVertexAttribArray(2)
+      Engine::GL.EnableVertexAttribArray(3)
+      Engine::GL.EnableVertexAttribArray(4)
+      Engine::GL.EnableVertexAttribArray(5)
+      Engine::GL.EnableVertexAttribArray(6)
+    end
+
+    def generate_instance_vbo_buf
+      instance_vbo_buf = ' ' * 4
+      Engine::GL.GenBuffers(1, instance_vbo_buf)
+      @instance_vbo = instance_vbo_buf.unpack('L')[0]
+
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @instance_vbo)
+
+      # Set up vertex attributes once (stored in VAO)
+      vec4_size = Fiddle::SIZEOF_FLOAT * 4
+
+      Engine::GL.EnableVertexAttribArray(7)
+      Engine::GL.EnableVertexAttribArray(8)
+      Engine::GL.EnableVertexAttribArray(9)
+      Engine::GL.EnableVertexAttribArray(10)
+
+      Engine::GL.VertexAttribPointer(7, 4, Engine::GL::FLOAT, Engine::GL::FALSE, 4 * vec4_size, 0)
+      Engine::GL.VertexAttribPointer(8, 4, Engine::GL::FLOAT, Engine::GL::FALSE, 4 * vec4_size, 1 * vec4_size)
+      Engine::GL.VertexAttribPointer(9, 4, Engine::GL::FLOAT, Engine::GL::FALSE, 4 * vec4_size, 2 * vec4_size)
+      Engine::GL.VertexAttribPointer(10, 4, Engine::GL::FLOAT, Engine::GL::FALSE, 4 * vec4_size, 3 * vec4_size)
+
+      Engine::GL.VertexAttribDivisor(7, 1)
+      Engine::GL.VertexAttribDivisor(8, 1)
+      Engine::GL.VertexAttribDivisor(9, 1)
+      Engine::GL.VertexAttribDivisor(10, 1)
+    end
+
+    def update_vbo_buf
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @instance_vbo)
+      Engine::GL.BufferData(
+        Engine::GL::ARRAY_BUFFER, @packed_data.bytesize,
+        @packed_data, Engine::GL::DYNAMIC_DRAW
+      )
+    end
+  end
+end

data/lib/engine/rendering/post_processing/bloom_effect.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Rendering
+  class BloomEffect
+    include Effect
+
+    def initialize(threshold: 0.7, intensity: 1.0, blur_passes: 2, blur_scale: 1.0)
+      @threshold = threshold
+      @intensity = intensity
+      @blur_passes = blur_passes
+      @blur_scale = blur_scale
+
+      setup_materials
+    end
+
+    def apply(input_rt, output_rt, screen_quad)
+      ensure_textures(input_rt.width, input_rt.height)
+      Engine::GL.Disable(Engine::GL::DEPTH_TEST)
+
+      # Pass 1: Extract bright pixels
+      @ping.bind
+      Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+      screen_quad.draw(@threshold_material, input_rt.color_texture)
+
+      # Pass 2+: Blur passes (ping-pong between internal textures)
+      @blur_passes.times do
+        # Horizontal blur
+        @pong.bind
+        Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+        @blur_material.set_vec2("direction", [1.0, 0.0])
+        screen_quad.draw(@blur_material, @ping.color_texture)
+
+        # Vertical blur
+        @ping.bind
+        Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+        @blur_material.set_vec2("direction", [0.0, 1.0])
+        screen_quad.draw(@blur_material, @pong.color_texture)
+      end
+
+      # Pass 3: Combine original + bloom
+      output_rt.bind
+      Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+      @combine_material.set_runtime_texture("screenTexture", input_rt.color_texture)
+      @combine_material.set_runtime_texture("bloomTexture", @ping.color_texture)
+      screen_quad.draw_with_material(@combine_material)
+      output_rt
+    end
+
+    private
+
+    def setup_materials
+      @threshold_material = Engine::Material.create(
+        shader: Engine::Shader.for(
+          'fullscreen_vertex.glsl',
+          'post_process/bloom_threshold_frag.glsl',
+          source: :engine
+        )
+      )
+      @threshold_material.set_float("threshold", @threshold)
+
+      @blur_material = Engine::Material.create(
+        shader: Engine::Shader.for(
+          'fullscreen_vertex.glsl',
+          'post_process/bloom_blur_frag.glsl',
+          source: :engine
+        )
+      )
+      @blur_material.set_float("blurScale", @blur_scale)
+
+      @combine_material = Engine::Material.create(
+        shader: Engine::Shader.for(
+          'fullscreen_vertex.glsl',
+          'post_process/bloom_combine_frag.glsl',
+          source: :engine
+        )
+      )
+      @combine_material.set_float("intensity", @intensity)
+    end
+
+    def ensure_textures(width, height)
+      if @ping.nil? || @ping.width != width || @ping.height != height
+        @ping = RenderTexture.new(width, height)
+        @pong = RenderTexture.new(width, height)
+      end
+    end
+  end
+end

data/lib/engine/rendering/post_processing/depth_debug_effect.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rendering
+  class DepthDebugEffect
+    include SinglePassEffect
+
+    def initialize
+      @material = Engine::Material.create(
+        shader: Engine::Shader.for(
+          'fullscreen_vertex.glsl',
+          'post_process/depth_debug_frag.glsl',
+          source: :engine
+        )
+      )
+    end
+  end
+end

data/lib/engine/rendering/post_processing/depth_of_field_effect.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rendering
+  class DepthOfFieldEffect
+    include Effect
+
+    def initialize(focus_distance: 10.0, focus_range: 50.0, blur_amount: 3.0, near: 0.1, far: 1000.0)
+      @focus_distance = focus_distance
+      @focus_range = focus_range
+      @blur_amount = blur_amount
+      @near = near
+      @far = far
+    end
+
+    def apply(rt_a, rt_b, screen_quad)
+      Engine::GL.Disable(Engine::GL::DEPTH_TEST)
+
+      blur_pass(rt_a, rt_b, [1.0, 0.0], screen_quad)  # horizontal
+      blur_pass(rt_b, rt_a, [0.0, 1.0], screen_quad)  # vertical
+
+      rt_a
+    end
+
+    def blur_pass(source_rt, dest_rt, direction, screen_quad)
+      dest_rt.bind
+      material.set_vec2("direction", direction)
+      material.set_runtime_texture("screenTexture", source_rt.color_texture)
+      material.set_runtime_texture("depthTexture", PostProcessingEffect.depth_texture)
+      screen_quad.draw_with_material(material)
+    end
+
+    private
+
+    def material
+      @material ||= begin
+        mat = Engine::Material.create(
+          shader: Engine::Shader.for(
+            'fullscreen_vertex.glsl',
+            'post_process/dof_blur_frag.glsl',
+            source: :engine
+          )
+        )
+        mat.set_float("focusDistance", @focus_distance)
+        mat.set_float("focusRange", @focus_range)
+        mat.set_float("blurAmount", @blur_amount)
+        mat.set_float("nearPlane", @near)
+        mat.set_float("farPlane", @far)
+        mat
+      end
+    end
+  end
+end

data/lib/engine/rendering/post_processing/effect.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rendering
+  module Effect
+    attr_accessor :enabled
+
+    def enabled
+      @enabled.nil? ? true : @enabled
+    end
+  end
+end

data/lib/engine/rendering/post_processing/post_processing_effect.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Rendering
+  module PostProcessingEffect
+    class << self
+      def add(effect)
+        effects << effect
+        effect
+      end
+
+      def add_all(effects_array)
+        effects_array.each { |effect| add(effect) }
+        effects_array
+      end
+
+      def remove(effect)
+        effects.delete(effect)
+      end
+
+      def clear
+        @effects = []
+      end
+
+      def apply_all(render_texture_a, render_texture_b, screen_quad, normal_buffer = nil, start_index: 0)
+        @depth_texture = render_texture_a.depth_texture
+        @normal_texture = normal_buffer || render_texture_a.normal_texture
+
+        enabled_effects = effects.select(&:enabled)
+        textures = [render_texture_a, render_texture_b]
+        return textures[start_index] if enabled_effects.empty?
+        current_index = start_index
+
+        enabled_effects.each do |effect|
+          input_rt = textures[current_index]
+          output_rt = textures[1 - current_index]
+
+          stage_name = "pp:#{effect.class.name.split('::').last}"
+          result_rt = GpuTimer.measure(stage_name) do
+            effect.apply(input_rt, output_rt, screen_quad)
+          end
+          current_index = 1 - current_index if result_rt == output_rt
+        end
+
+        textures[current_index]
+      end
+
+      def depth_texture
+        @depth_texture
+      end
+
+      def normal_texture
+        @normal_texture
+      end
+
+      def effects
+        @effects ||= []
+      end
+
+      # Built-in effects
+
+      def tint(color: [1.0, 1.0, 1.0], intensity: 0.5)
+        TintEffect.new(color: color, intensity: intensity)
+      end
+
+      def depth_of_field(focus_distance: 10.0, focus_range: 50.0, blur_amount: 3.0, near: 0.1, far: 1000.0)
+        DepthOfFieldEffect.new(focus_distance: focus_distance, focus_range: focus_range, blur_amount: blur_amount, near: near, far: far)
+      end
+
+      def depth_debug
+        DepthDebugEffect.new
+      end
+
+      def bloom(threshold: 0.7, intensity: 1.0, blur_passes: 2, blur_scale: 1.0)
+        BloomEffect.new(threshold: threshold, intensity: intensity, blur_passes: blur_passes, blur_scale: blur_scale)
+      end
+
+      def ssr(max_steps: 64, max_ray_distance: 50.0, thickness: 0.5, ray_offset: 2.0)
+        SSREffect.new(max_steps: max_steps, max_ray_distance: max_ray_distance, thickness: thickness, ray_offset: ray_offset)
+      end
+
+      def ssao(kernel_size: 16, radius: 0.5, bias: 0.025, power: 2.0, blur_size: 2, depth_threshold: 1000.0)
+        SSAOEffect.new(kernel_size: kernel_size, radius: radius, bias: bias, power: power, blur_size: blur_size, depth_threshold: depth_threshold)
+      end
+    end
+  end
+end

data/lib/engine/rendering/post_processing/single_pass_effect.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rendering
+  module SinglePassEffect
+    include Effect
+
+    attr_reader :material
+
+    def apply(input_rt, output_rt, screen_quad)
+      output_rt.bind
+      Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+      Engine::GL.Disable(Engine::GL::DEPTH_TEST)
+
+      material.set_runtime_texture("depthTexture", PostProcessingEffect.depth_texture)
+      screen_quad.draw(material, input_rt.color_texture)
+      output_rt
+    end
+  end
+end