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
5.5
UnrealEngineUWP/Engine/Source/Runtime/RenderCore/Private/RayTracingGeometry.cpp

304 lines
9.2 KiB
C++
Raw Permalink Normal View History

Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
// Copyright Epic Games, Inc. All Rights Reserved.
#include "RayTracingGeometry.h"
Fixed non-unity build break in RayTracingGeometry.cpp. #preflight trivial [CL 25746276 by zach bethel in ue5-main branch]
2023-06-01 18:13:20 -04:00
#include "RHICommandList.h"
Adding includes before cleaning up RHI dependencies. [CL 23888475 by christopher waters in ue5-main branch]
2023-01-27 14:17:39 -05:00
#include "HAL/IConsoleManager.h"
Moved FRayTracingGeometryManager out of RenderCore - This will enable extending it to track which proxies use each FRayTracingGeometry/UStaticMesh in follow up changes. - Added new IRayTracingGeometryManagerInterface to RenderCore since FRayTracingGeometry also needs to interact with FRayTracingGeometryManager. #rb Yuriy.ODonnell [CL 29779645 by tiago costa in ue5-main branch]
2023-11-16 11:28:36 -05:00
#include "RayTracingGeometryManagerInterface.h"
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
#include "RenderUtils.h"
Fix crashes in static and skeletal mesh streaming systems - Removed FRHIAsyncCommandList. Use of this helper was dangerous as the resulting RHICmdList is enqueued for execution via ENQUEUE_RENDER_COMMAND, which doesn't guarantee correct ordering vs other RHI commands. - Removed deprecated functions that made use of this async helper type. - Reimplemented mesh streaming jobs to create a local RHICmdList to use for resource creation / initialization on the async thread, which is then submitted on the render thread in DoFinishUpdate. This guarantees command ordering in all cases (e.g. with bypass / no RHI thread etc). - Most raytracing operations have been kept on the render thread, as they are not yet threadsafe to run on the async streaming threads. - Added a breadcrumb in CreateBuffers to show which static / skeletal mesh is getting streamed in Insights etc traces. Renamed "update RHI resource" APIs used by mesh streaming to "replace RHI resource" (e.g. RHICmdList.UpdateRHIResources() -> RHICmdList.ReplaceResources(), TRHIResourceUpdateBatcher -> FRHIResourceReplaceBatcher) - Old naming was generic and didn't describe what was actually happening. - Also removed the reference counting done by the API now that the mesh streamer holds references until after DoFinishUpdate is called. #rb zach.bethel #jira FORT-704446 [CL 31417988 by Luke Thatcher in ue5-main branch]
2024-02-13 05:28:36 -05:00
#include "RHIResourceReplace.h"
Ran IWYU on RHI and RenderCore, private only. #preflight 63d358c85c69f453c1f79c37 [CL 23889591 by christopher waters in ue5-main branch]
2023-01-27 14:54:10 -05:00
#include "RHITextureReference.h" // IWYU pragma: keep
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
Moved FRayTracingGeometryManager out of RenderCore - This will enable extending it to track which proxies use each FRayTracingGeometry/UStaticMesh in follow up changes. - Added new IRayTracingGeometryManagerInterface to RenderCore since FRayTracingGeometry also needs to interact with FRayTracingGeometryManager. #rb Yuriy.ODonnell [CL 29779645 by tiago costa in ue5-main branch]
2023-11-16 11:28:36 -05:00
#if RHI_RAYTRACING
IRayTracingGeometryManager* GRayTracingGeometryManager = nullptr;
#endif
Use FIntermediateRayTracingGeometry instead of partially initialized FRayTracingGeometry to store intermediate data during mesh streaming. #rb aleksander.netzel [CL 27540060 by tiago costa in ue5-main branch]
2023-08-31 17:40:48 -04:00
static TAutoConsoleVariable<int32> CVarDebugForceRuntimeBLAS(
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
TEXT("r.Raytracing.DebugForceRuntimeBLAS"),
Use FIntermediateRayTracingGeometry instead of partially initialized FRayTracingGeometry to store intermediate data during mesh streaming. #rb aleksander.netzel [CL 27540060 by tiago costa in ue5-main branch]
2023-08-31 17:40:48 -04:00
0,
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
TEXT("Force building BLAS at runtime."),
ECVF_ReadOnly);
Deprecate public access to RayTracingGeometryRHI in FRayTracingGeometry. - use GetRHI() instead. [FYI] aleksander.netzel [CL 31843065 by tiago costa in ue5-main branch]
2024-02-27 11:57:07 -05:00
PRAGMA_DISABLE_DEPRECATION_WARNINGS // Remove this in UE 5.6 once RayTracingGeometryRHI is made private
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
#if RHI_RAYTRACING
Fix crashes in static and skeletal mesh streaming systems - Removed FRHIAsyncCommandList. Use of this helper was dangerous as the resulting RHICmdList is enqueued for execution via ENQUEUE_RENDER_COMMAND, which doesn't guarantee correct ordering vs other RHI commands. - Removed deprecated functions that made use of this async helper type. - Reimplemented mesh streaming jobs to create a local RHICmdList to use for resource creation / initialization on the async thread, which is then submitted on the render thread in DoFinishUpdate. This guarantees command ordering in all cases (e.g. with bypass / no RHI thread etc). - Most raytracing operations have been kept on the render thread, as they are not yet threadsafe to run on the async streaming threads. - Added a breadcrumb in CreateBuffers to show which static / skeletal mesh is getting streamed in Insights etc traces. Renamed "update RHI resource" APIs used by mesh streaming to "replace RHI resource" (e.g. RHICmdList.UpdateRHIResources() -> RHICmdList.ReplaceResources(), TRHIResourceUpdateBatcher -> FRHIResourceReplaceBatcher) - Old naming was generic and didn't describe what was actually happening. - Also removed the reference counting done by the API now that the mesh streamer holds references until after DoFinishUpdate is called. #rb zach.bethel #jira FORT-704446 [CL 31417988 by Luke Thatcher in ue5-main branch]
2024-02-13 05:28:36 -05:00
void FRayTracingGeometry::InitRHIForStreaming(FRHIRayTracingGeometry* IntermediateGeometry, FRHIResourceReplaceBatcher& Batcher)
TRHIResourceUpdateBatcher cleanup - Moving TRHIResourceUpdateBatcher and FRHIResourceUpdateInfo into their own file, RHIResourceUpdates - TRHIResourceUpdateBatcher is now only the data class and has a base class to manage the functionality. - The new base class can be used generically, removing the need for templates on all prior uses of TRHIResourceUpdateBatcher - Changing all functional uses of TRHIResourceUpdateBatcher to use the base class and moving all implementations into cpp files. #rb zach.bethel #preflight 638fd8607e0feab0b77fa218 [CL 23425504 by christopher waters in ue5-main branch]
2022-12-07 00:05:42 -05:00
{
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
checkf(IntermediateGeometry,
TEXT("IntermediateGeometry should be valid when streaming-in ray tracing geometry.\n")
TEXT("This will result in FRayTracingGeometry not being correctly initialized.\n")
Don't clear Initializer in FRayTracingGeometry::ReleaseRHIForStreaming(...) - clearing initializer causes streamed out geometries to not be properly initialized when raytracing is toggled on. - static mesh ray tracing geometry initializer doesn't change at runtime, so instead of clearing initializer on stream-out and setting it up again during stream-in, we only need to set Initializer.Type as appropriate. - added CheckRayTracingGeometryInitializer(...) to verify that initializer is matches previous logic. Repro steps for the issue this change fixes: 1 - Run project with mesh streaming and dynamic ray tracing enabled. 2 - show RayTracingDebug (enable some raytracing scene visualization) 3 - r.RayTracing.Enable 0 (disable raytracing) 4 - r.Streaming.StressTest 1 (enable streaming stress test which causes some LODs to be streamed out) 5 - r.RayTracing.Enable 1 (re-enable raytracing) 6 - r.Streaming.StressTest 0 (disable streaming stress test which causes LODs to be streamed in) 7 - Notice that, without this change, ray tracing instances are still using the lower LOD geometry. #rb aleksander.netzel [CL 28841029 by tiago costa in ue5-main branch]
2023-10-17 11:52:48 -04:00
);
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
checkf(RayTracingGeometryRHI, TEXT("RayTracingGeometryRHI must be valid when InitRHIForStreaming is called.\n"));
Don't clear Initializer in FRayTracingGeometry::ReleaseRHIForStreaming(...) - clearing initializer causes streamed out geometries to not be properly initialized when raytracing is toggled on. - static mesh ray tracing geometry initializer doesn't change at runtime, so instead of clearing initializer on stream-out and setting it up again during stream-in, we only need to set Initializer.Type as appropriate. - added CheckRayTracingGeometryInitializer(...) to verify that initializer is matches previous logic. Repro steps for the issue this change fixes: 1 - Run project with mesh streaming and dynamic ray tracing enabled. 2 - show RayTracingDebug (enable some raytracing scene visualization) 3 - r.RayTracing.Enable 0 (disable raytracing) 4 - r.Streaming.StressTest 1 (enable streaming stress test which causes some LODs to be streamed out) 5 - r.RayTracing.Enable 1 (re-enable raytracing) 6 - r.Streaming.StressTest 0 (disable streaming stress test which causes LODs to be streamed in) 7 - Notice that, without this change, ray tracing instances are still using the lower LOD geometry. #rb aleksander.netzel [CL 28841029 by tiago costa in ue5-main branch]
2023-10-17 11:52:48 -04:00
Initializer.Type = ERayTracingGeometryInitializerType::Rendering;
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
Batcher.EnqueueReplace(RayTracingGeometryRHI, IntermediateGeometry);
EnumAddFlags(GeometryState, EGeometryStateFlags::Valid);
TRHIResourceUpdateBatcher cleanup - Moving TRHIResourceUpdateBatcher and FRHIResourceUpdateInfo into their own file, RHIResourceUpdates - TRHIResourceUpdateBatcher is now only the data class and has a base class to manage the functionality. - The new base class can be used generically, removing the need for templates on all prior uses of TRHIResourceUpdateBatcher - Changing all functional uses of TRHIResourceUpdateBatcher to use the base class and moving all implementations into cpp files. #rb zach.bethel #preflight 638fd8607e0feab0b77fa218 [CL 23425504 by christopher waters in ue5-main branch]
2022-12-07 00:05:42 -05:00
EnumAddFlags(GeometryState, EGeometryStateFlags::StreamedIn);
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
GRayTracingGeometryManager->RefreshRegisteredGeometry(RayTracingGeometryHandle);
TRHIResourceUpdateBatcher cleanup - Moving TRHIResourceUpdateBatcher and FRHIResourceUpdateInfo into their own file, RHIResourceUpdates - TRHIResourceUpdateBatcher is now only the data class and has a base class to manage the functionality. - The new base class can be used generically, removing the need for templates on all prior uses of TRHIResourceUpdateBatcher - Changing all functional uses of TRHIResourceUpdateBatcher to use the base class and moving all implementations into cpp files. #rb zach.bethel #preflight 638fd8607e0feab0b77fa218 [CL 23425504 by christopher waters in ue5-main branch]
2022-12-07 00:05:42 -05:00
}
Fix crashes in static and skeletal mesh streaming systems - Removed FRHIAsyncCommandList. Use of this helper was dangerous as the resulting RHICmdList is enqueued for execution via ENQUEUE_RENDER_COMMAND, which doesn't guarantee correct ordering vs other RHI commands. - Removed deprecated functions that made use of this async helper type. - Reimplemented mesh streaming jobs to create a local RHICmdList to use for resource creation / initialization on the async thread, which is then submitted on the render thread in DoFinishUpdate. This guarantees command ordering in all cases (e.g. with bypass / no RHI thread etc). - Most raytracing operations have been kept on the render thread, as they are not yet threadsafe to run on the async streaming threads. - Added a breadcrumb in CreateBuffers to show which static / skeletal mesh is getting streamed in Insights etc traces. Renamed "update RHI resource" APIs used by mesh streaming to "replace RHI resource" (e.g. RHICmdList.UpdateRHIResources() -> RHICmdList.ReplaceResources(), TRHIResourceUpdateBatcher -> FRHIResourceReplaceBatcher) - Old naming was generic and didn't describe what was actually happening. - Also removed the reference counting done by the API now that the mesh streamer holds references until after DoFinishUpdate is called. #rb zach.bethel #jira FORT-704446 [CL 31417988 by Luke Thatcher in ue5-main branch]
2024-02-13 05:28:36 -05:00
void FRayTracingGeometry::ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher)
TRHIResourceUpdateBatcher cleanup - Moving TRHIResourceUpdateBatcher and FRHIResourceUpdateInfo into their own file, RHIResourceUpdates - TRHIResourceUpdateBatcher is now only the data class and has a base class to manage the functionality. - The new base class can be used generically, removing the need for templates on all prior uses of TRHIResourceUpdateBatcher - Changing all functional uses of TRHIResourceUpdateBatcher to use the base class and moving all implementations into cpp files. #rb zach.bethel #preflight 638fd8607e0feab0b77fa218 [CL 23425504 by christopher waters in ue5-main branch]
2022-12-07 00:05:42 -05:00
{
Fix FRayTracingGeometry incorrectly keeping Valid state after it's streamed out while ray tracing is disabled. #rb aleksander.netzel [CL 28005105 by tiago costa in ue5-main branch]
2023-09-19 14:34:30 -04:00
RemoveBuildRequest();
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
checkf(RayTracingGeometryRHI, TEXT("RayTracingGeometryRHI must be valid when ReleaseRHIForStreaming is called.\n"));
TRHIResourceUpdateBatcher cleanup - Moving TRHIResourceUpdateBatcher and FRHIResourceUpdateInfo into their own file, RHIResourceUpdates - TRHIResourceUpdateBatcher is now only the data class and has a base class to manage the functionality. - The new base class can be used generically, removing the need for templates on all prior uses of TRHIResourceUpdateBatcher - Changing all functional uses of TRHIResourceUpdateBatcher to use the base class and moving all implementations into cpp files. #rb zach.bethel #preflight 638fd8607e0feab0b77fa218 [CL 23425504 by christopher waters in ue5-main branch]
2022-12-07 00:05:42 -05:00
EnumRemoveFlags(GeometryState, EGeometryStateFlags::StreamedIn);
Fix FRayTracingGeometry incorrectly keeping Valid state after it's streamed out while ray tracing is disabled. #rb aleksander.netzel [CL 28005105 by tiago costa in ue5-main branch]
2023-09-19 14:34:30 -04:00
EnumRemoveFlags(GeometryState, EGeometryStateFlags::Valid);
TRHIResourceUpdateBatcher cleanup - Moving TRHIResourceUpdateBatcher and FRHIResourceUpdateInfo into their own file, RHIResourceUpdates - TRHIResourceUpdateBatcher is now only the data class and has a base class to manage the functionality. - The new base class can be used generically, removing the need for templates on all prior uses of TRHIResourceUpdateBatcher - Changing all functional uses of TRHIResourceUpdateBatcher to use the base class and moving all implementations into cpp files. #rb zach.bethel #preflight 638fd8607e0feab0b77fa218 [CL 23425504 by christopher waters in ue5-main branch]
2022-12-07 00:05:42 -05:00
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
Batcher.EnqueueReplace(RayTracingGeometryRHI, nullptr);
Don't clear Initializer in FRayTracingGeometry::ReleaseRHIForStreaming(...) - clearing initializer causes streamed out geometries to not be properly initialized when raytracing is toggled on. - static mesh ray tracing geometry initializer doesn't change at runtime, so instead of clearing initializer on stream-out and setting it up again during stream-in, we only need to set Initializer.Type as appropriate. - added CheckRayTracingGeometryInitializer(...) to verify that initializer is matches previous logic. Repro steps for the issue this change fixes: 1 - Run project with mesh streaming and dynamic ray tracing enabled. 2 - show RayTracingDebug (enable some raytracing scene visualization) 3 - r.RayTracing.Enable 0 (disable raytracing) 4 - r.Streaming.StressTest 1 (enable streaming stress test which causes some LODs to be streamed out) 5 - r.RayTracing.Enable 1 (re-enable raytracing) 6 - r.Streaming.StressTest 0 (disable streaming stress test which causes LODs to be streamed in) 7 - Notice that, without this change, ray tracing instances are still using the lower LOD geometry. #rb aleksander.netzel [CL 28841029 by tiago costa in ue5-main branch]
2023-10-17 11:52:48 -04:00
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
Initializer.Type = ERayTracingGeometryInitializerType::StreamingDestination;
Keep track of resident ray tracing geometries in FRayTracingGeometryManager. - reduces FRayTracingGeometryManager::Tick(...) overhead since it doesn't need to loop over all registered geometries. - also added a new stat to show how much memory is being used. #rb aleksander.netzel [CL 33583730 by tiago costa in ue5-main branch]
2024-05-10 15:16:02 -04:00
GRayTracingGeometryManager->RefreshRegisteredGeometry(RayTracingGeometryHandle);
TRHIResourceUpdateBatcher cleanup - Moving TRHIResourceUpdateBatcher and FRHIResourceUpdateInfo into their own file, RHIResourceUpdates - TRHIResourceUpdateBatcher is now only the data class and has a base class to manage the functionality. - The new base class can be used generically, removing the need for templates on all prior uses of TRHIResourceUpdateBatcher - Changing all functional uses of TRHIResourceUpdateBatcher to use the base class and moving all implementations into cpp files. #rb zach.bethel #preflight 638fd8607e0feab0b77fa218 [CL 23425504 by christopher waters in ue5-main branch]
2022-12-07 00:05:42 -05:00
}
Add FRHICommandListBase argument to FRHIRayTracingGeometry::SetInitializer to remove use of FRHICommandListImmediate::Get() in platform RHIs. #rb Kenzo.Terelst [CL 32273819 by luke thatcher in ue5-main branch]
2024-03-15 10:56:24 -04:00
void FRayTracingGeometry::RequestBuildIfNeeded(FRHICommandListBase& RHICmdList, ERTAccelerationStructureBuildPriority InBuildPriority)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
if (GetRequiresBuild())
{
Removed FRHICommandList parameter from FRayTracingGeometryManager::RequestBuildAccelerationStructure() - Also made it possible to update some other functions to only require FRHICommandListBase. #rb Yuriy.ODonnell [CL 29999933 by tiago costa in ue5-main branch]
2023-11-29 17:09:38 -05:00
RayTracingBuildRequestIndex = GRayTracingGeometryManager->RequestBuildAccelerationStructure(this, InBuildPriority);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
SetRequiresBuild(false);
}
}
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
void FRayTracingGeometry::MakeResident(FRHICommandList& RHICmdList)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
check(EnumHasAllFlags(GeometryState, EGeometryStateFlags::Evicted) && RayTracingGeometryRHI == nullptr);
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
checkf(!EnumHasAllFlags(GeometryState, EGeometryStateFlags::StreamedIn),
TEXT("Evicted FRayTracingGeometry shouldn't have StreamedIn flag set."));
Don't create geometries that use shared buffers when FRayTracingGeometry::MakeResident() is called. - added an ensure to check this. [FYI] aleksander.netzel, Kenzo.Terelst [CL 33482129 by tiago costa in ue5-main branch]
2024-05-07 08:58:33 -04:00
if (!ensureMsgf(DynamicGeometrySharedBufferGenerationID == NonSharedVertexBuffers,
TEXT("Cannot call MakeResident(...) on FRayTracingGeometry using shared vertex buffers.\n")
TEXT("Dynamic geometry should be rebuilt instead.")))
{
// if geometry is using shared buffers those buffers might not be valid at this point
// instead of being made resident here, dynamic geometries need to be manually updated as necessary
return;
}
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
EnumRemoveFlags(GeometryState, EGeometryStateFlags::Evicted);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
InitRHI(RHICmdList);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
Fix FRayTracingGeometry incorrectly keeping EGeometryStateFlags::Valid when RHI resource is released. - that state combination is only correct when RHI resource is evicted due to dynamic raytracing being disabled. Repro: - Run cooked build with dynamic raytracing enabled. - Toggle r.Streaming.StressTest on/off #rb aleksander.netzel [CL 27929315 by tiago costa in ue5-main branch]
2023-09-15 15:31:24 -04:00
void FRayTracingGeometry::Evict()
{
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
check(!EnumHasAllFlags(GeometryState, EGeometryStateFlags::Evicted) && RayTracingGeometryRHI != nullptr);
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
Fix FRayTracingGeometry incorrectly keeping EGeometryStateFlags::Valid when RHI resource is released. - that state combination is only correct when RHI resource is evicted due to dynamic raytracing being disabled. Repro: - Run cooked build with dynamic raytracing enabled. - Toggle r.Streaming.StressTest on/off #rb aleksander.netzel [CL 27929315 by tiago costa in ue5-main branch]
2023-09-15 15:31:24 -04:00
RemoveBuildRequest();
RayTracingGeometryRHI.SafeRelease();
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
EnumAddFlags(GeometryState, EGeometryStateFlags::Evicted);
Resubmit CL34232076 - added missing TargetPlatform->UsesRayTracing() check in BuildStaticMeshDerivedDataKeySuffix(...) ----------------------------------------------------------------- Support BLAS streaming when using r.RayTracing.UseReferenceBasedResidency - serialize FStaticMeshRayTracingProxyLOD buffers into separate FByteBulkData. - for the FStaticMeshRayTracingProxy.bUsingRenderingLODs case, this requires shared ownership of resources. FStaticMeshRayTracingProxyLOD owns the RayTracingGeometry while FStaticMeshLODResources owns the VB/IB/etc as usual. - FRayTracingGeometryManager is responsible for responsible for issuing bulk data read requests and processing the results. - decoupled r.RayTracing.UseReferenceBasedResidency from r.RayTracing.EnableOnDemand. - made r.RayTracing.UseReferenceBasedResidency read-only since it affects serialization. #rb aleksander.netzel, Kenzo.Terelst [CL 34249031 by tiago costa in ue5-main branch]
2024-06-10 15:29:33 -04:00
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
if (EnumHasAllFlags(GeometryState, EGeometryStateFlags::StreamedIn))
Resubmit CL34232076 - added missing TargetPlatform->UsesRayTracing() check in BuildStaticMeshDerivedDataKeySuffix(...) ----------------------------------------------------------------- Support BLAS streaming when using r.RayTracing.UseReferenceBasedResidency - serialize FStaticMeshRayTracingProxyLOD buffers into separate FByteBulkData. - for the FStaticMeshRayTracingProxy.bUsingRenderingLODs case, this requires shared ownership of resources. FStaticMeshRayTracingProxyLOD owns the RayTracingGeometry while FStaticMeshLODResources owns the VB/IB/etc as usual. - FRayTracingGeometryManager is responsible for responsible for issuing bulk data read requests and processing the results. - decoupled r.RayTracing.UseReferenceBasedResidency from r.RayTracing.EnableOnDemand. - made r.RayTracing.UseReferenceBasedResidency read-only since it affects serialization. #rb aleksander.netzel, Kenzo.Terelst [CL 34249031 by tiago costa in ue5-main branch]
2024-06-10 15:29:33 -04:00
{
Refactored management of evicted ray tracing geometry. Context: - Evicted FRayTracingGeometry maintained the StreamedIn flag, which was later used in MakeResident(...) to recreate the geometry as-if it was streamed-in. - While this was valid on PC since ray tracing geometry for streamed-in meshes is simply built at runtime, on platforms that support offline built BLAS this code path didn't handle loading the offline data (instead the BLAS ended up being built at runtime like on PC). Changes: - Refactored some branches out of FRayTracingGeometry::InitRHIForStreaming(...)/ReleaseRHIForStreaming(...) and moved them higher level where more context is available to avoid unexpected state simply being ignored. - Evicting a streamed-in ray tracing geometry clears the StreamedIn and Valid flags, and sets Initializer.Type back to StreamingDestination. - MakeResident() will simply create the RHI object without special handling for streamed-in ray tracing geometries. - High level logic that calls FRayTracingGeometry::MakeResident(...) (currently FRayTracingGeometryManager) is responsible for handling the streaming-in of FRayTracingGeometry that requires it (ie: building BLAS at runtime, or streaming offline data as necessary). - When ray tracing is toggled on, make all registered geometries resident and kick-off streaming requests as necessary. #rb aleksander.netzel [CL 34365484 by tiago costa in ue5-main branch]
2024-06-14 04:16:57 -04:00
EnumRemoveFlags(GeometryState, EGeometryStateFlags::StreamedIn);
EnumRemoveFlags(GeometryState, EGeometryStateFlags::Valid);
Initializer.Type = ERayTracingGeometryInitializerType::StreamingDestination;
Resubmit CL34232076 - added missing TargetPlatform->UsesRayTracing() check in BuildStaticMeshDerivedDataKeySuffix(...) ----------------------------------------------------------------- Support BLAS streaming when using r.RayTracing.UseReferenceBasedResidency - serialize FStaticMeshRayTracingProxyLOD buffers into separate FByteBulkData. - for the FStaticMeshRayTracingProxy.bUsingRenderingLODs case, this requires shared ownership of resources. FStaticMeshRayTracingProxyLOD owns the RayTracingGeometry while FStaticMeshLODResources owns the VB/IB/etc as usual. - FRayTracingGeometryManager is responsible for responsible for issuing bulk data read requests and processing the results. - decoupled r.RayTracing.UseReferenceBasedResidency from r.RayTracing.EnableOnDemand. - made r.RayTracing.UseReferenceBasedResidency read-only since it affects serialization. #rb aleksander.netzel, Kenzo.Terelst [CL 34249031 by tiago costa in ue5-main branch]
2024-06-10 15:29:33 -04:00
}
Keep track of resident ray tracing geometries in FRayTracingGeometryManager. - reduces FRayTracingGeometryManager::Tick(...) overhead since it doesn't need to loop over all registered geometries. - also added a new stat to show how much memory is being used. #rb aleksander.netzel [CL 33583730 by tiago costa in ue5-main branch]
2024-05-10 15:16:02 -04:00
GRayTracingGeometryManager->RefreshRegisteredGeometry(RayTracingGeometryHandle);
Modified FRayTracingGeometry::Evict() to call RequestUpdateCachedRenderState(...) - less error prone than having to manually call it after evicting geometries. [CL 33487206 by tiago costa in ue5-main branch]
2024-05-07 12:39:27 -04:00
if (GroupHandle != INDEX_NONE)
{
GRayTracingGeometryManager->RequestUpdateCachedRenderState(GroupHandle);
}
Fix FRayTracingGeometry incorrectly keeping EGeometryStateFlags::Valid when RHI resource is released. - that state combination is only correct when RHI resource is evicted due to dynamic raytracing being disabled. Repro: - Run cooked build with dynamic raytracing enabled. - Toggle r.Streaming.StressTest on/off #rb aleksander.netzel [CL 27929315 by tiago costa in ue5-main branch]
2023-09-15 15:31:24 -04:00
}
Removed FRHICommandList parameter from FRayTracingGeometryManager::RequestBuildAccelerationStructure() - Also made it possible to update some other functions to only require FRHICommandListBase. #rb Yuriy.ODonnell [CL 29999933 by tiago costa in ue5-main branch]
2023-11-29 17:09:38 -05:00
void FRayTracingGeometry::CreateRayTracingGeometry(FRHICommandListBase& RHICmdList, ERTAccelerationStructureBuildPriority InBuildPriority)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
// Release previous RHI object if any
ReleaseRHI();
if (RawData.Num())
{
Use FIntermediateRayTracingGeometry instead of partially initialized FRayTracingGeometry to store intermediate data during mesh streaming. #rb aleksander.netzel [CL 27540060 by tiago costa in ue5-main branch]
2023-08-31 17:40:48 -04:00
check(Initializer.OfflineData == nullptr);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
Initializer.OfflineData = &RawData;
}
Use FIntermediateRayTracingGeometry instead of partially initialized FRayTracingGeometry to store intermediate data during mesh streaming. #rb aleksander.netzel [CL 27540060 by tiago costa in ue5-main branch]
2023-08-31 17:40:48 -04:00
if (CVarDebugForceRuntimeBLAS.GetValueOnAnyThread() && Initializer.OfflineData != nullptr)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
Initializer.OfflineData->Discard();
Initializer.OfflineData = nullptr;
}
bool bAllSegmentsAreValid = Initializer.Segments.Num() > 0 || Initializer.OfflineData;
for (const FRayTracingGeometrySegment& Segment : Initializer.Segments)
{
if (!Segment.VertexBuffer)
{
bAllSegmentsAreValid = false;
break;
}
}
if (bAllSegmentsAreValid)
{
Clear FRayTracingGeometry state in ReleaseRHI(). #rb aleksander.netzel [CL 28088395 by tiago costa in ue5-main branch]
2023-09-21 11:59:18 -04:00
// Geometries with StreamingDestination type are initially created in invalid state until they are streamed in (see InitRHIForStreaming).
const bool bWithNativeResource = Initializer.Type != ERayTracingGeometryInitializerType::StreamingDestination;
if (bWithNativeResource)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
EnumAddFlags(GeometryState, EGeometryStateFlags::Valid);
}
if (IsRayTracingEnabled())
{
Deprecated InitRHI() in favor of InitRHI(FRHICommandListBase&). #rb mihnea.balta, luke.thatcher, christopher.waters [CL 26097009 by zach bethel in ue5-main branch]
2023-06-19 13:56:56 -04:00
RayTracingGeometryRHI = RHICmdList.CreateRayTracingGeometry(Initializer);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
else
{
EnumAddFlags(GeometryState, EGeometryStateFlags::Evicted);
}
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
if (Initializer.OfflineData == nullptr)
{
// Request build if not skip
if (InBuildPriority != ERTAccelerationStructureBuildPriority::Skip)
{
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
if (RayTracingGeometryRHI)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
Removed FRHICommandList parameter from FRayTracingGeometryManager::RequestBuildAccelerationStructure() - Also made it possible to update some other functions to only require FRHICommandListBase. #rb Yuriy.ODonnell [CL 29999933 by tiago costa in ue5-main branch]
2023-11-29 17:09:38 -05:00
RayTracingBuildRequestIndex = GRayTracingGeometryManager->RequestBuildAccelerationStructure(this, InBuildPriority);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
SetRequiresBuild(false);
}
Resubmit CL34232076 - added missing TargetPlatform->UsesRayTracing() check in BuildStaticMeshDerivedDataKeySuffix(...) ----------------------------------------------------------------- Support BLAS streaming when using r.RayTracing.UseReferenceBasedResidency - serialize FStaticMeshRayTracingProxyLOD buffers into separate FByteBulkData. - for the FStaticMeshRayTracingProxy.bUsingRenderingLODs case, this requires shared ownership of resources. FStaticMeshRayTracingProxyLOD owns the RayTracingGeometry while FStaticMeshLODResources owns the VB/IB/etc as usual. - FRayTracingGeometryManager is responsible for responsible for issuing bulk data read requests and processing the results. - decoupled r.RayTracing.UseReferenceBasedResidency from r.RayTracing.EnableOnDemand. - made r.RayTracing.UseReferenceBasedResidency read-only since it affects serialization. #rb aleksander.netzel, Kenzo.Terelst [CL 34249031 by tiago costa in ue5-main branch]
2024-06-10 15:29:33 -04:00
else if (bWithNativeResource)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
SetRequiresBuild(true);
}
}
else
{
Add offline BLAS compression for supporting platforms: * Add IsCompressed() to FRHIRayTracingGeometry. * If BLAS is compressed it will trigger a build that will do the decompression. * Controlled by target platform setting "Enable Static Mesh Offline BVH Compression" * Enabled by default. #jira UE-146162 #rb yuriy.odonnell [CL 26559972 by aleksander netzel in ue5-main branch]
2023-07-24 20:01:35 -04:00
if (RayTracingGeometryRHI && RayTracingGeometryRHI->IsCompressed())
{
Removed FRHICommandList parameter from FRayTracingGeometryManager::RequestBuildAccelerationStructure() - Also made it possible to update some other functions to only require FRHICommandListBase. #rb Yuriy.ODonnell [CL 29999933 by tiago costa in ue5-main branch]
2023-11-29 17:09:38 -05:00
RayTracingBuildRequestIndex = GRayTracingGeometryManager->RequestBuildAccelerationStructure(this, InBuildPriority);
Add offline BLAS compression for supporting platforms: * Add IsCompressed() to FRHIRayTracingGeometry. * If BLAS is compressed it will trigger a build that will do the decompression. * Controlled by target platform setting "Enable Static Mesh Offline BVH Compression" * Enabled by default. #jira UE-146162 #rb yuriy.odonnell [CL 26559972 by aleksander netzel in ue5-main branch]
2023-07-24 20:01:35 -04:00
}
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
SetRequiresBuild(false);
// Offline data ownership is transferred to the RHI, which discards it after use.
// It is no longer valid to use it after this point.
Initializer.OfflineData = nullptr;
}
}
Keep track of resident ray tracing geometries in FRayTracingGeometryManager. - reduces FRayTracingGeometryManager::Tick(...) overhead since it doesn't need to loop over all registered geometries. - also added a new stat to show how much memory is being used. #rb aleksander.netzel [CL 33583730 by tiago costa in ue5-main branch]
2024-05-10 15:16:02 -04:00
GRayTracingGeometryManager->RefreshRegisteredGeometry(RayTracingGeometryHandle);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
bool FRayTracingGeometry::IsValid() const
{
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
// can't check IsInitialized() because current implementation of hair ray tracing support doesn't initialize resource
//check(IsInitialized());
Modified FRayTracingGeometry::IsValid() to ignore whether the geometry is evicted. - higher level should explicitly check if geometry if is evicted and handle it approriately. - for example, dynamic geometry can usually ignore eviction state since BLAS will be rebuilt anyway. #rb Kenzo.Terelst [CL 33237221 by tiago costa in ue5-main branch]
2024-04-25 13:33:16 -04:00
const bool bIsValid = EnumHasAllFlags(GeometryState, EGeometryStateFlags::Valid);
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
Modified FRayTracingGeometry::IsValid() to ignore whether the geometry is evicted. - higher level should explicitly check if geometry if is evicted and handle it approriately. - for example, dynamic geometry can usually ignore eviction state since BLAS will be rebuilt anyway. #rb Kenzo.Terelst [CL 33237221 by tiago costa in ue5-main branch]
2024-04-25 13:33:16 -04:00
if (bIsValid)
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
{
Modified FRayTracingGeometry::IsValid() to ignore whether the geometry is evicted. - higher level should explicitly check if geometry if is evicted and handle it approriately. - for example, dynamic geometry can usually ignore eviction state since BLAS will be rebuilt anyway. #rb Kenzo.Terelst [CL 33237221 by tiago costa in ue5-main branch]
2024-04-25 13:33:16 -04:00
check(Initializer.TotalPrimitiveCount > 0);
check(RayTracingGeometryRHI != nullptr || EnumHasAllFlags(GeometryState, EGeometryStateFlags::Evicted));
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
}
Modified FRayTracingGeometry::IsValid() to ignore whether the geometry is evicted. - higher level should explicitly check if geometry if is evicted and handle it approriately. - for example, dynamic geometry can usually ignore eviction state since BLAS will be rebuilt anyway. #rb Kenzo.Terelst [CL 33237221 by tiago costa in ue5-main branch]
2024-04-25 13:33:16 -04:00
return bIsValid;
Explicit Evicted state in FRayTracingGeometry #rb aleksander.netzel [CL 28884642 by tiago costa in ue5-main branch]
2023-10-18 14:26:10 -04:00
}
bool FRayTracingGeometry::IsEvicted() const
{
// can't check IsInitialized() because current implementation of hair ray tracing support doesn't initialize resource
//check(IsInitialized());
const bool bIsEvicted = EnumHasAllFlags(GeometryState, EGeometryStateFlags::Evicted);
if (bIsEvicted)
{
check(RayTracingGeometryRHI == nullptr);
}
return bIsEvicted;
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
Deprecated InitRHI() in favor of InitRHI(FRHICommandListBase&). #rb mihnea.balta, luke.thatcher, christopher.waters [CL 26097009 by zach bethel in ue5-main branch]
2023-06-19 13:56:56 -04:00
void FRayTracingGeometry::InitRHI(FRHICommandListBase& RHICmdList)
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
{
if (!IsRayTracingAllowed())
return;
ERTAccelerationStructureBuildPriority BuildPriority = Initializer.Type != ERayTracingGeometryInitializerType::Rendering
? ERTAccelerationStructureBuildPriority::Skip
: ERTAccelerationStructureBuildPriority::Normal;
Removed FRHICommandList parameter from FRayTracingGeometryManager::RequestBuildAccelerationStructure() - Also made it possible to update some other functions to only require FRHICommandListBase. #rb Yuriy.ODonnell [CL 29999933 by tiago costa in ue5-main branch]
2023-11-29 17:09:38 -05:00
CreateRayTracingGeometry(RHICmdList, BuildPriority);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
void FRayTracingGeometry::ReleaseRHI()
{
RemoveBuildRequest();
RayTracingGeometryRHI.SafeRelease();
Clear FRayTracingGeometry state in ReleaseRHI(). #rb aleksander.netzel [CL 28088395 by tiago costa in ue5-main branch]
2023-09-21 11:59:18 -04:00
GeometryState = EGeometryStateFlags::Invalid;
Refresh registered ray tracing geometry when FRayTracingGeometry::ReleaseRHI() is called. - otherwise the geometry stays in EvictableGeometries and causes a fail to check. #rb aleksander.netzel [CL 35751325 by tiago costa in ue5-main branch]
2024-08-22 15:24:21 -04:00
GRayTracingGeometryManager->RefreshRegisteredGeometry(RayTracingGeometryHandle);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
void FRayTracingGeometry::RemoveBuildRequest()
{
if (HasPendingBuildRequest())
{
Moved FRayTracingGeometryManager out of RenderCore - This will enable extending it to track which proxies use each FRayTracingGeometry/UStaticMesh in follow up changes. - Added new IRayTracingGeometryManagerInterface to RenderCore since FRayTracingGeometry also needs to interact with FRayTracingGeometryManager. #rb Yuriy.ODonnell [CL 29779645 by tiago costa in ue5-main branch]
2023-11-16 11:28:36 -05:00
GRayTracingGeometryManager->RemoveBuildRequest(RayTracingBuildRequestIndex);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
RayTracingBuildRequestIndex = INDEX_NONE;
}
}
Resubmit check IsRayTracingAllowed() when creating or destroying FRayTracingGeometry. - using ensureMsgf instead of checkf #rb aleksander.netzel [CL 27588192 by tiago costa in ue5-main branch]
2023-09-04 13:55:57 -04:00
void FRayTracingGeometry::InitResource(FRHICommandListBase& RHICmdList)
{
Don't register FRayTracingGeometry with GRayTracingGeometryManager if it's already registered. #rb aleksnader.netzel [CL 27918482 by tiago costa in ue5-main branch]
2023-09-15 12:02:44 -04:00
ensureMsgf(IsRayTracingAllowed(), TEXT("FRayTracingGeometry should only be initialized when Ray Tracing is allowed."));
Resubmit check IsRayTracingAllowed() when creating or destroying FRayTracingGeometry. - using ensureMsgf instead of checkf #rb aleksander.netzel [CL 27588192 by tiago costa in ue5-main branch]
2023-09-04 13:55:57 -04:00
FRenderResource::InitResource(RHICmdList);
Register/unregister FRayTracingGeometry with FRayTracingGeometryManager in Init/ReleaseResource - instead doing it in Init/ReleaseRHI - fixes RegisteredGeometries being modified while iterating over it due to InitRHIForDynamicRayTracing(...) internally calling Init/ReleaseRHI #jira UE-195457 #rb aleksander.netzel [CL 27888598 by tiago costa in ue5-main branch]
2023-09-14 14:36:39 -04:00
Don't register FRayTracingGeometry with GRayTracingGeometryManager if it's already registered. #rb aleksnader.netzel [CL 27918482 by tiago costa in ue5-main branch]
2023-09-15 12:02:44 -04:00
if (RayTracingGeometryHandle == INDEX_NONE)
{
Moved FRayTracingGeometryManager out of RenderCore - This will enable extending it to track which proxies use each FRayTracingGeometry/UStaticMesh in follow up changes. - Added new IRayTracingGeometryManagerInterface to RenderCore since FRayTracingGeometry also needs to interact with FRayTracingGeometryManager. #rb Yuriy.ODonnell [CL 29779645 by tiago costa in ue5-main branch]
2023-11-16 11:28:36 -05:00
RayTracingGeometryHandle = GRayTracingGeometryManager->RegisterRayTracingGeometry(this);
Don't register FRayTracingGeometry with GRayTracingGeometryManager if it's already registered. #rb aleksnader.netzel [CL 27918482 by tiago costa in ue5-main branch]
2023-09-15 12:02:44 -04:00
}
Resubmit check IsRayTracingAllowed() when creating or destroying FRayTracingGeometry. - using ensureMsgf instead of checkf #rb aleksander.netzel [CL 27588192 by tiago costa in ue5-main branch]
2023-09-04 13:55:57 -04:00
}
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
void FRayTracingGeometry::ReleaseResource()
{
Don't register FRayTracingGeometry with GRayTracingGeometryManager if it's already registered. #rb aleksnader.netzel [CL 27918482 by tiago costa in ue5-main branch]
2023-09-15 12:02:44 -04:00
ensureMsgf(IsRayTracingAllowed() || !IsInitialized(), TEXT("FRayTracingGeometry should only be initialized when Ray Tracing is allowed."));
Resubmit check IsRayTracingAllowed() when creating or destroying FRayTracingGeometry. - using ensureMsgf instead of checkf #rb aleksander.netzel [CL 27588192 by tiago costa in ue5-main branch]
2023-09-04 13:55:57 -04:00
Register/unregister FRayTracingGeometry with FRayTracingGeometryManager in Init/ReleaseResource - instead doing it in Init/ReleaseRHI - fixes RegisteredGeometries being modified while iterating over it due to InitRHIForDynamicRayTracing(...) internally calling Init/ReleaseRHI #jira UE-195457 #rb aleksander.netzel [CL 27888598 by tiago costa in ue5-main branch]
2023-09-14 14:36:39 -04:00
if (RayTracingGeometryHandle != INDEX_NONE)
{
Moved FRayTracingGeometryManager out of RenderCore - This will enable extending it to track which proxies use each FRayTracingGeometry/UStaticMesh in follow up changes. - Added new IRayTracingGeometryManagerInterface to RenderCore since FRayTracingGeometry also needs to interact with FRayTracingGeometryManager. #rb Yuriy.ODonnell [CL 29779645 by tiago costa in ue5-main branch]
2023-11-16 11:28:36 -05:00
GRayTracingGeometryManager->ReleaseRayTracingGeometryHandle(RayTracingGeometryHandle);
Register/unregister FRayTracingGeometry with FRayTracingGeometryManager in Init/ReleaseResource - instead doing it in Init/ReleaseRHI - fixes RegisteredGeometries being modified while iterating over it due to InitRHIForDynamicRayTracing(...) internally calling Init/ReleaseRHI #jira UE-195457 #rb aleksander.netzel [CL 27888598 by tiago costa in ue5-main branch]
2023-09-14 14:36:39 -04:00
RayTracingGeometryHandle = INDEX_NONE;
}
Only clear Initializer in FRayTracingGeometry::ReleaseResource() after calling FRenderResource::ReleaseResource() - this is the reverse order of logic used during initialization. - having valid Initializer during destruction prevents checks from failing incorrectly. [FYI] aleksander.netzel #rb Kenzo.Terelst [CL 33231647 by tiago costa in ue5-main branch]
2024-04-25 10:51:24 -04:00
FRenderResource::ReleaseResource();
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
// Release any resource references held by the initializer.
// This includes index and vertex buffers used for building the BLAS.
Initializer = FRayTracingGeometryInitializer{};
}
Moved an ensure into FRayTracingGeometry::HasPendingBuildRequest(). [CL 33233815 by tiago costa in ue5-main branch]
2024-04-25 12:03:10 -04:00
bool FRayTracingGeometry::HasPendingBuildRequest() const
{
const bool bHasPendingBuildRequest = RayTracingBuildRequestIndex != INDEX_NONE;
if (bHasPendingBuildRequest)
{
Modified FRayTracingGeometry::IsValid() to ignore whether the geometry is evicted. - higher level should explicitly check if geometry if is evicted and handle it approriately. - for example, dynamic geometry can usually ignore eviction state since BLAS will be rebuilt anyway. #rb Kenzo.Terelst [CL 33237221 by tiago costa in ue5-main branch]
2024-04-25 13:33:16 -04:00
ensure(IsValid() && !IsEvicted());
Moved an ensure into FRayTracingGeometry::HasPendingBuildRequest(). [CL 33233815 by tiago costa in ue5-main branch]
2024-04-25 12:03:10 -04:00
}
return bHasPendingBuildRequest;
}
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
void FRayTracingGeometry::BoostBuildPriority(float InBoostValue) const
{
check(HasPendingBuildRequest());
Moved FRayTracingGeometryManager out of RenderCore - This will enable extending it to track which proxies use each FRayTracingGeometry/UStaticMesh in follow up changes. - Added new IRayTracingGeometryManagerInterface to RenderCore since FRayTracingGeometry also needs to interact with FRayTracingGeometryManager. #rb Yuriy.ODonnell [CL 29779645 by tiago costa in ue5-main branch]
2023-11-16 11:28:36 -05:00
GRayTracingGeometryManager->BoostPriority(RayTracingBuildRequestIndex, InBoostValue);
Moving FRayTracingGeometry into its own header+source files. FRayTracingGeometry can't forward declare its RHI members yet, so we need it in its own header to remove those dependencies from RenderResource.h #rb tiago.costa #preflight 63897bc0976b1644cb2f7450 [CL 23377483 by christopher waters in ue5-main branch]
2022-12-02 15:09:41 -05:00
}
#endif // RHI_RAYTRACING
Deprecate public access to RayTracingGeometryRHI in FRayTracingGeometry. - use GetRHI() instead. [FYI] aleksander.netzel [CL 31843065 by tiago costa in ue5-main branch]
2024-02-27 11:57:07 -05:00
PRAGMA_ENABLE_DEPRECATION_WARNINGS
Reference in New Issue Copy Permalink