662 lines
22 KiB
Markdown
662 lines
22 KiB
Markdown
# Phase 7-2: SSGI Implementation Plan
|
|
|
|
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
|
|
|
**Goal:** SSAO + Color Bleeding 기반 SSGI로 간접광과 앰비언트 오클루전 추가
|
|
|
|
**Architecture:** `voltex_renderer`에 ssgi.rs(리소스+커널 생성) + ssgi_shader.wgsl(SSGI 풀스크린 패스) 추가. 기존 deferred_lighting.wgsl의 Shadow+IBL 바인드 그룹에 SSGI 출력 텍스처를 추가하여 ambient에 적용.
|
|
|
|
**Tech Stack:** Rust, wgpu 28.0, WGSL
|
|
|
|
**Spec:** `docs/superpowers/specs/2026-03-25-phase7-2-ssgi.md`
|
|
|
|
---
|
|
|
|
## File Structure
|
|
|
|
- `crates/voltex_renderer/src/ssgi.rs` — SsgiResources, SsgiUniform, 커널/노이즈 생성 (Create)
|
|
- `crates/voltex_renderer/src/ssgi_shader.wgsl` — SSGI 풀스크린 셰이더 (Create)
|
|
- `crates/voltex_renderer/src/deferred_pipeline.rs` — SSGI 파이프라인 + 바인드 그룹 레이아웃 추가 (Modify)
|
|
- `crates/voltex_renderer/src/deferred_lighting.wgsl` — SSGI 텍스처 읽어서 ambient 적용 (Modify)
|
|
- `crates/voltex_renderer/src/lib.rs` — ssgi 모듈 등록 (Modify)
|
|
- `examples/deferred_demo/src/main.rs` — SSGI 패스 통합 (Modify)
|
|
|
|
---
|
|
|
|
## Task 1: SsgiResources + 커널/노이즈 생성
|
|
|
|
**Files:**
|
|
- Create: `crates/voltex_renderer/src/ssgi.rs`
|
|
- Modify: `crates/voltex_renderer/src/lib.rs`
|
|
|
|
- [ ] **Step 1: ssgi.rs 작성**
|
|
|
|
```rust
|
|
// crates/voltex_renderer/src/ssgi.rs
|
|
use bytemuck::{Pod, Zeroable};
|
|
use wgpu::util::DeviceExt;
|
|
|
|
pub const SSGI_OUTPUT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
|
|
pub const SSGI_KERNEL_SIZE: usize = 64;
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
|
|
pub struct SsgiUniform {
|
|
pub projection: [f32; 16],
|
|
pub view: [f32; 16],
|
|
pub radius: f32,
|
|
pub bias: f32,
|
|
pub intensity: f32,
|
|
pub indirect_strength: f32,
|
|
}
|
|
|
|
impl Default for SsgiUniform {
|
|
fn default() -> Self {
|
|
Self {
|
|
projection: [0.0; 16],
|
|
view: [0.0; 16],
|
|
radius: 0.5,
|
|
bias: 0.025,
|
|
intensity: 1.5,
|
|
indirect_strength: 0.5,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct SsgiResources {
|
|
pub output_view: wgpu::TextureView,
|
|
pub kernel_buffer: wgpu::Buffer,
|
|
pub noise_view: wgpu::TextureView,
|
|
pub noise_sampler: wgpu::Sampler,
|
|
pub uniform_buffer: wgpu::Buffer,
|
|
pub width: u32,
|
|
pub height: u32,
|
|
}
|
|
|
|
impl SsgiResources {
|
|
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, width: u32, height: u32) -> Self {
|
|
let output_view = create_ssgi_output(device, width, height);
|
|
let kernel_data = generate_kernel(SSGI_KERNEL_SIZE);
|
|
let kernel_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
|
label: Some("SSGI Kernel"),
|
|
contents: bytemuck::cast_slice(&kernel_data),
|
|
usage: wgpu::BufferUsages::UNIFORM,
|
|
});
|
|
let noise_view = create_noise_texture(device, queue);
|
|
let noise_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
|
|
label: Some("SSGI Noise Sampler"),
|
|
address_mode_u: wgpu::AddressMode::Repeat,
|
|
address_mode_v: wgpu::AddressMode::Repeat,
|
|
mag_filter: wgpu::FilterMode::Nearest,
|
|
min_filter: wgpu::FilterMode::Nearest,
|
|
..Default::default()
|
|
});
|
|
let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
|
label: Some("SSGI Uniform"),
|
|
contents: bytemuck::bytes_of(&SsgiUniform::default()),
|
|
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
|
});
|
|
Self { output_view, kernel_buffer, noise_view, noise_sampler, uniform_buffer, width, height }
|
|
}
|
|
|
|
pub fn resize(&mut self, device: &wgpu::Device, width: u32, height: u32) {
|
|
self.output_view = create_ssgi_output(device, width, height);
|
|
self.width = width;
|
|
self.height = height;
|
|
}
|
|
}
|
|
|
|
fn create_ssgi_output(device: &wgpu::Device, w: u32, h: u32) -> wgpu::TextureView {
|
|
let tex = device.create_texture(&wgpu::TextureDescriptor {
|
|
label: Some("SSGI Output"),
|
|
size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
|
|
mip_level_count: 1,
|
|
sample_count: 1,
|
|
dimension: wgpu::TextureDimension::D2,
|
|
format: SSGI_OUTPUT_FORMAT,
|
|
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
|
|
view_formats: &[],
|
|
});
|
|
tex.create_view(&wgpu::TextureViewDescriptor::default())
|
|
}
|
|
|
|
/// Generate hemisphere sample kernel for SSAO/SSGI.
|
|
/// Samples are distributed in a hemisphere (z >= 0) with more samples near center.
|
|
pub fn generate_kernel(count: usize) -> Vec<[f32; 4]> {
|
|
let mut kernel = Vec::with_capacity(count);
|
|
for i in 0..count {
|
|
// Pseudo-random using simple hash
|
|
let fi = i as f32;
|
|
let x = pseudo_random(i * 2) * 2.0 - 1.0;
|
|
let y = pseudo_random(i * 2 + 1) * 2.0 - 1.0;
|
|
let z = pseudo_random(i * 3 + 7).max(0.05); // hemisphere, z > 0
|
|
|
|
let len = (x * x + y * y + z * z).sqrt();
|
|
let (nx, ny, nz) = (x / len, y / len, z / len);
|
|
|
|
// Scale: more samples near center
|
|
let mut scale = fi / count as f32;
|
|
scale = 0.1 + scale * scale * 0.9; // lerp(0.1, 1.0, scale^2)
|
|
|
|
kernel.push([nx * scale, ny * scale, nz * scale, 0.0]);
|
|
}
|
|
kernel
|
|
}
|
|
|
|
/// Generate 4x4 noise texture data (random tangent-space rotation vectors).
|
|
pub fn generate_noise_data() -> Vec<[f32; 4]> {
|
|
let mut noise = Vec::with_capacity(16);
|
|
for i in 0..16 {
|
|
let x = pseudo_random(i * 5 + 13) * 2.0 - 1.0;
|
|
let y = pseudo_random(i * 7 + 17) * 2.0 - 1.0;
|
|
let len = (x * x + y * y).sqrt().max(0.001);
|
|
noise.push([x / len, y / len, 0.0, 0.0]);
|
|
}
|
|
noise
|
|
}
|
|
|
|
fn create_noise_texture(device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::TextureView {
|
|
let data = generate_noise_data();
|
|
let bytes: Vec<u8> = data.iter().flat_map(|v| {
|
|
v.iter().flat_map(|f| f.to_le_bytes())
|
|
}).collect();
|
|
|
|
let tex = device.create_texture(&wgpu::TextureDescriptor {
|
|
label: Some("SSGI Noise"),
|
|
size: wgpu::Extent3d { width: 4, height: 4, depth_or_array_layers: 1 },
|
|
mip_level_count: 1,
|
|
sample_count: 1,
|
|
dimension: wgpu::TextureDimension::D2,
|
|
format: wgpu::TextureFormat::Rgba32Float,
|
|
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
|
|
view_formats: &[],
|
|
});
|
|
queue.write_texture(
|
|
wgpu::TexelCopyTextureInfo { texture: &tex, mip_level: 0, origin: wgpu::Origin3d::ZERO, aspect: wgpu::TextureAspect::All },
|
|
&bytes,
|
|
wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(4 * 16), rows_per_image: None },
|
|
wgpu::Extent3d { width: 4, height: 4, depth_or_array_layers: 1 },
|
|
);
|
|
tex.create_view(&wgpu::TextureViewDescriptor::default())
|
|
}
|
|
|
|
/// Simple deterministic pseudo-random [0, 1) from integer seed.
|
|
fn pseudo_random(seed: usize) -> f32 {
|
|
let n = seed.wrapping_mul(0x5DEECE66D).wrapping_add(0xB) & 0xFFFFFF;
|
|
n as f32 / 0xFFFFFF as f32
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_kernel_hemisphere() {
|
|
let kernel = generate_kernel(64);
|
|
assert_eq!(kernel.len(), 64);
|
|
for k in &kernel {
|
|
assert!(k[2] >= 0.0, "kernel z must be >= 0 (hemisphere), got {}", k[2]);
|
|
let len = (k[0] * k[0] + k[1] * k[1] + k[2] * k[2]).sqrt();
|
|
assert!(len <= 1.01, "kernel sample must be within unit hemisphere, len={}", len);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_noise_data() {
|
|
let noise = generate_noise_data();
|
|
assert_eq!(noise.len(), 16);
|
|
for n in &noise {
|
|
assert!((n[2]).abs() < 1e-5, "noise z should be 0");
|
|
let len = (n[0] * n[0] + n[1] * n[1]).sqrt();
|
|
assert!((len - 1.0).abs() < 0.1, "noise vector should be roughly unit length, got {}", len);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_ssgi_uniform_default() {
|
|
let u = SsgiUniform::default();
|
|
assert!((u.radius - 0.5).abs() < 1e-5);
|
|
assert!((u.bias - 0.025).abs() < 1e-5);
|
|
}
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: lib.rs에 ssgi 모듈 등록**
|
|
|
|
```rust
|
|
pub mod ssgi;
|
|
pub use ssgi::{SsgiResources, SsgiUniform, SSGI_OUTPUT_FORMAT};
|
|
```
|
|
|
|
- [ ] **Step 3: 빌드 + 테스트**
|
|
|
|
Run: `cargo test -p voltex_renderer`
|
|
Expected: 기존 20 + 3 = 23 PASS
|
|
|
|
- [ ] **Step 4: 커밋**
|
|
|
|
```bash
|
|
git add crates/voltex_renderer/src/ssgi.rs crates/voltex_renderer/src/lib.rs
|
|
git commit -m "feat(renderer): add SSGI resources with hemisphere kernel and noise texture"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 2: SSGI 셰이더 + 파이프라인
|
|
|
|
**Files:**
|
|
- Create: `crates/voltex_renderer/src/ssgi_shader.wgsl`
|
|
- Modify: `crates/voltex_renderer/src/deferred_pipeline.rs`
|
|
|
|
- [ ] **Step 1: ssgi_shader.wgsl 작성**
|
|
|
|
```wgsl
|
|
// SSGI pass: screen-space ambient occlusion + color bleeding
|
|
// Reads G-Buffer position/normal/albedo, outputs AO + indirect color
|
|
|
|
// Group 0: G-Buffer (same layout as lighting pass)
|
|
@group(0) @binding(0) var t_position: texture_2d<f32>;
|
|
@group(0) @binding(1) var t_normal: texture_2d<f32>;
|
|
@group(0) @binding(2) var t_albedo: texture_2d<f32>;
|
|
@group(0) @binding(3) var s_gbuffer: sampler;
|
|
|
|
// Group 1: SSGI data
|
|
struct SsgiUniform {
|
|
projection: mat4x4<f32>,
|
|
view: mat4x4<f32>,
|
|
radius: f32,
|
|
bias: f32,
|
|
intensity: f32,
|
|
indirect_strength: f32,
|
|
};
|
|
|
|
struct SsgiKernel {
|
|
samples: array<vec4<f32>, 64>,
|
|
};
|
|
|
|
@group(1) @binding(0) var<uniform> ssgi: SsgiUniform;
|
|
@group(1) @binding(1) var<uniform> kernel: SsgiKernel;
|
|
@group(1) @binding(2) var t_noise: texture_2d<f32>;
|
|
@group(1) @binding(3) var s_noise: sampler;
|
|
|
|
struct VertexOutput {
|
|
@builtin(position) clip_position: vec4<f32>,
|
|
@location(0) uv: vec2<f32>,
|
|
};
|
|
|
|
@vertex
|
|
fn vs_main(@location(0) position: vec2<f32>) -> VertexOutput {
|
|
var out: VertexOutput;
|
|
out.clip_position = vec4<f32>(position, 0.0, 1.0);
|
|
out.uv = vec2<f32>(position.x * 0.5 + 0.5, 1.0 - (position.y * 0.5 + 0.5));
|
|
return out;
|
|
}
|
|
|
|
@fragment
|
|
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
|
|
let uv = in.uv;
|
|
|
|
let world_pos = textureSample(t_position, s_gbuffer, uv).xyz;
|
|
|
|
// Skip background
|
|
if dot(world_pos, world_pos) < 0.001 {
|
|
return vec4<f32>(1.0, 0.0, 0.0, 0.0); // AO=1 (no occlusion), indirect=0
|
|
}
|
|
|
|
let world_normal = normalize(textureSample(t_normal, s_gbuffer, uv).xyz * 2.0 - 1.0);
|
|
|
|
// Transform to view space
|
|
let view_pos = (ssgi.view * vec4<f32>(world_pos, 1.0)).xyz;
|
|
let view_normal = normalize((ssgi.view * vec4<f32>(world_normal, 0.0)).xyz);
|
|
|
|
// Random rotation from noise texture (4x4 tiling)
|
|
let tex_dims = textureDimensions(t_position);
|
|
let noise_scale = vec2<f32>(f32(tex_dims.x) / 4.0, f32(tex_dims.y) / 4.0);
|
|
let random_vec = textureSample(t_noise, s_noise, uv * noise_scale).xyz;
|
|
|
|
// Construct TBN in view space using Gram-Schmidt
|
|
let tangent = normalize(random_vec - view_normal * dot(random_vec, view_normal));
|
|
let bitangent = cross(view_normal, tangent);
|
|
let TBN = mat3x3<f32>(tangent, bitangent, view_normal);
|
|
|
|
var occlusion = 0.0;
|
|
var indirect = vec3<f32>(0.0);
|
|
|
|
for (var i = 0u; i < 64u; i++) {
|
|
// Sample position in view space
|
|
let sample_offset = TBN * kernel.samples[i].xyz;
|
|
let sample_view_pos = view_pos + sample_offset * ssgi.radius;
|
|
|
|
// Project to screen UV
|
|
let clip = ssgi.projection * vec4<f32>(sample_view_pos, 1.0);
|
|
var screen_uv = clip.xy / clip.w * 0.5 + 0.5;
|
|
screen_uv.y = 1.0 - screen_uv.y;
|
|
|
|
// Clamp to valid range
|
|
screen_uv = clamp(screen_uv, vec2<f32>(0.001), vec2<f32>(0.999));
|
|
|
|
// Read actual position at that screen location
|
|
let actual_world_pos = textureSample(t_position, s_gbuffer, screen_uv).xyz;
|
|
let actual_view_pos = (ssgi.view * vec4<f32>(actual_world_pos, 1.0)).xyz;
|
|
|
|
// Occlusion: is the actual geometry closer to camera than our sample?
|
|
let depth_diff = sample_view_pos.z - actual_view_pos.z;
|
|
let range_check = smoothstep(0.0, 1.0, ssgi.radius / (abs(view_pos.z - actual_view_pos.z) + 0.001));
|
|
|
|
if depth_diff > ssgi.bias && depth_diff < ssgi.radius {
|
|
occlusion += range_check;
|
|
// Color bleeding: sample albedo at occluder position
|
|
let sample_albedo = textureSample(t_albedo, s_gbuffer, screen_uv).rgb;
|
|
indirect += sample_albedo * range_check;
|
|
}
|
|
}
|
|
|
|
let ao = clamp(1.0 - (occlusion / 64.0) * ssgi.intensity, 0.0, 1.0);
|
|
indirect = indirect / 64.0 * ssgi.indirect_strength;
|
|
|
|
return vec4<f32>(ao, indirect);
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: deferred_pipeline.rs에 SSGI 파이프라인 함수 추가**
|
|
|
|
Add to deferred_pipeline.rs:
|
|
|
|
```rust
|
|
use crate::ssgi::SSGI_OUTPUT_FORMAT;
|
|
|
|
/// SSGI pass: reads G-Buffer (group 0) + SSGI data (group 1)
|
|
pub fn ssgi_gbuffer_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
|
|
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
|
label: Some("SSGI GBuffer BGL"),
|
|
entries: &[
|
|
// position (non-filterable)
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 0,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Texture {
|
|
sample_type: wgpu::TextureSampleType::Float { filterable: false },
|
|
view_dimension: wgpu::TextureViewDimension::D2,
|
|
multisampled: false,
|
|
},
|
|
count: None,
|
|
},
|
|
// normal (filterable)
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 1,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Texture {
|
|
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
|
view_dimension: wgpu::TextureViewDimension::D2,
|
|
multisampled: false,
|
|
},
|
|
count: None,
|
|
},
|
|
// albedo (filterable)
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 2,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Texture {
|
|
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
|
view_dimension: wgpu::TextureViewDimension::D2,
|
|
multisampled: false,
|
|
},
|
|
count: None,
|
|
},
|
|
// sampler (non-filtering for position)
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 3,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::NonFiltering),
|
|
count: None,
|
|
},
|
|
],
|
|
})
|
|
}
|
|
|
|
pub fn ssgi_data_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
|
|
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
|
label: Some("SSGI Data BGL"),
|
|
entries: &[
|
|
// SsgiUniform
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 0,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Buffer {
|
|
ty: wgpu::BufferBindingType::Uniform,
|
|
has_dynamic_offset: false,
|
|
min_binding_size: None,
|
|
},
|
|
count: None,
|
|
},
|
|
// kernel (uniform buffer, 64 * vec4 = 1024 bytes)
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 1,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Buffer {
|
|
ty: wgpu::BufferBindingType::Uniform,
|
|
has_dynamic_offset: false,
|
|
min_binding_size: None,
|
|
},
|
|
count: None,
|
|
},
|
|
// noise texture (non-filterable, Rgba32Float)
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 2,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Texture {
|
|
sample_type: wgpu::TextureSampleType::Float { filterable: false },
|
|
view_dimension: wgpu::TextureViewDimension::D2,
|
|
multisampled: false,
|
|
},
|
|
count: None,
|
|
},
|
|
// noise sampler
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 3,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::NonFiltering),
|
|
count: None,
|
|
},
|
|
],
|
|
})
|
|
}
|
|
|
|
pub fn create_ssgi_pipeline(
|
|
device: &wgpu::Device,
|
|
gbuffer_layout: &wgpu::BindGroupLayout,
|
|
data_layout: &wgpu::BindGroupLayout,
|
|
) -> wgpu::RenderPipeline {
|
|
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
|
label: Some("SSGI Shader"),
|
|
source: wgpu::ShaderSource::Wgsl(include_str!("ssgi_shader.wgsl").into()),
|
|
});
|
|
|
|
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
|
label: Some("SSGI Pipeline Layout"),
|
|
bind_group_layouts: &[gbuffer_layout, data_layout],
|
|
immediate_size: 0,
|
|
});
|
|
|
|
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
|
label: Some("SSGI Pipeline"),
|
|
layout: Some(&layout),
|
|
vertex: wgpu::VertexState {
|
|
module: &shader,
|
|
entry_point: Some("vs_main"),
|
|
buffers: &[FullscreenVertex::LAYOUT],
|
|
compilation_options: wgpu::PipelineCompilationOptions::default(),
|
|
},
|
|
fragment: Some(wgpu::FragmentState {
|
|
module: &shader,
|
|
entry_point: Some("fs_main"),
|
|
targets: &[Some(wgpu::ColorTargetState {
|
|
format: SSGI_OUTPUT_FORMAT,
|
|
blend: None,
|
|
write_mask: wgpu::ColorWrites::ALL,
|
|
})],
|
|
compilation_options: wgpu::PipelineCompilationOptions::default(),
|
|
}),
|
|
primitive: wgpu::PrimitiveState {
|
|
topology: wgpu::PrimitiveTopology::TriangleList,
|
|
..Default::default()
|
|
},
|
|
depth_stencil: None,
|
|
multisample: wgpu::MultisampleState::default(),
|
|
multiview_mask: None,
|
|
cache: None,
|
|
})
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 3: 빌드 확인**
|
|
|
|
Run: `cargo build -p voltex_renderer`
|
|
Expected: 컴파일 성공
|
|
|
|
- [ ] **Step 4: 커밋**
|
|
|
|
```bash
|
|
git add crates/voltex_renderer/src/ssgi_shader.wgsl crates/voltex_renderer/src/deferred_pipeline.rs
|
|
git commit -m "feat(renderer): add SSGI shader and pipeline for screen-space GI"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 3: Lighting Pass에 SSGI 통합
|
|
|
|
**Files:**
|
|
- Modify: `crates/voltex_renderer/src/deferred_lighting.wgsl`
|
|
- Modify: `crates/voltex_renderer/src/deferred_pipeline.rs`
|
|
|
|
- [ ] **Step 1: lighting_shadow_bind_group_layout에 SSGI binding 추가**
|
|
|
|
현재 `lighting_shadow_bind_group_layout`에 binding 0-4 (shadow+IBL). 여기에 추가:
|
|
|
|
```rust
|
|
// binding 5: SSGI output texture
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 5,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Texture {
|
|
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
|
view_dimension: wgpu::TextureViewDimension::D2,
|
|
multisampled: false,
|
|
},
|
|
count: None,
|
|
},
|
|
// binding 6: SSGI sampler
|
|
wgpu::BindGroupLayoutEntry {
|
|
binding: 6,
|
|
visibility: wgpu::ShaderStages::FRAGMENT,
|
|
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
|
|
count: None,
|
|
},
|
|
```
|
|
|
|
- [ ] **Step 2: deferred_lighting.wgsl에 SSGI 바인딩 + 적용 추가**
|
|
|
|
Group 2에 추가:
|
|
```wgsl
|
|
@group(2) @binding(5) var t_ssgi: texture_2d<f32>;
|
|
@group(2) @binding(6) var s_ssgi: sampler;
|
|
```
|
|
|
|
Fragment shader에서 ambient 계산 부분 변경:
|
|
```wgsl
|
|
// 기존: let ambient = (diffuse_ibl + specular_ibl) * ao;
|
|
// 변경:
|
|
let ssgi_data = textureSample(t_ssgi, s_ssgi, uv);
|
|
let ssgi_ao = ssgi_data.r;
|
|
let ssgi_indirect = ssgi_data.gba;
|
|
let ambient = (diffuse_ibl + specular_ibl) * ao * ssgi_ao + ssgi_indirect;
|
|
```
|
|
|
|
- [ ] **Step 3: 빌드 확인**
|
|
|
|
Run: `cargo build -p voltex_renderer`
|
|
Expected: 컴파일 성공
|
|
|
|
- [ ] **Step 4: 커밋**
|
|
|
|
```bash
|
|
git add crates/voltex_renderer/src/deferred_lighting.wgsl crates/voltex_renderer/src/deferred_pipeline.rs
|
|
git commit -m "feat(renderer): integrate SSGI output into deferred lighting pass"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 4: deferred_demo에 SSGI 패스 통합
|
|
|
|
**Files:**
|
|
- Modify: `examples/deferred_demo/src/main.rs`
|
|
|
|
NOTE: 이 태스크는 기존 deferred_demo를 확장하여 3-pass 렌더링으로 변경합니다.
|
|
|
|
변경사항:
|
|
1. `SsgiResources::new()` 호출하여 SSGI 리소스 생성
|
|
2. SSGI 파이프라인 + 바인드 그룹 레이아웃 생성
|
|
3. SSGI 바인드 그룹 2개 생성 (G-Buffer + SSGI data)
|
|
4. 기존 Shadow+IBL 바인드 그룹에 SSGI output texture + sampler 추가 (binding 5,6)
|
|
5. 렌더 루프에 SSGI 패스 삽입 (Pass 2: SSGI, 기존 Lighting은 Pass 3으로)
|
|
6. 매 프레임 SsgiUniform 업데이트 (view, projection 행렬)
|
|
7. 리사이즈 시 SSGI 리소스 + 바인드 그룹 재생성
|
|
|
|
이 태스크는 deferred_demo의 전체 구조를 이해해야 하므로 opus 모델로 실행.
|
|
|
|
- [ ] **Step 1: deferred_demo 수정**
|
|
|
|
Read the current `examples/deferred_demo/src/main.rs` first, then add SSGI integration.
|
|
|
|
- [ ] **Step 2: 빌드 확인**
|
|
|
|
Run: `cargo build --bin deferred_demo`
|
|
Expected: 컴파일 성공
|
|
|
|
- [ ] **Step 3: 커밋**
|
|
|
|
```bash
|
|
git add examples/deferred_demo/src/main.rs
|
|
git commit -m "feat(renderer): add SSGI pass to deferred_demo (AO + color bleeding)"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 5: 문서 업데이트
|
|
|
|
**Files:**
|
|
- Modify: `docs/STATUS.md`
|
|
- Modify: `docs/DEFERRED.md`
|
|
|
|
- [ ] **Step 1: STATUS.md에 Phase 7-2 추가**
|
|
|
|
Phase 7-1 아래에:
|
|
```markdown
|
|
### Phase 7-2: SSGI (Screen-Space Global Illumination)
|
|
- voltex_renderer: SsgiResources (hemisphere kernel, 4x4 noise, output texture)
|
|
- voltex_renderer: SSGI shader (SSAO + color bleeding in one pass)
|
|
- voltex_renderer: SSGI pipeline + bind group layouts
|
|
- voltex_renderer: Lighting pass SSGI integration (ambient * ssgi_ao + indirect)
|
|
- deferred_demo updated with 3-pass rendering (GBuffer → SSGI → Lighting)
|
|
```
|
|
|
|
테스트 수 업데이트 (voltex_renderer: 23).
|
|
|
|
- [ ] **Step 2: DEFERRED.md에 Phase 7-2 미뤄진 항목**
|
|
|
|
```markdown
|
|
## Phase 7-2
|
|
|
|
- **Bilateral Blur** — SSGI 노이즈 제거 블러 미구현. 4x4 노이즈 타일링만.
|
|
- **반해상도 렌더링** — 풀 해상도에서 SSGI 실행. 성능 최적화 미적용.
|
|
- **Temporal Accumulation** — 프레임 간 누적 미구현. 매 프레임 독립 계산.
|
|
- **Light Probes** — 베이크 기반 GI 미구현.
|
|
```
|
|
|
|
- [ ] **Step 3: 커밋**
|
|
|
|
```bash
|
|
git add docs/STATUS.md docs/DEFERRED.md
|
|
git commit -m "docs: add Phase 7-2 SSGI status and deferred items"
|
|
```
|