// Copyright Epic Games, Inc. All Rights Reserved.

/*=============================================================================
	RHICommandListCommandExecutes.inl: RHI Command List execute functions.
=============================================================================*/

#if !defined(INTERNAL_DECORATOR)
	#define INTERNAL_DECORATOR(Method) CmdList.GetContext().Method
#endif

//for functions where the signatures do not match between gfx and compute commandlists
#if !defined(INTERNAL_DECORATOR_COMPUTE)
#define INTERNAL_DECORATOR_COMPUTE(Method) CmdList.GetComputeContext().Method
#endif

class FRHICommandListBase;
class IRHIComputeContext;
struct FComputedBSS;
struct FComputedUniformBuffer;
struct FMemory;
struct FRHICommandBeginRenderQuery;
struct FRHICommandBuildLocalBoundShaderState;
struct FRHICommandBuildLocalGraphicsPipelineState;
struct FRHICommandBuildLocalUniformBuffer;
struct FRHICommandDrawIndexedIndirect;
struct FRHICommandDrawIndexedPrimitive;
struct FRHICommandDrawIndexedPrimitiveIndirect;
struct FRHICommandDrawPrimitive;
struct FRHICommandDrawPrimitiveIndirect;
struct FRHICommandMultiDrawPrimitiveIndirect;
struct FRHICommandSetDepthBounds;
struct FRHICommandEndDrawingViewport;
struct FRHICommandEndOcclusionQueryBatch;
struct FRHICommandEndRenderQuery;
struct FRHICommandSetBlendFactor;
struct FRHICommandSetBoundShaderState;
struct FRHICommandSetLocalGraphicsPipelineState;
struct FRHICommandSetRasterizerState;
struct FRHICommandSetRenderTargets;
struct FRHICommandSetRenderTargetsAndClear;
struct FRHICommandSetScissorRect;
struct FRHICommandSetStencilRef;
struct FRHICommandSetStereoViewport;
struct FRHICommandSetStreamSource;
struct FRHICommandSetViewport;
struct FRHICommandTransitionTextures;
struct FRHICommandTransitionTexturesPipeline;
struct FRHICommandTransitionTexturesDepth;
struct FRHICommandTransitionTexturesArray;
struct FRHICommandClearBindings;
struct FRHICommandRayTraceDispatch;
struct FRHICommandSetBindings;

template <typename TRHIShader> struct FRHICommandSetLocalUniformBuffer;

#if WITH_MGPU
void FRHICommandSetGPUMask::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetGPUMask);

	// Update the RHICmdList copy of the current mask
	CmdList.PersistentState.CurrentGPUMask = GPUMask;

	// Apply the new mask to all contexts owned by this command list.
	for (IRHIComputeContext* Context : CmdList.Contexts)
	{
		if (Context)
		{
			Context->RHISetGPUMask(GPUMask);
		}
	}
}

void FRHICommandTransferResources::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(TransferResources);
	INTERNAL_DECORATOR_COMPUTE(RHITransferResources)(Params);
}

void FRHICommandTransferResourceSignal::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(TransferResourceSignal);
	INTERNAL_DECORATOR_COMPUTE(RHITransferResourceSignal)(FenceDatas, SrcGPUMask);
}

void FRHICommandTransferResourceWait::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(TransferResourceWait);
	INTERNAL_DECORATOR_COMPUTE(RHITransferResourceWait)(FenceDatas);
}

void FRHICommandCrossGPUTransfer::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(CrossGPUTransfer);
	INTERNAL_DECORATOR_COMPUTE(RHICrossGPUTransfer)(Params, PreTransfer, PostTransfer);
}

void FRHICommandCrossGPUTransferSignal::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(CrossGPUTransferSignal);
	INTERNAL_DECORATOR_COMPUTE(RHICrossGPUTransferSignal)(Params, PreTransfer);
}

void FRHICommandCrossGPUTransferWait::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(CrossGPUTransferWait);
	INTERNAL_DECORATOR_COMPUTE(RHICrossGPUTransferWait)(SyncPoints);
}

#endif // WITH_MGPU

void FRHICommandSetStencilRef::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetStencilRef);
	INTERNAL_DECORATOR(RHISetStencilRef)(StencilRef);
}

