【UE源码分析】PSOcache预编译的源码流程分析

最新推荐文章于 2024-08-16 18:57:09 发布
最新推荐文章于 2024-08-16 18:57:09 发布
阅读量799 收藏 13
点赞数 30
分类专栏： # PSO功能 文章标签： ue4 游戏引擎 游戏 游戏程序 ue5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47309438/article/details/137554319
版权

温(mian)馨(ze)提(sheng)示(ming):

  1. 此文是个人学习过程记录，内容质量差
  2. 今天刚好学习UE一个月，本文是作为前两篇的笔记补全计划^ ^
  3. 本来一开始只是看看PSO背后的代码逻辑，没想到本来一两篇笔记就能搞好的，我写了好几篇
  4. 经过对PSO预编译流程的梳理，从一开始不知道怎么读代码到能捋清一个模块确实收获很多，但看到源码后也深感自己的不足，自己远没有能总结出像样的笔记的能力，所以暂时以后也不更新了^^
  5. 立个flag，我要当图形学和游戏引擎糕手！明年九月我要去拯救世界！

初始化PSO

int32 FEngineLoop::PreInitPreStartupScreen(const TCHAR* CmdLine)启动屏幕的预处理的前处理

​ void FShaderPipelineCache::Initialize(EShaderPlatform Platform)在这里初始化ShaderPipelineCache并且根据平台创建FShaderPipelineCache

​ void FPipelineFileCache::Initialize(uint32 InGameVersion)在这里初始化PipelineFileCache

int32 FEngineLoop::PreInitPreStartupScreen(const TCHAR* CmdLine)启动屏幕的预处理的后处理

​ bool FShaderPipelineCache::OpenPipelineFileCache(EShaderPlatform Platform)在这里面调用了一图流靠近右上角的open函数

​ bool FShaderPipelineCache::Open(FString const& Name, EShaderPlatform Platform)除了调用FPipelineFileCache::OpenPipelineFileCache以外，还创建了LocalPreFetchedTasks来为后续做准备

​ bool FPipelineFileCache::OpenPipelineFileCache(FString const& Name, EShaderPlatform Platform, FGuid& OutGameFileGuid)就是在这里面创建了TOC

​

对编译任务做准备

void FShaderPipelineCache::Tick( float DeltaTime )这一步是每帧都在做的，对准备编译任务来说，核心部分是以下代码：

	if (ReadyForNextBatch() && (OrderedCompileTasks.Num() || FetchTasks.Num()))
	{
        uint32 Num = 0;
        if (BatchSize > static_cast<uint32>(FetchTasks.Num()))
        {
            Num = BatchSize - FetchTasks.Num();
        }
        Num = FMath::Min(Num, (uint32)OrderedCompileTasks.Num());
            
		if (FetchTasks.Num() < (int32)Num)
		{
			TDoubleLinkedList<FPipelineCacheFileFormatPSORead*> NewBatch;
		
			Num -= FetchTasks.Num();
            for (auto Iterator = OrderedCompileTasks.CreateIterator(); Iterator && Num > 0; ++Iterator)
            {
                bool bHasShaders = true;
                for (FSHAHash const& Hash : Iterator->Shaders)
                {
                    bHasShaders &= FShaderCodeLibrary::ContainsShaderCode(Hash);
                }
            	if (bHasShaders)
            	{
            		FPipelineCacheFileFormatPSORead* Entry = new FPipelineCacheFileFormatPSORead;
					Entry->Hash = Iterator->Hash;
					Entry->Ar = new FShaderPipelineCacheArchive;
					
					// Add to both new batch and fetch lists
					NewBatch.AddTail(Entry);
					FetchTasks.AddTail(Entry);
					
	            	Iterator.RemoveCurrent();
                    FPlatformAtomics::InterlockedIncrement(&TotalActiveTasks);
                    FPlatformAtomics::InterlockedDecrement(&TotalWaitingTasks);
                    --Num;
            	}
            }
			
			FPipelineFileCache::FetchPSODescriptors(NewBatch);
		}

        if (static_cast<uint32>(FetchTasks.Num()) > BatchSize)
        {
            UE_LOG(LogRHI, Warning, TEXT("FShaderPipelineCache: Attempting to pre-compile more jobs (%d) than the batch size (%d)"), FetchTasks.Num(), BatchSize);
        }
        
		PreparePipelineBatch(FetchTasks);
	}

主要干了四个事情：判断和添加读取的数量，预取ShaderCodeLibrary，取得相应PSO的描述符，准备管线Batch

