birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
cc615a8f325cce418292d3fc6b82291191bade75
o3de/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderAsset.cpp
T
galibzon cc615a8f32 [ATOM-15472] Shader Build Pipeline: Remove Deprecated Files And Funct… (#1079) 
* [ATOM-15472] Shader Build Pipeline: Remove Deprecated Files And Functions That
Predate The Shader Supervariants

These are the essential impactful changes as a result of deprecating the
ShaderResourceGroupAsset.

* Addressed feedback by @moudgils. Better comments in header files.

* More updates related with deprecation of ShaderResourceGroupAsset

* Deleted the temporary version 2 classes.

* Updated version of the shader asset builders.

* Updated version of all the shader related classes impacted
by the Supervariant concept and deprecation of ShaderResourceGroupAsset

* Changes to *.pass and DGI, Reflections and RayTracing.

* changes to material related assets

* changes to core lights

* Changes to auxgeom/dynamic draw.

* changes to decals, lyshine, imguipass

* changes to RPI Pass classes

* Shader for SceneSrg, ViewSrg and ForwardPass Srgs.

* changes to mesh, skinned mesh, Morphtarget.

* Fixes to RayTracingPass.cpp & now allow empty srg in shaders.

* Updated Atom_RPI.Tests

* Simplified InstanceDatabase by removing AddHandler

------------------------------------------------------------------------------------
* Updated DiffuseGI precompiled shaders.
Added RayTracingSceneSrg and RayTracingMaterialSrg shader asset.
Updated ShaderAssetCreator::Clone to handle the supervariant when processing root variants.
Co-authored-by: Doug McDiarmid <dmcdiar@amazon.com>
------------------------------------------------------------------------------------

* Changed semantics for some PassSrg to SRG_PerPass_WithFallback.

AuxGeom/FixedShapeProcessor.cpp requires SRG_PerDraw on ObjectSrg.

Removed names of SceneSrg and ViewSrg from RPISystemDescriptor.cpp

* Moved ShaderLib/Atom/Features/DummyEntryFunctions.azsli
To  Gems/Atom/RPI/Assets/ShaderLib/Atom/RPI/DummyEntryFunctions.azsli

Removed redundant checking for finalization in
ShaderResourceGroupLayout.cpp

* Fixed race condition bug for Shader::FindOrCreate.
InstanceDatabase<>::CreateInstance() needs to be atomic
for instance creation and initialization.

Added optional InstanceHandler::CreateFunctionWithParams to accomodate
to the needs of Instances that need more than an asset reference
to be able to be created an initialzed.

Removed ShaderResourceGroup::FindOrCreate() only ::Create is available
now.

* Renamed scene_and_view_srgs.* as SceneAndViewSrgs.*

Changed GetAzslFileOfOrigin for GetUniqueId

* Fixed unit tests.

* Reverted the serialization name of m_uniqueId back to
"m_azslFileOfOrigin" so precompiled shaders don't fail
in layout comparison.

* Fixed AtomCore.Tests
Removed non-applicable test. InstanceDatabase.AddHandler() is not
available anymore.

* The Null rhi is re-enabled for shader compilation.

Signed-off-by: garrieta <garrieta@amazon.com>
2021-06-11 07:48:23 -05:00

591 lines
25 KiB
C++
Raw Blame History

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
#include <Atom/RPI.Reflect/Shader/ShaderCommonTypes.h>
#include <AzCore/Casting/numeric_cast.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/std/algorithm.h>
#include <Atom/RHI/Factory.h>
#include <AzCore/Interface/Interface.h>
#include <Atom/RPI.Reflect/Shader/IShaderVariantFinder.h>
#include <Atom/RPI.Public/Shader/ShaderReloadDebugTracker.h>
#include <Atom/RPI.Public/Shader/ShaderReloadNotificationBus.h>
namespace AZ
{
namespace RPI
{
const ShaderVariantStableId ShaderAsset::RootShaderVariantStableId{0};
static constexpr uint32_t SubProductTypeBitPosition = 0;
static constexpr uint32_t SubProductTypeNumBits = SupervariantIndexBitPosition - SubProductTypeBitPosition;
static constexpr uint32_t SubProductTypeMaxValue = (1 << SubProductTypeNumBits) - 1;
static_assert(RhiIndexMaxValue == RHI::Limits::APIType::PerPlatformApiUniqueIndexMax);
uint32_t ShaderAsset::MakeProductAssetSubId(
uint32_t rhiApiUniqueIndex, uint32_t supervariantIndex, uint32_t subProductType)
{
AZ_Assert(rhiApiUniqueIndex <= RhiIndexMaxValue, "Invalid rhiApiUniqueIndex [%u]", rhiApiUniqueIndex);
AZ_Assert(supervariantIndex <= SupervariantIndexMaxValue, "Invalid supervariantIndex [%u]", supervariantIndex);
AZ_Assert(subProductType <= SubProductTypeMaxValue, "Invalid subProductType [%u]", subProductType);
const uint32_t assetProductSubId = (rhiApiUniqueIndex << RhiIndexBitPosition) |
(supervariantIndex << SupervariantIndexBitPosition) | (subProductType << SubProductTypeBitPosition);
return assetProductSubId;
}
SupervariantIndex ShaderAsset::GetSupervariantIndexFromProductAssetSubId(uint32_t assetProducSubId)
{
const uint32_t supervariantIndex = assetProducSubId >> SupervariantIndexBitPosition;
return SupervariantIndex{supervariantIndex & SupervariantIndexMaxValue};
}
SupervariantIndex ShaderAsset::GetSupervariantIndexFromAssetId(const Data::AssetId& assetId)
{
return GetSupervariantIndexFromProductAssetSubId(assetId.m_subId);
}
void ShaderAsset::Supervariant::Reflect(AZ::ReflectContext* context)
{
if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
{
serializeContext->Class<Supervariant>()
->Version(1)
->Field("Name", &Supervariant::m_name)
->Field("SrgLayoutList", &Supervariant::m_srgLayoutList)
->Field("PipelineLayout", &Supervariant::m_pipelineLayoutDescriptor)
->Field("InputContract", &Supervariant::m_inputContract)
->Field("OutputContract", &Supervariant::m_outputContract)
->Field("RenderStates", &Supervariant::m_renderStates)
->Field("AttributeMapList", &Supervariant::m_attributeMaps)
->Field("RootVariantAsset", &Supervariant::m_rootShaderVariantAsset)
;
}
}
void ShaderAsset::ShaderApiDataContainer::Reflect(AZ::ReflectContext* context)
{
if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
{
serializeContext->Class<ShaderApiDataContainer>()
->Version(1)
->Field("APIType", &ShaderApiDataContainer::m_APIType)
->Field("Supervariants", &ShaderApiDataContainer::m_supervariants)
;
}
}
void ShaderAsset::Reflect(ReflectContext* context)
{
Supervariant::Reflect(context);
ShaderApiDataContainer::Reflect(context);
if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
{
serializeContext->Class<ShaderAsset>()
->Version(1)
->Field("name", &ShaderAsset::m_name)
->Field("pipelineStateType", &ShaderAsset::m_pipelineStateType)
->Field("shaderOptionGroupLayout", &ShaderAsset::m_shaderOptionGroupLayout)
->Field("drawListName", &ShaderAsset::m_drawListName)
->Field("shaderAssetBuildTimestamp", &ShaderAsset::m_shaderAssetBuildTimestamp)
->Field("perAPIShaderData", &ShaderAsset::m_perAPIShaderData)
;
}
}
ShaderAsset::~ShaderAsset()
{
Data::AssetBus::Handler::BusDisconnect();
ShaderVariantFinderNotificationBus::Handler::BusDisconnect();
}
const Name& ShaderAsset::GetName() const
{
return m_name;
}
RHI::PipelineStateType ShaderAsset::GetPipelineStateType() const
{
return m_pipelineStateType;
}
const ShaderOptionGroupLayout* ShaderAsset::GetShaderOptionGroupLayout() const
{
AZ_Assert(m_shaderOptionGroupLayout, "m_shaderOptionGroupLayout is null");
return m_shaderOptionGroupLayout.get();
}
const Name& ShaderAsset::GetDrawListName() const
{
return m_drawListName;
}
AZStd::sys_time_t ShaderAsset::GetShaderAssetBuildTimestamp() const
{
return m_shaderAssetBuildTimestamp;
}
void ShaderAsset::SetReady()
{
m_status = AssetStatus::Ready;
}
SupervariantIndex ShaderAsset::GetSupervariantIndex(const AZ::Name& supervariantName) const
{
const auto& supervariants = GetCurrentShaderApiData().m_supervariants;
const uint32_t supervariantCount = supervariants.size();
for (uint32_t index = 0; index < supervariantCount; ++index)
{
if (supervariants[index].m_name == supervariantName)
{
return SupervariantIndex{index};
}
}
return InvalidSupervariantIndex;
}
Data::Asset<ShaderVariantAsset> ShaderAsset::GetVariant(
const ShaderVariantId& shaderVariantId, SupervariantIndex supervariantIndex)
{
AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
auto variantFinder = AZ::Interface<IShaderVariantFinder>::Get();
AZ_Assert(variantFinder, "The IShaderVariantFinder doesn't exist");
Data::Asset<ShaderAsset> thisAsset(this, Data::AssetLoadBehavior::Default);
Data::Asset<ShaderVariantAsset> shaderVariantAsset =
variantFinder->GetShaderVariantAssetByVariantId(thisAsset, shaderVariantId, supervariantIndex);
if (!shaderVariantAsset)
{
variantFinder->QueueLoadShaderVariantAssetByVariantId(thisAsset, shaderVariantId, supervariantIndex);
}
return shaderVariantAsset;
}
ShaderVariantSearchResult ShaderAsset::FindVariantStableId(const ShaderVariantId& shaderVariantId)
{
AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
uint32_t dynamicOptionCount = aznumeric_cast<uint32_t>(GetShaderOptionGroupLayout()->GetShaderOptions().size());
ShaderVariantSearchResult variantSearchResult{RootShaderVariantStableId, dynamicOptionCount };
if (!dynamicOptionCount)
{
// The shader has no options at all. There's nothing to search.
return variantSearchResult;
}
auto variantFinder = AZ::Interface<IShaderVariantFinder>::Get();
AZ_Assert(variantFinder, "The IShaderVariantFinder doesn't exist");
{
AZStd::shared_lock<decltype(m_variantTreeMutex)> lock(m_variantTreeMutex);
if (m_shaderVariantTree)
{
return m_shaderVariantTree->FindVariantStableId(GetShaderOptionGroupLayout(), shaderVariantId);
}
}
AZStd::unique_lock<decltype(m_variantTreeMutex)> lock(m_variantTreeMutex);
if (!m_shaderVariantTree)
{
m_shaderVariantTree = variantFinder->GetShaderVariantTreeAsset(GetId());
if (!m_shaderVariantTree)
{
if (!m_shaderVariantTreeLoadWasRequested)
{
variantFinder->QueueLoadShaderVariantTreeAsset(GetId());
m_shaderVariantTreeLoadWasRequested = true;
}
// The variant tree could be under construction or simply doesn't exist at all.
return variantSearchResult;
}
}
return m_shaderVariantTree->FindVariantStableId(GetShaderOptionGroupLayout(), shaderVariantId);
}
Data::Asset<ShaderVariantAsset> ShaderAsset::GetVariant(
ShaderVariantStableId shaderVariantStableId, SupervariantIndex supervariantIndex) const
{
if (!shaderVariantStableId.IsValid() || shaderVariantStableId == RootShaderVariantStableId)
{
return GetRootVariant(supervariantIndex);
}
auto variantFinder = AZ::Interface<IShaderVariantFinder>::Get();
AZ_Assert(variantFinder, "No Variant Finder For shaderAsset with name [%s] and stableId [%u]", GetName().GetCStr(), shaderVariantStableId.GetIndex());
Data::Asset<ShaderVariantAsset> variant =
variantFinder->GetShaderVariantAsset(m_shaderVariantTree.GetId(), shaderVariantStableId, supervariantIndex);
if (!variant.IsReady())
{
// Enqueue a request to load the variant, next time around the caller will get the asset.
Data::AssetId variantTreeAssetId;
{
AZStd::shared_lock<decltype(m_variantTreeMutex)> lock(m_variantTreeMutex);
if (m_shaderVariantTree)
{
variantTreeAssetId = m_shaderVariantTree.GetId();
}
}
if (variantTreeAssetId.IsValid())
{
variantFinder->QueueLoadShaderVariantAsset(variantTreeAssetId, shaderVariantStableId, supervariantIndex);
}
return GetRootVariant(supervariantIndex);
}
else if (variant->GetBuildTimestamp() >= m_shaderAssetBuildTimestamp)
{
return variant;
}
else
{
// When rebuilding shaders we may be in a state where the ShaderAsset and root ShaderVariantAsset have been rebuilt and reloaded, but some (or all)
// shader variants haven't been built yet. Since we want to use the latest version of the shader code, ignore the old variants and fall back to the newer root variant instead.
AZ_Warning("ShaderAsset", false, "ShaderAsset and ShaderVariantAsset are out of sync; defaulting to root shader variant. (This is common while reloading shaders).");
return GetRootVariant(supervariantIndex);
}
}
Data::Asset<ShaderVariantAsset> ShaderAsset::GetRootVariant(SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
if (!supervariant)
{
return Data::Asset<ShaderVariantAsset>();
}
return supervariant->m_rootShaderVariantAsset;
}
const RHI::Ptr<RHI::ShaderResourceGroupLayout>& ShaderAsset::FindShaderResourceGroupLayout(
const Name& shaderResourceGroupName, SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
if (!supervariant)
{
return RHI::NullSrgLayout;
}
const auto& srgLayoutList = supervariant->m_srgLayoutList;
const auto findIt = AZStd::find_if(srgLayoutList.begin(), srgLayoutList.end(), [&](const RHI::Ptr<RHI::ShaderResourceGroupLayout>& layout)
{
return layout->GetName() == shaderResourceGroupName;
});
if (findIt != srgLayoutList.end())
{
return *findIt;
}
return RHI::NullSrgLayout;
}
const RHI::Ptr<RHI::ShaderResourceGroupLayout>& ShaderAsset::FindShaderResourceGroupLayout(
uint32_t bindingSlot, SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
if (!supervariant)
{
return RHI::NullSrgLayout;
}
const auto& srgLayoutList = supervariant->m_srgLayoutList;
const auto findIt =
AZStd::find_if(srgLayoutList.begin(), srgLayoutList.end(), [&](const RHI::Ptr<RHI::ShaderResourceGroupLayout>& layout)
{
return layout && layout->GetBindingSlot() == bindingSlot;
});
if (findIt != srgLayoutList.end())
{
return *findIt;
}
return RHI::NullSrgLayout;
}
const RHI::Ptr<RHI::ShaderResourceGroupLayout>& ShaderAsset::FindFallbackShaderResourceGroupLayout(
SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
if (!supervariant)
{
return RHI::NullSrgLayout;
}
const auto& srgLayoutList = supervariant->m_srgLayoutList;
const auto findIt =
AZStd::find_if(srgLayoutList.begin(), srgLayoutList.end(), [&](const RHI::Ptr<RHI::ShaderResourceGroupLayout>& layout)
{
return layout && layout->HasShaderVariantKeyFallbackEntry();
});
if (findIt != srgLayoutList.end())
{
return *findIt;
}
return RHI::NullSrgLayout;
}
AZStd::array_view<RHI::Ptr<RHI::ShaderResourceGroupLayout>> ShaderAsset::GetShaderResourceGroupLayouts(
SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
if (!supervariant)
{
return {};
}
return supervariant->m_srgLayoutList;
}
const RHI::Ptr<RHI::ShaderResourceGroupLayout>& ShaderAsset::GetDrawSrgLayout(SupervariantIndex supervariantIndex) const
{
return FindShaderResourceGroupLayout(SrgBindingSlot::Draw, supervariantIndex);
}
const ShaderInputContract& ShaderAsset::GetInputContract(SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
return supervariant->m_inputContract;
}
const ShaderOutputContract& ShaderAsset::GetOutputContract(SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
return supervariant->m_outputContract;
}
const RHI::RenderStates& ShaderAsset::GetRenderStates(SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
return supervariant->m_renderStates;
}
const RHI::PipelineLayoutDescriptor* ShaderAsset::GetPipelineLayoutDescriptor(SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
if (!supervariant)
{
return nullptr;
}
AZ_Assert(supervariant->m_pipelineLayoutDescriptor, "m_pipelineLayoutDescriptor is null");
return supervariant->m_pipelineLayoutDescriptor.get();
}
AZStd::optional<RHI::ShaderStageAttributeArguments> ShaderAsset::GetAttribute(const RHI::ShaderStage& shaderStage, const Name& attributeName,
SupervariantIndex supervariantIndex) const
{
auto supervariant = GetSupervariant(supervariantIndex);
if (!supervariant)
{
return AZStd::nullopt;
}
const auto stageIndex = static_cast<uint32_t>(shaderStage);
AZ_Assert(stageIndex < RHI::ShaderStageCount, "Invalid shader stage specified!");
const auto& attributeMaps = supervariant->m_attributeMaps;
const auto& attrPair = attributeMaps[stageIndex].find(attributeName);
if (attrPair == attributeMaps[stageIndex].end())
{
return AZStd::nullopt;
}
return attrPair->second;
}
ShaderAsset::ShaderApiDataContainer& ShaderAsset::GetCurrentShaderApiData()
{
const size_t perApiShaderDataCount = m_perAPIShaderData.size();
AZ_Assert(perApiShaderDataCount > 0, "Invalid m_perAPIShaderData");
if (m_currentAPITypeIndex < perApiShaderDataCount)
{
return m_perAPIShaderData[m_currentAPITypeIndex];
}
// We may only endup here when running in a Builder context.
return m_perAPIShaderData[0];
}
const ShaderAsset::ShaderApiDataContainer& ShaderAsset::GetCurrentShaderApiData() const
{
const size_t perApiShaderDataCount = m_perAPIShaderData.size();
AZ_Assert(perApiShaderDataCount > 0, "Invalid m_perAPIShaderData");
if (m_currentAPITypeIndex < perApiShaderDataCount)
{
return m_perAPIShaderData[m_currentAPITypeIndex];
}
// We may only endup here when running in a Builder context.
return m_perAPIShaderData[0];
}
ShaderAsset::Supervariant* ShaderAsset::GetSupervariant(SupervariantIndex supervariantIndex)
{
auto& supervariants = GetCurrentShaderApiData().m_supervariants;
auto index = supervariantIndex.GetIndex();
if (index >= supervariants.size())
{
AZ_Error(
"ShaderAsset", false, "Supervariant index = %u is invalid because there are only %zu supervariants", index,
supervariants.size());
return nullptr;
}
return &supervariants[index];
}
const ShaderAsset::Supervariant* ShaderAsset::GetSupervariant(SupervariantIndex supervariantIndex) const
{
const auto& supervariants = GetCurrentShaderApiData().m_supervariants;
auto index = supervariantIndex.GetIndex();
if (index >= supervariants.size())
{
AZ_Error(
"ShaderAsset", false, "Supervariant index = %u is invalid because there are only %zu supervariants", index,
supervariants.size());
return nullptr;
}
return &supervariants[index];
}
bool ShaderAsset::FinalizeAfterLoad()
{
// Use the current RHI that is active to select which shader data to use.
// We don't assert if the Factory is not available because this method could be called during build time,
// when no Factory is available. Some assets (like the material asset) need to load the ShaderAsset
// in order to get some non API specific data (like a ShaderResourceGroup) during their build
// process. If they try to access any RHI API specific data, an assert will be trigger because the
// correct API index will not set.
if (RHI::Factory::IsReady())
{
auto rhiType = RHI::Factory::Get().GetType();
auto findIt = AZStd::find_if(m_perAPIShaderData.begin(), m_perAPIShaderData.end(), [&rhiType](const auto& shaderData)
{
return shaderData.m_APIType == rhiType;
});
if (findIt != m_perAPIShaderData.end())
{
m_currentAPITypeIndex = AZStd::distance(m_perAPIShaderData.begin(), findIt);
}
else
{
AZ_Error("ShaderAsset", false, "Could not find shader for API %s in shader %s", RHI::Factory::Get().GetName().GetCStr(), GetName().GetCStr());
return false;
}
}
// Common finalize check
for (const auto& shaderApiData : m_perAPIShaderData)
{
const auto& supervariants = shaderApiData.m_supervariants;
for (const auto& supervariant : supervariants)
{
bool beTrue = supervariant.m_attributeMaps.size() == RHI::ShaderStageCount;
if (!beTrue)
{
AZ_Error("ShaderAsset", false, "Unexpected number of shader stages at supervariant with name [%s]!", supervariant.m_name.GetCStr());
return false;
}
}
}
// Once the ShaderAsset is loaded, it is necessary to listen for changes in the Root Variant Asset.
Data::AssetBus::Handler::BusConnect(GetRootVariant().GetId());
ShaderVariantFinderNotificationBus::Handler::BusConnect(GetId());
return true;
}
///////////////////////////////////////////////////////////////////////
// AssetBus overrides...
void ShaderAsset::OnAssetReloaded(Data::Asset<Data::AssetData> asset)
{
ShaderReloadDebugTracker::ScopedSection reloadSection("ShaderAsset::OnAssetReloaded %s", asset.GetHint().c_str());
Data::Asset<ShaderVariantAsset> shaderVariantAsset = { asset.GetAs<ShaderVariantAsset>(), AZ::Data::AssetLoadBehavior::PreLoad };
AZ_Assert(shaderVariantAsset->GetStableId() == RootShaderVariantStableId,
"Was expecting to update the root variant");
SupervariantIndex supervariantIndex = GetSupervariantIndexFromAssetId(asset.GetId());
GetCurrentShaderApiData().m_supervariants[supervariantIndex.GetIndex()].m_rootShaderVariantAsset = asset;
ShaderReloadNotificationBus::Event(GetId(), &ShaderReloadNotificationBus::Events::OnShaderAssetReinitialized, Data::Asset<ShaderAsset>{ this, AZ::Data::AssetLoadBehavior::PreLoad } );
}
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
/// ShaderVariantFinderNotificationBus overrides
void ShaderAsset::OnShaderVariantTreeAssetReady(Data::Asset<ShaderVariantTreeAsset> shaderVariantTreeAsset, bool isError)
{
ShaderReloadDebugTracker::ScopedSection reloadSection("ShaderAsset::OnShaderVariantTreeAssetReady %s", shaderVariantTreeAsset.GetHint().c_str());
AZStd::unique_lock<decltype(m_variantTreeMutex)> lock(m_variantTreeMutex);
if (isError)
{
m_shaderVariantTree = {}; //This will force to attempt to reload later.
m_shaderVariantTreeLoadWasRequested = false;
}
else
{
m_shaderVariantTree = shaderVariantTreeAsset;
}
lock.unlock();
ShaderReloadNotificationBus::Event(GetId(), &ShaderReloadNotificationBus::Events::OnShaderAssetReinitialized, Data::Asset<ShaderAsset>{ this, AZ::Data::AssetLoadBehavior::PreLoad });
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
// ShaderAssetHandler
Data::AssetHandler::LoadResult ShaderAssetHandler::LoadAssetData(
const Data::Asset<Data::AssetData>& asset,
AZStd::shared_ptr<Data::AssetDataStream> stream,
const Data::AssetFilterCB& assetLoadFilterCB)
{
if (Base::LoadAssetData(asset, stream, assetLoadFilterCB) == Data::AssetHandler::LoadResult::LoadComplete)
{
return PostLoadInit(asset);
}
return Data::AssetHandler::LoadResult::Error;
}
Data::AssetHandler::LoadResult ShaderAssetHandler::PostLoadInit(const Data::Asset<Data::AssetData>& asset)
{
if (ShaderAsset* shaderAsset = asset.GetAs<ShaderAsset>())
{
if (!shaderAsset->FinalizeAfterLoad())
{
AZ_Error("ShaderAssetHandler", false, "Shader asset failed to finalize.");
return Data::AssetHandler::LoadResult::Error;
}
return Data::AssetHandler::LoadResult::LoadComplete;
}
return Data::AssetHandler::LoadResult::Error;
}
///////////////////////////////////////////////////////////////////////
} // namespace RPI
} // namespace AZ
Reference in New Issue View Git Blame Copy Permalink