template<> RHI_EXECUTE_API void FRHICommandSetShaderParameters<FRHIComputeShader>::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetShaderParameters);
	INTERNAL_DECORATOR_COMPUTE(RHISetShaderParameters)(Shader, ParametersData, Parameters, ResourceParameters, BindlessParameters);
}

template<> RHI_EXECUTE_API void FRHICommandSetShaderParameters<FRHIGraphicsShader>::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetShaderParameters);
	INTERNAL_DECORATOR(RHISetShaderParameters)(Shader, ParametersData, Parameters, ResourceParameters, BindlessParameters);
}

template<> RHI_EXECUTE_API void FRHICommandSetShaderUnbinds<FRHIComputeShader>::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetShaderUnbinds);
	INTERNAL_DECORATOR_COMPUTE(RHISetShaderUnbinds)(Shader, Unbinds);
}

template<> RHI_EXECUTE_API void FRHICommandSetShaderUnbinds<FRHIGraphicsShader>::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetShaderUnbinds);
	INTERNAL_DECORATOR(RHISetShaderUnbinds)(Shader, Unbinds);
}

void FRHICommandDrawPrimitive::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DrawPrimitive);
	INTERNAL_DECORATOR(RHIDrawPrimitive)(BaseVertexIndex, NumPrimitives, NumInstances);
}

void FRHICommandDrawIndexedPrimitive::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DrawIndexedPrimitive);
	INTERNAL_DECORATOR(RHIDrawIndexedPrimitive)(IndexBuffer, BaseVertexIndex, FirstInstance, NumVertices, StartIndex, NumPrimitives, NumInstances);
}

void FRHICommandSetBlendFactor::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetBlendFactor);
	INTERNAL_DECORATOR(RHISetBlendFactor)(BlendFactor);
}

void FRHICommandSetStreamSource::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetStreamSource);
	INTERNAL_DECORATOR(RHISetStreamSource)(StreamIndex, VertexBuffer, Offset);
}

void FRHICommandSetViewport::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetViewport);
	INTERNAL_DECORATOR(RHISetViewport)(MinX, MinY, MinZ, MaxX, MaxY, MaxZ);
}

void FRHICommandSetStereoViewport::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetStereoViewport);
	INTERNAL_DECORATOR(RHISetStereoViewport)(LeftMinX, RightMinX, LeftMinY, RightMinY, MinZ, LeftMaxX, RightMaxX, LeftMaxY, RightMaxY, MaxZ);
}

void FRHICommandSetScissorRect::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetScissorRect);
	INTERNAL_DECORATOR(RHISetScissorRect)(bEnable, MinX, MinY, MaxX, MaxY);
}

void FRHICommandBeginRenderPass::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(BeginRenderPass);
	INTERNAL_DECORATOR(RHIBeginRenderPass)(Info, Name);
}

void FRHICommandEndRenderPass::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EndRenderPass);
	INTERNAL_DECORATOR(RHIEndRenderPass)();
}

void FRHICommandNextSubpass::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(NextSubpass);
	INTERNAL_DECORATOR(RHINextSubpass)();
}

void FRHICommandSetComputePipelineState::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetComputePipelineState);
	extern RHI_API FRHIComputePipelineState* ExecuteSetComputePipelineState(FComputePipelineState* ComputePipelineState);
	FRHIComputePipelineState* RHIComputePipelineState = ExecuteSetComputePipelineState(ComputePipelineState);
	INTERNAL_DECORATOR_COMPUTE(RHISetComputePipelineState)(RHIComputePipelineState);
}

void FRHICommandSetGraphicsPipelineState::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetGraphicsPipelineState);
	extern FRHIGraphicsPipelineState* ExecuteSetGraphicsPipelineState(FGraphicsPipelineState* GraphicsPipelineState);
	FRHIGraphicsPipelineState* RHIGraphicsPipelineState = ExecuteSetGraphicsPipelineState(GraphicsPipelineState);
	INTERNAL_DECORATOR(RHISetGraphicsPipelineState)(RHIGraphicsPipelineState, StencilRef, bApplyAdditionalState);
}

#if PLATFORM_USE_FALLBACK_PSO
void FRHICommandSetGraphicsPipelineStateFromInitializer::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetGraphicsPipelineStateFromInitializer);
	INTERNAL_DECORATOR(RHISetGraphicsPipelineState)(PsoInit, StencilRef, bApplyAdditionalState);
}
#endif

