ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/rendering/cubemap_shadow_map_array.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Rendering
+  class CubemapShadowMapArray
+    attr_reader :size, :layer_count, :framebuffer, :depth_texture
+
+    def initialize(size: 1024, layer_count: 4)
+      @size = size
+      @layer_count = layer_count
+      create_framebuffer
+      create_depth_cubemap_array
+      check_framebuffer_complete
+    end
+
+    def bind_face(layer_index, face_index)
+      raise "Layer index #{layer_index} out of bounds" if layer_index >= @layer_count
+      raise "Face index #{face_index} out of bounds" if face_index >= 6
+
+      Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, @framebuffer)
+      # In a cubemap array, layers are: layer0_face0, layer0_face1, ..., layer0_face5, layer1_face0, ...
+      array_layer = layer_index * 6 + face_index
+      Engine::GL.FramebufferTextureLayer(Engine::GL::FRAMEBUFFER, Engine::GL::DEPTH_ATTACHMENT, @depth_texture, 0, array_layer)
+      Engine::GL.Viewport(0, 0, @size, @size)
+      Engine::GL.Clear(Engine::GL::DEPTH_BUFFER_BIT)
+    end
+
+    private
+
+    def create_framebuffer
+      fbo_buf = ' ' * 4
+      Engine::GL.GenFramebuffers(1, fbo_buf)
+      @framebuffer = fbo_buf.unpack1('L')
+    end
+
+    def create_depth_cubemap_array
+      tex_buf = ' ' * 4
+      Engine::GL.GenTextures(1, tex_buf)
+      @depth_texture = tex_buf.unpack1('L')
+
+      Engine::GL.BindTexture(Engine::GL::TEXTURE_CUBE_MAP_ARRAY, @depth_texture)
+
+      # For cubemap arrays, depth = layer_count * 6 (6 faces per cubemap)
+      Engine::GL.TexImage3D(
+        Engine::GL::TEXTURE_CUBE_MAP_ARRAY,
+        0,
+        Engine::GL::DEPTH_COMPONENT32F,
+        @size,
+        @size,
+        @layer_count * 6,
+        0,
+        Engine::GL::DEPTH_COMPONENT,
+        Engine::GL::FLOAT,
+        nil
+      )
+
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_CUBE_MAP_ARRAY, Engine::GL::TEXTURE_MIN_FILTER, Engine::GL::NEAREST)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_CUBE_MAP_ARRAY, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::NEAREST)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_CUBE_MAP_ARRAY, Engine::GL::TEXTURE_WRAP_S, Engine::GL::CLAMP_TO_EDGE)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_CUBE_MAP_ARRAY, Engine::GL::TEXTURE_WRAP_T, Engine::GL::CLAMP_TO_EDGE)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_CUBE_MAP_ARRAY, Engine::GL::TEXTURE_WRAP_R, Engine::GL::CLAMP_TO_EDGE)
+
+      Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, @framebuffer)
+      # Attach first layer's first face for completeness check
+      Engine::GL.FramebufferTextureLayer(Engine::GL::FRAMEBUFFER, Engine::GL::DEPTH_ATTACHMENT, @depth_texture, 0, 0)
+      Engine::GL.DrawBuffer(Engine::GL::NONE)
+      Engine::GL.ReadBuffer(Engine::GL::NONE)
+    end
+
+    def check_framebuffer_complete
+      Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, @framebuffer)
+      status = Engine::GL.CheckFramebufferStatus(Engine::GL::FRAMEBUFFER)
+      unless status == Engine::GL::FRAMEBUFFER_COMPLETE
+        raise "Cubemap shadow map array framebuffer not complete: #{status}"
+      end
+    end
+  end
+end

