izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
daacee5732ea20871e243ccd11746bd97a142e4e
UnrealEngineUWP/Engine/Source/Runtime/Renderer/Private/MeshPassProcessor.cpp

2391 lines
95 KiB
C++
Raw Normal View History

Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
// Copyright Epic Games, Inc. All Rights Reserved.
/*=============================================================================
MeshPassProcessor.cpp:
=============================================================================*/
#include "MeshPassProcessor.h"
#include "SceneUtils.h"
#include "SceneRendering.h"
#include "Logging/LogMacros.h"
#include "RendererModule.h"
#include "SceneCore.h"
#include "ScenePrivate.h"
#include "SceneInterface.h"
#include "MeshPassProcessor.inl"
#include "PipelineStateCache.h"
#include "RayTracing/RayTracingMaterialHitShaders.h"
#include "Hash/CityHash.h"
#include "ComponentRecreateRenderStateContext.h"
Adding includes to rendering cpp files in preparation for header changes. #preflight 6387bd29fa053c489ad45427 [CL 23343615 by christopher waters in ue5-main branch]
2022-11-30 18:29:09 -05:00
#include "RenderCore.h"
Adding includes and forward declarations for upcoming dependency cleanup. [CL 23599524 by christopher waters in ue5-main branch]
2023-01-06 12:24:17 -05:00
#include "UnrealEngine.h"
Add initial version of scene uniform buffer and move GPUScene from View. #preflight 63e0ca6c244dc45a20d3f808 #rb ola.olsson, zach.bethel [CL 24027890 by wouter dek in ue5-main branch]
2023-02-06 05:56:29 -05:00
#include "SceneUniformBuffer.h"
Add mesh draw command stats collection. This collects information about each draw call in each pass used during MDC rendering. It reads back indirect args if they are used to get the correct final rendered instance and primitive counts. Use SetMeshDrawCommandStatsCategory() on primitive components to set category types. Use "r.MeshDrawCommands.Stats 1" to show per category stats on screen. Use "stat culling" to show global stats using the standard stats system. Use "DumpMeshDrawCommandFrameStats" in developmet builds to dump detailed draw info of a frame to a csv file on disc. [FYI] kenzo.terelst [CL 26721817 by jeremy moore in ue5-main branch]
2023-07-31 17:25:08 -04:00
#include "MeshDrawCommandStats.h"
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FRWLock FGraphicsMinimalPipelineStateId::PersistentIdTableLock;
FGraphicsMinimalPipelineStateId::PersistentTableType FGraphicsMinimalPipelineStateId::PersistentIdTable;
#if MESH_DRAW_COMMAND_DEBUG_DATA
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
std::atomic<int32> FGraphicsMinimalPipelineStateId::DebugSaltAllocationIndex;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
std::atomic<int32> FGraphicsMinimalPipelineStateId::LocalPipelineIdTableSize(0);
std::atomic<int32> FGraphicsMinimalPipelineStateId::CurrentLocalPipelineIdTableSize(0);
#endif //MESH_DRAW_COMMAND_DEBUG_DATA
bool FGraphicsMinimalPipelineStateId::NeedsShaderInitialisation = true;
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
bool FGraphicsMinimalPipelineStateId::bIsIdTableFrozen = false;
std::atomic<int32> FGraphicsMinimalPipelineStateId::ReffedItemCount(0);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FMeshDrawCommandSortKey FMeshDrawCommandSortKey::Default = { {0} };
int32 GEmitMeshDrawEvent = 0;
static FAutoConsoleVariableRef CVarEmitMeshDrawEvent(
TEXT("r.EmitMeshDrawEvents"),
GEmitMeshDrawEvent,
TEXT("Emits a GPU event around each drawing policy draw call. /n")
TEXT("Useful for seeing stats about each draw call, however it greatly distorts total time and time per draw call."),
ECVF_RenderThreadSafe
);
static TAutoConsoleVariable<int32> CVarSafeStateLookup(
TEXT("r.SafeStateLookup"),
1,
TEXT("Forces new-style safe state lookup for easy runtime perf comparison\n"),
ECVF_Scalability | ECVF_RenderThreadSafe);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
int32 GSkipDrawOnPSOPrecaching = 0;
static FAutoConsoleVariableRef CVarSkipDrawOnPSOPrecaching(
TEXT("r.SkipDrawOnPSOPrecaching"),
GSkipDrawOnPSOPrecaching,
TEXT("Skips mesh draw call when the PSO is still compiling (default 0)."),
ECVF_RenderThreadSafe
);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
#if WITH_EDITORONLY_DATA
int32 GNaniteIsolateInvalidCoarseMesh = 0;
static FAutoConsoleVariableRef CVarNaniteIsolateInvalidCoarseMesh(
TEXT("r.Nanite.IsolateInvalidCoarseMesh"),
GNaniteIsolateInvalidCoarseMesh,
TEXT("Debug mode to render only non-Nanite proxies that incorrectly reference coarse static mesh assets."),
FConsoleVariableDelegate::CreateLambda([](IConsoleVariable* InVariable)
{
// Needed to force a recache of all the static mesh draw commands
FGlobalComponentRecreateRenderStateContext Context;
})
);
#endif
class FReadOnlyMeshDrawSingleShaderBindings : public FMeshDrawShaderBindingsLayout
{
public:
FReadOnlyMeshDrawSingleShaderBindings(const FMeshDrawShaderBindingsLayout& InLayout, const uint8* InData) :
FMeshDrawShaderBindingsLayout(InLayout)
{
Data = InData;
}
inline FRHIUniformBuffer*const* GetUniformBufferStart() const
{
return (FRHIUniformBuffer**)(Data + GetUniformBufferOffset());
}
inline FRHISamplerState** GetSamplerStart() const
{
const uint8* SamplerDataStart = Data + GetSamplerOffset();
return (FRHISamplerState**)SamplerDataStart;
}
inline FRHIResource** GetSRVStart() const
{
const uint8* SRVDataStart = Data + GetSRVOffset();
return (FRHIResource**)SRVDataStart;
}
inline const uint8* GetSRVTypeStart() const
{
const uint8* SRVTypeDataStart = Data + GetSRVTypeOffset();
return SRVTypeDataStart;
}
inline const uint8* GetLooseDataStart() const
{
const uint8* LooseDataStart = Data + GetLooseDataOffset();
return LooseDataStart;
}
private:
const uint8* Data;
};
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
inline void SetTextureParameter(FRHIBatchedShaderParameters& BatchedParameters, const FShaderResourceParameterInfo& Parameter, FRHITexture* TextureRHI)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
#if PLATFORM_SUPPORTS_BINDLESS_RENDERING
Bindless Resources - Splitting "Bindless Resource" shader parameter types into "Bindless SRV" and "Bindless UAV" to make sure reflection/binding validation is correct. #jira UE-166341 #rb jeannoe.morissette [CL 28995862 by christopher waters in ue5-main branch]
2023-10-20 23:12:44 -04:00
if (Parameter.Type == EShaderParameterType::BindlessSRV)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
Chaning more code to use SetShaderParameters - MeshPassProcessor converted to use SetShaderParameters instead of setting individual resources. Caching of SRVs and Samplers was also removed. - UnsetShaderSRVs and UnsetShaderUAVs now set all the null binds in a single SetShaderParameters command. - Made some FRHIShaderParameterResource utilities more public. #jira none #rb jeannoe.morrisette, luke.thatcher #preflight 637565eebf76990b71eb38d0 [CL 23197327 by christopher waters in ue5-main branch]
2022-11-18 12:10:55 -05:00
check(Parameter.BufferIndex == 0);
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetBindlessTexture(Parameter.BaseIndex, TextureRHI);
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
}
else
#endif
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetShaderTexture(Parameter.BaseIndex, TextureRHI);
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
}
}
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
inline void SetSrvParameter(FRHIBatchedShaderParameters& BatchedParameters, const FShaderResourceParameterInfo& Parameter, FRHIShaderResourceView* SrvRHI)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
#if PLATFORM_SUPPORTS_BINDLESS_RENDERING
Bindless Resources - Splitting "Bindless Resource" shader parameter types into "Bindless SRV" and "Bindless UAV" to make sure reflection/binding validation is correct. #jira UE-166341 #rb jeannoe.morissette [CL 28995862 by christopher waters in ue5-main branch]
2023-10-20 23:12:44 -04:00
if (Parameter.Type == EShaderParameterType::BindlessSRV)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
Chaning more code to use SetShaderParameters - MeshPassProcessor converted to use SetShaderParameters instead of setting individual resources. Caching of SRVs and Samplers was also removed. - UnsetShaderSRVs and UnsetShaderUAVs now set all the null binds in a single SetShaderParameters command. - Made some FRHIShaderParameterResource utilities more public. #jira none #rb jeannoe.morrisette, luke.thatcher #preflight 637565eebf76990b71eb38d0 [CL 23197327 by christopher waters in ue5-main branch]
2022-11-18 12:10:55 -05:00
check(Parameter.BufferIndex == 0);
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetBindlessResourceView(Parameter.BaseIndex, SrvRHI);
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
}
else
#endif
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetShaderResourceViewParameter(Parameter.BaseIndex, SrvRHI);
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
}
}
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
inline void SetSamplerParameter(FRHIBatchedShaderParameters& BatchedParameters, const FShaderResourceParameterInfo& Parameter, FRHISamplerState* SamplerStateRHI)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
#if PLATFORM_SUPPORTS_BINDLESS_RENDERING
Bindless Resources - Splitting "Bindless Resource" shader parameter types into "Bindless SRV" and "Bindless UAV" to make sure reflection/binding validation is correct. #jira UE-166341 #rb jeannoe.morissette [CL 28995862 by christopher waters in ue5-main branch]
2023-10-20 23:12:44 -04:00
if (Parameter.Type == EShaderParameterType::BindlessSampler)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetBindlessSampler(Parameter.BaseIndex, SamplerStateRHI);
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
}
else
#endif
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetShaderSampler(Parameter.BaseIndex, SamplerStateRHI);
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
}
}
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
inline void SetLooseParameters(FRHIBatchedShaderParameters& BatchedParameters, const FShaderParameterMapInfo& ParameterMapInfo, const uint8* LooseDataStart)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
Chaning more code to use SetShaderParameters - MeshPassProcessor converted to use SetShaderParameters instead of setting individual resources. Caching of SRVs and Samplers was also removed. - UnsetShaderSRVs and UnsetShaderUAVs now set all the null binds in a single SetShaderParameters command. - Made some FRHIShaderParameterResource utilities more public. #jira none #rb jeannoe.morrisette, luke.thatcher #preflight 637565eebf76990b71eb38d0 [CL 23197327 by christopher waters in ue5-main branch]
2022-11-18 12:10:55 -05:00
for (const FShaderLooseParameterBufferInfo& LooseParameterBuffer : ParameterMapInfo.LooseParameterBuffers)
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
{
Chaning more code to use SetShaderParameters - MeshPassProcessor converted to use SetShaderParameters instead of setting individual resources. Caching of SRVs and Samplers was also removed. - UnsetShaderSRVs and UnsetShaderUAVs now set all the null binds in a single SetShaderParameters command. - Made some FRHIShaderParameterResource utilities more public. #jira none #rb jeannoe.morrisette, luke.thatcher #preflight 637565eebf76990b71eb38d0 [CL 23197327 by christopher waters in ue5-main branch]
2022-11-18 12:10:55 -05:00
for (const FShaderLooseParameterInfo& Parameter : LooseParameterBuffer.Parameters)
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetShaderParameter(
LooseParameterBuffer.BaseIndex,
Parameter.BaseIndex,
Parameter.Size,
LooseDataStart
);
Chaning more code to use SetShaderParameters - MeshPassProcessor converted to use SetShaderParameters instead of setting individual resources. Caching of SRVs and Samplers was also removed. - UnsetShaderSRVs and UnsetShaderUAVs now set all the null binds in a single SetShaderParameters command. - Made some FRHIShaderParameterResource utilities more public. #jira none #rb jeannoe.morrisette, luke.thatcher #preflight 637565eebf76990b71eb38d0 [CL 23197327 by christopher waters in ue5-main branch]
2022-11-18 12:10:55 -05:00
LooseDataStart += Parameter.Size;
}
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
}
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
void FMeshDrawShaderBindings::SetShaderBindings(
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
FRHIBatchedShaderParameters& BatchedParameters,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FReadOnlyMeshDrawSingleShaderBindings& RESTRICT SingleShaderBindings,
FShaderBindingState& RESTRICT ShaderBindingState)
{
FRHIUniformBuffer* const* RESTRICT UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderUniformBufferParameterInfo* RESTRICT UniformBufferParameters = SingleShaderBindings.ParameterMapInfo.UniformBuffers.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const int32 NumUniformBuffers = SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num();
for (int32 UniformBufferIndex = 0; UniformBufferIndex < NumUniformBuffers; UniformBufferIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderUniformBufferParameterInfo Parameter = UniformBufferParameters[UniformBufferIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
checkSlow(Parameter.BaseIndex < UE_ARRAY_COUNT(ShaderBindingState.UniformBuffers));
FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
if (UniformBuffer != ShaderBindingState.UniformBuffers[Parameter.BaseIndex])
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetShaderUniformBuffer(Parameter.BaseIndex, UniformBuffer);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
ShaderBindingState.UniformBuffers[Parameter.BaseIndex] = UniformBuffer;
ShaderBindingState.MaxUniformBufferUsed = FMath::Max((int32)Parameter.BaseIndex, ShaderBindingState.MaxUniformBufferUsed);
}
}
FRHISamplerState* const* RESTRICT SamplerBindings = SingleShaderBindings.GetSamplerStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderResourceParameterInfo* RESTRICT TextureSamplerParameters = SingleShaderBindings.ParameterMapInfo.TextureSamplers.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const int32 NumTextureSamplers = SingleShaderBindings.ParameterMapInfo.TextureSamplers.Num();
for (int32 SamplerIndex = 0; SamplerIndex < NumTextureSamplers; SamplerIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderResourceParameterInfo Parameter = TextureSamplerParameters[SamplerIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FRHISamplerState* Sampler = (FRHISamplerState*)SamplerBindings[SamplerIndex];
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetSamplerParameter(BatchedParameters, Parameter, Sampler);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
const uint8* RESTRICT SRVType = SingleShaderBindings.GetSRVTypeStart();
FRHIResource* const* RESTRICT SRVBindings = SingleShaderBindings.GetSRVStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderResourceParameterInfo* RESTRICT SRVParameters = SingleShaderBindings.ParameterMapInfo.SRVs.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const uint32 NumSRVs = SingleShaderBindings.ParameterMapInfo.SRVs.Num();
for (uint32 SRVIndex = 0; SRVIndex < NumSRVs; SRVIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderResourceParameterInfo Parameter = SRVParameters[SRVIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 TypeByteIndex = SRVIndex / 8;
uint32 TypeBitIndex = SRVIndex % 8;
if (SRVType[TypeByteIndex] & (1 << TypeBitIndex))
{
FRHIShaderResourceView* SRV = (FRHIShaderResourceView*)SRVBindings[SRVIndex];
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetSrvParameter(BatchedParameters, Parameter, SRV);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
else
{
FRHITexture* Texture = (FRHITexture*)SRVBindings[SRVIndex];
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetTextureParameter(BatchedParameters, Parameter, Texture);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetLooseParameters(BatchedParameters, SingleShaderBindings.ParameterMapInfo, SingleShaderBindings.GetLooseDataStart());
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
void FMeshDrawShaderBindings::SetShaderBindings(
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
FRHIBatchedShaderParameters& BatchedParameters,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FReadOnlyMeshDrawSingleShaderBindings& RESTRICT SingleShaderBindings)
{
FRHIUniformBuffer* const* RESTRICT UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderUniformBufferParameterInfo* RESTRICT UniformBufferParameters = SingleShaderBindings.ParameterMapInfo.UniformBuffers.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const int32 NumUniformBuffers = SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num();
for (int32 UniformBufferIndex = 0; UniformBufferIndex < NumUniformBuffers; UniformBufferIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderUniformBufferParameterInfo Parameter = UniformBufferParameters[UniformBufferIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
if (UniformBuffer)
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
BatchedParameters.SetShaderUniformBuffer(Parameter.BaseIndex, UniformBuffer);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
FRHISamplerState* const* RESTRICT SamplerBindings = SingleShaderBindings.GetSamplerStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderResourceParameterInfo* RESTRICT TextureSamplerParameters = SingleShaderBindings.ParameterMapInfo.TextureSamplers.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const int32 NumTextureSamplers = SingleShaderBindings.ParameterMapInfo.TextureSamplers.Num();
for (int32 SamplerIndex = 0; SamplerIndex < NumTextureSamplers; SamplerIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderResourceParameterInfo Parameter = TextureSamplerParameters[SamplerIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FRHISamplerState* Sampler = (FRHISamplerState*)SamplerBindings[SamplerIndex];
HetergenousVolumes: Adding support for shadow-casting from hard surfaces. #rb sebastien.hillaire mihnea.balta #preflight 631956d0d135b61bc5e853a9 [CL 21907421 by patrick kelly in ue5-main branch]
2022-09-08 19:31:50 -04:00
if (Sampler)
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetSamplerParameter(BatchedParameters, Parameter, Sampler);
HetergenousVolumes: Adding support for shadow-casting from hard surfaces. #rb sebastien.hillaire mihnea.balta #preflight 631956d0d135b61bc5e853a9 [CL 21907421 by patrick kelly in ue5-main branch]
2022-09-08 19:31:50 -04:00
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
const uint8* RESTRICT SRVType = SingleShaderBindings.GetSRVTypeStart();
FRHIResource* const* RESTRICT SRVBindings = SingleShaderBindings.GetSRVStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderResourceParameterInfo* RESTRICT SRVParameters = SingleShaderBindings.ParameterMapInfo.SRVs.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const uint32 NumSRVs = SingleShaderBindings.ParameterMapInfo.SRVs.Num();
for (uint32 SRVIndex = 0; SRVIndex < NumSRVs; SRVIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderResourceParameterInfo Parameter = SRVParameters[SRVIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 TypeByteIndex = SRVIndex / 8;
uint32 TypeBitIndex = SRVIndex % 8;
if (SRVType[TypeByteIndex] & (1 << TypeBitIndex))
{
FRHIShaderResourceView* SRV = (FRHIShaderResourceView*)SRVBindings[SRVIndex];
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetSrvParameter(BatchedParameters, Parameter, SRV);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
else
{
FRHITexture* Texture = (FRHITexture*)SRVBindings[SRVIndex];
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetTextureParameter(BatchedParameters, Parameter, Texture);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetLooseParameters(BatchedParameters, SingleShaderBindings.ParameterMapInfo, SingleShaderBindings.GetLooseDataStart());
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
#if RHI_RAYTRACING
FRayTracingLocalShaderBindings* FMeshDrawShaderBindings::SetRayTracingShaderBindingsForHitGroup(
FRayTracingLocalShaderBindingWriter* BindingWriter,
uint32 InstanceIndex,
uint32 SegmentIndex,
uint32 HitGroupIndexInPipeline,
uint32 ShaderSlot) const
{
check(ShaderLayouts.Num() == 1);
FReadOnlyMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[0], GetData());
FRHIUniformBuffer* const* RESTRICT UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderUniformBufferParameterInfo* RESTRICT UniformBufferParameters = SingleShaderBindings.ParameterMapInfo.UniformBuffers.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const int32 NumUniformBufferParameters = SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num();
checkf(SingleShaderBindings.ParameterMapInfo.TextureSamplers.Num() == 0, TEXT("Texture sampler parameters are not supported for ray tracing. UniformBuffers must be used for all resource binding."));
checkf(SingleShaderBindings.ParameterMapInfo.SRVs.Num() == 0, TEXT("SRV parameters are not supported for ray tracing. UniformBuffers must be used for all resource binding."));
// Measure parameter memory requirements
Fix invalid check when there are loose parameters present #rb Yuriy.ODonnell #jira none #preflight 63211325506f1a33e07fe6a6 [CL 21996202 by chris kulla in ue5-main branch]
2022-09-13 19:58:34 -04:00
int32 MaxUniformBufferIndex = -1;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
for (int32 UniformBufferIndex = 0; UniformBufferIndex < NumUniformBufferParameters; UniformBufferIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderUniformBufferParameterInfo Parameter = UniformBufferParameters[UniformBufferIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
Fix invalid check when there are loose parameters present #rb Yuriy.ODonnell #jira none #preflight 63211325506f1a33e07fe6a6 [CL 21996202 by chris kulla in ue5-main branch]
2022-09-13 19:58:34 -04:00
MaxUniformBufferIndex = FMath::Max((int32)Parameter.BaseIndex, MaxUniformBufferIndex);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
Fix invalid check when there are loose parameters present #rb Yuriy.ODonnell #jira none #preflight 63211325506f1a33e07fe6a6 [CL 21996202 by chris kulla in ue5-main branch]
2022-09-13 19:58:34 -04:00
const uint32 NumUniformBuffersToSet = MaxUniformBufferIndex + 1;
Path Tracer: Fix potential crash in shader bindings when a decal material accesses scene textures Make sure decals are attached before the raytracing scene is created so that the right number of slots can be reserved Fix miss/callbable shader typo Fix potential crash when searching for default callable shader index #jira UE-156382 #rb Tiago.Costa, Yuriy.ODonnell #preflight 62abbb48c6467711b631c4e1 [CL 20697490 by chris kulla in ue5-main branch]
2022-06-16 19:27:09 -04:00
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const TMemoryImageArray<FShaderLooseParameterBufferInfo>& LooseParameterBuffers = SingleShaderBindings.ParameterMapInfo.LooseParameterBuffers;
uint32 LooseParameterDataSize = 0;
if (LooseParameterBuffers.Num())
{
check(LooseParameterBuffers.Num() <= 1);
const FShaderLooseParameterBufferInfo& LooseParameterBuffer = SingleShaderBindings.ParameterMapInfo.LooseParameterBuffers[0];
check(LooseParameterBuffer.BaseIndex == 0);
for (int32 LooseParameterIndex = 0; LooseParameterIndex < LooseParameterBuffer.Parameters.Num(); LooseParameterIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderLooseParameterInfo LooseParameter = LooseParameterBuffer.Parameters[LooseParameterIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
LooseParameterDataSize = FMath::Max<uint32>(LooseParameterDataSize, LooseParameter.BaseIndex + LooseParameter.Size);
}
}
Fix invalid check when there are loose parameters present #rb Yuriy.ODonnell #jira none #preflight 63211325506f1a33e07fe6a6 [CL 21996202 by chris kulla in ue5-main branch]
2022-09-13 19:58:34 -04:00
checkf(MaxUniformBufferIndex + 1 == NumUniformBufferParameters + LooseParameterBuffers.Num(),
TEXT("Highest index of a uniform buffer was %d, but there were %d uniform buffer parameters and %d loose parameters"),
MaxUniformBufferIndex,
NumUniformBufferParameters,
LooseParameterBuffers.Num());
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
// Allocate and fill bindings
const uint32 UserData = 0; // UserData could be used to store material ID or any other kind of per-material constant. This can be retrieved in hit shaders via GetHitGroupUserData().
FRayTracingLocalShaderBindings& Bindings = BindingWriter->AddWithInlineParameters(NumUniformBuffersToSet, LooseParameterDataSize);
Bindings.InstanceIndex = InstanceIndex;
Bindings.SegmentIndex = SegmentIndex;
Bindings.ShaderSlot = ShaderSlot;
Bindings.ShaderIndexInPipeline = HitGroupIndexInPipeline;
Bindings.UserData = UserData;
for (int32 UniformBufferIndex = 0; UniformBufferIndex < NumUniformBufferParameters; UniformBufferIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderUniformBufferParameterInfo Parameter = UniformBufferParameters[UniformBufferIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
Bindings.UniformBuffers[Parameter.BaseIndex] = const_cast<FRHIUniformBuffer*>(UniformBuffer);
}
if (LooseParameterBuffers.Num())
{
const FShaderLooseParameterBufferInfo& LooseParameterBuffer = SingleShaderBindings.ParameterMapInfo.LooseParameterBuffers[0];
const uint8* LooseDataOffset = SingleShaderBindings.GetLooseDataStart();
for (int32 LooseParameterIndex = 0; LooseParameterIndex < LooseParameterBuffer.Parameters.Num(); LooseParameterIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderLooseParameterInfo LooseParameter = LooseParameterBuffer.Parameters[LooseParameterIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FMemory::Memcpy(Bindings.LooseParameterData + LooseParameter.BaseIndex, LooseDataOffset, LooseParameter.Size);
LooseDataOffset += LooseParameter.Size;
}
}
return &Bindings;
}
FRayTracingLocalShaderBindings* FMeshDrawShaderBindings::SetRayTracingShaderBindings(FRayTracingLocalShaderBindingWriter* BindingWriter, uint32 ShaderIndexInPipeline, uint32 ShaderSlot) const
{
check(ShaderLayouts.Num() == 1);
return SetRayTracingShaderBindingsForHitGroup(BindingWriter, 0, 0, ShaderIndexInPipeline, ShaderSlot);
}
PR #9166: Ray tracing light function implementation (Contributed by ehartNV) #jira UE-151474 #rb Yuriy.ODonnell Create raytracing miss shaders that implement light functions for raytraced reflections, refractions and the raytracing debug primary view. Each light with a valid light function material is assigned a miss shader in the main raytracing pipeline which is used to modulate the light intensity as part of the shadowing calculation. The light function implementation intentionally converts to grayscale for visual compatibility with the deferred renderer. As part of this CL, the default behavior for miss shaders in RT pipeline is changed. We now require the caller to use RHISetRayTracingMissShader before the first dispatch to ensure the desired shader is assigned to the desired slot in the pipeline. This relaxes some prior assumptions about the shader slot index needing to matching the shader index in the pipeline (which would not hold after having added more miss shaders to the main raytracing pipeline). Basic validation has been added to the D3D12 RHI to ensure we are correctly binding at least the 0'th miss shader slot prior to the first dispatch. #preflight 62bc99aca966c9f7ae8b1df9 #preflight 62bcbbf45d53ca5bcefc828f #preflight 62bccd7a3f0d6beee247ca53 [CL 20884852 by ehartNV in ue5-main branch]
2022-06-29 18:26:36 -04:00
void FMeshDrawShaderBindings::SetRayTracingShaderBindingsForMissShader(
FRHICommandList& RHICmdList,
FRHIRayTracingScene* Scene,
FRayTracingPipelineState* PipelineState,
uint32 ShaderIndexInPipeline,
uint32 ShaderSlot) const
{
check(ShaderLayouts.Num() == 1);
FReadOnlyMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[0], GetData());
FShaderBindingState BindingState;
const int32 MaxUniformBuffers = UE_ARRAY_COUNT(BindingState.UniformBuffers);
FRHIUniformBuffer* const* RESTRICT UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderUniformBufferParameterInfo* RESTRICT UniformBufferParameters = SingleShaderBindings.ParameterMapInfo.UniformBuffers.GetData();
PR #9166: Ray tracing light function implementation (Contributed by ehartNV) #jira UE-151474 #rb Yuriy.ODonnell Create raytracing miss shaders that implement light functions for raytraced reflections, refractions and the raytracing debug primary view. Each light with a valid light function material is assigned a miss shader in the main raytracing pipeline which is used to modulate the light intensity as part of the shadowing calculation. The light function implementation intentionally converts to grayscale for visual compatibility with the deferred renderer. As part of this CL, the default behavior for miss shaders in RT pipeline is changed. We now require the caller to use RHISetRayTracingMissShader before the first dispatch to ensure the desired shader is assigned to the desired slot in the pipeline. This relaxes some prior assumptions about the shader slot index needing to matching the shader index in the pipeline (which would not hold after having added more miss shaders to the main raytracing pipeline). Basic validation has been added to the D3D12 RHI to ensure we are correctly binding at least the 0'th miss shader slot prior to the first dispatch. #preflight 62bc99aca966c9f7ae8b1df9 #preflight 62bcbbf45d53ca5bcefc828f #preflight 62bccd7a3f0d6beee247ca53 [CL 20884852 by ehartNV in ue5-main branch]
2022-06-29 18:26:36 -04:00
const int32 NumUniformBufferParameters = SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num();
checkf(SingleShaderBindings.ParameterMapInfo.TextureSamplers.Num() == 0, TEXT("Texture sampler parameters are not supported for ray tracing. UniformBuffers must be used for all resource binding."));
checkf(SingleShaderBindings.ParameterMapInfo.SRVs.Num() == 0, TEXT("SRV parameters are not supported for ray tracing. UniformBuffers must be used for all resource binding."));
// Measure parameter memory requirements
int32 MaxUniformBufferUsed = -1;
for (int32 UniformBufferIndex = 0; UniformBufferIndex < NumUniformBufferParameters; UniformBufferIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderUniformBufferParameterInfo Parameter = UniformBufferParameters[UniformBufferIndex];
PR #9166: Ray tracing light function implementation (Contributed by ehartNV) #jira UE-151474 #rb Yuriy.ODonnell Create raytracing miss shaders that implement light functions for raytraced reflections, refractions and the raytracing debug primary view. Each light with a valid light function material is assigned a miss shader in the main raytracing pipeline which is used to modulate the light intensity as part of the shadowing calculation. The light function implementation intentionally converts to grayscale for visual compatibility with the deferred renderer. As part of this CL, the default behavior for miss shaders in RT pipeline is changed. We now require the caller to use RHISetRayTracingMissShader before the first dispatch to ensure the desired shader is assigned to the desired slot in the pipeline. This relaxes some prior assumptions about the shader slot index needing to matching the shader index in the pipeline (which would not hold after having added more miss shaders to the main raytracing pipeline). Basic validation has been added to the D3D12 RHI to ensure we are correctly binding at least the 0'th miss shader slot prior to the first dispatch. #preflight 62bc99aca966c9f7ae8b1df9 #preflight 62bcbbf45d53ca5bcefc828f #preflight 62bccd7a3f0d6beee247ca53 [CL 20884852 by ehartNV in ue5-main branch]
2022-06-29 18:26:36 -04:00
checkSlow(Parameter.BaseIndex < MaxUniformBuffers);
FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
if (Parameter.BaseIndex < MaxUniformBuffers)
{
BindingState.UniformBuffers[Parameter.BaseIndex] = UniformBuffer;
MaxUniformBufferUsed = FMath::Max((int32)Parameter.BaseIndex, MaxUniformBufferUsed);
}
}
checkf(SingleShaderBindings.ParameterMapInfo.TextureSamplers.Num() == 0, TEXT("Texture sampler parameters are not supported for ray tracing. UniformBuffers must be used for all resource binding."));
checkf(SingleShaderBindings.ParameterMapInfo.SRVs.Num() == 0, TEXT("SRV parameters are not supported for ray tracing. UniformBuffers must be used for all resource binding."));
checkf(SingleShaderBindings.ParameterMapInfo.LooseParameterBuffers.Num() == 0, TEXT("Ray tracing miss shaders may not have loose parameters"));
uint32 NumUniformBuffersToSet = MaxUniformBufferUsed + 1;
const uint32 UserData = 0; // UserData could be used to store material ID or any other kind of per-material constant. This can be retrieved in hit shaders via GetHitGroupUserData().
RHICmdList.SetRayTracingMissShader(Scene, ShaderSlot, PipelineState, ShaderIndexInPipeline,
NumUniformBuffersToSet, BindingState.UniformBuffers,
UserData);
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
#endif // RHI_RAYTRACING
FGraphicsMinimalPipelineStateId FGraphicsMinimalPipelineStateId::GetPersistentId(const FGraphicsMinimalPipelineStateInitializer& InPipelineState)
{
Experimental::FHashElementId TableId;
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
#if MESH_DRAW_COMMAND_DEBUG_DATA
int32 DebugSalt;
#endif
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
auto hash = PersistentIdTable.ComputeHash(InPipelineState);
{
FRWScopeLock Lock(PersistentIdTableLock, SLT_ReadOnly);
#if UE_BUILD_DEBUG
FGraphicsMinimalPipelineStateInitializer PipelineStateDebug = FGraphicsMinimalPipelineStateInitializer(InPipelineState);
check(GetTypeHash(PipelineStateDebug) == GetTypeHash(InPipelineState));
check(PipelineStateDebug == InPipelineState);
#endif
TableId = PersistentIdTable.FindIdByHash(hash, InPipelineState);
if (!TableId.IsValid())
{
Lock.ReleaseReadOnlyLockAndAcquireWriteLock_USE_WITH_CAUTION();
TableId = PersistentIdTable.FindOrAddIdByHash(hash, InPipelineState, FRefCountedGraphicsMinimalPipelineState());
}
FRefCountedGraphicsMinimalPipelineState& Value = PersistentIdTable.GetByElementId(TableId).Value;
Fix for Persistent ID ReffedItem count assert -- conditional needs to be atomic so ReffedItem can only be incremented once, if multiple threads happen to request a given item at the same time. #jira none #rnx #rb jeremie.roy #preflight 63c860a6d206f305131f691e [CL 23764885 by jason hoerner in ue5-main branch]
2023-01-18 16:42:28 -05:00
// Needs to be atomic, so condition is only true on first increment
if (Value.RefNum.fetch_add(1) == 0)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
if (!NeedsShaderInitialisation)
{
NeedsShaderInitialisation = true;
}
ReffedItemCount++;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
#if MESH_DRAW_COMMAND_DEBUG_DATA
DebugSalt = Value.DebugSalt;
#endif
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
checkf(TableId.GetIndex() < (MAX_uint32 >> 2), TEXT("Persistent FGraphicsMinimalPipelineStateId table overflow!"));
FGraphicsMinimalPipelineStateId Ret;
Ret.bValid = 1;
Ret.bComesFromLocalPipelineStateSet = 0;
Ret.SetElementIndex = TableId.GetIndex();
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
#if MESH_DRAW_COMMAND_DEBUG_DATA
Ret.DebugSalt = DebugSalt;
#endif
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
return Ret;
}
void FGraphicsMinimalPipelineStateId::InitializePersistentIds()
{
TRACE_CPUPROFILER_EVENT_SCOPE(InitializePersistentMdcIds);
FRWScopeLock WriteLock(PersistentIdTableLock, SLT_Write);
if (NeedsShaderInitialisation)
{
for (TPair<const FGraphicsMinimalPipelineStateInitializer, FRefCountedGraphicsMinimalPipelineState>& Element : PersistentIdTable)
{
Element.Key.BoundShaderState.LazilyInitShaders();
}
NeedsShaderInitialisation = false;
}
}
void FGraphicsMinimalPipelineStateId::RemovePersistentId(FGraphicsMinimalPipelineStateId Id)
{
check(!Id.bComesFromLocalPipelineStateSet && Id.bValid);
{
FRWScopeLock WriteLock(PersistentIdTableLock, SLT_Write);
FRefCountedGraphicsMinimalPipelineState& RefCountedStateInitializer = PersistentIdTable.GetByElementId(Id.SetElementIndex).Value;
check(RefCountedStateInitializer.RefNum > 0);
--RefCountedStateInitializer.RefNum;
if (RefCountedStateInitializer.RefNum == 0)
{
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
ReffedItemCount--;
if (bIsIdTableFrozen == false)
{
PersistentIdTable.RemoveByElementId(Id.SetElementIndex);
}
}
}
}
void FGraphicsMinimalPipelineStateId::FreezeIdTable(bool bFreeze)
{
if (bFreeze != bIsIdTableFrozen)
{
FRWScopeLock WriteLock(PersistentIdTableLock, SLT_Write);
bIsIdTableFrozen = bFreeze;
// When set back to false, do a pass through the table and clean up any zero ref items. Zero ref items usually don't happen
// in practice given the context of how this function is used during calls to FPrimitiveSceneInfo::UpdateStaticMeshes where
// multiple scene renderers are running (i.e. nDisplay multi-view). That function removes and re-creates draw commands for a
// set of render proxies, which we expect to produce the same set of pipeline cache IDs, given that no game logic can run
// to change any state in the render proxies between renders of the same scene. We could assert, but cleaning up the zero
// reference items isn't an unreasonable option either (in case someone tries to use this function for other purposes)...
if (bFreeze == false)
{
// We can detect whether we need to scan the table for zero ref items, by checking whether the number of items with
// non-zero ref count equals the number of items in the table.
if (PersistentIdTable.Num() != ReffedItemCount)
{
// There's a bug in our reference counting if the reffed item count is more than the items actually in the table
check(PersistentIdTable.Num() > ReffedItemCount);
// Remove zero reffed items
for (auto PersistentIdIterator = PersistentIdTable.begin(); PersistentIdIterator != PersistentIdTable.end(); ++PersistentIdIterator)
{
if (PersistentIdTable.GetByElementId(PersistentIdIterator.GetElementId()).Value.RefNum == 0)
{
PersistentIdTable.RemoveByElementId(PersistentIdIterator.GetElementId());
}
}
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
}
FGraphicsMinimalPipelineStateId FGraphicsMinimalPipelineStateId::GetPipelineStateId(const FGraphicsMinimalPipelineStateInitializer& InPipelineState, FGraphicsMinimalPipelineStateSet& InOutPassSet, bool& InNeedsShaderInitialisation)
{
FGraphicsMinimalPipelineStateId Ret;
Ret.bValid = 1;
Ret.bComesFromLocalPipelineStateSet = 1;
#if UE_BUILD_DEBUG
FGraphicsMinimalPipelineStateInitializer PipelineStateDebug = FGraphicsMinimalPipelineStateInitializer(InPipelineState);
check(GetTypeHash(PipelineStateDebug) == GetTypeHash(InPipelineState));
check(PipelineStateDebug == InPipelineState);
#endif
Experimental::FHashElementId TableIndex = InOutPassSet.FindOrAddId(InPipelineState);
#if UE_BUILD_DEBUG
check(InOutPassSet.GetByElementId(TableIndex) == InPipelineState);
#endif
InNeedsShaderInitialisation = InNeedsShaderInitialisation || InPipelineState.BoundShaderState.NeedsShaderInitialisation();
checkf(TableIndex.GetIndex() < (MAX_uint32 >> 2), TEXT("One frame FGraphicsMinimalPipelineStateId table overflow!"));
Ret.SetElementIndex = TableIndex.GetIndex();
Proper fix for Nanite uniform buffer crash, allowing multi-view rendering optimizations to be re-enabled (reversing CL 23287608, which disabled those optimizations). Saves mulitple ms CPU potentially. Need to ensure pipeline state cache references (FGraphicsMinimalPipelineStateId) aren't released by another thread while still in use by parallel task threads (FSubmitNaniteMaterialPassCommandsAnyThreadTask or FDrawVisibleMeshCommandsAnyThreadTask). This can happen during calls to FPrimitiveSceneInfo::UpdateStaticMeshes, which calls RemoveCachedMeshDrawCommands followed by CacheMeshDrawCommands (or the Nanite equivalent) for a set of proxies to rebuild their mesh commands. If any persistent pipeline state ID goes to zero reference count during that process, it will be released and the cached ID will change when it gets reallocated. A utility function freezes the pipeline state ID table during FSceneRenderer::ComputeViewVisibility (which is what calls UpdateStaticMeshes) for scene renderers besides the first, making it so persistent pipeline state IDs aren't freed even if their reference count goes to zero. The same pipeline states end up being used in the draw commands for a render proxy following an update, given that the scene renderers are run sequentially, and nothing can run between them to change any state. If any zero reference items remain when the table is unfrozen, they will be cleaned up anyway, just in case that ever happens. #jira none #rnx #preflight 63c6b4b802024f93d8597267 #rb mihnea.balta kenzo.terelst [CL 23737757 by jason hoerner in ue5-main branch]
2023-01-17 10:00:00 -05:00
#if MESH_DRAW_COMMAND_DEBUG_DATA
Ret.DebugSalt = 0; // Salt is ignored for pipelines from local pipeline state set, just initialize to zero
#endif
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
return Ret;
}
void FGraphicsMinimalPipelineStateId::ResetLocalPipelineIdTableSize()
{
#if MESH_DRAW_COMMAND_DEBUG_DATA
int32 CapturedPipelineIdTableSize;
do
{
CapturedPipelineIdTableSize = CurrentLocalPipelineIdTableSize;
}while (!CurrentLocalPipelineIdTableSize.compare_exchange_strong(CapturedPipelineIdTableSize, 0));
LocalPipelineIdTableSize = CapturedPipelineIdTableSize;
#endif //MESH_DRAW_COMMAND_DEBUG_DATA
}
void FGraphicsMinimalPipelineStateId::AddSizeToLocalPipelineIdTableSize(SIZE_T Size)
{
#if MESH_DRAW_COMMAND_DEBUG_DATA
CurrentLocalPipelineIdTableSize += int32(Size);
#endif
}
FMeshDrawShaderBindings::~FMeshDrawShaderBindings()
{
Release();
}
Mesh Pass Cleanup - Removing DrawRenderState from GetShaderBindings since it's not used anymore. - Adding version of FMeshDrawShaderBindings::GetSingleShaderBindings that doesn't need an unused argument. - Deprecating Compute and RayTracing shaders on TMeshProcessorShaders; these were only added to mimic the graphics passes but that's overkill. - Changing a few pass-by-value arguments to pass-by-reference to avoid extra reference counted pointer copies. - Moved the copy-pasted compute mesh pass code into UE::MeshPassUtils::SetupComputeBindings. #rb Kenzo.Terelst, Laura.Hermanns, Yuriy.ODonnell [CL 30812160 by christopher waters in ue5-main branch]
2024-01-23 13:58:04 -05:00
void FMeshDrawShaderBindings::Initialize(const FMeshProcessorShaders& Shaders)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
const int32 NumShaderFrequencies =
(Shaders.VertexShader.IsValid() ? 1 : 0) +
(Shaders.PixelShader.IsValid() ? 1 : 0) +
(Shaders.GeometryShader.IsValid() ? 1 : 0) +
(Shaders.ComputeShader.IsValid() ? 1 : 0)
#if RHI_RAYTRACING
+ (Shaders.RayTracingShader.IsValid() ? 1 : 0)
#endif
;
ShaderLayouts.Empty(NumShaderFrequencies);
int32 ShaderBindingDataSize = 0;
if (Shaders.VertexShader.IsValid())
{
ShaderLayouts.Add(FMeshDrawShaderBindingsLayout(Shaders.VertexShader));
ShaderBindingDataSize += ShaderLayouts.Last().GetDataSizeBytes();
check(ShaderFrequencyBits < (1 << SF_Vertex));
ShaderFrequencyBits |= (1 << SF_Vertex);
}
if (Shaders.PixelShader.IsValid())
{
ShaderLayouts.Add(FMeshDrawShaderBindingsLayout(Shaders.PixelShader));
ShaderBindingDataSize += ShaderLayouts.Last().GetDataSizeBytes();
check(ShaderFrequencyBits < (1 << SF_Pixel));
ShaderFrequencyBits |= (1 << SF_Pixel);
}
if (Shaders.GeometryShader.IsValid())
{
ShaderLayouts.Add(FMeshDrawShaderBindingsLayout(Shaders.GeometryShader));
ShaderBindingDataSize += ShaderLayouts.Last().GetDataSizeBytes();
check(ShaderFrequencyBits < (1 << SF_Geometry));
ShaderFrequencyBits |= (1 << SF_Geometry);
}
if (Shaders.ComputeShader.IsValid())
{
ShaderLayouts.Add(FMeshDrawShaderBindingsLayout(Shaders.ComputeShader));
ShaderBindingDataSize += ShaderLayouts.Last().GetDataSizeBytes();
check(ShaderFrequencyBits < (1 << SF_Compute));
ShaderFrequencyBits |= (1 << SF_Compute);
}
#if RHI_RAYTRACING
if (Shaders.RayTracingShader.IsValid())
{
ShaderLayouts.Add(FMeshDrawShaderBindingsLayout(Shaders.RayTracingShader));
ShaderBindingDataSize += ShaderLayouts.Last().GetDataSizeBytes();
const EShaderFrequency Frequency = Shaders.RayTracingShader->GetFrequency();
check(ShaderFrequencyBits < (1 << Frequency));
ShaderFrequencyBits |= (1 << Frequency);
}
#endif
checkSlow(ShaderLayouts.Num() == NumShaderFrequencies);
if (ShaderBindingDataSize > 0)
{
AllocateZeroed(ShaderBindingDataSize);
}
}
Mesh Pass Cleanup - Removing DrawRenderState from GetShaderBindings since it's not used anymore. - Adding version of FMeshDrawShaderBindings::GetSingleShaderBindings that doesn't need an unused argument. - Deprecating Compute and RayTracing shaders on TMeshProcessorShaders; these were only added to mimic the graphics passes but that's overkill. - Changing a few pass-by-value arguments to pass-by-reference to avoid extra reference counted pointer copies. - Moved the copy-pasted compute mesh pass code into UE::MeshPassUtils::SetupComputeBindings. #rb Kenzo.Terelst, Laura.Hermanns, Yuriy.ODonnell [CL 30812160 by christopher waters in ue5-main branch]
2024-01-23 13:58:04 -05:00
void FMeshDrawShaderBindings::Initialize(const TShaderRef<FShader>& Shader)
{
const int32 NumShaderFrequencies = (Shader.IsValid() ? 1 : 0);
ShaderLayouts.Empty(NumShaderFrequencies);
int32 ShaderBindingDataSize = 0;
if (Shader.IsValid())
{
ShaderLayouts.Add(FMeshDrawShaderBindingsLayout(Shader));
ShaderBindingDataSize += ShaderLayouts.Last().GetDataSizeBytes();
const EShaderFrequency Frequency = Shader->GetFrequency();
check(ShaderFrequencyBits < (1 << Frequency));
ShaderFrequencyBits |= (1 << Frequency);
}
checkSlow(ShaderLayouts.Num() == NumShaderFrequencies);
if (ShaderBindingDataSize > 0)
{
AllocateZeroed(ShaderBindingDataSize);
}
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
void FMeshDrawShaderBindings::Finalize(const FMeshProcessorShaders* ShadersForDebugging)
{
#if VALIDATE_MESH_COMMAND_BINDINGS
if (!ShadersForDebugging)
{
return;
}
const uint8* ShaderBindingDataPtr = GetData();
uint32 ShaderFrequencyBitIndex = ~0;
for (int32 ShaderBindingsIndex = 0; ShaderBindingsIndex < ShaderLayouts.Num(); ShaderBindingsIndex++)
{
EShaderFrequency Frequency = SF_NumFrequencies;
while (true)
{
ShaderFrequencyBitIndex++;
if ((ShaderFrequencyBits & (1 << ShaderFrequencyBitIndex)) != 0)
{
Frequency = EShaderFrequency(ShaderFrequencyBitIndex);
break;
}
}
check(Frequency < SF_NumFrequencies);
const FMeshDrawShaderBindingsLayout& ShaderLayout = ShaderLayouts[ShaderBindingsIndex];
TShaderRef<FShader> Shader = ShadersForDebugging->GetShader(Frequency);
check(Shader.IsValid());
const FVertexFactoryType* VFType = Shader.GetVertexFactoryType();
FReadOnlyMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayout, ShaderBindingDataPtr);
FRHIUniformBuffer* const* UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
for (int32 BindingIndex = 0; BindingIndex < ShaderLayout.ParameterMapInfo.UniformBuffers.Num(); BindingIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderUniformBufferParameterInfo ParameterInfo = ShaderLayout.ParameterMapInfo.UniformBuffers[BindingIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FRHIUniformBuffer* UniformBufferValue = UniformBufferBindings[BindingIndex];
if (!UniformBufferValue)
{
// Search the automatically bound uniform buffers for more context if available
const FShaderParametersMetadata* AutomaticallyBoundUniformBufferStruct = Shader->FindAutomaticallyBoundUniformBufferStruct(ParameterInfo.BaseIndex);
if (AutomaticallyBoundUniformBufferStruct)
{
ensureMsgf(
UniformBufferValue || EnumHasAnyFlags(AutomaticallyBoundUniformBufferStruct->GetBindingFlags(), EUniformBufferBindingFlags::Static),
TEXT("Shader %s with vertex factory %s never set automatically bound uniform buffer at BaseIndex %i. Expected buffer of type %s. This can cause GPU hangs, depending on how the shader uses it."),
Shader.GetType()->GetName(),
VFType ? VFType->GetName() : TEXT("nullptr"),
ParameterInfo.BaseIndex,
AutomaticallyBoundUniformBufferStruct->GetStructTypeName());
}
else
{
ensureMsgf(UniformBufferValue, TEXT("Shader %s with vertex factory %s never set uniform buffer at BaseIndex %i. This can cause GPU hangs, depending on how the shader uses it."),
VFType ? VFType->GetName() : TEXT("nullptr"),
Shader.GetType()->GetName(),
ParameterInfo.BaseIndex);
}
}
}
FRHISamplerState* const* SamplerBindings = SingleShaderBindings.GetSamplerStart();
for (int32 BindingIndex = 0; BindingIndex < ShaderLayout.ParameterMapInfo.TextureSamplers.Num(); BindingIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderResourceParameterInfo ParameterInfo = ShaderLayout.ParameterMapInfo.TextureSamplers[BindingIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FRHISamplerState* SamplerValue = SamplerBindings[BindingIndex];
ensureMsgf(SamplerValue, TEXT("Shader %s with vertex factory %s never set sampler at BaseIndex %u. This can cause GPU hangs, depending on how the shader uses it."),
Shader.GetType()->GetName(),
VFType ? VFType->GetName() : TEXT("nullptr"),
ParameterInfo.BaseIndex);
}
const uint8* RESTRICT SRVType = SingleShaderBindings.GetSRVTypeStart();
FRHIResource* const* RESTRICT SRVBindings = SingleShaderBindings.GetSRVStart();
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
const FShaderResourceParameterInfo* RESTRICT SRVParameters = SingleShaderBindings.ParameterMapInfo.SRVs.GetData();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const uint32 NumSRVs = SingleShaderBindings.ParameterMapInfo.SRVs.Num();
for (uint32 SRVIndex = 0; SRVIndex < NumSRVs; SRVIndex++)
{
Adding bindless support to more MDC parameter types. Removing unneeded data from MDC UB binding info. #jira UE-139616 #rb zach.bethel #preflight 6303ec020061f895d0edfe3d [CL 21496103 by christopher waters in ue5-main branch]
2022-08-22 18:22:37 -04:00
FShaderResourceParameterInfo Parameter = SRVParameters[SRVIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 TypeByteIndex = SRVIndex / 8;
uint32 TypeBitIndex = SRVIndex % 8;
if (SRVType[TypeByteIndex] & (1 << TypeBitIndex))
{
FRHIShaderResourceView* SRV = (FRHIShaderResourceView*)SRVBindings[SRVIndex];
ensureMsgf(SRV, TEXT("Shader %s with vertex factory %s never set SRV at BaseIndex %u. This can cause GPU hangs, depending on how the shader uses it."),
Shader.GetType()->GetName(),
VFType ? VFType->GetName() : TEXT("nullptr"),
Parameter.BaseIndex);
}
else
{
FRHITexture* Texture = (FRHITexture*)SRVBindings[SRVIndex];
ensureMsgf(Texture, TEXT("Shader %s with vertex factory %s never set texture at BaseIndex %u. This can cause GPU hangs, depending on how the shader uses it."),
Shader.GetType()->GetName(),
VFType ? VFType->GetName() : TEXT("nullptr"),
Parameter.BaseIndex);
}
}
ShaderBindingDataPtr += ShaderLayout.GetDataSizeBytes();
}
#endif
}
void FMeshDrawShaderBindings::CopyFrom(const FMeshDrawShaderBindings& Other)
{
Release();
ShaderLayouts = Other.ShaderLayouts;
ShaderFrequencyBits = Other.ShaderFrequencyBits;
Allocate(Other.Size);
if (Other.UsesInlineStorage())
{
Data = Other.Data;
}
else
{
FPlatformMemory::Memcpy(GetData(), Other.GetData(), Size);
}
#if VALIDATE_UNIFORM_BUFFER_LIFETIME
uint8* ShaderBindingDataPtr = GetData();
for (int32 ShaderBindingsIndex = 0; ShaderBindingsIndex < ShaderLayouts.Num(); ShaderBindingsIndex++)
{
FMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[ShaderBindingsIndex], ShaderBindingDataPtr);
Fixing VALIDATE_UNIFORM_BUFFER_LIFETIME compile errors and getting it to run correctly in a multithreaded environment. #jira none #rb mihnea.balta #preflight 63d45b925354589b5c18b494 [CL 23909528 by christopher waters in ue5-main branch]
2023-01-30 11:55:39 -05:00
const FRHIUniformBuffer** RESTRICT UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const int32 NumUniformBuffers = SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num();
for (int32 UniformBufferIndex = 0; UniformBufferIndex < NumUniformBuffers; UniformBufferIndex++)
{
Fixing VALIDATE_UNIFORM_BUFFER_LIFETIME compile errors and getting it to run correctly in a multithreaded environment. #jira none #rb mihnea.balta #preflight 63d45b925354589b5c18b494 [CL 23909528 by christopher waters in ue5-main branch]
2023-01-30 11:55:39 -05:00
const FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
if (UniformBuffer)
{
UniformBuffer->NumMeshCommandReferencesForDebugging++;
}
}
ShaderBindingDataPtr += ShaderLayouts[ShaderBindingsIndex].GetDataSizeBytes();
}
#endif
}
void FMeshDrawShaderBindings::Release()
{
#if VALIDATE_UNIFORM_BUFFER_LIFETIME
uint8* ShaderBindingDataPtr = GetData();
for (int32 ShaderBindingsIndex = 0; ShaderBindingsIndex < ShaderLayouts.Num(); ShaderBindingsIndex++)
{
FMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[ShaderBindingsIndex], ShaderBindingDataPtr);
Fixing VALIDATE_UNIFORM_BUFFER_LIFETIME compile errors and getting it to run correctly in a multithreaded environment. #jira none #rb mihnea.balta #preflight 63d45b925354589b5c18b494 [CL 23909528 by christopher waters in ue5-main branch]
2023-01-30 11:55:39 -05:00
const FRHIUniformBuffer** RESTRICT UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const int32 NumUniformBuffers = SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num();
for (int32 UniformBufferIndex = 0; UniformBufferIndex < NumUniformBuffers; UniformBufferIndex++)
{
Fixing VALIDATE_UNIFORM_BUFFER_LIFETIME compile errors and getting it to run correctly in a multithreaded environment. #jira none #rb mihnea.balta #preflight 63d45b925354589b5c18b494 [CL 23909528 by christopher waters in ue5-main branch]
2023-01-30 11:55:39 -05:00
if (const FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex])
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
Fixing VALIDATE_UNIFORM_BUFFER_LIFETIME compile errors and getting it to run correctly in a multithreaded environment. #jira none #rb mihnea.balta #preflight 63d45b925354589b5c18b494 [CL 23909528 by christopher waters in ue5-main branch]
2023-01-30 11:55:39 -05:00
const int32 NumMeshCommandReferencesForDebugging = --UniformBuffer->NumMeshCommandReferencesForDebugging;
check(NumMeshCommandReferencesForDebugging >= 0);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
ShaderBindingDataPtr += ShaderLayouts[ShaderBindingsIndex].GetDataSizeBytes();
}
#endif
if (Size > sizeof(FData))
{
delete[] Data.GetHeapData();
}
Size = 0;
Data.SetHeapData(nullptr);
}
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
void FGraphicsMinimalPipelineStateInitializer::SetupBoundShaderState(FRHIVertexDeclaration* VertexDeclaration, const FMeshProcessorShaders& Shaders)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
BoundShaderState = FMinimalBoundShaderStateInput();
BoundShaderState.VertexDeclarationRHI = VertexDeclaration;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
checkf(Shaders.VertexShader.IsValid(), TEXT("Can't render without a vertex shader"));
if(Shaders.VertexShader.IsValid())
{
checkSlow(Shaders.VertexShader->GetFrequency() == SF_Vertex);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
BoundShaderState.VertexShaderResource = Shaders.VertexShader.GetResource();
BoundShaderState.VertexShaderIndex = Shaders.VertexShader->GetResourceIndex();
check(BoundShaderState.VertexShaderResource->IsValidShaderIndex(BoundShaderState.VertexShaderIndex));
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
if (Shaders.PixelShader.IsValid())
{
checkSlow(Shaders.PixelShader->GetFrequency() == SF_Pixel);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
BoundShaderState.PixelShaderResource = Shaders.PixelShader.GetResource();
BoundShaderState.PixelShaderIndex = Shaders.PixelShader->GetResourceIndex();
check(BoundShaderState.PixelShaderResource->IsValidShaderIndex(BoundShaderState.PixelShaderIndex));
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
#if PLATFORM_SUPPORTS_GEOMETRY_SHADERS
if (Shaders.GeometryShader.IsValid())
{
checkSlow(Shaders.GeometryShader->GetFrequency() == SF_Geometry);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
BoundShaderState.GeometryShaderResource = Shaders.GeometryShader.GetResource();
BoundShaderState.GeometryShaderIndex = Shaders.GeometryShader->GetResourceIndex();
check(BoundShaderState.GeometryShaderResource->IsValidShaderIndex(BoundShaderState.GeometryShaderIndex));
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
#endif // PLATFORM_SUPPORTS_GEOMETRY_SHADERS
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
void FGraphicsMinimalPipelineStateInitializer::ComputeStatePrecachePSOHash()
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
{
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
if(StatePrecachePSOHash == 0)
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
{
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
StatePrecachePSOHash = AsGraphicsPipelineStateInitializer().StatePrecachePSOHash;
check(StatePrecachePSOHash);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
else
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
{
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
checkSlow(StatePrecachePSOHash == AsGraphicsPipelineStateInitializer().StatePrecachePSOHash);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
#if RHI_RAYTRACING
void FRayTracingMeshCommand::SetRayTracingShaderBindingsForHitGroup(
FRayTracingLocalShaderBindingWriter* BindingWriter,
const TUniformBufferRef<FViewUniformShaderParameters>& ViewUniformBuffer,
Add initial version of scene uniform buffer and move GPUScene from View. #preflight 63e0ca6c244dc45a20d3f808 #rb ola.olsson, zach.bethel [CL 24027890 by wouter dek in ue5-main branch]
2023-02-06 05:56:29 -05:00
FRHIUniformBuffer* SceneUniformBuffer,
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
FRHIUniformBuffer* NaniteUniformBuffer,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 InstanceIndex,
uint32 SegmentIndex,
uint32 HitGroupIndexInPipeline,
uint32 ShaderSlot) const
{
FRayTracingLocalShaderBindings* Bindings = ShaderBindings.SetRayTracingShaderBindingsForHitGroup(BindingWriter, InstanceIndex, SegmentIndex, HitGroupIndexInPipeline, ShaderSlot);
if (ViewUniformBufferParameter.IsBound())
{
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
check(ViewUniformBuffer);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
Bindings->UniformBuffers[ViewUniformBufferParameter.GetBaseIndex()] = ViewUniformBuffer;
}
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
Add initial version of scene uniform buffer and move GPUScene from View. #preflight 63e0ca6c244dc45a20d3f808 #rb ola.olsson, zach.bethel [CL 24027890 by wouter dek in ue5-main branch]
2023-02-06 05:56:29 -05:00
if (SceneUniformBufferParameter.IsBound())
{
check(SceneUniformBuffer);
Bindings->UniformBuffers[SceneUniformBufferParameter.GetBaseIndex()] = SceneUniformBuffer;
}
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
if (NaniteUniformBufferParameter.IsBound())
{
check(NaniteUniformBuffer);
Bindings->UniformBuffers[NaniteUniformBufferParameter.GetBaseIndex()] = NaniteUniformBuffer;
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
Mesh Pass Cleanup - Removing DrawRenderState from GetShaderBindings since it's not used anymore. - Adding version of FMeshDrawShaderBindings::GetSingleShaderBindings that doesn't need an unused argument. - Deprecating Compute and RayTracing shaders on TMeshProcessorShaders; these were only added to mimic the graphics passes but that's overkill. - Changing a few pass-by-value arguments to pass-by-reference to avoid extra reference counted pointer copies. - Moved the copy-pasted compute mesh pass code into UE::MeshPassUtils::SetupComputeBindings. #rb Kenzo.Terelst, Laura.Hermanns, Yuriy.ODonnell [CL 30812160 by christopher waters in ue5-main branch]
2024-01-23 13:58:04 -05:00
void FRayTracingMeshCommand::SetShader(const TShaderRef<FShader>& Shader)
{
check(Shader.IsValid());
MaterialShaderIndex = Shader.GetRayTracingHitGroupLibraryIndex();
MaterialShader = Shader.GetRayTracingShader();
ViewUniformBufferParameter = Shader->GetUniformBufferParameter<FViewUniformShaderParameters>();
SceneUniformBufferParameter = Shader->GetUniformBufferParameter<FSceneUniformParameters>();
NaniteUniformBufferParameter = Shader->GetUniformBufferParameter<FNaniteRayTracingUniformParameters>();
ShaderBindings.Initialize(Shader);
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
void FRayTracingMeshCommand::SetShaders(const FMeshProcessorShaders& Shaders)
{
Mesh Pass Cleanup - Removing DrawRenderState from GetShaderBindings since it's not used anymore. - Adding version of FMeshDrawShaderBindings::GetSingleShaderBindings that doesn't need an unused argument. - Deprecating Compute and RayTracing shaders on TMeshProcessorShaders; these were only added to mimic the graphics passes but that's overkill. - Changing a few pass-by-value arguments to pass-by-reference to avoid extra reference counted pointer copies. - Moved the copy-pasted compute mesh pass code into UE::MeshPassUtils::SetupComputeBindings. #rb Kenzo.Terelst, Laura.Hermanns, Yuriy.ODonnell [CL 30812160 by christopher waters in ue5-main branch]
2024-01-23 13:58:04 -05:00
SetShader(Shaders.RayTracingShader);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
Support for Nanite Raytracing in RayTracingDebug - Implemented permutation of FRayTracingDebugCHS that calculates geometry normal from Nanite Cluster Data instead of VB/IB used to build BLAS. - Modified RTPSO to include 2 hitgroups (Regular, Nanite RT) and appropriate hitgroup index is selected when building SBT. - GetGeometryNormalFromTriangleBaseAttributes(...) use the appropriate logic depending on whether NANITE_RAY_TRACING is defined. #preflight 6477a4e40848b7126de42b5c #rb aleksander.netzel #jira UE-166730 [CL 25712293 by tiago costa in ue5-main branch]
2023-05-31 16:11:51 -04:00
bool FRayTracingMeshCommand::IsUsingNaniteRayTracing() const
{
return NaniteUniformBufferParameter.IsBound();
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
void FRayTracingShaderCommand::SetRayTracingShaderBindings(
FRayTracingLocalShaderBindingWriter* BindingWriter,
const TUniformBufferRef<FViewUniformShaderParameters>& ViewUniformBuffer,
Add initial version of scene uniform buffer and move GPUScene from View. #preflight 63e0ca6c244dc45a20d3f808 #rb ola.olsson, zach.bethel [CL 24027890 by wouter dek in ue5-main branch]
2023-02-06 05:56:29 -05:00
FRHIUniformBuffer* SceneUniformBuffer,
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
FRHIUniformBuffer* NaniteUniformBuffer,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 ShaderIndexInPipeline,
uint32 ShaderSlot) const
{
FRayTracingLocalShaderBindings* Bindings = ShaderBindings.SetRayTracingShaderBindings(BindingWriter, ShaderIndexInPipeline, ShaderSlot);
if (ViewUniformBufferParameter.IsBound())
{
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
check(ViewUniformBuffer);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
Bindings->UniformBuffers[ViewUniformBufferParameter.GetBaseIndex()] = ViewUniformBuffer;
}
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
Add initial version of scene uniform buffer and move GPUScene from View. #preflight 63e0ca6c244dc45a20d3f808 #rb ola.olsson, zach.bethel [CL 24027890 by wouter dek in ue5-main branch]
2023-02-06 05:56:29 -05:00
if (SceneUniformBufferParameter.IsBound())
{
check(SceneUniformBuffer);
Bindings->UniformBuffers[SceneUniformBufferParameter.GetBaseIndex()] = SceneUniformBuffer;
}
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
if (NaniteUniformBufferParameter.IsBound())
{
check(NaniteUniformBuffer);
Bindings->UniformBuffers[NaniteUniformBufferParameter.GetBaseIndex()] = NaniteUniformBuffer;
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
void FRayTracingShaderCommand::SetShader(const TShaderRef<FShader>& InShader)
{
check(InShader->GetFrequency() == SF_RayCallable || InShader->GetFrequency() == SF_RayMiss);
ShaderIndex = InShader.GetRayTracingCallableShaderLibraryIndex();
Shader = InShader.GetRayTracingShader();
ViewUniformBufferParameter = InShader->GetUniformBufferParameter<FViewUniformShaderParameters>();
Add initial version of scene uniform buffer and move GPUScene from View. #preflight 63e0ca6c244dc45a20d3f808 #rb ola.olsson, zach.bethel [CL 24027890 by wouter dek in ue5-main branch]
2023-02-06 05:56:29 -05:00
SceneUniformBufferParameter = InShader->GetUniformBufferParameter<FSceneUniformParameters>();
Support ray tracing high quality nanite meshes instead of fallback meshes. - Currently disabled by default (controlled using r.RayTracing.Nanite.Mode) - Nanite triangle data is streamed out to temporary buffers and used to build BLASes. - For hit shaders, instead of having to keep uncompressed vertex/index buffers, nanite data is referenced using an auxiliary buffer to identify page/cluster indices. - BLAS build: - Whenever a new Nanite page is installed/uninstalled, a rebuild of the associated mesh BLAS is requested. - Compute shader is dispatched to stream out mesh data to temporary buffer as well as auxiliary data used by hit shaders. - CPU then does a readback of part of the data to determine size of the BLAS etc and kicks off a BLAS rebuild. - Added raytracing support to Nanite Vertex Factory. #rb rune.stubbe, yuriy.odonnell #preflight 6331cec7b20e73a0983d9326 [CL 22203852 by tiago costa in ue5-main branch]
2022-09-27 08:28:24 -04:00
NaniteUniformBufferParameter = InShader->GetUniformBufferParameter<FNaniteRayTracingUniformParameters>();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
Mesh Pass Cleanup - Removing DrawRenderState from GetShaderBindings since it's not used anymore. - Adding version of FMeshDrawShaderBindings::GetSingleShaderBindings that doesn't need an unused argument. - Deprecating Compute and RayTracing shaders on TMeshProcessorShaders; these were only added to mimic the graphics passes but that's overkill. - Changing a few pass-by-value arguments to pass-by-reference to avoid extra reference counted pointer copies. - Moved the copy-pasted compute mesh pass code into UE::MeshPassUtils::SetupComputeBindings. #rb Kenzo.Terelst, Laura.Hermanns, Yuriy.ODonnell [CL 30812160 by christopher waters in ue5-main branch]
2024-01-23 13:58:04 -05:00
ShaderBindings.Initialize(InShader);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
#endif // RHI_RAYTRACING
void FMeshDrawCommand::SetDrawParametersAndFinalize(
const FMeshBatch& MeshBatch,
int32 BatchElementIndex,
FGraphicsMinimalPipelineStateId PipelineId,
const FMeshProcessorShaders* ShadersForDebugging)
{
const FMeshBatchElement& BatchElement = MeshBatch.Elements[BatchElementIndex];
check(!BatchElement.IndexBuffer || (BatchElement.IndexBuffer && BatchElement.IndexBuffer->IsInitialized() && BatchElement.IndexBuffer->IndexBufferRHI));
IndexBuffer = BatchElement.IndexBuffer ? BatchElement.IndexBuffer->IndexBufferRHI.GetReference() : nullptr;
FirstIndex = BatchElement.FirstIndex;
NumPrimitives = BatchElement.NumPrimitives;
NumInstances = BatchElement.NumInstances;
// If the mesh batch has a valid dynamic index buffer, use it instead
Fix CIS non-unity build issue. #rb charles.derousiers [CL 30817436 by charles derousiers in ue5-main branch]
2024-01-23 16:13:34 -05:00
if (BatchElement.DynamicIndexBuffer.IsValid() && BatchElement.DynamicIndexBuffer.IndexBuffer->IsInitialized())
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
check(!BatchElement.DynamicIndexBuffer.IndexBuffer || (BatchElement.DynamicIndexBuffer.IndexBuffer && BatchElement.DynamicIndexBuffer.IndexBuffer->IsInitialized() && BatchElement.DynamicIndexBuffer.IndexBuffer->IndexBufferRHI));
IndexBuffer = BatchElement.DynamicIndexBuffer.IndexBuffer ? BatchElement.DynamicIndexBuffer.IndexBuffer->IndexBufferRHI.GetReference() : nullptr;
FirstIndex = BatchElement.DynamicIndexBuffer.FirstIndex;
PrimitiveType = EPrimitiveType(BatchElement.DynamicIndexBuffer.PrimitiveType);
}
if (NumPrimitives > 0)
{
VertexParams.BaseVertexIndex = BatchElement.BaseVertexIndex;
VertexParams.NumVertices = BatchElement.MaxVertexIndex - BatchElement.MinVertexIndex + 1;
checkf(!BatchElement.IndirectArgsBuffer, TEXT("FMeshBatchElement::NumPrimitives must be set to 0 when a IndirectArgsBuffer is used"));
}
else
{
checkf(BatchElement.IndirectArgsBuffer, TEXT("It is only valid to set BatchElement.NumPrimitives == 0 when a IndirectArgsBuffer is used"));
IndirectArgs.Buffer = BatchElement.IndirectArgsBuffer;
IndirectArgs.Offset = BatchElement.IndirectArgsOffset;
}
Finalize(PipelineId, ShadersForDebugging);
}
void FMeshDrawShaderBindings::SetOnCommandList(FRHICommandList& RHICmdList, const FBoundShaderStateInput& Shaders, FShaderBindingState* StateCacheShaderBindings) const
{
const uint8* ShaderBindingDataPtr = GetData();
uint32 ShaderFrequencyBitIndex = ~0;
for (int32 ShaderBindingsIndex = 0; ShaderBindingsIndex < ShaderLayouts.Num(); ShaderBindingsIndex++)
{
EShaderFrequency Frequency = SF_NumFrequencies;
while (true)
{
ShaderFrequencyBitIndex++;
if ((ShaderFrequencyBits & (1 << ShaderFrequencyBitIndex)) != 0)
{
Frequency = EShaderFrequency(ShaderFrequencyBitIndex);
break;
}
}
check(Frequency < SF_NumFrequencies);
FReadOnlyMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[ShaderBindingsIndex], ShaderBindingDataPtr);
FShaderBindingState& ShaderBindingState = StateCacheShaderBindings[Frequency];
if (Frequency == SF_Vertex)
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
FRHIBatchedShaderParameters& BatchedParameters = RHICmdList.GetScratchShaderParameters();
SetShaderBindings(BatchedParameters, SingleShaderBindings, ShaderBindingState);
RHICmdList.SetBatchedShaderParameters(Shaders.VertexShaderRHI, BatchedParameters);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
else if (Frequency == SF_Pixel)
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
FRHIBatchedShaderParameters& BatchedParameters = RHICmdList.GetScratchShaderParameters();
SetShaderBindings(BatchedParameters, SingleShaderBindings, ShaderBindingState);
RHICmdList.SetBatchedShaderParameters(Shaders.PixelShaderRHI, BatchedParameters);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
else if (Frequency == SF_Geometry)
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
FRHIBatchedShaderParameters& BatchedParameters = RHICmdList.GetScratchShaderParameters();
SetShaderBindings(BatchedParameters, SingleShaderBindings, ShaderBindingState);
RHICmdList.SetBatchedShaderParameters(Shaders.GetGeometryShader(), BatchedParameters);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
else
{
checkf(0, TEXT("Unknown shader frequency"));
}
ShaderBindingDataPtr += ShaderLayouts[ShaderBindingsIndex].GetDataSizeBytes();
}
}
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
void FMeshDrawShaderBindings::SetParameters(FRHIBatchedShaderParameters& BatchedParameters, FRHIComputeShader* Shader, class FShaderBindingState* StateCacheShaderBindings) const
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
check(ShaderLayouts.Num() == 1);
FReadOnlyMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[0], GetData());
check(ShaderFrequencyBits & (1 << SF_Compute));
if (StateCacheShaderBindings != nullptr)
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetShaderBindings(BatchedParameters, SingleShaderBindings, *StateCacheShaderBindings);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
else
{
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
SetShaderBindings(BatchedParameters, SingleShaderBindings);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
Adding more widespread use of FRHIBatchedShaderParameters - RHI Command lists now have their own "scratch" batched parameters for code setting parameters to use. The parameters are reset when the scratch is returned so it's up to the callers to actually set them on the command list. - Enabling Uniform Buffers in batched shader parameters from shader parameter structs. - Changing MeshPassProcessor to use FRHIBatchedShaderParameters instead of its own type. - Updating BasePassRendering to use FRHIBatchedShaderParameters. #rb zach.bethel #preflight 63dd54a34d25c400b7c040a6 [CL 23996881 by christopher waters in ue5-main branch]
2023-02-03 15:45:12 -05:00
void FMeshDrawShaderBindings::SetOnCommandList(FRHIComputeCommandList& RHICmdList, FRHIComputeShader* Shader, FShaderBindingState* StateCacheShaderBindings) const
{
FRHIBatchedShaderParameters& BatchedParameters = RHICmdList.GetScratchShaderParameters();
SetParameters(BatchedParameters, Shader, StateCacheShaderBindings);
RHICmdList.SetBatchedShaderParameters(Shader, BatchedParameters);
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
bool FMeshDrawShaderBindings::MatchesForDynamicInstancing(const FMeshDrawShaderBindings& Rhs) const
{
if (ShaderFrequencyBits != Rhs.ShaderFrequencyBits)
{
return false;
}
if (ShaderLayouts.Num() != Rhs.ShaderLayouts.Num())
{
return false;
}
for (int Index = 0; Index < ShaderLayouts.Num(); Index++)
{
if (!(ShaderLayouts[Index] == Rhs.ShaderLayouts[Index]))
{
return false;
}
}
const uint8* ShaderBindingDataPtr = GetData();
const uint8* OtherShaderBindingDataPtr = Rhs.GetData();
for (int32 ShaderBindingsIndex = 0; ShaderBindingsIndex < ShaderLayouts.Num(); ShaderBindingsIndex++)
{
FReadOnlyMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[ShaderBindingsIndex], ShaderBindingDataPtr);
FReadOnlyMeshDrawSingleShaderBindings OtherSingleShaderBindings(Rhs.ShaderLayouts[ShaderBindingsIndex], OtherShaderBindingDataPtr);
if (SingleShaderBindings.ParameterMapInfo.LooseParameterBuffers.Num())
{
const uint8* LooseBindings = SingleShaderBindings.GetLooseDataStart();
const uint8* OtherLooseBindings = OtherSingleShaderBindings.GetLooseDataStart();
const uint32 LooseLength = SingleShaderBindings.GetLooseDataSizeBytes();
const uint32 OtherLength = OtherSingleShaderBindings.GetLooseDataSizeBytes();
if (LooseLength != OtherLength)
{
return false;
}
if (memcmp(LooseBindings, OtherLooseBindings, LooseLength) != 0)
{
return false;
}
}
FRHISamplerState* const* SamplerBindings = SingleShaderBindings.GetSamplerStart();
FRHISamplerState* const* OtherSamplerBindings = OtherSingleShaderBindings.GetSamplerStart();
for (int32 SamplerIndex = 0; SamplerIndex < SingleShaderBindings.ParameterMapInfo.TextureSamplers.Num(); SamplerIndex++)
{
const FRHIResource* Sampler = SamplerBindings[SamplerIndex];
const FRHIResource* OtherSampler = OtherSamplerBindings[SamplerIndex];
if (Sampler != OtherSampler)
{
return false;
}
}
FRHIResource* const* SrvBindings = SingleShaderBindings.GetSRVStart();
FRHIResource* const* OtherSrvBindings = OtherSingleShaderBindings.GetSRVStart();
for (int32 SrvIndex = 0; SrvIndex < SingleShaderBindings.ParameterMapInfo.SRVs.Num(); SrvIndex++)
{
const FRHIResource* Srv = SrvBindings[SrvIndex];
const FRHIResource* OtherSrv = OtherSrvBindings[SrvIndex];
if (Srv != OtherSrv)
{
return false;
}
}
FRHIUniformBuffer* const* UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
FRHIUniformBuffer* const* OtherUniformBufferBindings = OtherSingleShaderBindings.GetUniformBufferStart();
for (int32 UniformBufferIndex = 0; UniformBufferIndex < SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num(); UniformBufferIndex++)
{
const FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
const FRHIUniformBuffer* OtherUniformBuffer = OtherUniformBufferBindings[UniformBufferIndex];
if (UniformBuffer != OtherUniformBuffer)
{
return false;
}
}
ShaderBindingDataPtr += ShaderLayouts[ShaderBindingsIndex].GetDataSizeBytes();
OtherShaderBindingDataPtr += Rhs.ShaderLayouts[ShaderBindingsIndex].GetDataSizeBytes();
}
return true;
}
uint32 FMeshDrawShaderBindings::GetDynamicInstancingHash() const
{
//add and initialize any leftover padding within the struct to avoid unstable keys
struct FHashKey
{
uint32 LooseParametersHash = 0;
uint32 UniformBufferHash = 0;
uint16 Size;
uint16 Frequencies;
static inline uint32 PointerHash(const void* Key)
{
#if PLATFORM_64BITS
// Ignoring the lower 4 bits since they are likely zero anyway.
// Higher bits are more significant in 64 bit builds.
return reinterpret_cast<UPTRINT>(Key) >> 4;
#else
return reinterpret_cast<UPTRINT>(Key);
#endif
};
static inline uint32 HashCombine(uint32 A, uint32 B)
{
return A ^ (B + 0x9e3779b9 + (A << 6) + (A >> 2));
}
} HashKey;
HashKey.Size = Size;
HashKey.Frequencies = ShaderFrequencyBits;
const uint8* ShaderBindingDataPtr = GetData();
for (int32 ShaderBindingsIndex = 0; ShaderBindingsIndex < ShaderLayouts.Num(); ShaderBindingsIndex++)
{
FReadOnlyMeshDrawSingleShaderBindings SingleShaderBindings(ShaderLayouts[ShaderBindingsIndex], ShaderBindingDataPtr);
if (SingleShaderBindings.ParameterMapInfo.LooseParameterBuffers.Num())
{
const uint8* LooseBindings = SingleShaderBindings.GetLooseDataStart();
uint32 Length = SingleShaderBindings.GetLooseDataSizeBytes();
HashKey.LooseParametersHash = uint32(CityHash64((const char*)LooseBindings, Length));
}
FRHISamplerState* const* SamplerBindings = SingleShaderBindings.GetSamplerStart();
for (int32 SamplerIndex = 0; SamplerIndex < SingleShaderBindings.ParameterMapInfo.TextureSamplers.Num(); SamplerIndex++)
{
const FRHIResource* Sampler = SamplerBindings[SamplerIndex];
HashKey.LooseParametersHash = FHashKey::HashCombine(FHashKey::PointerHash(Sampler), HashKey.LooseParametersHash);
}
FRHIResource* const* SrvBindings = SingleShaderBindings.GetSRVStart();
for (int32 SrvIndex = 0; SrvIndex < SingleShaderBindings.ParameterMapInfo.SRVs.Num(); SrvIndex++)
{
const FRHIResource* Srv = SrvBindings[SrvIndex];
HashKey.LooseParametersHash = FHashKey::HashCombine(FHashKey::PointerHash(Srv), HashKey.LooseParametersHash);
}
FRHIUniformBuffer* const* UniformBufferBindings = SingleShaderBindings.GetUniformBufferStart();
for (int32 UniformBufferIndex = 0; UniformBufferIndex < SingleShaderBindings.ParameterMapInfo.UniformBuffers.Num(); UniformBufferIndex++)
{
const FRHIUniformBuffer* UniformBuffer = UniformBufferBindings[UniformBufferIndex];
HashKey.UniformBufferHash = FHashKey::HashCombine(FHashKey::PointerHash(UniformBuffer), HashKey.UniformBufferHash);
}
ShaderBindingDataPtr += ShaderLayouts[ShaderBindingsIndex].GetDataSizeBytes();
}
return uint32(CityHash64((char*)&HashKey, sizeof(FHashKey)));
}
Improve PSO stats collection further: * Add a CVar to control whether minimal PSOs are checked at all. * Cache PSO precache result on the MeshPipelineState so that it's not re-checked unless necessary. According to my tests this saves a lot of time. * Enable the `PSO_PRECACHING_VALIDATE` #define in Shipping. Validation is still turned off by default at runtime through the CVar. I've run A/B tests on my local machine with validation turned on and off in Lightweight mode (r.PSOPrecache.Validation = 1) and noticed no performance regressions. #pf 647e0d4709776a4f921f204d [CL 25845819 by daniele vettorel in ue5-main branch]
2023-06-07 11:04:19 -04:00
static EPSOPrecacheResult RetrieveAndCachePSOPrecacheResult(
const FGraphicsMinimalPipelineStateInitializer& MeshPipelineState,
const FGraphicsPipelineStateInitializer& GraphicsPSOInit,
bool bAllowSkipDrawCommand)
{
if (!PipelineStateCache::IsPSOPrecachingEnabled())
{
return EPSOPrecacheResult::Unknown;
}
EPSOPrecacheResult PSOPrecacheResult = MeshPipelineState.PSOPrecacheState;
bool bShouldCheckPrecacheResult = false;
// If PSO precache validation is on, we need to check the state for stats tracking purposes.
#if PSO_PRECACHING_VALIDATE
if (PSOCollectorStats::IsPrecachingValidationEnabled() && PSOPrecacheResult == EPSOPrecacheResult::Unknown)
{
bShouldCheckPrecacheResult = true;
}
#endif
// If we are skipping draws when the PSO is being precached but is not ready, we
// need to keep checking the state until it's not marked active anymore.
if (bAllowSkipDrawCommand && GSkipDrawOnPSOPrecaching)
{
if (PSOPrecacheResult == EPSOPrecacheResult::Unknown ||
PSOPrecacheResult == EPSOPrecacheResult::Active)
{
bShouldCheckPrecacheResult = true;
}
}
if (bShouldCheckPrecacheResult)
{
// Cache the state so that it's only checked again if necessary.
PSOPrecacheResult = PipelineStateCache::CheckPipelineStateInCache(GraphicsPSOInit);
MeshPipelineState.PSOPrecacheState = PSOPrecacheResult;
}
return PSOPrecacheResult;
}
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
bool FMeshDrawCommand::SubmitDrawBegin(
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FMeshDrawCommand& RESTRICT MeshDrawCommand,
const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const FMeshDrawCommandSceneArgs& SceneArgs,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 InstanceFactor,
FRHICommandList& RHICmdList,
- Add option to skip indirect draws when PSOs are still precaching - Precache Nanite programmable raster PSOs #rb Rune.Stubbe, Graham.Wihlidal, Mihnea.Balta [CL 23075419 by kenzo terelst in ue5-main branch]
2022-11-10 06:33:14 -05:00
FMeshDrawCommandStateCache& RESTRICT StateCache,
bool bAllowSkipDrawCommand)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
checkSlow(MeshDrawCommand.CachedPipelineId.IsValid());
// GPUCULL_TODO: Can't do this check as the VFs are created with GMaxRHIFeatureLevel (so may support PrimitiveIdStreamIndex even for preview platforms)
// Want to be sure that we supply GPU-scene instance data if required.
// checkSlow(MeshDrawCommand.PrimitiveIdStreamIndex == -1 || ScenePrimitiveIdsBuffer != nullptr);
const FGraphicsMinimalPipelineStateInitializer& MeshPipelineState = MeshDrawCommand.CachedPipelineId.GetPipelineState(GraphicsMinimalPipelineStateSet);
if (MeshDrawCommand.CachedPipelineId.GetId() != StateCache.PipelineId)
{
FGraphicsPipelineStateInitializer GraphicsPSOInit = MeshPipelineState.AsGraphicsPipelineStateInitializer();
RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
Improve PSO stats collection further: * Add a CVar to control whether minimal PSOs are checked at all. * Cache PSO precache result on the MeshPipelineState so that it's not re-checked unless necessary. According to my tests this saves a lot of time. * Enable the `PSO_PRECACHING_VALIDATE` #define in Shipping. Validation is still turned off by default at runtime through the CVar. I've run A/B tests on my local machine with validation turned on and off in Lightweight mode (r.PSOPrecache.Validation = 1) and noticed no performance regressions. #pf 647e0d4709776a4f921f204d [CL 25845819 by daniele vettorel in ue5-main branch]
2023-06-07 11:04:19 -04:00
EPSOPrecacheResult PSOPrecacheResult = RetrieveAndCachePSOPrecacheResult(MeshPipelineState, GraphicsPSOInit, bAllowSkipDrawCommand);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
#if PSO_PRECACHING_VALIDATE
#if MESH_DRAW_COMMAND_DEBUG_DATA
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
PSOCollectorStats::CheckFullPipelineStateInCache(GraphicsPSOInit, PSOPrecacheResult, MeshDrawCommand.DebugData.MaterialRenderProxy,
MeshDrawCommand.DebugData.VertexFactoryType, MeshDrawCommand.DebugData.PrimitiveSceneProxyIfNotUsingStateBuckets, MeshDrawCommand.DebugData.PSOCollectorIndex);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
#else
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
PSOCollectorStats::CheckFullPipelineStateInCache(GraphicsPSOInit, PSOPrecacheResult, nullptr, nullptr, nullptr, INDEX_NONE);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
#endif // MESH_DRAW_COMMAND_DEBUG_DATA
#endif // PSO_PRECACHING_VALIDATE
Improve PSO stats collection further: * Add a CVar to control whether minimal PSOs are checked at all. * Cache PSO precache result on the MeshPipelineState so that it's not re-checked unless necessary. According to my tests this saves a lot of time. * Enable the `PSO_PRECACHING_VALIDATE` #define in Shipping. Validation is still turned off by default at runtime through the CVar. I've run A/B tests on my local machine with validation turned on and off in Lightweight mode (r.PSOPrecache.Validation = 1) and noticed no performance regressions. #pf 647e0d4709776a4f921f204d [CL 25845819 by daniele vettorel in ue5-main branch]
2023-06-07 11:04:19 -04:00
// Try and skip draw if the PSO is not precached yet.
if (bAllowSkipDrawCommand && GSkipDrawOnPSOPrecaching && PSOPrecacheResult == EPSOPrecacheResult::Active)
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
{
Improve PSO stats collection further: * Add a CVar to control whether minimal PSOs are checked at all. * Cache PSO precache result on the MeshPipelineState so that it's not re-checked unless necessary. According to my tests this saves a lot of time. * Enable the `PSO_PRECACHING_VALIDATE` #define in Shipping. Validation is still turned off by default at runtime through the CVar. I've run A/B tests on my local machine with validation turned on and off in Lightweight mode (r.PSOPrecache.Validation = 1) and noticed no performance regressions. #pf 647e0d4709776a4f921f204d [CL 25845819 by daniele vettorel in ue5-main branch]
2023-06-07 11:04:19 -04:00
return false;
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
// We can set the new StencilRef here to avoid the set below
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
bool bApplyAdditionalState = true;
SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit, MeshDrawCommand.StencilRef, EApplyRendertargetOption::CheckApply, bApplyAdditionalState, PSOPrecacheResult);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
StateCache.SetPipelineState(MeshDrawCommand.CachedPipelineId.GetId());
StateCache.StencilRef = MeshDrawCommand.StencilRef;
}
if (MeshDrawCommand.StencilRef != StateCache.StencilRef)
{
RHICmdList.SetStencilRef(MeshDrawCommand.StencilRef);
StateCache.StencilRef = MeshDrawCommand.StencilRef;
}
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
// Platforms that use global UB binding don't need to set PrimitiveIdStream
const int8 PrimitiveIdStreamIndex = (IsUniformBufferStaticSlotValid(SceneArgs.BatchedPrimitiveSlot) ? -1 : MeshDrawCommand.PrimitiveIdStreamIndex);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
for (int32 VertexBindingIndex = 0; VertexBindingIndex < MeshDrawCommand.VertexStreams.Num(); VertexBindingIndex++)
{
const FVertexInputStream& Stream = MeshDrawCommand.VertexStreams[VertexBindingIndex];
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
if (PrimitiveIdStreamIndex != -1 && Stream.StreamIndex == PrimitiveIdStreamIndex)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
RHICmdList.SetStreamSource(Stream.StreamIndex, SceneArgs.PrimitiveIdsBuffer, SceneArgs.PrimitiveIdOffset);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
StateCache.VertexStreams[Stream.StreamIndex] = Stream;
}
else if (StateCache.VertexStreams[Stream.StreamIndex] != Stream)
{
RHICmdList.SetStreamSource(Stream.StreamIndex, Stream.VertexBuffer, Stream.Offset);
StateCache.VertexStreams[Stream.StreamIndex] = Stream;
}
}
MeshDrawCommand.ShaderBindings.SetOnCommandList(RHICmdList, MeshPipelineState.BoundShaderState.AsBoundShaderState(), StateCache.ShaderBindings);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
return true;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
void FMeshDrawCommand::SubmitDrawEnd(const FMeshDrawCommand& MeshDrawCommand, const FMeshDrawCommandSceneArgs& SceneArgs, uint32 InstanceFactor, FRHICommandList& RHICmdList)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const bool bDoOverrideArgs = SceneArgs.IndirectArgsBuffer != nullptr && MeshDrawCommand.PrimitiveIdStreamIndex >= 0;
if (IsUniformBufferStaticSlotValid(SceneArgs.BatchedPrimitiveSlot))
{
RHICmdList.SetUniformBufferDynamicOffset(SceneArgs.BatchedPrimitiveSlot, SceneArgs.PrimitiveIdOffset);
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
if (MeshDrawCommand.IndexBuffer)
{
if (MeshDrawCommand.NumPrimitives > 0 && !bDoOverrideArgs)
{
RHICmdList.DrawIndexedPrimitive(
MeshDrawCommand.IndexBuffer,
MeshDrawCommand.VertexParams.BaseVertexIndex,
0,
MeshDrawCommand.VertexParams.NumVertices,
MeshDrawCommand.FirstIndex,
MeshDrawCommand.NumPrimitives,
MeshDrawCommand.NumInstances * InstanceFactor
);
}
else
{
RHICmdList.DrawIndexedPrimitiveIndirect(
MeshDrawCommand.IndexBuffer,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
bDoOverrideArgs ? SceneArgs.IndirectArgsBuffer : MeshDrawCommand.IndirectArgs.Buffer,
bDoOverrideArgs ? SceneArgs.IndirectArgsByteOffset : MeshDrawCommand.IndirectArgs.Offset
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
);
}
}
else
{
if (MeshDrawCommand.NumPrimitives > 0 && !bDoOverrideArgs)
{
RHICmdList.DrawPrimitive(
MeshDrawCommand.VertexParams.BaseVertexIndex + MeshDrawCommand.FirstIndex,
MeshDrawCommand.NumPrimitives,
MeshDrawCommand.NumInstances * InstanceFactor);
}
else
{
RHICmdList.DrawPrimitiveIndirect(
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
bDoOverrideArgs ? SceneArgs.IndirectArgsBuffer : MeshDrawCommand.IndirectArgs.Buffer,
bDoOverrideArgs ? SceneArgs.IndirectArgsByteOffset : MeshDrawCommand.IndirectArgs.Offset
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
);
}
}
}
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
bool FMeshDrawCommand::SubmitDrawIndirectBegin(
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
const FMeshDrawCommand& RESTRICT MeshDrawCommand,
const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const FMeshDrawCommandSceneArgs& SceneArgs,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 InstanceFactor,
FRHICommandList& RHICmdList,
- Add option to skip indirect draws when PSOs are still precaching - Precache Nanite programmable raster PSOs #rb Rune.Stubbe, Graham.Wihlidal, Mihnea.Balta [CL 23075419 by kenzo terelst in ue5-main branch]
2022-11-10 06:33:14 -05:00
FMeshDrawCommandStateCache& RESTRICT StateCache,
bool bAllowSkipDrawCommand)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
return SubmitDrawBegin(
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
MeshDrawCommand,
GraphicsMinimalPipelineStateSet,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
SceneArgs,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
InstanceFactor,
RHICmdList,
- Add option to skip indirect draws when PSOs are still precaching - Precache Nanite programmable raster PSOs #rb Rune.Stubbe, Graham.Wihlidal, Mihnea.Balta [CL 23075419 by kenzo terelst in ue5-main branch]
2022-11-10 06:33:14 -05:00
StateCache,
bAllowSkipDrawCommand
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
);
}
void FMeshDrawCommand::SubmitDrawIndirectEnd(
const FMeshDrawCommand& MeshDrawCommand,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const FMeshDrawCommandSceneArgs& SceneArgs,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 InstanceFactor,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
FRHICommandList& RHICmdList)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
FRHIBuffer* IndirectArgsBuffer = nullptr;
uint32 IndirectArgsOffset = 0;
if (MeshDrawCommand.NumPrimitives == 0)
{
IndirectArgsBuffer = MeshDrawCommand.IndirectArgs.Buffer;
IndirectArgsOffset = MeshDrawCommand.IndirectArgs.Offset;
}
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
if (SceneArgs.IndirectArgsBuffer != nullptr)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
IndirectArgsBuffer = SceneArgs.IndirectArgsBuffer;
IndirectArgsOffset = SceneArgs.IndirectArgsByteOffset;
}
if (IsUniformBufferStaticSlotValid(SceneArgs.BatchedPrimitiveSlot))
{
RHICmdList.SetUniformBufferDynamicOffset(SceneArgs.BatchedPrimitiveSlot, SceneArgs.PrimitiveIdOffset);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
if (IndirectArgsBuffer != nullptr)
{
if (MeshDrawCommand.IndexBuffer)
{
RHICmdList.DrawIndexedPrimitiveIndirect(
MeshDrawCommand.IndexBuffer,
IndirectArgsBuffer,
IndirectArgsOffset
);
}
else
{
RHICmdList.DrawPrimitiveIndirect(
IndirectArgsBuffer,
IndirectArgsOffset
);
}
}
else if (MeshDrawCommand.NumPrimitives > 0)
{
if (MeshDrawCommand.IndexBuffer)
{
RHICmdList.DrawIndexedPrimitive(
MeshDrawCommand.IndexBuffer,
MeshDrawCommand.VertexParams.BaseVertexIndex,
0,
MeshDrawCommand.VertexParams.NumVertices,
MeshDrawCommand.FirstIndex,
MeshDrawCommand.NumPrimitives,
MeshDrawCommand.NumInstances * InstanceFactor
);
}
else
{
RHICmdList.DrawPrimitive(
MeshDrawCommand.VertexParams.BaseVertexIndex + MeshDrawCommand.FirstIndex,
MeshDrawCommand.NumPrimitives,
MeshDrawCommand.NumInstances * InstanceFactor
);
}
}
}
void FMeshDrawCommand::SubmitDraw(
const FMeshDrawCommand& RESTRICT MeshDrawCommand,
const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const FMeshDrawCommandSceneArgs& SceneArgs,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 InstanceFactor,
FRHICommandList& RHICmdList,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
FMeshDrawCommandStateCache& RESTRICT StateCache)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
#if WANTS_DRAW_MESH_EVENTS
FMeshDrawEvent MeshEvent(MeshDrawCommand, InstanceFactor, RHICmdList);
#endif
- Add option to skip indirect draws when PSOs are still precaching - Precache Nanite programmable raster PSOs #rb Rune.Stubbe, Graham.Wihlidal, Mihnea.Balta [CL 23075419 by kenzo terelst in ue5-main branch]
2022-11-10 06:33:14 -05:00
bool bAllowSkipDrawCommand = true;
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
if (SubmitDrawBegin(MeshDrawCommand, GraphicsMinimalPipelineStateSet, SceneArgs, InstanceFactor, RHICmdList, StateCache, bAllowSkipDrawCommand))
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
{
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
SubmitDrawEnd(MeshDrawCommand, SceneArgs, InstanceFactor, RHICmdList);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
void ApplyTargetsInfo(FGraphicsPipelineStateInitializer& GraphicsPSOInit, const FGraphicsPipelineRenderTargetsInfo& RenderTargetsInfo)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
GraphicsPSOInit.RenderTargetsEnabled = RenderTargetsInfo.RenderTargetsEnabled;
GraphicsPSOInit.RenderTargetFormats = RenderTargetsInfo.RenderTargetFormats;
GraphicsPSOInit.RenderTargetFlags = RenderTargetsInfo.RenderTargetFlags;
GraphicsPSOInit.NumSamples = RenderTargetsInfo.NumSamples;
GraphicsPSOInit.DepthStencilTargetFormat = RenderTargetsInfo.DepthStencilTargetFormat;
GraphicsPSOInit.DepthStencilTargetFlag = RenderTargetsInfo.DepthStencilTargetFlag;
GraphicsPSOInit.DepthTargetLoadAction = RenderTargetsInfo.DepthTargetLoadAction;
GraphicsPSOInit.DepthTargetStoreAction = RenderTargetsInfo.DepthTargetStoreAction;
GraphicsPSOInit.StencilTargetLoadAction = RenderTargetsInfo.StencilTargetLoadAction;
GraphicsPSOInit.StencilTargetStoreAction = RenderTargetsInfo.StencilTargetStoreAction;
GraphicsPSOInit.DepthStencilAccess = RenderTargetsInfo.DepthStencilAccess;
GraphicsPSOInit.MultiViewCount = RenderTargetsInfo.MultiViewCount;
GraphicsPSOInit.bHasFragmentDensityAttachment = RenderTargetsInfo.bHasFragmentDensityAttachment;
}
uint64 FMeshDrawCommand::GetPipelineStateSortingKey(FRHICommandList& RHICmdList, const FGraphicsPipelineRenderTargetsInfo& RenderTargetsInfo) const
{
// Default fallback sort key
uint64 SortKey = CachedPipelineId.GetId();
if (GRHISupportsPipelineStateSortKey)
{
Refactored Nanite material GBuffer passes to run off the render thread. #preflight 62a2129f081ed277df5aa9ed #rb yuriy.odonnell, krzysztof.narkowicz, kenzo.terelst [CL 20579258 by zach bethel in ue5-main branch]
2022-06-09 12:40:44 -04:00
FGraphicsMinimalPipelineStateSet PipelineStateSet;
FGraphicsPipelineStateInitializer GraphicsPSOInit = CachedPipelineId.GetPipelineState(PipelineStateSet).AsGraphicsPipelineStateInitializer();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
ApplyTargetsInfo(GraphicsPSOInit, RenderTargetsInfo);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
// PSO is retrieved here already. This is currently only used by Nanite::DrawLumenMeshCards - can this also used the version without command list?
const FGraphicsPipelineState* PipelineState = PipelineStateCache::GetAndOrCreateGraphicsPipelineState(RHICmdList, GraphicsPSOInit, EApplyRendertargetOption::DoNothing, EPSOPrecacheResult::Unknown);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
if (PipelineState)
{
const uint64 StateSortKey = PipelineStateCache::RetrieveGraphicsPipelineStateSortKey(PipelineState);
if (StateSortKey != 0) // 0 on the first occurrence (prior to caching), so these commands will fall back on shader id for sorting.
{
SortKey = StateSortKey;
}
}
}
return SortKey;
}
Refactored Nanite material GBuffer passes to run off the render thread. #preflight 62a2129f081ed277df5aa9ed #rb yuriy.odonnell, krzysztof.narkowicz, kenzo.terelst [CL 20579258 by zach bethel in ue5-main branch]
2022-06-09 12:40:44 -04:00
uint64 FMeshDrawCommand::GetPipelineStateSortingKey(const FGraphicsPipelineRenderTargetsInfo& RenderTargetsInfo) const
{
// Default fallback sort key
uint64 SortKey = CachedPipelineId.GetId();
if (GRHISupportsPipelineStateSortKey)
{
FGraphicsMinimalPipelineStateSet PipelineStateSet;
FGraphicsPipelineStateInitializer GraphicsPSOInit = CachedPipelineId.GetPipelineState(PipelineStateSet).AsGraphicsPipelineStateInitializer();
ApplyTargetsInfo(GraphicsPSOInit, RenderTargetsInfo);
Hooked up Nanite CS materials to CPU visibility culling results, and also significantly optimized CS material PSO retrieval. #rb jamie.hayes [FYI] brian.karis, rune.stubbe, zach.bethel, luke.thatcher, ben.woodhouse #jira UE-187341 [CL 28266584 by graham wihlidal in ue5-main branch]
2023-09-27 04:27:13 -04:00
const FGraphicsPipelineState* PipelineState = PipelineStateCache::FindGraphicsPipelineState(GraphicsPSOInit, false /* bVerifyUse */);
Refactored Nanite material GBuffer passes to run off the render thread. #preflight 62a2129f081ed277df5aa9ed #rb yuriy.odonnell, krzysztof.narkowicz, kenzo.terelst [CL 20579258 by zach bethel in ue5-main branch]
2022-06-09 12:40:44 -04:00
if (PipelineState)
{
const uint64 StateSortKey = PipelineStateCache::RetrieveGraphicsPipelineStateSortKey(PipelineState);
if (StateSortKey != 0) // 0 on the first occurrence (prior to caching), so these commands will fall back on shader id for sorting.
{
SortKey = StateSortKey;
}
}
}
return SortKey;
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
#if MESH_DRAW_COMMAND_DEBUG_DATA
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
void FMeshDrawCommand::SetDebugData(const FPrimitiveSceneProxy* PrimitiveSceneProxy, const FMaterial* Material, const FMaterialRenderProxy* MaterialRenderProxy, const FMeshProcessorShaders& UntypedShaders, const FVertexFactory* VertexFactory, const FMeshBatch& MeshBatch, int32 PSOCollectorIndex)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
DebugData.PrimitiveSceneProxyIfNotUsingStateBuckets = PrimitiveSceneProxy;
DebugData.MaterialRenderProxy = MaterialRenderProxy;
DebugData.VertexShader = UntypedShaders.VertexShader;
DebugData.PixelShader = UntypedShaders.PixelShader;
DebugData.VertexFactory = VertexFactory;
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
DebugData.VertexFactoryType = VertexFactory->GetType();
Mesh draw command stat categories now default to component class name unless explicitly set. Budget categories can now capture groups of stat categories. The MDC stat system is now development build only. Added r.MeshDrawCommands.Stat 2 which displays visibile triangles per draw pass. [CL 26834228 by jeremy moore in ue5-main branch]
2023-08-03 20:04:19 -04:00
DebugData.LODIndex = MeshBatch.LODIndex;
DebugData.SegmentIndex = MeshBatch.SegmentIndex;
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
DebugData.PSOCollectorIndex = PSOCollectorIndex;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
DebugData.ResourceName = PrimitiveSceneProxy ? PrimitiveSceneProxy->GetResourceName() : FName();
Fix for Material Instances resolving their parent material's name in debug data and GPU captures, instead of the instance name. Altered the default MID naming convention to be clearer and easier to follow from debug data/captures from e.g. MaterialInstanceDynamic450 to MID_ParentMaterialName_450. #rb Massimo.Tristano [CL 26237763 by jon cain in ue5-main branch]
2023-06-26 13:20:37 -04:00
DebugData.MaterialName = MaterialRenderProxy->GetMaterialName();
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
#endif
Mesh draw command stat categories now default to component class name unless explicitly set. Budget categories can now capture groups of stat categories. The MDC stat system is now development build only. Added r.MeshDrawCommands.Stat 2 which displays visibile triangles per draw pass. [CL 26834228 by jeremy moore in ue5-main branch]
2023-08-03 20:04:19 -04:00
#if MESH_DRAW_COMMAND_STATS
void FMeshDrawCommand::SetStatsData(const FPrimitiveSceneProxy* PrimitiveSceneProxy)
Add mesh draw command stats collection. This collects information about each draw call in each pass used during MDC rendering. It reads back indirect args if they are used to get the correct final rendered instance and primitive counts. Use SetMeshDrawCommandStatsCategory() on primitive components to set category types. Use "r.MeshDrawCommands.Stats 1" to show per category stats on screen. Use "stat culling" to show global stats using the standard stats system. Use "DumpMeshDrawCommandFrameStats" in developmet builds to dump detailed draw info of a frame to a csv file on disc. [FYI] kenzo.terelst [CL 26721817 by jeremy moore in ue5-main branch]
2023-07-31 17:25:08 -04:00
{
Mesh draw command stat categories now default to component class name unless explicitly set. Budget categories can now capture groups of stat categories. The MDC stat system is now development build only. Added r.MeshDrawCommands.Stat 2 which displays visibile triangles per draw pass. [CL 26834228 by jeremy moore in ue5-main branch]
2023-08-03 20:04:19 -04:00
StatsData.CategoryName = PrimitiveSceneProxy ? PrimitiveSceneProxy->GetMeshDrawCommandStatsCategory() : FName();
Add mesh draw command stats collection. This collects information about each draw call in each pass used during MDC rendering. It reads back indirect args if they are used to get the correct final rendered instance and primitive counts. Use SetMeshDrawCommandStatsCategory() on primitive components to set category types. Use "r.MeshDrawCommands.Stats 1" to show per category stats on screen. Use "stat culling" to show global stats using the standard stats system. Use "DumpMeshDrawCommandFrameStats" in developmet builds to dump detailed draw info of a frame to a csv file on disc. [FYI] kenzo.terelst [CL 26721817 by jeremy moore in ue5-main branch]
2023-07-31 17:25:08 -04:00
}
void FMeshDrawCommand::GetStatsData(FVisibleMeshDrawCommandStatsData& OutVisibleStatsData) const
{
OutVisibleStatsData.StatsData = StatsData;
OutVisibleStatsData.PrimitiveCount = NumPrimitives;
#if MESH_DRAW_COMMAND_DEBUG_DATA
Mesh draw command stat categories now default to component class name unless explicitly set. Budget categories can now capture groups of stat categories. The MDC stat system is now development build only. Added r.MeshDrawCommands.Stat 2 which displays visibile triangles per draw pass. [CL 26834228 by jeremy moore in ue5-main branch]
2023-08-03 20:04:19 -04:00
OutVisibleStatsData.LODIndex = DebugData.LODIndex;
OutVisibleStatsData.SegmentIndex = DebugData.SegmentIndex;
Add mesh draw command stats collection. This collects information about each draw call in each pass used during MDC rendering. It reads back indirect args if they are used to get the correct final rendered instance and primitive counts. Use SetMeshDrawCommandStatsCategory() on primitive components to set category types. Use "r.MeshDrawCommands.Stats 1" to show per category stats on screen. Use "stat culling" to show global stats using the standard stats system. Use "DumpMeshDrawCommandFrameStats" in developmet builds to dump detailed draw info of a frame to a csv file on disc. [FYI] kenzo.terelst [CL 26721817 by jeremy moore in ue5-main branch]
2023-07-31 17:25:08 -04:00
OutVisibleStatsData.ResourceName = DebugData.ResourceName;
OutVisibleStatsData.MaterialName = DebugData.MaterialName;
#endif
}
Mesh draw command stat categories now default to component class name unless explicitly set. Budget categories can now capture groups of stat categories. The MDC stat system is now development build only. Added r.MeshDrawCommands.Stat 2 which displays visibile triangles per draw pass. [CL 26834228 by jeremy moore in ue5-main branch]
2023-08-03 20:04:19 -04:00
#endif // MESH_DRAW_COMMAND_STATS
Add mesh draw command stats collection. This collects information about each draw call in each pass used during MDC rendering. It reads back indirect args if they are used to get the correct final rendered instance and primitive counts. Use SetMeshDrawCommandStatsCategory() on primitive components to set category types. Use "r.MeshDrawCommands.Stats 1" to show per category stats on screen. Use "stat culling" to show global stats using the standard stats system. Use "DumpMeshDrawCommandFrameStats" in developmet builds to dump detailed draw info of a frame to a csv file on disc. [FYI] kenzo.terelst [CL 26721817 by jeremy moore in ue5-main branch]
2023-07-31 17:25:08 -04:00
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
void SubmitMeshDrawCommands(
const FMeshCommandOneFrameArray& VisibleMeshDrawCommands,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
const FMeshDrawCommandSceneArgs& SceneArgs,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 PrimitiveIdBufferStride,
bool bDynamicInstancing,
uint32 InstanceFactor,
FRHICommandList& RHICmdList)
{
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
SubmitMeshDrawCommandsRange(VisibleMeshDrawCommands, GraphicsMinimalPipelineStateSet, SceneArgs, PrimitiveIdBufferStride, bDynamicInstancing, 0, VisibleMeshDrawCommands.Num(), InstanceFactor, RHICmdList);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
void SubmitMeshDrawCommandsRange(
const FMeshCommandOneFrameArray& VisibleMeshDrawCommands,
const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const FMeshDrawCommandSceneArgs& InSceneArgs,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
uint32 PrimitiveIdBufferStride,
bool bDynamicInstancing,
int32 StartIndex,
int32 NumMeshDrawCommands,
uint32 InstanceFactor,
FRHICommandList& RHICmdList)
{
// GPUCULL_TODO: workaround for the fact that DrawDynamicMeshPassPrivate et al. don't work with GPU-Scene instancing
// we don't support dynamic instancing for this path since we require one primitive per draw command
// This is because the stride on the instance data buffer is set to 0 so only the first will ever be fetched.
checkSlow(!bDynamicInstancing);
Fix warning V763: Parameter is always rewritten in function body before being used. #rnx [CL 29411736 by marc audy in ue5-main branch]
2023-11-03 13:24:06 -04:00
bDynamicInstancing = false; //-V763
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FMeshDrawCommandStateCache StateCache;
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
FMeshDrawCommandSceneArgs LocalSceneArgs = InSceneArgs;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
INC_DWORD_STAT_BY(STAT_MeshDrawCalls, NumMeshDrawCommands);
for (int32 DrawCommandIndex = StartIndex; DrawCommandIndex < StartIndex + NumMeshDrawCommands; DrawCommandIndex++)
{
SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, MeshEvent, GEmitMeshDrawEvent != 0, TEXT("Mesh Draw"));
const FVisibleMeshDrawCommand& VisibleMeshDrawCommand = VisibleMeshDrawCommands[DrawCommandIndex];
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
LocalSceneArgs.PrimitiveIdOffset = InSceneArgs.PrimitiveIdOffset + (bDynamicInstancing ? VisibleMeshDrawCommand.PrimitiveIdBufferOffset : DrawCommandIndex) * PrimitiveIdBufferStride;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
checkSlow(!bDynamicInstancing || VisibleMeshDrawCommand.PrimitiveIdBufferOffset >= 0);
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
FMeshDrawCommand::SubmitDraw(*VisibleMeshDrawCommand.MeshDrawCommand, GraphicsMinimalPipelineStateSet, LocalSceneArgs, InstanceFactor, RHICmdList, StateCache);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
void ApplyViewOverridesToMeshDrawCommands(const FSceneView& View, FMeshCommandOneFrameArray& VisibleMeshDrawCommands, FDynamicMeshDrawCommandStorage& DynamicMeshDrawCommandStorage, FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet, bool& InNeedsShaderInitialisation)
{
if (View.bReverseCulling || View.bRenderSceneTwoSided)
{
const FMeshCommandOneFrameArray& PassVisibleMeshDrawCommands = VisibleMeshDrawCommands;
FMeshCommandOneFrameArray ViewOverriddenMeshCommands;
ViewOverriddenMeshCommands.Empty(PassVisibleMeshDrawCommands.Num());
for (int32 MeshCommandIndex = 0; MeshCommandIndex < PassVisibleMeshDrawCommands.Num(); MeshCommandIndex++)
{
DynamicMeshDrawCommandStorage.MeshDrawCommands.Add(1);
FMeshDrawCommand& NewMeshCommand = DynamicMeshDrawCommandStorage.MeshDrawCommands[DynamicMeshDrawCommandStorage.MeshDrawCommands.Num() - 1];
const FVisibleMeshDrawCommand& VisibleMeshDrawCommand = PassVisibleMeshDrawCommands[MeshCommandIndex];
const FMeshDrawCommand& MeshCommand = *VisibleMeshDrawCommand.MeshDrawCommand;
NewMeshCommand = MeshCommand;
const ERasterizerCullMode LocalCullMode = View.bRenderSceneTwoSided ? CM_None : View.bReverseCulling ? FMeshPassProcessor::InverseCullMode(VisibleMeshDrawCommand.MeshCullMode) : VisibleMeshDrawCommand.MeshCullMode;
FGraphicsMinimalPipelineStateInitializer PipelineState = MeshCommand.CachedPipelineId.GetPipelineState(GraphicsMinimalPipelineStateSet);
PipelineState.RasterizerState = GetStaticRasterizerState<true>(VisibleMeshDrawCommand.MeshFillMode, LocalCullMode);
const FGraphicsMinimalPipelineStateId PipelineId = FGraphicsMinimalPipelineStateId::GetPipelineStateId(PipelineState, GraphicsMinimalPipelineStateSet, InNeedsShaderInitialisation);
NewMeshCommand.Finalize(PipelineId, nullptr);
FVisibleMeshDrawCommand NewVisibleMeshDrawCommand;
NewVisibleMeshDrawCommand.Setup(
&NewMeshCommand,
VisibleMeshDrawCommand.PrimitiveIdInfo,
VisibleMeshDrawCommand.StateBucketId,
VisibleMeshDrawCommand.MeshFillMode,
VisibleMeshDrawCommand.MeshCullMode,
VisibleMeshDrawCommand.Flags,
VisibleMeshDrawCommand.SortKey,
Add support for LOD selection of ISM instances using the GPU instance culling system. For each ISM primitive we determine minimum and maximum LOD and submit a mesh draw command for each. Then GPU culling uses the min and max screen size for each LOD draw command to cull instances against each LOD. This naively multiplies the number of instances that get pushed through instance culling. Though in reality, except on weaker platforms, instance culling is fast enough that it doesn't really matter. ISMs use the current CPU "one LOD for all instances" approach by default. The new approach is used if GPUScene is enabled and instance culling is enabled and bUseGpuLodSelection is true on the component. Also r.InstancedStaticMeshes.GpuLod can be used to turn the system on and off. #rb ola.olsson [CL 26130126 by jeremy moore in ue5-main branch]
2023-06-20 14:47:40 -04:00
VisibleMeshDrawCommand.CullingPayload,
VisibleMeshDrawCommand.CullingPayloadFlags,
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
VisibleMeshDrawCommand.RunArray,
VisibleMeshDrawCommand.NumRuns);
ViewOverriddenMeshCommands.Add(NewVisibleMeshDrawCommand);
}
// Replace VisibleMeshDrawCommands
Fixed calls to FMemory::Memswap with compile-time sizes. #rb robert.manuszewski #jira none #preflight 646f38bd1417daba1e57bd2a [CL 25619819 by Steve Robb in ue5-main branch]
2023-05-25 09:07:23 -04:00
Swap(VisibleMeshDrawCommands, ViewOverriddenMeshCommands);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
Merging CL#29037036 Make 'UniformView' GPUScene path work with DynamicMeshPass. This needs some extra care as DynamicMeshPass can be mixed with a regular mesh passes, so code that uses it has to restore static 'UniformView' binding after DynamicMeshPass call #rb ola.olsson [CL 29039857 by bob tellez in ue5-main branch]
2023-10-24 04:53:09 -04:00
class FDynamicBatchedPrimitiveLayout : public FRenderResource
{
public:
void InitRHI(FRHICommandListBase& RHICmdList) override
{
// This Layout fully replicates BatchedPrimitive UB
// we replace RDG_SRV with a regular SRV to be able to update UB inside RDG passes
static FName BatchedPrimitiveSlotName = "BatchedPrimitive";
FRHIUniformBufferLayoutInitializer Initialzer(TEXT("DynamicBatchedPrimitive"), 16u);
Initialzer.bUniformView = true;
Initialzer.Resources.Add({0, UBMT_RDG_BUFFER_SRV});
Initialzer.StaticSlot = FUniformBufferStaticSlotRegistry::Get().FindSlotByName(BatchedPrimitiveSlotName);
Initialzer.BindingFlags = EUniformBufferBindingFlags::StaticAndShader;
Initialzer.ComputeHash();
// set view source to a regular SRV after hash computation, to make sure hash matches BatchedPrimitive layout
Initialzer.Resources[0].MemberType = UBMT_SRV;
LayoutRHI = RHICreateUniformBufferLayout(Initialzer);
}
void ReleaseRHI() override
{
LayoutRHI = nullptr;
}
FUniformBufferLayoutRHIRef LayoutRHI;
};
TGlobalResource<FDynamicBatchedPrimitiveLayout> GDynamicBatchedPrimitiveLayout;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
void DrawDynamicMeshPassPrivate(
const FSceneView& View,
FRHICommandList& RHICmdList,
FMeshCommandOneFrameArray& VisibleMeshDrawCommands,
FDynamicMeshDrawCommandStorage& DynamicMeshDrawCommandStorage,
FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
bool& InNeedsShaderInitialisation,
uint32 InstanceFactor)
{
if (VisibleMeshDrawCommands.Num() > 0)
{
// GPUCULL_TODO: workaround for the fact that DrawDynamicMeshPassPrivate et al. don't work with GPU-Scene instancing
// we don't support dynamic instancing for this path since we require one primitive per draw command
// This is because the stride on the instance data buffer is set to 0 so only the first will ever be fetched.
const bool bDynamicInstancing = false;
Merging CL#29037036 Make 'UniformView' GPUScene path work with DynamicMeshPass. This needs some extra care as DynamicMeshPass can be mixed with a regular mesh passes, so code that uses it has to restore static 'UniformView' binding after DynamicMeshPass call #rb ola.olsson [CL 29039857 by bob tellez in ue5-main branch]
2023-10-24 04:53:09 -04:00
const ERHIFeatureLevel::Type FeatureLevel = View.GetFeatureLevel();
const bool bUseGPUScene = UseGPUScene(GMaxRHIShaderPlatform, FeatureLevel);
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
FMeshDrawCommandSceneArgs SceneArgs;
Merging CL#29037036 Make 'UniformView' GPUScene path work with DynamicMeshPass. This needs some extra care as DynamicMeshPass can be mixed with a regular mesh passes, so code that uses it has to restore static 'UniformView' binding after DynamicMeshPass call #rb ola.olsson [CL 29039857 by bob tellez in ue5-main branch]
2023-10-24 04:53:09 -04:00
if (bUseGPUScene)
{
SceneArgs.BatchedPrimitiveSlot = FInstanceCullingContext::GetUniformBufferViewStaticSlot(View.GetShaderPlatform());
}
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
const uint32 PrimitiveIdBufferStride = FInstanceCullingContext::GetInstanceIdBufferStride(View.GetShaderPlatform());
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
ApplyViewOverridesToMeshDrawCommands(View, VisibleMeshDrawCommands, DynamicMeshDrawCommandStorage, GraphicsMinimalPipelineStateSet, InNeedsShaderInitialisation);
check(View.bIsViewInfo);
const FViewInfo* ViewInfo = static_cast<const FViewInfo*>(&View);
Add initial version of scene uniform buffer and move GPUScene from View. #preflight 63e0ca6c244dc45a20d3f808 #rb ola.olsson, zach.bethel [CL 24027890 by wouter dek in ue5-main branch]
2023-02-06 05:56:29 -05:00
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
SortAndMergeDynamicPassMeshDrawCommands(View, RHICmdList, VisibleMeshDrawCommands, DynamicMeshDrawCommandStorage, SceneArgs.PrimitiveIdsBuffer, InstanceFactor, &ViewInfo->DynamicPrimitiveCollector);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
if (IsUniformBufferStaticSlotValid(SceneArgs.BatchedPrimitiveSlot))
{
Merging CL#29037036 Make 'UniformView' GPUScene path work with DynamicMeshPass. This needs some extra care as DynamicMeshPass can be mixed with a regular mesh passes, so code that uses it has to restore static 'UniformView' binding after DynamicMeshPass call #rb ola.olsson [CL 29039857 by bob tellez in ue5-main branch]
2023-10-24 04:53:09 -04:00
FShaderResourceViewRHIRef BatchedPrimitiveSRV = RHICmdList.CreateShaderResourceView(SceneArgs.PrimitiveIdsBuffer);
SceneArgs.PrimitiveIdsBuffer = nullptr;
FRHIShaderResourceView* SRV = BatchedPrimitiveSRV.GetReference();
FUniformBufferRHIRef UBRef = RHICreateUniformBuffer(&SRV, GDynamicBatchedPrimitiveLayout.LayoutRHI, UniformBuffer_SingleFrame, EUniformBufferValidation::None);
RHICmdList.SetStaticUniformBuffer(SceneArgs.BatchedPrimitiveSlot, UBRef);
Rework GPUScene support on mobile platforms. Platforms that do support uniform buffer objects can now provide batched primitive data through UBO. There is a limit UBO range that can be accessed in shaders, so we group instances into batches that fit into this limit. Switch uses 64KB views, other platfroms16KB views. For each primitive we allocate 512Bytes and 256Bytes for instance. Mobile platforms that do not support UBO will use a desktop version of GPUScene. There are a few things that still missing: Dynamic mesh passes, static lighting #rb ola.olsson, benjamin.rouveyrol [CL 26354848 by marc audy in ue5-main branch]
2023-06-30 16:34:38 -04:00
}
SubmitMeshDrawCommandsRange(VisibleMeshDrawCommands, GraphicsMinimalPipelineStateSet, SceneArgs, PrimitiveIdBufferStride, bDynamicInstancing, 0, VisibleMeshDrawCommands.Num(), InstanceFactor, RHICmdList);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
}
}
FMeshDrawCommandSortKey CalculateMeshStaticSortKey(const FMeshMaterialShader* VertexShader, const FMeshMaterialShader* PixelShader)
{
FMeshDrawCommandSortKey SortKey;
SortKey.Generic.VertexShaderHash = VertexShader ? VertexShader->GetSortKey() : 0;
SortKey.Generic.PixelShaderHash = PixelShader ? PixelShader->GetSortKey() : 0;
return SortKey;
}
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
FMeshPassProcessor::FMeshPassProcessor(EMeshPass::Type InMeshPassType, const FScene* InScene, ERHIFeatureLevel::Type InFeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext)
: IPSOCollector(FPassProcessorManager::GetPSOCollectorIndex(GetFeatureLevelShadingPath(InFeatureLevel), InMeshPassType))
, MeshPassType(InMeshPassType)
, Scene(InScene)
, FeatureLevel(InFeatureLevel)
, ViewIfDynamicMeshCommand(InViewIfDynamicMeshCommand)
, DrawListContext(InDrawListContext)
{
}
FMeshPassProcessor::FMeshPassProcessor(const TCHAR* InMeshPassName, const FScene* InScene, ERHIFeatureLevel::Type InFeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext)
: IPSOCollector(FPSOCollectorCreateManager::GetIndex(GetFeatureLevelShadingPath(InFeatureLevel), InMeshPassName))
, MeshPassType(EMeshPass::Num)
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
, Scene(InScene)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
, FeatureLevel(InFeatureLevel)
, ViewIfDynamicMeshCommand(InViewIfDynamicMeshCommand)
, DrawListContext(InDrawListContext)
{
}
PSO Precache: MeshPassProcessor implementation for all common used processors (refactor internal pass processor code to share as much code as possible between building of mesh draw commands and setting up the PSOs which are used) #jira UE-139584 #rb Jason.Nadro #preflight 63235e28214d9e96980f588d [CL 22032850 by kenzo terelst in ue5-main branch]
2022-09-15 13:46:19 -04:00
FMeshPassProcessor::FMeshDrawingPolicyOverrideSettings FMeshPassProcessor::ComputeMeshOverrideSettings(const FPSOPrecacheParams& PrecachePSOParams)
{
FMeshDrawingPolicyOverrideSettings OverrideSettings;
OverrideSettings.MeshPrimitiveType = PT_TriangleList;
Minor PSO precaching fixes: - use paramater FeatureLevel instead of touching possible nullptr scene - move static stat members to global c++ files instead of storing them in the header - fix check when PSO got rescheduled during precache background task - only enable PSO precache validation when actual PSO precaching is enabled as well #jira UE-139584 #rb Mihnea.Balta [CL 22089969 by kenzo terelst in ue5-main branch]
2022-09-20 04:55:47 -04:00
OverrideSettings.MeshOverrideFlags |= PrecachePSOParams.bDisableBackFaceCulling ? EDrawingPolicyOverrideFlags::TwoSided : EDrawingPolicyOverrideFlags::None;
PSO Precache: MeshPassProcessor implementation for all common used processors (refactor internal pass processor code to share as much code as possible between building of mesh draw commands and setting up the PSOs which are used) #jira UE-139584 #rb Jason.Nadro #preflight 63235e28214d9e96980f588d [CL 22032850 by kenzo terelst in ue5-main branch]
2022-09-15 13:46:19 -04:00
OverrideSettings.MeshOverrideFlags |= PrecachePSOParams.bReverseCulling ? EDrawingPolicyOverrideFlags::ReverseCullMode : EDrawingPolicyOverrideFlags::None;
return OverrideSettings;
}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
FMeshPassProcessor::FMeshDrawingPolicyOverrideSettings FMeshPassProcessor::ComputeMeshOverrideSettings(const FMeshBatch& Mesh)
{
FMeshDrawingPolicyOverrideSettings OverrideSettings;
OverrideSettings.MeshPrimitiveType = (EPrimitiveType)Mesh.Type;
OverrideSettings.MeshOverrideFlags |= Mesh.bDisableBackfaceCulling ? EDrawingPolicyOverrideFlags::TwoSided : EDrawingPolicyOverrideFlags::None;
OverrideSettings.MeshOverrideFlags |= Mesh.bDitheredLODTransition ? EDrawingPolicyOverrideFlags::DitheredLODTransition : EDrawingPolicyOverrideFlags::None;
OverrideSettings.MeshOverrideFlags |= Mesh.bWireframe ? EDrawingPolicyOverrideFlags::Wireframe : EDrawingPolicyOverrideFlags::None;
OverrideSettings.MeshOverrideFlags |= Mesh.ReverseCulling ? EDrawingPolicyOverrideFlags::ReverseCullMode : EDrawingPolicyOverrideFlags::None;
return OverrideSettings;
}
- ComputeMeshFillMode doesn't require MeshBatch as parameter - MeshPassProcessor create function takes feature level as create parameter - MeshPassProcessor base stores the processor enum type (handy for reference and stat tracking per pass type) When pass enum value is not available then EMeshPassType::Num is used for now #jira UE-139584 #rb Jason.Nadro, Mihnea.Balta, Zach.Bethel, Arciel.Rekman #preflight 631b30f1304480f8f89fca35 [CL 21987972 by kenzo terelst in ue5-main branch]
2022-09-13 14:04:12 -04:00
ERasterizerFillMode FMeshPassProcessor::ComputeMeshFillMode(const FMaterial& InMaterialResource, const FMeshDrawingPolicyOverrideSettings& InOverrideSettings)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
const bool bMaterialResourceIsTwoSided = InMaterialResource.IsTwoSided();
const bool bIsWireframeMaterial = InMaterialResource.IsWireframe() || !!(InOverrideSettings.MeshOverrideFlags & EDrawingPolicyOverrideFlags::Wireframe);
return bIsWireframeMaterial ? FM_Wireframe : FM_Solid;
}
- ComputeMeshFillMode doesn't require MeshBatch as parameter - MeshPassProcessor create function takes feature level as create parameter - MeshPassProcessor base stores the processor enum type (handy for reference and stat tracking per pass type) When pass enum value is not available then EMeshPassType::Num is used for now #jira UE-139584 #rb Jason.Nadro, Mihnea.Balta, Zach.Bethel, Arciel.Rekman #preflight 631b30f1304480f8f89fca35 [CL 21987972 by kenzo terelst in ue5-main branch]
2022-09-13 14:04:12 -04:00
ERasterizerCullMode FMeshPassProcessor::ComputeMeshCullMode(const FMaterial& InMaterialResource, const FMeshDrawingPolicyOverrideSettings& InOverrideSettings)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
const bool bMaterialResourceIsTwoSided = InMaterialResource.IsTwoSided();
const bool bInTwoSidedOverride = !!(InOverrideSettings.MeshOverrideFlags & EDrawingPolicyOverrideFlags::TwoSided);
const bool bInReverseCullModeOverride = !!(InOverrideSettings.MeshOverrideFlags & EDrawingPolicyOverrideFlags::ReverseCullMode);
const bool bIsTwoSided = (bMaterialResourceIsTwoSided || bInTwoSidedOverride);
const bool bMeshRenderTwoSided = bIsTwoSided || bInTwoSidedOverride;
return bMeshRenderTwoSided ? CM_None : (bInReverseCullModeOverride ? CM_CCW : CM_CW);
}
FMeshDrawCommandPrimitiveIdInfo FMeshPassProcessor::GetDrawCommandPrimitiveId(
const FPrimitiveSceneInfo* RESTRICT PrimitiveSceneInfo,
const FMeshBatchElement& BatchElement) const
{
Change GPU-Scene to use persistent primitive ID instead of the packed index. - removes the need to reupload primitives that change packed index and to patch instance data accordingly. #rb zach.bethel, tiago.costa, patrick.kelly, Graham.Wihlidal [CL 29742503 by ola olsson in ue5-main branch]
2023-11-15 06:19:15 -05:00
FMeshDrawCommandPrimitiveIdInfo PrimitiveIdInfo = FMeshDrawCommandPrimitiveIdInfo(0, FPersistentPrimitiveIndex { 0 }, -1);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
if (UseGPUScene(GMaxRHIShaderPlatform, FeatureLevel))
{
if (BatchElement.PrimitiveIdMode == PrimID_FromPrimitiveSceneInfo)
{
ensureMsgf(BatchElement.PrimitiveUniformBufferResource == nullptr, TEXT("PrimitiveUniformBufferResource should not be setup when PrimitiveIdMode == PrimID_FromPrimitiveSceneInfo"));
check(PrimitiveSceneInfo);
Change GPU-Scene to use persistent primitive ID instead of the packed index. - removes the need to reupload primitives that change packed index and to patch instance data accordingly. #rb zach.bethel, tiago.costa, patrick.kelly, Graham.Wihlidal [CL 29742503 by ola olsson in ue5-main branch]
2023-11-15 06:19:15 -05:00
PrimitiveIdInfo.DrawPrimitiveId = PrimitiveSceneInfo->GetPersistentIndex().Index;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
PrimitiveIdInfo.InstanceSceneDataOffset = PrimitiveSceneInfo->GetInstanceSceneDataOffset();
PrimitiveIdInfo.bIsDynamicPrimitive = 0U;
}
else if (BatchElement.PrimitiveIdMode == PrimID_DynamicPrimitiveShaderData && ViewIfDynamicMeshCommand != nullptr)
{
// Mark using GPrimIDDynamicFlag (top bit) as we defer this to later.
PrimitiveIdInfo.DrawPrimitiveId = BatchElement.DynamicPrimitiveIndex | GPrimIDDynamicFlag;
PrimitiveIdInfo.InstanceSceneDataOffset = BatchElement.DynamicPrimitiveInstanceSceneDataOffset;
PrimitiveIdInfo.bIsDynamicPrimitive = 1U;
}
else
{
check(BatchElement.PrimitiveIdMode == PrimID_ForceZero);
}
}
PrimitiveIdInfo.ScenePrimitiveId = PrimitiveSceneInfo ? PrimitiveSceneInfo->GetIndex() : -1;
return PrimitiveIdInfo;
}
bool FMeshPassProcessor::ShouldSkipMeshDrawCommand(const FMeshBatch& RESTRICT MeshBatch, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy) const
{
bool bSkipMeshDrawCommand = false;
#if WITH_EDITORONLY_DATA
// Support debug mode to render only non-Nanite proxies that incorrectly reference coarse mesh static mesh assets.
if (GNaniteIsolateInvalidCoarseMesh != 0)
{
// Skip everything by default
bSkipMeshDrawCommand = true;
const bool bNaniteProxy = PrimitiveSceneProxy != nullptr && PrimitiveSceneProxy->IsNaniteMesh();
if (!bNaniteProxy && MeshBatch.VertexFactory != nullptr)
{
// Only skip if the referenced static mesh is not a generated Nanite coarse mesh
const bool bIsCoarseProxy = MeshBatch.VertexFactory->IsCoarseProxyMesh();
if (bIsCoarseProxy)
{
bSkipMeshDrawCommand = false;
}
}
}
#endif
return bSkipMeshDrawCommand;
}
FCachedPassMeshDrawListContext::FCachedPassMeshDrawListContext(FScene& InScene)
: Scene(InScene)
, bUseGPUScene(UseGPUScene(GMaxRHIShaderPlatform, GMaxRHIFeatureLevel))
{
}
FMeshDrawCommand& FCachedPassMeshDrawListContext::AddCommand(FMeshDrawCommand& Initializer, uint32 NumElements)
{
checkf(CurrMeshPass < EMeshPass::Num, TEXT("BeginMeshPass() must be called before adding commands to this context"));
ensureMsgf(CommandInfo.CommandIndex == -1 && CommandInfo.StateBucketId == -1, TEXT("GetCommandInfoAndReset() wasn't called since the last command was added"));
if (NumElements == 1)
{
return Initializer;
}
else
{
MeshDrawCommandForStateBucketing = Initializer;
return MeshDrawCommandForStateBucketing;
}
}
void FCachedPassMeshDrawListContext::BeginMeshPass(EMeshPass::Type MeshPass)
{
checkf(CurrMeshPass == EMeshPass::Num, TEXT("BeginMeshPass() was called without a matching EndMeshPass()"));
check(MeshPass < EMeshPass::Num);
CurrMeshPass = MeshPass;
}
void FCachedPassMeshDrawListContext::EndMeshPass()
{
checkf(CurrMeshPass < EMeshPass::Num, TEXT("EndMeshPass() was called without matching BeginMeshPass()"));
CurrMeshPass = EMeshPass::Num;
}
FCachedMeshDrawCommandInfo FCachedPassMeshDrawListContext::GetCommandInfoAndReset()
{
FCachedMeshDrawCommandInfo Ret = CommandInfo;
CommandInfo.CommandIndex = -1;
CommandInfo.StateBucketId = -1;
return Ret;
}
void FCachedPassMeshDrawListContext::FinalizeCommandCommon(
const FMeshBatch& MeshBatch,
int32 BatchElementIndex,
ERasterizerFillMode MeshFillMode,
ERasterizerCullMode MeshCullMode,
FMeshDrawCommandSortKey SortKey,
EFVisibleMeshDrawCommandFlags Flags,
const FGraphicsMinimalPipelineStateInitializer& PipelineState,
const FMeshProcessorShaders* ShadersForDebugging,
FMeshDrawCommand& MeshDrawCommand)
{
FGraphicsMinimalPipelineStateId PipelineId = FGraphicsMinimalPipelineStateId::GetPersistentId(PipelineState);
MeshDrawCommand.SetDrawParametersAndFinalize(MeshBatch, BatchElementIndex, PipelineId, ShadersForDebugging);
CommandInfo = FCachedMeshDrawCommandInfo(CurrMeshPass);
CommandInfo.SortKey = SortKey;
Add support for LOD selection of ISM instances using the GPU instance culling system. For each ISM primitive we determine minimum and maximum LOD and submit a mesh draw command for each. Then GPU culling uses the min and max screen size for each LOD draw command to cull instances against each LOD. This naively multiplies the number of instances that get pushed through instance culling. Though in reality, except on weaker platforms, instance culling is fast enough that it doesn't really matter. ISMs use the current CPU "one LOD for all instances" approach by default. The new approach is used if GPUScene is enabled and instance culling is enabled and bUseGpuLodSelection is true on the component. Also r.InstancedStaticMeshes.GpuLod can be used to turn the system on and off. #rb ola.olsson [CL 26130126 by jeremy moore in ue5-main branch]
2023-06-20 14:47:40 -04:00
CommandInfo.CullingPayload = CreateCullingPayload(MeshBatch, MeshBatch.Elements[BatchElementIndex]);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
CommandInfo.MeshFillMode = MeshFillMode;
CommandInfo.MeshCullMode = MeshCullMode;
CommandInfo.Flags = Flags;
#if MESH_DRAW_COMMAND_DEBUG_DATA
if (bUseGPUScene)
{
MeshDrawCommand.ClearDebugPrimitiveSceneProxy(); //When using State Buckets multiple PrimitiveSceneProxies use the same MeshDrawCommand, so The PrimitiveSceneProxy pointer can't be stored.
}
#endif
#if DO_GUARD_SLOW
if (bUseGPUScene)
{
FMeshDrawCommand MeshDrawCommandDebug = FMeshDrawCommand(MeshDrawCommand);
check(MeshDrawCommandDebug.ShaderBindings.GetDynamicInstancingHash() == MeshDrawCommand.ShaderBindings.GetDynamicInstancingHash());
check(MeshDrawCommandDebug.GetDynamicInstancingHash() == MeshDrawCommand.GetDynamicInstancingHash());
}
if (Scene.GetShadingPath() == EShadingPath::Deferred)
{
ensureMsgf(MeshDrawCommand.VertexStreams.GetAllocatedSize() == 0, TEXT("Cached Mesh Draw command overflows VertexStreams. VertexStream inline size should be tweaked."));
VFX opaque collision with partial depth buffer (avoid particles collisions with themselves). Currently that pass does not run on mobile. Follow up: (1) make FCopyViewDepthCS common with Lumen and (2) make some code common in depthrendering. #rb stu.mckenna, simon.tovey, charles.derousiers #preflight https://horde.devtools.epicgames.com/job/6418d51b3d275ade38ad86ea [CL 24725686 by Sebastien Hillaire in ue5-main branch]
2023-03-20 18:35:18 -04:00
if (CurrMeshPass == EMeshPass::BasePass || CurrMeshPass == EMeshPass::DepthPass || CurrMeshPass == EMeshPass::SecondStageDepthPass || CurrMeshPass == EMeshPass::CSMShadowDepth || CurrMeshPass == EMeshPass::VSMShadowDepth)
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
{
TArray<EShaderFrequency, TInlineAllocator<SF_NumFrequencies>> ShaderFrequencies;
MeshDrawCommand.ShaderBindings.GetShaderFrequencies(ShaderFrequencies);
int32 DataOffset = 0;
for (int32 i = 0; i < ShaderFrequencies.Num(); i++)
{
FMeshDrawSingleShaderBindings SingleShaderBindings = MeshDrawCommand.ShaderBindings.GetSingleShaderBindings(ShaderFrequencies[i], DataOffset);
if (SingleShaderBindings.GetParameterMapInfo().LooseParameterBuffers.Num() != 0)
{
bAnyLooseParameterBuffers = true;
}
ensureMsgf(SingleShaderBindings.GetParameterMapInfo().SRVs.Num() == 0, TEXT("Cached Mesh Draw command uses individual SRVs. This will break dynamic instancing in performance critical pass. Use Uniform Buffers instead."));
ensureMsgf(SingleShaderBindings.GetParameterMapInfo().TextureSamplers.Num() == 0, TEXT("Cached Mesh Draw command uses individual Texture Samplers. This will break dynamic instancing in performance critical pass. Use Uniform Buffers instead."));
}
}
}
#endif
}
void FCachedPassMeshDrawListContextImmediate::FinalizeCommand(
const FMeshBatch& MeshBatch,
int32 BatchElementIndex,
const FMeshDrawCommandPrimitiveIdInfo& IdInfo,
ERasterizerFillMode MeshFillMode,
ERasterizerCullMode MeshCullMode,
FMeshDrawCommandSortKey SortKey,
EFVisibleMeshDrawCommandFlags Flags,
const FGraphicsMinimalPipelineStateInitializer& PipelineState,
const FMeshProcessorShaders* ShadersForDebugging,
FMeshDrawCommand& MeshDrawCommand)
{
// disabling this by default as it incurs a high cost in perf captures due to sheer volume. Recommendation is to re-enable locally if you need to profile this particular code.
// QUICK_SCOPE_CYCLE_COUNTER(STAT_FinalizeCachedMeshDrawCommand);
FinalizeCommandCommon(
MeshBatch,
BatchElementIndex,
MeshFillMode,
MeshCullMode,
SortKey,
Flags,
PipelineState,
ShadersForDebugging,
MeshDrawCommand
);
if (bUseGPUScene)
{
Experimental::FHashElementId SetId;
FStateBucketMap& BucketMap = Scene.CachedMeshDrawCommandStateBuckets[CurrMeshPass];
auto hash = BucketMap.ComputeHash(MeshDrawCommand);
{
SetId = BucketMap.FindOrAddIdByHash(hash, MeshDrawCommand, FMeshDrawCommandCount());
FMeshDrawCommandCount& DrawCount = BucketMap.GetByElementId(SetId).Value;
DrawCount.Num++;
}
CommandInfo.StateBucketId = SetId.GetIndex();
}
else
{
// Only one FMeshDrawCommand supported per FStaticMesh in a pass
// Allocate at lowest free index so that 'r.DoLazyStaticMeshUpdate' can shrink the TSparseArray more effectively
FCachedPassMeshDrawList& CachedDrawLists = Scene.CachedDrawLists[CurrMeshPass];
CommandInfo.CommandIndex = CachedDrawLists.MeshDrawCommands.EmplaceAtLowestFreeIndex(CachedDrawLists.LowestFreeIndexSearchStart, MeshDrawCommand);
}
}
void FCachedPassMeshDrawListContextDeferred::FinalizeCommand(
const FMeshBatch& MeshBatch,
int32 BatchElementIndex,
const FMeshDrawCommandPrimitiveIdInfo& IdInfo,
ERasterizerFillMode MeshFillMode,
ERasterizerCullMode MeshCullMode,
FMeshDrawCommandSortKey SortKey,
EFVisibleMeshDrawCommandFlags Flags,
const FGraphicsMinimalPipelineStateInitializer& PipelineState,
const FMeshProcessorShaders* ShadersForDebugging,
FMeshDrawCommand& MeshDrawCommand)
{
// disabling this by default as it incurs a high cost in perf captures due to sheer volume. Recommendation is to re-enable locally if you need to profile this particular code.
// QUICK_SCOPE_CYCLE_COUNTER(STAT_FinalizeCachedMeshDrawCommand);
FinalizeCommandCommon(
MeshBatch,
BatchElementIndex,
MeshFillMode,
MeshCullMode,
SortKey,
Flags,
PipelineState,
ShadersForDebugging,
MeshDrawCommand
);
const int32 Index = DeferredCommands.Add(MeshDrawCommand);
if (bUseGPUScene)
{
// Cache the hash here to make the deferred finalize less expensive
DeferredCommandHashes.Add(FStateBucketMap::ComputeHash(MeshDrawCommand));
CommandInfo.StateBucketId = Index;
}
else
{
CommandInfo.CommandIndex = Index;
}
}
void FCachedPassMeshDrawListContextDeferred::DeferredFinalizeMeshDrawCommands(const TArrayView<FPrimitiveSceneInfo*>& SceneInfos, int32 Start, int32 End)
{
if (bUseGPUScene)
{
for (int32 SceneInfoIndex = Start; SceneInfoIndex < End; ++SceneInfoIndex)
{
FPrimitiveSceneInfo* SceneInfo = SceneInfos[SceneInfoIndex];
for (auto& CmdInfo : SceneInfo->StaticMeshCommandInfos)
{
check(CmdInfo.MeshPass < EMeshPass::Num);
FStateBucketMap& BucketMap = Scene.CachedMeshDrawCommandStateBuckets[CmdInfo.MeshPass];
Mobile: Light map artifacts with specific mesh when launched on Android Supply a mesh LOD index into MDC batching CS so it can fetch a correct lighting information for each instance #rb ola.olsson #jira UE-164402 #preflight 632d8688671a1a24b564bd0c [CL 22163633 by dmitriy dyomin in ue5-main branch]
2022-09-23 20:02:18 -04:00
int32 DeferredIndex = CmdInfo.StateBucketId;
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
Mobile: Light map artifacts with specific mesh when launched on Android Supply a mesh LOD index into MDC batching CS so it can fetch a correct lighting information for each instance #rb ola.olsson #jira UE-164402 #preflight 632d8688671a1a24b564bd0c [CL 22163633 by dmitriy dyomin in ue5-main branch]
2022-09-23 20:02:18 -04:00
check(DeferredIndex >= 0 && DeferredIndex < DeferredCommands.Num());
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
check(CmdInfo.CommandIndex == -1);
Mobile: Light map artifacts with specific mesh when launched on Android Supply a mesh LOD index into MDC batching CS so it can fetch a correct lighting information for each instance #rb ola.olsson #jira UE-164402 #preflight 632d8688671a1a24b564bd0c [CL 22163633 by dmitriy dyomin in ue5-main branch]
2022-09-23 20:02:18 -04:00
FMeshDrawCommand& Command = DeferredCommands[DeferredIndex];
const Experimental::FHashType CommandHash = DeferredCommandHashes[DeferredIndex];
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
Experimental::FHashElementId SetId = BucketMap.FindOrAddIdByHash(CommandHash, MoveTemp(Command), FMeshDrawCommandCount());
FMeshDrawCommandCount& DrawCount = BucketMap.GetByElementId(SetId).Value;
DrawCount.Num++;
CmdInfo.StateBucketId = SetId.GetIndex();
}
}
}
else
{
for (int32 SceneInfoIndex = Start; SceneInfoIndex < End; ++SceneInfoIndex)
{
FPrimitiveSceneInfo* SceneInfo = SceneInfos[SceneInfoIndex];
for (auto& CmdInfo : SceneInfo->StaticMeshCommandInfos)
{
check(CmdInfo.MeshPass < EMeshPass::Num);
FCachedPassMeshDrawList& CachedDrawLists = Scene.CachedDrawLists[CmdInfo.MeshPass];
check(CmdInfo.CommandIndex >= 0 && CmdInfo.CommandIndex < DeferredCommands.Num());
check(CmdInfo.StateBucketId == -1);
FMeshDrawCommand& Command = DeferredCommands[CmdInfo.CommandIndex];
CmdInfo.CommandIndex = CachedDrawLists.MeshDrawCommands.EmplaceAtLowestFreeIndex(CachedDrawLists.LowestFreeIndexSearchStart, MoveTemp(Command));
}
}
}
DeferredCommands.Reset();
DeferredCommandHashes.Reset();
}
PassProcessorCreateFunction FPassProcessorManager::JumpTable[(int32)EShadingPath::Num][EMeshPass::Num] = {};
- ComputeMeshFillMode doesn't require MeshBatch as parameter - MeshPassProcessor create function takes feature level as create parameter - MeshPassProcessor base stores the processor enum type (handy for reference and stat tracking per pass type) When pass enum value is not available then EMeshPassType::Num is used for now #jira UE-139584 #rb Jason.Nadro, Mihnea.Balta, Zach.Bethel, Arciel.Rekman #preflight 631b30f1304480f8f89fca35 [CL 21987972 by kenzo terelst in ue5-main branch]
2022-09-13 14:04:12 -04:00
DeprecatedPassProcessorCreateFunction FPassProcessorManager::DeprecatedJumpTable[(int32)EShadingPath::Num][EMeshPass::Num] = {};
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
EMeshPassFlags FPassProcessorManager::Flags[(int32)EShadingPath::Num][EMeshPass::Num] = {};
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
int32 FPassProcessorManager::PSOCollectorIndex[(int32)EShadingPath::Num][EMeshPass::Num] = {};
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
static_assert(EMeshPass::Num <= FPSOCollectorCreateManager::MaxPSOCollectorCount);
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
void FPassProcessorManager::SetPassFlags(EShadingPath ShadingPath, EMeshPass::Type PassType, EMeshPassFlags NewFlags)
{
check(IsInGameThread());
FGlobalComponentRecreateRenderStateContext Context;
if (JumpTable[(uint32)ShadingPath][PassType])
{
Flags[(uint32)ShadingPath][PassType] = NewFlags;
}
}
#if WANTS_DRAW_MESH_EVENTS
FMeshDrawCommand::FMeshDrawEvent::FMeshDrawEvent(const FMeshDrawCommand& MeshDrawCommand, const uint32 InstanceFactor, FRHICommandList& RHICmdList)
Merging //UE5/Dev-ParallelRendering/... (up to CL 30965645) to //UE5/Main/... (base CL 30962637) Significant refactor of RHI command list management and submission, and RHI breadcrumbs / RenderGraph (RDG) scopes, to allow for parallel translation of most RHI command lists. See individual changelists in //UE5/Dev-ParallelRendering for details. A summary of the changes is as follows: This work's primary goal was to allow as many RHI command lists as possible to be parallel translated, to make more efficient use of many-core systems. To achieve this: - The submission code paths for the immediate and parallel RHI command lists have been merged into a single function: FRHICommandListExecutor::Submit(). - A "dispatch thread" (which is simply a series of chained task graph tasks) is used to decide which command lists are batched together in a single parallel translate job. - Individual command lists can disable parallel translate, which forces them to be executed on the RHI thread. This happens automatically if an RHI command list performs an operation that is not thread safe (e.g. buffer lock, or low-level resource transition). One of the primary blockers for parallel translation was the RHI breadcrumb system, and the way RDG builds scopes. This was also refactored to remove these limitations: - RDG could only push/pop events on the immediate command list, which resulted in parallel and immediate work being interleaved, breaking any opportunity for parallelism. - Platform RHI implementations of breadcrumbs (e.g. in D3D12 RHI) was not correct across multiple RHI contexts. Push/pop operations aren't necessarily balanced within any one RHI context given that RDG builds "parallel pass sets" containing arbitrary ranges of renderer passes. A summary of the new RHI breadcrumb system is as follows: - A tree of breadcrumb nodes is built by the render thread and RDG. Each node contains the node name, and pointers to the parent and next nodes. When fully built, the nodes form a depth-first linked list which is used for traversing the tree for GPU crash debugging. - The memory for breadcrumb nodes is provided by ref-counted allocator objects. These allocators are pipelined through the RHI, allowing the platform RHI implementation to extend their lifetime for GPU crash debugging purposes. - RHIPushEvent / RHIPopEvent have been removed, replaced with RHIBeginBreadcrumbGPU / RHIEndBreadcrumbGPU. Platform RHIs implement these functions to perform GPU immediate writes using the unique ID of each node, for tracking GPU progress. - Format string arguments are captured by-value to remove the cost of string formatting while building the breadcrumb tree. String formatting only occurs when the actual formatted string is required (e.g. during GPU crash breadcrumb stack traversal, or when calling platform GPU profiling APIs). RenderGraph scopes have been simplified: - The separate scope trees / arrays of ops have been combined. There is now a single tree of RDG scopes containing all types. - Each RDG pass holds a pointer to the scope it was created under. - BeginCPU / EndCPU is called on each RDG scope as the various RDG threads enter / exit them. This allows us to mark-up each worker thread with the relevant Unreal Insights scopes. Other changes include: - Fixes for bugs uncovered when parallel translate was enabled. - Adjusted platform affinities necessary due to the new layout of thread tasks in the renderer. - Refactored RHI draw call stats to better fit the new pipeline design. #rb jeannoe.morissette, zach.bethel #jira UE-139543 [CL 30973133 by Luke Thatcher in ue5-main branch]
2024-01-29 12:47:28 -05:00
: Breadcrumb(
RHICmdList
, GShowMaterialDrawEvents != 0
, TEXT("%s %s (%u instances)")
, MeshDrawCommand.DebugData.MaterialName
, MeshDrawCommand.DebugData.ResourceName
, MeshDrawCommand.NumInstances * InstanceFactor
)
{}
Remove view uniform buffer from ray tracing mesh draw commands and delete FPersistentUniformBuffers::ViewUniformBuffer. Deprecated the view uniform buffer from MeshPassRenderState. #rb yuriy.odonnell #preflight 629915e62e20b63f9a9d2d46 [CL 20475710 by zach bethel in ue5-main branch]
2022-06-02 16:57:29 -04:00
#endif
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
void AddRenderTargetInfo(
EPixelFormat PixelFormat,
ETextureCreateFlags CreateFlags,
FGraphicsPipelineRenderTargetsInfo& RenderTargetsInfo)
{
RenderTargetsInfo.RenderTargetFormats[RenderTargetsInfo.RenderTargetsEnabled] = PixelFormat;
RenderTargetsInfo.RenderTargetFlags[RenderTargetsInfo.RenderTargetsEnabled] = CreateFlags;
RenderTargetsInfo.RenderTargetsEnabled++;
}
void SetupDepthStencilInfo(
EPixelFormat DepthStencilFormat,
ETextureCreateFlags DepthStencilCreateFlags,
ERenderTargetLoadAction DepthTargetLoadAction,
ERenderTargetLoadAction StencilTargetLoadAction,
FExclusiveDepthStencil DepthStencilAccess,
FGraphicsPipelineRenderTargetsInfo& RenderTargetsInfo)
{
// Setup depth stencil state
RenderTargetsInfo.DepthStencilTargetFormat = DepthStencilFormat;
RenderTargetsInfo.DepthStencilTargetFlag = DepthStencilCreateFlags;
RenderTargetsInfo.DepthTargetLoadAction = DepthTargetLoadAction;
RenderTargetsInfo.StencilTargetLoadAction = StencilTargetLoadAction;
RenderTargetsInfo.DepthStencilAccess = DepthStencilAccess;
const ERenderTargetStoreAction StoreAction = EnumHasAnyFlags(RenderTargetsInfo.DepthStencilTargetFlag, TexCreate_Memoryless) ? ERenderTargetStoreAction::ENoAction : ERenderTargetStoreAction::EStore;
RenderTargetsInfo.DepthTargetStoreAction = RenderTargetsInfo.DepthStencilAccess.IsUsingDepth() ? StoreAction : ERenderTargetStoreAction::ENoAction;
RenderTargetsInfo.StencilTargetStoreAction = RenderTargetsInfo.DepthStencilAccess.IsUsingStencil() ? StoreAction : ERenderTargetStoreAction::ENoAction;
}
void SetupGBufferRenderTargetInfo(const FSceneTexturesConfig& SceneTexturesConfig, FGraphicsPipelineRenderTargetsInfo& RenderTargetsInfo, bool bSetupDepthStencil)
{
SceneTexturesConfig.GetGBufferRenderTargetsInfo(RenderTargetsInfo);
if (bSetupDepthStencil)
{
SetupDepthStencilInfo(PF_DepthStencil, SceneTexturesConfig.DepthCreateFlags, ERenderTargetLoadAction::ELoad,
PSO precache fixes: - Precache PSOs for materials used by the WidgetComponent - Just-in-time PSO precaching for PSOs used by canvas rendering - these force use the base pass rendering with specific color format on RT0 - Also precache PSOs with alpha channel on RT0 for base pass materials because these can be used for planar reflection or scene capture (water and sky also use base pass shaders) - Also precache custom depth PSOs when depth rendering is enabled (custom depth can be enabled without precaching PSOs again - would probably be too late as well if done just in time) - Change default CVar value of r.PSOPrecache.LightMapPolicyMode to 1 to only precache PSOs for LMP_NO_LIGHTMAP - Change default DepthStencil mode from DepthWrite_StencilWrite to DepthRead_StencilWrite which is used by default - ParticleComponent (Niagara and Cascade) precache custom depth passes as well and also precache for both regular and culling and reverse culling because PSO precaching is done at asset level and don't know if component will have negative determinant - Use spline params of SplineMeshComponent to know if reverse culling is needed - SplineMeshVertexFactory now used GPU scene and doesn't need special implementation for GetPSOPrecacheVertexFetchElements anymore (can use parent one) #jira UE-171570 #rb Benjamin.Rouveyrol [CL 30373218 by kenzo terelst in ue5-main branch]
2023-12-18 05:07:01 -05:00
ERenderTargetLoadAction::ELoad, FExclusiveDepthStencil::DepthRead_StencilWrite, RenderTargetsInfo);
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
}
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
#if PSO_PRECACHING_VALIDATE
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
FGraphicsMinimalPipelineStateInitializer PSOCollectorStats::GetShadersOnlyInitializer(const FGraphicsMinimalPipelineStateInitializer& Initializer)
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
{
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
FGraphicsMinimalPipelineStateInitializer ShadersOnlyInitializer;
ShadersOnlyInitializer.BoundShaderState = Initializer.BoundShaderState;
ShadersOnlyInitializer.BoundShaderState.VertexDeclarationRHI = nullptr;
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
ShadersOnlyInitializer.ComputeStatePrecachePSOHash();
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
return ShadersOnlyInitializer;
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
FGraphicsMinimalPipelineStateInitializer PSOCollectorStats::PatchMinimalPipelineStateToCheck(const FGraphicsMinimalPipelineStateInitializer& Initializer)
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
{
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
FGraphicsMinimalPipelineStateInitializer PatchedInitializer = Initializer;
//PatchedInitializer.DepthStencilState = nullptr;
//PatchedInitializer.RasterizerState = nullptr;
//PatchedInitializer.BlendState = nullptr;
//PatchedInitializer.PrimitiveType = PT_TriangleList;
//PatchedInitializer.ImmutableSamplerState = FImmutableSamplerState();
//PatchedInitializer.BoundShaderState.VertexDeclarationRHI = nullptr;
//PatchedInitializer.UniqueEntry = false;
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
// Recompute the hash when disabling certain states for checks.
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
// PatchedInitializer.StatePrecachePSOHash = 0;
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
PatchedInitializer.ComputeStatePrecachePSOHash();
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
Enhance PSO stats collection: * Refactor multiple points of collection into a single Collector class to reduce code duplication. * Collect stats on untracked, missed, hit, etc. PSOs at various stages (shaders-only, minimal and full PSOs). Use `stat PSOPrecache` to show. * Only use hashes for tracking shaders-only and minimal PSOs. The likelihood (and consequences, since we're only tracking for development purposes) of a collision are minimal. In a future CL I will add different verbosity options to `r.PSOPrecache.Validation` so that we can have some lightweight tracking always on for testing. #pf 646cf866576becd7b5f0f1cf #tests tested that the counters with the new unified collector implementation match the current ones [CL 25605392 by daniele vettorel in ue5-main branch]
2023-05-24 12:12:50 -04:00
return PatchedInitializer;
PSO Precache Base Changes (disabled by default) Add PSOPrecache file which wraps engine level PSO structs and functions - FPSOPrecacheParams used to wrap certain parameters which drive the PSO collection (mostly set from components) - IPSOCollector interface used as engine entry to the mesh pass processors in renderer project - FPSOCollectorCreateManager to wrap all statically registered IPSOCollector CreateFuncions - PSOCollectorStats structs and helper functions Add PSOPrecache support to PipelineStateCache: - functions to precache compute and graphics PSOs - functions to check current precache state - FPrecacheGraphicsPipelineCache which wraps all currently precached PSOs IMaterial entry function to PrecachePSOs with given vertex factories and params (implemented by UMaterial & UMaterialInstance) which forwards call to FMaterial and finally the FMaterialShaderMap - FMaterialShaderMap will iterate all registered IPSOCollector to collect all possible PSOs used and forward them to the PipelineStateCache for actual (async) precaching RHI Changes: - Add RHI specific functions to retrieve & compare the FRHIVertexDeclaration and FGraphicsPipelineStateInitializer hash for each RHI - Add helper functions to match RHI*State data by retrieving initializer Minimal vertex factory changes for PSO precaching as prep - actual changes in upcoming CLs MeshPassProcessor base functions to collect PSOs which can be used by all mesh pass processor implemention (actual changes in upcoming CLs) - Cache complete precache data hash of stored minimal PSO so it can be used for fast actual PSO initializer hash computation (full PSO initializer is build at runtime) - Cache if minimal PSO was successfully precache and option to skip draw when PSO is still precaching (disabled by default and doesn't work yet via GPU scene based rendering) - Add helper functions to setup the per mesh pass render target data used during PSO collection Refactor SceneTextureConfig so it can be initialized from an init struct and move all function to setup the internal members from SceneTexture to SceneTextureConfig using the data from the init struct (so it's available in Engine project) Fix GBufferInfo format for velocity target (was always floating point while it should be unorm when not android Make certain helper functions definitions to h file so they can be used everywhere (SupportsNaniteRendering, FTextureRenderTarget2DResource::GetFormat & CreateFlags) #preflight 63189a5a967ffc68fb9044a5 #jira UE-139584 #rb Mihnea.Balta [CL 21907508 by kenzo terelst in ue5-main branch]
2022-09-08 19:34:08 -04:00
}
Improve PSO precaching stats collection: * Introduce two tracking options, lightweight and full. Lightweight tracking simply tracks stats using an aggregated counter, while full tracking organizes stats by mesh pass/vertex factory type (if available). This is in preparation of an "always-on" option. * Better performance using shorter critical sections and lock-free counters where possible, especially in lightweight mode. * Enable validation code paths in Test builds (still disabled at runtime through CVar), and disable them in editor builds (which do not support PSO precaching). #pf 6475fa254b0d5a1eb1cc91ee [CL 25685077 by daniele vettorel in ue5-main branch]
2023-05-30 15:27:32 -04:00
uint64 PSOCollectorStats::GetPSOPrecacheHash(const FGraphicsMinimalPipelineStateInitializer& GraphicsPSOInitializer)
{
Move the calculation of the state component of the PSO precache hash to the RHI. default implementation of RHIComputePrecachePSOHash will calculate the StatePrecachePSOHash if it is missing. This allows: - RHIs to override the content of StatePrecachePSOHash - RHIComputePrecachePSOHash can be called for any graphics initializer. #rb Daniele.Vettorel [CL 26844533 by allan bentham in ue5-main branch]
2023-08-04 09:49:52 -04:00
return GraphicsPSOInitializer.StatePrecachePSOHash;
Improve PSO precaching stats collection: * Introduce two tracking options, lightweight and full. Lightweight tracking simply tracks stats using an aggregated counter, while full tracking organizes stats by mesh pass/vertex factory type (if available). This is in preparation of an "always-on" option. * Better performance using shorter critical sections and lock-free counters where possible, especially in lightweight mode. * Enable validation code paths in Test builds (still disabled at runtime through CVar), and disable them in editor builds (which do not support PSO precaching). #pf 6475fa254b0d5a1eb1cc91ee [CL 25685077 by daniele vettorel in ue5-main branch]
2023-05-30 15:27:32 -04:00
}
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
void PSOCollectorStats::CheckShaderOnlyStateInCache(
const FGraphicsMinimalPipelineStateInitializer& Initializer,
const FMaterial& Material,
const FVertexFactoryType* VFType,
const FPrimitiveSceneProxy* PrimitiveSceneProxy,
int32 PSOCollectorIndex)
{
FGraphicsMinimalPipelineStateInitializer ShadersOnlyInitializer = GetShadersOnlyInitializer(Initializer);
Add CSV Stats for PSO Precaching #rb daniele.vettorel [CL 31716130 by kenzo terelst in ue5-main branch]
2024-02-22 03:49:33 -05:00
EPSOPrecacheResult Result = EPSOPrecacheResult::Unknown;
bool bStatsUpdated = PSOCollectorStats::GetShadersOnlyPSOPrecacheStatsCollector().CheckStateInCacheByHash(ShadersOnlyInitializer.StatePrecachePSOHash, PSOCollectorIndex, VFType, Result);
if (IsFullPrecachingValidationEnabled() && bStatsUpdated && Result != EPSOPrecacheResult::Unknown && Result != EPSOPrecacheResult::Complete)
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
{
FGraphicsPipelineStateInitializer GraphicsPSOInitializer = ShadersOnlyInitializer.AsGraphicsPipelineStateInitializer();
LogPSOMissInfo(GraphicsPSOInitializer, EPSOPrecacheMissType::ShadersOnly, Result, &Material, VFType, PrimitiveSceneProxy, PSOCollectorIndex, ShadersOnlyInitializer.StatePrecachePSOHash);
}
}
void PSOCollectorStats::CheckMinimalPipelineStateInCache(
const FGraphicsMinimalPipelineStateInitializer& Initializer,
const FMaterial& Material,
const FVertexFactoryType* VFType,
const FPrimitiveSceneProxy* PrimitiveSceneProxy,
int32 PSOCollectorIndex)
{
FGraphicsMinimalPipelineStateInitializer PatchedMinimalInitializer = PSOCollectorStats::PatchMinimalPipelineStateToCheck(Initializer);
Add CSV Stats for PSO Precaching #rb daniele.vettorel [CL 31716130 by kenzo terelst in ue5-main branch]
2024-02-22 03:49:33 -05:00
EPSOPrecacheResult Result = EPSOPrecacheResult::Unknown;
bool bStatsUpdated = PSOCollectorStats::GetMinimalPSOPrecacheStatsCollector().CheckStateInCacheByHash(PatchedMinimalInitializer.StatePrecachePSOHash, PSOCollectorIndex, VFType, Result);
if (IsFullPrecachingValidationEnabled() && bStatsUpdated && Result != EPSOPrecacheResult::Unknown && Result != EPSOPrecacheResult::Complete)
PSO Precache refactor and usage improvements: - Split PSOPrecache.h/cpp in 3 files for better code readability and less code recompile: PSOPrecache, PSOPrecacheMaterial & PSOPrecacheValidation - Don't rely on EMeshPass::Type when adding a new IPSOCollector, but store PSOCollectorIndex which can be remapped to a human readable string for debugging and output - Add option to log detailed information on PSOPrecache misses on why a certain PSO is missing (will check cache to find out what closest PSO is already precached and log the difference - help track down misses in the future) - Simplify debug options for tracking, only have enable, minimal and full validation. Full validation will log detailed information on misses for ShaderOnly, MinimalGraphicsPSO and FullPSO (detailed logging only available on development builds - needs to store extra tracking information on precached PSOs) - Add option to break when precaching PSOs for certain materials (with optional Passname) or certain shader hashes (used for debugging PSO misses - data is logged on PSO misses) #rb benjamin.rouveyrol [CL 30207893 by kenzo terelst in ue5-main branch]
2023-12-08 05:32:14 -05:00
{
FGraphicsMinimalPipelineStateInitializer ShadersOnlyInitializer = GetShadersOnlyInitializer(Initializer);
bool bShaderOnlyPrecached = PSOCollectorStats::GetShadersOnlyPSOPrecacheStatsCollector().IsPrecached(ShadersOnlyInitializer.StatePrecachePSOHash);
if (bShaderOnlyPrecached)
{
check(Result == EPSOPrecacheResult::Missed);
FGraphicsPipelineStateInitializer GraphicsPSOInitializer = PatchedMinimalInitializer.AsGraphicsPipelineStateInitializer();
LogPSOMissInfo(GraphicsPSOInitializer, EPSOPrecacheMissType::MinimalPSOState, Result, &Material, VFType, PrimitiveSceneProxy, PSOCollectorIndex, ShadersOnlyInitializer.StatePrecachePSOHash);
}
}
}
Do not compute PSO precache hash if validation is disabled. #rnx [CL 25609495 by daniele vettorel in ue5-main branch]
2023-05-24 14:44:26 -04:00
#endif // PSO_PRECACHING_VALIDATE
Reference in New Issue Copy Permalink