自学教程：C++ IsInRenderingThread函数代码示例

/** Returns true if the Material and Vertex Factory combination require adjacency information. */bool RequiresAdjacencyInformation( UMaterialInterface* Material, const FVertexFactoryType* VertexFactoryType, ERHIFeatureLevel::Type InFeatureLevel ){	EMaterialTessellationMode TessellationMode = MTM_NoTessellation;	bool bEnableCrackFreeDisplacement = false;	if ( RHISupportsTessellation(GShaderPlatformForFeatureLevel[InFeatureLevel]) && VertexFactoryType->SupportsTessellationShaders() && Material )	{		if ( IsInRenderingThread() )		{			FMaterialRenderProxy* MaterialRenderProxy = Material->GetRenderProxy( false, false );			check( MaterialRenderProxy );			const FMaterial* MaterialResource = MaterialRenderProxy->GetMaterial(InFeatureLevel);			check( MaterialResource );			TessellationMode = MaterialResource->GetTessellationMode();			bEnableCrackFreeDisplacement = MaterialResource->IsCrackFreeDisplacementEnabled();		}		else if ( IsInGameThread() )		{			UMaterial* BaseMaterial = Material->GetMaterial();			check( BaseMaterial );			TessellationMode = (EMaterialTessellationMode)BaseMaterial->D3D11TessellationMode;			bEnableCrackFreeDisplacement = BaseMaterial->bEnableCrackFreeDisplacement;		}		else		{			UMaterialInterface::TMicRecursionGuard RecursionGuard;			const UMaterial* BaseMaterial = Material->GetMaterial_Concurrent(RecursionGuard);			check( BaseMaterial );			TessellationMode = (EMaterialTessellationMode)BaseMaterial->D3D11TessellationMode;			bEnableCrackFreeDisplacement = BaseMaterial->bEnableCrackFreeDisplacement;		}	}	return TessellationMode == MTM_PNTriangles || ( TessellationMode == MTM_FlatTessellation && bEnableCrackFreeDisplacement );}

