2nd/10_Wiki/Topics/AI_and_ML/렌더링 파이프라인(Rendering Pipeline).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-렌더링-파이프라인-rendering-pipeline	렌더링 파이프라인(Rendering Pipeline)	10_Wiki/Topics	verified	self	Rendering Pipeline Graphics Pipeline GPU Pipeline	none	A	0.9	applied	graphics gpu rendering real-time		2026-05-10	pending	language framework glsl/wgsl Vulkan / DirectX 12 / WebGPU

렌더링 파이프라인(Rendering Pipeline)

매 한 줄

"매 vertex → fragment → screen pixel로 변환하는 GPU의 stage chain". 1990s fixed-function OpenGL에서 시작 → programmable shaders (GeForce 3, 2001) → modern compute-driven pipeline (mesh shaders, DX12 Ultimate)으로 evolve. 2026 현재 Vulkan 1.4 · DirectX 12 Ultimate · WebGPU가 cross-platform standard, ray-traced GI + neural rendering (DLSS 4, FSR 4)이 default.

매 핵심

매 Classic Pipeline (Stages)

• Input Assembly (IA): 매 vertex buffer + index buffer → primitive.
• Vertex Shader (VS): 매 per-vertex transform (world → view → clip).
• Tessellation / Geometry: 매 optional — adaptive subdivision, particle expansion.
• Rasterization: 매 primitive → fragments (interpolated).
• Fragment / Pixel Shader (FS): 매 per-pixel shading (PBR, lighting).
• Output Merger: 매 depth/stencil test + blend → framebuffer.

매 Modern Compute-Driven

• Mesh Shaders (DX12 Ultimate, Vulkan): 매 IA + VS + Geom 대체, GPU-driven culling.
• Ray Tracing: 매 RT cores → BVH traversal → shadow / GI / reflection.
• Variable Rate Shading (VRS): 매 영역별 shading rate 조절.
• Neural Upscaling: 매 DLSS 4 / FSR 4 / XeSS 2 — render at 1/4 res, upsample to 4K.

매 응용

1. Unreal Engine 5 Nanite — virtualized geometry, mesh-shader based.
2. Unity HDRP — render graph, customizable per-frame.
3. WebGPU (Chrome 120+) — browser-native compute + render.
4. Godot 4.4 — Vulkan-first, mobile-aware forward+ renderer.

💻 패턴

WebGPU Render Pipeline Setup

const pipeline = device.createRenderPipeline({
  layout: 'auto',
  vertex: {
    module: device.createShaderModule({ code: vsWGSL }),
    entryPoint: 'main',
    buffers: [{
      arrayStride: 32,
      attributes: [
        { shaderLocation: 0, offset: 0, format: 'float32x3' },  // pos
        { shaderLocation: 1, offset: 12, format: 'float32x3' }, // normal
        { shaderLocation: 2, offset: 24, format: 'float32x2' }, // uv
      ],
    }],
  },
  fragment: {
    module: device.createShaderModule({ code: fsWGSL }),
    entryPoint: 'main',
    targets: [{ format: 'bgra8unorm' }],
  },
  primitive: { topology: 'triangle-list', cullMode: 'back' },
  depthStencil: { format: 'depth24plus', depthWriteEnabled: true, depthCompare: 'less' },
});

Forward+ Tiled Light Culling (WGSL compute)

@group(0) @binding(0) var<storage, read> lights: array<Light>;
@group(0) @binding(1) var<storage, read_write> tile_lights: array<u32>;
@group(0) @binding(2) var depth_tex: texture_depth_2d;

@compute @workgroup_size(16, 16)
fn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {
  let tile = gid.xy / 16u;
  let frustum = build_tile_frustum(tile, depth_tex);
  var idx: u32 = 0u;
  for (var i = 0u; i < arrayLength(&lights); i = i + 1u) {
    if (sphere_in_frustum(lights[i].pos_radius, frustum)) {
      tile_lights[tile_offset(tile) + idx] = i;
      idx = idx + 1u;
    }
  }
}

Vulkan Command Buffer

