From b5ba985831901d5a12535d414675dade41ec5723 Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Fri, 10 Apr 2026 01:57:15 +0800 Subject: [PATCH] Formalize render object id contract --- editor/src/Viewport/ViewportObjectIdPicker.h | 6 +- .../Rendering/FrameData/VisibleRenderItem.h | 2 + .../Rendering/Passes/BuiltinObjectIdPass.h | 15 +- .../Passes/BuiltinSelectionMaskPass.h | 3 +- .../Rendering/Picking/ObjectIdCodec.h | 50 ++++-- .../Extraction/RenderSceneUtility.cpp | 13 ++ .../Passes/BuiltinObjectIdOutlinePass.cpp | 148 ++++++++++++------ .../Passes/BuiltinObjectIdPassResources.cpp | 83 +++++++--- .../Passes/BuiltinSelectionMaskPass.cpp | 18 ++- .../integration/object_id_scene/main.cpp | 4 +- .../unit/test_object_id_encoding.cpp | 38 +++-- .../unit/test_render_scene_utility.cpp | 4 + 12 files changed, 282 insertions(+), 102 deletions(-) diff --git a/editor/src/Viewport/ViewportObjectIdPicker.h b/editor/src/Viewport/ViewportObjectIdPicker.h index 5738856c..98eccda6 100644 --- a/editor/src/Viewport/ViewportObjectIdPicker.h +++ b/editor/src/Viewport/ViewportObjectIdPicker.h @@ -42,6 +42,7 @@ enum class ViewportObjectIdPickStatus : uint8_t { struct ViewportObjectIdPickResult { ViewportObjectIdPickStatus status = ViewportObjectIdPickStatus::Unavailable; + Rendering::RenderObjectId renderObjectId = Rendering::kInvalidRenderObjectId; uint64_t entityId = 0; bool HasResolvedSample() const { @@ -101,11 +102,12 @@ ViewportObjectIdPickResult PickViewportObjectIdEntity( } result.status = ViewportObjectIdPickStatus::Success; - result.entityId = static_cast(Rendering::DecodeObjectIdFromColor( + result.renderObjectId = Rendering::DecodeRenderObjectIdFromColor( rgba[0], rgba[1], rgba[2], - rgba[3])); + rgba[3]); + result.entityId = Rendering::ConvertRenderObjectIdToRuntimeObjectId(result.renderObjectId); return result; } diff --git a/engine/include/XCEngine/Rendering/FrameData/VisibleRenderItem.h b/engine/include/XCEngine/Rendering/FrameData/VisibleRenderItem.h index 8e4e4e30..21abe9a0 100644 --- a/engine/include/XCEngine/Rendering/FrameData/VisibleRenderItem.h +++ b/engine/include/XCEngine/Rendering/FrameData/VisibleRenderItem.h @@ -2,6 +2,7 @@ #include #include +#include #include namespace XCEngine { @@ -19,6 +20,7 @@ struct VisibleRenderItem { Components::MeshRendererComponent* meshRenderer = nullptr; Resources::Mesh* mesh = nullptr; const Resources::Material* material = nullptr; + RenderObjectId renderObjectId = kInvalidRenderObjectId; Core::uint32 materialIndex = 0; Core::uint32 sectionIndex = 0; bool hasSection = false; diff --git a/engine/include/XCEngine/Rendering/Passes/BuiltinObjectIdPass.h b/engine/include/XCEngine/Rendering/Passes/BuiltinObjectIdPass.h index 6430fff5..d92f2020 100644 --- a/engine/include/XCEngine/Rendering/Passes/BuiltinObjectIdPass.h +++ b/engine/include/XCEngine/Rendering/Passes/BuiltinObjectIdPass.h @@ -43,11 +43,15 @@ private: RHI::RHIDescriptorSet* set = nullptr; }; - bool EnsureInitialized(const RenderContext& context); - bool CreateResources(const RenderContext& context); + bool EnsureInitialized( + const RenderContext& context, + const RenderSurface& surface); + bool CreateResources( + const RenderContext& context, + const RenderSurface& surface); void DestroyResources(); - RHI::RHIDescriptorSet* GetOrCreatePerObjectSet(uint64_t objectId); + RHI::RHIDescriptorSet* GetOrCreatePerObjectSet(RenderObjectId objectId); void DestroyOwnedDescriptorSet(OwnedDescriptorSet& descriptorSet); bool DrawVisibleItem( const RenderContext& context, @@ -61,9 +65,12 @@ private: PassResourceBindingLocation m_perObjectBinding = {}; BuiltinPassSetLayoutMetadata m_perObjectSetLayout = {}; Core::uint32 m_firstDescriptorSet = 0; + RHI::Format m_renderTargetFormat = RHI::Format::Unknown; + RHI::Format m_depthStencilFormat = RHI::Format::Unknown; + uint32_t m_renderTargetSampleCount = 1u; Resources::ResourceHandle m_builtinObjectIdShader; RenderResourceCache m_resourceCache; - std::unordered_map m_perObjectSets; + std::unordered_map m_perObjectSets; }; } // namespace Passes diff --git a/engine/include/XCEngine/Rendering/Passes/BuiltinSelectionMaskPass.h b/engine/include/XCEngine/Rendering/Passes/BuiltinSelectionMaskPass.h index 12c5c43a..65e63cc8 100644 --- a/engine/include/XCEngine/Rendering/Passes/BuiltinSelectionMaskPass.h +++ b/engine/include/XCEngine/Rendering/Passes/BuiltinSelectionMaskPass.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include @@ -32,7 +33,7 @@ protected: bool ShouldRenderVisibleItem(const VisibleRenderItem& visibleItem) const override; private: - std::vector m_selectedObjectIds = {}; + std::vector m_selectedObjectIds = {}; }; } // namespace Passes diff --git a/engine/include/XCEngine/Rendering/Picking/ObjectIdCodec.h b/engine/include/XCEngine/Rendering/Picking/ObjectIdCodec.h index 026c2ea8..a3b8a52e 100644 --- a/engine/include/XCEngine/Rendering/Picking/ObjectIdCodec.h +++ b/engine/include/XCEngine/Rendering/Picking/ObjectIdCodec.h @@ -3,27 +3,51 @@ #include #include +#include + namespace XCEngine { namespace Rendering { -using EncodedObjectId = Core::uint32; +using RenderObjectId = Core::uint32; +using EncodedObjectId = RenderObjectId; -// Object-id render targets store only the low 32 bits of a runtime object id. -// This codec is for editor/runtime picking surfaces, not for persistent ids. -inline bool CanEncodeObjectIdWithoutLoss(Core::uint64 objectId) { - return (objectId & 0xFFFFFFFF00000000ull) == 0ull; +static constexpr RenderObjectId kInvalidRenderObjectId = 0u; + +inline bool IsValidRenderObjectId(RenderObjectId renderObjectId) { + return renderObjectId != kInvalidRenderObjectId; } -inline EncodedObjectId EncodeObjectIdToEncodedId(Core::uint64 objectId) { - return static_cast(objectId & 0xFFFFFFFFull); +inline bool CanConvertRuntimeObjectIdToRenderObjectId(Core::uint64 runtimeObjectId) { + return runtimeObjectId != 0u && + runtimeObjectId <= static_cast(std::numeric_limits::max()); } -inline EncodedObjectId EncodeObjectIdToUInt32(Core::uint64 objectId) { - return EncodeObjectIdToEncodedId(objectId); +inline bool TryConvertRuntimeObjectIdToRenderObjectId( + Core::uint64 runtimeObjectId, + RenderObjectId& outRenderObjectId) { + outRenderObjectId = kInvalidRenderObjectId; + if (!CanConvertRuntimeObjectIdToRenderObjectId(runtimeObjectId)) { + return false; + } + + outRenderObjectId = static_cast(runtimeObjectId); + return true; } -inline Math::Vector4 EncodeObjectIdToColor(Core::uint64 objectId) { - const EncodedObjectId encodedId = EncodeObjectIdToEncodedId(objectId); +inline Core::uint64 ConvertRenderObjectIdToRuntimeObjectId(RenderObjectId renderObjectId) { + return static_cast(renderObjectId); +} + +inline EncodedObjectId EncodeRenderObjectIdToEncodedId(RenderObjectId renderObjectId) { + return renderObjectId; +} + +inline EncodedObjectId EncodeRenderObjectIdToUInt32(RenderObjectId renderObjectId) { + return EncodeRenderObjectIdToEncodedId(renderObjectId); +} + +inline Math::Vector4 EncodeRenderObjectIdToColor(RenderObjectId renderObjectId) { + const EncodedObjectId encodedId = EncodeRenderObjectIdToEncodedId(renderObjectId); constexpr float kInv255 = 1.0f / 255.0f; return Math::Vector4( static_cast((encodedId >> 0) & 0xFFu) * kInv255, @@ -43,12 +67,12 @@ inline EncodedObjectId DecodeEncodedObjectIdFromColor( (static_cast(a) << 24u); } -inline Core::uint64 DecodeObjectIdFromColor( +inline RenderObjectId DecodeRenderObjectIdFromColor( Core::uint8 r, Core::uint8 g, Core::uint8 b, Core::uint8 a) { - return static_cast(DecodeEncodedObjectIdFromColor(r, g, b, a)); + return DecodeEncodedObjectIdFromColor(r, g, b, a); } } // namespace Rendering diff --git a/engine/src/Rendering/Extraction/RenderSceneUtility.cpp b/engine/src/Rendering/Extraction/RenderSceneUtility.cpp index cb524c95..525d3d23 100644 --- a/engine/src/Rendering/Extraction/RenderSceneUtility.cpp +++ b/engine/src/Rendering/Extraction/RenderSceneUtility.cpp @@ -15,6 +15,16 @@ namespace XCEngine { namespace Rendering { +namespace { + +RenderObjectId BuildRenderObjectIdOrInvalid(const Components::GameObject& gameObject) { + RenderObjectId renderObjectId = kInvalidRenderObjectId; + TryConvertRuntimeObjectIdToRenderObjectId(gameObject.GetID(), renderObjectId); + return renderObjectId; +} + +} // namespace + RenderCameraData BuildRenderCameraData( const Components::CameraComponent& camera, uint32_t viewportWidth, @@ -89,6 +99,7 @@ void AppendRenderItemsForGameObject( const Math::Matrix4x4 localToWorld = gameObject.GetTransform()->GetLocalToWorldMatrix(); const Math::Vector3 worldPosition = localToWorld.GetTranslation(); const float cameraDistanceSq = (worldPosition - cameraPosition).SqrMagnitude(); + const RenderObjectId renderObjectId = BuildRenderObjectIdOrInvalid(gameObject); const Containers::Array& sections = mesh->GetSections(); if (!sections.Empty()) { @@ -101,6 +112,7 @@ void AppendRenderItemsForGameObject( visibleItem.meshRenderer = meshRenderer; visibleItem.mesh = mesh; visibleItem.materialIndex = section.materialID; + visibleItem.renderObjectId = renderObjectId; visibleItem.sectionIndex = static_cast(sectionIndex); visibleItem.hasSection = true; visibleItem.material = ResolveMaterial(meshRenderer, mesh, section.materialID); @@ -117,6 +129,7 @@ void AppendRenderItemsForGameObject( visibleItem.meshFilter = meshFilter; visibleItem.meshRenderer = meshRenderer; visibleItem.mesh = mesh; + visibleItem.renderObjectId = renderObjectId; visibleItem.materialIndex = 0; visibleItem.sectionIndex = 0; visibleItem.hasSection = false; diff --git a/engine/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp b/engine/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp index fc4a9376..f0bcf3f8 100644 --- a/engine/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp +++ b/engine/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp @@ -2,9 +2,10 @@ #include "Core/Asset/ResourceManager.h" #include "Debug/Logger.h" -#include "Rendering/Picking/ObjectIdCodec.h" -#include "Rendering/Detail/ShaderVariantUtils.h" +#include "Rendering/Internal/RenderSurfacePipelineUtils.h" +#include "Rendering/Internal/ShaderVariantUtils.h" #include "Rendering/Materials/RenderMaterialStateUtils.h" +#include "Rendering/Picking/ObjectIdCodec.h" #include "RHI/RHICommandList.h" #include "RHI/RHIDevice.h" #include @@ -23,18 +24,18 @@ const Resources::ShaderPass* FindObjectIdOutlineCompatiblePass( Resources::ShaderBackend backend) { const Resources::ShaderPass* outlinePass = shader.FindPass("ObjectIdOutline"); if (outlinePass != nullptr && - ::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, outlinePass->name, backend)) { + ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, outlinePass->name, backend)) { return outlinePass; } const Resources::ShaderPass* editorOutlinePass = shader.FindPass("EditorObjectIdOutline"); if (editorOutlinePass != nullptr && - ::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, editorOutlinePass->name, backend)) { + ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, editorOutlinePass->name, backend)) { return editorOutlinePass; } if (shader.GetPassCount() > 0 && - ::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, shader.GetPasses()[0].name, backend)) { + ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, shader.GetPasses()[0].name, backend)) { return &shader.GetPasses()[0]; } @@ -45,14 +46,15 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc( RHI::RHIType backendType, RHI::RHIPipelineLayout* pipelineLayout, const Resources::Shader& shader, - const Containers::String& passName) { + const Containers::String& passName, + const RenderSurface& surface) { RHI::GraphicsPipelineDesc pipelineDesc = {}; pipelineDesc.pipelineLayout = pipelineLayout; pipelineDesc.topologyType = static_cast(RHI::PrimitiveTopologyType::Triangle); - pipelineDesc.renderTargetCount = 1; - pipelineDesc.renderTargetFormats[0] = static_cast(RHI::Format::R8G8B8A8_UNorm); + ::XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc( + surface, + pipelineDesc); pipelineDesc.depthStencilFormat = static_cast(RHI::Format::Unknown); - pipelineDesc.sampleCount = 1; const Resources::ShaderPass* shaderPass = shader.FindPass(passName); if (shaderPass != nullptr && shaderPass->hasFixedFunctionState) { @@ -74,11 +76,11 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc( ::XCEngine::Rendering::ApplyRenderState(fallbackState, pipelineDesc); } - const Resources::ShaderBackend backend = ::XCEngine::Rendering::Detail::ToShaderBackend(backendType); + const Resources::ShaderBackend backend = ::XCEngine::Rendering::Internal::ToShaderBackend(backendType); if (const Resources::ShaderStageVariant* vertexVariant = shader.FindVariant(passName, Resources::ShaderType::Vertex, backend)) { if (shaderPass != nullptr) { - ::XCEngine::Rendering::Detail::ApplyShaderStageVariant( + ::XCEngine::Rendering::Internal::ApplyShaderStageVariant( shader.GetPath(), *shaderPass, backend, @@ -89,7 +91,7 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc( if (const Resources::ShaderStageVariant* fragmentVariant = shader.FindVariant(passName, Resources::ShaderType::Fragment, backend)) { if (shaderPass != nullptr) { - ::XCEngine::Rendering::Detail::ApplyShaderStageVariant( + ::XCEngine::Rendering::Internal::ApplyShaderStageVariant( shader.GetPath(), *shaderPass, backend, @@ -128,22 +130,28 @@ void BuiltinObjectIdOutlinePass::Shutdown() { bool BuiltinObjectIdOutlinePass::Render( const RenderContext& renderContext, const RenderSurface& surface, - RHI::RHIResourceView* objectIdTextureView, + const ObjectIdOutlinePassInputs& inputs, const std::vector& selectedObjectIds, const ObjectIdOutlineStyle& style) { if (!renderContext.IsValid() || - renderContext.backendType != RHI::RHIType::D3D12 || - objectIdTextureView == nullptr || + inputs.objectIdTextureView == nullptr || selectedObjectIds.empty()) { return false; } - if (!EnsureInitialized(renderContext)) { + const std::vector& colorAttachments = surface.GetColorAttachments(); + if (!::XCEngine::Rendering::Internal::HasSingleColorAttachment(surface) || + colorAttachments.empty() || + colorAttachments[0] == nullptr) { return false; } - const std::vector& colorAttachments = surface.GetColorAttachments(); - if (colorAttachments.empty() || colorAttachments[0] == nullptr) { + const Math::RectInt renderArea = surface.GetRenderArea(); + if (renderArea.width <= 0 || renderArea.height <= 0) { + return false; + } + + if (!EnsureInitialized(renderContext, surface)) { return false; } @@ -159,39 +167,61 @@ bool BuiltinObjectIdOutlinePass::Render( style.outlineColor.b, style.outlineColor.a); - const uint32_t selectedCount = (std::min)( - static_cast(selectedObjectIds.size()), - kMaxSelectedObjectCount); + uint32_t selectedCount = 0u; + for (uint64_t selectedObjectId : selectedObjectIds) { + if (selectedCount >= kMaxSelectedObjectCount) { + break; + } + + RenderObjectId renderObjectId = kInvalidRenderObjectId; + if (!TryConvertRuntimeObjectIdToRenderObjectId(selectedObjectId, renderObjectId)) { + continue; + } + + constants.selectedObjectColors[selectedCount] = + EncodeRenderObjectIdToColor(renderObjectId); + ++selectedCount; + } + if (selectedCount == 0u) { + return false; + } + constants.selectedInfo = Math::Vector4( static_cast(selectedCount), style.debugSelectionMask ? 1.0f : 0.0f, style.outlineWidthPixels, 0.0f); - for (uint32_t index = 0; index < selectedCount; ++index) { - constants.selectedObjectColors[index] = - EncodeObjectIdToColor(selectedObjectIds[index]); - } m_constantSet->WriteConstant(0, &constants, sizeof(constants)); - m_textureSet->Update(0, objectIdTextureView); + m_textureSet->Update(0, inputs.objectIdTextureView); RHI::RHICommandList* commandList = renderContext.commandList; RHI::RHIResourceView* renderTarget = colorAttachments[0]; + if (surface.IsAutoTransitionEnabled()) { + commandList->TransitionBarrier( + renderTarget, + surface.GetColorStateAfter(), + RHI::ResourceStates::RenderTarget); + commandList->TransitionBarrier( + inputs.objectIdTextureView, + inputs.objectIdTextureState, + RHI::ResourceStates::PixelShaderResource); + } commandList->SetRenderTargets(1, &renderTarget, nullptr); const RHI::Viewport viewport = { - 0.0f, - 0.0f, - static_cast(surface.GetWidth()), - static_cast(surface.GetHeight()), + static_cast(renderArea.x), + static_cast(renderArea.y), + static_cast(renderArea.width), + static_cast(renderArea.height), 0.0f, 1.0f }; const RHI::Rect scissorRect = { - 0, - 0, - static_cast(surface.GetWidth()), - static_cast(surface.GetHeight()) + renderArea.x, + renderArea.y, + renderArea.x + renderArea.width, + renderArea.y + renderArea.height }; commandList->SetViewport(viewport); @@ -202,10 +232,27 @@ bool BuiltinObjectIdOutlinePass::Render( RHI::RHIDescriptorSet* descriptorSets[] = { m_constantSet, m_textureSet }; commandList->SetGraphicsDescriptorSets(0, 2, descriptorSets, m_pipelineLayout); commandList->Draw(3, 1, 0, 0); + commandList->EndRenderPass(); + + if (surface.IsAutoTransitionEnabled()) { + commandList->TransitionBarrier( + renderTarget, + RHI::ResourceStates::RenderTarget, + surface.GetColorStateAfter()); + commandList->TransitionBarrier( + inputs.objectIdTextureView, + RHI::ResourceStates::PixelShaderResource, + inputs.objectIdTextureState); + } + return true; } -bool BuiltinObjectIdOutlinePass::EnsureInitialized(const RenderContext& renderContext) { +bool BuiltinObjectIdOutlinePass::EnsureInitialized(const RenderContext& renderContext, const RenderSurface& surface) { + const RHI::Format renderTargetFormat = + ::XCEngine::Rendering::Internal::ResolveSurfaceColorFormat(surface, 0u); + const uint32_t renderTargetSampleCount = + ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(surface); if (m_pipelineLayout != nullptr && m_pipelineState != nullptr && m_constantPool != nullptr && @@ -213,18 +260,25 @@ bool BuiltinObjectIdOutlinePass::EnsureInitialized(const RenderContext& renderCo m_texturePool != nullptr && m_textureSet != nullptr && m_device == renderContext.device && - m_backendType == renderContext.backendType) { + m_backendType == renderContext.backendType && + m_renderTargetFormat == renderTargetFormat && + m_renderTargetSampleCount == renderTargetSampleCount) { return true; } if (HasCreatedResources()) { DestroyResources(); } - return CreateResources(renderContext); + return CreateResources(renderContext, surface); } -bool BuiltinObjectIdOutlinePass::CreateResources(const RenderContext& renderContext) { - if (!renderContext.IsValid() || renderContext.backendType != RHI::RHIType::D3D12) { +bool BuiltinObjectIdOutlinePass::CreateResources(const RenderContext& renderContext, const RenderSurface& surface) { + if (!renderContext.IsValid()) { + return false; + } + + if (!::XCEngine::Rendering::Internal::HasSingleColorAttachment(surface) || + ::XCEngine::Rendering::Internal::ResolveSurfaceColorFormat(surface, 0u) == RHI::Format::Unknown) { return false; } @@ -249,7 +303,7 @@ bool BuiltinObjectIdOutlinePass::CreateResources(const RenderContext& renderCont m_backendType = renderContext.backendType; m_builtinObjectIdOutlineShader.emplace(std::move(shader)); - const Resources::ShaderBackend backend = ::XCEngine::Rendering::Detail::ToShaderBackend(m_backendType); + const Resources::ShaderBackend backend = ::XCEngine::Rendering::Internal::ToShaderBackend(m_backendType); const Resources::ShaderPass* outlinePass = FindObjectIdOutlineCompatiblePass(*m_builtinObjectIdOutlineShader->Get(), backend); if (outlinePass == nullptr) { @@ -323,15 +377,19 @@ bool BuiltinObjectIdOutlinePass::CreateResources(const RenderContext& renderCont m_pipelineState = m_device->CreatePipelineState( CreatePipelineDesc( - m_backendType, - m_pipelineLayout, - *m_builtinObjectIdOutlineShader->Get(), - outlinePass->name)); + m_backendType, + m_pipelineLayout, + *m_builtinObjectIdOutlineShader->Get(), + outlinePass->name, + surface)); if (m_pipelineState == nullptr || !m_pipelineState->IsValid()) { DestroyResources(); return false; } + m_renderTargetFormat = ::XCEngine::Rendering::Internal::ResolveSurfaceColorFormat(surface, 0u); + m_renderTargetSampleCount = ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(surface); + return true; } @@ -400,6 +458,8 @@ void BuiltinObjectIdOutlinePass::ResetState() { m_texturePool = nullptr; m_textureSet = nullptr; m_builtinObjectIdOutlineShader.reset(); + m_renderTargetFormat = RHI::Format::Unknown; + m_renderTargetSampleCount = 1u; } } // namespace Passes diff --git a/engine/src/Rendering/Passes/BuiltinObjectIdPassResources.cpp b/engine/src/Rendering/Passes/BuiltinObjectIdPassResources.cpp index b9c0eed2..dbc7f3d6 100644 --- a/engine/src/Rendering/Passes/BuiltinObjectIdPassResources.cpp +++ b/engine/src/Rendering/Passes/BuiltinObjectIdPassResources.cpp @@ -7,7 +7,8 @@ #include "RHI/RHIPipelineLayout.h" #include "RHI/RHIPipelineState.h" #include "Rendering/Builtin/BuiltinPassLayoutUtils.h" -#include "Rendering/Detail/ShaderVariantUtils.h" +#include "Rendering/Internal/RenderSurfacePipelineUtils.h" +#include "Rendering/Internal/ShaderVariantUtils.h" #include "Rendering/Extraction/RenderSceneExtractor.h" #include "Rendering/RenderSurface.h" #include "Resources/BuiltinResources.h" @@ -26,25 +27,25 @@ const Resources::ShaderPass* FindObjectIdCompatiblePass( Resources::ShaderBackend backend) { for (const Resources::ShaderPass& shaderPass : shader.GetPasses()) { if (ShaderPassMatchesBuiltinPass(shaderPass, BuiltinMaterialPass::ObjectId) && - ::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, shaderPass.name, backend)) { + ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, shaderPass.name, backend)) { return &shaderPass; } } const Resources::ShaderPass* objectIdPass = shader.FindPass("ObjectId"); if (objectIdPass != nullptr && - ::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, objectIdPass->name, backend)) { + ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, objectIdPass->name, backend)) { return objectIdPass; } const Resources::ShaderPass* editorObjectIdPass = shader.FindPass("EditorObjectId"); if (editorObjectIdPass != nullptr && - ::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, editorObjectIdPass->name, backend)) { + ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, editorObjectIdPass->name, backend)) { return editorObjectIdPass; } if (shader.GetPassCount() > 0 && - ::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, shader.GetPasses()[0].name, backend)) { + ::XCEngine::Rendering::Internal::ShaderPassHasGraphicsVariants(shader, shader.GetPasses()[0].name, backend)) { return &shader.GetPasses()[0]; } @@ -55,14 +56,16 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc( RHI::RHIType backendType, RHI::RHIPipelineLayout* pipelineLayout, const Resources::Shader& shader, - const Containers::String& passName) { + const Containers::String& passName, + const RenderSurface& surface) { RHI::GraphicsPipelineDesc pipelineDesc = {}; pipelineDesc.pipelineLayout = pipelineLayout; pipelineDesc.topologyType = static_cast(RHI::PrimitiveTopologyType::Triangle); - pipelineDesc.renderTargetCount = 1; - pipelineDesc.renderTargetFormats[0] = static_cast(RHI::Format::R8G8B8A8_UNorm); - pipelineDesc.depthStencilFormat = static_cast(RHI::Format::D24_UNorm_S8_UInt); - pipelineDesc.sampleCount = 1; + ::XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc( + surface, + pipelineDesc); + pipelineDesc.depthStencilFormat = + static_cast(::XCEngine::Rendering::Internal::ResolveSurfaceDepthFormat(surface)); pipelineDesc.inputLayout = BuiltinObjectIdPass::BuildInputLayout(); pipelineDesc.rasterizerState.fillMode = static_cast(RHI::FillMode::Solid); @@ -78,11 +81,11 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc( pipelineDesc.depthStencilState.depthFunc = static_cast(RHI::ComparisonFunc::LessEqual); const Resources::ShaderPass* shaderPass = shader.FindPass(passName); - const Resources::ShaderBackend backend = ::XCEngine::Rendering::Detail::ToShaderBackend(backendType); + const Resources::ShaderBackend backend = ::XCEngine::Rendering::Internal::ToShaderBackend(backendType); if (const Resources::ShaderStageVariant* vertexVariant = shader.FindVariant(passName, Resources::ShaderType::Vertex, backend)) { if (shaderPass != nullptr) { - ::XCEngine::Rendering::Detail::ApplyShaderStageVariant( + ::XCEngine::Rendering::Internal::ApplyShaderStageVariant( shader.GetPath(), *shaderPass, backend, @@ -93,7 +96,7 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc( if (const Resources::ShaderStageVariant* fragmentVariant = shader.FindVariant(passName, Resources::ShaderType::Fragment, backend)) { if (shaderPass != nullptr) { - ::XCEngine::Rendering::Detail::ApplyShaderStageVariant( + ::XCEngine::Rendering::Internal::ApplyShaderStageVariant( shader.GetPath(), *shaderPass, backend, @@ -107,25 +110,52 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc( } // namespace -bool BuiltinObjectIdPass::EnsureInitialized(const RenderContext& context) { +bool BuiltinObjectIdPass::EnsureInitialized( + const RenderContext& context, + const RenderSurface& surface) { if (!context.IsValid()) { return false; } + const RHI::Format renderTargetFormat = + ::XCEngine::Rendering::Internal::ResolveSurfaceColorFormat(surface, 0u); + const RHI::Format depthStencilFormat = + ::XCEngine::Rendering::Internal::ResolveSurfaceDepthFormat(surface); + const uint32_t renderTargetSampleCount = + ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(surface); + if (m_pipelineLayout != nullptr && m_pipelineState != nullptr && m_device == context.device && - m_backendType == context.backendType) { + m_backendType == context.backendType && + m_renderTargetFormat == renderTargetFormat && + m_depthStencilFormat == depthStencilFormat && + m_renderTargetSampleCount == renderTargetSampleCount) { return true; } DestroyResources(); - return CreateResources(context); + return CreateResources(context, surface); } -bool BuiltinObjectIdPass::CreateResources(const RenderContext& context) { +bool BuiltinObjectIdPass::CreateResources( + const RenderContext& context, + const RenderSurface& surface) { + RHI::Format renderTargetFormat = RHI::Format::Unknown; + if (!::XCEngine::Rendering::Internal::TryResolveSingleColorAttachmentFormat(surface, renderTargetFormat)) { + return false; + } + const RHI::Format depthStencilFormat = + ::XCEngine::Rendering::Internal::ResolveSurfaceDepthFormat(surface); + if (depthStencilFormat == RHI::Format::Unknown) { + return false; + } + m_device = context.device; m_backendType = context.backendType; + m_renderTargetFormat = renderTargetFormat; + m_depthStencilFormat = depthStencilFormat; + m_renderTargetSampleCount = ::XCEngine::Rendering::Internal::ResolveSurfaceSampleCount(surface); m_builtinObjectIdShader = Resources::ResourceManager::Get().Load( Resources::GetBuiltinObjectIdShaderPath()); if (!m_builtinObjectIdShader.IsValid()) { @@ -136,7 +166,7 @@ bool BuiltinObjectIdPass::CreateResources(const RenderContext& context) { return false; } - const Resources::ShaderBackend backend = ::XCEngine::Rendering::Detail::ToShaderBackend(m_backendType); + const Resources::ShaderBackend backend = ::XCEngine::Rendering::Internal::ToShaderBackend(m_backendType); const Resources::ShaderPass* objectIdPass = FindObjectIdCompatiblePass(*m_builtinObjectIdShader.Get(), backend); if (objectIdPass == nullptr) { @@ -211,7 +241,8 @@ bool BuiltinObjectIdPass::CreateResources(const RenderContext& context) { m_backendType, m_pipelineLayout, *m_builtinObjectIdShader.Get(), - objectIdPass->name)); + objectIdPass->name, + surface)); if (m_pipelineState == nullptr || !m_pipelineState->IsValid()) { if (m_pipelineState != nullptr) { m_pipelineState->Shutdown(); @@ -250,10 +281,13 @@ void BuiltinObjectIdPass::DestroyResources() { m_perObjectBinding = {}; m_perObjectSetLayout = {}; m_firstDescriptorSet = 0; + m_renderTargetFormat = RHI::Format::Unknown; + m_depthStencilFormat = RHI::Format::Unknown; + m_renderTargetSampleCount = 1u; m_builtinObjectIdShader.Reset(); } -RHI::RHIDescriptorSet* BuiltinObjectIdPass::GetOrCreatePerObjectSet(uint64_t objectId) { +RHI::RHIDescriptorSet* BuiltinObjectIdPass::GetOrCreatePerObjectSet(RenderObjectId objectId) { if (m_perObjectBinding.IsValid() == false || m_perObjectSetLayout.layout.bindingCount == 0) { return nullptr; @@ -324,8 +358,11 @@ bool BuiltinObjectIdPass::DrawVisibleItem( commandList->SetIndexBuffer(cachedMesh->indexBufferView, 0); } - const uint64_t objectId = visibleItem.gameObject->GetID(); - RHI::RHIDescriptorSet* constantSet = GetOrCreatePerObjectSet(objectId); + if (!IsValidRenderObjectId(visibleItem.renderObjectId)) { + return false; + } + + RHI::RHIDescriptorSet* constantSet = GetOrCreatePerObjectSet(visibleItem.renderObjectId); if (constantSet == nullptr) { return false; } @@ -334,7 +371,7 @@ bool BuiltinObjectIdPass::DrawVisibleItem( sceneData.cameraData.projection, sceneData.cameraData.view, visibleItem.localToWorld.Transpose(), - EncodeObjectIdToColor(objectId) + EncodeRenderObjectIdToColor(visibleItem.renderObjectId) }; constantSet->WriteConstant(m_perObjectBinding.binding, &constants, sizeof(constants)); diff --git a/engine/src/Rendering/Passes/BuiltinSelectionMaskPass.cpp b/engine/src/Rendering/Passes/BuiltinSelectionMaskPass.cpp index ef5dce32..dbd5465c 100644 --- a/engine/src/Rendering/Passes/BuiltinSelectionMaskPass.cpp +++ b/engine/src/Rendering/Passes/BuiltinSelectionMaskPass.cpp @@ -31,7 +31,15 @@ bool BuiltinSelectionMaskPass::Render( const RenderSurface& surface, const RenderSceneData& sceneData, const std::vector& selectedObjectIds) { - m_selectedObjectIds = selectedObjectIds; + m_selectedObjectIds.clear(); + m_selectedObjectIds.reserve(selectedObjectIds.size()); + for (uint64_t selectedObjectId : selectedObjectIds) { + RenderObjectId renderObjectId = kInvalidRenderObjectId; + if (TryConvertRuntimeObjectIdToRenderObjectId(selectedObjectId, renderObjectId)) { + m_selectedObjectIds.push_back(renderObjectId); + } + } + if (m_selectedObjectIds.empty()) { return false; } @@ -45,18 +53,18 @@ bool BuiltinSelectionMaskPass::Render( surface, selectionMaskSceneData, nullptr, - nullptr + nullptr, + RHI::ResourceStates::Common }; return Execute(passContext); } bool BuiltinSelectionMaskPass::ShouldRenderVisibleItem(const VisibleRenderItem& visibleItem) const { - if (visibleItem.gameObject == nullptr) { + if (!IsValidRenderObjectId(visibleItem.renderObjectId)) { return false; } - const uint64_t objectId = visibleItem.gameObject->GetID(); - return std::find(m_selectedObjectIds.begin(), m_selectedObjectIds.end(), objectId) != + return std::find(m_selectedObjectIds.begin(), m_selectedObjectIds.end(), visibleItem.renderObjectId) != m_selectedObjectIds.end(); } diff --git a/tests/Rendering/integration/object_id_scene/main.cpp b/tests/Rendering/integration/object_id_scene/main.cpp index 17a5fa08..c51b9638 100644 --- a/tests/Rendering/integration/object_id_scene/main.cpp +++ b/tests/Rendering/integration/object_id_scene/main.cpp @@ -134,7 +134,9 @@ PpmImage LoadPpmImage(const std::filesystem::path& path) { } std::array EncodeObjectIdToRgb(uint64_t objectId) { - const uint32_t encodedId = EncodeObjectIdToUInt32(objectId); + RenderObjectId renderObjectId = kInvalidRenderObjectId; + EXPECT_TRUE(TryConvertRuntimeObjectIdToRenderObjectId(objectId, renderObjectId)); + const uint32_t encodedId = EncodeRenderObjectIdToUInt32(renderObjectId); return { static_cast((encodedId >> 0u) & 0xFFu), static_cast((encodedId >> 8u) & 0xFFu), diff --git a/tests/Rendering/unit/test_object_id_encoding.cpp b/tests/Rendering/unit/test_object_id_encoding.cpp index 5a9720e0..81ac7684 100644 --- a/tests/Rendering/unit/test_object_id_encoding.cpp +++ b/tests/Rendering/unit/test_object_id_encoding.cpp @@ -2,28 +2,48 @@ #include +#include + using namespace XCEngine::Rendering; -TEST(ObjectIdEncoding_Test, EncodesOnlyLow32BitsIntoPickingId) { - constexpr uint64_t objectId = 0x123456789ABCDEF0ull; +TEST(ObjectIdEncoding_Test, ConvertsValidRuntimeObjectIdLosslessly) { + constexpr uint64_t objectId = 0x00ABCDEFu; + RenderObjectId renderObjectId = kInvalidRenderObjectId; - EXPECT_FALSE(CanEncodeObjectIdWithoutLoss(objectId)); - EXPECT_EQ(EncodeObjectIdToEncodedId(objectId), 0x9ABCDEF0u); - EXPECT_EQ(EncodeObjectIdToUInt32(objectId), 0x9ABCDEF0u); + EXPECT_TRUE(CanConvertRuntimeObjectIdToRenderObjectId(objectId)); + EXPECT_TRUE(TryConvertRuntimeObjectIdToRenderObjectId(objectId, renderObjectId)); + EXPECT_EQ(renderObjectId, 0x00ABCDEFu); + EXPECT_EQ(ConvertRenderObjectIdToRuntimeObjectId(renderObjectId), objectId); } -TEST(ObjectIdEncoding_Test, DecodesColorBackToWidenedRuntimeId) { +TEST(ObjectIdEncoding_Test, RejectsInvalidAndOverflowRuntimeObjectIds) { + RenderObjectId renderObjectId = 123u; + + EXPECT_FALSE(CanConvertRuntimeObjectIdToRenderObjectId(0u)); + EXPECT_FALSE(TryConvertRuntimeObjectIdToRenderObjectId(0u, renderObjectId)); + EXPECT_EQ(renderObjectId, kInvalidRenderObjectId); + + const uint64_t overflowObjectId = + static_cast(std::numeric_limits::max()) + 1ull; + renderObjectId = 456u; + EXPECT_FALSE(CanConvertRuntimeObjectIdToRenderObjectId(overflowObjectId)); + EXPECT_FALSE(TryConvertRuntimeObjectIdToRenderObjectId(overflowObjectId, renderObjectId)); + EXPECT_EQ(renderObjectId, kInvalidRenderObjectId); +} + +TEST(ObjectIdEncoding_Test, DecodesColorBackToRenderObjectId) { constexpr uint8_t r = 0x12u; constexpr uint8_t g = 0x34u; constexpr uint8_t b = 0x56u; constexpr uint8_t a = 0x78u; EXPECT_EQ(DecodeEncodedObjectIdFromColor(r, g, b, a), 0x78563412u); - EXPECT_EQ(DecodeObjectIdFromColor(r, g, b, a), 0x78563412ull); + EXPECT_EQ(DecodeRenderObjectIdFromColor(r, g, b, a), 0x78563412u); + EXPECT_EQ(ConvertRenderObjectIdToRuntimeObjectId(DecodeRenderObjectIdFromColor(r, g, b, a)), 0x78563412ull); } -TEST(ObjectIdEncoding_Test, EncodesColorChannelsFromLow32Bits) { - const auto encodedColor = EncodeObjectIdToColor(0x78563412ull); +TEST(ObjectIdEncoding_Test, EncodesColorChannelsFromRenderObjectId) { + const auto encodedColor = EncodeRenderObjectIdToColor(0x78563412u); constexpr float kInv255 = 1.0f / 255.0f; EXPECT_FLOAT_EQ(encodedColor.x, 0x12u * kInv255); diff --git a/tests/Rendering/unit/test_render_scene_utility.cpp b/tests/Rendering/unit/test_render_scene_utility.cpp index 013f02c7..4b18ccbe 100644 --- a/tests/Rendering/unit/test_render_scene_utility.cpp +++ b/tests/Rendering/unit/test_render_scene_utility.cpp @@ -28,7 +28,9 @@ using XCEngine::Math::Vector3; using XCEngine::Rendering::BuildRenderCameraData; using XCEngine::Rendering::CompareVisibleRenderItemsStable; using XCEngine::Rendering::CollectRenderItemsForEntityIds; +using XCEngine::Rendering::ConvertRenderObjectIdToRuntimeObjectId; using XCEngine::Rendering::VisibleRenderItem; +using XCEngine::Rendering::kInvalidRenderObjectId; using XCEngine::Resources::Mesh; using XCEngine::Resources::MeshSection; using XCEngine::Resources::StaticMeshVertex; @@ -199,6 +201,8 @@ TEST_F(RenderSceneUtilityTest, CollectRenderItemsForEntityIdsFiltersInvalidTarge EXPECT_EQ(renderables[0].gameObject, validObject); EXPECT_EQ(renderables[0].meshRenderer, validObject->GetComponent()); EXPECT_TRUE(renderables[0].hasSection); + EXPECT_NE(renderables[0].renderObjectId, kInvalidRenderObjectId); + EXPECT_EQ(ConvertRenderObjectIdToRuntimeObjectId(renderables[0].renderObjectId), validObject->GetID()); } TEST_F(RenderSceneUtilityTest, CollectRenderItemsForEntityIdsExpandsMeshSections) {