data/lib/engine/rendering/gpu_timer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Rendering
+  class GpuTimer
+    class << self
+      def enabled?
+        @enabled ||= false
+      end
+
+      def enable
+        @enabled = true
+        @frame_count = 0
+        @stages = []
+        @queries = {}
+        puts "GPU Profiler: ON"
+      end
+
+      def measure(stage)
+        unless enabled?
+          return yield
+        end
+
+        query_id = query_for(stage)
+        Engine::GL.BeginQuery(Engine::GL::TIME_ELAPSED, query_id)
+        result = yield
+        Engine::GL.EndQuery(Engine::GL::TIME_ELAPSED)
+        result
+      end
+
+      def print_results
+        return unless enabled?
+
+        @frame_count += 1
+        return unless (@frame_count % 60) == 0
+
+        results = {}
+        @stages.each do |stage|
+          buf = ' ' * 8
+          Engine::GL.GetQueryObjectui64v(@queries[stage], Engine::GL::QUERY_RESULT, buf)
+          results[stage] = buf.unpack1('Q') / 1_000_000.0
+        end
+
+        total = results.values.sum
+        puts "\n=== GPU Timing ==="
+        @stages.each do |stage|
+          ms = results[stage]
+          pct = total > 0 ? (ms / total * 100).round(1) : 0
+          bar = "█" * (pct / 5).to_i
+          puts format("%-20s %6.2f ms (%5.1f%%) %s", stage, ms, pct, bar)
+        end
+        puts format("%-20s %6.2f ms", "TOTAL", total)
+        puts "===================="
+      end
+
+      private
+
+      def query_for(stage)
+        return @queries[stage] if @queries[stage]
+
+        buf = ' ' * 4
+        Engine::GL.GenQueries(1, buf)
+        @queries[stage] = buf.unpack1('L')
+        @stages << stage
+        @queries[stage]
+      end
+    end
+  end
+end

data/lib/engine/rendering/instance_renderer.rb

@@ -4,45 +4,84 @@ 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 = []
-      @mesh_matrix_data = []
+      @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
-      @mesh_matrix_data += mesh_renderer.game_object.model_matrix.to_a.flatten
+      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)
-      @mesh_matrix_data[index * 16, 16] = []
+      # 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)
-      @mesh_matrix_data[index * 16, 16] = mesh_renderer.game_object.model_matrix.to_a.flatten
+      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
 
-      GL.BindVertexArray(@vao)
+      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
-      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @ebo)
-      GL.BindBuffer(GL::ARRAY_BUFFER, @instance_vbo)
+      Engine::GL.BindBuffer(Engine::GL::ELEMENT_ARRAY_BUFFER, @ebo)
+      Engine::GL.BindBuffer(Engine::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)
+      Engine::GL.DrawElementsInstanced(Engine::GL::TRIANGLES, mesh.index_data.length, Engine::GL::UNSIGNED_INT, 0, @mesh_renderers.count)
     end
 
     private
@@ -50,6 +89,7 @@ module Rendering
     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
@@ -57,97 +97,136 @@ module Rendering
 
     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.game_object.pos)
+        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|
-        material.set_vec3("directionalLights[#{i}].direction", light.game_object.forward)
+        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
-      GL.GenBuffers(1, ebo_buf)
+      Engine::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
+      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
-      GL.GenVertexArrays(1, vao_buf)
+      Engine::GL.GenVertexArrays(1, vao_buf)
       @vao = vao_buf.unpack('L')[0]
-      GL.BindVertexArray(@vao)
+      Engine::GL.BindVertexArray(@vao)
     end
 
     def setup_vertex_buffer
       vbo_buf = ' ' * 4
-      GL.GenBuffers(1, vbo_buf)
+      Engine::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
+      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
 
-      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)
+      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
-      GL.GenBuffers(1, instance_vbo_buf)
+      Engine::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
-      )
+      Engine::GL.BindBuffer(Engine::GL::ARRAY_BUFFER, @instance_vbo)
 
+      # Set up vertex attributes once (stored in VAO)
       vec4_size = Fiddle::SIZEOF_FLOAT * 4
 
-      GL.EnableVertexAttribArray(7)
-      GL.EnableVertexAttribArray(8)
-      GL.EnableVertexAttribArray(9)
-      GL.EnableVertexAttribArray(10)
+      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)
 
-      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)
+      Engine::GL.VertexAttribDivisor(7, 1)
+      Engine::GL.VertexAttribDivisor(8, 1)
+      Engine::GL.VertexAttribDivisor(9, 1)
+      Engine::GL.VertexAttribDivisor(10, 1)
+    end
 
-      GL.VertexAttribDivisor(7, 1)
-      GL.VertexAttribDivisor(8, 1)
-      GL.VertexAttribDivisor(9, 1)
-      GL.VertexAttribDivisor(10, 1)
+    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