// RenderCore/Private/RenderGraphBuilder.cpp:1751
void FRDGBuilder::Execute()
{
    // 1. Compile: 의존성 그래프 구성
    //    - 각 Pass가 어떤 리소스를 읽고/쓰는지 분석
    //    - 배리어 위치 결정
    //    - Async compute 영역 식별

    // 2. Cull: 불필요한 패스 제거
    //    - 최종 출력(QueueTextureExtraction)에 기여하지 않는 패스 제거
    //    - 경고 메시지 출력

    // 3. Allocate: 리소스 할당
    //    - Transient 리소스 풀에서 할당
    //    - Aliasing 기회 탐색 (동시에 사용되지 않는 리소스끼리 메모리 공유)

    // 4. Execute: 패스 실행
    //    - ExecutePass() 호출
    //    - 병렬 실행 가능한 패스는 task로 dispatch
}

// RenderCore/Private/RenderGraphBuilder.cpp:3448-3461
void FRDGBuilder::ExecutePass(FRHIComputeCommandList& RHICmdListPass, FRDGPass* Pass)
{
    SCOPED_GPU_MASK(RHICmdListPass, Pass->GPUMask);

    ExecutePassPrologue(RHICmdListPass, Pass);  // 배리어 시작

    Pass->Execute(RHICmdListPass);              // 람다 실행

    ExecutePassEpilogue(RHICmdListPass, Pass);  // 배리어 종료, 렌더패스 종료
}

// RenderCore/Private/RenderGraphBuilder.cpp:3361-3392
void FRDGBuilder::ExecutePassPrologue(FRHIComputeCommandList& RHICmdListPass, FRDGPass* Pass)
{
    const ERDGPassFlags PassFlags = Pass->Flags;
    const ERHIPipeline PassPipeline = Pass->Pipeline;

    // 1. 배리어 시작 (PrologueBarriersToBegin)
    if (Pass->PrologueBarriersToBegin)
    {
        Pass->PrologueBarriersToBegin->Submit(RHICmdListPass, PassPipeline);
    }

    if (Pass->PrologueBarriersToEnd)
    {
        Pass->PrologueBarriersToEnd->Submit(RHICmdListPass, PassPipeline);
    }

    // 2. RenderPass 시작 (Raster 패스인 경우)
    if (EnumHasAnyFlags(PassFlags, ERDGPassFlags::Raster))
    {
        if (!EnumHasAnyFlags(PassFlags, ERDGPassFlags::SkipRenderPass) && !Pass->SkipRenderPassBegin())
        {
            static_cast<FRHICommandList&>(RHICmdListPass).BeginRenderPass(Pass->GetParameters().GetRenderPassInfo(), Pass->GetName());
        }
    }

    // 3. UAV Overlap 시작 (validation)
    BeginUAVOverlap(Pass, RHICmdListPass);
}

// RenderCore/Private/RenderGraphBuilder.cpp:3394-3446
void FRDGBuilder::ExecutePassEpilogue(FRHIComputeCommandList& RHICmdListPass, FRDGPass* Pass)
{
    // 1. UAV Overlap 종료
	EndUAVOverlap(Pass, RHICmdListPass);

	const ERDGPassFlags PassFlags = Pass->Flags;
	const ERHIPipeline PassPipeline = Pass->Pipeline;
	const FRDGParameterStruct PassParameters = Pass->GetParameters();

    // 2. RenderPass 종료 (Raster 패스인 경우)
	if (EnumHasAnyFlags(PassFlags, ERDGPassFlags::Raster) && !EnumHasAnyFlags(PassFlags, ERDGPassFlags::SkipRenderPass) && !Pass->SkipRenderPassEnd())
	{
        static_cast<FRHICommandList&>(RHICmdListPass).EndRenderPass();
	}

	FRDGTransitionQueue Transitions;

	if (Pass->EpilogueBarriersToBeginForGraphics)
	{
        Pass->EpilogueBarriersToBeginForGraphics->Submit(RHICmdListPass, PassPipeline, Transitions);
	}

	if (Pass->EpilogueBarriersToBeginForAsyncCompute)
	{
        Pass->EpilogueBarriersToBeginForAsyncCompute->Submit(RHICmdListPass, PassPipeline, Transitions);
	}

	if (Pass->EpilogueBarriersToBeginForAll)
	{
        Pass->EpilogueBarriersToBeginForAll->Submit(RHICmdListPass, PassPipeline, Transitions);
	}

	for (FRDGBarrierBatchBegin* BarriersToBegin : Pass->SharedEpilogueBarriersToBegin)
	{
        BarriersToBegin->Submit(RHICmdListPass, PassPipeline, Transitions);
	}

	if (!Transitions.IsEmpty())
	{
        RHICmdListPass.BeginTransitions(Transitions);
	}

    // 3. 배리어 종료 (EpilogueBarriersToEnd)
	if (Pass->EpilogueBarriersToEnd)
	{
		Pass->EpilogueBarriersToEnd->Submit(RHICmdListPass, PassPipeline);
	}
}

// RenderGraphPass.h:107-168
class FRDGBarrierBatchBegin
{
public:
    void AddTransition(FRDGViewableResource* Resource, FRDGTransitionInfo Info);
    void AddAlias(FRDGViewableResource* Resource, const FRHITransientAliasingInfo& Info);

    void CreateTransition(TConstArrayView<FRHITransitionInfo> TransitionsRHI);
    void Submit(FRHIComputeCommandList& RHICmdList, ERHIPipeline Pipeline);

private:
    const FRHITransition* Transition;  // Batch된 전환
    TArray<FRDGTransitionInfo, FRDGArrayAllocator> Transitions;
    ERHIPipeline PipelinesToBegin;
    ERHIPipeline PipelinesToEnd;
};

// Graphics → AsyncCompute 전환
// 10개의 텍스처와 5개의 버퍼가 함께 전환되는 경우

// Native RHI: 15번의 개별 배리어
for (Texture : Textures)
    RHICmdList.Transition(Texture, OldAccess, NewAccess);

// RDG: 1번의 batch 배리어
Batch.AddTransition(Texture1, ...);
Batch.AddTransition(Texture2, ...);
// ... (15개 추가)
Batch.Submit(RHICmdList);  // 한 번에 제출

// RenderGraphPass.h:57-83
struct FRDGTransitionInfo
{
    // 64-bit packed structure
    uint64 AccessBefore            : 21;  // ERHIAccess (Before)
    uint64 AccessAfter             : 21;  // ERHIAccess (After)
    uint64 ResourceHandle          : 16;  // Resource index
    uint64 ResourceType            : 3;   // Texture/Buffer
    uint64 ResourceTransitionFlags : 3;   // Flags

    union {
        struct { uint16 ArraySlice; uint8 MipIndex; uint8 PlaneSlice; } Texture;
        struct { uint64 CommitSize; } Buffer;
    };
};

// MeshDrawCommands.h:130-146
void FParallelMeshDrawCommandPass::DispatchPassSetup(
    FScene* Scene,
    const FViewInfo& View,
    FInstanceCullingContext &&InstanceCullingContext,
    EMeshPass::Type PassType,  // BasePass, DepthPass, ShadowDepth...
    FMeshPassProcessor* MeshPassProcessor,
    const TArray<FMeshBatchAndRelevance, SceneRenderingAllocator>& DynamicMeshElements,
    int32 NumDynamicMeshElements,
    FMeshCommandOneFrameArray& InOutMeshDrawCommands
)
{
    // Task 생성 → 백그라운드 스레드에서 실행
    // - MeshPassProcessor->AddMeshBatch() 호출
    // - 각 Mesh마다 draw command 생성
    // - Sorting, Merging, Instancing
}

