Add rendering post-process scene integration test
This commit is contained in:
439
engine/src/Rendering/Passes/BuiltinColorScalePostProcessPass.cpp
Normal file
439
engine/src/Rendering/Passes/BuiltinColorScalePostProcessPass.cpp
Normal file
@@ -0,0 +1,439 @@
|
||||
#include "Rendering/Passes/BuiltinColorScalePostProcessPass.h"
|
||||
|
||||
#include "Core/Asset/ResourceManager.h"
|
||||
#include "Debug/Logger.h"
|
||||
#include "Rendering/Detail/ShaderVariantUtils.h"
|
||||
#include "Rendering/RenderSurface.h"
|
||||
#include "Resources/BuiltinResources.h"
|
||||
#include "RHI/RHICommandList.h"
|
||||
#include "RHI/RHIDescriptorPool.h"
|
||||
#include "RHI/RHIDescriptorSet.h"
|
||||
#include "RHI/RHIDevice.h"
|
||||
#include "RHI/RHIPipelineLayout.h"
|
||||
#include "RHI/RHIPipelineState.h"
|
||||
#include "RHI/RHIResourceView.h"
|
||||
#include "RHI/RHISampler.h"
|
||||
|
||||
#include <utility>
|
||||
|
||||
namespace XCEngine {
|
||||
namespace Rendering {
|
||||
namespace Passes {
|
||||
|
||||
namespace {
|
||||
|
||||
struct PostProcessConstants {
|
||||
Math::Vector4 colorScale = Math::Vector4::One();
|
||||
};
|
||||
|
||||
const Resources::ShaderPass* FindCompatiblePass(
|
||||
const Resources::Shader& shader,
|
||||
Resources::ShaderBackend backend) {
|
||||
const Resources::ShaderPass* colorScalePass = shader.FindPass("ColorScale");
|
||||
if (colorScalePass != nullptr &&
|
||||
::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, colorScalePass->name, backend)) {
|
||||
return colorScalePass;
|
||||
}
|
||||
|
||||
if (shader.GetPassCount() > 0 &&
|
||||
::XCEngine::Rendering::Detail::ShaderPassHasGraphicsVariants(shader, shader.GetPasses()[0].name, backend)) {
|
||||
return &shader.GetPasses()[0];
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
RHI::GraphicsPipelineDesc CreatePipelineDesc(
|
||||
RHI::RHIType backendType,
|
||||
RHI::RHIPipelineLayout* pipelineLayout,
|
||||
const Resources::Shader& shader,
|
||||
const Containers::String& passName,
|
||||
RHI::Format renderTargetFormat) {
|
||||
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>(renderTargetFormat);
|
||||
pipelineDesc.depthStencilFormat = static_cast<uint32_t>(RHI::Format::Unknown);
|
||||
pipelineDesc.sampleCount = 1;
|
||||
|
||||
pipelineDesc.rasterizerState.fillMode = static_cast<uint32_t>(RHI::FillMode::Solid);
|
||||
pipelineDesc.rasterizerState.cullMode = static_cast<uint32_t>(RHI::CullMode::None);
|
||||
pipelineDesc.rasterizerState.frontFace = static_cast<uint32_t>(RHI::FrontFace::CounterClockwise);
|
||||
pipelineDesc.rasterizerState.depthClipEnable = true;
|
||||
|
||||
pipelineDesc.blendState.blendEnable = false;
|
||||
pipelineDesc.blendState.srcBlend = static_cast<uint32_t>(RHI::BlendFactor::One);
|
||||
pipelineDesc.blendState.dstBlend = static_cast<uint32_t>(RHI::BlendFactor::Zero);
|
||||
pipelineDesc.blendState.srcBlendAlpha = static_cast<uint32_t>(RHI::BlendFactor::One);
|
||||
pipelineDesc.blendState.dstBlendAlpha = static_cast<uint32_t>(RHI::BlendFactor::Zero);
|
||||
pipelineDesc.blendState.blendOp = static_cast<uint32_t>(RHI::BlendOp::Add);
|
||||
pipelineDesc.blendState.blendOpAlpha = static_cast<uint32_t>(RHI::BlendOp::Add);
|
||||
pipelineDesc.blendState.colorWriteMask = static_cast<uint8_t>(RHI::ColorWriteMask::All);
|
||||
|
||||
pipelineDesc.depthStencilState.depthTestEnable = false;
|
||||
pipelineDesc.depthStencilState.depthWriteEnable = false;
|
||||
pipelineDesc.depthStencilState.depthFunc = static_cast<uint32_t>(RHI::ComparisonFunc::Always);
|
||||
|
||||
const Resources::ShaderBackend backend = ::XCEngine::Rendering::Detail::ToShaderBackend(backendType);
|
||||
if (const Resources::ShaderStageVariant* vertexVariant =
|
||||
shader.FindVariant(passName, Resources::ShaderType::Vertex, backend)) {
|
||||
::XCEngine::Rendering::Detail::ApplyShaderStageVariant(*vertexVariant, pipelineDesc.vertexShader);
|
||||
}
|
||||
if (const Resources::ShaderStageVariant* fragmentVariant =
|
||||
shader.FindVariant(passName, Resources::ShaderType::Fragment, backend)) {
|
||||
::XCEngine::Rendering::Detail::ApplyShaderStageVariant(*fragmentVariant, pipelineDesc.fragmentShader);
|
||||
}
|
||||
|
||||
return pipelineDesc;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
BuiltinColorScalePostProcessPass::BuiltinColorScalePostProcessPass(
|
||||
const Math::Vector4& colorScale,
|
||||
Containers::String shaderPath)
|
||||
: m_shaderPath(std::move(shaderPath))
|
||||
, m_colorScale(colorScale) {
|
||||
if (m_shaderPath.Empty()) {
|
||||
m_shaderPath = Resources::GetBuiltinColorScalePostProcessShaderPath();
|
||||
}
|
||||
}
|
||||
|
||||
BuiltinColorScalePostProcessPass::~BuiltinColorScalePostProcessPass() {
|
||||
Shutdown();
|
||||
}
|
||||
|
||||
const char* BuiltinColorScalePostProcessPass::GetName() const {
|
||||
return "BuiltinColorScalePostProcessPass";
|
||||
}
|
||||
|
||||
bool BuiltinColorScalePostProcessPass::Execute(const RenderPassContext& context) {
|
||||
if (!context.renderContext.IsValid() || context.sourceColorView == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const std::vector<RHI::RHIResourceView*>& colorAttachments = context.surface.GetColorAttachments();
|
||||
if (colorAttachments.empty() || colorAttachments[0] == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const Math::RectInt renderArea = context.surface.GetRenderArea();
|
||||
if (renderArea.width <= 0 || renderArea.height <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const RHI::Format renderTargetFormat = colorAttachments[0]->GetFormat();
|
||||
if (!EnsureInitialized(context.renderContext, renderTargetFormat)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
PostProcessConstants constants = {};
|
||||
constants.colorScale = m_colorScale;
|
||||
m_constantsSet.set->WriteConstant(0, &constants, sizeof(constants));
|
||||
|
||||
if (m_boundSourceColorView != context.sourceColorView) {
|
||||
m_textureSet.set->Update(0, context.sourceColorView);
|
||||
m_boundSourceColorView = context.sourceColorView;
|
||||
}
|
||||
|
||||
RHI::RHICommandList* commandList = context.renderContext.commandList;
|
||||
RHI::RHIResourceView* renderTarget = colorAttachments[0];
|
||||
|
||||
if (context.surface.IsAutoTransitionEnabled()) {
|
||||
commandList->TransitionBarrier(
|
||||
renderTarget,
|
||||
context.surface.GetColorStateBefore(),
|
||||
RHI::ResourceStates::RenderTarget);
|
||||
}
|
||||
|
||||
commandList->SetRenderTargets(1, &renderTarget, nullptr);
|
||||
|
||||
const 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 RHI::Rect scissorRect = {
|
||||
renderArea.x,
|
||||
renderArea.y,
|
||||
renderArea.x + renderArea.width,
|
||||
renderArea.y + renderArea.height
|
||||
};
|
||||
|
||||
commandList->SetViewport(viewport);
|
||||
commandList->SetScissorRect(scissorRect);
|
||||
commandList->SetPrimitiveTopology(RHI::PrimitiveTopology::TriangleList);
|
||||
commandList->SetPipelineState(m_pipelineState);
|
||||
|
||||
RHI::RHIDescriptorSet* descriptorSets[] = {
|
||||
m_constantsSet.set,
|
||||
m_textureSet.set,
|
||||
m_samplerSet.set
|
||||
};
|
||||
commandList->SetGraphicsDescriptorSets(0, 3, descriptorSets, m_pipelineLayout);
|
||||
commandList->Draw(3, 1, 0, 0);
|
||||
commandList->EndRenderPass();
|
||||
|
||||
if (context.surface.IsAutoTransitionEnabled()) {
|
||||
commandList->TransitionBarrier(
|
||||
renderTarget,
|
||||
RHI::ResourceStates::RenderTarget,
|
||||
context.surface.GetColorStateAfter());
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void BuiltinColorScalePostProcessPass::Shutdown() {
|
||||
DestroyResources();
|
||||
}
|
||||
|
||||
void BuiltinColorScalePostProcessPass::SetColorScale(const Math::Vector4& colorScale) {
|
||||
m_colorScale = colorScale;
|
||||
}
|
||||
|
||||
const Math::Vector4& BuiltinColorScalePostProcessPass::GetColorScale() const {
|
||||
return m_colorScale;
|
||||
}
|
||||
|
||||
void BuiltinColorScalePostProcessPass::SetShaderPath(const Containers::String& shaderPath) {
|
||||
if (m_shaderPath == shaderPath) {
|
||||
return;
|
||||
}
|
||||
|
||||
DestroyResources();
|
||||
m_shaderPath = shaderPath;
|
||||
}
|
||||
|
||||
const Containers::String& BuiltinColorScalePostProcessPass::GetShaderPath() const {
|
||||
return m_shaderPath;
|
||||
}
|
||||
|
||||
bool BuiltinColorScalePostProcessPass::EnsureInitialized(
|
||||
const RenderContext& renderContext,
|
||||
RHI::Format renderTargetFormat) {
|
||||
if (m_device == renderContext.device &&
|
||||
m_backendType == renderContext.backendType &&
|
||||
m_renderTargetFormat == renderTargetFormat &&
|
||||
m_pipelineLayout != nullptr &&
|
||||
m_pipelineState != nullptr &&
|
||||
m_sampler != nullptr &&
|
||||
m_constantsSet.set != nullptr &&
|
||||
m_textureSet.set != nullptr &&
|
||||
m_samplerSet.set != nullptr) {
|
||||
return true;
|
||||
}
|
||||
|
||||
DestroyResources();
|
||||
return CreateResources(renderContext, renderTargetFormat);
|
||||
}
|
||||
|
||||
bool BuiltinColorScalePostProcessPass::CreateResources(
|
||||
const RenderContext& renderContext,
|
||||
RHI::Format renderTargetFormat) {
|
||||
if (!renderContext.IsValid()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m_shaderPath.Empty()) {
|
||||
Debug::Logger::Get().Error(
|
||||
Debug::LogCategory::Rendering,
|
||||
"BuiltinColorScalePostProcessPass requires a shader path before resource creation");
|
||||
return false;
|
||||
}
|
||||
|
||||
m_shader = Resources::ResourceManager::Get().Load<Resources::Shader>(m_shaderPath);
|
||||
if (!m_shader.IsValid()) {
|
||||
Debug::Logger::Get().Error(
|
||||
Debug::LogCategory::Rendering,
|
||||
"BuiltinColorScalePostProcessPass failed to load configured post-process shader resource");
|
||||
DestroyResources();
|
||||
return false;
|
||||
}
|
||||
|
||||
const Resources::ShaderBackend backend = ::XCEngine::Rendering::Detail::ToShaderBackend(renderContext.backendType);
|
||||
const Resources::ShaderPass* colorScalePass = FindCompatiblePass(*m_shader.Get(), backend);
|
||||
if (colorScalePass == nullptr) {
|
||||
Debug::Logger::Get().Error(
|
||||
Debug::LogCategory::Rendering,
|
||||
"BuiltinColorScalePostProcessPass could not resolve a valid ColorScale shader pass");
|
||||
DestroyResources();
|
||||
return false;
|
||||
}
|
||||
|
||||
m_device = renderContext.device;
|
||||
m_backendType = renderContext.backendType;
|
||||
m_renderTargetFormat = renderTargetFormat;
|
||||
|
||||
RHI::DescriptorSetLayoutBinding constantBinding = {};
|
||||
constantBinding.binding = 0;
|
||||
constantBinding.type = static_cast<uint32_t>(RHI::DescriptorType::CBV);
|
||||
constantBinding.count = 1;
|
||||
constantBinding.visibility = static_cast<uint32_t>(RHI::ShaderVisibility::All);
|
||||
|
||||
RHI::DescriptorSetLayoutBinding textureBinding = {};
|
||||
textureBinding.binding = 0;
|
||||
textureBinding.type = static_cast<uint32_t>(RHI::DescriptorType::SRV);
|
||||
textureBinding.count = 1;
|
||||
textureBinding.visibility = static_cast<uint32_t>(RHI::ShaderVisibility::All);
|
||||
|
||||
RHI::DescriptorSetLayoutBinding samplerBinding = {};
|
||||
samplerBinding.binding = 0;
|
||||
samplerBinding.type = static_cast<uint32_t>(RHI::DescriptorType::Sampler);
|
||||
samplerBinding.count = 1;
|
||||
samplerBinding.visibility = static_cast<uint32_t>(RHI::ShaderVisibility::All);
|
||||
|
||||
RHI::DescriptorSetLayoutDesc constantLayout = {};
|
||||
constantLayout.bindings = &constantBinding;
|
||||
constantLayout.bindingCount = 1;
|
||||
|
||||
RHI::DescriptorSetLayoutDesc textureLayout = {};
|
||||
textureLayout.bindings = &textureBinding;
|
||||
textureLayout.bindingCount = 1;
|
||||
|
||||
RHI::DescriptorSetLayoutDesc samplerLayout = {};
|
||||
samplerLayout.bindings = &samplerBinding;
|
||||
samplerLayout.bindingCount = 1;
|
||||
|
||||
RHI::DescriptorSetLayoutDesc setLayouts[] = {
|
||||
constantLayout,
|
||||
textureLayout,
|
||||
samplerLayout
|
||||
};
|
||||
|
||||
RHI::RHIPipelineLayoutDesc pipelineLayoutDesc = {};
|
||||
pipelineLayoutDesc.setLayouts = setLayouts;
|
||||
pipelineLayoutDesc.setLayoutCount = 3;
|
||||
m_pipelineLayout = m_device->CreatePipelineLayout(pipelineLayoutDesc);
|
||||
if (m_pipelineLayout == nullptr) {
|
||||
DestroyResources();
|
||||
return false;
|
||||
}
|
||||
|
||||
RHI::SamplerDesc samplerDesc = {};
|
||||
samplerDesc.filter = static_cast<uint32_t>(RHI::FilterMode::Linear);
|
||||
samplerDesc.addressU = static_cast<uint32_t>(RHI::TextureAddressMode::Clamp);
|
||||
samplerDesc.addressV = static_cast<uint32_t>(RHI::TextureAddressMode::Clamp);
|
||||
samplerDesc.addressW = static_cast<uint32_t>(RHI::TextureAddressMode::Clamp);
|
||||
samplerDesc.mipLodBias = 0.0f;
|
||||
samplerDesc.maxAnisotropy = 1;
|
||||
samplerDesc.comparisonFunc = static_cast<uint32_t>(RHI::ComparisonFunc::Always);
|
||||
samplerDesc.minLod = 0.0f;
|
||||
samplerDesc.maxLod = 1000.0f;
|
||||
m_sampler = m_device->CreateSampler(samplerDesc);
|
||||
if (m_sampler == nullptr) {
|
||||
DestroyResources();
|
||||
return false;
|
||||
}
|
||||
|
||||
auto createOwnedDescriptorSet =
|
||||
[this](const RHI::DescriptorSetLayoutDesc& layout,
|
||||
RHI::DescriptorHeapType heapType,
|
||||
bool shaderVisible,
|
||||
OwnedDescriptorSet& ownedSet) -> bool {
|
||||
RHI::DescriptorPoolDesc poolDesc = {};
|
||||
poolDesc.type = heapType;
|
||||
poolDesc.descriptorCount = 1;
|
||||
poolDesc.shaderVisible = shaderVisible;
|
||||
ownedSet.pool = m_device->CreateDescriptorPool(poolDesc);
|
||||
if (ownedSet.pool == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ownedSet.set = ownedSet.pool->AllocateSet(layout);
|
||||
if (ownedSet.set == nullptr) {
|
||||
DestroyOwnedDescriptorSet(ownedSet);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
if (!createOwnedDescriptorSet(
|
||||
constantLayout,
|
||||
RHI::DescriptorHeapType::CBV_SRV_UAV,
|
||||
false,
|
||||
m_constantsSet) ||
|
||||
!createOwnedDescriptorSet(
|
||||
textureLayout,
|
||||
RHI::DescriptorHeapType::CBV_SRV_UAV,
|
||||
true,
|
||||
m_textureSet) ||
|
||||
!createOwnedDescriptorSet(
|
||||
samplerLayout,
|
||||
RHI::DescriptorHeapType::Sampler,
|
||||
true,
|
||||
m_samplerSet)) {
|
||||
DestroyResources();
|
||||
return false;
|
||||
}
|
||||
|
||||
m_samplerSet.set->UpdateSampler(0, m_sampler);
|
||||
|
||||
m_pipelineState = m_device->CreatePipelineState(
|
||||
CreatePipelineDesc(
|
||||
m_backendType,
|
||||
m_pipelineLayout,
|
||||
*m_shader.Get(),
|
||||
colorScalePass->name,
|
||||
m_renderTargetFormat));
|
||||
if (m_pipelineState == nullptr || !m_pipelineState->IsValid()) {
|
||||
DestroyResources();
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void BuiltinColorScalePostProcessPass::DestroyResources() {
|
||||
m_boundSourceColorView = nullptr;
|
||||
|
||||
if (m_pipelineState != nullptr) {
|
||||
m_pipelineState->Shutdown();
|
||||
delete m_pipelineState;
|
||||
m_pipelineState = nullptr;
|
||||
}
|
||||
|
||||
DestroyOwnedDescriptorSet(m_samplerSet);
|
||||
DestroyOwnedDescriptorSet(m_textureSet);
|
||||
DestroyOwnedDescriptorSet(m_constantsSet);
|
||||
|
||||
if (m_pipelineLayout != nullptr) {
|
||||
m_pipelineLayout->Shutdown();
|
||||
delete m_pipelineLayout;
|
||||
m_pipelineLayout = nullptr;
|
||||
}
|
||||
|
||||
if (m_sampler != nullptr) {
|
||||
m_sampler->Shutdown();
|
||||
delete m_sampler;
|
||||
m_sampler = nullptr;
|
||||
}
|
||||
|
||||
m_shader.Reset();
|
||||
m_device = nullptr;
|
||||
m_backendType = RHI::RHIType::D3D12;
|
||||
m_renderTargetFormat = RHI::Format::Unknown;
|
||||
}
|
||||
|
||||
void BuiltinColorScalePostProcessPass::DestroyOwnedDescriptorSet(OwnedDescriptorSet& descriptorSet) {
|
||||
if (descriptorSet.set != nullptr) {
|
||||
descriptorSet.set->Shutdown();
|
||||
delete descriptorSet.set;
|
||||
descriptorSet.set = nullptr;
|
||||
}
|
||||
|
||||
if (descriptorSet.pool != nullptr) {
|
||||
descriptorSet.pool->Shutdown();
|
||||
delete descriptorSet.pool;
|
||||
descriptorSet.pool = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace Passes
|
||||
} // namespace Rendering
|
||||
} // namespace XCEngine
|
||||
@@ -33,6 +33,8 @@ constexpr const char* kBuiltinDepthOnlyShaderPath = "builtin://shaders/depth-onl
|
||||
constexpr const char* kBuiltinShadowCasterShaderPath = "builtin://shaders/shadow-caster";
|
||||
constexpr const char* kBuiltinObjectIdShaderPath = "builtin://shaders/object-id";
|
||||
constexpr const char* kBuiltinSkyboxShaderPath = "builtin://shaders/skybox";
|
||||
constexpr const char* kBuiltinColorScalePostProcessShaderPath =
|
||||
"builtin://shaders/color-scale-post-process";
|
||||
constexpr const char* kBuiltinDefaultPrimitiveTexturePath = "builtin://textures/default-primitive-albedo";
|
||||
constexpr float kPi = 3.14159265358979323846f;
|
||||
|
||||
@@ -55,6 +57,8 @@ constexpr const char* kBuiltinObjectIdShaderManifestRelativePath =
|
||||
"engine/assets/builtin/shaders/object-id/object-id.shader";
|
||||
constexpr const char* kBuiltinSkyboxShaderManifestRelativePath =
|
||||
"engine/assets/builtin/shaders/skybox/skybox.shader";
|
||||
constexpr const char* kBuiltinColorScalePostProcessShaderManifestRelativePath =
|
||||
"engine/assets/builtin/shaders/color-scale-post-process/color-scale-post-process.shader";
|
||||
|
||||
Containers::String NormalizeBuiltinAssetPath(const std::filesystem::path& path) {
|
||||
return Containers::String(path.lexically_normal().generic_string().c_str());
|
||||
@@ -136,6 +140,9 @@ const char* GetBuiltinShaderManifestRelativePath(const Containers::String& built
|
||||
if (builtinShaderPath == Containers::String(kBuiltinSkyboxShaderPath)) {
|
||||
return kBuiltinSkyboxShaderManifestRelativePath;
|
||||
}
|
||||
if (builtinShaderPath == Containers::String(kBuiltinColorScalePostProcessShaderPath)) {
|
||||
return kBuiltinColorScalePostProcessShaderManifestRelativePath;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
@@ -680,6 +687,10 @@ Shader* BuildBuiltinSkyboxShader(const Containers::String& path) {
|
||||
return TryLoadBuiltinShaderFromManifest(path);
|
||||
}
|
||||
|
||||
Shader* BuildBuiltinColorScalePostProcessShader(const Containers::String& path) {
|
||||
return TryLoadBuiltinShaderFromManifest(path);
|
||||
}
|
||||
|
||||
Material* BuildDefaultPrimitiveMaterial(const Containers::String& path) {
|
||||
auto* material = new Material();
|
||||
IResource::ConstructParams params;
|
||||
@@ -802,6 +813,10 @@ Containers::String GetBuiltinSkyboxShaderPath() {
|
||||
return Containers::String(kBuiltinSkyboxShaderPath);
|
||||
}
|
||||
|
||||
Containers::String GetBuiltinColorScalePostProcessShaderPath() {
|
||||
return Containers::String(kBuiltinColorScalePostProcessShaderPath);
|
||||
}
|
||||
|
||||
Containers::String GetBuiltinDefaultPrimitiveTexturePath() {
|
||||
return Containers::String(kBuiltinDefaultPrimitiveTexturePath);
|
||||
}
|
||||
@@ -905,6 +920,8 @@ LoadResult CreateBuiltinShaderResource(const Containers::String& path) {
|
||||
shader = BuildBuiltinObjectIdShader(path);
|
||||
} else if (path == GetBuiltinSkyboxShaderPath()) {
|
||||
shader = BuildBuiltinSkyboxShader(path);
|
||||
} else if (path == GetBuiltinColorScalePostProcessShaderPath()) {
|
||||
shader = BuildBuiltinColorScalePostProcessShader(path);
|
||||
} else {
|
||||
return LoadResult(Containers::String("Unknown builtin shader: ") + path);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user