​ void FPipelineFileCache::FetchPSODescriptors(TDoubleLinkedList<FPipelineCacheFileFormatPSORead*>& Batch) 从这里获取之前准备好的TOC的数据

​ void FShaderPipelineCache::PreparePipelineBatch(TDoubleLinkedList<FPipelineCacheFileFormatPSORead*>& PipelineBatch) 在这里面通过FShaderCodeLibrary::PreloadShader函数来预加载PSO的shader，如果加载成功就把异步读取的任务加入到ReadTasks中

预编译PSO

void FShaderPipelineCache::Tick( float DeltaTime )，对这一步来说，核心是以下代码：

	if (ReadyForPrecompile())
	{
		SCOPE_SECONDS_ACCUMULATOR(STAT_PreCompileTotalTime);
		SCOPE_CYCLE_COUNTER(STAT_PreCompileTime);
		
		uint32 Start = FPlatformTime::Cycles();

		PrecompilePipelineBatch();

		uint32 End = FPlatformTime::Cycles();

		if (BatchTime > 0.0f)
		{
			float ElapsedMs = FPlatformTime::ToMilliseconds(End - Start);
			if (ElapsedMs < BatchTime)
			{
				BatchSize++;
			}
			else if (ElapsedMs > BatchTime)
			{
				if (BatchSize > 1)
				{
					BatchSize--;
				}
				else
				{
					UE_LOG(LogRHI, Warning, TEXT("FShaderPipelineCache: Cannot reduce BatchSize below 1 to meet target of %f ms, elapsed time was %f ms)"), BatchTime, ElapsedMs);
				}
			}
		}
	}

主要干了两个事情，第一个是调用PrecompilePipelineBatch，第二个是动态调节BatchSize的大小

​ void FShaderPipelineCache::PrecompilePipelineBatch() 这个函数是判断了CompileTasks和BatchSize的最小值后调用可以用上的最多的CompileTasks来通过Precompile函数进行预编译

​ bool FShaderPipelineCache::Precompile(FRHICommandListImmediate& RHICmdList, EShaderPlatform Platform, FPipelineCacheFileFormatPSO const& PSO) 这里就是进行了预编译，核心代码如下：

		if(FPipelineCacheFileFormatPSO::DescriptorType::Graphics == PSO.Type)
		{
			FGraphicsPipelineStateInitializer GraphicsInitializer;
			
			FRHIVertexDeclaration* VertexDesc = PipelineStateCache::GetOrCreateVertexDeclaration(PSO.GraphicsDesc.VertexDescriptor);
			GraphicsInitializer.BoundShaderState.VertexDeclarationRHI = VertexDesc;
			
			FVertexShaderRHIRef VertexShader;
			if (PSO.GraphicsDesc.VertexShader != FSHAHash())
			{
				VertexShader = FShaderCodeLibrary::CreateVertexShader(Platform, PSO.GraphicsDesc.VertexShader);
				GraphicsInitializer.BoundShaderState.VertexShaderRHI = VertexShader;
			}

	#if PLATFORM_SUPPORTS_TESSELLATION_SHADERS
			FHullShaderRHIRef HullShader;
			if (PSO.GraphicsDesc.HullShader != FSHAHash())
			{
				HullShader = FShaderCodeLibrary::CreateHullShader(Platform, PSO.GraphicsDesc.HullShader);
				GraphicsInitializer.BoundShaderState.HullShaderRHI = HullShader;
			}

			FDomainShaderRHIRef DomainShader;
			if (PSO.GraphicsDesc.DomainShader != FSHAHash())
			{
				DomainShader = FShaderCodeLibrary::CreateDomainShader(Platform, PSO.GraphicsDesc.DomainShader);
				GraphicsInitializer.BoundShaderState.DomainShaderRHI = DomainShader;
			}
	#endif
			FPixelShaderRHIRef FragmentShader;
			if (PSO.GraphicsDesc.FragmentShader != FSHAHash())
			{
				FragmentShader = FShaderCodeLibrary::CreatePixelShader(Platform, PSO.GraphicsDesc.FragmentShader);
				GraphicsInitializer.BoundShaderState.PixelShaderRHI = FragmentShader;
			}

	#if PLATFORM_SUPPORTS_GEOMETRY_SHADERS
			FGeometryShaderRHIRef GeometryShader;
			if (PSO.GraphicsDesc.GeometryShader != FSHAHash())
			{
				GeometryShader = FShaderCodeLibrary::CreateGeometryShader(Platform, PSO.GraphicsDesc.GeometryShader);
				GraphicsInitializer.BoundShaderState.GeometryShaderRHI = GeometryShader;
			}
	#endif
			auto BlendState = GetOrCreateBlendState(PSO.GraphicsDesc.BlendState);
			GraphicsInitializer.BlendState = BlendState;
			
			auto RasterState = GetOrCreateRasterizerState(PSO.GraphicsDesc.RasterizerState);
			GraphicsInitializer.RasterizerState = RasterState;
			
			auto DepthState = GetOrCreateDepthStencilState(PSO.GraphicsDesc.DepthStencilState);
			GraphicsInitializer.DepthStencilState = DepthState;

			for (uint32 i = 0; i < MaxSimultaneousRenderTargets; ++i)
			{
				GraphicsInitializer.RenderTargetFormats[i] = PSO.GraphicsDesc.RenderTargetFormats[i];
				GraphicsInitializer.RenderTargetFlags[i] = PSO.GraphicsDesc.RenderTargetFlags[i];
			}
			
			GraphicsInitializer.RenderTargetsEnabled = PSO.GraphicsDesc.RenderTargetsActive;
			GraphicsInitializer.NumSamples = PSO.GraphicsDesc.MSAASamples;

			GraphicsInitializer.SubpassHint = (ESubpassHint)PSO.GraphicsDesc.SubpassHint;
			GraphicsInitializer.SubpassIndex = PSO.GraphicsDesc.SubpassIndex;
			
			GraphicsInitializer.DepthStencilTargetFormat = PSO.GraphicsDesc.DepthStencilFormat;
			GraphicsInitializer.DepthStencilTargetFlag = PSO.GraphicsDesc.DepthStencilFlags;
			GraphicsInitializer.DepthTargetLoadAction = PSO.GraphicsDesc.DepthLoad;
			GraphicsInitializer.StencilTargetLoadAction = PSO.GraphicsDesc.StencilLoad;
			GraphicsInitializer.DepthTargetStoreAction = PSO.GraphicsDesc.DepthStore;
			GraphicsInitializer.StencilTargetStoreAction = PSO.GraphicsDesc.StencilStore;
			
			GraphicsInitializer.PrimitiveType = PSO.GraphicsDesc.PrimitiveType;
			GraphicsInitializer.bFromPSOFileCache = true;
			
			// This indicates we do not want a fatal error if this compilation fails
			// (ie, if this entry in the file cache is bad)
			GraphicsInitializer.bFromPSOFileCache = 1;
			
			// Use SetGraphicsPipelineState to call down into PipelineStateCache and also handle the fallback case used by OpenGL.
			SetGraphicsPipelineState(RHICmdList, GraphicsInitializer, EApplyRendertargetOption::DoNothing, false);
			bOk = true;
		}