// MeshDrawCommands.h:54-109
class FMeshDrawCommandPassSetupTaskContext
{
    // Input
    const FViewInfo* View;
    const FScene* Scene;
    EMeshPass::Type PassType;
    FMeshPassProcessor* MeshPassProcessor;
    const TArray<FMeshBatchAndRelevance>* DynamicMeshElements;

    // Output
    FMeshCommandOneFrameArray MeshDrawCommands;         // 생성된 draw commands
    FInstanceCullingContext InstanceCullingContext;     // GPU culling 데이터
    int32 VisibleMeshDrawCommandsNum;                   // 통계
};

// Renderer/Private/MeshDrawCommands.h
void FParallelMeshDrawCommandPass::BuildRenderingCommands(
    FRDGBuilder& GraphBuilder,
    const FGPUScene& GPUScene,
    FInstanceCullingDrawParams& OutInstanceCullingDrawParams
)
{
    // 1. Setup Task 대기
    WaitForSetupTask();

    // 2. GPU에서 Instance Culling 실행 (Compute Shader - BuildInstanceDrawCommands.usf)
    //    - Frustum culling
    //    - Occlusion culling (HZB)
    //    - Draw command compaction

    // 3. Instance ID 리스트 생성
    //    - Visible instance IDs를 GPU 버퍼에 기록
    //    - Indirect draw arguments 생성
}

// Renderer/Private/MeshDrawCommands.h
void FParallelMeshDrawCommandPass::Draw(
    FRHICommandList& RHICmdList,
    const FInstanceCullingDrawParams* InstanceCullingDrawParams
) const
{
    // For each MeshDrawCommand:
    //   1. Bind PSO (Pipeline State Object)
    //   2. Bind Shader Bindings (Textures, Buffers, Constants)
    //   3. Set Vertex/Index Buffers
    //   4. DrawIndexedPrimitive() or ExecuteIndirect()
}

// Renderer/Private/MeshDrawCommands.h
void Dispatch(
    FRDGDispatchPassBuilder& DispatchPassBuilder,  // RDG parallel task builder
    const FInstanceCullingDrawParams* InstanceCullingDrawParams,
    float ViewportScale = 1.0f
) const;

// Renderer/Private/MeshDrawCommands.h
class FPrimitiveIdVertexBufferPool : public FRenderResource
{
    FPrimitiveIdVertexBufferPoolEntry Allocate(FRHICommandList& RHICmdList, int32 BufferSize);
    void ReturnToFreeList(FPrimitiveIdVertexBufferPoolEntry Entry);
    void DiscardAll();  // 매 프레임 호출

private:
    uint32 DiscardId;
    TArray<FPrimitiveIdVertexBufferPoolEntry> Entries;
};

extern TGlobalResource<FPrimitiveIdVertexBufferPool> GPrimitiveIdVertexBufferPool;

// 1. Setup Task에서 크기 계산
int32 PrimitiveIdBufferSize = NumInstances * sizeof(uint32);

// 2. 버퍼 할당
FPrimitiveIdVertexBufferPoolEntry Entry =
    GPrimitiveIdVertexBufferPool.Allocate(RHICmdList, PrimitiveIdBufferSize);

// 3. Instance ID 기록 (GPU 또는 CPU)
// 4. Vertex Buffer로 바인딩
// 5. 프레임 끝에 반환
GPrimitiveIdVertexBufferPool.ReturnToFreeList(Entry);

// Engine/Source/Runtime/Renderer/Private/SceneVisibility.cpp
// ComputeViewVisibility() 호출 전 PreVisibilityFrameSetup()에서 초기화

// 1단계: Distance Culling - 카메라 거리 기반 조기 제외
// 2단계: Frustum Culling - View Frustum 밖의 오브젝트 제외
// 3단계: Occlusion Culling - 다른 오브젝트에 가려진 오브젝트 제외
// 4단계: Relevance 계산 - 각 View에 대한 Primitive의 렌더링 관련성 판단

// Engine/Source/Runtime/Renderer/Private/SceneVisibility.cpp:773
static int32 FrustumCull(
    const FScene& Scene,
    FViewInfo& View,
    FFrustumCullingFlags Flags,
    float MaxDrawDistanceScale,
    const FHLODVisibilityState* const HLODState,
    const FSceneBitArray* VisibleNodes,
    const FVisibilityTaskConfig& TaskConfig,
    int32 TaskIndex)
{
    // Task 기반 병렬 처리를 위한 Word 단위 순회
    const int32 TaskWordOffset = TaskIndex * TaskConfig.FrustumCull.NumWordsPerTask;

    for (int32 WordIndex = TaskWordOffset;
         WordIndex < TaskWordOffset + TaskConfig.FrustumCull.NumWordsPerTask;
         WordIndex++)
    {
        uint32 Mask = 0x1;
        uint32 VisBits = 0;

        for (int32 BitSubIndex = 0; BitSubIndex < NumBitsPerDWORD; BitSubIndex++, Mask <<= 1)
        {
            int32 Index = WordIndex * NumBitsPerDWORD + BitSubIndex;

            // Hidden 플래그 체크
            bool bPrimitiveIsHidden = IsPrimitiveHidden(Scene, View, Index, Flags);
            bool bIsVisible = !bPrimitiveIsHidden;

            // Bounding Sphere 유효성 검사
            const FPrimitiveBounds& Bounds = Scene.PrimitiveBounds[Index];
            bIsVisible &= Bounds.BoxSphereBounds.SphereRadius > 0;

            // HLOD 강제 가시성/숨김 처리
            if (HLODState)
            {
                if (HLODState->IsNodeForcedVisible(Index))
                    bShouldDistanceCull = false;
                else if (HLODState->IsNodeForcedHidden(Index))
                    bIsVisible = false;
            }

            // Octree 기반 계층적 컬링 (활성화된 경우)
            if (Flags.bUseVisibilityOctree)
            {
                uint32 OctreeNodeIndex = Scene.PrimitiveOctreeIndex[Index];
                bIsVisible = (*VisibleNodes)[OctreeNodeIndex * 2];
                bPartiallyOutside = (*VisibleNodes)[OctreeNodeIndex * 2 + 1];
            }

            // Fast Intersect: SIMD 8-Plane 테스트
            if (bIsVisible && Flags.bUseFastIntersect)
            {
                bIsVisible = IntersectBox8Plane(
                    Bounds.BoxSphereBounds.Origin,
                    Bounds.BoxSphereBounds.BoxExtent,
                    PermutedPlanePtr);
            }

            // Distance Culling
            if (bIsVisible && bShouldDistanceCull)
            {
                bIsVisible = !IsDistanceCulled(...);
            }
        }
    }
}

// r.Visibility.FrustumCull.Enabled: Frustum Culling 활성화
// r.Visibility.FrustumCull.UseOctree: Octree 기반 계층적 컬링
// r.Visibility.FrustumCull.UseSphereTestFirst: Sphere 테스트 우선 실행
// r.Visibility.FrustumCull.UseFastIntersect: SIMD 8-Plane 최적화 사용
// r.Visibility.FrustumCull.NumPrimitivesPerTask: Task당 Primitive 수

