void AllocRT(float scaleFactor)
{
m_AmbientOcclusionTex = RTHandles.Alloc(Vector2.one, TextureXR.slices, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R8_UNorm, dimension: TextureXR.dimension, useDynamicScale: true, enableRandomWrite: true, name: "Ambient Occlusion");
m_PackedDataTex = RTHandles.Alloc(Vector2.one * scaleFactor, TextureXR.slices, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, useDynamicScale: true, enableRandomWrite: true, name: "AO Packed data");
m_PackedDataBlurred = RTHandles.Alloc(Vector2.one * scaleFactor, TextureXR.slices, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, useDynamicScale: true, enableRandomWrite: true, name: "AO Packed blurred data");
m_FinalHalfRes = RTHandles.Alloc(Vector2.one * 0.5f, TextureXR.slices, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, useDynamicScale: true, enableRandomWrite: true, name: "Final Half Res AO Packed");
}
void ScreenSpaceShadowInitializeNonRenderGraphResources()
{
// Allocate the final result texture
int numShadowTextures = Math.Max((int)Math.Ceiling(m_Asset.currentPlatformRenderPipelineSettings.hdShadowInitParams.maxScreenSpaceShadowSlots / 4.0f), 1);
GraphicsFormat graphicsFormat = (GraphicsFormat)m_Asset.currentPlatformRenderPipelineSettings.hdShadowInitParams.screenSpaceShadowBufferFormat;
m_ScreenSpaceShadowTextureArray = RTHandles.Alloc(Vector2.one, slices: numShadowTextures * TextureXR.slices, dimension: TextureDimension.Tex2DArray, filterMode: FilterMode.Point, colorFormat: graphicsFormat, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "AreaShadowArrayBuffer");
}
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
halfResTarget = RTHandles.Alloc(
Vector2.one * 0.5f, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, // We don't need alpha for this effect
useDynamicScale: true, name: "Half Res Custom Pass"
);
}
public HDShadowAtlas(int width, int height, Material clearMaterial, FilterMode filterMode = FilterMode.Bilinear, DepthBits depthBufferBits = DepthBits.Depth16, RenderTextureFormat format = RenderTextureFormat.Shadowmap, string name = "")
{
m_Atlas = RTHandles.Alloc(width, height, filterMode: filterMode, depthBufferBits: depthBufferBits, sRGB: false, colorFormat: format, name: name);
m_Width = width;
m_Height = height;
identifier = new RenderTargetIdentifier(m_Atlas);
m_ClearMaterial = clearMaterial;
}
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_VelocitySupport = settings.supportMotionVectors;
m_ReuseGBufferMemory = settings.supportedLitShaderMode != RenderPipelineSettings.SupportedLitShaderMode.ForwardOnly;
// Create the depth/stencil buffer
m_CameraDepthStencilBuffer = RTHandles.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth32, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, name: "CameraDepthStencil");
// Create the mip chain buffer
m_CameraDepthBufferMipChainInfo = new HDUtils.PackedMipChainInfo();
m_CameraDepthBufferMipChainInfo.Allocate();
m_CameraDepthBufferMipChain = RTHandles.Alloc(ComputeDepthBufferMipChainSize, colorFormat: RenderTextureFormat.RFloat, filterMode: FilterMode.Point, sRGB: false, enableRandomWrite: true, name: "CameraDepthBufferMipChain");
// 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, depthBufferBits: DepthBits.None, colorFormat: RenderTextureFormat.R8, sRGB: false, filterMode: FilterMode.Point, enableRandomWrite: true, name: "CameraStencilCopy"); // DXGI_FORMAT_R8_UINT is not supported by Unity
if (m_VelocitySupport)
{
m_VelocityRT = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetVelocityBufferFormat(), sRGB: Builtin.GetVelocityBufferSRGBFlag(), name: "Velocity");
if (m_MSAASupported)
{
m_VelocityMSAART = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetVelocityBufferFormat(), sRGB: Builtin.GetVelocityBufferSRGBFlag(), enableMSAA: true, bindTextureMS: true, name: "VelocityMSAA");
}
}
// Allocate the additional textures only if MSAA is supported
if (m_MSAASupported)
{
// Let's create the MSAA textures
m_CameraDepthStencilMSAABuffer = RTHandles.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, bindTextureMS: true, enableMSAA: true, name: "CameraDepthStencilMSAA");
m_CameraDepthValuesBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBFloat, sRGB: false, name: "DepthValuesBuffer");
m_DepthAsColorMSAART = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RFloat, sRGB: false, bindTextureMS: true, enableMSAA: 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, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGB32, sRGB: false, enableMSAA: true, bindTextureMS: 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, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGB32, sRGB: false, enableRandomWrite: 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
}
}
public override void Setup()
{
if (Shader.Find("Hidden/Shader/LowResolution_RLPRO") != null)
{
m_Material = new Material(Shader.Find("Hidden/Shader/LowResolution_RLPRO"));
}
lowresTexture = RTHandles.Alloc(Vector2.one * downscale.value, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "lowresTexture");
highresTexture = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "highresTexture");
}
public VTBufferManager(HDRenderPipelineAsset asset)
{
m_DownSampleCS = asset.renderPipelineResources.shaders.VTFeedbackDownsample;
m_DownsampleKernel = m_DownSampleCS.FindKernel("KMain");
m_DownsampleKernelMSAA = m_DownSampleCS.FindKernel("KMainMSAA");
// This texture needs to be persistent because we do async gpu readback on it.
m_LowresResolver = RTHandles.Alloc(m_ResolverScale, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, enableRandomWrite: true, autoGenerateMips: false, name: "VTFeedback lowres");
}
public override void Setup()
{
if (Shader.Find("Hidden/Shader/ColormapPaletteEffect_RLPRO") != null)
{
m_Material = new Material(Shader.Find("Hidden/Shader/ColormapPaletteEffect_RLPRO"));
}
lowresTexture = RTHandles.Alloc(Vector2.one / pixelSize.value, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "lowresTexture");
m_Init = true;
}
internal ScreenSpaceAmbientOcclusionPass()
{
m_CurrentSettings = new ScreenSpaceAmbientOcclusionSettings();
m_SSAOTexture1 = RTHandles.Alloc(new RenderTargetIdentifier(s_SSAOTexture1ID, 0, CubemapFace.Unknown, -1), "_SSAO_OcclusionTexture1");
m_SSAOTexture2 = RTHandles.Alloc(new RenderTargetIdentifier(s_SSAOTexture2ID, 0, CubemapFace.Unknown, -1), "_SSAO_OcclusionTexture2");
m_SSAOTexture3 = RTHandles.Alloc(new RenderTargetIdentifier(s_SSAOTexture3ID, 0, CubemapFace.Unknown, -1), "_SSAO_OcclusionTexture3");
m_SSAOTextureFinal = RTHandles.Alloc(new RenderTargetIdentifier(s_SSAOTextureFinalID, 0, CubemapFace.Unknown, -1), "_SSAO_OcclusionTexture");
}
private void SetupPPTempBuffer(CustomPassContext ctx)
{
if (_postProcessTempBuffer == null)
_postProcessTempBuffer = RTHandles.Alloc(
scaleFactor: Vector2.one,
colorFormat: ctx.cameraColorBuffer.rt.graphicsFormat,
filterMode: ctx.cameraColorBuffer.rt.filterMode,
name: "JTRP PP Temp");
}
public override void Setup()
{
if (Shader.Find("Hidden/Shader/NoiseEffects_RLPRO") != null)
{
m_Material = new Material(Shader.Find("Hidden/Shader/NoiseEffects_RLPRO"));
}
texTape = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "texLast");
stop = false;
}
public void Init(HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager)
{
m_SimpleDenoiserCS = rpRTResources.simpleDenoiserCS;
m_SharedRTManager = sharedRTManager;
m_IntermediateBuffer0 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IntermediateBuffer0");
m_IntermediateBuffer1 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "IntermediateBuffer1");
}
RTHandle RTAllocator(AOVBuffers bufferID)
{
if (bufferID == AOVBuffers.Color)
{
return(rtColor ?? (rtColor = RTHandles.Alloc(diffuse.width, diffuse.height, 1, DepthBits.None, GraphicsFormat.R8G8B8A8_SRGB)));
}
return(null);
}
void InitRecursiveRenderer()
{
m_RaytracingFlagStateBlock = new RenderStateBlock
{
depthState = new DepthState(false, CompareFunction.LessEqual),
mask = RenderStateMask.Depth
};
m_FlagMaskTextureRT = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8_SNorm, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "FlagMaskTexture");
}
public override void Setup()
{
Debug.Log("Setup");
// Load assets from Resources folder
_nnModels = new NNModel[]
{
Resources.Load <NNModel>("adele_2"),
Resources.Load <NNModel>("model_32channels")
};
Debug.Assert(Enum.GetNames(typeof(ModelType)).Length == _nnModels.Length);
Debug.Assert(_nnModels.All(m => m != null));
ComputeInfo.channelsOrder = ComputeInfo.ChannelsOrder.NCHW;
// Compile the model asset into an object oriented representation
_model = ModelLoader.Load(_nnModels[(int)modelType.value], debugModelLoading.value);
float scale = 1; //inputResolution.value.y / (float)Screen.height;
_rtHandle = RTHandles.Alloc(
colorFormat: GraphicsFormat.R16G16B16A16_UNorm,
scaleFactor: Vector2.one * scale,
wrapMode: TextureWrapMode.Clamp,
enableRandomWrite: true
);
_rtHandlePregamma = RTHandles.Alloc(
colorFormat: GraphicsFormat.R16G16B16A16_UNorm,
scaleFactor: Vector2.one * scale,
wrapMode: TextureWrapMode.Clamp,
enableRandomWrite: true
);
_rtHandlePostgamma = RTHandles.Alloc(
colorFormat: GraphicsFormat.R16G16B16A16_UNorm,
scaleFactor: Vector2.one * scale,
wrapMode: TextureWrapMode.Clamp,
enableRandomWrite: true
);
_rtHandleStyle = RTHandles.Alloc(
256, 256,
colorFormat: GraphicsFormat.R16G16B16A16_SFloat,
wrapMode: TextureWrapMode.Clamp,
enableRandomWrite: true
);
_pregammaMat = new Material(Shader.Find("Barracuda/Activation"));
_pregammaMat.EnableKeyword("Pow");
_pregammaMat.EnableKeyword("BATCHTILLING_ON");
_postgammaMat = new Material(_pregammaMat);
_postgammaMat.CopyPropertiesFromMaterial(_pregammaMat);
//Prepare style transfer prediction and runtime worker at load time (to avoid memory allocation at runtime)
PrepareStylePrediction();
CreateBarracudaWorker();
}
void AllocateRenderTexture()
{
if (m_Atlas != null)
{
m_Atlas.Release();
}
m_Atlas = RTHandles.Alloc(width, height, filterMode: m_FilterMode, depthBufferBits: m_DepthBufferBits, sRGB: false, colorFormat: m_Format, name: m_Name);
identifier = new RenderTargetIdentifier(m_Atlas);
}
public void CreateBuffers(RenderPipelineSettings settings)
{
FeedbackBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, useDynamicScale: true, name: "VTFeedbackForward");
if (settings.supportMSAA)
{
// Our processing handles both MSAA and regular buffers so we don't need to explicitly resolve here saving a buffer
FeedbackBufferMsaa = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R8G8B8A8_UNorm, bindTextureMS: true,
enableMSAA: settings.supportMSAA, useDynamicScale: true, name: "VTFeedbackForwardMSAA");
}
}
public RTHandle GetNewRTHandle(HDCamera camera)
{
var width = camera.actualWidth;
var height = camera.actualHeight;
const GraphicsFormat RTFormat = GraphicsFormat.R16G16B16A16_SFloat;
var rt = RTHandles.Alloc(scaleFactor: Vector2.one, colorFormat: RTFormat);// RTHandles.Alloc(width, height, colorFormat: RTFormat);
// rtHandles.Add(rt);
return(rt);
}
public override void Setup()
{
if (Shader.Find("Hidden/Shader/Glitch2Effect_RLPRO") != null)
{
m_Material = new Material(Shader.Find("Hidden/Shader/Glitch2Effect_RLPRO"));
}
_trashFrame1 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "_trashFrame1");
_trashFrame2 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "_trashFrame2");
SetUpResources(resolutionMultiplier.value);
}
public void Init(RenderPipelineResources renderPipelineResources)
{
m_Blit = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.blitPS);
m_DrawRayCount = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.debugViewRayCountPS);
m_RayCountCompute = renderPipelineResources.shaders.countTracedRays;
s_DebugFontTex = renderPipelineResources.textures.debugFontTex;
// UINT textures must use UINT32, since groupshared uint used to synchronize counts is allocated as a UINT32
m_RayCountTex = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R32G32B32A32_UInt, enableRandomWrite: true, useMipMap: false, name: "RayCountTex");
s_TotalRayCountBuffer = new ComputeBuffer(3, sizeof(uint));
}
public void InitializeNonRenderGraphResources()
{
m_LightCountBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R32_SFloat, enableRandomWrite: false, useMipMap: false, name: "LightVolumeCount");
m_ColorAccumulationBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: false, useMipMap: false, name: "LightVolumeColorAccumulation");
m_DebugLightVolumesTexture = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, useMipMap: false, name: "LightVolumeDebugLightVolumesTexture");
m_DepthBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, depthBufferBits: DepthBits.None, colorFormat: GraphicsFormat.R8_UNorm, name: "LightVolumeDepth");
// Fill the render target array
m_RTIDs[0] = m_LightCountBuffer;
m_RTIDs[1] = m_ColorAccumulationBuffer;
}
public void RebuildTextures(int resolution)
{
bool updateNeeded = m_SkyboxCubemapRT == null || (m_SkyboxCubemapRT.rt.width != resolution);
// Cleanup first if needed
if (updateNeeded)
{
RTHandles.Release(m_SkyboxCubemapRT);
RTHandles.Release(m_SkyboxGGXCubemapRT);
m_SkyboxCubemapRT = null;
m_SkyboxGGXCubemapRT = null;
}
if (!m_SupportsMIS && (m_SkyboxConditionalCdfRT != null))
{
RTHandles.Release(m_SkyboxConditionalCdfRT);
RTHandles.Release(m_SkyboxMarginalRowCdfRT);
m_SkyboxConditionalCdfRT = null;
m_SkyboxMarginalRowCdfRT = null;
}
// Reallocate everything
if (m_SkyboxCubemapRT == null)
{
m_SkyboxCubemapRT = RTHandles.Alloc(resolution, resolution, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxCubemap");
}
if (m_SkyboxGGXCubemapRT == null && m_SupportsConvolution)
{
m_SkyboxGGXCubemapRT = RTHandles.Alloc(resolution, resolution, colorFormat: RenderTextureFormat.ARGBHalf, sRGB: false, dimension: TextureDimension.Cube, useMipMap: true, autoGenerateMips: false, filterMode: FilterMode.Trilinear, name: "SkyboxGGXCubemap");
}
if (m_SupportsMIS && (m_SkyboxConditionalCdfRT == null))
{
// Temporary, it should be dependent on the sky resolution
int width = (int)LightSamplingParameters.TextureWidth;
int height = (int)LightSamplingParameters.TextureHeight;
// + 1 because we store the value of the integral of the cubemap at the end of the texture.
m_SkyboxMarginalRowCdfRT = RTHandles.Alloc(height + 1, 1, colorFormat: RenderTextureFormat.RFloat, sRGB: false, useMipMap: false, enableRandomWrite: true, filterMode: FilterMode.Point, name: "SkyboxMarginalRowCdf");
// TODO: switch the format to R16 (once it's available) to save some bandwidth.
m_SkyboxMarginalRowCdfRT = RTHandles.Alloc(width, height, colorFormat: RenderTextureFormat.RFloat, sRGB: false, useMipMap: false, enableRandomWrite: true, filterMode: FilterMode.Point, name: "SkyboxMarginalRowCdf");
}
m_CubemapScreenSize = new Vector4((float)resolution, (float)resolution, 1.0f / (float)resolution, 1.0f / (float)resolution);
if (updateNeeded)
{
m_NeedUpdate = true; // Special case. Even if update mode is set to OnDemand, we need to regenerate the environment after destroying the texture.
RebuildSkyMatrices(resolution);
}
}
RTHandle[] m_InScatteredRadianceTables; // Air SS, Aerosol SS, Atmosphere MS, Atmosphere one order, Temp
RTHandle AllocateGroundIrradianceTable(int index)
{
var table = RTHandles.Alloc((int)PbrSkyConfig.GroundIrradianceTableSize, 1,
colorFormat: s_ColorFormat,
enableRandomWrite: true,
name: string.Format("GroundIrradianceTable{0}", index));
Debug.Assert(table != null);
return(table);
}
public void Init(HDRenderPipelineRayTracingResources rpRTResources, SharedRTManager sharedRTManager)
{
// Keep track of the resources
m_TemporalFilterCS = rpRTResources.temporalFilterCS;
// Keep track of the shared rt manager
m_SharedRTManager = sharedRTManager;
// Allocate the temporary buffers
m_ValidationBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R8_UInt, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, autoGenerateMips: false, name: "ValidationBuffer");
}
void InitRaytracingDeferred()
{
m_RayBinResult = new ComputeBuffer(1, sizeof(uint));
m_RayBinSizeResult = new ComputeBuffer(1, sizeof(uint));
m_RaytracingDirectionBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "RaytracingDirectionBuffer");
m_RaytracingDistanceBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.R32_SFloat, dimension: TextureXR.dimension, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "RaytracingDistanceBuffer");
m_RaytracingGBufferManager = new GBufferManager(asset, m_DeferredMaterial);
m_RaytracingGBufferManager.CreateBuffers();
}
// It can be used to configure render targets and their clear state. Also to create temporary render target textures.
// When empty this render pass will render to the active camera render target.
// You should never call CommandBuffer.SetRenderTarget. Instead call <c>ConfigureTarget</c> and <c>ConfigureClear</c>.
// The render pipeline will ensure target setup and clearing happens in an performance manner.
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
fullscreenMaterial = CoreUtils.CreateEngineMaterial("FullScreen/EdgeDetection");
edgeDetectionBuffer = RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, useDynamicScale: true, name: "EdgeDetection Buffer");
compositingPass = fullscreenMaterial.FindPass("Compositing");
copyPass = fullscreenMaterial.FindPass("Copy");
targetColorBuffer = TargetBuffer.Custom;
targetDepthBuffer = TargetBuffer.Custom;
clearFlags = ClearFlag.All;
}
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
outlineShader = Shader.Find("Hidden/Outline");
fullscreenOutline = CoreUtils.CreateEngineMaterial(outlineShader);
outlineBuffer = RTHandles.Alloc(
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, // We don't need alpha for this effect
useDynamicScale: true, name: "Outline Buffer"
);
}
public override void Setup()
{
if (Shader.Find("Hidden/Shader/ArtefactsEffect_RLPRO") != null)
{
m_Material = new Material(Shader.Find("Hidden/Shader/ArtefactsEffect_RLPRO"));
}
texLast = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "texLast");
texfeedback = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "texfeedback");
texfeedback2 = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "texfeedback2");
previous = RTHandles.Alloc(Vector2.one, TextureXR.slices, colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2DArray, enableRandomWrite: true, useDynamicScale: true, name: "previous");
}
public void SetUp()
{
_buffer1 = RTHandles.Alloc(1024, 1024, 1,
dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R8G8B8A8_UNorm,
useDynamicScale: false, name: "_SharedRenderTexture"
);
StaticProps.TextureId = _buffer1.rt.GetNativeTexturePtr().ToInt32();
}
public void InitRecursiveRenderer()
{
m_RaytracingFlagTarget = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R8_SNorm, enableRandomWrite: true, useMipMap: false, name: "RaytracingFlagTexture");
m_DebugRaytracingTexture = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, useDynamicScale: true, useMipMap: false, name: "DebugRaytracingBuffer");
m_RaytracingFlagStateBlock = new RenderStateBlock
{
depthState = new DepthState(false, CompareFunction.LessEqual),
mask = RenderStateMask.Depth
};
}
