Scene View(씬 뷰)

// 문제: 스왑체인 백버퍼는 전체 화면에만 렌더링 가능 // ImGui 창 내부에는 렌더링 불가능 // 해결: 별도의 텍스처에 렌더링 후 ImGui에 표시 RenderTarget* sceneViewTarget = RenderTarget::Create(spec); sceneViewTarget->Bind(); // 씬 렌더링... sceneViewTarget->Unbind(); // ImGui 창에서 텍스처 표시 ImGui::Image(sceneViewTarget->GetTexture(), size);

enum class eRenderTargetFormat { None = 0, RGBA8, // 8비트 RGBA 색상 RED_INTEGER, // 정수형 RED 채널 (오브젝트 ID 저장) DEPTH24STENCIL8, // 24비트 깊이 + 8비트 스텐실 SHADER_RESOURCE, // 셰이더에서 읽을 수 있는 범용 포맷 Depth = DEPTH24STENCIL8 };

// 오브젝트 ID를 RED_INTEGER 포맷 렌더 타겟에 저장 pixelShaderOutput.objectID = entityID; // 1, 2, 3, ... // 마우스 클릭 시 오브젝트 ID 읽기 int clickedObjectID = renderTarget->ReadPixel(0, mouseX, mouseY);

struct RenderTargetTextureSpecification { eRenderTargetFormat TextureFormat = eRenderTargetFormat::None; // 향후 확장 가능: 필터링, 래핑 모드 등 }; struct RenderTargetAttachmentSpecification { std::vector<RenderTargetTextureSpecification> Attachments; }; struct RenderTargetSpecification { UINT Width = 0, Height = 0; RenderTargetAttachmentSpecification Attachments; UINT Samples = 1; // MSAA 샘플 수 bool SwapChainTarget = false; // 스왑체인 백버퍼 사용 여부 };

// Scene View용 렌더 타겟 생성 RenderTargetSpecification sceneSpec; sceneSpec.Width = 1280; sceneSpec.Height = 720; sceneSpec.Attachments.Attachments = { { eRenderTargetFormat::RGBA8 }, // 색상 { eRenderTargetFormat::RED_INTEGER }, // 오브젝트 ID { eRenderTargetFormat::DEPTH24STENCIL8} // 깊이 }; RenderTarget* sceneViewRT = RenderTarget::Create(sceneSpec);

class RenderTarget { public: RenderTarget(const RenderTargetSpecification& spec); virtual ~RenderTarget(); // 정적 생성 함수 static RenderTarget* Create(const RenderTargetSpecification& spec); // 렌더 타겟 재생성 void Invalidate(); // 바인딩 (렌더링 대상으로 설정) void Bind(); void Unbind(); // 크기 조정 void Resize(UINT width, UINT height); // 픽셀 데이터 읽기 int ReadPixel(uint32_t attachmentIndex, int x, int y); // 첨부물 초기화 void ClearAttachment(UINT index, const void* value); // 텍스처 접근 Texture* GetAttachmentTexture(UINT index); // 사양 접근 RenderTargetSpecification& GetSpecification() { return mSpecification; } private: RenderTargetSpecification mSpecification; // 색상 첨부물 std::vector<RenderTargetTextureSpecification> mColorAttachmentSpecifications; std::vector<Texture*> mColorAttachments; // 깊이 첨부물 RenderTargetTextureSpecification mDepthAttachmentSpecification; Texture* mDepthAttachment = nullptr; };

void RenderTarget::Invalidate() { // 1. 기존 리소스 해제 for (auto* attachment : mColorAttachments) { if (attachment) delete attachment; } mColorAttachments.clear(); if (mDepthAttachment) { delete mDepthAttachment; mDepthAttachment = nullptr; } // 2. 색상 첨부물 생성 for (const auto& spec : mColorAttachmentSpecifications) { Texture* colorTexture = CreateColorTexture( mSpecification.Width, mSpecification.Height, spec.TextureFormat ); mColorAttachments.push_back(colorTexture); } // 3. 깊이 첨부물 생성 if (mDepthAttachmentSpecification.TextureFormat != eRenderTargetFormat::None) { mDepthAttachment = CreateDepthTexture( mSpecification.Width, mSpecification.Height, mDepthAttachmentSpecification.TextureFormat ); } }

Texture* RenderTarget::CreateColorTexture( UINT width, UINT height, eRenderTargetFormat format) { // DirectX 텍스처 설명 D3D11_TEXTURE2D_DESC textureDesc = {}; textureDesc.Width = width; textureDesc.Height = height; textureDesc.MipLevels = 1; textureDesc.ArraySize = 1; textureDesc.SampleDesc.Count = mSpecification.Samples; textureDesc.SampleDesc.Quality = 0; textureDesc.Usage = D3D11_USAGE_DEFAULT; textureDesc.CPUAccessFlags = 0; // 포맷 설정 switch (format) { case eRenderTargetFormat::RGBA8: textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE; break; case eRenderTargetFormat::RED_INTEGER: textureDesc.Format = DXGI_FORMAT_R32_SINT; textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE; break; // ... 기타 포맷 } // 텍스처 생성 ID3D11Texture2D* d3dTexture = nullptr; HRESULT hr = device->CreateTexture2D(&textureDesc, nullptr, &d3dTexture); // RTV (Render Target View) 생성 ID3D11RenderTargetView* rtv = nullptr; hr = device->CreateRenderTargetView(d3dTexture, nullptr, &rtv); // SRV (Shader Resource View) 생성 ID3D11ShaderResourceView* srv = nullptr; hr = device->CreateShaderResourceView(d3dTexture, nullptr, &srv); // Texture 래퍼 객체 생성 Texture* texture = new Texture(); texture->SetD3DTexture(d3dTexture); texture->SetRTV(rtv); texture->SetSRV(srv); return texture; }

Texture* RenderTarget::CreateDepthTexture( UINT width, UINT height, eRenderTargetFormat format) { D3D11_TEXTURE2D_DESC depthDesc = {}; depthDesc.Width = width; depthDesc.Height = height; depthDesc.MipLevels = 1; depthDesc.ArraySize = 1; depthDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthDesc.SampleDesc.Count = mSpecification.Samples; depthDesc.SampleDesc.Quality = 0; depthDesc.Usage = D3D11_USAGE_DEFAULT; depthDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; depthDesc.CPUAccessFlags = 0; ID3D11Texture2D* depthTexture = nullptr; device->CreateTexture2D(&depthDesc, nullptr, &depthTexture); // DSV (Depth Stencil View) 생성 ID3D11DepthStencilView* dsv = nullptr; device->CreateDepthStencilView(depthTexture, nullptr, &dsv); Texture* texture = new Texture(); texture->SetD3DTexture(depthTexture); texture->SetDSV(dsv); return texture; }

void RenderTarget::Bind() { // 1. RTV 배열 준비 std::vector<ID3D11RenderTargetView*> rtvs; for (auto* attachment : mColorAttachments) { rtvs.push_back(attachment->GetRTV().Get()); } // 2. DSV 가져오기 ID3D11DepthStencilView* dsv = mDepthAttachment ? mDepthAttachment->GetDSV().Get() : nullptr; // 3. 렌더 타겟 설정 deviceContext->OMSetRenderTargets( static_cast<UINT>(rtvs.size()), rtvs.data(), dsv ); // 4. 뷰포트 설정 D3D11_VIEWPORT viewport = {}; viewport.TopLeftX = 0.0f; viewport.TopLeftY = 0.0f; viewport.Width = static_cast<float>(mSpecification.Width); viewport.Height = static_cast<float>(mSpecification.Height); viewport.MinDepth = 0.0f; viewport.MaxDepth = 1.0f; deviceContext->RSSetViewports(1, &viewport); }

void RenderTarget::Resize(UINT width, UINT height) { // 크기가 변경되지 않았으면 무시 if (mSpecification.Width == width && mSpecification.Height == height) return; // 사양 업데이트 mSpecification.Width = width; mSpecification.Height = height; // 리소스 재생성 Invalidate(); }

int RenderTarget::ReadPixel(uint32_t attachmentIndex, int x, int y) { assert(attachmentIndex < mColorAttachments.size()); Texture* texture = mColorAttachments[attachmentIndex]; // 1. Staging 텍스처 생성 (CPU에서 읽을 수 있는 텍스처) D3D11_TEXTURE2D_DESC stagingDesc = {}; stagingDesc.Width = 1; stagingDesc.Height = 1; stagingDesc.MipLevels = 1; stagingDesc.ArraySize = 1; stagingDesc.Format = DXGI_FORMAT_R32_SINT; // RED_INTEGER 포맷 stagingDesc.SampleDesc.Count = 1; stagingDesc.Usage = D3D11_USAGE_STAGING; stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; ID3D11Texture2D* stagingTexture = nullptr; device->CreateTexture2D(&stagingDesc, nullptr, &stagingTexture); // 2. 픽셀 복사 D3D11_BOX sourceRegion = {}; sourceRegion.left = x; sourceRegion.right = x + 1; sourceRegion.top = y; sourceRegion.bottom = y + 1; sourceRegion.front = 0; sourceRegion.back = 1; deviceContext->CopySubresourceRegion( stagingTexture, 0, 0, 0, 0, texture->GetD3DTexture(), 0, &sourceRegion ); // 3. CPU에서 데이터 읽기 D3D11_MAPPED_SUBRESOURCE mappedResource = {}; deviceContext->Map(stagingTexture, 0, D3D11_MAP_READ, 0, &mappedResource); int pixelValue = *static_cast<int*>(mappedResource.pData); deviceContext->Unmap(stagingTexture, 0); stagingTexture->Release(); return pixelValue; }

void RenderTarget::ClearAttachment(UINT index, const void* value) { assert(index < mColorAttachments.size()); Texture* texture = mColorAttachments[index]; // 정수형 포맷인 경우 if (mColorAttachmentSpecifications[index].TextureFormat == eRenderTargetFormat::RED_INTEGER) { UINT clearValue[4] = { *static_cast<const int*>(value), 0, 0, 0 }; deviceContext->ClearRenderTargetView(texture->GetRTV().Get(), reinterpret_cast<const float*>(clearValue)); } // 실수형 포맷인 경우 else { float clearColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; if (value) memcpy(clearColor, value, sizeof(float) * 4); deviceContext->ClearRenderTargetView(texture->GetRTV().Get(), clearColor); } }

void Application::ResizeGraphicDevice() { // 그래픽 디바이스가 없으면 무시 if (mGraphicDevice == nullptr) return; // 1. 윈도우 클라이언트 영역 크기 가져오기 RECT winRect; ::GetClientRect(mHwnd, &winRect); // 2. 뷰포트 설정 D3D11_VIEWPORT viewport = {}; viewport.TopLeftX = 0.0f; viewport.TopLeftY = 0.0f; viewport.Width = static_cast<float>(winRect.right - winRect.left); viewport.Height = static_cast<float>(winRect.bottom - winRect.top); viewport.MinDepth = 0.0f; viewport.MaxDepth = 1.0f; // 3. 애플리케이션 크기 저장 mWidth = static_cast<UINT>(viewport.Width); mHeight = static_cast<UINT>(viewport.Height); // 4. 그래픽 디바이스 리소스 조정 mGraphicDevice->Resize(viewport); // 5. 프레임 버퍼 크기 조정 if (renderer::FrameBuffer) { renderer::FrameBuffer->Resize(mWidth, mHeight); } }

void GraphicDevice_DX11::Resize(const D3D11_VIEWPORT& viewport) { // 1. 기존 RTV와 DSV 해제 mContext->OMSetRenderTargets(0, nullptr, nullptr); if (mRenderTargetView) { mRenderTargetView->Release(); mRenderTargetView = nullptr; } if (mDepthStencilView) { mDepthStencilView->Release(); mDepthStencilView = nullptr; } // 2. 스왑체인 버퍼 크기 조정 HRESULT hr = mSwapChain->ResizeBuffers( 0, // 버퍼 수 유지 static_cast<UINT>(viewport.Width), static_cast<UINT>(viewport.Height), DXGI_FORMAT_UNKNOWN, // 포맷 유지 0 ); if (FAILED(hr)) { LOG_ERROR("Failed to resize swap chain buffers"); return; } // 3. 새 백버퍼로 RTV 재생성 ID3D11Texture2D* backBuffer = nullptr; mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBuffer); mDevice->CreateRenderTargetView(backBuffer, nullptr, &mRenderTargetView); backBuffer->Release(); // 4. 새 깊이 스텐실 버퍼 생성 D3D11_TEXTURE2D_DESC depthDesc = {}; depthDesc.Width = static_cast<UINT>(viewport.Width); depthDesc.Height = static_cast<UINT>(viewport.Height); depthDesc.MipLevels = 1; depthDesc.ArraySize = 1; depthDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthDesc.SampleDesc.Count = 1; depthDesc.Usage = D3D11_USAGE_DEFAULT; depthDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; ID3D11Texture2D* depthStencilBuffer = nullptr; mDevice->CreateTexture2D(&depthDesc, nullptr, &depthStencilBuffer); mDevice->CreateDepthStencilView(depthStencilBuffer, nullptr, &mDepthStencilView); depthStencilBuffer->Release(); // 5. 뷰포트 설정 mViewport = viewport; mContext->RSSetViewports(1, &mViewport); }

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_SIZE: { // 최소화 상태는 무시 if (wParam == SIZE_MINIMIZED) break; // 크기 조정 application.ResizeGraphicDevice(); break; } case WM_EXITSIZEMOVE: { // 크기 조정 완료 시 최종 업데이트 application.ResizeGraphicDevice(); break; } // ... 기타 메시지 처리 } return DefWindowProc(hwnd, message, wParam, lParam); }

// 성능 최적화 버전 bool resizePending = false; case WM_SIZE: resizePending = true; break; // 메인 루프에서 if (resizePending) { application.ResizeGraphicDevice(); resizePending = false; }

void EditorLayer::OnImGuiRender() { // 1. 스타일 설정 (패딩 제거) ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2{ 0, 0 }); // 2. Scene View 창 시작 ImGui::Begin("Scene"); // 3. 뷰포트 좌표 및 크기 계산 CalculateViewportBounds(); // 4. 뷰포트 상태 확인 UpdateViewportState(); // 5. 렌더 타겟 크기 조정 ResizeViewportIfNeeded(); // 6. 씬을 렌더 타겟에 렌더링 RenderSceneToTarget(); // 7. 렌더 타겟 텍스처를 ImGui에 표시 DisplayRenderTarget(); // 8. 드래그 앤 드롭 처리 HandleDragAndDrop(); // 9. 마우스 픽킹 처리 HandleMousePicking(); // 10. 기즈모 렌더링 RenderGizmo(); // 11. Scene View 창 종료 ImGui::End(); // 12. 스타일 복구 ImGui::PopStyleVar(); }

void EditorLayer::CalculateViewportBounds() { // 창 내부의 콘텐츠 영역 가져오기 ImVec2 viewportMinRegion = ImGui::GetWindowContentRegionMin(); ImVec2 viewportMaxRegion = ImGui::GetWindowContentRegionMax(); // 창의 화면 상 위치 ImVec2 viewportOffset = ImGui::GetWindowPos(); // 절대 좌표 계산 mViewportBounds[0] = { viewportMinRegion.x + viewportOffset.x, viewportMinRegion.y + viewportOffset.y }; mViewportBounds[1] = { viewportMaxRegion.x + viewportOffset.x, viewportMaxRegion.y + viewportOffset.y }; }

void EditorLayer::UpdateViewportState() { // 포커스 확인: 키보드 입력 받을 수 있는지 mViewportFocused = ImGui::IsWindowFocused(); // 호버 확인: 마우스가 창 위에 있는지 mViewportHovered = ImGui::IsWindowHovered(); // 입력 블로킹 설정 Application::Get().GetImGuiLayer()->BlockEvents(!mViewportFocused && !mViewportHovered); }

// Scene View 창 밖에서 클릭했을 때 if (!mViewportHovered) { // ImGui가 이벤트를 먼저 처리 // → 다른 패널 클릭, 버튼 클릭 등 } else { // Scene View에서 마우스 클릭 // → 오브젝트 선택, 카메라 이동 등 }

void EditorLayer::ResizeViewportIfNeeded() { // 현재 사용 가능한 콘텐츠 영역 크기 ImVec2 viewportPanelSize = ImGui::GetContentRegionAvail(); // 크기가 변경되었는지 확인 if (mViewportSize.x != viewportPanelSize.x || mViewportSize.y != viewportPanelSize.y) { // 유효한 크기인지 확인 (0은 무시) if (viewportPanelSize.x > 0 && viewportPanelSize.y > 0) { mViewportSize = { viewportPanelSize.x, viewportPanelSize.y }; // 렌더 타겟 크기 조정 mFrameBuffer->Resize( static_cast<UINT>(mViewportSize.x), static_cast<UINT>(mViewportSize.y) ); // 카메라 종횡비 업데이트 mEditorCamera.SetViewportSize(mViewportSize.x, mViewportSize.y); } } }

void EditorLayer::RenderSceneToTarget() { // 1. 렌더 타겟 바인딩 mFrameBuffer->Bind(); // 2. 렌더 타겟 초기화 float clearColor[4] = { 0.1f, 0.1f, 0.1f, 1.0f }; mFrameBuffer->ClearAttachment(0, clearColor); // 오브젝트 ID 버퍼 초기화 (-1로) int clearID = -1; mFrameBuffer->ClearAttachment(1, &clearID); // 3. 카메라 설정 mEditorCamera.OnUpdate(deltaTime); // 4. 씬 렌더링 Renderer::BeginScene(mEditorCamera); // 모든 엔티티 렌더링 auto view = mActiveScene->GetAllEntitiesWith<TransformComponent, MeshComponent>(); for (auto entity : view) { auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(entity); // 오브젝트 ID를 셰이더에 전달 Renderer::SetEntityID(static_cast<int>(entity)); // 메쉬 렌더링 Renderer::DrawMesh(transform.GetTransform(), mesh); } Renderer::EndScene(); // 5. 렌더 타겟 언바인딩 mFrameBuffer->Unbind(); }

void EditorLayer::DisplayRenderTarget() { // 색상 첨부물 가져오기 Texture* colorTexture = mFrameBuffer->GetAttachmentTexture(0); // ImGui 이미지로 표시 ImGui::Image( (ImTextureID)colorTexture->GetSRV().Get(), // 텍스처 ImVec2{ mViewportSize.x, mViewportSize.y }, // 크기 ImVec2{ 0, 0 }, // UV 시작 ImVec2{ 1, 1 } // UV 끝 ); }

void EditorLayer::HandleDragAndDrop() { // 드롭 타겟으로 설정 if (ImGui::BeginDragDropTarget()) { // "PROJECT_ITEM" 페이로드 수락 if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("PROJECT_ITEM")) { // 파일 경로 가져오기 const wchar_t* path = (const wchar_t*)payload->Data; // 파일 확장자 확인 std::wstring pathStr(path); if (pathStr.ends_with(L".scene")) { // 씬 파일 열기 OpenScene(path); } else if (pathStr.ends_with(L".prefab")) { // 프리팹 인스턴스 생성 InstantiatePrefab(path); } else if (pathStr.ends_with(L".fbx") || pathStr.ends_with(L".obj")) { // 3D 모델 임포트 ImportModel(path); } } ImGui::EndDragDropTarget(); } }

void EditorLayer::HandleMousePicking() { // Scene View에 포커스되어 있고 마우스가 위에 있을 때만 if (!mViewportHovered || !ImGui::IsMouseClicked(ImGuiMouseButton_Left)) return; // 1. 마우스 위치 가져오기 ImVec2 mousePos = ImGui::GetMousePos(); // 2. 뷰포트 상대 좌표로 변환 float mouseX = mousePos.x - mViewportBounds[0].x; float mouseY = mousePos.y - mViewportBounds[0].y; // 3. 범위 체크 if (mouseX >= 0 && mouseX < mViewportSize.x && mouseY >= 0 && mouseY < mViewportSize.y) { // 4. 오브젝트 ID 읽기 int entityID = mFrameBuffer->ReadPixel(1, (int)mouseX, (int)mouseY); // 5. 엔티티 선택 if (entityID >= 0) { SelectEntity(entityID); } else { // 빈 공간 클릭 시 선택 해제 DeselectEntity(); } } }

void EditorLayer::ResizeViewportIfNeeded() { ImVec2 viewportPanelSize = ImGui::GetContentRegionAvail(); // 작은 변화는 무시 (1픽셀 차이 무시) float widthDiff = abs(mViewportSize.x - viewportPanelSize.x); float heightDiff = abs(mViewportSize.y - viewportPanelSize.y); if (widthDiff < 1.0f && heightDiff < 1.0f) return; // 일정 크기 이상만 처리 if (viewportPanelSize.x < 32 || viewportPanelSize.y < 32) return; // 크기 조정 mViewportSize = { viewportPanelSize.x, viewportPanelSize.y }; mFrameBuffer->Resize( static_cast<UINT>(mViewportSize.x), static_cast<UINT>(mViewportSize.y) ); }

void EditorLayer::OnUpdate(float deltaTime) { // Scene View가 보이지 않으면 렌더링 스킵 if (!mSceneViewVisible || mViewportSize.x == 0 || mViewportSize.y == 0) return; // 씬 렌더링... }

// 매 프레임 읽지 않고 마우스 클릭 시에만 읽기 if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) { int entityID = mFrameBuffer->ReadPixel(1, mouseX, mouseY); // ... } // 또는 비동기로 읽기 (다음 프레임에서 결과 받기) RequestPixelRead(1, mouseX, mouseY, [this](int entityID) { SelectEntity(entityID); });

void EditorLayer::DebugRenderTargets() { ImGui::Begin("Debug Render Targets"); // 각 첨부물 표시 for (int i = 0; i < mFrameBuffer->GetAttachmentCount(); i++) { Texture* texture = mFrameBuffer->GetAttachmentTexture(i); ImGui::Text("Attachment %d", i); ImGui::Image( (ImTextureID)texture->GetSRV().Get(), ImVec2{ 256, 256 } ); } ImGui::End(); }

void EditorLayer::DisplayViewportInfo() { ImGui::Begin("Viewport Info"); ImGui::Text("Size: %.0f x %.0f", mViewportSize.x, mViewportSize.y); ImGui::Text("Bounds: (%.0f, %.0f) to (%.0f, %.0f)", mViewportBounds[0].x, mViewportBounds[0].y, mViewportBounds[1].x, mViewportBounds[1].y); ImGui::Text("Focused: %s", mViewportFocused ? "Yes" : "No"); ImGui::Text("Hovered: %s", mViewportHovered ? "Yes" : "No"); ImGui::End(); }