// Engine/Source/Runtime/Renderer/Private/SceneVisibility.cpp:527
inline bool IntersectBox8Plane(const FVector& InOrigin, const FVector& InExtent, const FPlane* PermutedPlanePtr)
{
    // SIMD 레지스터에 Origin/Extent 로드
    const VectorRegister Origin = VectorLoadFloat3(&InOrigin);
    const VectorRegister Extent = VectorLoadFloat3(&InExtent);

    // 첫 4개 Plane (Near, Far, Left, Right)
    const VectorRegister PlanesX_0 = VectorLoadAligned(&PermutedPlanePtr[0]);
    const VectorRegister PlanesY_0 = VectorLoadAligned(&PermutedPlanePtr[1]);
    const VectorRegister PlanesZ_0 = VectorLoadAligned(&PermutedPlanePtr[2]);
    const VectorRegister PlanesW_0 = VectorLoadAligned(&PermutedPlanePtr[3]);

    // 나머지 4개 Plane (Top, Bottom + 2 패딩)
    const VectorRegister PlanesX_1 = VectorLoadAligned(&PermutedPlanePtr[4]);
    const VectorRegister PlanesY_1 = VectorLoadAligned(&PermutedPlanePtr[5]);
    const VectorRegister PlanesZ_1 = VectorLoadAligned(&PermutedPlanePtr[6]);
    const VectorRegister PlanesW_1 = VectorLoadAligned(&PermutedPlanePtr[7]);

    // Distance 계산: dot(Origin, PlaneNormal) - PlaneW
    VectorRegister Distance_0 = VectorSubtract(
        VectorMultiplyAdd(OrigZ, PlanesZ_0,
            VectorMultiplyAdd(OrigY, PlanesY_0,
                VectorMultiply(OrigX, PlanesX_0))),
        PlanesW_0);

    // Push-out 거리: abs(Extent.x * PlaneNormal.x) + abs(Extent.y * PlaneNormal.y) + ...
    VectorRegister PushOut_0 = VectorMultiplyAdd(AbsExtentZ, VectorAbs(PlanesZ_0),
        VectorMultiplyAdd(AbsExtentY, VectorAbs(PlanesY_0),
            VectorMultiply(AbsExtentX, VectorAbs(PlanesX_0))));

    // Distance > PushOut이면 완전히 바깥 → false 반환
    if (VectorAnyGreaterThan(Distance_0, PushOut_0))
        return false;

    // 두 번째 4개 Plane에 대해 동일한 테스트
    // ...
    return true;
}

// Engine/Source/Runtime/Renderer/Private/SceneOcclusion.cpp
static void BeginOcclusionTests(
    FRHICommandList& RHICmdList,
    FViewInfo& View,
    const FViewOcclusionQueries& ViewQuery,
    ERHIFeatureLevel::Type FeatureLevel,
    uint32 DownsampleFactor,
    FGraphicsPipelineStateInitializer* InGraphicsPSOInit = nullptr)
{
    // 1. HZB Mip-chain 구성
    //    - Mip 0: 전체 해상도 Depth
    //    - Mip N: 2^N 다운샘플링, 각 텍셀은 해당 영역의 최대(또는 최소) 깊이

    // 2. Occlusion Query 배치
    //    - 각 오브젝트의 Bounding Box를 해당 Mip 레벨에서 샘플링
    //    - Coarse Mip에서 먼저 테스트 → 실패 시 Fine Mip으로 진행

    // 3. Query 결과 활용
    //    - GPU에서 비동기로 결과 생성
    //    - 다음 프레임에서 결과 읽기 (1프레임 지연)
}

// Engine/Source/Runtime/Renderer/Private/InstanceCulling/InstanceCullingManager.cpp
void FInstanceCullingManager::BeginDeferredCulling(FRDGBuilder& GraphBuilder)
{
    // GPU Compute Shader 기반 Culling
    // 1. Frustum Culling - GPU에서 병렬 처리
    // 2. Occlusion Culling - HZB 텍스처 샘플링
    // 3. Distance Culling - 인스턴스별 거리 계산
    // 4. Draw Command Compaction - 가시 인스턴스만 Indirect Draw Buffer에 기록
}

// Engine/Source/Runtime/Renderer/Private/DepthRendering.cpp:525
void FDeferredShadingSceneRenderer::RenderPrePass(
    FRDGBuilder& GraphBuilder,
    TArrayView<FViewInfo> InViews,
    FRDGTextureRef SceneDepthTexture,
    FInstanceCullingManager& InstanceCullingManager,
    FRDGTextureRef* FirstStageDepthBuffer)
{
    RDG_EVENT_SCOPE_STAT(GraphBuilder, Prepass, "PrePass %s %s",
        GetDepthDrawingModeString(DepthPass.EarlyZPassMode),
        GetDepthPassReason(DepthPass.bDitheredLODTransitionsUseStencil, ShaderPlatform));

    const bool bParallelDepthPass = GRHICommandList.UseParallelAlgorithms() &&
                                    CVarParallelPrePass.GetValueOnRenderThread();

    // HMD 전용 Prepass (VR)
    RenderPrePassHMD(GraphBuilder, InViews, SceneDepthTexture);

    // Dithered LOD Transition을 위한 Stencil 초기화
    if (DepthPass.IsRasterStencilDitherEnabled())
    {
        AddDitheredStencilFillPass(GraphBuilder, InViews, SceneDepthTexture, DepthPass);
    }

    // Primary Depth Pass 렌더링
    if (DepthPass.EarlyZPassMode != DDM_None)
    {
        RenderDepthPass(EMeshPass::DepthPass);
    }

    // Secondary Depth Pass (WPO, Dithered LOD 등을 위한 2단계 깊이)
    if (bUsesSecondStageDepthPass)
    {
        // 1단계 깊이 복사
        *FirstStageDepthBuffer = GraphBuilder.CreateTexture(..., TEXT("FirstStageDepthBuffer"));
        DepthCopy::AddViewDepthCopyPSPass(GraphBuilder, View, SceneDepthTexture, *FirstStageDepthBuffer);

        // 2단계 깊이 렌더링
        RenderDepthPass(EMeshPass::SecondStageDepthPass);
    }
}

// Engine/Source/Runtime/Renderer/Private/DepthRendering.cpp:548
auto RenderDepthPass = [&](uint8 DepthMeshPass)
{
    if (bParallelDepthPass)
    {
        for (int32 ViewIndex = 0; ViewIndex < InViews.Num(); ++ViewIndex)
        {
            FViewInfo& View = InViews[ViewIndex];
            View.BeginRenderView();

            FDepthPassParameters* PassParameters = GetDepthPassParameters(GraphBuilder, View, SceneDepthTexture);

            if (auto* Pass = View.ParallelMeshDrawCommandPasses[DepthMeshPass])
            {
                // GPU Scene에서 Instance Culling 데이터 빌드
                Pass->BuildRenderingCommands(GraphBuilder, Scene->GPUScene, PassParameters->InstanceCullingDrawParams);

                // Parallel Dispatch: 여러 Worker Thread에서 Draw Command 인코딩
                GraphBuilder.AddDispatchPass(
                    RDG_EVENT_NAME("DepthPassParallel"),
                    PassParameters,
                    ERDGPassFlags::Raster,
                    [Pass, PassParameters](FRDGDispatchPassBuilder& DispatchPassBuilder)
                    {
                        Pass->Dispatch(DispatchPassBuilder, &PassParameters->InstanceCullingDrawParams);
                    });
            }
        }
    }
    else
    {
        // Non-parallel: 단일 스레드 렌더링
        GraphBuilder.AddPass(
            RDG_EVENT_NAME("DepthPass"),
            PassParameters,
            ERDGPassFlags::Raster,
            [&View, Pass, PassParameters](FRDGAsyncTask, FRHICommandList& RHICmdList)
            {
                SetStereoViewport(RHICmdList, View, 1.0f);
                Pass->Draw(RHICmdList, &PassParameters->InstanceCullingDrawParams);
            });
    }
};