这里先是创建了FGraphicsPipelineStateInitializer GraphicsInitializer，然后分别设置其BoundShaderState、BlendState、RasterizerState、DepthStencilState等等很多东西，不过我之前看的是OpenGL的，由于OpenGL没有PSO的概念，虽然PSO也收集了，但是只会用到BoundShaderState。收集完后会调用SetGraphicsPipelineState函数

​ void SetGraphicsPipelineState(FRHICommandList& RHICmdList, const FGraphicsPipelineStateInitializer& Initializer, EApplyRendertargetOption ApplyFlags, bool bApplyAdditionalState) 这个函数主要干两个事情，第一个是调用GetAndOrCreateGraphicsPipelineState函数来创建真正的PSO，然后调用SetGraphicsPipelineState设置管线状态

​ FGraphicsPipelineState* PipelineStateCache::GetAndOrCreateGraphicsPipelineState(FRHICommandList& RHICmdList, const FGraphicsPipelineStateInitializer& OriginalInitializer, EApplyRendertargetOption ApplyFlags) 从这个函数里面去取得或者创建PSO，重点部分如下：

		if (DoAsyncCompile)
		{
			OutCachedState->CompletionEvent = TGraphTask<FCompilePipelineStateTask>::CreateTask().ConstructAndDispatchWhenReady(OutCachedState, *Initializer);
			RHICmdList.AddDispatchPrerequisite(OutCachedState->CompletionEvent);
		}
		else
		{
			OutCachedState->RHIPipeline = RHICreateGraphicsPipelineState(*Initializer);
			if(!OutCachedState->RHIPipeline)
			{
				HandlePipelineCreationFailure(*Initializer);
			}
		}

如果使用异步编译的话，启动一个异步任务来编译渲染管线状态，并确保在这个状态编译完成之前，任何依赖于它的渲染命令都不会被执行。不使用的话就通过RHICreateGraphicsPipelineState来执行，这就和之前的笔记PSO函数调用对接上了^^

