CustomStencil C++部分整理

你的名字 2023-01-20 11:48 26阅读 0赞

1. Render: F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\Renderer\\Private\\DeferredShadingRenderer.cpp

TAutoConsoleVariable<int32> CVarCustomDepthOrder(
    	TEXT("r.CustomDepth.Order"),
    	1,	
    	TEXT("When CustomDepth (and CustomStencil) is getting rendered\n")
    	TEXT("  0: Before GBuffer (can be more efficient with AsyncCompute, allows using it in DBuffer pass, no GBuffer blending decals allow GBuffer compression)\n")
    	TEXT("  1: After Base Pass (default)"),
    	ECVF_RenderThreadSafe);

// @return 0/1
    static int32 GetCustomDepthPassLocation()
    {		
    	return FMath::Clamp(CVarCustomDepthOrder.GetValueOnRenderThread(), 0, 1);
    }

void FDeferredShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)

if(GetCustomDepthPassLocation() == 1)
    	{
    		CSV_SCOPED_TIMING_STAT_EXCLUSIVE(CustomDepthPass);
    		QUICK_SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_CustomDepthPass1);
    		RenderCustomDepthPassAtLocation(RHICmdList, 1);
    	}

F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\Renderer\\Private\\SceneRendering.cpp

void FSceneRenderer::RenderCustomDepthPassAtLocation(FRHICommandListImmediate& RHICmdList, int32 Location)
    {		
    	extern TAutoConsoleVariable<int32> CVarCustomDepthOrder;
    	int32 CustomDepthOrder = FMath::Clamp(CVarCustomDepthOrder.GetValueOnRenderThread(), 0, 1);
    
    	if(CustomDepthOrder == Location)
    	{
    		QUICK_SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_CustomDepthPass);
    		RenderCustomDepthPass(RHICmdList);
    		ServiceLocalQueue();
    	}
    }
    
    void FSceneRenderer::RenderCustomDepthPass(FRHICommandListImmediate& RHICmdList)
    {
    	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderCustomDepthPass);
    
    	// do we have primitives in this pass?
    	bool bPrimitives = false;
    
    	if(!Scene->World || (Scene->World->WorldType != EWorldType::EditorPreview && Scene->World->WorldType != EWorldType::Inactive))
    	{
    		for(int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
    		{
    			const FViewInfo& View = Views[ViewIndex];
    			if (View.bHasCustomDepthPrimitives)
    			{
    				bPrimitives = true;
    				break;
    			}
    		}
    	}
    
    	// Render CustomDepth
    	FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
    	if (SceneContext.BeginRenderingCustomDepth(RHICmdList, bPrimitives))
    	{
    		SCOPED_DRAW_EVENT(RHICmdList, CustomDepth);
    		SCOPED_GPU_STAT(RHICmdList, CustomDepth);
    
    		for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
    		{
    			SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView, Views.Num() > 1, TEXT("View%d"), ViewIndex);
    
    			FViewInfo& View = Views[ViewIndex];
    
    			if (View.ShouldRenderView())
    			{
    				FRHIUniformBuffer* PassUniformBuffer = nullptr;
    
    				if (FSceneInterface::GetShadingPath(View.FeatureLevel) == EShadingPath::Mobile)
    				{
    					FMobileSceneTextureUniformParameters SceneTextureParameters;
    					SetupMobileSceneTextureUniformParameters(SceneContext, View.FeatureLevel, false, false, SceneTextureParameters);
    					Scene->UniformBuffers.MobileCustomDepthPassUniformBuffer.UpdateUniformBufferImmediate(SceneTextureParameters);
    					PassUniformBuffer = Scene->UniformBuffers.MobileCustomDepthPassUniformBuffer;
    				}
    				else
    				{
    					FSceneTexturesUniformParameters SceneTextureParameters;
    					SetupSceneTextureUniformParameters(SceneContext, View.FeatureLevel, ESceneTextureSetupMode::None, SceneTextureParameters);
    					Scene->UniformBuffers.CustomDepthPassUniformBuffer.UpdateUniformBufferImmediate(SceneTextureParameters);
    					PassUniformBuffer = Scene->UniformBuffers.CustomDepthPassUniformBuffer;
    				}
    				
    				if (!View.IsInstancedStereoPass())
    				{
    					RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0.0f, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1.0f);
    				}
    				else
    				{
    					if (View.bIsMultiViewEnabled)
    					{
    						const uint32 LeftMinX = Views[0].ViewRect.Min.X;
    						const uint32 LeftMaxX = Views[0].ViewRect.Max.X;
    						const uint32 RightMinX = Views[1].ViewRect.Min.X;
    						const uint32 RightMaxX = Views[1].ViewRect.Max.X;
    						const uint32 LeftMaxY = Views[0].ViewRect.Max.Y;
    						const uint32 RightMaxY = Views[1].ViewRect.Max.Y;
    						RHICmdList.SetStereoViewport(LeftMinX, RightMinX, 0, 0, 0.0f, LeftMaxX, RightMaxX, LeftMaxY, RightMaxY, 1.0f);
    					}
    					else
    					{
    						RHICmdList.SetViewport(0, 0, 0, InstancedStereoWidth, View.ViewRect.Max.Y, 1);
    					}
    				}
    
    				if (CVarCustomDepthTemporalAAJitter.GetValueOnRenderThread() == 0 && View.AntiAliasingMethod == AAM_TemporalAA)
    				{
    					// Handle the "current" view the same, always.
    					FViewUniformShaderParameters CustomDepthViewUniformBufferParameters = *View.CachedViewUniformShaderParameters;
    
    					FBox VolumeBounds[TVC_MAX];
    
    					FViewMatrices ModifiedViewMatrices = View.ViewMatrices;
    					ModifiedViewMatrices.HackRemoveTemporalAAProjectionJitter();
    
    					View.SetupUniformBufferParameters(
    						SceneContext,
    						ModifiedViewMatrices,
    						ModifiedViewMatrices,
    						VolumeBounds,
    						TVC_MAX,
    						CustomDepthViewUniformBufferParameters);
    
    					Scene->UniformBuffers.CustomDepthViewUniformBuffer.UpdateUniformBufferImmediate(CustomDepthViewUniformBufferParameters);
    
    					if ((View.IsInstancedStereoPass() || View.bIsMobileMultiViewEnabled) && View.Family->Views.Num() > 0)
    					{
    						// When drawing the left eye in a stereo scene, set up the instanced custom depth uniform buffer with the right-eye data,
    						// with the TAA jitter removed.
    						const EStereoscopicPass StereoPassIndex = IStereoRendering::IsStereoEyeView(View) ? eSSP_RIGHT_EYE : eSSP_FULL;
    
    						const FViewInfo& InstancedView = static_cast<const FViewInfo&>(View.Family->GetStereoEyeView(StereoPassIndex));
    
    						CustomDepthViewUniformBufferParameters = *InstancedView.CachedViewUniformShaderParameters;
    						ModifiedViewMatrices = InstancedView.ViewMatrices;
    						ModifiedViewMatrices.HackRemoveTemporalAAProjectionJitter();
    
    						InstancedView.SetupUniformBufferParameters(
    							SceneContext,
    							ModifiedViewMatrices,
    							ModifiedViewMatrices,
    							VolumeBounds,
    							TVC_MAX,
    							CustomDepthViewUniformBufferParameters);
    
    						Scene->UniformBuffers.InstancedCustomDepthViewUniformBuffer.UpdateUniformBufferImmediate(reinterpret_cast<FInstancedViewUniformShaderParameters&>(CustomDepthViewUniformBufferParameters));
    					}
    				}
    				else
    				{
    					Scene->UniformBuffers.CustomDepthViewUniformBuffer.UpdateUniformBufferImmediate(*View.CachedViewUniformShaderParameters);
    					if ((View.IsInstancedStereoPass() || View.bIsMobileMultiViewEnabled) && View.Family->Views.Num() > 0)
    					{
    						const FViewInfo& InstancedView = Scene->UniformBuffers.GetInstancedView(View);
    						Scene->UniformBuffers.InstancedCustomDepthViewUniformBuffer.UpdateUniformBufferImmediate(reinterpret_cast<FInstancedViewUniformShaderParameters&>(*InstancedView.CachedViewUniformShaderParameters));
    					}
    					else
    					{
    						// If we don't render this pass in stereo we simply update the buffer with the same view uniform parameters.
    						Scene->UniformBuffers.InstancedCustomDepthViewUniformBuffer.UpdateUniformBufferImmediate(reinterpret_cast<FInstancedViewUniformShaderParameters&>(*View.CachedViewUniformShaderParameters));
    					}
    				}
    
    				extern TSet<IPersistentViewUniformBufferExtension*> PersistentViewUniformBufferExtensions;
    				
    				for (IPersistentViewUniformBufferExtension* Extension : PersistentViewUniformBufferExtensions)
    				{
    					Extension->BeginRenderView(&View);
    				}
    	
    				View.ParallelMeshDrawCommandPasses[EMeshPass::CustomDepth].DispatchDraw(nullptr, RHICmdList);
    			}
    		}
    
    		// resolve using the current ResolveParams 
    		SceneContext.FinishRenderingCustomDepth(RHICmdList);
    	}
    }