// Engine/Source/Runtime/Renderer/Public/DepthRendering.h
enum EDepthDrawingMode
{
    DDM_None,            // Depth Prepass 비활성화
    DDM_NonMaskedOnly,   // Masked 머티리얼 제외 (Alpha Test 없는 오브젝트만)
    DDM_AllOccluders,    // 모든 Occluder (bUseAsOccluder=true인 오브젝트)
    DDM_AllOpaque,       // 모든 불투명 오브젝트
};

// Engine/Source/Runtime/Renderer/Private/DepthRendering.cpp
EDepthDrawingMode EarlyZPassMode = DDM_None;

// Forward Shading: Depth만 먼저 그려야 라이팅 계산 전에 Z-test 가능
if (bForwardShading)
    EarlyZPassMode = DDM_AllOpaque;

// Deferred Shading: 씬 복잡도에 따라 결정
else if (bDeferredShading)
{
    // Nanite 활성화 시: Nanite가 자체 depth 생성하므로 Non-Nanite만 처리
    if (bNaniteEnabled)
        EarlyZPassMode = DDM_NonMaskedOnly;

    // 복잡한 씬: 모든 Occluder 렌더링
    else if (NumOccluders > OccluderThreshold)
        EarlyZPassMode = DDM_AllOccluders;

    // 단순한 씬: Overdraw가 적으므로 Prepass 스킵 가능
    else
        EarlyZPassMode = DDM_None;
}

// Engine/Source/Runtime/Renderer/Private/DepthRendering.cpp
void SetupDepthPassState(FMeshPassProcessorRenderState& DrawRenderState)
{
    // Depth Write 활성화, Color Write 비활성화
    DrawRenderState.SetBlendState(TStaticBlendStateWriteMask<CW_NONE>::GetRHI());

    // Depth Test: Less or Equal (기존 깊이보다 가깝거나 같으면 통과)
    DrawRenderState.SetDepthStencilState(
        TStaticDepthStencilState<true, CF_DepthNearOrEqual>::GetRHI());
}

// Engine/Source/Runtime/Renderer/Private/BasePassRendering.cpp:1071
void FDeferredShadingSceneRenderer::RenderBasePass(
    FDeferredShadingSceneRenderer& Renderer,
    FRDGBuilder& GraphBuilder,
    TArrayView<FViewInfo> InViews,
    FSceneTextures& SceneTextures,
    const FDBufferTextures& DBufferTextures,
    FExclusiveDepthStencil::Type BasePassDepthStencilAccess,
    FRDGTextureRef ForwardShadowMaskTexture,
    FInstanceCullingManager& InstanceCullingManager,
    bool bNaniteEnabled,
    FNaniteShadingCommands& NaniteBasePassShadingCommands,
    const TArrayView<Nanite::FRasterResults>& NaniteRasterResults)
{
    // 1. Parallel Base Pass 활성화 여부 결정
    const bool bEnableParallelBasePasses = GRHICommandList.UseParallelAlgorithms() &&
                                           CVarParallelBasePass.GetValueOnRenderThread();
    const bool bDoParallelBasePass = bEnableParallelBasePasses && !bDebugViewMode;

    // 2. Clear Method 결정 (r.ClearSceneMethod CVar)
    //    - 0: No clear
    //    - 1: RHICmdList.Clear (하드웨어 클리어)
    //    - 2: Far-Z Quad (전체 화면 쿼드로 클리어)

    // 3. G-Buffer Render Target 설정
    TStaticArray<FTextureRenderTargetBinding, MaxSimultaneousRenderTargets> BasePassTextures;
    uint32 BasePassTextureCount = SceneTextures.GetGBufferRenderTargets(BasePassTextures);

    // Substrate MRT 추가 (Substrate 활성화 시)
    Substrate::AppendSubstrateMRTs(Renderer, BasePassTextureCount, BasePassTextures);

    // 4. G-Buffer 클리어 (필요 시)
    if (bRequiresRHIClear)
    {
        GraphBuilder.AddPass(RDG_EVENT_NAME("GBufferClear"), PassParameters, ERDGPassFlags::Raster,
            [PassParameters, SceneColorClearValue](FRDGAsyncTask, FRHICommandList& RHICmdList)
            {
                // MRT Clear 또는 Shader Clear
                DrawClearQuadMRT(RHICmdList, ...);
            });
    }

    // 5. 각 View에 대해 Base Pass 렌더링
    for (int32 ViewIndex = 0; ViewIndex < InViews.Num(); ++ViewIndex)
    {
        FViewInfo& View = InViews[ViewIndex];

        if (bDoParallelBasePass)
        {
            // Parallel Dispatch
            GraphBuilder.AddDispatchPass(
                RDG_EVENT_NAME("BasePassParallel"),
                PassParameters,
                ERDGPassFlags::Raster | ERDGPassFlags::NeverCull,
                [Pass, PassParameters](FRDGDispatchPassBuilder& DispatchPassBuilder)
                {
                    Pass->Dispatch(DispatchPassBuilder, &PassParameters->InstanceCullingDrawParams);
                });
        }
        else
        {
            // Single-threaded Draw
            GraphBuilder.AddPass(...);
        }
    }
}

// Engine/Source/Runtime/Renderer/Internal/SceneTextures.h
// Engine/Source/Runtime/RenderCore/Public/GBufferInfo.h

// 기본 G-Buffer 슬롯 (EGBufferSlot enum)
GBS_SceneColor       // RGB 11.11.10 - 최종 라이팅 결과 (Base Pass에서는 Emissive만)
GBS_WorldNormal      // RGB 10.10.10 - Octahedron 인코딩된 월드 노멀
GBS_PerObjectGBufferData  // 2 bits - 오브젝트별 데이터
GBS_Metallic         // R8 - 금속성
GBS_Specular         // R8 - 스페큘러 강도
GBS_Roughness        // R8 - 거칠기
GBS_ShadingModelId   // 4 bits - 셰이딩 모델 ID (Default, Subsurface, Cloth 등)
GBS_SelectiveOutputMask // 4 bits - 선택적 출력 마스크
GBS_BaseColor        // RGB8 - 기본 색상 (Albedo)
GBS_GenericAO        // R8 - Ambient Occlusion
GBS_Velocity         // RG float16 - 모션 벡터
GBS_CustomData       // RGBA8 - 셰이딩 모델별 커스텀 데이터

// Engine/Source/Runtime/Renderer/Private/Nanite/NaniteRender.cpp
void Nanite::DrawBasePass(
    FRDGBuilder& GraphBuilder,
    const FSceneRenderer& SceneRenderer,
    const FScene& Scene,
    const FViewInfo& View,
    const FRasterResults& RasterResults,
    FSceneTextures& SceneTextures,
    FNaniteShadingCommands& ShadingCommands)
{
    // 1. Visibility Buffer에서 삼각형 ID, 바리센트릭 좌표 읽기
    // 2. Material Depth Pass: 머티리얼별 깊이 기록
    // 3. Deferred Material Pass: G-Buffer에 머티리얼 속성 기록
    //    - Compute Shader로 Visibility Buffer를 디코딩
    //    - 픽셀별로 해당 머티리얼 셰이더 실행
}