void FRHIResource::FlushPendingDeletes(){	SCOPE_CYCLE_COUNTER(STAT_DeleteResources);	check(IsInRenderingThread());	FRHICommandListExecutor::CheckNoOutstandingCmdLists();	FRHICommandListExecutor::GetImmediateCommandList().ImmediateFlush(EImmediateFlushType::FlushRHIThread);	while (1)	{		TArray<FRHIResource*> ToDelete;		PendingDeletes.PopAll(ToDelete);		if (!ToDelete.Num())		{			break;		}		for (int32 Index = 0; Index < ToDelete.Num(); Index++)		{			FRHIResource* Ref = ToDelete[Index];			check(Ref->MarkedForDelete == 1);			if (Ref->GetRefCount() == 0) // caches can bring dead objects back to life			{				CurrentlyDeleting = Ref;				delete Ref;				CurrentlyDeleting = nullptr;			}			else			{				Ref->MarkedForDelete = 0;				FPlatformMisc::MemoryBarrier();			}		}	}}

void FSteamVRHMD::RenderTexture_RenderThread(FRHICommandListImmediate& RHICmdList, FTexture2DRHIParamRef BackBuffer, FTexture2DRHIParamRef SrcTexture) const{	check(IsInRenderingThread());	if (WindowMirrorMode == 0)	{		return;	}	const uint32 ViewportWidth = BackBuffer->GetSizeX();	const uint32 ViewportHeight = BackBuffer->GetSizeY();	SetRenderTarget(RHICmdList, BackBuffer, FTextureRHIRef());	RHICmdList.SetViewport(0, 0, 0, ViewportWidth, ViewportHeight, 1.0f);	RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI());	RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI());	RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI());	const auto FeatureLevel = GMaxRHIFeatureLevel;	auto ShaderMap = GetGlobalShaderMap(FeatureLevel);	TShaderMapRef<FScreenVS> VertexShader(ShaderMap);	TShaderMapRef<FScreenPS> PixelShader(ShaderMap);	static FGlobalBoundShaderState BoundShaderState;	SetGlobalBoundShaderState(RHICmdList, FeatureLevel, BoundShaderState, RendererModule->GetFilterVertexDeclaration().VertexDeclarationRHI, *VertexShader, *PixelShader);	PixelShader->SetParameters(RHICmdList, TStaticSamplerState<SF_Bilinear>::GetRHI(), SrcTexture);	if (WindowMirrorMode == 1)	{		// need to clear when rendering only one eye since the borders won't be touched by the DrawRect below		RHICmdList.Clear(true, FLinearColor::Black, false, 0, false, 0, FIntRect());		RendererModule->DrawRectangle(			RHICmdList,			ViewportWidth / 4, 0,			ViewportWidth / 2, ViewportHeight,			0.1f, 0.2f,			0.3f, 0.6f,			FIntPoint(ViewportWidth, ViewportHeight),			FIntPoint(1, 1),			*VertexShader,			EDRF_Default);	}	else if (WindowMirrorMode == 2)	{		RendererModule->DrawRectangle(			RHICmdList,			0, 0,			ViewportWidth, ViewportHeight,			0.0f, 0.0f,			1.0f, 1.0f,			FIntPoint(ViewportWidth, ViewportHeight),			FIntPoint(1, 1),			*VertexShader,			EDRF_Default);	}}

bool FD3D11DynamicRHI::RHIGetRenderQueryResult(FRenderQueryRHIParamRef QueryRHI,uint64& OutResult,bool bWait){	check(IsInRenderingThread());	FD3D11RenderQuery* Query = ResourceCast(QueryRHI);	bool bSuccess = true;	if(!Query->bResultIsCached)	{		bSuccess = GetQueryData(Query->Resource,&Query->Result,sizeof(Query->Result),bWait, Query->QueryType);		Query->bResultIsCached = bSuccess;	}	if(Query->QueryType == RQT_AbsoluteTime)	{		// GetTimingFrequency is the number of ticks per second		uint64 Div = FGPUTiming::GetTimingFrequency() / (1000 * 1000);		// convert from GPU specific timestamp to micro sec (1 / 1 000 000 s) which seems a reasonable resolution		OutResult = Query->Result / Div;	}	else	{		OutResult = Query->Result;	}	return bSuccess;}

void FIndirectLightingCache::FinalizeUpdateInternal_RenderThread(FScene* Scene, FSceneRenderer& Renderer, TMap<FIntVector, FBlockUpdateInfo>& BlocksToUpdate, const TArray<FIndirectLightingCacheAllocation*>& TransitionsOverTimeToUpdate){	check(IsInRenderingThread());	if (IndirectLightingAllowed(Scene, Renderer))	{		{			SCOPE_CYCLE_COUNTER(STAT_UpdateIndirectLightingCacheBlocks);			UpdateBlocks(Scene, Renderer.Views.GetData(), BlocksToUpdate);		}		{			SCOPE_CYCLE_COUNTER(STAT_UpdateIndirectLightingCacheTransitions);			UpdateTransitionsOverTime(TransitionsOverTimeToUpdate, Renderer.ViewFamily.DeltaWorldTime);		}	}		if (GCacheDrawLightingSamples || Renderer.ViewFamily.EngineShowFlags.VolumeLightingSamples || GCacheDrawDirectionalShadowing)	{		FViewElementPDI DebugPDI(Renderer.Views.GetData(), NULL);		for (int32 VolumeIndex = 0; VolumeIndex < Scene->PrecomputedLightVolumes.Num(); VolumeIndex++)		{			const FPrecomputedLightVolume* PrecomputedLightVolume = Scene->PrecomputedLightVolumes[VolumeIndex];			PrecomputedLightVolume->DebugDrawSamples(&DebugPDI, GCacheDrawDirectionalShadowing != 0);		}	}}

void FCompositionLighting::ProcessLpvIndirect(FRHICommandListImmediate& RHICmdList, FViewInfo& View){	check(IsInRenderingThread());		FMemMark Mark(FMemStack::Get());	FRenderingCompositePassContext CompositeContext(RHICmdList, View);	FPostprocessContext Context(CompositeContext.Graph, View);	if(IsLpvIndirectPassRequired(Context))	{		FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);		FRenderingCompositePass* SSAO = Context.Graph.RegisterPass(new FRCPassPostProcessInput(SceneContext.ScreenSpaceAO));		FRenderingCompositePass* Pass = Context.Graph.RegisterPass(new FRCPassPostProcessLpvIndirect());		Pass->SetInput(ePId_Input0, Context.FinalOutput);		Pass->SetInput(ePId_Input1, SSAO );		Context.FinalOutput = FRenderingCompositeOutputRef(Pass);	}	// The graph setup should be finished before this line ----------------------------------------	SCOPED_DRAW_EVENT(RHICmdList, CompositionLpvIndirect);	// we don't replace the final element with the scenecolor because this is what those passes should do by themself	CompositeContext.Process(Context.FinalOutput.GetPass(), TEXT("CompositionLighting"));}

void FGearVRSplash::Tick(float DeltaTime){	check(IsInRenderingThread());	FCustomPresent* pCustomPresent = pPlugin->GetCustomPresent_Internal();	if (pCustomPresent && pPlugin->HasValidOvrMobile())	{		static double LastHighFreqTime = FPlatformTime::Seconds();		const double CurTime = FPlatformTime::Seconds();		const double DeltaSecondsHighFreq = CurTime - LastHighFreqTime;		if (!IsLoadingIconMode())		{			bool bNeedToPushFrame = false;			FScopeLock ScopeLock2(&RenderSplashScreensLock);			FGameFrame* pCurrentFrame = static_cast<FGameFrame*>(RenderFrame.Get());			check(pCurrentFrame);			for (int32 i = 0; i < RenderSplashScreens.Num(); ++i)			{				FRenderSplashInfo& Splash = RenderSplashScreens[i];				// Let update only each 2nd frame if rotation is needed				if ((!Splash.Desc.DeltaRotation.Equals(FQuat::Identity) && DeltaSecondsHighFreq > 2.f * DisplayRefreshRate))				{					if (pCurrentFrame)					{						const FHMDLayerDesc* pLayerDesc = LayerMgr->GetLayerDesc(Splash.SplashLID);						if (pLayerDesc)						{							FHMDLayerDesc layerDesc = *pLayerDesc;							FTransform transform(layerDesc.GetTransform());							if (!Splash.Desc.DeltaRotation.Equals(FQuat::Identity))							{								const FQuat prevRotation(transform.GetRotation());								const FQuat resultRotation(Splash.Desc.DeltaRotation * prevRotation);								transform.SetRotation(resultRotation);								layerDesc.SetTransform(transform);							}							LayerMgr->UpdateLayer(layerDesc);							bNeedToPushFrame = true;						}					}				}			}			if (bNeedToPushFrame || DeltaSecondsHighFreq > .5f) // also call push frame once in half second			{				++pCurrentFrame->FrameNumber; // = pPlugin->GetCurrentFrameNumber();				FLayerManager* pGearVRLayerMgr = (FLayerManager*)LayerMgr.Get();				pGearVRLayerMgr->PreSubmitUpdate_RenderThread(FRHICommandListExecutor::GetImmediateCommandList(), pCurrentFrame, false);				pCustomPresent->PushFrame(pGearVRLayerMgr, pCurrentFrame);				LastHighFreqTime = CurTime;			}		}		else if (DeltaSecondsHighFreq > 1.f / 3.f)		{			pPlugin->RenderLoadingIcon_RenderThread();			LastHighFreqTime = CurTime;		}	}}

	/** Initialization */	void Init(const FArrowVertexBuffer* VertexBuffer)	{		if (IsInRenderingThread())		{			// Initialize the vertex factory's stream components.			FDataType NewData;			NewData.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Position, VET_Float3);			NewData.TextureCoordinates.Add(				FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FDynamicMeshVertex, TextureCoordinate), sizeof(FDynamicMeshVertex), VET_Float2)				);			NewData.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentX, VET_PackedNormal);			NewData.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentZ, VET_PackedNormal);			SetData(NewData);		}		else		{			ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(				InitArrowVertexFactory,				FArrowVertexFactory*, VertexFactory, this,				const FArrowVertexBuffer*, VertexBuffer, VertexBuffer,				{				// Initialize the vertex factory's stream components.				FDataType NewData;				NewData.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, Position, VET_Float3);				NewData.TextureCoordinates.Add(					FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FDynamicMeshVertex, TextureCoordinate), sizeof(FDynamicMeshVertex), VET_Float2)					);				NewData.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentX, VET_PackedNormal);				NewData.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FDynamicMeshVertex, TangentZ, VET_PackedNormal);				VertexFactory->SetData(NewData);			});		}

FLightPrimitiveInteraction::~FLightPrimitiveInteraction(){	check(IsInRenderingThread());#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)	// Update the game thread's counter of number of uncached static lighting interactions.	if(bUncachedStaticLighting)	{		LightSceneInfo->NumUnbuiltInteractions--;		FPlatformAtomics::InterlockedDecrement(&PrimitiveSceneInfo->Scene->NumUncachedStaticLightingInteractions);#if WITH_EDITOR		PrimitiveSceneInfo->Proxy->NumUncachedStaticLightingInteractions--;#endif	}#endif	// Remove the interaction from the light's interaction list.	if(NextPrimitive)	{		NextPrimitive->PrevPrimitiveLink = PrevPrimitiveLink;	}	*PrevPrimitiveLink = NextPrimitive;	// Remove the interaction from the primitive's interaction list.	if(NextLight)	{		NextLight->PrevLightLink = PrevLightLink;	}	*PrevLightLink = NextLight;}

void FSsPartsVertexFactory::Init(const FSsPartsVertexBuffer* VertexBuffer){	if(IsInRenderingThread())	{		FLocalVertexFactory::DataType Data;		Data.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Position, VET_Float3);		Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,TexCoord), sizeof(FSsPartVertex), VET_Float2));		Data.ColorComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Color, VET_Color);		Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,ColorBlend), sizeof(FSsPartVertex), VET_Float2));		Data.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentX, VET_PackedNormal);		Data.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentZ, VET_PackedNormal);		SetData(Data);	}	else	{		ENQUEUE_UNIQUE_RENDER_COMMAND_TWOPARAMETER(			FInitSsPartsVertexFactory,			FSsPartsVertexFactory*, VertexFactory, this,			const FSsPartsVertexBuffer*, VertexBuffer, VertexBuffer,		{			DataType Data;			Data.PositionComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Position, VET_Float3);			Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,TexCoord), sizeof(FSsPartVertex), VET_Float2));			Data.ColorComponent = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, Color, VET_Color);			Data.TextureCoordinates.Add(FVertexStreamComponent(VertexBuffer, STRUCT_OFFSET(FSsPartVertex,ColorBlend), sizeof(FSsPartVertex), VET_Float2));			Data.TangentBasisComponents[0] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentX, VET_PackedNormal);			Data.TangentBasisComponents[1] = STRUCTMEMBER_VERTEXSTREAMCOMPONENT(VertexBuffer, FSsPartVertex, TangentZ, VET_PackedNormal);			VertexFactory->SetData(Data);		});	}