​ FORCEINLINE_DEBUGGABLE void SetGraphicsPipelineState(class FGraphicsPipelineState* GraphicsPipelineState, const FBoundShaderStateInput& ShaderInput, bool bApplyAdditionalState)这个函数首先通过ExecuteSetGraphicsPipelineState来获得RHIGraphicsPipelineState，接着通过RHISetGraphicsPipelineState来调用RHISetGraphicsPipelineState，紧接着里面会调用RHISetBoundShaderState，这也和之前笔记的PSO函数调用对接上了^^

mesh使用PSO的流程

首先要了解meshdrawingpipeline

MeshDrawingPipeline

在这里插入图片描述

网格体渲染从"FPrimitiveSceneProxy"开始，这是游戏线程的"UPrimitiveComponent"渲染线程表示。"FPrimitiveSceneProxy"负责通过对"GetDynamicMeshElements"和"DrawStaticElements"的回调将FMeshBatch提交给渲染器。

"FMeshBatch"包含了通道确定最终着色器绑定和渲染状态所需的所有内容。

下一步是将"FMeshBatch"转换为一个特定于网格体通道的"FMeshDrawCommand"。"FMeshDrawCommand"是"FMeshBatch"和RHI之间的接口。它是一个完全无状态的绘制描述，存储了RHI需要知道的关于网格体绘制的所有信息。"FMeshDrawCommand"是由一个特定于网格体通道的"FMeshPassProcessor"根据"FMeshBatch"创建的。

最后，"SubmitMeshDrawCommands"用于将"FMeshDrawCommand"转换为RHICommandList上设置的一系列RHI命令。

我们的重点是MeshDrawingPipeline中是怎么和PSO扯上关系的，所以从BuildMeshDrawCommands这步开始

BuildMeshDrawCommands

因为每个"FMeshPassProcessor"必须通过"BuildMeshDrawCommands()“来调用通道着色器的"GetShaderBindings()”，所以通过"ShaderElementData"参数到"BuildMeshDrawCommands()"来将任意数据从"FMeshPassProcessor"传递到"GetShaderBindings()"调用。