// Base Pass에서 DBuffer Decal 적용
if (DBufferTextures.IsValid())
{
    // DBufferA: Base Color Decal
    // DBufferB: Normal Decal
    // DBufferC: Roughness/Metallic/AO Decal
    // → G-Buffer 값에 블렌딩
}

// Substrate 활성화 시 추가 MRT
if (Substrate::IsSubstrateEnabled())
{
    Substrate::AppendSubstrateMRTs(Renderer, BasePassTextureCount, BasePassTextures);
    // SubstrateTopLayerTexture, SubstrateClosureOffsetTexture 등 추가
}

// Engine/Source/Runtime/Renderer/Private/ShadowDepthRendering.cpp:1678
void FSceneRenderer::RenderShadowDepthMaps(
    FRDGBuilder& GraphBuilder,
    FDynamicShadowsTaskData* DynamicShadowsTaskData,
    FInstanceCullingManager& InstanceCullingManager,
    FRDGExternalAccessQueue& ExternalAccessQueue)
{
    // 조기 종료 조건
    if (!ViewFamily.EngineShowFlags.DynamicShadows)
    {
        bShadowDepthRenderCompleted = true;
        return;
    }

    RDG_EVENT_SCOPE_STAT(GraphBuilder, ShadowDepths, "ShadowDepths");

    // 1. Dynamic Shadow Mesh Pass 완료 대기
    //    - 병렬로 생성된 Shadow Mesh Draw Command 수집
    if (DynamicShadowsTaskData)
    {
        FinishDynamicShadowMeshPassSetup(GraphBuilder, DynamicShadowsTaskData);
    }

    // 2. Instance Culling 배치 시작
    //    - Shadow View에 대한 Culling 작업 등록
    InstanceCullingManager.BeginDeferredCulling(GraphBuilder);

    // 3. Virtual Shadow Maps 렌더링 (UE5 기본값)
    FShadowSceneRenderer* ShadowSceneRenderer = GetSceneExtensionsRenderers().GetRendererPtr<FShadowSceneRenderer>();
    if (ShadowSceneRenderer)
    {
        ShadowSceneRenderer->RenderVirtualShadowMaps(GraphBuilder, bNaniteEnabled);
    }

    // 4. 전통적 Shadow Map Atlas 렌더링 (Non-VSM)
    //    - Directional Light CSM
    //    - Spot/Point Light Per-Object Shadows
    RenderShadowDepthMapAtlases(GraphBuilder);

    // 5. Cubemap Shadow Maps (Point Light 전용)
    for (FSortedShadowMapAtlas& ShadowMap : SortedShadowsForShadowDepthPass.ShadowMapCubemaps)
    {
        FProjectedShadowInfo* ProjectedShadowInfo = ShadowMap.Shadows[0];

        // Cubemap 6면 렌더링
        ProjectedShadowInfo->RenderDepth(GraphBuilder, this, ShadowDepthTexture,
            bDoParallelDispatch, bDoCrossGPUCopy);

        // Nanite Shadow 통합
        if (bNaniteEnabled && CVarNaniteShadows.GetValueOnRenderThread())
        {
            for (int32 FaceIndex = 0; FaceIndex < 6; FaceIndex++)
            {
                Nanite::RenderShadowDepths(GraphBuilder, ...);
            }
        }
    }

    bShadowDepthRenderCompleted = true;
}

// Engine/Source/Runtime/Renderer/Private/ShadowSetup.cpp
void FProjectedShadowInfo::SetupWholeSceneProjection(
    FLightSceneInfo* InLightSceneInfo,
    FViewInfo* InDependentView,
    const FWholeSceneProjectedShadowInitializer& Initializer,
    uint32 InResolutionX,
    uint32 InResolutionY,
    uint32 InBorderSize,
    bool bInReflectiveShadowMap)
{
    // Cascade 분할 계산
    // - Practical Split Scheme: Log + Linear 혼합
    // - 각 Cascade의 Near/Far 평면 결정

    // Cascade별 Shadow Matrix 계산
    // - Light Space View Matrix
    // - Light Space Projection Matrix (Orthographic)
}

// Practical Split Scheme
float SplitNear = Mix(
    NearClip * pow(FarClip / NearClip, CascadeIndex / NumCascades),      // Logarithmic
    NearClip + (FarClip - NearClip) * (CascadeIndex / NumCascades),      // Linear
    Lambda  // 혼합 비율 (0.5 ~ 0.9)
);

// Engine/Source/Runtime/Renderer/Private/VirtualShadowMaps/VirtualShadowMapArray.cpp
void FVirtualShadowMapArray::RenderVirtualShadowMapsHw(FRDGBuilder& GraphBuilder, ...)
{
    // 1. Page Table 업데이트
    //    - 화면에 보이는 영역만 페이지 할당
    //    - LOD 기반 해상도 선택

    // 2. Physical Page Pool 관리
    //    - LRU 기반 페이지 교체
    //    - 캐싱을 통한 재사용

    // 3. Nanite 통합 렌더링
    //    - Nanite 클러스터를 직접 VSM에 래스터화
    //    - GPU-driven 컬링 + 렌더링

    // 4. Non-Nanite 메시 렌더링
    //    - 전통적 방식으로 VSM 페이지에 렌더링
}

// Engine/Source/Runtime/Renderer/Private/ShadowDepthRendering.cpp
void FSceneRenderer::RenderShadowDepthMapAtlases(FRDGBuilder& GraphBuilder)
{
    // Shadow Map들을 Atlas 텍스처에 패킹
    // - 작은 Shadow Map들을 하나의 큰 텍스처에 배치
    // - Draw Call 최소화

    for (FSortedShadowMapAtlas& Atlas : SortedShadowsForShadowDepthPass.ShadowMapAtlases)
    {
        FRDGTextureRef ShadowDepthTexture = GraphBuilder.RegisterExternalTexture(
            Atlas.RenderTargets.DepthTarget);

        for (FProjectedShadowInfo* Shadow : Atlas.Shadows)
        {
            // 각 Shadow를 Atlas 내 할당된 영역에 렌더링
            Shadow->RenderDepth(GraphBuilder, this, ShadowDepthTexture, ...);
        }
    }
}

// Shadow Map 샘플링 및 PCF 필터링
float SampleShadowMap(float3 ShadowCoord, float2 ShadowMapSize)
{
    // 1. Depth 비교
    float ReceiverDepth = ShadowCoord.z;
    float ShadowMapDepth = ShadowDepthTexture.Sample(ShadowCoord.xy);

    // 2. PCF (Percentage Closer Filtering)
    float Shadow = 0;
    for (int i = 0; i < NumSamples; i++)
    {
        float2 Offset = PoissonDisk[i] / ShadowMapSize;
        Shadow += ShadowDepthTexture.Sample(ShadowCoord.xy + Offset) > ReceiverDepth ? 1 : 0;
    }
    return Shadow / NumSamples;

    // 3. PCSS (Percentage Closer Soft Shadows) - 선택적
    // - Blocker 검색 → Penumbra 크기 계산 → 가변 필터 크기
}