void FRHICommandDispatchComputeShader::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DispatchComputeShader);
	INTERNAL_DECORATOR_COMPUTE(RHIDispatchComputeShader)(ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ);
}

void FRHICommandDispatchIndirectComputeShader::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DispatchIndirectComputeShader);
	INTERNAL_DECORATOR_COMPUTE(RHIDispatchIndirectComputeShader)(ArgumentBuffer, ArgumentOffset);
}

void FRHICommandDispatchComputeShaderBundle::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DispatchShaderBundle);
	extern RHI_API FRHIComputePipelineState* ExecuteSetComputePipelineState(FComputePipelineState* ComputePipelineState);
	for (int32 DispatchIndex = 0; DispatchIndex < Dispatches.Num(); ++DispatchIndex)
	{
		FRHIShaderBundleComputeDispatch& Dispatch = Dispatches[DispatchIndex];
#if !PLATFORM_USE_FALLBACK_PSO
		if (Dispatch.RecordIndex != ~uint32(0u) && Dispatch.PipelineState)
		{
			Dispatch.RHIPipeline = ExecuteSetComputePipelineState(Dispatch.PipelineState);
		}
#endif
	}
	INTERNAL_DECORATOR_COMPUTE(RHIDispatchComputeShaderBundle)(ShaderBundle, RecordArgBuffer, SharedBindlessParameters, Dispatches, bEmulated);
}

void FRHICommandDispatchGraphicsShaderBundle::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DispatchShaderBundle);
	extern RHI_API FRHIGraphicsPipelineState* ExecuteSetGraphicsPipelineState(FGraphicsPipelineState* GraphicsPipelineState);
	for (int32 DispatchIndex = 0; DispatchIndex < Dispatches.Num(); ++DispatchIndex)
	{
		FRHIShaderBundleGraphicsDispatch& Dispatch = Dispatches[DispatchIndex];
#if !PLATFORM_USE_FALLBACK_PSO
		if (Dispatch.RecordIndex != ~uint32(0u) && Dispatch.PipelineState)
		{
			Dispatch.RHIPipeline = ExecuteSetGraphicsPipelineState(Dispatch.PipelineState);
		}
#endif
	}
	INTERNAL_DECORATOR_COMPUTE(RHIDispatchGraphicsShaderBundle)(ShaderBundle, RecordArgBuffer, BundleState, SharedBindlessParameters, Dispatches, bEmulated);
}

void FRHICommandSetShaderRootConstants::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetShaderRootConstants);
	INTERNAL_DECORATOR_COMPUTE(RHISetShaderRootConstants)(Constants);
}

void FRHICommandBeginUAVOverlap::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(BeginUAVOverlap);
	INTERNAL_DECORATOR_COMPUTE(RHIBeginUAVOverlap)();
}

void FRHICommandEndUAVOverlap::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EndUAVOverlap);
	INTERNAL_DECORATOR_COMPUTE(RHIEndUAVOverlap)();
}

void FRHICommandBeginSpecificUAVOverlap::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(BeginSpecificUAVOverlap);
	INTERNAL_DECORATOR_COMPUTE(RHIBeginUAVOverlap)(UAVs);
}

void FRHICommandEndSpecificUAVOverlap::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EndSpecificUAVOverlap);
	INTERNAL_DECORATOR_COMPUTE(RHIEndUAVOverlap)(UAVs);
}

void FRHICommandDrawPrimitiveIndirect::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DrawPrimitiveIndirect);
	INTERNAL_DECORATOR(RHIDrawPrimitiveIndirect)(ArgumentBuffer, ArgumentOffset);
}

void FRHICommandDrawIndexedIndirect::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DrawIndexedIndirect);
	INTERNAL_DECORATOR(RHIDrawIndexedIndirect)(IndexBufferRHI, ArgumentsBufferRHI, DrawArgumentsIndex, NumInstances);
}

void FRHICommandDrawIndexedPrimitiveIndirect::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DrawIndexedPrimitiveIndirect);
	INTERNAL_DECORATOR(RHIDrawIndexedPrimitiveIndirect)(IndexBuffer, ArgumentsBuffer, ArgumentOffset);
}