template<typename PassShadersType, typename ShaderElementDataType>
void FMeshPassProcessor::BuildMeshDrawCommands(
	const FMeshBatch& RESTRICT MeshBatch,
	uint64 BatchElementMask,
	const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy,
	const FMaterialRenderProxy& RESTRICT MaterialRenderProxy,
	const FMaterial& RESTRICT MaterialResource,
	const FMeshPassProcessorRenderState& RESTRICT DrawRenderState,
	PassShadersType PassShaders,
	ERasterizerFillMode MeshFillMode,
	ERasterizerCullMode MeshCullMode,
	FMeshDrawCommandSortKey SortKey,
	EMeshPassFeatures MeshPassFeatures,
	const ShaderElementDataType& ShaderElementData)
{
	const FVertexFactory* RESTRICT VertexFactory = MeshBatch.VertexFactory;
	const FPrimitiveSceneInfo* RESTRICT PrimitiveSceneInfo = PrimitiveSceneProxy ? PrimitiveSceneProxy->GetPrimitiveSceneInfo() : nullptr;

	FMeshDrawCommand SharedMeshDrawCommand;

	SharedMeshDrawCommand.SetStencilRef(DrawRenderState.GetStencilRef());

	FGraphicsMinimalPipelineStateInitializer PipelineState;
	PipelineState.PrimitiveType = (EPrimitiveType)MeshBatch.Type;
	PipelineState.ImmutableSamplerState = MaterialRenderProxy.ImmutableSamplerState;

	EVertexInputStreamType InputStreamType = EVertexInputStreamType::Default;
	if ((MeshPassFeatures & EMeshPassFeatures::PositionOnly) != EMeshPassFeatures::Default)				InputStreamType = EVertexInputStreamType::PositionOnly;
	if ((MeshPassFeatures & EMeshPassFeatures::PositionAndNormalOnly) != EMeshPassFeatures::Default)	InputStreamType = EVertexInputStreamType::PositionAndNormalOnly;

	check(VertexFactory && VertexFactory->IsInitialized());
	FRHIVertexDeclaration* VertexDeclaration = VertexFactory->GetDeclaration(InputStreamType);

	check(!VertexFactory->NeedsDeclaration() || VertexDeclaration);

	SharedMeshDrawCommand.SetShaders(VertexDeclaration, PassShaders.GetUntypedShaders(), PipelineState);

	PipelineState.RasterizerState = GetStaticRasterizerState<true>(MeshFillMode, MeshCullMode);

	check(DrawRenderState.GetDepthStencilState());
	check(DrawRenderState.GetBlendState());

	PipelineState.BlendState = DrawRenderState.GetBlendState();
	PipelineState.DepthStencilState = DrawRenderState.GetDepthStencilState();
   	PipelineState.DrawShadingRate = GetShadingRateFromMaterial(MaterialResource.GetShadingRate());

	check(VertexFactory && VertexFactory->IsInitialized());
	VertexFactory->GetStreams(FeatureLevel, InputStreamType, SharedMeshDrawCommand.VertexStreams);

	SharedMeshDrawCommand.PrimitiveIdStreamIndex = VertexFactory->GetPrimitiveIdStreamIndex(InputStreamType);

	int32 DataOffset = 0;
	if (PassShaders.VertexShader.IsValid())
	{
		FMeshDrawSingleShaderBindings ShaderBindings = SharedMeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Vertex, DataOffset);
		PassShaders.VertexShader->GetShaderBindings(Scene, FeatureLevel, PrimitiveSceneProxy, MaterialRenderProxy, MaterialResource, DrawRenderState, ShaderElementData, ShaderBindings);
	}

	if (PassShaders.HullShader.IsValid() & PassShaders.DomainShader.IsValid())
	{
		FMeshDrawSingleShaderBindings HullShaderBindings = SharedMeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Hull, DataOffset);
		FMeshDrawSingleShaderBindings DomainShaderBindings = SharedMeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Domain, DataOffset);
		PassShaders.HullShader->GetShaderBindings(Scene, FeatureLevel, PrimitiveSceneProxy, MaterialRenderProxy, MaterialResource, DrawRenderState, ShaderElementData, HullShaderBindings);
		PassShaders.DomainShader->GetShaderBindings(Scene, FeatureLevel, PrimitiveSceneProxy, MaterialRenderProxy, MaterialResource, DrawRenderState, ShaderElementData, DomainShaderBindings);
	}

	if (PassShaders.PixelShader.IsValid())
	{
		FMeshDrawSingleShaderBindings ShaderBindings = SharedMeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Pixel, DataOffset);
		PassShaders.PixelShader->GetShaderBindings(Scene, FeatureLevel, PrimitiveSceneProxy, MaterialRenderProxy, MaterialResource, DrawRenderState, ShaderElementData, ShaderBindings);
	}

	if (PassShaders.GeometryShader.IsValid())
	{
		FMeshDrawSingleShaderBindings ShaderBindings = SharedMeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Geometry, DataOffset);
		PassShaders.GeometryShader->GetShaderBindings(Scene, FeatureLevel, PrimitiveSceneProxy, MaterialRenderProxy, MaterialResource, DrawRenderState, ShaderElementData, ShaderBindings);
	}

	SharedMeshDrawCommand.SetDebugData(PrimitiveSceneProxy, &MaterialResource, &MaterialRenderProxy, PassShaders.GetUntypedShaders(), VertexFactory);

	const int32 NumElements = MeshBatch.Elements.Num();

	for (int32 BatchElementIndex = 0; BatchElementIndex < NumElements; BatchElementIndex++)
	{
		if ((1ull << BatchElementIndex) & BatchElementMask)
		{
			const FMeshBatchElement& BatchElement = MeshBatch.Elements[BatchElementIndex];
			FMeshDrawCommand& MeshDrawCommand = DrawListContext->AddCommand(SharedMeshDrawCommand, NumElements);

			DataOffset = 0;
			if (PassShaders.VertexShader.IsValid())
			{
				FMeshDrawSingleShaderBindings VertexShaderBindings = MeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Vertex, DataOffset);
				FMeshMaterialShader::GetElementShaderBindings(PassShaders.VertexShader, Scene, ViewIfDynamicMeshCommand, VertexFactory, InputStreamType, FeatureLevel, PrimitiveSceneProxy, MeshBatch, BatchElement, ShaderElementData, VertexShaderBindings, MeshDrawCommand.VertexStreams);
			}

			if (PassShaders.HullShader.IsValid() & PassShaders.DomainShader.IsValid())
			{
				FMeshDrawSingleShaderBindings HullShaderBindings = MeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Hull, DataOffset);
				FMeshDrawSingleShaderBindings DomainShaderBindings = MeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Domain, DataOffset);
				FMeshMaterialShader::GetElementShaderBindings(PassShaders.HullShader, Scene, ViewIfDynamicMeshCommand, VertexFactory, EVertexInputStreamType::Default, FeatureLevel, PrimitiveSceneProxy, MeshBatch, BatchElement, ShaderElementData, HullShaderBindings, MeshDrawCommand.VertexStreams);
				FMeshMaterialShader::GetElementShaderBindings(PassShaders.DomainShader, Scene, ViewIfDynamicMeshCommand, VertexFactory, EVertexInputStreamType::Default, FeatureLevel, PrimitiveSceneProxy, MeshBatch, BatchElement, ShaderElementData, DomainShaderBindings, MeshDrawCommand.VertexStreams);
			}

			if (PassShaders.PixelShader.IsValid())
			{
				FMeshDrawSingleShaderBindings PixelShaderBindings = MeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Pixel, DataOffset);
				FMeshMaterialShader::GetElementShaderBindings(PassShaders.PixelShader, Scene, ViewIfDynamicMeshCommand, VertexFactory, EVertexInputStreamType::Default, FeatureLevel, PrimitiveSceneProxy, MeshBatch, BatchElement, ShaderElementData, PixelShaderBindings, MeshDrawCommand.VertexStreams);
			}


			if (PassShaders.GeometryShader.IsValid())
			{
				FMeshDrawSingleShaderBindings GeometryShaderBindings = MeshDrawCommand.ShaderBindings.GetSingleShaderBindings(SF_Geometry, DataOffset);
				FMeshMaterialShader::GetElementShaderBindings(PassShaders.GeometryShader, Scene, ViewIfDynamicMeshCommand, VertexFactory, EVertexInputStreamType::Default, FeatureLevel, PrimitiveSceneProxy, MeshBatch, BatchElement, ShaderElementData, GeometryShaderBindings, MeshDrawCommand.VertexStreams);
			}

			int32 DrawPrimitiveId;
			int32 ScenePrimitiveId;
			GetDrawCommandPrimitiveId(PrimitiveSceneInfo, BatchElement, DrawPrimitiveId, ScenePrimitiveId);

			FMeshProcessorShaders ShadersForDebugging = PassShaders.GetUntypedShaders();
			DrawListContext->FinalizeCommand(MeshBatch, BatchElementIndex, DrawPrimitiveId, ScenePrimitiveId, MeshFillMode, MeshCullMode, SortKey, PipelineState, &ShadersForDebugging, MeshDrawCommand);
		}
	}
}