// Engine/Source/Runtime/Renderer/Private/LightSceneInfo.h
// FSortedLightSetSceneInfo 구조

SortedLights[0 ~ SimpleLightsEnd]           // Simple Lights: 작은 범위, 섀도우 없음
SortedLights[SimpleLightsEnd ~ ClusteredSupportedEnd]  // Clustered 지원 광원
SortedLights[ClusteredSupportedEnd ~ UnbatchedLightStart]  // Batched Lights
SortedLights[UnbatchedLightStart ~ MegaLightsLightStart]   // Unbatched: 개별 처리 (섀도우, IES 등)
SortedLights[MegaLightsLightStart ~ Num]    // MegaLights 대상

// Engine/Source/Runtime/Renderer/Private/LightRendering.cpp:1520
void FDeferredShadingSceneRenderer::RenderLights(
    FRDGBuilder& GraphBuilder,
    FMinimalSceneTextures& SceneTextures,
    FRDGTextureRef LightingChannelsTexture,
    const FSortedLightSetSceneInfo& SortedLightSet)
{
    RDG_EVENT_SCOPE_STAT(GraphBuilder, Lights, "Lights");

    // 1. Substrate Stencil 마킹 (Substrate 활성화 시)
    //    - Simple/Complex 머티리얼 영역을 Stencil로 구분
    if (ViewFamily.EngineShowFlags.DirectLighting && Substrate::IsSubstrateEnabled())
    {
        Substrate::AddSubstrateStencilPass(GraphBuilder, Views, SceneTextures);
    }

    // 2. VSM Projection Mask 렌더링
    //    - Virtual Shadow Map의 섀도우 마스크 생성
    FShadowSceneRenderer& ShadowSceneRenderer = GetSceneExtensionsRenderers().GetRenderer<FShadowSceneRenderer>();
    ShadowSceneRenderer.RenderVirtualShadowMapProjectionMaskBits(GraphBuilder, SceneTextures);

    // 3. Clustered Deferred Shading
    //    - 3D Light Grid를 통해 다수의 광원을 효율적으로 처리
    if (ShouldUseClusteredDeferredShading(ViewFamily.GetShaderPlatform()) && AreLightsInLightGrid())
    {
        AddClusteredDeferredShadingPass(GraphBuilder, SceneTextures, SortedLightSet,
            ShadowSceneRenderer.VirtualShadowMapMaskBits,
            ShadowSceneRenderer.VirtualShadowMapMaskBitsHairStrands,
            LightingChannelsTexture);
    }
    else if (SortedLightSet.SimpleLights.InstanceData.Num() > 0)
    {
        // Clustered 미사용 시 Standard Deferred
        RenderSimpleLightsStandardDeferred(GraphBuilder, SceneTextures, SortedLightSet);
    }

    // 4. Unbatched Lights (개별 광원)
    //    - 섀도우 캐스팅, Light Function, IES Profile 등 복잡한 광원
    for (int32 LightIndex = UnbatchedLightStart; LightIndex < SortedLights.Num(); LightIndex++)
    {
        const FSortedLightSceneInfo& SortedLight = SortedLights[LightIndex];
        const FLightSceneInfo& LightSceneInfo = *SortedLight.LightSceneInfo;

        // Stencil 볼륨 최적화
        if (LightSceneInfo.Proxy->GetLightType() == LightType_Point ||
            LightSceneInfo.Proxy->GetLightType() == LightType_Spot)
        {
            // Light Volume (Sphere/Cone)으로 영향 범위 제한
            RenderLightForStencilVolume(GraphBuilder, LightSceneInfo, ...);
        }

        // 실제 라이팅 계산
        RenderLight(GraphBuilder, SceneTextures, SortedLight, ...);
    }
}

// Engine/Source/Runtime/Renderer/Private/ClusteredDeferredShadingPass.cpp
void FDeferredShadingSceneRenderer::AddClusteredDeferredShadingPass(...)
{
    // Substrate 머티리얼 타입별 분기
    if (Substrate::IsSubstrateEnabled())
    {
        // 각 타일 타입별로 별도 패스
        if (Substrate::GetSubstrateUsesTileType(View, ESubstrateTileType::EComplexSpecial))
            InternalAddClusteredDeferredShadingPass(..., EClusteredShadingPass::Substrate);
        if (Substrate::GetSubstrateUsesTileType(View, ESubstrateTileType::EComplex))
            InternalAddClusteredDeferredShadingPass(...);
        // ... ESingle, ESimple
    }
    else
    {
        // 기존 GBuffer 경로
        InternalAddClusteredDeferredShadingPass(..., EClusteredShadingPass::GBuffer);
    }

    // Hair Strands 전용 패스
    if (HairStrands::HasViewHairStrandsData(View))
    {
        FHairStrandsTransmittanceMaskData TransmittanceMask = RenderHairStrandsOnePassTransmittanceMask(...);
        InternalAddClusteredDeferredShadingPass(..., EClusteredShadingPass::HairStrands);
    }
}

// ClusteredDeferredShadingPixelShader.usf
float3 CalculateClusteredLighting(float3 WorldPosition, ...)
{
    // 1. 현재 픽셀의 클러스터 인덱스 계산
    uint3 ClusterIndex = ComputeClusterIndex(ScreenUV, Depth);

    // 2. 해당 클러스터의 Light 리스트 가져오기
    uint LightListOffset = LightGrid[ClusterIndex].Offset;
    uint LightCount = LightGrid[ClusterIndex].Count;

    // 3. 각 광원에 대해 라이팅 계산
    float3 Lighting = 0;
    for (uint i = 0; i < LightCount; i++)
    {
        uint LightIndex = LightIndices[LightListOffset + i];
        FLightData Light = GetLightData(LightIndex);

        Lighting += CalculateLightContribution(Light, WorldPosition, Normal, ...);
    }
    return Lighting;
}

// Engine/Source/Runtime/Renderer/Private/LightRendering.cpp
void RenderLight(
    FRDGBuilder& GraphBuilder,
    const FMinimalSceneTextures& SceneTextures,
    const FSortedLightSceneInfo& SortedLight,
    ...)
{
    const FLightSceneInfo& LightSceneInfo = *SortedLight.LightSceneInfo;

    // 1. Shadow Projection (섀도우 캐스팅 광원)
    if (SortedLight.SortedShadowInfo.Num() > 0)
    {
        RenderProjectedShadows(GraphBuilder, LightSceneInfo, SortedLight.SortedShadowInfo);
    }

    // 2. Light Function 적용 (광원 마스킹)
    if (LightSceneInfo.Proxy->GetLightFunctionMaterial())
    {
        RenderLightFunction(GraphBuilder, LightSceneInfo);
    }

    // 3. 실제 라이팅 계산
    GraphBuilder.AddPass(
        RDG_EVENT_NAME("StandardDeferredLighting"),
        PassParameters,
        ERDGPassFlags::Raster,
        [&](FRHICommandList& RHICmdList)
        {
            // Light Volume 또는 Full-screen Quad
            if (bUseLightVolume)
                DrawLightVolume(RHICmdList, LightSceneInfo);
            else
                DrawFullScreenQuad(RHICmdList);
        });
}

