Module: Rendering::RenderPipeline

Defined in:
lib/engine/rendering/render_pipeline.rb

Class Method Summary collapse

Class Method Details

.add_instance(mesh_renderer) ⇒ Object 



133
134
135
 
# File 'lib/engine/rendering/render_pipeline.rb', line 133

def self.add_instance(mesh_renderer)
  instance_renderers[mesh_renderer.renderer_key].add_instance(mesh_renderer)
end

.alternate_rt(current_rt) ⇒ Object 



155
156
157
 
# File 'lib/engine/rendering/render_pipeline.rb', line 155

def self.alternate_rt(current_rt)
  current_rt == render_texture_a ? render_texture_b : render_texture_a
end

.blit_material ⇒ Object 



182
183
184
 
# File 'lib/engine/rendering/render_pipeline.rb', line 182

def self.blit_material
  @blit_material ||= Engine::Material.create(shader: Engine::Shader.fullscreen)
end

.blit_to_screen(texture) ⇒ Object 



163
164
165
166
167
 
# File 'lib/engine/rendering/render_pipeline.rb', line 163

def self.blit_to_screen(texture)
  Engine::GL.BindFramebuffer(Engine::GL::FRAMEBUFFER, 0)
  reset_viewport
  screen_quad.draw(blit_material, texture)
end

.clear_buffer ⇒ Object 



159
160
161
 
# File 'lib/engine/rendering/render_pipeline.rb', line 159

def self.clear_buffer
  Engine::GL.Clear(Engine::GL::COLOR_BUFFER_BIT | Engine::GL::DEPTH_BUFFER_BIT)
end

.copy_fbo ⇒ Object 



244
245
246
247
248
249
250
 
# File 'lib/engine/rendering/render_pipeline.rb', line 244

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

.copy_normal_texture ⇒ Object 



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/engine/rendering/render_pipeline.rb', line 228

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

.create_normal_buffer ⇒ Object 



198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/engine/rendering/render_pipeline.rb', line 198

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

.directional_shadow_map_array ⇒ Object 



84
85
86
 
# File 'lib/engine/rendering/render_pipeline.rb', line 84

def self.directional_shadow_map_array
  @directional_shadow_map_array ||= ShadowMapArray.new(layer_count: 4)
end

.disable_depth_test ⇒ Object 



174
175
176
 
# File 'lib/engine/rendering/render_pipeline.rb', line 174

def self.disable_depth_test
  Engine::GL.Disable(Engine::GL::DEPTH_TEST)
end

.draw ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/engine/rendering/render_pipeline.rb', line 5

def self.draw
  # Skip rendering when window is minimized (e.g. alt-tab on Windows)
  return if Engine::Window.framebuffer_width <= 0 || Engine::Window.framebuffer_height <= 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(:debug) do
    DebugDraw.draw(current_texture.framebuffer)
  end

  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

.draw_3d ⇒ Object 



122
123
124
 
# File 'lib/engine/rendering/render_pipeline.rb', line 122

def self.draw_3d
  instance_renderers.values.each(&:draw_all)
end

.draw_shadow_maps ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/engine/rendering/render_pipeline.rb', line 53

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

.draw_ui ⇒ Object 



126
127
128
129
130
131
 
# File 'lib/engine/rendering/render_pipeline.rb', line 126

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

.enable_depth_test ⇒ Object 



169
170
171
172
 
# File 'lib/engine/rendering/render_pipeline.rb', line 169

def self.enable_depth_test
  Engine::GL.Enable(Engine::GL::DEPTH_TEST)
  Engine::GL.DepthFunc(Engine::GL::LESS)
end

.instance_renderers ⇒ Object 



268
269
270
271
272
 
# File 'lib/engine/rendering/render_pipeline.rb', line 268

def self.instance_renderers
  @instance_renderers ||= Hash.new do |hash, key|
    hash[key] = InstanceRenderer.new(key[0], key[1])
  end
end

.normal_buffer ⇒ Object 



194
195
196
 
# File 'lib/engine/rendering/render_pipeline.rb', line 194

def self.normal_buffer
  @normal_buffer ||= create_normal_buffer
end

.point_shadow_map_array ⇒ Object 



92
93
94
 
# File 'lib/engine/rendering/render_pipeline.rb', line 92

def self.point_shadow_map_array
  @point_shadow_map_array ||= CubemapShadowMapArray.new(layer_count: 4)
end

.remove_instance(mesh_renderer) ⇒ Object 



137
138
139
 
# File 'lib/engine/rendering/render_pipeline.rb', line 137

def self.remove_instance(mesh_renderer)
  instance_renderers[mesh_renderer.renderer_key].remove_instance(mesh_renderer)
end

.render_point_shadow_to_layer(layer_index, light) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/engine/rendering/render_pipeline.rb', line 103

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

.render_shadow_map_to_layer(shadow_map_array, layer_index, light_space_matrix) ⇒ Object 



96
97
98
99
100
101
 
# File 'lib/engine/rendering/render_pipeline.rb', line 96

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_depth_only(light_space_matrix)
  end
end

.render_texture_a ⇒ Object 



252
253
254
255
256
257
258
 
# File 'lib/engine/rendering/render_pipeline.rb', line 252

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

.render_texture_b ⇒ Object 



260
261
262
 
# File 'lib/engine/rendering/render_pipeline.rb', line 260

def self.render_texture_b
  @render_texture_b ||= RenderTexture.new(Engine::Window.framebuffer_width, Engine::Window.framebuffer_height)
end

.reset_viewport ⇒ Object 



178
179
180
 
# File 'lib/engine/rendering/render_pipeline.rb', line 178

def self.reset_viewport
  Engine::GL.Viewport(0, 0, Engine::Window.framebuffer_width, Engine::Window.framebuffer_height)
end

.resize_normal_buffer(width, height) ⇒ Object 



218
219
220
221
222
223
224
225
226
 
# File 'lib/engine/rendering/render_pipeline.rb', line 218

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

.screen_quad ⇒ Object 



264
265
266
 
# File 'lib/engine/rendering/render_pipeline.rb', line 264

def self.screen_quad
  @screen_quad ||= ScreenQuad.new
end

.set_skybox_colors(ground:, horizon:, sky:, ground_y: -0.3,, horizon_y: 0.0, sky_y: 1.0) ⇒ Object 



145
146
147
 
# File 'lib/engine/rendering/render_pipeline.rb', line 145

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

.skybox_cubemap ⇒ Object 



149
150
151
 
# File 'lib/engine/rendering/render_pipeline.rb', line 149

def self.skybox_cubemap
  SkyboxRenderer.cubemap
end

.spot_shadow_map_array ⇒ Object 



88
89
90
 
# File 'lib/engine/rendering/render_pipeline.rb', line 88

def self.spot_shadow_map_array
  @spot_shadow_map_array ||= ShadowMapArray.new(layer_count: 4)
end

.sync_transforms ⇒ Object 



116
117
118
119
120
 
# File 'lib/engine/rendering/render_pipeline.rb', line 116

def self.sync_transforms
  Engine::GameObject.mesh_renderers.each do |renderer|
    renderer.sync_transform if renderer.respond_to?(:sync_transform)
  end
end

.update_instance(mesh_renderer) ⇒ Object 



141
142
143
 
# File 'lib/engine/rendering/render_pipeline.rb', line 141

def self.update_instance(mesh_renderer)
  instance_renderers[mesh_renderer.renderer_key].update_instance(mesh_renderer)
end

.update_render_texture_size ⇒ Object 



186
187
188
189
190
191
192
 
# File 'lib/engine/rendering/render_pipeline.rb', line 186

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