ruby_rpg 0.0.4 → 0.1.0

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

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Rendering
+  class SSAOEffect
+    include Effect
+
+    def initialize(kernel_size: 16, radius: 0.5, bias: 0.025, power: 2.0, blur_size: 2, depth_threshold: 1000.0)
+      @kernel_size = [kernel_size, 64].min
+      @radius = radius
+      @bias = bias
+      @power = power
+      @blur_size = blur_size
+      @depth_threshold = depth_threshold
+    end
+
+    def apply(input_rt, output_rt, screen_quad)
+      ensure_textures(input_rt.width, input_rt.height)
+
+      camera = Engine::Camera.instance
+      Engine::GL.Disable(Engine::GL::DEPTH_TEST)
+
+      # Pass 1: Generate SSAO
+      @ssao_rt.bind
+      Engine::GL.ClearColor(1.0, 1.0, 1.0, 1.0)
+      Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+
+      ssao_material.set_runtime_texture("depthTexture", PostProcessingEffect.depth_texture)
+      ssao_material.set_runtime_texture("normalTexture", PostProcessingEffect.normal_texture)
+      ssao_material.set_runtime_texture("noiseTexture", noise_texture)
+
+      ssao_material.set_mat4("projection", camera.projection.transpose)
+      ssao_material.set_mat4("view", camera.view_matrix)
+      ssao_material.set_mat4("inverseVP", camera.inverse_vp_matrix)
+      ssao_material.set_float("nearPlane", camera.near)
+      ssao_material.set_float("farPlane", camera.far)
+
+      noise_scale = [@ssao_rt.width / 4.0, @ssao_rt.height / 4.0]
+      ssao_material.set_vec2("noiseScale", noise_scale)
+
+      screen_quad.draw_with_material(ssao_material)
+
+      # Pass 2: Blur SSAO
+      @blur_rt.bind
+      Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+
+      blur_material.set_runtime_texture("ssaoTexture", @ssao_rt.color_texture)
+      blur_material.set_runtime_texture("depthTexture", PostProcessingEffect.depth_texture)
+
+      screen_quad.draw_with_material(blur_material)
+
+      # Pass 3: Combine with scene
+      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("ssaoTexture", @blur_rt.color_texture)
+
+      screen_quad.draw_with_material(combine_material)
+      output_rt
+    end
+
+    attr_accessor :radius, :bias, :power, :blur_size
+
+    def update_params
+      ssao_material.set_float("radius", @radius)
+      ssao_material.set_float("bias", @bias)
+      ssao_material.set_float("power", @power)
+      blur_material.set_int("blurSize", @blur_size)
+    end
+
+    private
+
+    def kernel
+      @kernel ||= begin
+        samples = []
+        @kernel_size.times do |i|
+          # Random point in hemisphere (tangent space)
+          x = rand * 2.0 - 1.0
+          y = rand * 2.0 - 1.0
+          z = rand # z is always positive (hemisphere)
+
+          # Normalize
+          length = Math.sqrt(x**2 + y**2 + z**2)
+          x /= length
+          y /= length
+          z /= length
+
+          # Scale to distribute more samples near origin (accelerating lerp)
+          scale = i.to_f / @kernel_size
+          scale = lerp(0.1, 1.0, scale * scale)
+
+          samples << Vector[x * scale, y * scale, z * scale]
+        end
+        samples
+      end
+    end
+
+    def lerp(a, b, t)
+      a + (b - a) * t
+    end
+
+    def noise_texture
+      @noise_texture ||= begin
+        # 4x4 texture of random rotation vectors (tangent space)
+        noise_data = []
+        16.times do
+          noise_data << (rand * 2.0 - 1.0) # x
+          noise_data << (rand * 2.0 - 1.0) # y
+          noise_data << 0.0                 # z (rotate around z axis)
+        end
+
+        tex_buf = ' ' * 4
+        Engine::GL.GenTextures(1, tex_buf)
+        texture = tex_buf.unpack1('L')
+
+        Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, texture)
+        Engine::GL.TexImage2D(Engine::GL::TEXTURE_2D, 0, Engine::GL::RGB16F, 4, 4, 0, Engine::GL::RGB, Engine::GL::FLOAT, noise_data.pack('f*'))
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MIN_FILTER, Engine::GL::NEAREST)
+        Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_MAG_FILTER, Engine::GL::NEAREST)
+        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)
+        texture
+      end
+    end
+
+    def ssao_material
+      @ssao_material ||= begin
+        material = Engine::Material.create(
+          shader: Engine::Shader.for(
+            'fullscreen_vertex.glsl',
+            'post_process/ssao/frag.glsl',
+            source: :engine
+          )
+        )
+
+        # Upload kernel samples
+        kernel.each_with_index do |sample, i|
+          material.set_vec3("samples[#{i}]", sample)
+        end
+        material.set_int("kernelSize", @kernel_size)
+        material.set_float("radius", @radius)
+        material.set_float("bias", @bias)
+        material.set_float("power", @power)
+        material
+      end
+    end
+
+    def blur_material
+      @blur_material ||= begin
+        material = Engine::Material.create(
+          shader: Engine::Shader.for(
+            'fullscreen_vertex.glsl',
+            'post_process/ssao/blur_frag.glsl',
+            source: :engine
+          )
+        )
+        material.set_int("blurSize", @blur_size)
+        material.set_float("depthThreshold", @depth_threshold)
+        material
+      end
+    end
+
+    def combine_material
+      @combine_material ||= Engine::Material.create(
+        shader: Engine::Shader.for(
+          'fullscreen_vertex.glsl',
+          'post_process/ssao/combine_frag.glsl',
+          source: :engine
+        )
+      )
+    end
+
+    def ensure_textures(width, height)
+      half_width = width / 2
+      half_height = height / 2
+      if @ssao_rt.nil? || @ssao_rt.width != half_width || @ssao_rt.height != half_height
+        @ssao_rt = RenderTexture.new(half_width, half_height)
+        @blur_rt = RenderTexture.new(half_width, half_height)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Rendering
+  class SSREffect
+    include Effect
+
+    def initialize(max_steps: 64, max_ray_distance: 50.0, thickness: 0.5, ray_offset: 2.0)
+      @max_steps = max_steps
+      @max_ray_distance = max_ray_distance
+      @thickness = thickness
+      @ray_offset = ray_offset
+    end
+
+    def apply(input_rt, output_rt, screen_quad)
+      ensure_textures(input_rt.width, input_rt.height)
+
+      camera = Engine::Camera.instance
+      Engine::GL.Disable(Engine::GL::DEPTH_TEST)
+
+      # Pass 1: Render SSR at half resolution
+      @ssr_rt.bind
+      Engine::GL.Disable(Engine::GL::BLEND)
+      Engine::GL.ClearColor(0.0, 0.0, 0.0, 0.0)
+      Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT)
+
+      ssr_material.set_runtime_texture("screenTexture", input_rt.color_texture)
+      ssr_material.set_runtime_texture("depthTexture", PostProcessingEffect.depth_texture)
+      ssr_material.set_runtime_texture("normalTexture", PostProcessingEffect.normal_texture)
+
+      ssr_material.set_mat4("inverseVP", camera.inverse_vp_matrix)
+      ssr_material.set_mat4("viewProj", camera.matrix)
+      ssr_material.set_vec3("cameraPos", camera.position)
+      ssr_material.set_float("nearPlane", camera.near)
+      ssr_material.set_float("farPlane", camera.far)
+
+      cubemap = RenderPipeline.skybox_cubemap
+      ssr_material.set_cubemap("skyboxCubemap", cubemap&.texture)
+
+      screen_quad.draw_with_material(ssr_material)
+
+      # Pass 2: Combine with scene at full resolution
+      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("ssrTexture", @ssr_rt.color_texture)
+
+      screen_quad.draw_with_material(combine_material)
+      output_rt
+    end
+
+    private
+
+    def ssr_material
+      @ssr_material ||= begin
+        material = Engine::Material.create(
+          shader: Engine::Shader.for(
+            'fullscreen_vertex.glsl',
+            'post_process/ssr/frag.glsl',
+            source: :engine
+          )
+        )
+        material.set_int("maxSteps", @max_steps)
+        material.set_float("maxRayDistance", @max_ray_distance)
+        material.set_float("thickness", @thickness)
+        material.set_float("rayOffset", @ray_offset)
+        material
+      end
+    end
+
+    def combine_material
+      @combine_material ||= Engine::Material.create(
+        shader: Engine::Shader.for(
+          'fullscreen_vertex.glsl',
+          'post_process/ssr/combine_frag.glsl',
+          source: :engine
+        )
+      )
+    end
+
+    def ensure_textures(width, height)
+      half_width = width / 2
+      half_height = height / 2
+      if @ssr_rt.nil? || @ssr_rt.width != half_width || @ssr_rt.height != half_height
+        @ssr_rt = RenderTexture.new(half_width, half_height)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rendering
+  class TintEffect
+    include SinglePassEffect
+
+    def initialize(color: [1.0, 1.0, 1.0], intensity: 0.5)
+      @material = Engine::Material.create(
+        shader: Engine::Shader.for(
+          'fullscreen_vertex.glsl',
+          'post_process/tint_frag.glsl',
+          source: :engine
+        )
+      )
+      @material.set_vec4("tintColor", [color[0], color[1], color[2], intensity])
+    end
+  end
+end