SceneContext.BeginRenderingCustomDepth(RHICmdList, bPrimitives) 在F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\Renderer\\Private\\PostProcess\\SceneRenderTargets.cpp

bool FSceneRenderTargets::BeginRenderingCustomDepth(FRHICommandListImmediate& RHICmdList, bool bPrimitives)
    {
    	check(!RHICmdList.IsInsideRenderPass());
    
    	IPooledRenderTarget* CustomDepthRenderTarget = RequestCustomDepth(RHICmdList, bPrimitives);
    
    	if(CustomDepthRenderTarget)
    	{
    		SCOPED_DRAW_EVENT(RHICmdList, BeginRenderingCustomDepth);
    
    		FRHIRenderPassInfo RPInfo;
    
    		const bool bWritesCustomStencilValues = IsCustomDepthPassWritingStencil();
    		const bool bRequiresStencilColorTarget = (bWritesCustomStencilValues && CurrentFeatureLevel <= ERHIFeatureLevel::ES3_1);
    
    		int32 NumColorTargets = 0;
    		FRHIRenderTargetView ColorView = {};
    		if (bRequiresStencilColorTarget)
    		{
    			checkSlow(MobileCustomStencil.IsValid());
    
    			RPInfo.ColorRenderTargets[0].Action = ERenderTargetActions::Clear_Store;
    			RPInfo.ColorRenderTargets[0].ArraySlice = -1;
    			RPInfo.ColorRenderTargets[0].MipIndex = 0;
    			RPInfo.ColorRenderTargets[0].RenderTarget = MobileCustomStencil->GetRenderTargetItem().ShaderResourceTexture;
    
    			ColorView =	FRHIRenderTargetView(MobileCustomStencil->GetRenderTargetItem().ShaderResourceTexture, 0, -1, ERenderTargetLoadAction::EClear, ERenderTargetStoreAction::EStore);
    			NumColorTargets = 1;
    		}
    
    		RPInfo.DepthStencilRenderTarget.Action = MakeDepthStencilTargetActions(ERenderTargetActions::Clear_Store, ERenderTargetActions::Load_Store);
    		if (bWritesCustomStencilValues)
    		{
    			RPInfo.DepthStencilRenderTarget.Action = MakeDepthStencilTargetActions(ERenderTargetActions::Clear_Store, ERenderTargetActions::Clear_Store);
    		}
    
    		RPInfo.DepthStencilRenderTarget.DepthStencilTarget = CustomDepthRenderTarget->GetRenderTargetItem().ShaderResourceTexture;
    		RPInfo.DepthStencilRenderTarget.ExclusiveDepthStencil = FExclusiveDepthStencil::DepthWrite_StencilWrite;
    
    		check(RPInfo.DepthStencilRenderTarget.DepthStencilTarget->GetStencilClearValue() == 0);
    
    		// #todo-renderpasses need ResolveRect here
    		//RPInfo.DepthStencilRenderTarget.ResolveTarget = CustomDepth->GetRenderTargetItem().ShaderResourceTexture;
    		RHICmdList.BeginRenderPass(RPInfo, TEXT("BeginRenderCustomDepth"));
    
    		return true;
    	}
    
    	return false;
    }

RequestCustomDepth()

IPooledRenderTarget* FSceneRenderTargets::RequestCustomDepth(FRHICommandListImmediate& RHICmdList, bool bPrimitives)
    {
    	int Value = CVarCustomDepth.GetValueOnRenderThread();
    	const bool bCustomDepthPassWritingStencil = IsCustomDepthPassWritingStencil();
    	const bool bMobilePath = (CurrentFeatureLevel <= ERHIFeatureLevel::ES3_1);
    
    	if ((Value == 1 && bPrimitives) || Value == 2 || bCustomDepthPassWritingStencil)
    	{
    		bool bHasValidCustomDepth = (CustomDepth.IsValid() && BufferSize == CustomDepth->GetDesc().Extent && !GFastVRamConfig.bDirty);
    		bool bHasValidCustomStencil;
    		if (bMobilePath)
    		{
    			bHasValidCustomStencil = (MobileCustomStencil.IsValid() && BufferSize == MobileCustomStencil->GetDesc().Extent);
    		}
    		else
    		{
    			bHasValidCustomStencil = CustomStencilSRV.IsValid();
    		}
    						
    		if (!(bHasValidCustomDepth && bHasValidCustomStencil))
    		{
    			// Skip depth decompression, custom depth doesn't benefit from it
    			// Also disables fast clears, but typically only a small portion of custom depth is written to anyway
    			uint32 CustomDepthFlags = TexCreate_NoFastClear;
    
    			// Todo: Could check if writes stencil here and create min viable target
    			FPooledRenderTargetDesc Desc(FPooledRenderTargetDesc::Create2DDesc(BufferSize, PF_DepthStencil, FClearValueBinding::DepthFar, CustomDepthFlags, TexCreate_DepthStencilTargetable | TexCreate_ShaderResource, false));
    			Desc.Flags |= GFastVRamConfig.CustomDepth;
    			GRenderTargetPool.FindFreeElement(RHICmdList, Desc, CustomDepth, TEXT("CustomDepth"), true, ERenderTargetTransience::NonTransient);
    			
    			if (bMobilePath)
    			{
    				FPooledRenderTargetDesc MobileCustomStencilDesc(FPooledRenderTargetDesc::Create2DDesc(BufferSize, PF_B8G8R8A8, FClearValueBinding::Transparent, TexCreate_None, TexCreate_RenderTargetable | TexCreate_ShaderResource, false));
    				GRenderTargetPool.FindFreeElement(RHICmdList, MobileCustomStencilDesc, MobileCustomStencil, TEXT("MobileCustomStencil"));
    			}
    			else
    			{
    				//CustomStencilSRV = RHICreateShaderResourceView((FTexture2DRHIRef&)CustomDepth->GetRenderTargetItem().TargetableTexture, 0, 1, PF_X24_G8);
    				CustomStencilSRV = RHICreateShaderResourceView((FTexture2DRHIRef&)CustomDepth->GetRenderTargetItem().TargetableTexture, 0, 1, PF_B8G8R8A8);
    			}
    		}
    		return CustomDepth;
    	}
    
    	return 0;
    }

F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\Renderer\\Private\\PostProcess\\SceneRenderTargets.h

