/* * 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 "ShaderBuilderUtility.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ShaderPlatformInterfaceRequest.h" #include "AtomShaderConfig.h" namespace AZ { namespace ShaderBuilder { namespace ShaderBuilderUtility { static const char* ShaderBuilderUtilityName = "ShaderBuilderUtility"; Outcome LoadShaderDataJson(const AZStd::string& fullPathToJsonFile) { RPI::ShaderSourceData shaderSourceData; auto document = JsonSerializationUtils::ReadJsonFile(fullPathToJsonFile); if (!document.IsSuccess()) { return Failure(document.GetError()); } JsonDeserializerSettings settings; RPI::JsonReportingHelper reportingHelper; reportingHelper.Attach(settings); JsonSerialization::Load(shaderSourceData, document.GetValue(), settings); return AZ::Success(shaderSourceData); } void GetAbsolutePathToAzslFile(const AZStd::string& shaderTemplatePathAndFile, AZStd::string specifiedShaderPathAndName, AZStd::string& absoluteAzslPath) { AZStd::string sourcePath; AzFramework::StringFunc::Path::GetFullPath(shaderTemplatePathAndFile.data(), sourcePath); AzFramework::StringFunc::Path::Normalize(specifiedShaderPathAndName); bool shaderNameHasPath = (specifiedShaderPathAndName.find(AZ_CORRECT_FILESYSTEM_SEPARATOR) != AZStd::string::npos); // Join will handle overlapping directory structures for us AzFramework::StringFunc::Path::Join(sourcePath.data(), specifiedShaderPathAndName.data(), absoluteAzslPath, shaderNameHasPath /* handle directory overlap? */, false /* be case insensitive? */); AzFramework::StringFunc::Path::ReplaceExtension(absoluteAzslPath, "azsl"); } uint32_t MakeDebugByproductSubId(RHI::APIType apiType, const AZStd::string& productFileName) { // bits: ----- 24 -----|- 4 -|- 4 - // fn hash | id + api | 0xF uint32_t subId = 0xF; // to avoid collisions with subid of other source outputs using RPI::ShaderAssetSubId::GeneratedSource + api uint32_t id_api = static_cast(RPI::ShaderAssetSubId::DebugByProduct); id_api += apiType; id_api <<= 4; subId |= id_api; size_t fnHash = AZStd::hash()(productFileName); subId |= static_cast(fnHash) & 0xFFFFFF00; return subId; } static bool LoadShaderResourceGroupAssets( [[maybe_unused]] const char* BuilderName, const SrgDataContainer& resourceGroups, ShaderResourceGroupAssets& srgAssets) { bool readSRGsSuccessfuly = true; // Load all SRGs included in source file for (const SrgData& srgData : resourceGroups) { Data::AssetId assetId = {}; AZStd::string srgFilePath = ""; srgFilePath = srgData.m_containingFileName; AzFramework::StringFunc::Path::Normalize(srgFilePath); bool assetFound = false; Data::AssetInfo sourceInfo; AZStd::string watchFolder; AzToolsFramework::AssetSystemRequestBus::BroadcastResult(assetFound, &AzToolsFramework::AssetSystem::AssetSystemRequest::GetSourceInfoBySourcePath, srgFilePath.c_str(), sourceInfo, watchFolder); if (!assetFound) { AZ_Error(BuilderName, false, "Could not find asset identified by path '%s'", srgFilePath.c_str()); readSRGsSuccessfuly = false; continue; } assetId.m_guid = sourceInfo.m_assetId.m_guid; assetId.m_subId = static_cast(AZStd::hash()(srgData.m_name) & 0xFFFFFFFF); Data::Asset asset = Data::AssetManager::Instance().GetAsset( assetId, AZ::Data::AssetLoadBehavior::PreLoad); asset.BlockUntilLoadComplete(); if (!asset.IsReady()) { using Status = Data::AssetData::AssetStatus; AZStd::string statusString = asset.GetStatus() == Status::Loading ? "loading" : asset.GetStatus() == Status::ReadyPreNotify ? "ready-pre-notify" : asset.GetStatus() == Status::Error ? "error" : "not-loaded/ready/unknown"; AZ_Error(BuilderName, false, "Searching SRG [%s]: Could not load SRG asset. (asset status [%s]) AssetId='%s' Path='%s'", srgData.m_name.c_str(), statusString.c_str(), assetId.ToString().c_str(), srgFilePath.c_str()); readSRGsSuccessfuly = false; continue; } else if (!asset->IsValid()) { AZ_Error(BuilderName, false, "SRG asset has no layout information. AssetId='%s' Path='%s'", assetId.ToString().c_str(), srgFilePath.c_str()); readSRGsSuccessfuly = false; continue; } srgAssets.push_back(asset); } return readSRGsSuccessfuly; } AZStd::shared_ptr PrepareSourceInput( [[maybe_unused]] const char* builderName, const AZStd::string& shaderAssetSourcePath, RPI::ShaderSourceData& sourceAsset) { auto shaderAssetSourceFileParseOutput = ShaderBuilderUtility::LoadShaderDataJson(shaderAssetSourcePath); if (!shaderAssetSourceFileParseOutput.IsSuccess()) { AZ_Error(builderName, false, "Failed to load/parse Shader Descriptor JSON: %s", shaderAssetSourceFileParseOutput.GetError().c_str()); return nullptr; } sourceAsset = AZStd::move(shaderAssetSourceFileParseOutput.GetValue()); AZStd::shared_ptr files(new ShaderFiles); const AZStd::string& specifiedAzslName = sourceAsset.m_source; ShaderBuilderUtility::GetAbsolutePathToAzslFile(shaderAssetSourcePath, specifiedAzslName, files->m_azslSourceFullPath); // specifiedAzslName may have a relative path on it so need to strip it AzFramework::StringFunc::Path::GetFileName(specifiedAzslName.c_str(), files->m_azslFileName); return files; } AssetBuilderSDK::ProcessJobResultCode PopulateAzslDataFromJsonFiles( const char* BuilderName, const AzslSubProducts::Paths& pathOfJsonFiles, AzslData& azslData, ShaderResourceGroupAssets& srgAssets, RPI::Ptr shaderOptionGroupLayout, BindingDependencies& bindingDependencies, RootConstantData& rootConstantData) { AzslCompiler azslc(azslData.m_preprocessedFullPath); // set the input file for eventual error messages, but the compiler won't be called on it. bool allReadSuccess = true; // read: input assembly reflection // shader resource group reflection // options reflection // binding dependencies reflection int indicesOfInterest[] = { AzslSubProducts::ia, AzslSubProducts::srg, AzslSubProducts::options, AzslSubProducts::bindingdep }; AZStd::unordered_map> outcomes; for (int i : indicesOfInterest) { outcomes[i] = JsonSerializationUtils::ReadJsonFile(pathOfJsonFiles[i]); if (!outcomes[i].IsSuccess()) { AZ_Error(BuilderName, false, "%s", outcomes[i].GetError().c_str()); allReadSuccess = false; } } if (!allReadSuccess) { return AssetBuilderSDK::ProcessJobResult_Failed; } // Get full list of functions eligible for vertex shader entry points // along with metadata for constructing the InputAssembly for each of them if (!azslc.ParseIaPopulateFunctionData(outcomes[AzslSubProducts::ia].GetValue(), azslData.m_topData.m_functions)) { return AssetBuilderSDK::ProcessJobResult_Failed; } // Each SRG is built as a separate asset in the SrgLayoutBuilder, here we just // build the list and load the data from multiple dependency assets. if (!azslc.ParseSrgPopulateSrgData(outcomes[AzslSubProducts::srg].GetValue(), azslData.m_topData.m_srgData)) { return AssetBuilderSDK::ProcessJobResult_Failed; } // Add all Shader Resource Group Assets that were defined in the shader code to the shader asset if (!LoadShaderResourceGroupAssets(BuilderName, azslData.m_topData.m_srgData, srgAssets)) { AZ_Error(BuilderName, false, "Failed to obtain shader resource group assets"); return AssetBuilderSDK::ProcessJobResult_Failed; } // The shader options define what options are available, what are the allowed values/range // for each option and what is its default value. if (!azslc.ParseOptionsPopulateOptionGroupLayout(outcomes[AzslSubProducts::options].GetValue(), shaderOptionGroupLayout)) { AZ_Error(BuilderName, false, "Failed to find a valid list of shader options!"); return AssetBuilderSDK::ProcessJobResult_Failed; } // It analyzes the shader external bindings (all SRG contents) // and informs us on register indexes and shader stages using these resources if (!azslc.ParseBindingdepPopulateBindingDependencies(outcomes[AzslSubProducts::bindingdep].GetValue(), bindingDependencies)) // consuming data from binding-dep { AZ_Error(BuilderName, false, "Failed to obtain shader resource binding reflection"); return AssetBuilderSDK::ProcessJobResult_Failed; } // access the root constants reflection if (!azslc.ParseSrgPopulateRootConstantData(outcomes[AzslSubProducts::srg].GetValue(), rootConstantData)) // consuming data from --srg ("InlineConstantBuffer" subjson section) { AZ_Error(BuilderName, false, "Failed to obtain root constant data reflection"); return AssetBuilderSDK::ProcessJobResult_Failed; } return AssetBuilderSDK::ProcessJobResult_Success; } RHI::ShaderHardwareStage ToAssetBuilderShaderType(RPI::ShaderStageType stageType) { switch (stageType) { case RPI::ShaderStageType::Compute: return RHI::ShaderHardwareStage::Compute; case RPI::ShaderStageType::Fragment: return RHI::ShaderHardwareStage::Fragment; case RPI::ShaderStageType::Geometry: return RHI::ShaderHardwareStage::Geometry; case RPI::ShaderStageType::TessellationControl: return RHI::ShaderHardwareStage::TessellationControl; case RPI::ShaderStageType::TessellationEvaluation: return RHI::ShaderHardwareStage::TessellationEvaluation; case RPI::ShaderStageType::Vertex: return RHI::ShaderHardwareStage::Vertex; case RPI::ShaderStageType::RayTracing: return RHI::ShaderHardwareStage::RayTracing; } AZ_Assert(false, "Unable to find Shader stage given RPI ShaderStage %d", stageType); return RHI::ShaderHardwareStage::Invalid; } //! the binding dependency structure may store lots of high level function names which are not entry points static void PruneNonEntryFunctions(BindingDependencies& bindingDependencies /*inout*/, const MapOfStringToStageType& shaderEntryPoints) { auto cleaner = [&shaderEntryPoints](BindingDependencies::FunctionsNameVector& functionVector) { functionVector.erase( AZStd::remove_if( functionVector.begin(), functionVector.end(), [&shaderEntryPoints](const AZStd::string& functionName) { return shaderEntryPoints.find(functionName) == shaderEntryPoints.end(); }), functionVector.end()); }; for (auto& srg : bindingDependencies.m_orderedSrgs) { cleaner(srg.m_srgConstantsDependencies.m_binding.m_dependentFunctions); AZStd::for_each( srg.m_resources.begin(), srg.m_resources.end(), [&cleaner](decltype(*srg.m_resources.begin())& nameResourcePair) { cleaner(nameResourcePair.second.m_dependentFunctions); }); } } RHI::Ptr BuildPipelineLayoutDescriptorForApi( [[maybe_unused]] const char* BuilderName, RHI::ShaderPlatformInterface* shaderPlatformInterface, BindingDependencies& bindingDependencies /*inout*/, const ShaderResourceGroupAssets& srgAssets, const MapOfStringToStageType& shaderEntryPoints, const RHI::ShaderCompilerArguments& shaderCompilerArguments, const RootConstantData* rootConstantData /*= nullptr*/) { PruneNonEntryFunctions(bindingDependencies, shaderEntryPoints); // Translates from a list of function names that use a resource to a shader stage mask. auto getRHIShaderStageMask = [&shaderEntryPoints](const BindingDependencies::FunctionsNameVector& functions) { RHI::ShaderStageMask mask = RHI::ShaderStageMask::None; // Iterate through all the functions that are using the resource. for (const auto& functionName : functions) { // Search the function name into the list of valid entry points into the shader. auto findId = AZStd::find_if(shaderEntryPoints.begin(), shaderEntryPoints.end(), [&functionName, &mask](const auto& item) { return item.first == functionName; }); if (findId != shaderEntryPoints.end()) { // Use the entry point shader stage type to calculate the mask. RHI::ShaderHardwareStage hardwareStage = ToAssetBuilderShaderType(findId->second); mask |= static_cast(AZ_BIT(static_cast(RHI::ToRHIShaderStage(hardwareStage)))); } } return mask; }; // Build general PipelineLayoutDescriptor data that is provided for all platforms RHI::Ptr pipelineLayoutDescriptor = shaderPlatformInterface->CreatePipelineLayoutDescriptor(); RHI::ShaderPlatformInterface::ShaderResourceGroupInfoList srgInfos; for (const auto& srgAsset : srgAssets) { // Search the binding info for a Shader Resource Group. AZStd::string_view srgName = srgAsset->GetName().GetStringView(); const BindingDependencies::SrgResources* srgResources = bindingDependencies.GetSrg(srgName); if (!srgResources) { AZ_Error(BuilderName, false, "SRG %s not found in the dependency dataset", srgName.data()); return nullptr; } RHI::ShaderResourceGroupBindingInfo srgBindingInfo; srgBindingInfo.m_spaceId = srgResources->m_registerSpace; const RHI::ShaderResourceGroupLayout* layout = srgAsset->GetLayout(shaderPlatformInterface->GetAPIType()); // Calculate the binding in for the constant data. All constant data share the same binding info. srgBindingInfo.m_constantDataBindingInfo = { getRHIShaderStageMask(srgResources->m_srgConstantsDependencies.m_binding.m_dependentFunctions), srgResources->m_srgConstantsDependencies.m_binding.m_registerId }; // Calculate the binding info for each resource of the Shader Resource Group. for (auto const& resource : srgResources->m_resources) { auto const& resourceInfo = resource.second; srgBindingInfo.m_resourcesRegisterMap.insert( { AZ::Name(resourceInfo.m_selfName), RHI::ResourceBindingInfo(getRHIShaderStageMask(resourceInfo.m_dependentFunctions), resourceInfo.m_registerId) }); } pipelineLayoutDescriptor->AddShaderResourceGroupLayoutInfo(*layout, srgBindingInfo); srgInfos.push_back(RHI::ShaderPlatformInterface::ShaderResourceGroupInfo{ layout, srgBindingInfo }); } RHI::Ptr rootConstantsLayout = RHI::ConstantsLayout::Create(); if (rootConstantData) { for (const auto& constantData : rootConstantData->m_constants) { RHI::ShaderInputConstantDescriptor rootConstantDesc( constantData.m_nameId, constantData.m_constantByteOffset, constantData.m_constantByteSize, rootConstantData->m_bindingInfo.m_registerId); rootConstantsLayout->AddShaderInput(rootConstantDesc); } } if (!rootConstantsLayout->Finalize()) { AZ_Error(BuilderName, false, "Failed to finalize root constants layout"); return nullptr; } pipelineLayoutDescriptor->SetRootConstantsLayout(*rootConstantsLayout); RHI::ShaderPlatformInterface::RootConstantsInfo rootConstantInfo; if (rootConstantData) { rootConstantInfo.m_spaceId = rootConstantData->m_bindingInfo.m_space; rootConstantInfo.m_registerId = rootConstantData->m_bindingInfo.m_registerId; } else { RootConstantData dummyRootConstantData; rootConstantInfo.m_spaceId = dummyRootConstantData.m_bindingInfo.m_space; rootConstantInfo.m_registerId = dummyRootConstantData.m_bindingInfo.m_registerId; } rootConstantInfo.m_totalSizeInBytes = rootConstantsLayout->GetDataSize(); // Build platform-specific PipelineLayoutDescriptor data, and finalize if (!shaderPlatformInterface->BuildPipelineLayoutDescriptor(pipelineLayoutDescriptor, srgInfos, rootConstantInfo, shaderCompilerArguments)) { AZ_Error(BuilderName, false, "Failed to build pipeline layout descriptor"); return nullptr; } return pipelineLayoutDescriptor; } static AZStd::string DumpCode( [[maybe_unused]] const char* builderName, const AZStd::string& codeInString, const AZStd::string& dumpDirectory, const AZStd::string& stemName, const AZStd::string& apiTypeString, const AZStd::string& extension) { AZStd::string finalFilePath; AZStd::string formatted; if (apiTypeString.empty()) { formatted = AZStd::string::format("%s.%s", stemName.c_str(), extension.c_str()); } else { formatted = AZStd::string::format("%s.%s.%s", stemName.c_str(), apiTypeString.c_str(), extension.c_str()); } AzFramework::StringFunc::Path::Join(dumpDirectory.c_str(), formatted.c_str(), finalFilePath, true, true); AZ::IO::FileIOStream outFileStream(finalFilePath.data(), AZ::IO::OpenMode::ModeWrite); if (!outFileStream.IsOpen()) { AZ_Error(builderName, false, "Failed to open file to write (%s)\n", finalFilePath.data()); return ""; } outFileStream.Write(codeInString.size(), codeInString.data()); // Prevent warning: "warning: End of input with no newline" static constexpr char newLine[] = "\n"; outFileStream.Write(sizeof(newLine) - 1, newLine); outFileStream.Close(); return finalFilePath; } AZStd::string DumpPreprocessedCode(const char* builderName, const AZStd::string& preprocessedCode, const AZStd::string& tempDirPath, const AZStd::string& stemName, const AZStd::string& apiTypeString) { return DumpCode(builderName, preprocessedCode, tempDirPath, stemName, apiTypeString, "azslin"); } AZStd::string DumpAzslPrependedCode(const char* builderName, const AZStd::string& nonPreprocessedYetAzslSource, const AZStd::string& tempDirPath, const AZStd::string& stemName, const AZStd::string& apiTypeString) { return DumpCode(builderName, nonPreprocessedYetAzslSource, tempDirPath, stemName, apiTypeString, "azsl.prepend"); } AZStd::string ExtractStemName(const char* path) { AZStd::string result; AzFramework::StringFunc::Path::GetFileName(path, result); return result; } AZStd::vector DiscoverValidShaderPlatformInterfaces(const AssetBuilderSDK::PlatformInfo& info) { AZStd::vector platformInterfaces; ShaderPlatformInterfaceRequestBus::BroadcastResult(platformInterfaces, &ShaderPlatformInterfaceRequest::GetShaderPlatformInterface, info); // filter out nulls: platformInterfaces.erase(AZStd::remove_if(AZ_BEGIN_END(platformInterfaces), [](auto* element) { return element == nullptr; }), platformInterfaces.end()); return platformInterfaces; } static void ReadShaderCompilerProfiling([[maybe_unused]] const char* builderName, RHI::ShaderCompilerProfiling& shaderCompilerProfiling, AZStd::string_view shaderPath) { AZStd::string folderPath; AzFramework::StringFunc::Path::GetFullPath(shaderPath.data(), folderPath); AZStd::vector fileNames; IO::FileIOBase::GetInstance()->FindFiles(folderPath.c_str(), "*.profiling", [&](const char* filePath) -> bool { fileNames.push_back(AZStd::string(filePath)); return true; }); for (const AZStd::string& fileName : fileNames) { RHI::ShaderCompilerProfiling profiling; auto loadResult = AZ::JsonSerializationUtils::LoadObjectFromFile(profiling, fileName); if (!loadResult.IsSuccess()) { AZ_Error(builderName, false, "Failed to load shader compiler profiling from file [%s]", fileName.data()); AZ_Error(builderName, false, "Loading issues: %s", loadResult.GetError().data()); continue; } shaderCompilerProfiling.m_entries.insert( shaderCompilerProfiling.m_entries.begin(), profiling.m_entries.begin(), profiling.m_entries.end()); } } void LogProfilingData(const char* builderName, AZStd::string_view shaderPath) { RHI::ShaderCompilerProfiling shaderCompilerProfiling; ReadShaderCompilerProfiling(builderName, shaderCompilerProfiling, shaderPath); struct ProfilingPerCompiler { size_t m_calls; float m_totalElapsedTime; }; // The key is the compiler executable path. AZStd::unordered_map profilingPerCompiler; for (const RHI::ShaderCompilerProfiling::Entry& shaderCompilerProfilingEntry : shaderCompilerProfiling.m_entries) { auto it = profilingPerCompiler.find(shaderCompilerProfilingEntry.m_executablePath); if (it == profilingPerCompiler.end()) { profilingPerCompiler.emplace( shaderCompilerProfilingEntry.m_executablePath, ProfilingPerCompiler{ 1, shaderCompilerProfilingEntry.m_elapsedTimeSeconds }); } else { (*it).second.m_calls++; (*it).second.m_totalElapsedTime += shaderCompilerProfilingEntry.m_elapsedTimeSeconds; } } #if defined(AZ_ENABLE_TRACING) for (const auto& profiling : profilingPerCompiler) { AZ_TracePrintf(builderName, "Compiler: %s\n>\tCalls: %d\n>\tTime: %.2f seconds\n", profiling.first.c_str(), profiling.second.m_calls, profiling.second.m_totalElapsedTime); } #endif } uint32_t MakeAzslBuildProductSubId(RPI::ShaderAssetSubId subId, RHI::APIType apiType) { auto subIdMaxEnumerator = RPI::ShaderAssetSubId::GeneratedSource; // separate bit space between subid enum, and api-type: int shiftLeft = static_cast(log2(static_cast(subIdMaxEnumerator))) + 1; return static_cast(subId) + (apiType << shiftLeft); } Outcome ObtainBuildArtifactsFromAzslBuilder([[maybe_unused]] const char* builderName, const AZStd::string& sourceFullPath, RHI::APIType apiType, const AZStd::string& platform) { AzslSubProducts::Paths products; // platform id from identifier AzFramework::PlatformId platformId = AzFramework::PlatformId::PC; if (platform == "pc") { platformId = AzFramework::PlatformId::PC; } else if (platform == "osx_gl") { platformId = AzFramework::PlatformId::OSX; } else if (platform == "es3") { platformId = AzFramework::PlatformId::ES3; } else if (platform == "ios") { platformId = AzFramework::PlatformId::IOS; } for (RPI::ShaderAssetSubId sub : AzslSubProducts::SubList) { uint32_t assetSubId = MakeAzslBuildProductSubId(sub, apiType); auto assetIdOutcome = RPI::AssetUtils::MakeAssetId(sourceFullPath, assetSubId); AZ_Error(builderName, assetIdOutcome.IsSuccess(), "Missing AZSL product %s, for sub %d", sourceFullPath.c_str(), (uint32_t)sub); if (!assetIdOutcome.IsSuccess()) { return Failure(); } Data::AssetId assetId = assetIdOutcome.TakeValue(); // get the relative path: AZStd::string assetPath; Data::AssetCatalogRequestBus::BroadcastResult(assetPath, &Data::AssetCatalogRequests::GetAssetPathById, assetId); // get the root: AZStd::string assetRoot = AzToolsFramework::PlatformAddressedAssetCatalog::GetAssetRootForPlatform(platformId); // join AZStd::string assetFullPath; AzFramework::StringFunc::Path::Join(assetRoot.c_str(), assetPath.c_str(), assetFullPath); bool fileExists = IO::FileIOBase::GetInstance()->Exists(assetFullPath.c_str()) && !IO::FileIOBase::GetInstance()->IsDirectory(assetFullPath.c_str()); if (!fileExists) { return Failure(); } products.push_back(assetFullPath); } return AZ::Success(products); } // See header for info. // REMARK: The approach to string searching and matching done in this function is kind of naive // because the strings can match text within a comment block, etc. So it is not 100% fool proof. // We would need proper grammar parsing to reach 100% confidence. // [GFX TODO][ATOM-5302][ATOM-5308] The following function will be removed once, both, [ATOM-5302] & [ATOM-5308] are addressed, and // azslc allows redundant SrgSemantics for "partial" qualified SRGs. SrgSkipFileResult ShouldSkipFileForSrgProcessing([[maybe_unused]] const char* builderName, const AZStd::string_view fullPath) { AZ::IO::FileIOStream stream(fullPath.data(), AZ::IO::OpenMode::ModeRead); if (!stream.IsOpen()) { AZ_Warning(builderName, false, "\"%s\" source file could not be opened.", fullPath.data()); return SrgSkipFileResult::Error; } if (!stream.CanRead()) { AZ_Warning(builderName, false, "\"%s\" source file could not be read.", fullPath.data()); return SrgSkipFileResult::Error; } // Do a quick check for "ShaderResourceGroup" to determine if this file might even have a ShaderResourceGroup to parse. AZStd::string fileContents; fileContents.resize(stream.GetLength()); stream.Read(stream.GetLength(), fileContents.data()); static const AZStd::regex partialSrgRegex("\n\\s*partial\\s+ShaderResourceGroup\\s+", AZStd::regex::ECMAScript); if (AZStd::regex_search(fileContents.data(), partialSrgRegex)) { // It is considered a programmer's error if a file declares both, non-partial and partial SRGs. static const AZStd::regex srgRegex("\n\\s*ShaderResourceGroup\\s+", AZStd::regex::ECMAScript); if (AZStd::regex_search(fileContents.data(), srgRegex)) { AZ_Error(builderName, false, "\"%s\" defines both partial and non-partial SRGs.", fullPath.data()); return SrgSkipFileResult::Error; } // We should skip files that define partial Srgs because an srgi file will eventually // include it. return SrgSkipFileResult::SkipFile; } // This is an optimization to avoid unnecessary preprocessing a whole tree of azsli files; we can detect when a // ShaderResourceGroupAsset wouldn't be produced and return early. Note, we could remove this early-return check // if the preprocessing code below is updated to not follow include paths [ATOM-5302]. // (Note this optimization is not valid for srgi files because those do require scanning all include paths)" if (fileContents.find("ShaderResourceGroup") == AZStd::string::npos) { // No ShaderResourceGroup in this file, so there's nothing to do. Create no jobs and report success. return SrgSkipFileResult::SkipFile; } return SrgSkipFileResult::ContinueProcess; } } // namespace ShaderBuilderUtility } // namespace ShaderBuilder } // AZ