data/lib/engine/rendering/render_pipeline.rb

@@ -3,29 +3,261 @@
 module Rendering
   module RenderPipeline
     def self.draw
-      Engine::GameObject.mesh_renderers.each do |mesh_renderer|
-        mesh_renderer.update(0)
+      update_render_texture_size
+      sync_transforms
+      SkyboxRenderer.render_cubemap
+      reset_viewport
+
+      GpuTimer.measure(:shadows) do
+        enable_depth_test
+        draw_shadow_maps
+      end
+
+      GpuTimer.measure(:main_3d) do
+        render_texture_a.bind
+        clear_buffer
+        Engine::GL.Disable(Engine::GL::BLEND)  # Disable blending to preserve alpha channel (roughness) in MRT
+        draw_3d
+        Engine::GL.Enable(Engine::GL::BLEND)   # Re-enable for UI and post-processing
+      end
+
+      # Copy normal texture to separate buffer to avoid read/write hazard in SSR
+      copy_normal_texture
+
+      GpuTimer.measure(:skybox) do
+        SkyboxRenderer.draw(render_texture_a, render_texture_b, screen_quad)
+      end
+
+      current_texture = PostProcessingEffect.apply_all(render_texture_a, render_texture_b, screen_quad, normal_buffer, start_index: 1)
+
+      GpuTimer.measure(:ui) do
+        disable_depth_test
+        current_texture.bind
+        draw_ui
+      end
+
+      GpuTimer.measure(:blit) do
+        blit_to_screen(current_texture.color_texture)
       end
 