// GBuffer: Geometry Buffer rendered in base pass for deferred shading, only available between AllocGBufferTargets() and FreeGBufferTargets()
    	TRefCountPtr<IPooledRenderTarget> GBufferA;
    	TRefCountPtr<IPooledRenderTarget> GBufferB;
    	TRefCountPtr<IPooledRenderTarget> GBufferC;
    	TRefCountPtr<IPooledRenderTarget> GBufferD;
    	TRefCountPtr<IPooledRenderTarget> GBufferE;
    
    	// DBuffer: For decals before base pass (only temporarily available after early z pass and until base pass)
    	TRefCountPtr<IPooledRenderTarget> DBufferA;
    	TRefCountPtr<IPooledRenderTarget> DBufferB;
    	TRefCountPtr<IPooledRenderTarget> DBufferC;
    	TRefCountPtr<IPooledRenderTarget> DBufferMask;
    
    	// for AmbientOcclusion, only valid for a short time during the frame to allow reuse
    	TRefCountPtr<IPooledRenderTarget> ScreenSpaceAO;
    	TRefCountPtr<IPooledRenderTarget> ScreenSpaceGTAOHorizons;
    	// for shader/quad complexity, the temporary quad descriptors and complexity.
    	TRefCountPtr<IPooledRenderTarget> QuadOverdrawBuffer;
    	// used by the CustomDepth material feature, is allocated on demand or if r.CustomDepth is 2
    	TRefCountPtr<IPooledRenderTarget> CustomDepth;
    	TRefCountPtr<IPooledRenderTarget> MobileCustomStencil;
    	// used by the CustomDepth material feature for stencil
    	TRefCountPtr<FRHIShaderResourceView> CustomStencilSRV;
    	// optional in case this RHI requires a color render target (adjust up if necessary)
    	TRefCountPtr<IPooledRenderTarget> OptionalShadowDepthColor[4];

FindFreeElement() F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\RenderCore\\Private\\RenderTargetPool.cpp