void FSlateElementIndexBuffer::FillBuffer( const TArray<SlateIndex>& InIndices, bool bShrinkToFit  ){	check( IsInRenderingThread() );	if( InIndices.Num() )	{		uint32 NumIndices = InIndices.Num();		uint32 RequiredBufferSize = NumIndices*sizeof(SlateIndex);		// resize if needed		if( RequiredBufferSize > GetBufferSize() || bShrinkToFit )		{			// Use array resize techniques for the vertex buffer			ResizeBuffer( InIndices.GetAllocatedSize() );		}		BufferUsageSize += RequiredBufferSize;		void* IndicesPtr = RHILockIndexBuffer( IndexBufferRHI, 0, RequiredBufferSize, RLM_WriteOnly );		FMemory::Memcpy( IndicesPtr, InIndices.GetData(), RequiredBufferSize );		RHIUnlockIndexBuffer(IndexBufferRHI);	}}

void FCompositionLighting::ProcessAsyncSSAO(FRHICommandListImmediate& RHICmdList, TArray<FViewInfo>& Views){	check(IsInRenderingThread());	PrepareAsyncSSAO(RHICmdList, Views);	// so that the passes can register themselves to the graph	for (int32 i = 0; i < Views.Num(); ++i)	{		FViewInfo& View = Views[i];		FMemMark Mark(FMemStack::Get());		FRenderingCompositePassContext CompositeContext(RHICmdList, View);		// Add the passes we want to add to the graph (commenting a line means the pass is not inserted into the graph) ----------				uint32 Levels = ComputeAmbientOcclusionPassCount(View);				if (FSSAOHelper::IsAmbientOcclusionAsyncCompute(View, Levels))		{			FPostprocessContext Context(RHICmdList, CompositeContext.Graph, View);			FRenderingCompositeOutputRef AmbientOcclusion = AddPostProcessingAmbientOcclusion(RHICmdList, Context, Levels);			Context.FinalOutput = FRenderingCompositeOutputRef(AmbientOcclusion);						// The graph setup should be finished before this line ----------------------------------------			CompositeContext.Process(Context.FinalOutput.GetPass(), TEXT("Composition_ProcessAsyncSSAO"));		}			}	FinishAsyncSSAO(RHICmdList);}

void FSlateRHIRenderingPolicy::EndDrawingWindows(){	check( IsInRenderingThread() );	uint32 TotalVertexBufferMemory = 0;	uint32 TotalIndexBufferMemory = 0;	uint32 TotalVertexBufferUsage = 0;	uint32 TotalIndexBufferUsage = 0;	uint32 MinVertexBufferSize = VertexBuffers[0].GetMinBufferSize();	uint32 MinIndexBufferSize = IndexBuffers[0].GetMinBufferSize();	for( int32 BufferIndex = 0; BufferIndex < SlateRHIConstants::NumBuffers; ++BufferIndex )	{		TotalVertexBufferMemory += VertexBuffers[BufferIndex].GetBufferSize();		TotalVertexBufferUsage += VertexBuffers[BufferIndex].GetBufferUsageSize();				TotalIndexBufferMemory += IndexBuffers[BufferIndex].GetBufferSize();		TotalIndexBufferUsage += IndexBuffers[BufferIndex].GetBufferUsageSize();	}	SET_MEMORY_STAT( STAT_SlateVertexBufferMemory, TotalVertexBufferMemory );	SET_MEMORY_STAT( STAT_SlateIndexBufferMemory, TotalIndexBufferMemory );}

FD3D11UniformBuffer::~FD3D11UniformBuffer(){	// Do not return the allocation to the pool if it is in the dynamic constant buffer!	if (!RingAllocation.IsValid() && Resource != nullptr)	{		check(IsInRenderingThread());		D3D11_BUFFER_DESC Desc;		Resource->GetDesc(&Desc);		// Return this uniform buffer to the free pool		if (Desc.CPUAccessFlags == D3D11_CPU_ACCESS_WRITE && Desc.Usage == D3D11_USAGE_DYNAMIC)		{			check(IsValidRef(Resource));			FPooledUniformBuffer NewEntry;			NewEntry.Buffer = Resource;			NewEntry.FrameFreed = GFrameNumberRenderThread;			NewEntry.CreatedSize = Desc.ByteWidth;			// Add to this frame's array of free uniform buffers			const int32 SafeFrameIndex = (GFrameNumberRenderThread - 1) % NumSafeFrames;			const uint32 BucketIndex = GetPoolBucketIndex(Desc.ByteWidth);			int32 LastNum = SafeUniformBufferPools[SafeFrameIndex][BucketIndex].Num();			check(Desc.ByteWidth <= GetPoolBucketSize(Desc.ByteWidth));			SafeUniformBufferPools[SafeFrameIndex][BucketIndex].Add(NewEntry);			INC_DWORD_STAT(STAT_D3D11NumFreeUniformBuffers);			INC_MEMORY_STAT_BY(STAT_D3D11FreeUniformBufferMemory, Desc.ByteWidth);			FPlatformMisc::MemoryBarrier(); // check for unwanted concurrency			check(SafeUniformBufferPools[SafeFrameIndex][BucketIndex].Num() == LastNum + 1);		}	}}

void FOculusRiftHMD::RenderTexture_RenderThread(class FRHICommandListImmediate& RHICmdList, class FRHITexture2D* BackBuffer, class FRHITexture2D* SrcTexture) const{	check(IsInRenderingThread());	check(pCustomPresent);	auto RenderContext = pCustomPresent->GetRenderContext();	if (RenderContext && RenderContext->GetFrameSettings()->Flags.bMirrorToWindow)	{		if (RenderContext->GetFrameSettings()->MirrorWindowMode == FSettings::eMirrorWindow_Distorted)		{			FTexture2DRHIRef MirrorTexture = pCustomPresent->GetMirrorTexture();			if (MirrorTexture)			{				CopyTexture_RenderThread(RHICmdList, BackBuffer, MirrorTexture);			}		}		else if (RenderContext->GetFrameSettings()->MirrorWindowMode == FSettings::eMirrorWindow_Undistorted)		{			auto FrameSettings = RenderContext->GetFrameSettings();			FIntRect destRect(0, 0, BackBuffer->GetSizeX() / 2, BackBuffer->GetSizeY());			for (int i = 0; i < 2; ++i)			{				CopyTexture_RenderThread(RHICmdList, BackBuffer, SrcTexture, destRect, FrameSettings->EyeRenderViewport[i]);				destRect.Min.X += BackBuffer->GetSizeX() / 2;				destRect.Max.X += BackBuffer->GetSizeX() / 2;			}		}		else if (RenderContext->GetFrameSettings()->MirrorWindowMode == FSettings::eMirrorWindow_SingleEye)		{			auto FrameSettings = RenderContext->GetFrameSettings();			CopyTexture_RenderThread(RHICmdList, BackBuffer, SrcTexture, FIntRect(), FrameSettings->EyeRenderViewport[0]);		}	}}

/*** Creates a bound shader state instance which encapsulates a decl, vertex shader, and pixel shader* @param VertexDeclaration - existing vertex decl* @param StreamStrides - optional stream strides* @param VertexShader - existing vertex shader* @param HullShader - existing hull shader* @param DomainShader - existing domain shader* @param PixelShader - existing pixel shader* @param GeometryShader - existing geometry shader*/FBoundShaderStateRHIRef FD3D11DynamicRHI::RHICreateBoundShaderState(	FVertexDeclarationRHIParamRef VertexDeclarationRHI, 	FVertexShaderRHIParamRef VertexShaderRHI, 	FHullShaderRHIParamRef HullShaderRHI, 	FDomainShaderRHIParamRef DomainShaderRHI, 	FPixelShaderRHIParamRef PixelShaderRHI,	FGeometryShaderRHIParamRef GeometryShaderRHI	){	check(IsInRenderingThread());	SCOPE_CYCLE_COUNTER(STAT_D3D11CreateBoundShaderStateTime);	checkf(GIsRHIInitialized && Direct3DDeviceIMContext,(TEXT("Bound shader state RHI resource was created without initializing Direct3D first")));	// Check for an existing bound shader state which matches the parameters	FCachedBoundShaderStateLink* CachedBoundShaderStateLink = GetCachedBoundShaderState(		VertexDeclarationRHI,		VertexShaderRHI,		PixelShaderRHI,		HullShaderRHI,		DomainShaderRHI,		GeometryShaderRHI		);	if(CachedBoundShaderStateLink)	{		// If we've already created a bound shader state with these parameters, reuse it.		return CachedBoundShaderStateLink->BoundShaderState;	}	else	{		SCOPE_CYCLE_COUNTER(STAT_D3D11NewBoundShaderStateTime);		return new FD3D11BoundShaderState(VertexDeclarationRHI,VertexShaderRHI,PixelShaderRHI,HullShaderRHI,DomainShaderRHI,GeometryShaderRHI,Direct3DDevice);	}}

void FPrimitiveSceneInfo::RemoveFromScene(bool bUpdateStaticDrawLists){	check(IsInRenderingThread());	// implicit linked list. The destruction will update this "head" pointer to the next item in the list.	while(LightList)	{		FLightPrimitiveInteraction::Destroy(LightList);	}		// Remove the primitive from the octree.	check(OctreeId.IsValidId());	check(Scene->PrimitiveOctree.GetElementById(OctreeId).PrimitiveSceneInfo == this);	Scene->PrimitiveOctree.RemoveElement(OctreeId);	OctreeId = FOctreeElementId();	IndirectLightingCacheAllocation = NULL;	DEC_MEMORY_STAT_BY(STAT_PrimitiveInfoMemory, sizeof(*this) + StaticMeshes.GetAllocatedSize() + Proxy->GetMemoryFootprint());	if (bUpdateStaticDrawLists)	{		RemoveStaticMeshes();	}}

void FRuntimeMeshProxy::DeleteSection_RenderThread(int32 SectionId){	check(IsInRenderingThread());	bool bChangedState = false;	if (SectionId == INDEX_NONE)	{		Sections.Empty();		bChangedState = true;	}	else	{		// Remove the section if it exists		if (Sections.Remove(SectionId) > 0)		{			bChangedState = true;		}	}	if (bChangedState)	{		// Update the cached values for rendering.		UpdateCachedValues();	}}

const FTexture2DRHIRef& FSceneViewport::GetRenderTargetTexture() const{	if (IsInRenderingThread())	{		return RenderTargetTextureRenderThreadRHI;	}	return 	RenderTargetTextureRHI;}

FSlateShaderResource* FSceneViewport::GetViewportRenderTargetTexture(){	if (IsInRenderingThread())	{		return RenderThreadSlateTexture;	}	return (BufferedSlateHandles.Num() != 0) ? BufferedSlateHandles[CurrentBufferedTargetIndex] : nullptr;}

void FCompositionLighting::ProcessAfterBasePass(FRHICommandListImmediate& RHICmdList, FViewInfo& View){	check(IsInRenderingThread());		FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);	// might get renamed to refracted or ...WithAO	SceneContext.GetSceneColor()->SetDebugName(TEXT("SceneColor"));	// to be able to observe results with VisualizeTexture	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.GetSceneColor());	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.GBufferA);	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.GBufferB);	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.GBufferC);	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.GBufferD);	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.GBufferE);	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.GBufferVelocity);	GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SceneContext.ScreenSpaceAO);		// so that the passes can register themselves to the graph	{		FMemMark Mark(FMemStack::Get());		FRenderingCompositePassContext CompositeContext(RHICmdList, View);		FPostprocessContext Context(CompositeContext.Graph, View);		// Add the passes we want to add to the graph (commenting a line means the pass is not inserted into the graph) ----------		// decals are before AmbientOcclusion so the decal can output a normal that AO is affected by		if( Context.View.Family->EngineShowFlags.Decals &&			!Context.View.Family->EngineShowFlags.VisualizeLightCulling)		// decal are distracting when looking at LightCulling		{			AddDeferredDecalsBeforeLighting(Context);		}		FRenderingCompositeOutputRef AmbientOcclusion;		if(uint32 Levels = ComputeAmbientOcclusionPassCount(Context))		{			AmbientOcclusion = AddPostProcessingAmbientOcclusion(RHICmdList, Context, Levels);		}		if(IsAmbientCubemapPassRequired(Context))		{			AddPostProcessingAmbientCubemap(Context, AmbientOcclusion);		}		// The graph setup should be finished before this line ----------------------------------------		SCOPED_DRAW_EVENT(RHICmdList, LightCompositionTasks_PreLighting);		TRefCountPtr<IPooledRenderTarget>& SceneColor = SceneContext.GetSceneColor();		Context.FinalOutput.GetOutput()->RenderTargetDesc = SceneColor->GetDesc();		Context.FinalOutput.GetOutput()->PooledRenderTarget = SceneColor;		CompositeContext.Process(Context.FinalOutput.GetPass(), TEXT("CompositionLighting_AfterBasePass"));	}}

void FSteamVRHMD::PreRenderViewFamily_RenderThread(FRHICommandListImmediate& RHICmdList, FSceneViewFamily& ViewFamily){	check(IsInRenderingThread());	GetActiveRHIBridgeImpl()->BeginRendering();	FVector CurrentPosition;	FQuat CurrentOrientation;	GetCurrentPose(CurrentOrientation, CurrentPosition, vr::k_unTrackedDeviceIndex_Hmd, true);}

void FBoneDataVertexBuffer::UnlockData(){	check(IsValidRef(BoneBuffer));	check(IsInRenderingThread() && AllocBlock && AllocSize);	FRHICommandListExecutor::GetImmediateCommandList().UpdateVertexBuffer(BoneBuffer.VertexBufferRHI, AllocBlock, AllocSize);	FMemory::Free(AllocBlock);	AllocBlock = nullptr;	AllocSize = 0;}