// Engine/Source/Runtime/Renderer/Private/MegaLights/MegaLights.cpp
void FDeferredShadingSceneRenderer::RenderMegaLights(FRDGBuilder& GraphBuilder, ...)
{
    // 1. Importance Sampling 기반 광원 선택
    //    - 각 픽셀에 가장 중요한 N개 광원 선택
    //    - 광원 강도, 거리, 방향 기반 확률 분포

    // 2. Stochastic Lighting
    //    - 선택된 광원만 샘플링
    //    - 확률에 따른 가중치 적용

    // 3. Temporal Accumulation
    //    - 여러 프레임에 걸쳐 결과 누적
    //    - 노이즈 감소 + 수렴

    // 4. Denoising
    //    - Spatial/Temporal 필터링
    //    - 최종 결과 안정화
}

// Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp:347
void AddPostProcessingPasses(
    FRDGBuilder& GraphBuilder,
    const FViewInfo& View,
    int32 ViewIndex,
    FSceneUniformBuffer& SceneUniformBuffer,
    EDiffuseIndirectMethod DiffuseIndirectMethod,
    EReflectionsMethod ReflectionsMethod,
    const FPostProcessingInputs& Inputs,
    const Nanite::FRasterResults* NaniteRasterResults,
    FInstanceCullingManager& InstanceCullingManager,
    FVirtualShadowMapArray* VirtualShadowMapArray,
    FLumenSceneFrameTemporaries& LumenFrameTemporaries,
    const FSceneWithoutWaterTextures& SceneWithoutWaterTextures,
    FScreenPassTexture TSRFlickeringInput,
    FRDGTextureRef& InstancedEditorDepthTexture)
{
    // Pass Sequence 정의 (PostProcessing.cpp:441)
    enum class EPass : uint32
    {
        MotionBlur,
        PostProcessMaterialBeforeBloom,
        Tonemap,
        FXAA,
        SMAA,
        PostProcessMaterialAfterTonemapping,
        // ... Visualize passes ...
        PrimaryUpscale,
        SecondaryUpscale,
        AlphaInvert,
        MAX
    };

    TOverridePassSequence<EPass> PassSequence(ViewFamilyOutput);

    // TAA 설정 결정
    const EMainTAAPassConfig TAAConfig = GetMainTAAPassConfig(View);

    // Temporal Upscaler 분기 (PostProcessing.cpp:975)
    if (TAAConfig == EMainTAAPassConfig::TSR)
    {
        Outputs = AddMainTemporalSuperResolutionPasses(GraphBuilder, View, UpscalerPassInputs);
    }
    else if (TAAConfig == EMainTAAPassConfig::TAA)
    {
        Outputs = AddGen4MainTemporalAAPasses(GraphBuilder, View, UpscalerPassInputs);
    }
    else if (TAAConfig == EMainTAAPassConfig::ThirdParty)
    {
        Outputs = AddThirdPartyTemporalUpscalerPasses(GraphBuilder, View, UpscalerPassInputs);
    }
}

// Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessMotionBlur.cpp:128
bool IsMotionBlurEnabled(const FViewInfo& View)
{
    if (View.GetFeatureLevel() < ERHIFeatureLevel::SM5)
    {
        return false;
    }

    const int32 MotionBlurQuality = GetMotionBlurQualityFromCVar();
    const FSceneViewFamily& ViewFamily = *View.Family;

    return ViewFamily.EngineShowFlags.PostProcessing
        && ViewFamily.EngineShowFlags.MotionBlur
        && View.FinalPostProcessSettings.MotionBlurAmount > 0.001f
        && View.FinalPostProcessSettings.MotionBlurMax > 0.001f
        && ViewFamily.bRealtimeUpdate
        && MotionBlurQuality > 0
        && (CVarAllowMotionBlurInVR->GetInt() != 0 || !GEngine->StereoRenderingDevice.IsValid());
}

// Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessMotionBlur.cpp:153
bool IsMotionBlurScatterRequired(const FViewInfo& View, const FScreenPassTextureViewport& SceneViewport)
{
    const float ViewportWidth = SceneViewport.Rect.Width();
    const float VelocityMax = View.FinalPostProcessSettings.MotionBlurMax / 100.0f;

    // 타일 단위로 변환 (0.5 / 16.0 = 양방향 블러 + 타일 크기)
    const float VelocityMaxInTiles = VelocityMax * ViewportWidth * (0.5f / 16.0f);

    // Gather 방식으로 처리 가능한 최대 타일 거리
    const float TileDistanceMaxGathered = 3.0f;

    // 최대 속도가 Gather 한계를 초과하면 Scatter 사용
    const bool bIsScatterRequiredByVelocityLength = VelocityMaxInTiles > TileDistanceMaxGathered;

    // 시네마틱 일시정지 시 고품질 Scatter 사용
    const bool bInPausedCinematic = (ViewState && ViewState->SequencerState == ESS_Paused);

    return bIsScatterRequiredByUser || bIsScatterRequiredByVelocityLength;
}

// Engine/Source/Runtime/Renderer/Private/PostProcess/TemporalSuperResolution.cpp
// TSR 주요 설정 파라미터

// 히스토리 샘플 수 (기본 16, 최대 32)
TAutoConsoleVariable<float> CVarTSRHistorySampleCount(
    TEXT("r.TSR.History.SampleCount"), 16.0f,
    TEXT("Maximum number sample for each output pixel in the history."));

// 히스토리 해상도 배율 (기본 100%, 최대 200%)
TAutoConsoleVariable<float> CVarTSRHistorySP(
    TEXT("r.TSR.History.ScreenPercentage"), 100.0f,
    TEXT("Resolution multiplier of the history of TSR."));

// Async Compute 설정
TAutoConsoleVariable<int32> CVarTSRAsyncCompute(
    TEXT("r.TSR.AsyncCompute"), 2,
    TEXT("0: Disabled\n")
    TEXT("1: Independent passes only\n")
    TEXT("2: Depth/Velocity dependent passes (default)\n")
    TEXT("3: All passes on async compute"));

// TSR의 핵심 품질 파라미터
// Engine/Source/Runtime/Renderer/Private/PostProcess/TemporalSuperResolution.cpp:122

// Rejection 후 히스토리 샘플 수 (낮을수록 선명, 높을수록 안정)
TAutoConsoleVariable<float> CVarTSRHistoryRejectionSampleCount(
    TEXT("r.TSR.ShadingRejection.SampleCount"), 2.0f,
    TEXT("Lower values = higher clarity after rejection, but more instability"));

// Flickering 감지 활성화 (모아레 패턴, 복잡한 지오메트리 처리)
TAutoConsoleVariable<int32> CVarTSRFlickeringEnable(
    TEXT("r.TSR.ShadingRejection.Flickering"), 1,
    TEXT("Temporal analysis to stabilize flickering pixels"));

// Flickering 감지 주기 (프레임 단위)
TAutoConsoleVariable<float> CVarTSRFlickeringPeriod(
    TEXT("r.TSR.ShadingRejection.Flickering.Period"), 2.0f,
    TEXT("Frame frequency threshold for flickering detection"));

// Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessEyeAdaptation.cpp:265
EAutoExposureMethod GetAutoExposureMethod(const FViewInfo& View)
{
    EAutoExposureMethod AutoExposureMethod = View.FinalPostProcessSettings.AutoExposureMethod;

    // Feature Level에 따른 fallback
    if (!IsAutoExposureMethodSupported(View.GetFeatureLevel(), AutoExposureMethod))
    {
        AutoExposureMethod = IsAutoExposureMethodSupported(View.GetFeatureLevel(),
            EAutoExposureMethod::AEM_Basic) ? EAutoExposureMethod::AEM_Basic
                                            : EAutoExposureMethod::AEM_Manual;
    }

    return ApplyEyeAdaptationQuality(AutoExposureMethod);
}