VkCommandBufferBeginInfo begin{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
vkBeginCommandBuffer(cmd, &begin);

VkRenderingAttachmentInfo color{};
color.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
color.imageView = swapchainView;
color.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
color.clearValue = {.color = {{0, 0, 0, 1}}};

VkRenderingInfo info{VK_STRUCTURE_TYPE_RENDERING_INFO};
info.renderArea = {{0, 0}, extent};
info.layerCount = 1;
info.colorAttachmentCount = 1;
info.pColorAttachments = &color;

vkCmdBeginRendering(cmd, &info);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
vkCmdDraw(cmd, 3, 1, 0, 0);
vkCmdEndRendering(cmd);
vkEndCommandBuffer(cmd);

PBR Fragment Shader (WGSL)

fn fresnel_schlick(cos_theta: f32, F0: vec3<f32>) -> vec3<f32> {
  return F0 + (vec3(1.0) - F0) * pow(1.0 - cos_theta, 5.0);
}

fn distribution_ggx(N: vec3<f32>, H: vec3<f32>, roughness: f32) -> f32 {
  let a = roughness * roughness;
  let a2 = a * a;
  let NdotH = max(dot(N, H), 0.0);
  let denom = (NdotH * NdotH * (a2 - 1.0) + 1.0);
  return a2 / (3.14159 * denom * denom);
}

@fragment
fn fs_main(in: VsOut) -> @location(0) vec4<f32> {
  let N = normalize(in.normal);
  let V = normalize(camera_pos - in.world_pos);
  let L = normalize(light_pos - in.world_pos);
  let H = normalize(V + L);

  let F0 = mix(vec3(0.04), albedo, metallic);
  let F = fresnel_schlick(max(dot(H, V), 0.0), F0);
  let D = distribution_ggx(N, H, roughness);
  let G = geometry_smith(N, V, L, roughness);

  let specular = (D * G * F) / (4.0 * max(dot(N, V), 0.001) * max(dot(N, L), 0.001));
  let kD = (vec3(1.0) - F) * (1.0 - metallic);
  let diffuse = kD * albedo / 3.14159;
  let radiance = light_color * max(dot(N, L), 0.0);
  return vec4((diffuse + specular) * radiance, 1.0);
}

Render Graph (UE5-style)

auto& depth = graph.create_texture("Depth", {1920, 1080, VK_FORMAT_D32_SFLOAT});
auto& gbuffer = graph.create_texture("GBuffer", {1920, 1080, VK_FORMAT_R16G16B16A16_SFLOAT});

graph.add_pass("GBuffer", [&](PassBuilder& b) {
    b.write(gbuffer); b.write(depth);
    return [=](CommandBuffer& cmd) { draw_opaque(cmd); };
});

graph.add_pass("Lighting", [&](PassBuilder& b) {
    b.read(gbuffer); b.read(depth); b.write(swapchain);
    return [=](CommandBuffer& cmd) { fullscreen_pass(cmd, lighting_pso); };
});

graph.compile_and_execute(cmd);

매 결정 기준

상황	Approach
Cross-platform (incl. web)	WebGPU
AAA PC / console	Vulkan / DX12 with mesh shaders
Mobile-first	OpenGL ES 3.2 / Vulkan Mobile
Real-time RT	DXR 1.1 / Vulkan KHR_ray_tracing
Indie / prototype	Unity URP / Godot Forward+

기본값: Vulkan 1.3+ render-graph + forward+ tile-based + DLSS/FSR upscale.

🔗 Graph

• 부모: Computer_Graphics · GPU Architecture
• 변형: Deferred_Rendering
• 응용: WebGPU

🤖 LLM 활용

언제: shader template generation, render-graph pass scaffolding, debug-message interpretation. 언제 X: 매 perf-critical inner loop optimization — RenderDoc / NSight profiler가 ground truth.

❌ 안티패턴

• Immediate-mode draw calls: 매 draw call 수천 → CPU bottleneck (use indirect draws).
• Stalls on map/unmap: 매 GPU upload 동기화 → frame hitch (use staging + double buffer).
• No depth pre-pass: 매 expensive overdraw on dense scenes.
• Heavy fragment for far objects: 매 mip / LOD 무시.

🧪 검증 / 중복

• Verified (Vulkan 1.4 spec, "Real-Time Rendering 4th ed", DigitalFoundry 2025 analyses).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — graphics pipeline stages + modern compute-driven + WebGPU/Vulkan code 정리