在代码创建了中FGraphicsMinimalPipelineStateInitializer PipelineState这个类的源码注释中提到：

  • 不包含渲染目标状态的管线状态
  • 适用于在绘制之间渲染目标状态不会改变的网格绘制。
  • 注意：该类的大小会影响网格绘制遍历性能。

创建这个轻量的PipelineStateInitializer后调用了SetShaders函数并对其BoundShaderState赋值，至此如果是调用的PSOcache，那么应该是在这里计入缓存的管线id

SubmitMeshDrawCommands

在这个函数里面调用的是SubmitMeshDrawCommandsRange，此函数代码如下：

void SubmitMeshDrawCommandsRange(
	const FMeshCommandOneFrameArray& VisibleMeshDrawCommands,
	const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
	FRHIVertexBuffer* PrimitiveIdsBuffer,
	int32 BasePrimitiveIdsOffset,
	bool bDynamicInstancing,
	int32 StartIndex,
	int32 NumMeshDrawCommands,
	uint32 InstanceFactor,
	FRHICommandList& RHICmdList)
{
	FMeshDrawCommandStateCache StateCache;
	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];
		const int32 PrimitiveIdBufferOffset = BasePrimitiveIdsOffset + (bDynamicInstancing ? VisibleMeshDrawCommand.PrimitiveIdBufferOffset : DrawCommandIndex) * sizeof(int32);
		checkSlow(!bDynamicInstancing || VisibleMeshDrawCommand.PrimitiveIdBufferOffset >= 0);
		FMeshDrawCommand::SubmitDraw(*VisibleMeshDrawCommand.MeshDrawCommand, GraphicsMinimalPipelineStateSet, PrimitiveIdsBuffer, PrimitiveIdBufferOffset, InstanceFactor, RHICmdList, StateCache);
	}
}

这个函数传入了FGraphicsMinimalPipelineStateInitializer 的参数给FMeshDrawCommand::SubmitDraw用，这个函数通过之前的MeshDrawCommand的CachedPipelineId来获取GraphicsMinimalPipelineStateSet，然后通过AsGraphicsPipelineStateInitializer函数来把这个轻量的管线状态变为FGraphicsPipelineStateInitializer，接下来会调用SetGraphicsPipelineState函数，到这里就和之前的预编译流程的后面部分成功对接^^

