Formalize render object id contract

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<uint64_t>(Rendering::DecodeObjectIdFromColor(
+    result.renderObjectId = Rendering::DecodeRenderObjectIdFromColor(
         rgba[0],
         rgba[1],
         rgba[2],
-        rgba[3]));
+        rgba[3]);
+    result.entityId = Rendering::ConvertRenderObjectIdToRuntimeObjectId(result.renderObjectId);
     return result;
 }
 

engine/include/XCEngine/Rendering/FrameData/VisibleRenderItem.h

@@ -2,6 +2,7 @@
 
 #include <XCEngine/Core/Math/Matrix4.h>
 #include <XCEngine/Core/Types.h>
+#include <XCEngine/Rendering/Picking/ObjectIdCodec.h>
 #include <XCEngine/Resources/Mesh/Mesh.h>
 
 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;

engine/include/XCEngine/Rendering/Passes/BuiltinObjectIdPass.h

@@ -43,11 +43,15 @@ private:
         RHI::RHIDescriptorSet* set = nullptr;
     };
 
-    bool EnsureInitialized(const RenderContext& context);
+    bool EnsureInitialized(
-    bool CreateResources(const RenderContext& context);
+        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<Resources::Shader> m_builtinObjectIdShader;
     RenderResourceCache m_resourceCache;
-    std::unordered_map<uint64_t, OwnedDescriptorSet> m_perObjectSets;
+    std::unordered_map<RenderObjectId, OwnedDescriptorSet> m_perObjectSets;
 };
 
 } // namespace Passes

engine/include/XCEngine/Rendering/Passes/BuiltinSelectionMaskPass.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <XCEngine/Rendering/Passes/BuiltinDepthStylePassBase.h>
+#include <XCEngine/Rendering/Picking/ObjectIdCodec.h>
 
 #include <cstdint>
 #include <vector>
@@ -32,7 +33,7 @@ protected:
     bool ShouldRenderVisibleItem(const VisibleRenderItem& visibleItem) const override;
 
 private:
-    std::vector<uint64_t> m_selectedObjectIds = {};
+    std::vector<RenderObjectId> m_selectedObjectIds = {};
 };
 
 } // namespace Passes

engine/include/XCEngine/Rendering/Picking/ObjectIdCodec.h

@@ -3,27 +3,51 @@
 #include <XCEngine/Core/Math/Vector4.h>
 #include <XCEngine/Core/Types.h>
 
+#include <limits>
+
 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.