bool FRenderTargetPool::FindFreeElement(FRHICommandList& RHICmdList, const FPooledRenderTargetDesc& InputDesc, TRefCountPtr<IPooledRenderTarget> &Out, const TCHAR* InDebugName, bool bDoWritableBarrier, ERenderTargetTransience TransienceHint, bool bDeferTextureAllocation)
    {
    	check(IsInRenderingThread());
    
    	if (!InputDesc.IsValid())
    	{
    		// no need to do anything
    		return true;
    	}
    
    	// Querying a render target that have no mip levels makes no sens.
    	check(InputDesc.NumMips > 0);
    
    	// Make sure if requesting a depth format that the clear value is correct
    	ensure(!IsDepthOrStencilFormat(InputDesc.Format) || (InputDesc.ClearValue.ColorBinding == EClearBinding::ENoneBound || InputDesc.ClearValue.ColorBinding == EClearBinding::EDepthStencilBound));
    
    	// If we're doing aliasing, we may need to override Transient flags, depending on the input format and mode
    	FPooledRenderTargetDesc ModifiedDesc;
    	bool bMakeTransient = DoesTargetNeedTransienceOverride(InputDesc, TransienceHint);
    	if (bMakeTransient)
    	{
    		ModifiedDesc = InputDesc;
    		ModifiedDesc.Flags |= TexCreate_Transient;
    	}
    
    	// Override the descriptor if necessary
    	const FPooledRenderTargetDesc& Desc = bMakeTransient ? ModifiedDesc : InputDesc;
    
    	// if we can keep the current one, do that
    	if (Out)
    	{
    		FPooledRenderTarget* Current = (FPooledRenderTarget*)Out.GetReference();
    
    		check(!Current->IsSnapshot());
    
    		const bool bExactMatch = true;
    
    		if (Out->GetDesc().Compare(Desc, bExactMatch))
    		{
    			// we can reuse the same, but the debug name might have changed
    			Current->Desc.DebugName = InDebugName;
    			if (Current->GetRenderTargetItem().TargetableTexture)
    			{
    				RHIBindDebugLabelName(Current->GetRenderTargetItem().TargetableTexture, InDebugName);
    			}
    			check(!Out->IsFree());
    			return true;
    		}
    		else
    		{
    			// release old reference, it might free a RT we can use
    			Out = 0;
    
    			if (Current->IsFree())
    			{
    				AllocationLevelInKB -= ComputeSizeInKB(*Current);
    
    				int32 Index = FindIndex(Current);
    
    				check(Index >= 0);
    
    				// we don't use Remove() to not shuffle around the elements for better transparency on RenderTargetPoolEvents
    				PooledRenderTargets[Index] = 0;
    
    				VerifyAllocationLevel();
    			}
    		}
    	}
    
    	int32 AliasingMode = CVarRtPoolTransientMode.GetValueOnRenderThread();
    	FPooledRenderTarget* Found = 0;
    	uint32 FoundIndex = -1;
    	bool bReusingExistingTarget = false;
    	// try to find a suitable element in the pool
    	{
    		//don't spend time doing 2 passes if the platform doesn't support fastvram
    		uint32 PassCount = 1;
    		if (AliasingMode == 0)
    		{
    			if ((Desc.Flags & TexCreate_FastVRAM) && FPlatformMemory::SupportsFastVRAMMemory() )
    			{
    				PassCount = 2;
    			}
    		}
    
    		bool bAllowMultipleDiscards = ( CVarAllowMultipleAliasingDiscardsPerFrame.GetValueOnRenderThread() != 0 );
    		// first we try exact, if that fails we try without TexCreate_FastVRAM
    		// (easily we can run out of VRam, if this search becomes a performance problem we can optimize or we should use less TexCreate_FastVRAM)
    		for (uint32 Pass = 0; Pass < PassCount; ++Pass)
    		{
    			bool bExactMatch = (Pass == 0); //-V547
        
    			for (uint32 i = 0, Num = (uint32)PooledRenderTargets.Num(); i < Num; ++i)
    			{
    				FPooledRenderTarget* Element = PooledRenderTargets[i];
    				if (Element && Element->GetDesc().Compare(Desc, bExactMatch))
    				{
    					int a = 0;
    				}
        
    				if (Element && Element->IsFree() && Element->GetDesc().Compare(Desc, bExactMatch))
    				{
    					if ( ( Desc.Flags & TexCreate_Transient ) && bAllowMultipleDiscards == false && Element->HasBeenDiscardedThisFrame() )
    					{
    						// We can't re-use transient resources if they've already been discarded this frame
    						continue;
    					}
    					check(!Element->IsSnapshot());
    					Found = Element;
    					FoundIndex = i;
    					bReusingExistingTarget = true;
    					goto Done;
    				}
    			}
    		}
    	}
    Done:
    
    	if (!Found)
    	{
    		UE_LOG(LogRenderTargetPool, Display, TEXT("%d MB, NewRT %s %s"), (AllocationLevelInKB + 1023) / 1024, *Desc.GenerateInfoString(), InDebugName);
    
    		// not found in the pool, create a new element
    		Found = new FPooledRenderTarget(Desc, this);
    
    		PooledRenderTargets.Add(Found);
    		
    		// TexCreate_UAV should be used on Desc.TargetableFlags
    		check(!(Desc.Flags & TexCreate_UAV));
    		// TexCreate_FastVRAM should be used on Desc.Flags
    		ensure(!(Desc.TargetableFlags & TexCreate_FastVRAM));
    
    		FRHIResourceCreateInfo CreateInfo(Desc.ClearValue);
    		CreateInfo.DebugName = InDebugName;
    
    		if (Desc.TargetableFlags & (TexCreate_RenderTargetable | TexCreate_DepthStencilTargetable | TexCreate_UAV) && !bDeferTextureAllocation)
    		{
    			// Only create resources if we're not asked to defer creation.
    			if (Desc.Is2DTexture())
    			{
    				if (!Desc.IsArray())
    				{
    					RHICreateTargetableShaderResource2D(
    						Desc.Extent.X,
    						Desc.Extent.Y,
    						Desc.Format,
    						Desc.NumMips,
    						Desc.Flags,
    						Desc.TargetableFlags,
    						Desc.bForceSeparateTargetAndShaderResource,
    						Desc.bForceSharedTargetAndShaderResource,
    						CreateInfo,
    						(FTexture2DRHIRef&)Found->RenderTargetItem.TargetableTexture,
    						(FTexture2DRHIRef&)Found->RenderTargetItem.ShaderResourceTexture,
    						Desc.NumSamples
    					);
    				}
    				else
    				{
    					RHICreateTargetableShaderResource2DArray(
    						Desc.Extent.X,
    						Desc.Extent.Y,
    						Desc.ArraySize,
    						Desc.Format,
    						Desc.NumMips,
    						Desc.Flags,
    						Desc.TargetableFlags,
    						Desc.bForceSeparateTargetAndShaderResource,
    						Desc.bForceSharedTargetAndShaderResource,
    						CreateInfo,
    						(FTexture2DArrayRHIRef&)Found->RenderTargetItem.TargetableTexture,
    						(FTexture2DArrayRHIRef&)Found->RenderTargetItem.ShaderResourceTexture,
    						Desc.NumSamples
    					);
    				}
    
    				if (RHISupportsRenderTargetWriteMask(GMaxRHIShaderPlatform) && Desc.bCreateRenderTargetWriteMask)
    				{
    					Found->RenderTargetItem.RTWriteMaskSRV = RHICreateShaderResourceViewWriteMask((FTexture2DRHIRef&)Found->RenderTargetItem.TargetableTexture);
    				}
    				if (Desc.bCreateRenderTargetFmask)
    				{
    					Found->RenderTargetItem.FmaskSRV = RHICreateShaderResourceViewFMask((FTexture2DRHIRef&)Found->RenderTargetItem.TargetableTexture);
    				}
    			}
    			else if (Desc.Is3DTexture())
    			{
    				Found->RenderTargetItem.ShaderResourceTexture = RHICreateTexture3D(
    					Desc.Extent.X,
    					Desc.Extent.Y,
    					Desc.Depth,
    					Desc.Format,
    					Desc.NumMips,
    					Desc.Flags | Desc.TargetableFlags,
    					CreateInfo);
    
    				// similar to RHICreateTargetableShaderResource2D
    				Found->RenderTargetItem.TargetableTexture = Found->RenderTargetItem.ShaderResourceTexture;
    			}
    			else
    			{
    				check(Desc.IsCubemap());
    				if (Desc.IsArray())
    				{
    					RHICreateTargetableShaderResourceCubeArray(
    						Desc.Extent.X,
    						Desc.ArraySize,
    						Desc.Format,
    						Desc.NumMips,
    						Desc.Flags,
    						Desc.TargetableFlags,
    						false,
    						CreateInfo,
    						(FTextureCubeRHIRef&)Found->RenderTargetItem.TargetableTexture,
    						(FTextureCubeRHIRef&)Found->RenderTargetItem.ShaderResourceTexture
    						);
    				}
    				else
    				{
    					RHICreateTargetableShaderResourceCube(
    						Desc.Extent.X,
    						Desc.Format,
    						Desc.NumMips,
    						Desc.Flags,
    						Desc.TargetableFlags,
    						false,
    						CreateInfo,
    						(FTextureCubeRHIRef&)Found->RenderTargetItem.TargetableTexture,
    						(FTextureCubeRHIRef&)Found->RenderTargetItem.ShaderResourceTexture
    						);
    				}
    			}
    
    			RHIBindDebugLabelName(Found->RenderTargetItem.TargetableTexture, InDebugName);
    		}
    		else if (!bDeferTextureAllocation)
    		{
    			// Only create resources if we're not asked to defer creation.
    			if (Desc.Is2DTexture())
    			{
    				// this is useful to get a CPU lockable texture through the same interface
    				Found->RenderTargetItem.ShaderResourceTexture = RHICreateTexture2D(
    					Desc.Extent.X,
    					Desc.Extent.Y,
    					Desc.Format,
    					Desc.NumMips,
    					Desc.NumSamples,
    					Desc.Flags,
    					CreateInfo);
    			}
    			else if (Desc.Is3DTexture())
    			{
    				Found->RenderTargetItem.ShaderResourceTexture = RHICreateTexture3D(
    					Desc.Extent.X,
    					Desc.Extent.Y,
    					Desc.Depth,
    					Desc.Format,
    					Desc.NumMips,
    					Desc.Flags,
    					CreateInfo);
    			}
    			else 
    			{
    				check(Desc.IsCubemap());
    				if (Desc.IsArray())
    				{
    					FTextureCubeRHIRef CubeTexture = RHICreateTextureCubeArray(Desc.Extent.X,Desc.ArraySize,Desc.Format,Desc.NumMips,Desc.Flags | Desc.TargetableFlags | TexCreate_ShaderResource,CreateInfo);
    					Found->RenderTargetItem.TargetableTexture = Found->RenderTargetItem.ShaderResourceTexture = CubeTexture;
    				}
    				else
    				{
    					FTextureCubeRHIRef CubeTexture = RHICreateTextureCube(Desc.Extent.X,Desc.Format,Desc.NumMips,Desc.Flags | Desc.TargetableFlags | TexCreate_ShaderResource,CreateInfo);
    					Found->RenderTargetItem.TargetableTexture = Found->RenderTargetItem.ShaderResourceTexture = CubeTexture;
    				}
    			}
    
    			RHIBindDebugLabelName(Found->RenderTargetItem.ShaderResourceTexture, InDebugName);
    		}
    
    		if ((Desc.TargetableFlags & TexCreate_UAV) && !bDeferTextureAllocation)
    		{
    			// The render target desc is invalid if a UAV is requested with an RHI that doesn't support the high-end feature level.
    			check(GMaxRHIFeatureLevel == ERHIFeatureLevel::SM5 || GMaxRHIFeatureLevel == ERHIFeatureLevel::ES3_1);
    			Found->RenderTargetItem.MipUAVs.Reserve(Desc.NumMips);
    			for (uint32 MipLevel = 0; MipLevel < Desc.NumMips; MipLevel++)
    			{
    				Found->RenderTargetItem.MipUAVs.Add(RHICreateUnorderedAccessView(Found->RenderTargetItem.TargetableTexture, MipLevel));
    			}
    
    			Found->RenderTargetItem.UAV = Found->RenderTargetItem.MipUAVs[0];
    		}
    
    		if (!bDeferTextureAllocation)
    		{
    			// Only calculate allocation level if we actually allocated something. If bDeferTextureAllocation is true, the caller should call 
    			// UpdateElementSize once it's set the resources on the created object.
    			AllocationLevelInKB += ComputeSizeInKB(*Found);
    			VerifyAllocationLevel();
    		}
    
    		FoundIndex = PooledRenderTargets.Num() - 1;
    
    		Found->Desc.DebugName = InDebugName;
    	}
    
    	check(Found->IsFree());
    	check(!Found->IsSnapshot());
    
    	Found->Desc.DebugName = InDebugName;
    	Found->UnusedForNFrames = 0;
    
    	AddAllocEvent(FoundIndex, Found);
    
    	uint32 OriginalNumRefs = Found->GetRefCount();
    
    	// assign to the reference counted variable
    	Out = Found;
    
    	check(!Found->IsFree());
    
    	// Only referenced by the pool, map the physical pages
    	if (OriginalNumRefs == 1 && Found->GetRenderTargetItem().TargetableTexture != nullptr)
    	{
    		RHIAcquireTransientResource(Found->GetRenderTargetItem().TargetableTexture);
    	}
    
    	if (bReusingExistingTarget)
    	{
    		if (bDoWritableBarrier)
    		{
    			RHICmdList.TransitionResource(EResourceTransitionAccess::EWritable, Found->GetRenderTargetItem().TargetableTexture);
    		}
    	}
    
    	// Transient RTs have to be targettable
    	check( ( Desc.Flags & TexCreate_Transient ) == 0 || Found->GetRenderTargetItem().TargetableTexture != nullptr );
    
    	return false;
    }

