public void Init(HDRenderPipeline renderPipeline)
{
// Keep track of the pipeline asset
m_PipelineSettings = renderPipeline.currentPlatformRenderPipelineSettings;
m_PipelineResources = renderPipeline.asset.renderPipelineResources;
m_PipelineRayTracingResources = renderPipeline.asset.renderPipelineRayTracingResources;
// keep track of the render pipeline
m_RenderPipeline = renderPipeline;
// Allocate the intermediate textures
m_AOIntermediateBuffer0 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "AOIntermediateBuffer0");
m_AOIntermediateBuffer1 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "AOIntermediateBuffer1");
}
public AmbientOcclusionSystem(HDRenderPipelineAsset hdAsset, RenderPipelineResources defaultResources)
{
m_Settings = hdAsset.currentPlatformRenderPipelineSettings;
m_Resources = defaultResources;
#if ENABLE_RAYTRACING
m_RTResources = hdAsset.renderPipelineRayTracingResources;
#endif
if (!hdAsset.currentPlatformRenderPipelineSettings.supportSSAO)
{
return;
}
AllocRT(0.5f);
}
public void Init(RenderPipelineResources rpResources, HDRenderPipelineRayTracingResources rpRTResources, RenderPipelineSettings pipelineSettings, HDRaytracingManager raytracingManager, SharedRTManager sharedRTManager)
{
// Keep track of the pipeline asset
m_PipelineSettings = pipelineSettings;
m_PipelineResources = rpResources;
m_PipelineRayTracingResources = rpRTResources;
// keep track of the ray tracing manager
m_RaytracingManager = raytracingManager;
// Keep track of the shared rt manager
m_SharedRTManager = sharedRTManager;
m_AOIntermediateBuffer0 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "AOIntermediateBuffer0");
m_AOIntermediateBuffer1 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "AOIntermediateBuffer1");
}
uint m_SSSTransmissionFlags; // 1 bit/profile: 0 = regular, 1 = thin
void InitSSSBuffers()
{
RenderPipelineSettings settings = asset.currentPlatformRenderPipelineSettings;
if (settings.supportedLitShaderMode == RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly) //forward only
{
// In case of full forward we must allocate the render target for forward SSS (or reuse one already existing)
// TODO: Provide a way to reuse a render target
m_SSSColor = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_SRGB, dimension: TextureXR.dimension, useDynamicScale: true, name: "SSSBuffer");
m_SSSReuseGBufferMemory = false;
}
// We need to allocate the texture if we are in forward or both in case one of the cameras is in enable forward only mode
if (settings.supportMSAA)
{
m_SSSColorMSAA = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_SRGB, dimension: TextureXR.dimension, enableMSAA: true, bindTextureMS: true, useDynamicScale: true, name: "SSSBufferMSAA");
}
if ((settings.supportedLitShaderMode & RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly) != 0) //deferred or both
{
// In case of deferred, we must be in sync with SubsurfaceScattering.hlsl and lit.hlsl files and setup the correct buffers
m_SSSColor = m_GbufferManager.GetSubsurfaceScatteringBuffer(0); // Note: This buffer must be sRGB (which is the case with Lit.shader)
m_SSSReuseGBufferMemory = true;
}
if (NeedTemporarySubsurfaceBuffer() || settings.supportMSAA)
{
// Caution: must be same format as m_CameraSssDiffuseLightingBuffer
m_SSSCameraFilteringBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "SSSCameraFiltering"); // Enable UAV
}
// We use 8x8 tiles in order to match the native GCN HTile as closely as possible.
m_SSSHTile = RTHandles.Alloc(size => new Vector2Int((size.x + 7) / 8, (size.y + 7) / 8), TextureXR.slices, colorFormat: GraphicsFormat.R8_UNorm, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "SSSHtile"); // Enable UAV
// fill the list with the max number of diffusion profile so we dont have
// the error: exceeds previous array size (5 vs 3). Cap to previous size.
m_SSSThicknessRemaps = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSShapeParams = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSTransmissionTintsAndFresnel0 = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSDisabledTransmissionTintsAndFresnel0 = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSWorldScales = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSFilterKernels = new Vector4[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT * DiffusionProfileConstants.SSS_N_SAMPLES_NEAR_FIELD];
m_SSSDiffusionProfileHashes = new float[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSDiffusionProfileUpdate = new int[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
m_SSSSetDiffusionProfiles = new DiffusionProfileSettings[DiffusionProfileConstants.DIFFUSION_PROFILE_COUNT];
}
public void Init(RenderPipelineResources rpResources, HDRenderPipelineRayTracingResources rpRTResources, RenderPipelineSettings pipelineSettings, HDRaytracingManager raytracingManager, SharedRTManager sharedRTManager)
{
// Keep track of the pipeline asset
m_PipelineSettings = pipelineSettings;
m_PipelineResources = rpResources;
m_PipelineRayTracingResources = rpRTResources;
// keep track of the ray tracing manager
m_RaytracingManager = raytracingManager;
// Keep track of the shared rt manager
m_SharedRTManager = sharedRTManager;
// Intermediate buffer that holds the pre-denoised texture
m_IntermediateBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IntermediateAOBuffer");
// Buffer that holds the uncompressed normal buffer
m_ViewSpaceNormalBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "ViewSpaceNormalBuffer");
}
public void Init(RenderPipelineSettings settings, RenderPipelineResources rpResources, HDRenderPipelineRayTracingResources rayTracingResources, BlueNoise blueNoise, HDRenderPipeline renderPipeline, SharedRTManager sharedRTManager, DebugDisplaySettings currentDebugDisplaySettings)
{
// Keep track of the resources
m_Resources = rpResources;
m_RTResources = rayTracingResources;
// Keep track of the settings
m_Settings = settings;
// Keep track of the render pipeline
m_RenderPipeline = renderPipeline;
// Keep track of the shared RT manager
m_SharedRTManager = sharedRTManager;
// Keep track of the blue noise manager
m_BlueNoise = blueNoise;
// Create the list of environments
m_Environments = new List <HDRaytracingEnvironment>();
// Grab all the ray-tracing graphs that have been created before (in case the order of initialization has not been respected, which happens when we open unity the first time)
HDRaytracingEnvironment[] environmentArray = Object.FindObjectsOfType <HDRaytracingEnvironment>();
for (int envIdx = 0; envIdx < environmentArray.Length; ++envIdx)
{
RegisterEnvironment(environmentArray[envIdx]);
}
// Init the denoisers
m_TemporalFilter.Init(rayTracingResources, m_SharedRTManager);
m_SimpleDenoiser.Init(rayTracingResources, m_SharedRTManager);
m_DiffuseDenoiser.Init(rpResources, rayTracingResources, m_SharedRTManager);
// Init the ray count manager
m_RayCountManager.Init(rayTracingResources, currentDebugDisplaySettings);
#if UNITY_EDITOR
// We need to invalidate the acceleration structures in case the hierarchy changed
EditorApplication.hierarchyChanged += OnHierarchyChanged;
#endif
}
// Note: this version is the one tested as there is issue getting HDRenderPipelineAsset in batchmode in unit test framework currently.
/// <summary>Same than FrameSettings.AggregateFrameSettings but keep history of agregation in a collection for DebugMenu.
/// Aggregation is default with override of the renderer then sanitazed depending on supported features of hdrpasset. Then the DebugMenu override occurs.</summary>
/// <param name="aggregatedFrameSettings">The aggregated FrameSettings result.</param>
/// <param name="camera">The camera rendering.</param>
/// <param name="additionalData">Additional data of the camera rendering.</param>
/// <param name="defaultFrameSettings">Base framesettings to copy prior any override.</param>
/// <param name="supportedFeatures">Currently supported feature for the sanitazation pass.</param>
public static void AggregateFrameSettings(ref FrameSettings aggregatedFrameSettings, Camera camera, HDAdditionalCameraData additionalData, ref FrameSettings defaultFrameSettings, RenderPipelineSettings supportedFeatures)
{
FrameSettingsHistory history = new FrameSettingsHistory
{
camera = camera,
defaultType = additionalData ? additionalData.defaultFrameSettings : FrameSettingsRenderType.Camera
};
aggregatedFrameSettings = defaultFrameSettings;
if (additionalData && additionalData.customRenderingSettings)
{
FrameSettings.Override(ref aggregatedFrameSettings, additionalData.renderingPathCustomFrameSettings, additionalData.renderingPathCustomFrameSettingsOverrideMask);
history.customMask = additionalData.renderingPathCustomFrameSettingsOverrideMask;
}
history.overridden = aggregatedFrameSettings;
FrameSettings.Sanitize(ref aggregatedFrameSettings, camera, supportedFeatures);
bool noHistory = !frameSettingsHistory.ContainsKey(camera);
bool updatedComponent = !noHistory && frameSettingsHistory[camera].sanitazed != aggregatedFrameSettings;
bool dirty = noHistory || updatedComponent;
history.sanitazed = aggregatedFrameSettings;
if (dirty)
{
history.debug = history.sanitazed;
}
else
{
history.debug = frameSettingsHistory[camera].debug;
// Ensure user is not trying to activate unsupported settings in DebugMenu
FrameSettings.Sanitize(ref history.debug, camera, supportedFeatures);
}
aggregatedFrameSettings = history.debug;
frameSettingsHistory[camera] = history;
}
internal AmbientOcclusionSystem(HDRenderPipelineAsset hdAsset, RenderPipelineResources defaultResources)
{
m_Settings = hdAsset.currentPlatformRenderPipelineSettings;
m_Resources = defaultResources;
}
// Ray Tracing is supported if the asset setting supports it and the platform supports it static internal bool GatherRayTracingSupport(RenderPipelineSettings rpSetting) => rpSetting.supportRayTracing && rayTracingSupportedBySystem;
public void InitSharedBuffers(GBufferManager gbufferManager, RenderPipelineSettings settings, RenderPipelineResources resources)
{
// Set the flags
m_MSAASupported = settings.supportMSAA && settings.supportedLitShaderMode != RenderPipelineSettings.SupportedLitShaderMode.DeferredOnly;
m_MSAASamples = m_MSAASupported ? settings.msaaSampleCount : MSAASamples.None;
m_MotionVectorsSupport = settings.supportMotionVectors;
m_ReuseGBufferMemory = settings.supportedLitShaderMode != RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly;
m_DecalLayersSupported = settings.supportDecals && settings.supportDecalLayers;
// Create the depth/stencil buffer
m_CameraDepthStencilBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, DepthBits.Depth32, dimension: TextureXR.dimension, useDynamicScale: true, name: "CameraDepthStencil");
// Create the mip chain buffer
m_CameraDepthBufferMipChainInfo = new HDUtils.PackedMipChainInfo();
m_CameraDepthBufferMipChainInfo.Allocate();
m_CameraDepthBufferMipChain = RTHandles.Alloc(ComputeDepthBufferMipChainSize, TextureXR.slices, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "CameraDepthBufferMipChain");
if (settings.lowresTransparentSettings.enabled)
{
// Create the half res depth buffer used for low resolution transparency
m_CameraHalfResDepthBuffer = RTHandles.Alloc(Vector2.one * 0.5f, TextureXR.slices, DepthBits.Depth32, dimension: TextureXR.dimension, useDynamicScale: true, name: "LowResDepthBuffer");
}
if (m_MotionVectorsSupport)
{
m_MotionVectorsRT = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: Builtin.GetMotionVectorFormat(), dimension: TextureXR.dimension, useDynamicScale: true, name: "MotionVectors");
if (m_MSAASupported)
{
m_MotionVectorsMSAART = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: Builtin.GetMotionVectorFormat(), dimension: TextureXR.dimension, enableMSAA: true, bindTextureMS: true, useDynamicScale: true, name: "MotionVectorsMSAA");
}
}
// Allocate the additional textures only if MSAA is supported
if (m_MSAASupported)
{
// Let's create the MSAA textures
m_CameraDepthStencilMSAABuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, DepthBits.Depth24, dimension: TextureXR.dimension, bindTextureMS: true, enableMSAA: true, useDynamicScale: true, name: "CameraDepthStencilMSAA");
m_CameraDepthValuesBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R32G32B32A32_SFloat, dimension: TextureXR.dimension, useDynamicScale: true, name: "DepthValuesBuffer");
m_DepthAsColorMSAART = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, bindTextureMS: true, enableMSAA: true, useDynamicScale: true, name: "DepthAsColorMSAA");
m_StencilBufferResolved = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8_UInt, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "StencilBufferResolved");
// We need to allocate this texture as long as msaa is supported because on both mode, one of the cameras can be forward only using the framesettings
m_NormalMSAART = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, dimension: TextureXR.dimension, enableMSAA: true, bindTextureMS: true, useDynamicScale: true, name: "NormalBufferMSAA");
// Create the required resolve materials
m_DepthResolveMaterial = CoreUtils.CreateEngineMaterial(resources.shaders.depthValuesPS);
m_ColorResolveMaterial = CoreUtils.CreateEngineMaterial(resources.shaders.colorResolvePS);
m_MotionVectorResolve = CoreUtils.CreateEngineMaterial(resources.shaders.resolveMotionVecPS);
if (m_DecalLayersSupported)
{
m_DecalPrePassBufferMSAA = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, enableMSAA: true, useDynamicScale: true, name: "Decal PrePass Buffer MSAA");
}
CoreUtils.SetKeyword(m_DepthResolveMaterial, "_HAS_MOTION_VECTORS", m_MotionVectorsSupport);
}
// TODO: try to save this memory allocation. We can't reuse GBuffer for now as it require an additional clear before the GBuffer pass, otherwise the buffer can contain garbage that can be misinterpreted
// if forward object are render (see test in HDRP_Test DecalNormalPatch buffer)
if (m_DecalLayersSupported)
{
m_DecalPrePassBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, useDynamicScale: true, name: "Decal PrePass Buffer");
}
// If we are in the forward only mode
if (!m_ReuseGBufferMemory)
{
// In case of full forward we must allocate the render target for normal buffer (or reuse one already existing)
// TODO: Provide a way to reuse a render target
m_NormalRT = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "NormalBuffer");
}
else
{
// When not forward only we should are using the normal buffer of the gbuffer
// In case of deferred, we must be in sync with NormalBuffer.hlsl and lit.hlsl files and setup the correct buffers
m_NormalRT = gbufferManager.GetNormalBuffer(0); // Normal + Roughness
}
}
internal static RenderPipelineSettings NewDefault()
{
RenderPipelineSettings settings = new RenderPipelineSettings()
{
supportShadowMask = true,
supportSSAO = true,
supportSubsurfaceScattering = true,
sssSampleBudget = new IntScalableSetting(new[] { (int)DefaultSssSampleBudgetForQualityLevel.Low,
(int)DefaultSssSampleBudgetForQualityLevel.Medium,
(int)DefaultSssSampleBudgetForQualityLevel.High }, ScalableSettingSchemaId.With3Levels),
supportVolumetrics = true,
supportDistortion = true,
supportTransparentBackface = true,
supportTransparentDepthPrepass = true,
supportTransparentDepthPostpass = true,
colorBufferFormat = ColorBufferFormat.R11G11B10,
supportCustomPass = true,
customBufferFormat = CustomBufferFormat.R8G8B8A8,
supportedLitShaderMode = SupportedLitShaderMode.DeferredOnly,
supportDecals = true,
supportDecalLayers = false,
decalLayerName0 = "Decal Layer default",
decalLayerName1 = "Decal Layer 1",
decalLayerName2 = "Decal Layer 2",
decalLayerName3 = "Decal Layer 3",
decalLayerName4 = "Decal Layer 4",
decalLayerName5 = "Decal Layer 5",
decalLayerName6 = "Decal Layer 6",
decalLayerName7 = "Decal Layer 7",
msaaSampleCount = MSAASamples.None,
supportMotionVectors = true,
supportRuntimeDebugDisplay = false,
supportRuntimeAOVAPI = false,
supportDitheringCrossFade = true,
supportTerrainHole = false,
planarReflectionResolution = new PlanarReflectionAtlasResolutionScalableSetting(new[] { PlanarReflectionAtlasResolution.Resolution256,
PlanarReflectionAtlasResolution.Resolution1024,
PlanarReflectionAtlasResolution.Resolution2048 },
ScalableSettingSchemaId.With3Levels),
lightLoopSettings = GlobalLightLoopSettings.NewDefault(),
hdShadowInitParams = HDShadowInitParameters.NewDefault(),
decalSettings = GlobalDecalSettings.NewDefault(),
postProcessSettings = GlobalPostProcessSettings.NewDefault(),
dynamicResolutionSettings = GlobalDynamicResolutionSettings.NewDefault(),
lowresTransparentSettings = GlobalLowResolutionTransparencySettings.NewDefault(),
xrSettings = GlobalXRSettings.NewDefault(),
postProcessQualitySettings = GlobalPostProcessingQualitySettings.NewDefault(),
lightingQualitySettings = GlobalLightingQualitySettings.NewDefault(),
lightSettings = LightSettings.NewDefault(),
supportRayTracing = false,
supportedRayTracingMode = SupportedRayTracingMode.Both,
lodBias = new FloatScalableSetting(new[] { 1.0f, 1, 1 }, ScalableSettingSchemaId.With3Levels),
maximumLODLevel = new IntScalableSetting(new[] { 0, 0, 0 }, ScalableSettingSchemaId.With3Levels),
lightLayerName0 = "Light Layer default",
lightLayerName1 = "Light Layer 1",
lightLayerName2 = "Light Layer 2",
lightLayerName3 = "Light Layer 3",
lightLayerName4 = "Light Layer 4",
lightLayerName5 = "Light Layer 5",
lightLayerName6 = "Light Layer 6",
lightLayerName7 = "Light Layer 7",
supportProbeVolume = false,
probeVolumeSettings = GlobalProbeVolumeSettings.@default,
};
return(settings);
}
public void InitSharedBuffers(GBufferManager gbufferManager, RenderPipelineSettings settings, RenderPipelineResources resources)
{
// Set the flags
m_MSAASupported = settings.supportMSAA;
m_MSAASamples = m_MSAASupported ? settings.msaaSampleCount : MSAASamples.None;
m_MotionVectorsSupport = settings.supportMotionVectors;
m_ReuseGBufferMemory = settings.supportedLitShaderMode != RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly;
// Create the depth/stencil buffer
m_CameraDepthStencilBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, DepthBits.Depth32, dimension: TextureXR.dimension, useDynamicScale: true, name: "CameraDepthStencil");
// Create the mip chain buffer
m_CameraDepthBufferMipChainInfo = new HDUtils.PackedMipChainInfo();
m_CameraDepthBufferMipChainInfo.Allocate();
m_CameraDepthBufferMipChain = RTHandles.Alloc(ComputeDepthBufferMipChainSize, TextureXR.slices, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "CameraDepthBufferMipChain");
if (settings.lowresTransparentSettings.enabled)
{
// Create the half res depth buffer used for low resolution transparency
m_CameraHalfResDepthBuffer = RTHandles.Alloc(Vector2.one * 0.5f, TextureXR.slices, DepthBits.Depth32, dimension: TextureXR.dimension, useDynamicScale: true, name: "LowResDepthBuffer");
}
// Technically we won't need this buffer in some cases, but nothing that we can determine at init time.
m_CameraStencilBufferCopy = RTHandles.Alloc(Vector2.one, TextureXR.slices, DepthBits.None, colorFormat: GraphicsFormat.R8_UNorm, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "CameraStencilCopy"); // DXGI_FORMAT_R8_UINT is not supported by Unity
if (m_MotionVectorsSupport)
{
m_MotionVectorsRT = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: Builtin.GetMotionVectorFormat(), dimension: TextureXR.dimension, useDynamicScale: true, name: "MotionVectors");
if (m_MSAASupported)
{
m_MotionVectorsMSAART = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: Builtin.GetMotionVectorFormat(), dimension: TextureXR.dimension, enableMSAA: true, bindTextureMS: true, useDynamicScale: true, name: "MotionVectorsMSAA");
}
}
// Allocate the additional textures only if MSAA is supported
if (m_MSAASupported)
{
// Let's create the MSAA textures
m_CameraDepthStencilMSAABuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, DepthBits.Depth24, dimension: TextureXR.dimension, bindTextureMS: true, enableMSAA: true, useDynamicScale: true, name: "CameraDepthStencilMSAA");
m_CameraDepthValuesBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R32G32B32A32_SFloat, dimension: TextureXR.dimension, useDynamicScale: true, name: "DepthValuesBuffer");
m_DepthAsColorMSAART = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, bindTextureMS: true, enableMSAA: true, useDynamicScale: true, name: "DepthAsColorMSAA");
// We need to allocate this texture as long as msaa is supported because on both mode, one of the cameras can be forward only using the framesettings
m_NormalMSAART = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, dimension: TextureXR.dimension, enableMSAA: true, bindTextureMS: true, useDynamicScale: true, name: "NormalBufferMSAA");
// Create the required resolve materials
m_DepthResolveMaterial = CoreUtils.CreateEngineMaterial(resources.shaders.depthValuesPS);
m_ColorResolveMaterial = CoreUtils.CreateEngineMaterial(resources.shaders.colorResolvePS);
}
// If we are in the forward only mode
if (!m_ReuseGBufferMemory)
{
// In case of full forward we must allocate the render target for normal buffer (or reuse one already existing)
// TODO: Provide a way to reuse a render target
m_NormalRT = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, name: "NormalBuffer");
}
else
{
// When not forward only we should are using the normal buffer of the gbuffer
// In case of deferred, we must be in sync with NormalBuffer.hlsl and lit.hlsl files and setup the correct buffers
m_NormalRT = gbufferManager.GetNormalBuffer(0); // Normal + Roughness
}
}
// Ray Tracing is supported if the asset setting supports it and the platform supports it static internal bool PipelineSupportsRayTracing(RenderPipelineSettings rpSetting) => rpSetting.supportRayTracing && currentSystemSupportsRayTracing;