YouYider
关注
  • 30
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
jQuery1.9.1源码分析系列（十六）ajax之ajax框架
11-22
【jQuery1.9.1源码分析：Ajax框架详解】 在深入探讨jQuery1.9.1的Ajax框架之前，我们首先要理解AJAX的基本概念。AJAX全称为Asynchronous JavaScript and XML，即异步JavaScript和XML。它允许网页在不刷新整个页面的...
UE4 PSO缓存
NoCodeWorld的博客
01-08 1390
按路径划分就两个重要的东西插件PsoCacheGather 这个主要负责PSO的实机采集任务/ProjectDir/Tools/PSOCache 这个下面主要是批处理工具脚本，主要负责PSO二进制文件的生成工作，这里要重点说明下这些脚本执行前有一个重要的配置需要处理 PublicParam.bat@echo off。
UE4中使用PSO缓存优化
zxh1592000的博客
12-17 8230
UE4中使用PSO缓存优化1、简述2、构建流程3、测试结果4.总结： 1、简述 在首次进入项目时，第一次加载新场景，或打开RT缩略图的卡顿；在第二次进入游戏后不会，实则是编译新着色器时项目出现的卡顿耗时，可以通过PSO缓存方式优化加载时间： UE 中的 PSO Caching 机制，用于预先记录和构建出运行时所使用的材质依赖的 Shader 信息，当项目首次使用这些 Shader 时，该列表可以加速 Shader 的加载 / 编译过程。PSO Caching 会把渲染状态、顶点声明、Primitive 类型
【UE】Android PSO Caches的使用流程
weixin_47309438的博客
04-05 1302
通过上面步骤我们已经完成PSO的流程，但是我们不知道PSO的数据是否是如我们预期的一样，现在我们在C:\Unreal4.27\UnrealEngineEX_4.27.2-release\Engine\Source\Runtime\OpenGLDrv\Private\OpenGLShaders.cpp文件中添加Log输出。进行此操作的目的是尝试加载游戏中使用的每个内容，以便材质使用的着。的文件，在ue引擎的win64文件中，搜索找到后将其放置到C盘根目录上的PSOCaching文件夹中。
【UE源码分析】PSO相关类代码分析
weixin_47309438的博客
04-05 983
首先创建一个临时文件把文件的内容给move过来，然后创建一个reader来读取，reader创建好以后，判断标志以指示缓存文件是否应被使用，如果二进制文件大小是0，不会报错只会报警告，构建一个缓存条目列表FGLProgramBinaryFileCacheEntry，每个条目代表文件中的一个程序。所以可以看到在我们OpenGL3的条件下，if判断的第一个参数是一个为false的bool值，这段代码不会执行，但是还是分析下这个功能，这个函数确保所有的Uniform Block都正确地绑定到了预期的位置。
【UE源码分析】PSO cache函数调用过程分析
weixin_47309438的博客
04-05 1067
首先通过ProgramBinRefPtr去获得FGLProgramBinaryFileCacheEntry FoundProgram，判断FoundProgram的state不是ProgramStored或者ProgramAvailable说明这个地方为非预期，但如果是ProgramAvailable说明可以直接赋值返回，否则说明这个时候还没有准备好。接下来把Program绑定到管线上，重新创建LinkedProgram，如果有曲面细分的话就加上。如果程序存在的话，说明二进制数据已经被使用了，清空它。
PostgreSQL PostGIS so 预加载(preload) 性能提升 - 暨什么动态库建议预加载
weixin_34364135的博客
05-06 408
标签 PostgreSQL , PostGIS , preload , shared_preload_libraries , session_preload_libraries 背景 PostgreSQL是一个可扩展的数据库，如果你的扩展是C扩展，代码在动态库中。那么在使用时需要加载这个动态库来实现一些功能例如创建类型，创建函数，创建操作符等。 Po...
C语言实现粒子群算法(PSO)一
hcc199521的博客
12-03 3250
粒子群算法的C语言代码实现。
jQuery 源码分析笔记(4) Ready函数
01-21
这个功能在 jQuery的文档中提到了三种等价的形式： 代码如下: // 定义在jQuery.fn.ready $(document).ready(handler); // 和上一个是同一个，不推荐 $().ready(handler); // 单独在jQuery对象中处理 $(handler);...
UE蓝图编译过程详解，基于UE4源码
03-01
在Unreal Engine 4（UE4）中，蓝图是一种...理解UE4蓝图的编译过程对于优化开发流程、提升游戏性能以及解决复杂问题至关重要。通过深入研究源码，开发者可以更有效地利用蓝图系统，创造出更高效、更具表现力的游戏。
jQuery源码分析-02正则表达式 RegExp 常用正则表达式
01-19
后文预告：jQuery中的正则表达式分析 2.4 常用正则表达式 在网上找到一篇广为流传的文章《常用正则表达式》，逐一分析，不足地方进行补充和纠正。 代码如下: 常用的数字正则（严格匹配） 正则 含义 ^[1-9]\d*$ 匹配...
jQuery 源码分析笔记
12-19
"jQuery 源码分析笔记"探讨了jQuery的核心设计和实现，特别是其如何简化JavaScript开发，并且深入研究了jQuery的源码结构。 jQuery的创建方式是一个自执行的匿名函数，这样做的好处在于它不会污染全局命名空间，...
斯坦福UE4 C++课学习补充22：AI行为树-寻路入门
weixin_51524146的博客
08-16 652
会将其子节点的返回值反转。如果子节点返回成功，条件反转节点返回失败；如果子节点返回失败，条件反转节点返回成功。：会重复执行其子节点，直到满足指定的条件（如循环次数、子节点返回特定状态等）（通常是头部或眼睛的位置）。也指定一个具体的世界坐标来作为射线的起点。文件，添加我们所需要的模块。出于项目的规范统一，这里额外添加了。装饰器节点在其所装饰的子节点即将执行时触发。②射线检测的起始点，默认选择控制器所控制的。是UE中一个静态类，提供了一些便捷的。，实际上不添加也是可以的，因为UE在。已经为我们自动添加了。
斯坦福UE4 C++课学习补充20：位移技能
weixin_51524146的博客
08-13 945
主要用于定义一个粒子系统的类型，即它是什么样的效果，包括每个粒子的发射行为、运动轨迹、生命周期、材质动画、光效等。这只是对粒子系统的一种静态描述，类似于一个蓝图模板。它本身不会在游戏世界中渲染出任何东西。的一个运行时实例，还管理粒子系统的。为什么在上面这段代码中，
跨平台游戏引擎 Axmol-2.1.5 发布
一线灵的博客
08-12 1077
LTS。
游戏引擎phaser.js3的使用之玩家和静态物理组碰撞
m0_61177996的博客
08-16 152
游戏引擎phaser.js3的使用之玩家和静态物理组碰撞
GAMES104：08游戏引擎的动画技术基础-学习笔记
最新发布
噗噗噗的博客
08-16 652
人类祖先就喜欢通过画画试图把动态的人物画下来，近代发现了视觉残留（1/24秒），奠定了动画视觉实现的基础早期尝试：跑马灯、定格动画、早期动画电影（一帧一帧画的）等未来方向：实时渲染动画、电影（Zafari）
游戏引擎phaser.js3的使用之静态物理组的建立
m0_61177996的博客
08-16 117
游戏引擎phaser.js3的使用之静态物理组的建立
游戏引擎phaser.js3的使用
m0_61177996的博客
08-16 86
首先要加载对应的phaser.js资源，正常引入就可以了，线上的js路径为。引入后就可以正常进行使用了。//在这里加载游戏所需资源。以下就是初始使用方法。
设置ue源码编译平台
08-18
要设置UE源码编译平台，需要按照以下步骤进行操作。 1. 获取Unreal Engine源代码。可以通过Epic Games的GitHub仓库或者Unreal Engine官网下载源代码压缩包。 2. 解压缩源代码到本地计算机的合适位置。 3. 安装必要的软件和工具。编译Unreal Engine需要一些依赖软件和工具，例如Visual Studio（推荐使用VS2017或更高版本）、Windows SDK、DirectX、CMake等。根据Unreal Engine版本和所需功能进行适当安装。 4. 打开解压缩后的源代码目录，找到Setup.bat文件并运行。此脚本将执行一系列设置和配置操作，以确保编译环境的正确性。 5. 选择要编译的目标平台。根据项目需求，使用Setup.bat脚本提供的选项选择要编译的目标平台，例如Windows、Mac、Linux等。 6. 使用CMake生成项目文件。在源代码目录中，找到GenerateProjectFiles.bat文件并运行。此脚本将使用CMake生成项目文件。 7. 打开生成的项目文件。根据所用的开发工具，例如Visual Studio，使用生成的项目文件打开Unreal Engine。这将加载Unreal Engine的代码，并准备进行编译。 8. 编译Unreal Engine。使用开发工具进行编译，确保选择正确的编译配置和目标平台。编译过程可能需要一些时间，具体时间取决于计算机性能和项目大小。 9. 完成编译后，可以开始使用编译后的Unreal Engine。根据需要，可以运行自己的项目或者使用Unreal Engine进行开发或测试。 需要注意的是，UE源码编译平台的设置过程可能会因个人计算机的配置和项目需求而略有差异。建议在参考官方文档和社区参考资料的基础上进行设置，并根据实际情况调整。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值