레스터라이저 Rasterizer, 뎁스 스텐실 DepthStencil, 블렌드 Blend (State)

// Rasterizer State 설정 구조체 D3D11_RASTERIZER_DESC rsDesc = {}; rsDesc.FillMode = D3D11_FILL_SOLID; // 면 채우기 모드 rsDesc.CullMode = D3D11_CULL_BACK; // 뒷면 컬링 rsDesc.FrontCounterClockwise = FALSE; // 시계방향이 앞면 rsDesc.DepthBias = 0; // 깊이 바이어스 rsDesc.DepthBiasClamp = 0.0f; // 바이어스 최대값 rsDesc.SlopeScaledDepthBias = 0.0f; // 경사 기반 바이어스 rsDesc.DepthClipEnable = TRUE; // 깊이 클리핑 활성화 rsDesc.ScissorEnable = FALSE; // 시저 테스트 비활성화 rsDesc.MultisampleEnable = FALSE; // MSAA 비활성화 rsDesc.AntialiasedLineEnable = FALSE; // 라인 AA 비활성화 // Rasterizer State 객체 생성 ID3D11RasterizerState* rasterizerState = nullptr; HRESULT hr = device->CreateRasterizerState(&rsDesc, &rasterizerState);

enum D3D11_FILL_MODE { D3D11_FILL_WIREFRAME = 2, // 와이어프레임 (선만) D3D11_FILL_SOLID = 3 // 솔리드 (면 채우기) };

enum D3D11_CULL_MODE { D3D11_CULL_NONE = 1, // 컬링 없음 (양면 렌더링) D3D11_CULL_FRONT = 2, // 앞면 컬링 D3D11_CULL_BACK = 3 // 뒷면 컬링 (일반적) };

rsDesc.DepthBias = 100; // 정수 오프셋 rsDesc.SlopeScaledDepthBias = 1.0f; // 경사에 비례한 오프셋

void GraphicDevice_DX11::BindRasterizerState(ID3D11RasterizerState* rasterizerState) { context->RSSetState(rasterizerState); } // 사용 예시 BindRasterizerState(rasterizerStates[eRasterizerState::SolidBack].Get());

enum class eRasterizerState { SolidBack, // 기본 렌더링 SolidFront, // 내부 렌더링 SolidNone, // 양면 렌더링 Wireframe, // 디버그 와이어프레임 ShadowMap, // 그림자 맵 생성용 Count }; // 초기화 시 모든 State 생성 void InitializeRasterizerStates() { D3D11_RASTERIZER_DESC desc = {}; // 1. SolidBack: 일반 렌더링 desc.FillMode = D3D11_FILL_SOLID; desc.CullMode = D3D11_CULL_BACK; device->CreateRasterizerState(&desc, &states[SolidBack]); // 2. SolidFront: 내부 렌더링 desc.CullMode = D3D11_CULL_FRONT; device->CreateRasterizerState(&desc, &states[SolidFront]); // 3. SolidNone: 양면 렌더링 desc.CullMode = D3D11_CULL_NONE; device->CreateRasterizerState(&desc, &states[SolidNone]); // 4. Wireframe: 디버그 desc.FillMode = D3D11_FILL_WIREFRAME; device->CreateRasterizerState(&desc, &states[Wireframe]); // 5. ShadowMap: 그림자 매핑용 desc.FillMode = D3D11_FILL_SOLID; desc.CullMode = D3D11_CULL_FRONT; // 앞면 컬링으로 Shadow Acne 방지 desc.DepthBias = 100; desc.SlopeScaledDepthBias = 1.0f; device->CreateRasterizerState(&desc, &states[ShadowMap]); }

// Blend State 설정 구조체 D3D11_BLEND_DESC blendDesc = {}; // 전역 설정 blendDesc.AlphaToCoverageEnable = false; // MSAA에서 알파 사용 여부 blendDesc.IndependentBlendEnable = false; // false면 RT[0]만 사용, RT[1-7] 무시 // 렌더 타겟 0번 설정 blendDesc.RenderTarget[0].BlendEnable = true; // 블렌딩 활성화 // RGB 블렌딩 설정 blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; // Source 계수 blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; // Dest 계수 blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; // 연산: 덧셈 // Alpha 블렌딩 설정 blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; // Alpha Source blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; // Alpha Dest blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; // Alpha 연산 // 쓰기 마스크 (어떤 채널에 쓸지) blendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; // Blend State 객체 생성 ID3D11BlendState* blendState = nullptr; device->CreateBlendState(&blendDesc, &blendState);

enum D3D11_BLEND { D3D11_BLEND_ZERO, // 0 D3D11_BLEND_ONE, // 1 D3D11_BLEND_SRC_COLOR, // Source RGB D3D11_BLEND_INV_SRC_COLOR, // 1 - Source RGB D3D11_BLEND_SRC_ALPHA, // Source Alpha D3D11_BLEND_INV_SRC_ALPHA, // 1 - Source Alpha D3D11_BLEND_DEST_COLOR, // Dest RGB D3D11_BLEND_INV_DEST_COLOR, // 1 - Dest RGB D3D11_BLEND_DEST_ALPHA, // Dest Alpha D3D11_BLEND_INV_DEST_ALPHA, // 1 - Dest Alpha D3D11_BLEND_BLEND_FACTOR, // 커스텀 상수 // ... 더 많은 옵션 };

enum D3D11_BLEND_OP { D3D11_BLEND_OP_ADD, // Src + Dest D3D11_BLEND_OP_SUBTRACT, // Src - Dest D3D11_BLEND_OP_REV_SUBTRACT, // Dest - Src D3D11_BLEND_OP_MIN, // min(Src, Dest) D3D11_BLEND_OP_MAX // max(Src, Dest) };

enum D3D11_COLOR_WRITE_ENABLE { D3D11_COLOR_WRITE_ENABLE_RED = 1, // R 채널만 D3D11_COLOR_WRITE_ENABLE_GREEN = 2, // G 채널만 D3D11_COLOR_WRITE_ENABLE_BLUE = 4, // B 채널만 D3D11_COLOR_WRITE_ENABLE_ALPHA = 8, // A 채널만 D3D11_COLOR_WRITE_ENABLE_ALL = 15 // RGBA 모두 };

// Blend Factor: D3D11_BLEND_BLEND_FACTOR에서 사용할 상수 FLOAT blendFactor[4] = {0.0f, 0.0f, 0.0f, 0.0f}; // RGBA // Sample Mask: 멀티샘플 렌더 타겟에서 어떤 샘플을 활성화할지 UINT sampleMask = 0xffffffff; // 모든 샘플 사용 // Output Merger에 바인딩 context->OMSetBlendState( blendState, // Blend State 객체 blendFactor, // Blend Factor 상수 sampleMask // Sample Mask );

// 커스텀 블렌드 팩터 사용 예시 blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_BLEND_FACTOR; blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_BLEND_FACTOR; // 바인딩 시 팩터 값 지정 FLOAT customFactor[4] = {1.0f, 0.5f, 0.5f, 1.0f}; // 빨간색 강조 context->OMSetBlendState(blendState, customFactor, 0xffffffff);

enum class eBlendState { Default, // 불투명 (블렌딩 없음) AlphaBlend, // 알파 블렌딩 Additive, // 가산 블렌딩 Multiplicative, // 곱셈 블렌딩 NonPremultiplied,// 비사전곱셈 알파 Count }; void InitializeBlendStates() { D3D11_BLEND_DESC desc = {}; // 1. Default: 불투명 렌더링 desc.RenderTarget[0].BlendEnable = false; desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; device->CreateBlendState(&desc, &states[Default]); // 2. AlphaBlend: 표준 알파 블렌딩 desc.RenderTarget[0].BlendEnable = true; desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; device->CreateBlendState(&desc, &states[AlphaBlend]); // 3. Additive: 가산 블렌딩 (파티클 효과) desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; desc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE; desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; device->CreateBlendState(&desc, &states[Additive]); // 4. Multiplicative: 곱셈 블렌딩 (어두운 효과) desc.RenderTarget[0].SrcBlend = D3D11_BLEND_DEST_COLOR; desc.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO; desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; device->CreateBlendState(&desc, &states[Multiplicative]); // 5. NonPremultiplied: 비사전곱셈 알파 desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; device->CreateBlendState(&desc, &states[NonPremultiplied]); }

// Depth/Stencil State 설정 구조체 D3D11_DEPTH_STENCIL_DESC dsDesc = {}; // Depth Test 설정 dsDesc.DepthEnable = TRUE; // 깊이 테스트 활성화 dsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; // 깊이 쓰기 활성화 dsDesc.DepthFunc = D3D11_COMPARISON_LESS; // 가까운 것을 그림 // Stencil Test 설정 dsDesc.StencilEnable = FALSE; // 스텐실 테스트 비활성화 dsDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; // 0xFF dsDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK; // 0xFF // 앞면(Front-facing) 폴리곤에 대한 스텐실 동작 dsDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; // 스텐실 실패 시 dsDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; // 깊이 실패 시 dsDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; // 통과 시 dsDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // 항상 통과 // 뒷면(Back-facing) 폴리곤에 대한 스텐실 동작 dsDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; dsDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; dsDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; dsDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // Depth/Stencil State 객체 생성 ID3D11DepthStencilState* depthStencilState = nullptr; device->CreateDepthStencilState(&dsDesc, &depthStencilState);

enum D3D11_DEPTH_WRITE_MASK { D3D11_DEPTH_WRITE_MASK_ZERO, // 깊이 쓰기 비활성화 D3D11_DEPTH_WRITE_MASK_ALL // 깊이 쓰기 활성화 };

enum D3D11_COMPARISON_FUNC { D3D11_COMPARISON_NEVER, // 항상 실패 D3D11_COMPARISON_LESS, // New < Old (일반적) D3D11_COMPARISON_EQUAL, // New == Old D3D11_COMPARISON_LESS_EQUAL, // New <= Old D3D11_COMPARISON_GREATER, // New > Old D3D11_COMPARISON_NOT_EQUAL, // New != Old D3D11_COMPARISON_GREATER_EQUAL, // New >= Old D3D11_COMPARISON_ALWAYS // 항상 통과 };

enum D3D11_STENCIL_OP { D3D11_STENCIL_OP_KEEP, // 유지 D3D11_STENCIL_OP_ZERO, // 0으로 설정 D3D11_STENCIL_OP_REPLACE, // 참조값으로 대체 D3D11_STENCIL_OP_INCR_SAT, // +1 (포화) D3D11_STENCIL_OP_DECR_SAT, // -1 (포화) D3D11_STENCIL_OP_INVERT, // 비트 반전 D3D11_STENCIL_OP_INCR, // +1 (래핑) D3D11_STENCIL_OP_DECR // -1 (래핑) };

struct D3D11_DEPTH_STENCILOP_DESC { D3D11_STENCIL_OP StencilFailOp; // 스텐실 테스트 실패 시 D3D11_STENCIL_OP StencilDepthFailOp; // 스텐실 통과, 깊이 실패 시 D3D11_STENCIL_OP StencilPassOp; // 둘 다 통과 시 D3D11_COMPARISON_FUNC StencilFunc; // 스텐실 비교 함수 };

// Stencil Reference Value: 스텐실 비교 및 REPLACE 연산에 사용 UINT stencilRef = 1; // Output Merger에 바인딩 context->OMSetDepthStencilState(depthStencilState, stencilRef);

enum class eDepthStencilState { Default, // 일반 3D 렌더링 DepthReadOnly, // 깊이 읽기만 (파티클, 반투명) NoDepthTest, // 깊이 테스트 없음 (UI, 스카이박스) StencilWrite, // 스텐실 쓰기 (마스크 생성) StencilRead, // 스텐실 읽기 (마스크 적용) Count }; void InitializeDepthStencilStates() { D3D11_DEPTH_STENCIL_DESC desc = {}; // 1. Default: 일반 3D 렌더링 desc.DepthEnable = TRUE; desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; desc.DepthFunc = D3D11_COMPARISON_LESS; desc.StencilEnable = FALSE; device->CreateDepthStencilState(&desc, &states[Default]); // 2. DepthReadOnly: 깊이 읽기만 (반투명 오브젝트) desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO; device->CreateDepthStencilState(&desc, &states[DepthReadOnly]); // 3. NoDepthTest: 깊이 테스트 없음 (UI) desc.DepthEnable = FALSE; desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO; device->CreateDepthStencilState(&desc, &states[NoDepthTest]); // 4. StencilWrite: 스텐실 버퍼에 마스크 작성 desc.DepthEnable = TRUE; desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; desc.StencilEnable = TRUE; desc.StencilWriteMask = 0xFF; desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_REPLACE; // 참조값으로 대체 desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; desc.BackFace = desc.FrontFace; device->CreateDepthStencilState(&desc, &states[StencilWrite]); // 5. StencilRead: 스텐실 마스크 영역만 렌더링 desc.FrontFace.StencilFunc = D3D11_COMPARISON_EQUAL; // 참조값과 같으면 통과 desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; // 유지 device->CreateDepthStencilState(&desc, &states[StencilRead]); }

void RenderTransparentObjects(const std::vector<GameObject*>& transparentObjects) { // 1. 불투명 오브젝트를 먼저 렌더링 (일반 State) RenderOpaqueObjects(); // 2. 투명 오브젝트는 깊이 쓰기 비활성화 + 알파 블렌딩 BindDepthStencilState(eDepthStencilState::DepthReadOnly); BindBlendState(eBlendState::AlphaBlend); // 3. 뒤에서 앞으로 정렬 (Painter's Algorithm) std::vector<GameObject*> sorted = transparentObjects; SortBackToFront(sorted, camera->GetPosition()); // 4. 양면 렌더링 (투명 오브젝트는 뒷면도 보임) BindRasterizerState(eRasterizerState::SolidNone); // 5. 렌더링 for (auto& obj : sorted) { obj->Render(); } // 6. State 복원 BindDepthStencilState(eDepthStencilState::Default); BindBlendState(eBlendState::Default); BindRasterizerState(eRasterizerState::SolidBack); }

void RenderParticles(ParticleSystem* particles) { // 가산 블렌딩 (밝게 겹침) BindBlendState(eBlendState::Additive); // 깊이 읽기만 (뒤에 가려지되, 깊이는 쓰지 않음) BindDepthStencilState(eDepthStencilState::DepthReadOnly); // 양면 렌더링 BindRasterizerState(eRasterizerState::SolidNone); // 파티클 렌더링 particles->Render(); // State 복원 BindBlendState(eBlendState::Default); BindDepthStencilState(eDepthStencilState::Default); BindRasterizerState(eRasterizerState::SolidBack); }

void RenderObjectWithOutline(GameObject* obj, Color outlineColor) { // 1단계: 스텐실 버퍼에 오브젝트 마스크 작성 BindDepthStencilState(eDepthStencilState::StencilWrite); context->OMSetDepthStencilState(states[StencilWrite].Get(), 1); // Ref = 1 obj->Render(); // 2단계: 약간 확대된 오브젝트를 스텐실 마스크 밖에만 렌더링 BindDepthStencilState(eDepthStencilState::StencilRead); context->OMSetDepthStencilState(states[StencilRead].Get(), 0); // Ref = 0 (1과 다른 영역) // 스케일 약간 증가 obj->GetTransform()->SetScale(obj->GetScale() * 1.05f); // 단색 셰이더로 아웃라인 렌더링 Shader* outlineShader = Resources::Find<Shader>(L"OutlineShader"); outlineShader->SetColor(outlineColor); outlineShader->Bind(); obj->Render(); // 3단계: 원래대로 복원 obj->GetTransform()->SetScale(obj->GetScale() / 1.05f); BindDepthStencilState(eDepthStencilState::Default); }

void RenderUI() { // 깊이 테스트 비활성화 (항상 최상단에 표시) BindDepthStencilState(eDepthStencilState::NoDepthTest); // 알파 블렌딩 BindBlendState(eBlendState::AlphaBlend); // 양면 렌더링 (UI는 보통 평면) BindRasterizerState(eRasterizerState::SolidNone); // UI 요소들 렌더링 for (auto& uiElement : uiElements) { uiElement->Render(); } // State 복원 BindDepthStencilState(eDepthStencilState::Default); BindBlendState(eBlendState::Default); BindRasterizerState(eRasterizerState::SolidBack); }

// 나쁜 예: State를 자주 변경 for (auto& obj : allObjects) { obj->BindStates(); // 매번 State 변경 obj->Render(); } // 좋은 예: State별로 그룹화 for (auto state : allStates) { BindState(state); for (auto& obj : objectsByState[state]) { obj->Render(); // State 변경 없음 } }

// 불투명 오브젝트: 앞에서 뒤로 정렬 (Early-Z 최적화) SortFrontToBack(opaqueObjects, cameraPos); // 투명 오브젝트: 뒤에서 앞으로 정렬 (정확한 블렌딩) SortBackToFront(transparentObjects, cameraPos);

void RenderWithDepthPrepass() { // 1단계: 깊이만 렌더링 (색상 쓰기 비활성화) D3D11_BLEND_DESC noColorWrite = {}; noColorWrite.RenderTarget[0].RenderTargetWriteMask = 0; // 색상 쓰기 안 함 BindBlendState(noColorWriteState); RenderOpaqueObjects(); // 2단계: 깊이 읽기 전용으로 색상 렌더링 BindDepthStencilState(eDepthStencilState::DepthReadOnly); BindBlendState(eBlendState::Default); RenderOpaqueObjects(); // 픽셀 셰이더는 앞면만 실행됨 }