+      GpuTimer.print_results
+    end
+
+    def self.draw_shadow_maps
+      # Render directional light shadows to shared texture array
+      directional_casters = Engine::Components::DirectionLight.direction_lights
+        .select(&:cast_shadows)
+        .take(4)
+      directional_casters.each_with_index do |light, layer_index|
+        light.shadow_layer_index = layer_index
+        render_shadow_map_to_layer(directional_shadow_map_array, layer_index, light.light_space_matrix)
+      end
+
+      # Render spot light shadows to shared texture array
+      spot_casters = Engine::Components::SpotLight.spot_lights
+        .select(&:cast_shadows)
+        .take(4)
+      spot_casters.each_with_index do |light, layer_index|
+        light.shadow_layer_index = layer_index
+        render_shadow_map_to_layer(spot_shadow_map_array, layer_index, light.light_space_matrix)
+      end
+
+      # Render point light shadows to shared cubemap array
+      point_casters = Engine::Components::PointLight.point_lights
+        .select(&:cast_shadows)
+        .take(4)
+      point_casters.each_with_index do |light, layer_index|
+        light.shadow_layer_index = layer_index
+        render_point_shadow_to_layer(layer_index, light)
+      end
+
+      reset_viewport
+    end
+
+    def self.directional_shadow_map_array
+      @directional_shadow_map_array ||= ShadowMapArray.new(layer_count: 4)
+    end
+
+    def self.spot_shadow_map_array
+      @spot_shadow_map_array ||= ShadowMapArray.new(layer_count: 4)
+    end
+
+    def self.point_shadow_map_array
+      @point_shadow_map_array ||= CubemapShadowMapArray.new(layer_count: 4)
+    end
+
+    def self.render_shadow_map_to_layer(shadow_map_array, layer_index, light_space_matrix)
+      shadow_map_array.bind_layer(layer_index)
       instance_renderers.values.each do |renderer|