+static constexpr RenderObjectId kInvalidRenderObjectId = 0u;
-// This codec is for editor/runtime picking surfaces, not for persistent ids.
+
-inline bool CanEncodeObjectIdWithoutLoss(Core::uint64 objectId) {
+inline bool IsValidRenderObjectId(RenderObjectId renderObjectId) {
-    return (objectId & 0xFFFFFFFF00000000ull) == 0ull;
+    return renderObjectId != kInvalidRenderObjectId;
 }
 
-inline EncodedObjectId EncodeObjectIdToEncodedId(Core::uint64 objectId) {
+inline bool CanConvertRuntimeObjectIdToRenderObjectId(Core::uint64 runtimeObjectId) {
-    return static_cast<EncodedObjectId>(objectId & 0xFFFFFFFFull);
+    return runtimeObjectId != 0u &&
+        runtimeObjectId <= static_cast<Core::uint64>(std::numeric_limits<RenderObjectId>::max());
 }
 
-inline EncodedObjectId EncodeObjectIdToUInt32(Core::uint64 objectId) {
+inline bool TryConvertRuntimeObjectIdToRenderObjectId(
-    return EncodeObjectIdToEncodedId(objectId);
+    Core::uint64 runtimeObjectId,
+    RenderObjectId& outRenderObjectId) {
+    outRenderObjectId = kInvalidRenderObjectId;
+    if (!CanConvertRuntimeObjectIdToRenderObjectId(runtimeObjectId)) {
+        return false;
+    }
+
+    outRenderObjectId = static_cast<RenderObjectId>(runtimeObjectId);
+    return true;
 }
 
-inline Math::Vector4 EncodeObjectIdToColor(Core::uint64 objectId) {
+inline Core::uint64 ConvertRenderObjectIdToRuntimeObjectId(RenderObjectId renderObjectId) {
-    const EncodedObjectId encodedId = EncodeObjectIdToEncodedId(objectId);
+    return static_cast<Core::uint64>(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<float>((encodedId >> 0) & 0xFFu) * kInv255,
@@ -43,12 +67,12 @@ inline EncodedObjectId DecodeEncodedObjectIdFromColor(
            (static_cast<EncodedObjectId>(a) << 24u);
 }
 
-inline Core::uint64 DecodeObjectIdFromColor(
+inline RenderObjectId DecodeRenderObjectIdFromColor(
     Core::uint8 r,
     Core::uint8 g,
     Core::uint8 b,
     Core::uint8 a) {
-    return static_cast<Core::uint64>(DecodeEncodedObjectIdFromColor(r, g, b, a));
+    return DecodeEncodedObjectIdFromColor(r, g, b, a);
 }
 
 } // namespace Rendering

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<Resources::MeshSection>& 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<Core::uint32>(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;

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/Internal/RenderSurfacePipelineUtils.h"
-#include "Rendering/Detail/ShaderVariantUtils.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 <XCEngine/Resources/BuiltinResources.h>
@@ -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<uint32_t>(RHI::PrimitiveTopologyType::Triangle);
-    pipelineDesc.renderTargetCount = 1;
+    ::XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
-    pipelineDesc.renderTargetFormats[0] = static_cast<uint32_t>(RHI::Format::R8G8B8A8_UNorm);
+        surface,
+        pipelineDesc);
     pipelineDesc.depthStencilFormat = static_cast<uint32_t>(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<uint64_t>& selectedObjectIds,
     const ObjectIdOutlineStyle& style) {
     if (!renderContext.IsValid() ||
-        renderContext.backendType != RHI::RHIType::D3D12 ||
+        inputs.objectIdTextureView == nullptr ||
-        objectIdTextureView == nullptr ||
         selectedObjectIds.empty()) {
         return false;
     }
 
-    if (!EnsureInitialized(renderContext)) {
+    const std::vector<RHI::RHIResourceView*>& colorAttachments = surface.GetColorAttachments();
+    if (!::XCEngine::Rendering::Internal::HasSingleColorAttachment(surface) ||
+        colorAttachments.empty() ||
+        colorAttachments[0] == nullptr) {
         return false;
     }
 
-    const std::vector<RHI::RHIResourceView*>& colorAttachments = surface.GetColorAttachments();
+    const Math::RectInt renderArea = surface.GetRenderArea();
-    if (colorAttachments.empty() || colorAttachments[0] == nullptr) {
+    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)(
+    uint32_t selectedCount = 0u;
-        static_cast<uint32_t>(selectedObjectIds.size()),
+    for (uint64_t selectedObjectId : selectedObjectIds) {
-        kMaxSelectedObjectCount);
+        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<float>(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,
+        static_cast<float>(renderArea.x),
-        0.0f,
+        static_cast<float>(renderArea.y),
-        static_cast<float>(surface.GetWidth()),
+        static_cast<float>(renderArea.width),
-        static_cast<float>(surface.GetHeight()),
+        static_cast<float>(renderArea.height),
         0.0f,
         1.0f
     };
     const RHI::Rect scissorRect = {
-        0,
+        renderArea.x,
-        0,
+        renderArea.y,
-        static_cast<int32_t>(surface.GetWidth()),
+        renderArea.x + renderArea.width,
-        static_cast<int32_t>(surface.GetHeight())
+        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) {
+bool BuiltinObjectIdOutlinePass::CreateResources(const RenderContext& renderContext, const RenderSurface& surface) {
-    if (!renderContext.IsValid() || renderContext.backendType != RHI::RHIType::D3D12) {
+    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) {
@@ -326,12 +380,16 @@ bool BuiltinObjectIdOutlinePass::CreateResources(const RenderContext& renderCont
             m_backendType,
             m_pipelineLayout,
             *m_builtinObjectIdOutlineShader->Get(),
-                outlinePass->name));
+            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

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<uint32_t>(RHI::PrimitiveTopologyType::Triangle);
-    pipelineDesc.renderTargetCount = 1;
+    ::XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
-    pipelineDesc.renderTargetFormats[0] = static_cast<uint32_t>(RHI::Format::R8G8B8A8_UNorm);
+        surface,
-    pipelineDesc.depthStencilFormat = static_cast<uint32_t>(RHI::Format::D24_UNorm_S8_UInt);
+        pipelineDesc);
-    pipelineDesc.sampleCount = 1;
+    pipelineDesc.depthStencilFormat =
+        static_cast<uint32_t>(::XCEngine::Rendering::Internal::ResolveSurfaceDepthFormat(surface));
     pipelineDesc.inputLayout = BuiltinObjectIdPass::BuildInputLayout();
 
     pipelineDesc.rasterizerState.fillMode = static_cast<uint32_t>(RHI::FillMode::Solid);
@@ -78,11 +81,11 @@ RHI::GraphicsPipelineDesc CreatePipelineDesc(
     pipelineDesc.depthStencilState.depthFunc = static_cast<uint32_t>(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::Shader>(
         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();
+    if (!IsValidRenderObjectId(visibleItem.renderObjectId)) {
-    RHI::RHIDescriptorSet* constantSet = GetOrCreatePerObjectSet(objectId);
+        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));
 

engine/src/Rendering/Passes/BuiltinSelectionMaskPass.cpp

@@ -31,7 +31,15 @@ bool BuiltinSelectionMaskPass::Render(
     const RenderSurface& surface,
     const RenderSceneData& sceneData,
     const std::vector<uint64_t>& 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(), visibleItem.renderObjectId) !=
-    return std::find(m_selectedObjectIds.begin(), m_selectedObjectIds.end(), objectId) !=
         m_selectedObjectIds.end();
 }
 

tests/Rendering/integration/object_id_scene/main.cpp

@@ -134,7 +134,9 @@ PpmImage LoadPpmImage(const std::filesystem::path& path) {
 }
 
 std::array<uint8_t, 3> 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<uint8_t>((encodedId >> 0u) & 0xFFu),
         static_cast<uint8_t>((encodedId >> 8u) & 0xFFu),

tests/Rendering/unit/test_object_id_encoding.cpp

@@ -2,28 +2,48 @@
 
 #include <XCEngine/Rendering/Picking/ObjectIdCodec.h>
 
+#include <limits>
+
 using namespace XCEngine::Rendering;
 
-TEST(ObjectIdEncoding_Test, EncodesOnlyLow32BitsIntoPickingId) {
+TEST(ObjectIdEncoding_Test, ConvertsValidRuntimeObjectIdLosslessly) {
-    constexpr uint64_t objectId = 0x123456789ABCDEF0ull;
+    constexpr uint64_t objectId = 0x00ABCDEFu;
+    RenderObjectId renderObjectId = kInvalidRenderObjectId;
 
-    EXPECT_FALSE(CanEncodeObjectIdWithoutLoss(objectId));
+    EXPECT_TRUE(CanConvertRuntimeObjectIdToRenderObjectId(objectId));
-    EXPECT_EQ(EncodeObjectIdToEncodedId(objectId), 0x9ABCDEF0u);
+    EXPECT_TRUE(TryConvertRuntimeObjectIdToRenderObjectId(objectId, renderObjectId));
-    EXPECT_EQ(EncodeObjectIdToUInt32(objectId), 0x9ABCDEF0u);
+    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<uint64_t>(std::numeric_limits<RenderObjectId>::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) {
+TEST(ObjectIdEncoding_Test, EncodesColorChannelsFromRenderObjectId) {
-    const auto encodedColor = EncodeObjectIdToColor(0x78563412ull);
+    const auto encodedColor = EncodeRenderObjectIdToColor(0x78563412u);
     constexpr float kInv255 = 1.0f / 255.0f;
 
     EXPECT_FLOAT_EQ(encodedColor.x, 0x12u * kInv255);

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<MeshRendererComponent>());
     EXPECT_TRUE(renderables[0].hasSection);
+    EXPECT_NE(renderables[0].renderObjectId, kInvalidRenderObjectId);
+    EXPECT_EQ(ConvertRenderObjectIdToRuntimeObjectId(renderables[0].renderObjectId), validObject->GetID());
 }
 
 TEST_F(RenderSceneUtilityTest, CollectRenderItemsForEntityIdsExpandsMeshSections) {