xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Formalize render object id contract

Browse Source
This commit is contained in:
ssdfasd
2026-04-10 01:57:15 +08:00
parent 4debbbea1f
commit b5ba985831
12 changed files with 282 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
editor/src/Viewport/ViewportObjectIdPicker.h
View File

@@ -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;
}

2
engine/include/XCEngine/Rendering/FrameData/VisibleRenderItem.h
View File

@@ -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;

15
engine/include/XCEngine/Rendering/Passes/BuiltinObjectIdPass.h
View File

@@ -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<Resources::Shader> m_builtinObjectIdShader;
RenderResourceCache m_resourceCache;
std::unordered_map<uint64_t, OwnedDescriptorSet> m_perObjectSets;
std::unordered_map<RenderObjectId, OwnedDescriptorSet> m_perObjectSets;
};
} // namespace Passes

3
engine/include/XCEngine/Rendering/Passes/BuiltinSelectionMaskPass.h
View File

@@ -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

50
engine/include/XCEngine/Rendering/Picking/ObjectIdCodec.h
View File

@@ -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.
// 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<EncodedObjectId>(objectId & 0xFFFFFFFFull);
inline bool CanConvertRuntimeObjectIdToRenderObjectId(Core::uint64 runtimeObjectId) {
return runtimeObjectId != 0u &&
runtimeObjectId <= static_cast<Core::uint64>(std::numeric_limits<RenderObjectId>::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<RenderObjectId>(runtimeObjectId);
return true;
}
inline Math::Vector4 EncodeObjectIdToColor(Core::uint64 objectId) {
const EncodedObjectId encodedId = EncodeObjectIdToEncodedId(objectId);
inline Core::uint64 ConvertRenderObjectIdToRuntimeObjectId(RenderObjectId renderObjectId) {
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

13
engine/src/Rendering/Extraction/RenderSceneUtility.cpp
View File

@@ -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;

148
engine/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp
View File

@@ -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 <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;
pipelineDesc.renderTargetFormats[0] = static_cast<uint32_t>(RHI::Format::R8G8B8A8_UNorm);
::XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
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 ||
objectIdTextureView == nullptr ||
inputs.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();
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<uint32_t>(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<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,
0.0f,
static_cast<float>(surface.GetWidth()),
static_cast<float>(surface.GetHeight()),
static_cast<float>(renderArea.x),
static_cast<float>(renderArea.y),
static_cast<float>(renderArea.width),
static_cast<float>(renderArea.height),
0.0f,
1.0f
};
const RHI::Rect scissorRect = {
0,
0,
static_cast<int32_t>(surface.GetWidth()),
static_cast<int32_t>(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

83
engine/src/Rendering/Passes/BuiltinObjectIdPassResources.cpp
View File

@@ -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;
pipelineDesc.renderTargetFormats[0] = static_cast<uint32_t>(RHI::Format::R8G8B8A8_UNorm);
pipelineDesc.depthStencilFormat = static_cast<uint32_t>(RHI::Format::D24_UNorm_S8_UInt);
pipelineDesc.sampleCount = 1;
::XCEngine::Rendering::Internal::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
surface,
pipelineDesc);
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();
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));

18
engine/src/Rendering/Passes/BuiltinSelectionMaskPass.cpp
View File

@@ -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(), objectId) !=
return std::find(m_selectedObjectIds.begin(), m_selectedObjectIds.end(), visibleItem.renderObjectId) !=
m_selectedObjectIds.end();
}

4
tests/Rendering/integration/object_id_scene/main.cpp
View File

@@ -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),

38
tests/Rendering/unit/test_object_id_encoding.cpp
View File

@@ -2,28 +2,48 @@
#include <XCEngine/Rendering/Picking/ObjectIdCodec.h>
#include <limits>
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<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) {
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);

4
tests/Rendering/unit/test_render_scene_utility.cpp
View File

@@ -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) {