-        renderer.draw_all
+        renderer.draw_depth_only(light_space_matrix)
+      end
+    end
+
+    def self.render_point_shadow_to_layer(layer_index, light)
+      light_pos = light.position
+      far_plane = light.shadow_far
+      matrices = light.light_space_matrices
+
+      6.times do |face_index|
+        point_shadow_map_array.bind_face(layer_index, face_index)
+        instance_renderers.values.each do |renderer|
+          renderer.draw_point_light_depth(matrices[face_index], light_pos, far_plane)
+        end
       end
     end
 
+    def self.sync_transforms
+      Engine::GameObject.mesh_renderers.each do |renderer|
+        renderer.sync_transform if renderer.respond_to?(:sync_transform)
+      end
+    end
+
+    def self.draw_3d
+      instance_renderers.values.each(&:draw_all)
+    end
+
+    def self.draw_ui
+      Engine::GL.Clear(Engine::GL::STENCIL_BUFFER_BIT)
+      Engine::GL.Disable(Engine::GL::CULL_FACE)
+      Engine::Components::UI::Rect.draw_all
+      Engine::GL.Enable(Engine::GL::CULL_FACE)
+    end
+
     def self.add_instance(mesh_renderer)
-      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].add_instance(mesh_renderer)
+      instance_renderers[mesh_renderer.renderer_key].add_instance(mesh_renderer)
     end
 
     def self.remove_instance(mesh_renderer)
-      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].remove_instance(mesh_renderer)
+      instance_renderers[mesh_renderer.renderer_key].remove_instance(mesh_renderer)
     end
 
     def self.update_instance(mesh_renderer)
-      instance_renderers[[mesh_renderer.mesh, mesh_renderer.material]].update_instance(mesh_renderer)
+      instance_renderers[mesh_renderer.renderer_key].update_instance(mesh_renderer)
+    end
+
+    def self.set_skybox_colors(ground:, horizon:, sky:, ground_y: -0.3, horizon_y: 0.0, sky_y: 1.0)
+      SkyboxRenderer.set_colors(ground: ground, horizon: horizon, sky: sky, ground_y: ground_y, horizon_y: horizon_y, sky_y: sky_y)
+    end
+
+    def self.skybox_cubemap
+      SkyboxRenderer.cubemap
     end
 
     private
 