void FRHICommandMultiDrawIndexedPrimitiveIndirect::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(MultiDrawIndexedPrimitiveIndirect);
	INTERNAL_DECORATOR(RHIMultiDrawIndexedPrimitiveIndirect)(IndexBuffer, ArgumentBuffer, ArgumentOffset, CountBuffer, CountBufferOffset, MaxDrawArguments);
}

void FRHICommandDispatchMeshShader::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DispatchMeshShader);
	INTERNAL_DECORATOR(RHIDispatchMeshShader)(ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ);
}

void FRHICommandDispatchIndirectMeshShader::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DispatchIndirectMeshShader);
	INTERNAL_DECORATOR(RHIDispatchIndirectMeshShader)(ArgumentBuffer, ArgumentOffset);
}

void FRHICommandSetShadingRate::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetShadingRate);
	INTERNAL_DECORATOR(RHISetShadingRate)(ShadingRate, Combiner);
}

void FRHICommandSetDepthBounds::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EnableDepthBoundsTest);
	INTERNAL_DECORATOR(RHISetDepthBounds)(MinDepth, MaxDepth);
}

void FRHIGpuHangCommandListCorruption::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(GpuHangCommandListCorruption);
	INTERNAL_DECORATOR(RHIGpuHangCommandListCorruption)();
}

void FRHICommandClearUAVFloat::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(ClearUAV);
	INTERNAL_DECORATOR_COMPUTE(RHIClearUAVFloat)(UnorderedAccessViewRHI, Values);
}

void FRHICommandClearUAVUint::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(ClearUAV);
	INTERNAL_DECORATOR_COMPUTE(RHIClearUAVUint)(UnorderedAccessViewRHI, Values);
}

void FRHICommandCopyTexture::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(CopyTexture);
	INTERNAL_DECORATOR(RHICopyTexture)(SourceTexture, DestTexture, CopyInfo);
}

void FRHICommandResummarizeHTile::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(ResummarizeHTile);
	INTERNAL_DECORATOR(RHIResummarizeHTile)(DepthTexture);
}

void FRHICommandBeginTransitions::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(BeginTransitions);

	INTERNAL_DECORATOR_COMPUTE(RHIBeginTransitions)(Transitions);

	for (const FRHITransition* Transition : Transitions)
	{
		Transition->MarkBegin(CmdList.GetPipeline());
	}
}

void FRHICommandEndTransitions::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EndTransitions);

	INTERNAL_DECORATOR_COMPUTE(RHIEndTransitions)(Transitions);

	for (const FRHITransition* Transition : Transitions)
	{
		Transition->MarkEnd(CmdList.GetPipeline());
	}
}

void FRHICommandResourceTransition::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(ResourceTransition);

	INTERNAL_DECORATOR_COMPUTE(RHIBeginTransitions)(MakeArrayView((const FRHITransition**)&Transition, 1));
	INTERNAL_DECORATOR_COMPUTE(RHIEndTransitions)(MakeArrayView((const FRHITransition**)&Transition, 1));

	Transition->Cleanup();
}

void FRHICommandSetTrackedAccess::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetTrackedAccess);
	for (const FRHITrackedAccessInfo& Info : Infos)
	{
		INTERNAL_DECORATOR_COMPUTE(SetTrackedAccess)(Info);
	}
}

void FRHICommandSetAsyncComputeBudget::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetAsyncComputeBudget);
	INTERNAL_DECORATOR_COMPUTE(RHISetAsyncComputeBudget)(Budget);
}

void FRHICommandSetComputeBudget::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetComputeBudget);
	INTERNAL_DECORATOR(RHISetComputeBudget)(Budget);
}

void FRHICommandCopyToStagingBuffer::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EnqueueStagedRead);
	INTERNAL_DECORATOR_COMPUTE(RHICopyToStagingBuffer)(SourceBuffer, DestinationStagingBuffer, Offset, NumBytes);
}

void FRHICommandWriteGPUFence::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(WriteGPUFence);
	INTERNAL_DECORATOR_COMPUTE(RHIWriteGPUFence)(Fence);
	if (Fence)
	{
		Fence->NumPendingWriteCommands.Decrement();
	}
}

void FRHICommandSetStaticUniformBuffers::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetStaticUniformBuffers);
	INTERNAL_DECORATOR_COMPUTE(RHISetStaticUniformBuffers)(UniformBuffers);
}

