746 lines
26 KiB
C++
746 lines
26 KiB
C++
#include "Rendering/Viewport/Passes/SceneViewportSelectionOutlinePass.h"
|
|
|
|
#include "Rendering/Viewport/SceneViewportResourcePaths.h"
|
|
#include "Rendering/Viewport/ViewportRenderTargets.h"
|
|
|
|
#include <XCEngine/Components/GameObject.h>
|
|
#include <XCEngine/Rendering/RenderSurfacePipelineUtils.h>
|
|
#include <XCEngine/Rendering/ShaderVariantUtils.h>
|
|
#include <XCEngine/Rendering/Materials/RenderMaterialStateUtils.h>
|
|
|
|
#include <XCEngine/Core/Asset/ResourceManager.h>
|
|
#include <XCEngine/Core/Math/Vector4.h>
|
|
#include <XCEngine/Debug/Logger.h>
|
|
#include <XCEngine/Rendering/FrameData/RenderSceneData.h>
|
|
#include <XCEngine/Rendering/FrameData/VisibleRenderItem.h>
|
|
#include <XCEngine/Rendering/Passes/BuiltinDepthStylePassBase.h>
|
|
#include <XCEngine/RHI/RHICommandList.h>
|
|
#include <XCEngine/RHI/RHIDescriptorPool.h>
|
|
#include <XCEngine/RHI/RHIDescriptorSet.h>
|
|
#include <XCEngine/RHI/RHIDevice.h>
|
|
#include <XCEngine/RHI/RHIPipelineLayout.h>
|
|
#include <XCEngine/RHI/RHIPipelineState.h>
|
|
#include <XCEngine/Resources/Shader/Shader.h>
|
|
|
|
#include <algorithm>
|
|
#include <optional>
|
|
#include <utility>
|
|
|
|
namespace XCEngine::UI::Editor::App {
|
|
|
|
namespace {
|
|
|
|
class SceneViewportSelectionMaskPass final
|
|
: public ::XCEngine::Rendering::Passes::BuiltinDepthStylePassBase {
|
|
public:
|
|
SceneViewportSelectionMaskPass()
|
|
: BuiltinDepthStylePassBase(
|
|
::XCEngine::Rendering::BuiltinMaterialPass::SelectionMask,
|
|
GetSceneViewportSelectionMaskShaderPath()) {
|
|
}
|
|
|
|
const char* GetName() const override {
|
|
return "SceneViewportSelectionMaskPass";
|
|
}
|
|
|
|
bool Render(
|
|
const ::XCEngine::Rendering::RenderContext& context,
|
|
const ::XCEngine::Rendering::RenderSurface& surface,
|
|
const ::XCEngine::Rendering::RenderSceneData& sceneData,
|
|
const std::vector<std::uint64_t>& selectedObjectIds) {
|
|
m_selectedObjectIds.clear();
|
|
m_selectedObjectIds.reserve(selectedObjectIds.size());
|
|
for (const std::uint64_t selectedObjectId : selectedObjectIds) {
|
|
if (selectedObjectId != 0u) {
|
|
m_selectedObjectIds.push_back(selectedObjectId);
|
|
}
|
|
}
|
|
|
|
if (m_selectedObjectIds.empty()) {
|
|
return false;
|
|
}
|
|
|
|
::XCEngine::Rendering::RenderSceneData selectionMaskSceneData = sceneData;
|
|
selectionMaskSceneData.cameraData.clearFlags =
|
|
::XCEngine::Rendering::RenderClearFlags::Color;
|
|
selectionMaskSceneData.cameraData.clearColor =
|
|
::XCEngine::Math::Color::Black();
|
|
|
|
const ::XCEngine::Rendering::RenderPassContext passContext = {
|
|
context,
|
|
surface,
|
|
selectionMaskSceneData,
|
|
nullptr,
|
|
nullptr,
|
|
::XCEngine::RHI::ResourceStates::Common
|
|
};
|
|
return Execute(passContext);
|
|
}
|
|
|
|
protected:
|
|
bool ShouldRenderVisibleItem(
|
|
const ::XCEngine::Rendering::VisibleRenderItem& visibleItem) const override {
|
|
if (visibleItem.gameObject == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
const std::uint64_t runtimeObjectId = visibleItem.gameObject->GetID();
|
|
if (runtimeObjectId == 0u) {
|
|
return false;
|
|
}
|
|
|
|
return std::find(
|
|
m_selectedObjectIds.begin(),
|
|
m_selectedObjectIds.end(),
|
|
runtimeObjectId) != m_selectedObjectIds.end();
|
|
}
|
|
|
|
private:
|
|
std::vector<std::uint64_t> m_selectedObjectIds = {};
|
|
};
|
|
|
|
const ::XCEngine::Resources::ShaderPass* FindSelectionOutlineCompatiblePass(
|
|
const ::XCEngine::Resources::Shader& shader,
|
|
::XCEngine::Resources::ShaderBackend backend) {
|
|
const ::XCEngine::Resources::ShaderPass* outlinePass =
|
|
shader.FindPass("SelectionOutline");
|
|
if (outlinePass != nullptr &&
|
|
::XCEngine::Rendering::ShaderPassHasGraphicsVariants(
|
|
shader,
|
|
outlinePass->name,
|
|
backend)) {
|
|
return outlinePass;
|
|
}
|
|
|
|
const ::XCEngine::Resources::ShaderPass* editorOutlinePass =
|
|
shader.FindPass("EditorSelectionOutline");
|
|
if (editorOutlinePass != nullptr &&
|
|
::XCEngine::Rendering::ShaderPassHasGraphicsVariants(
|
|
shader,
|
|
editorOutlinePass->name,
|
|
backend)) {
|
|
return editorOutlinePass;
|
|
}
|
|
|
|
if (shader.GetPassCount() > 0 &&
|
|
::XCEngine::Rendering::ShaderPassHasGraphicsVariants(
|
|
shader,
|
|
shader.GetPasses()[0].name,
|
|
backend)) {
|
|
return &shader.GetPasses()[0];
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
::XCEngine::RHI::GraphicsPipelineDesc CreatePipelineDesc(
|
|
::XCEngine::RHI::RHIType backendType,
|
|
::XCEngine::RHI::RHIPipelineLayout* pipelineLayout,
|
|
const ::XCEngine::Resources::Shader& shader,
|
|
const ::XCEngine::Containers::String& passName,
|
|
const ::XCEngine::Rendering::RenderSurface& surface) {
|
|
::XCEngine::RHI::GraphicsPipelineDesc pipelineDesc = {};
|
|
pipelineDesc.pipelineLayout = pipelineLayout;
|
|
pipelineDesc.topologyType =
|
|
static_cast<std::uint32_t>(
|
|
::XCEngine::RHI::PrimitiveTopologyType::Triangle);
|
|
::XCEngine::Rendering::
|
|
ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
|
|
surface,
|
|
pipelineDesc);
|
|
pipelineDesc.depthStencilFormat =
|
|
static_cast<std::uint32_t>(::XCEngine::RHI::Format::Unknown);
|
|
|
|
const ::XCEngine::Resources::ShaderPass* shaderPass =
|
|
shader.FindPass(passName);
|
|
if (shaderPass != nullptr && shaderPass->hasFixedFunctionState) {
|
|
::XCEngine::Rendering::ApplyRenderState(
|
|
shaderPass->fixedFunctionState,
|
|
pipelineDesc);
|
|
} else {
|
|
::XCEngine::Resources::MaterialRenderState fallbackState = {};
|
|
fallbackState.cullMode =
|
|
::XCEngine::Resources::MaterialCullMode::None;
|
|
fallbackState.depthWriteEnable = false;
|
|
fallbackState.depthTestEnable = false;
|
|
fallbackState.depthFunc =
|
|
::XCEngine::Resources::MaterialComparisonFunc::Always;
|
|
fallbackState.blendEnable = true;
|
|
fallbackState.srcBlend =
|
|
::XCEngine::Resources::MaterialBlendFactor::SrcAlpha;
|
|
fallbackState.dstBlend =
|
|
::XCEngine::Resources::MaterialBlendFactor::InvSrcAlpha;
|
|
fallbackState.srcBlendAlpha =
|
|
::XCEngine::Resources::MaterialBlendFactor::One;
|
|
fallbackState.dstBlendAlpha =
|
|
::XCEngine::Resources::MaterialBlendFactor::InvSrcAlpha;
|
|
fallbackState.blendOp =
|
|
::XCEngine::Resources::MaterialBlendOp::Add;
|
|
fallbackState.blendOpAlpha =
|
|
::XCEngine::Resources::MaterialBlendOp::Add;
|
|
fallbackState.colorWriteMask = static_cast<std::uint8_t>(
|
|
::XCEngine::RHI::ColorWriteMask::All);
|
|
::XCEngine::Rendering::ApplyRenderState(
|
|
fallbackState,
|
|
pipelineDesc);
|
|
}
|
|
|
|
const ::XCEngine::Resources::ShaderBackend backend =
|
|
::XCEngine::Rendering::ToShaderBackend(backendType);
|
|
if (const ::XCEngine::Resources::ShaderStageVariant* vertexVariant =
|
|
shader.FindVariant(
|
|
passName,
|
|
::XCEngine::Resources::ShaderType::Vertex,
|
|
backend)) {
|
|
if (shaderPass != nullptr) {
|
|
::XCEngine::Rendering::ApplyShaderStageVariant(
|
|
shader.GetPath(),
|
|
*shaderPass,
|
|
backend,
|
|
*vertexVariant,
|
|
pipelineDesc.vertexShader);
|
|
}
|
|
}
|
|
if (const ::XCEngine::Resources::ShaderStageVariant* fragmentVariant =
|
|
shader.FindVariant(
|
|
passName,
|
|
::XCEngine::Resources::ShaderType::Fragment,
|
|
backend)) {
|
|
if (shaderPass != nullptr) {
|
|
::XCEngine::Rendering::ApplyShaderStageVariant(
|
|
shader.GetPath(),
|
|
*shaderPass,
|
|
backend,
|
|
*fragmentVariant,
|
|
pipelineDesc.fragmentShader);
|
|
}
|
|
}
|
|
|
|
return pipelineDesc;
|
|
}
|
|
|
|
class SceneViewportSelectionOutlinePass final
|
|
: public ::XCEngine::Rendering::RenderPass {
|
|
public:
|
|
SceneViewportSelectionOutlinePass(
|
|
SceneViewportSelectionOutlinePassRenderer& renderer,
|
|
ViewportRenderTargets* targets,
|
|
std::vector<std::uint64_t> selectedObjectIds,
|
|
const SceneViewportSelectionOutlineStyle& style)
|
|
: m_renderer(renderer)
|
|
, m_targets(targets)
|
|
, m_selectedObjectIds(std::move(selectedObjectIds))
|
|
, m_style(style) {
|
|
}
|
|
|
|
const char* GetName() const override {
|
|
return "SceneViewportSelectionOutline";
|
|
}
|
|
|
|
bool Execute(
|
|
const ::XCEngine::Rendering::RenderPassContext& context) override {
|
|
return m_renderer.Render(
|
|
context.renderContext,
|
|
context.surface,
|
|
context.sceneData,
|
|
*m_targets,
|
|
m_selectedObjectIds,
|
|
m_style);
|
|
}
|
|
|
|
private:
|
|
SceneViewportSelectionOutlinePassRenderer& m_renderer;
|
|
ViewportRenderTargets* m_targets = nullptr;
|
|
std::vector<std::uint64_t> m_selectedObjectIds = {};
|
|
SceneViewportSelectionOutlineStyle m_style = {};
|
|
};
|
|
|
|
} // namespace
|
|
|
|
class SceneViewportSelectionOutlinePassRenderer::Impl {
|
|
public:
|
|
struct OutlineConstants {
|
|
::XCEngine::Math::Vector4 viewportSizeAndTexelSize =
|
|
::XCEngine::Math::Vector4::Zero();
|
|
::XCEngine::Math::Vector4 outlineColor =
|
|
::XCEngine::Math::Vector4::Zero();
|
|
::XCEngine::Math::Vector4 outlineInfo =
|
|
::XCEngine::Math::Vector4::Zero();
|
|
::XCEngine::Math::Vector4 depthParams =
|
|
::XCEngine::Math::Vector4::Zero();
|
|
};
|
|
|
|
Impl()
|
|
: m_selectionMaskPass(std::make_unique<SceneViewportSelectionMaskPass>())
|
|
, m_shaderPath(GetSceneViewportSelectionOutlineShaderPath()) {
|
|
}
|
|
|
|
void Shutdown() {
|
|
if (m_selectionMaskPass != nullptr) {
|
|
m_selectionMaskPass->Shutdown();
|
|
}
|
|
DestroyResources();
|
|
}
|
|
|
|
bool Render(
|
|
const ::XCEngine::Rendering::RenderContext& renderContext,
|
|
const ::XCEngine::Rendering::RenderSurface& surface,
|
|
const ::XCEngine::Rendering::RenderSceneData& sceneData,
|
|
ViewportRenderTargets& targets,
|
|
const std::vector<std::uint64_t>& selectedObjectIds,
|
|
const SceneViewportSelectionOutlineStyle& style) {
|
|
::XCEngine::Rendering::RenderSurface selectionMaskSurface =
|
|
BuildViewportSelectionMaskSurface(targets);
|
|
selectionMaskSurface.SetRenderArea(surface.GetRenderArea());
|
|
|
|
if (!m_selectionMaskPass->Render(
|
|
renderContext,
|
|
selectionMaskSurface,
|
|
sceneData,
|
|
selectedObjectIds)) {
|
|
return false;
|
|
}
|
|
|
|
targets.selectionMaskState =
|
|
::XCEngine::RHI::ResourceStates::PixelShaderResource;
|
|
return RenderOutline(
|
|
renderContext,
|
|
surface,
|
|
targets.selectionMaskShaderView,
|
|
targets.selectionMaskState,
|
|
targets.depthShaderView,
|
|
surface.GetDepthStateAfter(),
|
|
style);
|
|
}
|
|
|
|
private:
|
|
bool RenderOutline(
|
|
const ::XCEngine::Rendering::RenderContext& renderContext,
|
|
const ::XCEngine::Rendering::RenderSurface& surface,
|
|
::XCEngine::RHI::RHIResourceView* selectionMaskTextureView,
|
|
::XCEngine::RHI::ResourceStates selectionMaskState,
|
|
::XCEngine::RHI::RHIResourceView* depthTextureView,
|
|
::XCEngine::RHI::ResourceStates depthTextureState,
|
|
const SceneViewportSelectionOutlineStyle& style) {
|
|
if (!renderContext.IsValid() ||
|
|
selectionMaskTextureView == nullptr ||
|
|
depthTextureView == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
const std::vector<::XCEngine::RHI::RHIResourceView*>& colorAttachments =
|
|
surface.GetColorAttachments();
|
|
if (!::XCEngine::Rendering::HasSingleColorAttachment(surface) ||
|
|
colorAttachments.empty() ||
|
|
colorAttachments[0] == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
const ::XCEngine::Math::RectInt renderArea = surface.GetRenderArea();
|
|
if (renderArea.width <= 0 || renderArea.height <= 0) {
|
|
return false;
|
|
}
|
|
|
|
if (!EnsureInitialized(renderContext, surface)) {
|
|
return false;
|
|
}
|
|
|
|
OutlineConstants constants = {};
|
|
constants.viewportSizeAndTexelSize = ::XCEngine::Math::Vector4(
|
|
static_cast<float>(surface.GetWidth()),
|
|
static_cast<float>(surface.GetHeight()),
|
|
surface.GetWidth() > 0
|
|
? 1.0f / static_cast<float>(surface.GetWidth())
|
|
: 0.0f,
|
|
surface.GetHeight() > 0
|
|
? 1.0f / static_cast<float>(surface.GetHeight())
|
|
: 0.0f);
|
|
constants.outlineColor = ::XCEngine::Math::Vector4(
|
|
style.outlineColor.r,
|
|
style.outlineColor.g,
|
|
style.outlineColor.b,
|
|
style.outlineColor.a);
|
|
constants.outlineInfo = ::XCEngine::Math::Vector4(
|
|
style.debugSelectionMask ? 1.0f : 0.0f,
|
|
style.outlineWidthPixels,
|
|
0.0f,
|
|
0.0f);
|
|
constants.depthParams =
|
|
::XCEngine::Math::Vector4(1.0e-5f, 0.0f, 0.0f, 0.0f);
|
|
|
|
m_constantSet->WriteConstant(0, &constants, sizeof(constants));
|
|
m_textureSet->Update(0, selectionMaskTextureView);
|
|
m_textureSet->Update(1, depthTextureView);
|
|
|
|
::XCEngine::RHI::RHICommandList* commandList =
|
|
renderContext.commandList;
|
|
::XCEngine::RHI::RHIResourceView* renderTarget = colorAttachments[0];
|
|
if (surface.IsAutoTransitionEnabled()) {
|
|
commandList->TransitionBarrier(
|
|
renderTarget,
|
|
surface.GetColorStateAfter(),
|
|
::XCEngine::RHI::ResourceStates::RenderTarget);
|
|
commandList->TransitionBarrier(
|
|
selectionMaskTextureView,
|
|
selectionMaskState,
|
|
::XCEngine::RHI::ResourceStates::PixelShaderResource);
|
|
commandList->TransitionBarrier(
|
|
depthTextureView,
|
|
depthTextureState,
|
|
::XCEngine::RHI::ResourceStates::PixelShaderResource);
|
|
}
|
|
commandList->SetRenderTargets(1, &renderTarget, nullptr);
|
|
|
|
const ::XCEngine::RHI::Viewport viewport = {
|
|
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 ::XCEngine::RHI::Rect scissorRect = {
|
|
renderArea.x,
|
|
renderArea.y,
|
|
renderArea.x + renderArea.width,
|
|
renderArea.y + renderArea.height
|
|
};
|
|
|
|
commandList->SetViewport(viewport);
|
|
commandList->SetScissorRect(scissorRect);
|
|
commandList->SetPrimitiveTopology(
|
|
::XCEngine::RHI::PrimitiveTopology::TriangleList);
|
|
commandList->SetPipelineState(m_pipelineState);
|
|
|
|
::XCEngine::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,
|
|
::XCEngine::RHI::ResourceStates::RenderTarget,
|
|
surface.GetColorStateAfter());
|
|
commandList->TransitionBarrier(
|
|
selectionMaskTextureView,
|
|
::XCEngine::RHI::ResourceStates::PixelShaderResource,
|
|
selectionMaskState);
|
|
commandList->TransitionBarrier(
|
|
depthTextureView,
|
|
::XCEngine::RHI::ResourceStates::PixelShaderResource,
|
|
depthTextureState);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool EnsureInitialized(
|
|
const ::XCEngine::Rendering::RenderContext& renderContext,
|
|
const ::XCEngine::Rendering::RenderSurface& surface) {
|
|
const ::XCEngine::RHI::Format renderTargetFormat =
|
|
::XCEngine::Rendering::ResolveSurfaceColorFormat(
|
|
surface,
|
|
0u);
|
|
const std::uint32_t renderTargetSampleCount =
|
|
::XCEngine::Rendering::ResolveSurfaceSampleCount(
|
|
surface);
|
|
if (m_pipelineLayout != nullptr &&
|
|
m_pipelineState != nullptr &&
|
|
m_constantPool != nullptr &&
|
|
m_constantSet != nullptr &&
|
|
m_texturePool != nullptr &&
|
|
m_textureSet != nullptr &&
|
|
m_device == renderContext.device &&
|
|
m_backendType == renderContext.backendType &&
|
|
m_renderTargetFormat == renderTargetFormat &&
|
|
m_renderTargetSampleCount == renderTargetSampleCount) {
|
|
return true;
|
|
}
|
|
|
|
if (HasCreatedResources()) {
|
|
DestroyResources();
|
|
}
|
|
return CreateResources(renderContext, surface);
|
|
}
|
|
|
|
bool CreateResources(
|
|
const ::XCEngine::Rendering::RenderContext& renderContext,
|
|
const ::XCEngine::Rendering::RenderSurface& surface) {
|
|
if (!renderContext.IsValid()) {
|
|
return false;
|
|
}
|
|
|
|
if (!::XCEngine::Rendering::HasSingleColorAttachment(surface) ||
|
|
::XCEngine::Rendering::ResolveSurfaceColorFormat(
|
|
surface,
|
|
0u) == ::XCEngine::RHI::Format::Unknown) {
|
|
return false;
|
|
}
|
|
|
|
if (m_shaderPath.Empty()) {
|
|
::XCEngine::Debug::Logger::Get().Error(
|
|
::XCEngine::Debug::LogCategory::Rendering,
|
|
"SceneViewportSelectionOutlinePassRenderer requires a valid shader path");
|
|
return false;
|
|
}
|
|
|
|
::XCEngine::Resources::ResourceHandle<::XCEngine::Resources::Shader>
|
|
shader =
|
|
::XCEngine::Resources::ResourceManager::Get()
|
|
.Load<::XCEngine::Resources::Shader>(m_shaderPath);
|
|
if (!shader.IsValid()) {
|
|
::XCEngine::Debug::Logger::Get().Error(
|
|
::XCEngine::Debug::LogCategory::Rendering,
|
|
"SceneViewportSelectionOutlinePassRenderer failed to load selection-outline shader");
|
|
ResetState();
|
|
return false;
|
|
}
|
|
|
|
m_device = renderContext.device;
|
|
m_backendType = renderContext.backendType;
|
|
m_shader.emplace(std::move(shader));
|
|
|
|
const ::XCEngine::Resources::ShaderBackend backend =
|
|
::XCEngine::Rendering::ToShaderBackend(m_backendType);
|
|
const ::XCEngine::Resources::ShaderPass* outlinePass =
|
|
FindSelectionOutlineCompatiblePass(*m_shader->Get(), backend);
|
|
if (outlinePass == nullptr) {
|
|
::XCEngine::Debug::Logger::Get().Error(
|
|
::XCEngine::Debug::LogCategory::Rendering,
|
|
"SceneViewportSelectionOutlinePassRenderer could not resolve SelectionOutline pass");
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
::XCEngine::RHI::DescriptorSetLayoutBinding constantBinding = {};
|
|
constantBinding.binding = 0;
|
|
constantBinding.type =
|
|
static_cast<std::uint32_t>(::XCEngine::RHI::DescriptorType::CBV);
|
|
constantBinding.count = 1;
|
|
|
|
::XCEngine::RHI::DescriptorSetLayoutBinding textureBindings[2] = {};
|
|
textureBindings[0].binding = 0;
|
|
textureBindings[0].type =
|
|
static_cast<std::uint32_t>(::XCEngine::RHI::DescriptorType::SRV);
|
|
textureBindings[0].count = 1;
|
|
textureBindings[1].binding = 1;
|
|
textureBindings[1].type =
|
|
static_cast<std::uint32_t>(::XCEngine::RHI::DescriptorType::SRV);
|
|
textureBindings[1].count = 1;
|
|
|
|
::XCEngine::RHI::DescriptorSetLayoutDesc constantLayout = {};
|
|
constantLayout.bindings = &constantBinding;
|
|
constantLayout.bindingCount = 1;
|
|
|
|
::XCEngine::RHI::DescriptorSetLayoutDesc textureLayout = {};
|
|
textureLayout.bindings = textureBindings;
|
|
textureLayout.bindingCount = 2;
|
|
|
|
::XCEngine::RHI::DescriptorSetLayoutDesc setLayouts[2] = {};
|
|
setLayouts[0] = constantLayout;
|
|
setLayouts[1] = textureLayout;
|
|
|
|
::XCEngine::RHI::RHIPipelineLayoutDesc pipelineLayoutDesc = {};
|
|
pipelineLayoutDesc.setLayouts = setLayouts;
|
|
pipelineLayoutDesc.setLayoutCount = 2;
|
|
m_pipelineLayout =
|
|
m_device->CreatePipelineLayout(pipelineLayoutDesc);
|
|
if (m_pipelineLayout == nullptr) {
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
::XCEngine::RHI::DescriptorPoolDesc constantPoolDesc = {};
|
|
constantPoolDesc.type =
|
|
::XCEngine::RHI::DescriptorHeapType::CBV_SRV_UAV;
|
|
constantPoolDesc.descriptorCount = 1;
|
|
constantPoolDesc.shaderVisible = false;
|
|
m_constantPool = m_device->CreateDescriptorPool(constantPoolDesc);
|
|
if (m_constantPool == nullptr) {
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_constantSet = m_constantPool->AllocateSet(constantLayout);
|
|
if (m_constantSet == nullptr) {
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
::XCEngine::RHI::DescriptorPoolDesc texturePoolDesc = {};
|
|
texturePoolDesc.type =
|
|
::XCEngine::RHI::DescriptorHeapType::CBV_SRV_UAV;
|
|
texturePoolDesc.descriptorCount = 2;
|
|
texturePoolDesc.shaderVisible = true;
|
|
m_texturePool = m_device->CreateDescriptorPool(texturePoolDesc);
|
|
if (m_texturePool == nullptr) {
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_textureSet = m_texturePool->AllocateSet(textureLayout);
|
|
if (m_textureSet == nullptr) {
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_pipelineState = m_device->CreatePipelineState(
|
|
CreatePipelineDesc(
|
|
m_backendType,
|
|
m_pipelineLayout,
|
|
*m_shader->Get(),
|
|
outlinePass->name,
|
|
surface));
|
|
if (m_pipelineState == nullptr || !m_pipelineState->IsValid()) {
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_renderTargetFormat =
|
|
::XCEngine::Rendering::ResolveSurfaceColorFormat(
|
|
surface,
|
|
0u);
|
|
m_renderTargetSampleCount =
|
|
::XCEngine::Rendering::ResolveSurfaceSampleCount(
|
|
surface);
|
|
return true;
|
|
}
|
|
|
|
bool HasCreatedResources() const {
|
|
return m_device != nullptr ||
|
|
m_pipelineLayout != nullptr ||
|
|
m_pipelineState != nullptr ||
|
|
m_constantPool != nullptr ||
|
|
m_constantSet != nullptr ||
|
|
m_texturePool != nullptr ||
|
|
m_textureSet != nullptr ||
|
|
m_shader.has_value();
|
|
}
|
|
|
|
void DestroyResources() {
|
|
if (m_pipelineState != nullptr) {
|
|
m_pipelineState->Shutdown();
|
|
delete m_pipelineState;
|
|
m_pipelineState = nullptr;
|
|
}
|
|
|
|
if (m_textureSet != nullptr) {
|
|
m_textureSet->Shutdown();
|
|
delete m_textureSet;
|
|
m_textureSet = nullptr;
|
|
}
|
|
|
|
if (m_texturePool != nullptr) {
|
|
m_texturePool->Shutdown();
|
|
delete m_texturePool;
|
|
m_texturePool = nullptr;
|
|
}
|
|
|
|
if (m_constantSet != nullptr) {
|
|
m_constantSet->Shutdown();
|
|
delete m_constantSet;
|
|
m_constantSet = nullptr;
|
|
}
|
|
|
|
if (m_constantPool != nullptr) {
|
|
m_constantPool->Shutdown();
|
|
delete m_constantPool;
|
|
m_constantPool = nullptr;
|
|
}
|
|
|
|
if (m_pipelineLayout != nullptr) {
|
|
m_pipelineLayout->Shutdown();
|
|
delete m_pipelineLayout;
|
|
m_pipelineLayout = nullptr;
|
|
}
|
|
|
|
if (m_shader.has_value()) {
|
|
m_shader.reset();
|
|
}
|
|
|
|
ResetState();
|
|
}
|
|
|
|
void ResetState() {
|
|
m_device = nullptr;
|
|
m_backendType = ::XCEngine::RHI::RHIType::D3D12;
|
|
m_pipelineLayout = nullptr;
|
|
m_pipelineState = nullptr;
|
|
m_constantPool = nullptr;
|
|
m_constantSet = nullptr;
|
|
m_texturePool = nullptr;
|
|
m_textureSet = nullptr;
|
|
m_shader.reset();
|
|
m_renderTargetFormat = ::XCEngine::RHI::Format::Unknown;
|
|
m_renderTargetSampleCount = 1u;
|
|
}
|
|
|
|
std::unique_ptr<SceneViewportSelectionMaskPass> m_selectionMaskPass = {};
|
|
::XCEngine::RHI::RHIDevice* m_device = nullptr;
|
|
::XCEngine::RHI::RHIType m_backendType =
|
|
::XCEngine::RHI::RHIType::D3D12;
|
|
::XCEngine::RHI::RHIPipelineLayout* m_pipelineLayout = nullptr;
|
|
::XCEngine::RHI::RHIPipelineState* m_pipelineState = nullptr;
|
|
::XCEngine::RHI::RHIDescriptorPool* m_constantPool = nullptr;
|
|
::XCEngine::RHI::RHIDescriptorSet* m_constantSet = nullptr;
|
|
::XCEngine::RHI::RHIDescriptorPool* m_texturePool = nullptr;
|
|
::XCEngine::RHI::RHIDescriptorSet* m_textureSet = nullptr;
|
|
::XCEngine::Containers::String m_shaderPath = {};
|
|
std::optional<
|
|
::XCEngine::Resources::ResourceHandle<::XCEngine::Resources::Shader>>
|
|
m_shader = {};
|
|
::XCEngine::RHI::Format m_renderTargetFormat =
|
|
::XCEngine::RHI::Format::Unknown;
|
|
std::uint32_t m_renderTargetSampleCount = 1u;
|
|
};
|
|
|
|
SceneViewportSelectionOutlinePassRenderer::
|
|
SceneViewportSelectionOutlinePassRenderer()
|
|
: m_impl(std::make_unique<Impl>()) {
|
|
}
|
|
|
|
SceneViewportSelectionOutlinePassRenderer::
|
|
~SceneViewportSelectionOutlinePassRenderer() = default;
|
|
|
|
void SceneViewportSelectionOutlinePassRenderer::Shutdown() {
|
|
m_impl->Shutdown();
|
|
}
|
|
|
|
bool SceneViewportSelectionOutlinePassRenderer::Render(
|
|
const ::XCEngine::Rendering::RenderContext& renderContext,
|
|
const ::XCEngine::Rendering::RenderSurface& surface,
|
|
const ::XCEngine::Rendering::RenderSceneData& sceneData,
|
|
ViewportRenderTargets& targets,
|
|
const std::vector<std::uint64_t>& selectedObjectIds,
|
|
const SceneViewportSelectionOutlineStyle& style) {
|
|
return m_impl->Render(
|
|
renderContext,
|
|
surface,
|
|
sceneData,
|
|
targets,
|
|
selectedObjectIds,
|
|
style);
|
|
}
|
|
|
|
std::unique_ptr<::XCEngine::Rendering::RenderPass>
|
|
CreateSceneViewportSelectionOutlinePass(
|
|
SceneViewportSelectionOutlinePassRenderer& renderer,
|
|
ViewportRenderTargets* targets,
|
|
const std::vector<std::uint64_t>& selectedObjectIds,
|
|
const SceneViewportSelectionOutlineStyle& style) {
|
|
return std::make_unique<SceneViewportSelectionOutlinePass>(
|
|
renderer,
|
|
targets,
|
|
selectedObjectIds,
|
|
style);
|
|
}
|
|
|
|
} // namespace XCEngine::UI::Editor::App
|