+    def self.alternate_rt(current_rt)
+      current_rt == render_texture_a ? render_texture_b : render_texture_a
+    end
+
+    def self.clear_buffer
+      Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT | Engine::GL::DEPTH_BUFFER_BIT)
+    end
+
+    def self.blit_to_screen(texture)
+      Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, 0)
+      reset_viewport
+      screen_quad.draw(blit_material, texture)
+    end
+
+    def self.enable_depth_test
+      Engine::GL.Enable(Engine::GL::DEPTH_TEST)
+      Engine::GL.DepthFunc(Engine::GL::LESS)
+    end
+
+    def self.disable_depth_test
+      Engine::GL.Disable(Engine::GL::DEPTH_TEST)
+    end
+
+    def self.reset_viewport
+      Engine::GL.Viewport(0, 0, Engine::Window.framebuffer_width, Engine::Window.framebuffer_height)
+    end
+
+    def self.blit_material
+      @blit_material ||= Engine::Material.create(shader: Engine::Shader.fullscreen)
+    end
+
+    def self.update_render_texture_size
+      width = Engine::Window.framebuffer_width
+      height = Engine::Window.framebuffer_height
+      render_texture_a.resize(width, height)
+      render_texture_b.resize(width, height)
+      resize_normal_buffer(width, height)
+    end
+
+    def self.normal_buffer
+      @normal_buffer ||= create_normal_buffer
+    end
+
+    def self.create_normal_buffer
+      width = Engine::Window.framebuffer_width
+      height = Engine::Window.framebuffer_height
+
+      tex_buf = ' ' * 4
+      Engine::GL.GenTextures(1, tex_buf)
+      texture = tex_buf.unpack1('L')
+
+      Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, texture)
+      Engine::GL.TexImage2D(Engine::GL::TEXTURE_2D, 0, Engine::GL::RGBA16F, width, height, 0, Engine::GL::RGBA, Engine::GL::FLOAT, nil)
+      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)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_S, Engine::GL::CLAMP_TO_EDGE)
+      Engine::GL.TexParameteri(Engine::GL::TEXTURE_2D, Engine::GL::TEXTURE_WRAP_T, Engine::GL::CLAMP_TO_EDGE)
+
+      @normal_buffer_width = width
+      @normal_buffer_height = height
+      texture
+    end
+
+    def self.resize_normal_buffer(width, height)
+      return if @normal_buffer_width == width && @normal_buffer_height == height
+      return unless @normal_buffer
+
+      Engine::GL.BindTexture(Engine::GL::TEXTURE_2D, @normal_buffer)
+      Engine::GL.TexImage2D(Engine::GL::TEXTURE_2D, 0, Engine::GL::RGBA16F, width, height, 0, Engine::GL::RGBA, Engine::GL::FLOAT, nil)
+      @normal_buffer_width = width
+      @normal_buffer_height = height
+    end
+
+    def self.copy_normal_texture
+      width = Engine::Window.framebuffer_width
+      height = Engine::Window.framebuffer_height
+
+      # Bind source (render_texture_a's normal attachment) as read framebuffer
+      Engine::GL.BindFramebuffer(Engine::GL::READ_FRAMEBUFFER, render_texture_a.framebuffer)
+      Engine::GL.ReadBuffer(Engine::GL::COLOR_ATTACHMENT1)  # Normal is second attachment
+
+      # Bind destination texture to a temp framebuffer for writing
+      Engine::GL.BindFramebuffer(Engine::GL::DRAW_FRAMEBUFFER, copy_fbo)
+      Engine::GL.FramebufferTexture2D(Engine::GL::DRAW_FRAMEBUFFER, Engine::GL::COLOR_ATTACHMENT0, Engine::GL::TEXTURE_2D, normal_buffer, 0)
+
+      # Blit
+      Engine::GL.BlitFramebuffer(0, 0, width, height, 0, 0, width, height, Engine::GL::COLOR_BUFFER_BIT, Engine::GL::NEAREST)
+    end
+
+    def self.copy_fbo
+      return @copy_fbo if @copy_fbo
+
+      fbo_buf = ' ' * 4
+      Engine::GL.GenFramebuffers(1, fbo_buf)
+      @copy_fbo = fbo_buf.unpack1('L')
+    end
+
+    def self.render_texture_a
+      @render_texture_a ||= RenderTexture.new(
+        Engine::Window.framebuffer_width,
+        Engine::Window.framebuffer_height,
+        num_color_attachments: 2  # Color + Normal/Roughness for SSR
+      )
+    end
+
+    def self.render_texture_b
+      @render_texture_b ||= RenderTexture.new(Engine::Window.framebuffer_width, Engine::Window.framebuffer_height)
+    end
+
+    def self.screen_quad
+      @screen_quad ||= ScreenQuad.new
+    end
+
     def self.instance_renderers
       @instance_renderers ||= Hash.new do |hash, key|
         hash[key] = InstanceRenderer.new(key[0], key[1])