void FRHICommandSetStaticUniformBuffer::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetStaticUniformBuffer);
	INTERNAL_DECORATOR_COMPUTE(RHISetStaticUniformBuffer)(Slot, Buffer);
}

void FRHICommandSetUniformBufferDynamicOffset::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetUniformBufferDynamicOffset);
	INTERNAL_DECORATOR(RHISetUniformBufferDynamicOffset)(Slot, Offset);
}

void FRHICommandBeginRenderQuery::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(BeginRenderQuery);
	INTERNAL_DECORATOR(RHIBeginRenderQuery)(RenderQuery);
}

void FRHICommandEndRenderQuery::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EndRenderQuery);
	INTERNAL_DECORATOR(RHIEndRenderQuery)(RenderQuery);
}

#if (RHI_NEW_GPU_PROFILER == 0)
void FRHICommandCalibrateTimers::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(CalibrateTimers);
	INTERNAL_DECORATOR(RHICalibrateTimers)(CalibrationQuery);
}
#endif

void FRHICommandPostExternalCommandsReset::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(PostExternalCommandsReset);
	INTERNAL_DECORATOR(RHIPostExternalCommandsReset)();
}

void FRHICommandCopyBufferRegion::Execute(FRHICommandListBase& CmdList)
{
	INTERNAL_DECORATOR(RHICopyBufferRegion)(DestBuffer, DstOffset, SourceBuffer, SrcOffset, NumBytes);
}

void FRHICommandBindAccelerationStructureMemory::Execute(FRHICommandListBase& CmdList)
{
	INTERNAL_DECORATOR_COMPUTE(RHIBindAccelerationStructureMemory)(Scene, Buffer, BufferOffset);
}

void FRHICommandBuildSceneAccelerationStructures::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(BuildAccelerationStructure);
	INTERNAL_DECORATOR_COMPUTE(RHIBuildAccelerationStructures)(Params);
}

void FRHICommandCommitShaderBindingTable::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(CommitShaderBindingTable);
	INTERNAL_DECORATOR(RHICommitShaderBindingTable)(SBT, InlineBindingDataBuffer);
}

void FRHICommandClearShaderBindingTable::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(ClearShaderBindingTable);
	INTERNAL_DECORATOR(RHIClearShaderBindingTable)(SBT);
}

void FRHICommandBuildAccelerationStructures::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(BuildAccelerationStructure);
	INTERNAL_DECORATOR_COMPUTE(RHIBuildAccelerationStructures)(Params, ScratchBufferRange);
}

void FRHICommandExecuteMultiIndirectClusterOperation::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(ExecuteMultiIndirectClusterOperation);
	INTERNAL_DECORATOR_COMPUTE(RHIExecuteMultiIndirectClusterOperation)(Params);
}

void FRHICommandRayTraceDispatch::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(RayTraceDispatch);
	extern RHI_API FRHIRayTracingPipelineState* GetRHIRayTracingPipelineState(FRayTracingPipelineState*);
	
	FRHIRayTracingPipelineState* RayTracingPipelineState = GetRHIRayTracingPipelineState(Pipeline);

	if (ArgumentBuffer)
	{
		INTERNAL_DECORATOR_COMPUTE(RHIRayTraceDispatchIndirect)(RayTracingPipelineState, RayGenShader, SBT, GlobalResourceBindings, ArgumentBuffer, ArgumentOffset);
	}
	else
	{
		INTERNAL_DECORATOR_COMPUTE(RHIRayTraceDispatch)(RayTracingPipelineState, RayGenShader, SBT, GlobalResourceBindings, Width, Height);
	}
}

void FRHICommandSetBindingsOnShaderBindingTable::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetRayTracingHitGroup);
	extern RHI_API FRHIRayTracingPipelineState* GetRHIRayTracingPipelineState(FRayTracingPipelineState*);
	
	FRHIRayTracingPipelineState* RayTracingPipelineState = GetRHIRayTracingPipelineState(Pipeline);

	INTERNAL_DECORATOR(RHISetBindingsOnShaderBindingTable)(SBT, RayTracingPipelineState, NumBindings, Bindings, BindingType);
}

void FRHICommandEndDrawingViewport::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(EndDrawingViewport);
	INTERNAL_DECORATOR(RHIEndDrawingViewport)(Viewport, bPresent, bLockToVsync);
}