// Histogram Eye Adaptation (PostProcessing.cpp:1275)
EyeAdaptationBuffer = AddHistogramEyeAdaptationPass(
    GraphBuilder, View,
    EyeAdaptationParameters,
    LocalExposureParameters,
    HistogramTexture,
    bLocalExposureEnabled && View.FinalPostProcessSettings.LocalExposureMethod == ELocalExposureMethod::Bilateral);

// Basic Eye Adaptation (PostProcessing.cpp:1264)
EyeAdaptationBuffer = AddBasicEyeAdaptationPass(
    GraphBuilder, View,
    EyeAdaptationParameters,
    LocalExposureParameters,
    SceneDownsampleChain.GetLastTexture(),
    LastEyeAdaptationBuffer,
    bLocalExposureEnabled);

// Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessBloomSetup.cpp:197
FScreenPassTexture AddGaussianBloomPasses(
    FRDGBuilder& GraphBuilder,
    const FViewInfo& View,
    const FTextureDownsampleChain* SceneDownsampleChain)
{
    const EBloomQuality BloomQuality = GetBloomQuality();

    // 품질별 다운샘플 스테이지 수
    const uint32 BloomQualityToSceneDownsampleStage[] =
    {
        static_cast<uint32>(-1), // Disabled
        3, // Q1
        3, // Q2
        4, // Q3
        5, // Q4
        6  // Q5
    };

    // 각 스테이지별 블룸 설정
    FBloomStage BloomStages[] =
    {
        { Settings.Bloom6Size, Settings.Bloom6Tint },  // 가장 넓은 블러
        { Settings.Bloom5Size, Settings.Bloom5Tint },
        { Settings.Bloom4Size, Settings.Bloom4Tint },
        { Settings.Bloom3Size, Settings.Bloom3Tint },
        { Settings.Bloom2Size, Settings.Bloom2Tint },
        { Settings.Bloom1Size, Settings.Bloom1Tint }   // 가장 좁은 블러
    };

    // 각 스테이지에 Gaussian Blur 적용
    for (uint32 StageIndex = 0; StageIndex < BloomStageCount; ++StageIndex)
    {
        FGaussianBlurInputs PassInputs;
        PassInputs.Filter = SceneDownsampleChain->GetTexture(SourceIndex);
        PassInputs.Additive = PassOutputs;  // 이전 결과와 합성
        PassInputs.KernelSizePercent = BloomStage.Size * Settings.BloomSizeScale;
        PassInputs.TintColor = BloomStage.Tint * TintScale;

        PassOutputs = AddGaussianBlurPass(GraphBuilder, View, PassInputs);
    }
}

// Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.cpp:227
FTonemapperOutputDeviceParameters GetTonemapperOutputDeviceParameters(const FSceneViewFamily& Family)
{
    EDisplayOutputFormat OutputDeviceValue;

    if (Family.SceneCaptureSource == SCS_FinalColorHDR)
    {
        OutputDeviceValue = EDisplayOutputFormat::HDR_LinearNoToneCurve;
    }
    else if (Family.SceneCaptureSource == SCS_FinalToneCurveHDR)
    {
        OutputDeviceValue = EDisplayOutputFormat::HDR_LinearWithToneCurve;
    }
    else
    {
        OutputDeviceValue = Family.RenderTarget->GetDisplayOutputFormat();
    }

    FTonemapperOutputDeviceParameters Parameters;
    Parameters.InverseGamma = InvDisplayGammaValue;
    Parameters.OutputDevice = static_cast<uint32>(OutputDeviceValue);
    Parameters.OutputGamut = static_cast<uint32>(Family.RenderTarget->GetDisplayColorGamut());
    Parameters.OutputMaxLuminance = HDRGetDisplayMaximumLuminance();
    return Parameters;
}

// Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessTonemap.cpp:287
BEGIN_SHADER_PARAMETER_STRUCT(FTonemapParameters, )
    SHADER_PARAMETER_STRUCT_INCLUDE(FViewShaderParameters, View)
    SHADER_PARAMETER_STRUCT_INCLUDE(FFilmGrainParameters, FilmGrain)
    SHADER_PARAMETER_STRUCT_INCLUDE(FTonemapperOutputDeviceParameters, OutputDevice)

    // Color Grading LUT
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, ColorGradingLUT)
    SHADER_PARAMETER(float, LUTSize)
    SHADER_PARAMETER(float, InvLUTSize)

    // Bloom 합성
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, BloomTexture)
    SHADER_PARAMETER(FScreenTransform, ColorToBloom)

    // Eye Adaptation
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>, EyeAdaptationBuffer)

    // Film 파라미터 (ACES Tonemapper)
    SHADER_PARAMETER(float, FilmSlope)
    SHADER_PARAMETER(float, FilmToe)
    SHADER_PARAMETER(float, FilmShoulder)
    SHADER_PARAMETER(float, FilmBlackClip)
    SHADER_PARAMETER(float, FilmWhiteClip)

    // Chromatic Aberration
    SHADER_PARAMETER(FVector4f, ChromaticAberrationParams)

    // Quantization Dithering (밴딩 방지)
    SHADER_PARAMETER(float, BackbufferQuantizationDithering)
END_SHADER_PARAMETER_STRUCT()

// Shader Permutation 정의
namespace TonemapperPermutation
{
    class FTonemapperGammaOnlyDim      : SHADER_PERMUTATION_BOOL("USE_GAMMA_ONLY");
    class FTonemapperLocalExposureDim  : SHADER_PERMUTATION_INT("LOCAL_EXPOSURE_MODE", 3);
    class FTonemapperSharpenDim        : SHADER_PERMUTATION_BOOL("USE_SHARPEN");
    class FTonemapperFilmGrainDim      : SHADER_PERMUTATION_BOOL("USE_FILM_GRAIN");
    class FTonemapperColorFringeDim    : SHADER_PERMUTATION_BOOL("USE_COLOR_FRINGE");
    class FTonemapperAlphaChannelDim   : SHADER_PERMUTATION_BOOL("DIM_ALPHA_CHANNEL");
}

// PostProcessing.cpp:1238-1251
if (bProduceSceneColorChain)
{
    const bool bLogLumaInAlpha = bBasicEyeAdaptationEnabled;
    SceneDownsampleChain.Init(
        GraphBuilder, View,
        EyeAdaptationParameters,
        bProcessEighthResolution ? EighthResSceneColor
            : (bProcessQuarterResolution ? QuarterResSceneColor : HalfResSceneColor),
        DownsampleChainQuality,
        6,  // 6단계 다운샘플
        bLogLumaInAlpha,
        TEXT("Scene"),
        bProcessEighthResolution ? 3 : (bProcessQuarterResolution ? 2 : 1));
}

// 주요 품질/성능 제어 CVar
r.MotionBlurQuality         // 0-4: Motion Blur 품질
r.BloomQuality              // 0-5: Bloom 품질 (다운샘플 단계 수)
r.Tonemapper.Sharpen        // -1~10: 샤프닝 강도
r.TSR.History.ScreenPercentage  // 100-200: TSR 히스토리 해상도
r.TSR.History.SampleCount   // 8-32: 히스토리 누적 샘플 수
r.EyeAdaptationQuality      // 0-2: Eye Adaptation 품질
r.PostProcessing.PropagateAlpha // 알파 채널 전파 (VFX 합성용)