RHICreateTargetableShaderResource2D() in F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\RHI\\Public\\RHIUtilities.h

/**
     * Creates 1 or 2 textures with the same dimensions/format.
     * If the RHI supports textures that can be used as both shader resources and render targets,
     * and bForceSeparateTargetAndShaderResource=false, then a single texture is created.
     * Otherwise two textures are created, one of them usable as a shader resource and resolve target, and one of them usable as a render target.
     * Two texture references are always returned, but they may reference the same texture.
     * If two different textures are returned, the render-target texture must be manually copied to the shader-resource texture.
     */
    inline void RHICreateTargetableShaderResource2D(
    	uint32 SizeX,
    	uint32 SizeY,
    	uint8 Format,	
    	uint32 NumMips,
    	uint32 Flags,
    	uint32 TargetableTextureFlags,
    	bool bForceSeparateTargetAndShaderResource,
    	bool bForceSharedTargetAndShaderResource,
    	FRHIResourceCreateInfo& CreateInfo,
    	FTexture2DRHIRef& OutTargetableTexture,
    	FTexture2DRHIRef& OutShaderResourceTexture,
    	uint32 NumSamples = 1
    )
    {
    	// Ensure none of the usage flags are passed in.
    	check(!(Flags & TexCreate_RenderTargetable));
    	check(!(Flags & TexCreate_ResolveTargetable));
    	check(!(Flags & TexCreate_ShaderResource));
    
    	// Ensure we aren't forcing separate and shared textures at the same time.
    	check(!(bForceSeparateTargetAndShaderResource && bForceSharedTargetAndShaderResource));
    
    	// Ensure that all of the flags provided for the targetable texture are not already passed in Flags.
    	check(!(Flags & TargetableTextureFlags));
    
    	// Ensure that the targetable texture is either render or depth-stencil targetable.
    	check(TargetableTextureFlags & (TexCreate_RenderTargetable | TexCreate_DepthStencilTargetable | TexCreate_UAV));
    
    	if (NumSamples > 1 && !bForceSharedTargetAndShaderResource)
    	{
    		bForceSeparateTargetAndShaderResource = RHISupportsSeparateMSAAAndResolveTextures(GMaxRHIShaderPlatform);
    	}
    
    	if (!bForceSeparateTargetAndShaderResource)
    	{
    		// Create a single texture that has both TargetableTextureFlags and TexCreate_ShaderResource set.
    		OutTargetableTexture = OutShaderResourceTexture = RHICreateTexture2D(SizeX, SizeY, Format, NumMips, NumSamples, Flags | TargetableTextureFlags | TexCreate_ShaderResource, CreateInfo);
    	}
    	else
    	{
    		uint32 ResolveTargetableTextureFlags = TexCreate_ResolveTargetable;
    		if (TargetableTextureFlags & TexCreate_DepthStencilTargetable)
    		{
    			ResolveTargetableTextureFlags |= TexCreate_DepthStencilResolveTarget;
    		}
    		// Create a texture that has TargetableTextureFlags set, and a second texture that has TexCreate_ResolveTargetable and TexCreate_ShaderResource set.
    		OutTargetableTexture = RHICreateTexture2D(SizeX, SizeY, Format, NumMips, NumSamples, Flags | TargetableTextureFlags, CreateInfo);
    		OutShaderResourceTexture = RHICreateTexture2D(SizeX, SizeY, Format, NumMips, 1, Flags | ResolveTargetableTextureFlags | TexCreate_ShaderResource, CreateInfo);
    	}
    }

RHICreateTexture2D() in F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\RHI\\Public\\RHICommandList.h

FORCEINLINE FTexture2DRHIRef RHICreateTexture2D(uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, uint32 NumSamples, uint32 Flags, FRHIResourceCreateInfo& CreateInfo)
    {
    	return FRHICommandListExecutor::GetImmediateCommandList().CreateTexture2D(SizeX, SizeY, Format, NumMips, NumSamples, Flags, CreateInfo);
    }
    
    FORCEINLINE FTexture2DRHIRef CreateTexture2D(uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, uint32 NumSamples, uint32 Flags, FRHIResourceCreateInfo& CreateInfo)
    {
    	LLM_SCOPE((Flags & (TexCreate_RenderTargetable | TexCreate_DepthStencilTargetable)) != 0 ? ELLMTag::RenderTargets : ELLMTag::Textures);
    	return GDynamicRHI->RHICreateTexture2D_RenderThread(*this, SizeX, SizeY, Format, NumMips, NumSamples, Flags, CreateInfo);
    }

RHICreateTexture2D\_RenderThread() in F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\RHI\\Private\\RHICommandList.cpp

FTexture2DRHIRef FDynamicRHI::RHICreateTexture2D_RenderThread(class FRHICommandListImmediate& RHICmdList, uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, uint32 NumSamples, uint32 Flags, FRHIResourceCreateInfo& CreateInfo)
    {
    	CSV_SCOPED_TIMING_STAT(RHITStalls, RHICreateTexture2D_RenderThread);
    	FScopedRHIThreadStaller StallRHIThread(RHICmdList);
    	return GDynamicRHI->RHICreateTexture2D(SizeX, SizeY, Format, NumMips, NumSamples, Flags, CreateInfo);
    }

RHICreateTexture2D() in F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\Windows\\D3D11RHI\\Private\\D3D11Texture.cpp

FTexture2DRHIRef FD3D11DynamicRHI::RHICreateTexture2D(uint32 SizeX,uint32 SizeY,uint8 Format,uint32 NumMips,uint32 NumSamples,uint32 Flags,FRHIResourceCreateInfo& CreateInfo)
    {
    	return CreateD3D11Texture2D<FD3D11BaseTexture2D>(SizeX,SizeY,1,false,false,Format,NumMips,NumSamples,Flags,CreateInfo);
    }
    
    
    template<typename BaseResourceType>
    TD3D11Texture2D<BaseResourceType>* FD3D11DynamicRHI::CreateD3D11Texture2D(uint32 SizeX,uint32 SizeY,uint32 SizeZ,bool bTextureArray,bool bCubeTexture,uint8 Format,
    	uint32 NumMips,uint32 NumSamples,uint32 Flags, FRHIResourceCreateInfo& CreateInfo)
    {
    	check(SizeX > 0 && SizeY > 0 && NumMips > 0);
    
    	if (bCubeTexture)
    	{
    		checkf(SizeX <= GetMaxCubeTextureDimension(), TEXT("Requested cube texture size too large: %i, %i"), SizeX, GetMaxCubeTextureDimension());
    		check(SizeX == SizeY);
    	}
    	else
    	{
    		checkf(SizeX <= GetMax2DTextureDimension(), TEXT("Requested texture2d x size too large: %i, %i"), SizeX, GetMax2DTextureDimension());
    		checkf(SizeY <= GetMax2DTextureDimension(), TEXT("Requested texture2d y size too large: %i, %i"), SizeY, GetMax2DTextureDimension());
    	}
    
    	if (bTextureArray)
    	{
    		checkf(SizeZ <= GetMaxTextureArrayLayers(), TEXT("Requested texture array size too large: %i, %i"), SizeZ, GetMaxTextureArrayLayers());
    	}
    
    	// Render target allocation with UAV flag will silently fail in feature level 10
    	check(FeatureLevel >= D3D_FEATURE_LEVEL_11_0 || !(Flags & TexCreate_UAV));
    
    	SCOPE_CYCLE_COUNTER(STAT_D3D11CreateTextureTime);
    
    	bool bPooledTexture = true;
    
    	if (GMaxRHIFeatureLevel == ERHIFeatureLevel::ES2)
    	{
    		// Remove sRGB read flag when not supported
    		Flags &= ~TexCreate_SRGB;
    	}
    
    	const bool bSRGB = (Flags & TexCreate_SRGB) != 0;
    
    	const DXGI_FORMAT PlatformResourceFormat = FD3D11DynamicRHI::GetPlatformTextureResourceFormat((DXGI_FORMAT)GPixelFormats[Format].PlatformFormat, Flags);
    	const DXGI_FORMAT PlatformShaderResourceFormat = FindShaderResourceDXGIFormat(PlatformResourceFormat, bSRGB);
    	const DXGI_FORMAT PlatformRenderTargetFormat = FindShaderResourceDXGIFormat(PlatformResourceFormat, bSRGB);
    	
    	// Determine the MSAA settings to use for the texture.
    	D3D11_DSV_DIMENSION DepthStencilViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
    	D3D11_RTV_DIMENSION RenderTargetViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
    	D3D11_SRV_DIMENSION ShaderResourceViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
    	uint32 CPUAccessFlags = 0;
    	D3D11_USAGE TextureUsage = D3D11_USAGE_DEFAULT;
    	bool bCreateShaderResource = true;
    
    	uint32 ActualMSAACount = NumSamples;
    
    	uint32 ActualMSAAQuality = GetMaxMSAAQuality(ActualMSAACount);
    
    	// 0xffffffff means not supported
    	if (ActualMSAAQuality == 0xffffffff || (Flags & TexCreate_Shared) != 0)
    	{
    		// no MSAA
    		ActualMSAACount = 1;
    		ActualMSAAQuality = 0;
    	}
    
    	if(ActualMSAACount > 1)
    	{
    		DepthStencilViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
    		RenderTargetViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
    		ShaderResourceViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
    		bPooledTexture = false;
    	}
    
    	if (NumMips < 1 || SizeX != SizeY || (1 << (NumMips - 1)) != SizeX || (Flags & TexCreate_Shared) != 0)
    	{
    		bPooledTexture = false;
    	}
    
    	if (Flags & TexCreate_CPUReadback)
    	{
    		check(!(Flags & TexCreate_RenderTargetable));
    		check(!(Flags & TexCreate_DepthStencilTargetable));
    		check(!(Flags & TexCreate_ShaderResource));
    
    		CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    		TextureUsage = D3D11_USAGE_STAGING;
    		bCreateShaderResource = false;
    	}
    
    	if (Flags & TexCreate_CPUWritable)
    	{
    		CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    		TextureUsage = D3D11_USAGE_STAGING;
    		bCreateShaderResource = false;
    	}
    
    	// Describe the texture.
    	D3D11_TEXTURE2D_DESC TextureDesc;
    	ZeroMemory( &TextureDesc, sizeof( D3D11_TEXTURE2D_DESC ) );
    	TextureDesc.Width = SizeX;
    	TextureDesc.Height = SizeY;
    	TextureDesc.MipLevels = NumMips;
    	TextureDesc.ArraySize = SizeZ;
    	TextureDesc.Format = PlatformResourceFormat;
    	TextureDesc.SampleDesc.Count = ActualMSAACount;
    	TextureDesc.SampleDesc.Quality = ActualMSAAQuality;
    	TextureDesc.Usage = TextureUsage;
    	TextureDesc.BindFlags = bCreateShaderResource? D3D11_BIND_SHADER_RESOURCE : 0;
    	TextureDesc.CPUAccessFlags = CPUAccessFlags;
    	TextureDesc.MiscFlags = bCubeTexture ? D3D11_RESOURCE_MISC_TEXTURECUBE : 0;
    
    	// NV12 doesn't support SRV in NV12 format so don't create SRV for it.
    	// Todo: add support for SRVs of underneath luminance & chrominance textures.
    	if (Format == PF_NV12)
    	{
    		// JoeG - I moved this to below the bind flags because it is valid to bind R8 or B8G8 to this
    		// And creating a SRV afterward would fail because of the missing bind flags
    		bCreateShaderResource = false;
    	}
    
    	if (Flags & TexCreate_DisableSRVCreation)
    	{
    		bCreateShaderResource = false;
    	}
    
    	if (Flags & TexCreate_Shared)
    	{
    		TextureDesc.MiscFlags |= D3D11_RESOURCE_MISC_SHARED;
    	}
    
    	if (Flags & TexCreate_GenerateMipCapable)
    	{
    		// Set the flag that allows us to call GenerateMips on this texture later
    		TextureDesc.MiscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS;
    		bPooledTexture = false;
    	}
    
    	// Set up the texture bind flags.
    	bool bCreateRTV = false;
    	bool bCreateDSV = false;
    	bool bCreatedRTVPerSlice = false;
    
    	if(Flags & TexCreate_RenderTargetable)
    	{
    		check(!(Flags & TexCreate_DepthStencilTargetable));
    		check(!(Flags & TexCreate_ResolveTargetable));		
    		TextureDesc.BindFlags |= D3D11_BIND_RENDER_TARGET;
    		bCreateRTV = true;		
    	}
    	else if(Flags & TexCreate_DepthStencilTargetable)
    	{
    		check(!(Flags & TexCreate_RenderTargetable));
    		check(!(Flags & TexCreate_ResolveTargetable));
    		TextureDesc.BindFlags |= D3D11_BIND_DEPTH_STENCIL; 
    		bCreateDSV = true;
    	}
    	else if(Flags & TexCreate_ResolveTargetable)
    	{
    		check(!(Flags & TexCreate_RenderTargetable));
    		check(!(Flags & TexCreate_DepthStencilTargetable));
    		if(Format == PF_DepthStencil || Format == PF_ShadowDepth || Format == PF_D24)
    		{
    			TextureDesc.BindFlags |= D3D11_BIND_DEPTH_STENCIL; 
    			bCreateDSV = true;
    		}
    		else
    		{
    			TextureDesc.BindFlags |= D3D11_BIND_RENDER_TARGET;
    			bCreateRTV = true;
    		}
    	}
    	// NV12 doesn't support RTV in NV12 format so don't create RTV for it.
    	// Todo: add support for RTVs of underneath luminance & chrominance textures.
    	if (Format == PF_NV12)
    	{
    		bCreateRTV = false;
    	}
    
    	if (Flags & TexCreate_UAV)
    	{
    		TextureDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
    		bPooledTexture = false;
    	}
    
    	if (bCreateDSV && !(Flags & TexCreate_ShaderResource))
    	{
    		TextureDesc.BindFlags &= ~D3D11_BIND_SHADER_RESOURCE;
    		bCreateShaderResource = false;
    	}
    
    	if (bCreateDSV || bCreateRTV || bCubeTexture || bTextureArray)
    	{
    		bPooledTexture = false;
    	}
    
    	FVRamAllocation VRamAllocation;
    
    	if (FPlatformMemory::SupportsFastVRAMMemory())
    	{
    		if (Flags & TexCreate_FastVRAM)
    		{
    			VRamAllocation = FFastVRAMAllocator::GetFastVRAMAllocator()->AllocTexture2D(TextureDesc);
    		}
    	}
    
    	TRefCountPtr<ID3D11Texture2D> TextureResource;
    	TRefCountPtr<ID3D11ShaderResourceView> ShaderResourceView;
    	TArray<TRefCountPtr<ID3D11RenderTargetView> > RenderTargetViews;
    	TRefCountPtr<ID3D11DepthStencilView> DepthStencilViews[FExclusiveDepthStencil::MaxIndex];
    	
    #if PLATFORM_SUPPORTS_VIRTUAL_TEXTURES
    	// Turn off pooling when we are using virtual textures or the texture is offline processed as we control when the memory is released
    	if ( (Flags & (TexCreate_Virtual | TexCreate_OfflineProcessed)) != 0 )
    	{
    		bPooledTexture = false;
    	}
    	void* RawTextureMemory = nullptr;
    #else
    	Flags &= ~TexCreate_Virtual;
    #endif
    
    	if (bPooledTexture)
    	{
    		FPooledTexture2D PooledTexture;
    		if (GetPooledTexture2D(NumMips, (EPixelFormat)Format, &PooledTexture))
    		{
    			TextureResource = PooledTexture.Resource;
    		}
    	}
    
    	if (!IsValidRef(TextureResource))
    	{
    		TArray<D3D11_SUBRESOURCE_DATA> SubResourceData;
    
    		if (CreateInfo.BulkData)
    		{
    			uint8* Data = (uint8*)CreateInfo.BulkData->GetResourceBulkData();
    
    			// each mip of each array slice counts as a subresource
    			SubResourceData.AddZeroed(NumMips * SizeZ);
    
    			uint32 SliceOffset = 0;
    			for (uint32 ArraySliceIndex = 0; ArraySliceIndex < SizeZ; ++ArraySliceIndex)
    			{			
    				uint32 MipOffset = 0;
    				for(uint32 MipIndex = 0;MipIndex < NumMips;++MipIndex)
    				{
    					uint32 DataOffset = SliceOffset + MipOffset;
    					uint32 SubResourceIndex = ArraySliceIndex * NumMips + MipIndex;
    
    					uint32 NumBlocksX = FMath::Max<uint32>(1,(SizeX >> MipIndex) / GPixelFormats[Format].BlockSizeX);
    					uint32 NumBlocksY = FMath::Max<uint32>(1,(SizeY >> MipIndex) / GPixelFormats[Format].BlockSizeY);
    
    					SubResourceData[SubResourceIndex].pSysMem = &Data[DataOffset];
    					SubResourceData[SubResourceIndex].SysMemPitch      =  NumBlocksX * GPixelFormats[Format].BlockBytes;
    					SubResourceData[SubResourceIndex].SysMemSlicePitch =  NumBlocksX * NumBlocksY * SubResourceData[MipIndex].SysMemPitch;
    
    					MipOffset                                  += NumBlocksY * SubResourceData[MipIndex].SysMemPitch;
    				}
    				SliceOffset += MipOffset;
    			}
    		}
    
    #if PLATFORM_SUPPORTS_VIRTUAL_TEXTURES
    		if ( (Flags & (TexCreate_Virtual | TexCreate_OfflineProcessed)) != 0 )
    		{
    			RawTextureMemory = CreateVirtualTexture(SizeX, SizeY, SizeZ, NumMips, bCubeTexture, Flags, &TextureDesc, &TextureResource);
    		}
    		else
    #endif
    		{
    			SafeCreateTexture2D(Direct3DDevice, Format, &TextureDesc, CreateInfo.BulkData != NULL ? (const D3D11_SUBRESOURCE_DATA*)SubResourceData.GetData() : NULL, TextureResource.GetInitReference());
    		}
    
    		if(bCreateRTV)
    		{
    			// Create a render target view for each mip
    			for (uint32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
    			{
    				if ((Flags & TexCreate_TargetArraySlicesIndependently) && (bTextureArray || bCubeTexture))
    				{
    					bCreatedRTVPerSlice = true;
    
    					for (uint32 SliceIndex = 0; SliceIndex < TextureDesc.ArraySize; SliceIndex++)
    					{
    						D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;
    						FMemory::Memzero(&RTVDesc,sizeof(RTVDesc));
    						RTVDesc.Format = PlatformRenderTargetFormat;
    						RTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
    						RTVDesc.Texture2DArray.FirstArraySlice = SliceIndex;
    						RTVDesc.Texture2DArray.ArraySize = 1;
    						RTVDesc.Texture2DArray.MipSlice = MipIndex;
    
    						TRefCountPtr<ID3D11RenderTargetView> RenderTargetView;
    						VERIFYD3D11RESULT_EX(Direct3DDevice->CreateRenderTargetView(TextureResource,&RTVDesc,RenderTargetView.GetInitReference()), Direct3DDevice);
    						RenderTargetViews.Add(RenderTargetView);
    					}
    				}
    				else
    				{
    					D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;
    					FMemory::Memzero(&RTVDesc,sizeof(RTVDesc));
    					RTVDesc.Format = PlatformRenderTargetFormat;
    					if (bTextureArray || bCubeTexture)
    					{
    						RTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
    						RTVDesc.Texture2DArray.FirstArraySlice = 0;
    						RTVDesc.Texture2DArray.ArraySize = TextureDesc.ArraySize;
    						RTVDesc.Texture2DArray.MipSlice = MipIndex;
    					}
    					else
    					{
    						RTVDesc.ViewDimension = RenderTargetViewDimension;
    						RTVDesc.Texture2D.MipSlice = MipIndex;
    					}
    
    					TRefCountPtr<ID3D11RenderTargetView> RenderTargetView;
    					VERIFYD3D11RESULT_EX(Direct3DDevice->CreateRenderTargetView(TextureResource,&RTVDesc,RenderTargetView.GetInitReference()), Direct3DDevice);
    					RenderTargetViews.Add(RenderTargetView);
    				}
    			}
    		}
    	
    		if(bCreateDSV)
    		{
    			// Create a depth-stencil-view for the texture.
    			D3D11_DEPTH_STENCIL_VIEW_DESC DSVDesc;
    			FMemory::Memzero(&DSVDesc,sizeof(DSVDesc));
    			DSVDesc.Format = FindDepthStencilDXGIFormat(PlatformResourceFormat);
    			if(bTextureArray || bCubeTexture)
    			{
    				DSVDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
    				DSVDesc.Texture2DArray.FirstArraySlice = 0;
    				DSVDesc.Texture2DArray.ArraySize = TextureDesc.ArraySize;
    				DSVDesc.Texture2DArray.MipSlice = 0;
    			}
    			else
    			{
    				DSVDesc.ViewDimension = DepthStencilViewDimension;
    				DSVDesc.Texture2D.MipSlice = 0;
    			}
    
    			for (uint32 AccessType = 0; AccessType < FExclusiveDepthStencil::MaxIndex; ++AccessType)
    			{
    				// Create a read-only access views for the texture.
    				// Read-only DSVs are not supported in Feature Level 10 so 
    				// a dummy DSV is created in order reduce logic complexity at a higher-level.
    				if(Direct3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_11_0 || Direct3DDevice->GetFeatureLevel() == D3D_FEATURE_LEVEL_11_1)
    				{
    					DSVDesc.Flags = (AccessType & FExclusiveDepthStencil::DepthRead_StencilWrite) ? D3D11_DSV_READ_ONLY_DEPTH : 0;
    					if(HasStencilBits(DSVDesc.Format))
    					{
    						DSVDesc.Flags |= (AccessType & FExclusiveDepthStencil::DepthWrite_StencilRead) ? D3D11_DSV_READ_ONLY_STENCIL : 0;
    					}
    				}
    				VERIFYD3D11RESULT_EX(Direct3DDevice->CreateDepthStencilView(TextureResource,&DSVDesc,DepthStencilViews[AccessType].GetInitReference()), Direct3DDevice);
    			}
    		}
    	}
    	check(IsValidRef(TextureResource));
    
    	// Create a shader resource view for the texture.
    	if (bCreateShaderResource)
    	{
    		{
    			D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
    			SRVDesc.Format = PlatformShaderResourceFormat;
    
    			if (bCubeTexture && bTextureArray)
    			{
    				SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
    				SRVDesc.TextureCubeArray.MostDetailedMip = 0;
    				SRVDesc.TextureCubeArray.MipLevels = NumMips;
    				SRVDesc.TextureCubeArray.First2DArrayFace = 0;
    				SRVDesc.TextureCubeArray.NumCubes = SizeZ / 6;
    			}
    			else if(bCubeTexture)
    			{
    				SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
    				SRVDesc.TextureCube.MostDetailedMip = 0;
    				SRVDesc.TextureCube.MipLevels = NumMips;
    			}
    			else if(bTextureArray)
    			{
    				SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
    				SRVDesc.Texture2DArray.MostDetailedMip = 0;
    				SRVDesc.Texture2DArray.MipLevels = NumMips;
    				SRVDesc.Texture2DArray.FirstArraySlice = 0;
    				SRVDesc.Texture2DArray.ArraySize = TextureDesc.ArraySize;
    			}
    			else
    			{
    				SRVDesc.ViewDimension = ShaderResourceViewDimension;
    				SRVDesc.Texture2D.MostDetailedMip = 0;
    				SRVDesc.Texture2D.MipLevels = NumMips;
    			}
    			VERIFYD3D11RESULT_EX(Direct3DDevice->CreateShaderResourceView(TextureResource,&SRVDesc,ShaderResourceView.GetInitReference()), Direct3DDevice);
    		}
    
    		check(IsValidRef(ShaderResourceView));
    	}
    
    	TD3D11Texture2D<BaseResourceType>* Texture2D = new TD3D11Texture2D<BaseResourceType>(
    		this,
    		TextureResource,
    		ShaderResourceView,
    		bCreatedRTVPerSlice,
    		TextureDesc.ArraySize,
    		RenderTargetViews,
    		DepthStencilViews,
    		SizeX,
    		SizeY,
    		SizeZ,
    		NumMips,
    		ActualMSAACount,
    		(EPixelFormat)Format,
    		bCubeTexture,
    		Flags,
    		bPooledTexture,
    		CreateInfo.ClearValueBinding
    #if PLATFORM_SUPPORTS_VIRTUAL_TEXTURES
    		, RawTextureMemory
    #endif
    		);
    
    	Texture2D->ResourceInfo.VRamAllocation = VRamAllocation;
    
    	if (Flags & TexCreate_RenderTargetable)
    	{
    		Texture2D->SetCurrentGPUAccess(EResourceTransitionAccess::EWritable);
    	}
    
    	D3D11TextureAllocated(*Texture2D);
    	
    #if !PLATFORM_HOLOLENS
    	if (IsRHIDeviceNVIDIA() && (Flags & TexCreate_AFRManual))
    	{
    		// get a resource handle for this texture
    		void* IHVHandle = nullptr;
    		//getobjecthandle not threadsafe
    		NvAPI_D3D_GetObjectHandleForResource(Direct3DDevice, Texture2D->GetResource(), (NVDX_ObjectHandle*)&(IHVHandle));
    		Texture2D->SetIHVResourceHandle(IHVHandle);
    		
    		NvU32 ManualAFR = 1;
    		NvAPI_D3D_SetResourceHint(Direct3DDevice, (NVDX_ObjectHandle)IHVHandle, NVAPI_D3D_SRH_CATEGORY_SLI, NVAPI_D3D_SRH_SLI_APP_CONTROLLED_INTERFRAME_CONTENT_SYNC, &ManualAFR);
    	}
    #endif
    	if (CreateInfo.BulkData)
    	{
    		CreateInfo.BulkData->Discard();
    	}
    
    	return Texture2D;
    }

TD3D11Texture2D() in F:\\UnrealEngine-424\\Engine\\Source\\Runtime\\Windows\\D3D11RHI\\Public\\D3D11Resources.h

/** 2D texture (vanilla, cubemap or 2D array) */
    template<typename BaseResourceType>
    class D3D11RHI_API TD3D11Texture2D : public BaseResourceType, public FD3D11TextureBase
    {
    public:
    
    	/** Flags used when the texture was created */
    	uint32 Flags;
    
    	/** Initialization constructor. */
    	TD3D11Texture2D(
    		class FD3D11DynamicRHI* InD3DRHI,
    		ID3D11Texture2D* InResource,
    		ID3D11ShaderResourceView* InShaderResourceView,
    		bool bInCreatedRTVsPerSlice,
    		int32 InRTVArraySize,
    		const TArray<TRefCountPtr<ID3D11RenderTargetView> >& InRenderTargetViews,
    		TRefCountPtr<ID3D11DepthStencilView>* InDepthStencilViews,
    		uint32 InSizeX,
    		uint32 InSizeY,
    		uint32 InSizeZ,
    		uint32 InNumMips,
    		uint32 InNumSamples,
    		EPixelFormat InFormat,
    		bool bInCubemap,
    		uint32 InFlags,
    		bool bInPooled,
    		const FClearValueBinding& InClearValue
    #if PLATFORM_SUPPORTS_VIRTUAL_TEXTURES
    		, void* InRawTextureMemory = nullptr
    #endif
    		)
    	: BaseResourceType(
    		InSizeX,
    		InSizeY,
    		InSizeZ,
    		InNumMips,
    		InNumSamples,
    		InFormat,
    		InFlags,
    		InClearValue
    		)
    	, FD3D11TextureBase(
    		InD3DRHI,
    		InResource,
    		InShaderResourceView, 
    		InRTVArraySize,
    		bInCreatedRTVsPerSlice,
    		InRenderTargetViews,
    		InDepthStencilViews
    		)
    	, Flags(InFlags)
    	, bCubemap(bInCubemap)
    	, bPooled(bInPooled)
    #if PLATFORM_SUPPORTS_VIRTUAL_TEXTURES
    	, RawTextureMemory(InRawTextureMemory)
    #endif
    	{
    	}
    
    	virtual ~TD3D11Texture2D();
    
    	/**
    	 * Locks one of the texture's mip-maps.
    	 * @return A pointer to the specified texture data.
    	 */
    	void* Lock(uint32 MipIndex,uint32 ArrayIndex,EResourceLockMode LockMode,uint32& DestStride,bool bForceLockDeferred = false);
    
    	/** Unlocks a previously locked mip-map. */
    	void Unlock(uint32 MipIndex,uint32 ArrayIndex);
    
    	// Accessors.
    	ID3D11Texture2D* GetResource() const { return (ID3D11Texture2D*)FD3D11TextureBase::GetResource(); }
    	bool IsCubemap() const { return bCubemap; }
    
    	/** FRHITexture override.  See FRHITexture::GetNativeResource() */
    	virtual void* GetNativeResource() const override final
    	{ 
    		return GetResource();
    	}
    	virtual void* GetNativeShaderResourceView() const override final
    	{
    		return GetShaderResourceView();
    	}
    	virtual void* GetTextureBaseRHI() override final
    	{
    		return static_cast<FD3D11TextureBase*>(this);
    	}
    
    
    	// IRefCountedObject interface.
    	virtual uint32 AddRef() const
    	{
    		return FRHIResource::AddRef();
    	}
    	virtual uint32 Release() const
    	{
    		return FRHIResource::Release();
    	}
    	virtual uint32 GetRefCount() const
    	{
    		return FRHIResource::GetRefCount();
    	}
    #if PLATFORM_SUPPORTS_VIRTUAL_TEXTURES
    	void* GetRawTextureMemory() const
    	{
    		return RawTextureMemory;
    	}
    #endif
    
    private:
    
    	/** Whether the texture is a cube-map. */
    	const uint32 bCubemap : 1;
    	/** Whether the texture can be pooled. */
    	const uint32 bPooled : 1;
    #if PLATFORM_SUPPORTS_VIRTUAL_TEXTURES
    	void* RawTextureMemory;
    #endif
    };

\---end