static Material CreateLightMaterial(Light2D light, bool isVolume)
{
bool isShape = light.IsShapeLight();
Material material;
if (isVolume)
{
material = CoreUtils.CreateEngineMaterial(isShape ? s_RendererData.shapeLightVolumeShader : s_RendererData.pointLightVolumeShader);
}
else
{
material = CoreUtils.CreateEngineMaterial(isShape ? s_RendererData.shapeLightShader : s_RendererData.pointLightShader);
if (!light.alphaBlendOnOverlap)
{
SetBlendModes(material, BlendMode.One, BlendMode.One);
material.EnableKeyword(k_UseAdditiveBlendingKeyword);
}
else
{
SetBlendModes(material, BlendMode.SrcAlpha, BlendMode.OneMinusSrcAlpha);
}
}
if (light.lightType == Light2D.LightType.Sprite)
{
material.EnableKeyword(k_SpriteLightKeyword);
}
if (!isShape && light.lightCookieSprite != null && light.lightCookieSprite.texture != null)
{
material.EnableKeyword(k_UsePointLightCookiesKeyword);
}
if (!isShape && light.pointLightQuality == Light2D.PointLightQuality.Fast)
{
material.EnableKeyword(k_LightQualityFastKeyword);
}
if (light.useNormalMap)
{
material.EnableKeyword(k_UseNormalMap);
}
return(material);
}
// The constructor of the pass. Here you can set any material properties that do not need to be updated on a per-frame basis.
public TemplatePass(TemplateFeature.PassSettings passSettings)
{
this.passSettings = passSettings;
// Set the render pass event.
renderPassEvent = passSettings.renderPassEvent;
// We create a material that will be used during our pass. You can do it like this using the 'CreateEngineMaterial' method, giving it
// a shader path as an input or you can use a 'public Material material;' field in your pass settings and access it here through 'passSettings.material'.
if (material == null)
{
material = CoreUtils.CreateEngineMaterial("Hidden/Blur");
}
// Set any material properties based on our pass settings.
material.SetInt(BlurStrengthProperty, passSettings.blurStrength);
}
private void InitDefaultRenderState(ref ForwardRendererData data)
{
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
m_CustomBlitMaterail = CoreUtils.CreateEngineMaterial(data.shaders.customBlitPS);
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
m_ScreenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
StencilStateData stencilData = data.defaultStencilState;
m_DefaultStencilState = StencilState.defaultValue;
m_DefaultStencilState.enabled = stencilData.overrideStencilState;
m_DefaultStencilState.SetCompareFunction(stencilData.stencilCompareFunction);
m_DefaultStencilState.SetPassOperation(stencilData.passOperation);
m_DefaultStencilState.SetFailOperation(stencilData.failOperation);
m_DefaultStencilState.SetZFailOperation(stencilData.zFailOperation);
}
public override void Create()
{
scriptablePass = new SSAORenderPass("SSAO");
m_Shader = Shader.Find(m_ShaderName);
if (!m_Material)
{
m_Material = CoreUtils.CreateEngineMaterial(m_Shader);
}
scriptablePass.SSAOMaterial = m_Material;
scriptablePass.intensity = settings.intensity;
scriptablePass.radius = settings.radius;
scriptablePass.sampleCount = settings.sampleCount;
scriptablePass.renderPassEvent = settings.renderPassEvent;
}
public MipGenerator(HDRenderPipelineAsset asset)
{
m_TempColorTargets = new RTHandle[kernelCount];
m_DepthPyramidCS = asset.renderPipelineResources.shaders.depthPyramidCS;
m_ColorPyramidCS = asset.renderPipelineResources.shaders.colorPyramidCS;
m_DepthDownsampleKernel = m_DepthPyramidCS.FindKernel("KDepthDownsample8DualUav");
m_ColorDownsampleKernel = InitColorKernel("KColorDownsample");
m_ColorDownsampleKernelCopyMip0 = InitColorKernel("KColorDownsampleCopyMip0");
m_ColorGaussianKernel = InitColorKernel("KColorGaussian");
m_SrcOffset = new int[4];
m_DstOffset = new int[4];
m_ColorPyramidPS = asset.renderPipelineResources.shaders.colorPyramidPS;
m_ColorPyramidPSMat = CoreUtils.CreateEngineMaterial(m_ColorPyramidPS);
m_PropertyBlock = new MaterialPropertyBlock();
}
private static Material CreateLightMaterial(Renderer2DData rendererData, Light2D light, bool isVolume)
{
var isPoint = light.isPointLight;
Material material;
if (isVolume)
{
material = CoreUtils.CreateEngineMaterial(isPoint ? rendererData.pointLightVolumeShader : rendererData.shapeLightVolumeShader);
}
else
{
material = CoreUtils.CreateEngineMaterial(isPoint ? rendererData.pointLightShader : rendererData.shapeLightShader);
if (light.overlapOperation == Light2D.OverlapOperation.Additive)
{
SetBlendModes(material, BlendMode.One, BlendMode.One);
material.EnableKeyword(k_UseAdditiveBlendingKeyword);
}
else
{
SetBlendModes(material, BlendMode.SrcAlpha, BlendMode.OneMinusSrcAlpha);
}
}
if (light.lightType == Light2D.LightType.Sprite)
{
material.EnableKeyword(k_SpriteLightKeyword);
}
if (isPoint && light.lightCookieSprite != null && light.lightCookieSprite.texture != null)
{
material.EnableKeyword(k_UsePointLightCookiesKeyword);
}
if (isPoint && light.normalMapQuality == Light2D.NormalMapQuality.Fast)
{
material.EnableKeyword(k_LightQualityFastKeyword);
}
if (light.normalMapQuality != Light2D.NormalMapQuality.Disabled)
{
material.EnableKeyword(k_UseNormalMap);
}
return(material);
}
public void Build(HDRenderPipelineAsset hdAsset, RenderPipelineResources defaultResources, IBLFilterBSDF[] iblFilterBSDFArray)
{
m_SkyRenderingContext = new SkyRenderingContext(iblFilterBSDFArray, (int)hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyReflectionSize, true);
#if UNITY_EDITOR
m_PreviewSkyRenderingContext = new SkyRenderingContext(iblFilterBSDFArray, (int)hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyReflectionSize, true);
#endif
m_StandardSkyboxMaterial = CoreUtils.CreateEngineMaterial(defaultResources.shaders.skyboxCubemapPS);
m_BlitCubemapMaterial = CoreUtils.CreateEngineMaterial(defaultResources.shaders.blitCubemapPS);
m_OpaqueAtmScatteringMaterial = CoreUtils.CreateEngineMaterial(defaultResources.shaders.opaqueAtmosphericScatteringPS);
m_OpaqueAtmScatteringBlock = new MaterialPropertyBlock();
m_LightingOverrideVolumeStack = VolumeManager.instance.CreateStack();
m_LightingOverrideLayerMask = hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask;
m_StaticLightingSkyRenderingContext = new SkyRenderingContext(iblFilterBSDFArray, (int)hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyReflectionSize, false);
}
public Renderer2D(Renderer2DData data) : base(data)
{
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.blitShader);
m_ColorGradingLutPass = new ColorGradingLutPass(RenderPassEvent.BeforeRenderingOpaques, data.postProcessData);
m_Render2DLightingPass = new Render2DLightingPass(data);
m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing, data.postProcessData);
m_FinalPostProcessPass = new PostProcessPass(RenderPassEvent.AfterRenderingPostProcessing, data.postProcessData);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering, m_BlitMaterial);
m_UseDepthStencilBuffer = data.useDepthStencilBuffer;
m_AfterPostProcessColorHandle.Init("_AfterPostProcessTexture");
m_ColorGradingLutHandle.Init("_InternalGradingLut");
m_Renderer2DData = data;
}
public StochasticRasterizerInstance()
{
m_PostProcessRenderContext = new PostProcessRenderContext();
int w = Screen.width; int h = Screen.height;
// Initial state of the RTHandle system.
// Tells the system that we will require MSAA or not so that we can avoid wasteful render texture allocation.
// TODO: Might want to initialize to at least the window resolution to avoid un-necessary re-alloc in the player
RTHandles.Initialize(1, 1, true, (MSAASamples)k_MSAASamples);
RTHandles.SetReferenceSize(w, h, (MSAASamples)k_MSAASamples);
InitializeBuffers();
// Our final pass is stored in Pass 4 of stochastic material.
m_FinalPass = CoreUtils.CreateEngineMaterial(Shader.Find("StochasticRasterizer/UnlitStochastic"));
}
void InitializeSubsurfaceScattering()
{
// Disney SSS (compute + combine)
string kernelName = "SubsurfaceScattering";
m_SubsurfaceScatteringCS = defaultResources.shaders.subsurfaceScatteringCS;
m_SubsurfaceScatteringKernel = m_SubsurfaceScatteringCS.FindKernel(kernelName);
m_CombineLightingPass = CoreUtils.CreateEngineMaterial(defaultResources.shaders.combineLightingPS);
m_CombineLightingPass.SetInt(HDShaderIDs._StencilRef, (int)StencilUsage.SubsurfaceScattering);
m_CombineLightingPass.SetInt(HDShaderIDs._StencilMask, (int)StencilUsage.SubsurfaceScattering);
m_SSSCopyStencilForSplitLighting = CoreUtils.CreateEngineMaterial(defaultResources.shaders.copyStencilBufferPS);
m_SSSCopyStencilForSplitLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilUsage.SubsurfaceScattering);
m_SSSCopyStencilForSplitLighting.SetInt(HDShaderIDs._StencilMask, (int)StencilUsage.SubsurfaceScattering);
m_SSSDefaultDiffusionProfile = defaultResources.assets.defaultDiffusionProfile;
}
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
if (stencilShader == null)
{
stencilShader = Shader.Find("Hidden/Renderers/SeeThroughStencil");
}
stencilMaterial = CoreUtils.CreateEngineMaterial(stencilShader);
shaderTags = new ShaderTagId[4]
{
new ShaderTagId("Forward"),
new ShaderTagId("ForwardOnly"),
new ShaderTagId("SRPDefaultUnlit"),
new ShaderTagId("FirstPass"),
};
}
public ForwardRenderer(ForwardRendererData data) : base(data)
{
Downsampling downsamplingMethod = LightweightRenderPipeline.asset.opaqueDownsampling;
Material blitMaterial = CoreUtils.CreateEngineMaterial(data.blitShader);
Material copyDepthMaterial = CoreUtils.CreateEngineMaterial(data.copyDepthShader);
Material samplingMaterial = CoreUtils.CreateEngineMaterial(data.samplingShader);
Material screenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.screenSpaceShadowShader);
StencilStateData stencilData = data.defaultStencilState;
m_DefaultStencilState = StencilState.defaultValue;
m_DefaultStencilState.enabled = stencilData.overrideStencilState;
m_DefaultStencilState.SetCompareFunction(stencilData.stencilCompareFunction);
m_DefaultStencilState.SetPassOperation(stencilData.passOperation);
m_DefaultStencilState.SetFailOperation(stencilData.failOperation);
m_DefaultStencilState.SetZFailOperation(stencilData.zFailOperation);
// Note: Since all custom render passes inject first and we have stable sort,
// we inject the builtin passes in the before events.
m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_ScreenSpaceShadowResolvePass = new ScreenSpaceShadowResolvePass(RenderPassEvent.BeforeRenderingPrepasses, screenspaceShadowsMaterial);
m_RenderOpaqueForwardPass = new DrawObjectsPass("Render Opaques", true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.BeforeRenderingOpaques, copyDepthMaterial);
m_OpaquePostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingOpaques, true);
m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.BeforeRenderingTransparents, samplingMaterial, downsamplingMethod);
m_RenderTransparentForwardPass = new DrawObjectsPass("Render Transparents", false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing);
m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering, blitMaterial);
#if UNITY_EDITOR
m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(RenderPassEvent.AfterRendering + 9, copyDepthMaterial);
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_CameraColorAttachment.Init("_CameraColorTexture");
m_CameraDepthAttachment.Init("_CameraDepthAttachment");
m_DepthTexture.Init("_CameraDepthTexture");
m_OpaqueColor.Init("_CameraOpaqueTexture");
m_ForwardLights = new ForwardLights();
}
public override void Create()
{
if (m_targetPrecomputeFrustumsCS)
{
if (m_precomputeFrustumsPass != null)
{
m_precomputeFrustumsPass.Release();
}
m_precomputeFrustumsPass = new PrecomputeFrustumsPass(
m_targetPrecomputeFrustumsCS);
}
m_depthOnlyPass = new DepthOnlyPass();
m_copyDepthPass = new CopyDepthPass();
if (m_targetForwardPlusLightCullingCS)
{
if (m_tileLightCullingPass != null)
{
m_tileLightCullingPass.Release();
}
m_tileLightCullingPass = new TileLightCullingPass(
m_targetForwardPlusLightCullingCS);
}
if (m_samplingShader)
{
Material samplingMaterial = CoreUtils.CreateEngineMaterial(
m_samplingShader);
m_copyColorPass = new CopyColorPass(
RenderPassEvent.BeforeRenderingPostProcessing, samplingMaterial);
}
if (m_showTileLightGridShader && m_heatMap)
{
m_showDebugTileLightGridMaterial = CoreUtils.CreateEngineMaterial(
m_showTileLightGridShader);
m_showDebugTileLightGridMaterial.SetTexture("_HeatMap", m_heatMap);
m_showLightGridsPass = new ShowLightGridsPass(m_showDebugTileLightGridMaterial);
}
m_backgroundRT.Init("_BackGroundRT");
}
public override void OnEnable()
{
base.OnEnable();
m_EnableLuxIntensityMode = true;
// HDRI sky does not have control over sun display.
m_CommonUIElementsMask = 0xFFFFFFFF & ~(uint)(SkySettingsUIElement.IncludeSunInBaking);
var o = new PropertyFetcher <HDRISky>(serializedObject);
m_hdriSky = Unpack(o.Find(x => x.hdriSky));
m_UpperHemisphereLuxValue = Unpack(o.Find(x => x.upperHemisphereLuxValue));
m_UpperHemisphereLuxColor = Unpack(o.Find(x => x.upperHemisphereLuxColor));
m_EnableCloudMotion = Unpack(o.Find(x => x.enableDistortion));
m_Procedural = Unpack(o.Find(x => x.procedural));
m_Flowmap = Unpack(o.Find(x => x.flowmap));
m_UpperHemisphereOnly = Unpack(o.Find(x => x.upperHemisphereOnly));
m_ScrollDirection = Unpack(o.Find(x => x.scrollDirection));
m_ScrollSpeed = Unpack(o.Find(x => x.scrollSpeed));
m_EnableBackplate = Unpack(o.Find(x => x.enableBackplate));
m_BackplateType = Unpack(o.Find(x => x.backplateType));
m_GroundLevel = Unpack(o.Find(x => x.groundLevel));
m_Scale = Unpack(o.Find(x => x.scale));
m_ProjectionDistance = Unpack(o.Find(x => x.projectionDistance));
m_PlateRotation = Unpack(o.Find(x => x.plateRotation));
m_PlateTexRotation = Unpack(o.Find(x => x.plateTexRotation));
m_PlateTexOffset = Unpack(o.Find(x => x.plateTexOffset));
m_BlendAmount = Unpack(o.Find(x => x.blendAmount));
m_PointLightShadow = Unpack(o.Find(x => x.pointLightShadow));
m_DirLightShadow = Unpack(o.Find(x => x.dirLightShadow));
m_RectLightShadow = Unpack(o.Find(x => x.rectLightShadow));
m_ShadowTint = Unpack(o.Find(x => x.shadowTint));
m_IntensityTexture = RTHandles.Alloc(1, 1, colorFormat: GraphicsFormat.R32G32B32A32_SFloat);
var hdrp = HDRenderPipeline.defaultAsset;
if (hdrp != null)
{
m_IntegrateHDRISkyMaterial = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.shaders.integrateHdriSkyPS);
}
m_ReadBackTexture = new Texture2D(1, 1, GraphicsFormat.R32G32B32A32_SFloat, TextureCreationFlags.None);
}
public void Initialize(CommandBuffer cmd)
{
if (!m_ComputeGgxIblSampleDataCS)
{
m_ComputeGgxIblSampleDataCS = m_RenderPipelineResources.computeGgxIblSampleData;
m_ComputeGgxIblSampleDataKernel = m_ComputeGgxIblSampleDataCS.FindKernel("ComputeGgxIblSampleData");
}
if (!m_BuildProbabilityTablesCS)
{
m_BuildProbabilityTablesCS = m_RenderPipelineResources.buildProbabilityTables;
m_ConditionalDensitiesKernel = m_BuildProbabilityTablesCS.FindKernel("ComputeConditionalDensities");
m_MarginalRowDensitiesKernel = m_BuildProbabilityTablesCS.FindKernel("ComputeMarginalRowDensities");
}
if (!m_GgxConvolveMaterial)
{
m_GgxConvolveMaterial = CoreUtils.CreateEngineMaterial(m_RenderPipelineResources.GGXConvolve);
}
if (!m_GgxIblSampleData)
{
m_GgxIblSampleData = new RenderTexture(m_GgxIblMaxSampleCount, k_GgxIblMipCountMinusOne, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
m_GgxIblSampleData.useMipMap = false;
m_GgxIblSampleData.autoGenerateMips = false;
m_GgxIblSampleData.enableRandomWrite = true;
m_GgxIblSampleData.filterMode = FilterMode.Point;
m_GgxIblSampleData.name = CoreUtils.GetRenderTargetAutoName(m_GgxIblMaxSampleCount, k_GgxIblMipCountMinusOne, 1, RenderTextureFormat.ARGBHalf, "GGXIblSampleData");
m_GgxIblSampleData.hideFlags = HideFlags.HideAndDontSave;
m_GgxIblSampleData.Create();
m_ComputeGgxIblSampleDataCS.SetTexture(m_ComputeGgxIblSampleDataKernel, "output", m_GgxIblSampleData);
using (new ProfilingSample(cmd, "Compute GGX IBL Sample Data"))
{
cmd.DispatchCompute(m_ComputeGgxIblSampleDataCS, m_ComputeGgxIblSampleDataKernel, 1, 1, 1);
}
}
for (int i = 0; i < 6; ++i)
{
var lookAt = Matrix4x4.LookAt(Vector3.zero, CoreUtils.lookAtList[i], CoreUtils.upVectorList[i]);
m_faceWorldToViewMatrixMatrices[i] = lookAt * Matrix4x4.Scale(new Vector3(1.0f, 1.0f, -1.0f)); // Need to scale -1.0 on Z to match what is being done in the camera.wolrdToCameraMatrix API. ...
}
}
// 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)
{
Debug.Log("Alloc !");
blurMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/FullScreen/BlurPasses"));
compositingMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/FullScreen/LiquidCompositing"));
shaderTags = new ShaderTagId[4]
{
new ShaderTagId("Forward"),
new ShaderTagId("ForwardOnly"),
new ShaderTagId("SRPDefaultUnlit"),
new ShaderTagId("FirstPass"),
};
// Allocate the buffers used for the blur in half resolution to save some memory
downSampleBuffer = RTHandles.Alloc(
Vector2.one * 0.5f, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SNorm,
useDynamicScale: true, name: "DownSampleBuffer"
);
blurBuffer = RTHandles.Alloc(
Vector2.one * 0.5f, TextureXR.slices, dimension: TextureXR.dimension,
colorFormat: GraphicsFormat.R16G16B16A16_SNorm,
useDynamicScale: true, name: "BlurBuffer"
);
targetColorBuffer = TargetBuffer.Custom;
targetDepthBuffer = TargetBuffer.Custom;
clearFlags = ClearFlag.All;
quad = new Mesh();
quad.SetVertices(new List <Vector3> {
new Vector3(-1, -1, 0),
new Vector3(1, -1, 0),
new Vector3(-1, 1, 0),
new Vector3(1, 1, 0),
});
quad.SetTriangles(new List <int> {
0, 3, 1, 0, 2, 3
}, 0);
quad.RecalculateBounds();
quad.UploadMeshData(false);
}
public LightweightShadowPass(LightweightPipelineAsset pipelineAsset, int maxLocalLightsCount)
{
BuildShadowSettings(pipelineAsset);
m_DirectionalShadowMatrices = new Matrix4x4[kMaxCascades + 1];
m_CascadeSlices = new ShadowSliceData[kMaxCascades];
m_CascadeSplitDistances = new Vector4[kMaxCascades];
m_LocalShadowMatrices = new Matrix4x4[maxLocalLightsCount];
m_LocalLightSlices = new ShadowSliceData[maxLocalLightsCount];
m_LocalShadowStrength = new float[maxLocalLightsCount];
DirectionalShadowConstantBuffer._WorldToShadow = Shader.PropertyToID("_WorldToShadow");
DirectionalShadowConstantBuffer._ShadowData = Shader.PropertyToID("_ShadowData");
DirectionalShadowConstantBuffer._DirShadowSplitSpheres = Shader.PropertyToID("_DirShadowSplitSpheres");
DirectionalShadowConstantBuffer._DirShadowSplitSphereRadii = Shader.PropertyToID("_DirShadowSplitSphereRadii");
DirectionalShadowConstantBuffer._ShadowOffset0 = Shader.PropertyToID("_ShadowOffset0");
DirectionalShadowConstantBuffer._ShadowOffset1 = Shader.PropertyToID("_ShadowOffset1");
DirectionalShadowConstantBuffer._ShadowOffset2 = Shader.PropertyToID("_ShadowOffset2");
DirectionalShadowConstantBuffer._ShadowOffset3 = Shader.PropertyToID("_ShadowOffset3");
DirectionalShadowConstantBuffer._ShadowmapSize = Shader.PropertyToID("_ShadowmapSize");
LocalShadowConstantBuffer._LocalWorldToShadowAtlas = Shader.PropertyToID("_LocalWorldToShadowAtlas");
LocalShadowConstantBuffer._LocalShadowStrength = Shader.PropertyToID("_LocalShadowStrength");
LocalShadowConstantBuffer._LocalShadowOffset0 = Shader.PropertyToID("_LocalShadowOffset0");
LocalShadowConstantBuffer._LocalShadowOffset1 = Shader.PropertyToID("_LocalShadowOffset1");
LocalShadowConstantBuffer._LocalShadowOffset2 = Shader.PropertyToID("_LocalShadowOffset2");
LocalShadowConstantBuffer._LocalShadowOffset3 = Shader.PropertyToID("_LocalShadowOffset3");
LocalShadowConstantBuffer._LocalShadowmapSize = Shader.PropertyToID("_LocalShadowmapSize");
m_DirectionalShadowmapID = Shader.PropertyToID("_ShadowMap");
m_LocalShadowmapID = Shader.PropertyToID("_LocalShadowMapAtlas");
m_ScreenSpaceShadowmapID = Shader.PropertyToID("_ScreenSpaceShadowMap");
m_ScreenSpaceShadowmapTexture = new RenderTargetIdentifier(m_ScreenSpaceShadowmapID);
m_DirectionalShadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.directionalShadowAtlasWidth,
m_ShadowSettings.directionalShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
m_LocalShadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.localShadowAtlasWidth,
m_ShadowSettings.localShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
m_ScreenSpaceShadowsMaterial = CoreUtils.CreateEngineMaterial(pipelineAsset.ScreenSpaceShadowShader);
Clear();
}
void InitializePrepass(HDRenderPipelineAsset hdAsset)
{
m_DepthResolveMaterial = CoreUtils.CreateEngineMaterial(asset.renderPipelineResources.shaders.depthValuesPS);
m_GBufferOutput = new GBufferOutput();
m_GBufferOutput.mrt = new TextureHandle[RenderGraph.kMaxMRTCount];
m_DBufferOutput = new DBufferOutput();
m_DBufferOutput.mrt = new TextureHandle[(int)Decal.DBufferMaterial.Count];
m_DepthBufferMipChainInfo = new HDUtils.PackedMipChainInfo();
m_DepthBufferMipChainInfo.Allocate();
m_DepthPyramidDesc = new TextureDesc(ComputeDepthBufferMipChainSize, true, true)
{
colorFormat = GraphicsFormat.R32_SFloat, enableRandomWrite = true, name = "CameraDepthBufferMipChain"
};
}
public void InitData(RenderPipelineResources renderPipelineResources)
{
m_DebugLightVolumeMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.debugLightVolumePS);
m_DebugLightVolumeCompute = renderPipelineResources.shaders.debugLightVolumeCS;
m_DebugLightVolumeGradientKernel = m_DebugLightVolumeCompute.FindKernel("LightVolumeGradient");
m_DebugLightVolumeColorsKernel = m_DebugLightVolumeCompute.FindKernel("LightVolumeColors");
m_ColorGradientTexture = renderPipelineResources.textures.colorGradient;
m_Blit = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.blitPS);
m_LightCountBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R32_SFloat, enableRandomWrite: false, useMipMap: false, xrInstancing: true, name: "LightVolumeCount");
m_ColorAccumulationBuffer = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: false, useMipMap: false, xrInstancing: true, name: "LightVolumeColorAccumulation");
m_DebugLightVolumesTexture = RTHandles.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, enableRandomWrite: true, useMipMap: false, xrInstancing: true, name: "LightVolumeDebugLightVolumesTexture");
m_DepthBuffer = RTHandles.Alloc(Vector2.one, depthBufferBits: DepthBits.None, colorFormat: GraphicsFormat.R8_UNorm, filterMode: FilterMode.Point, xrInstancing: true, name: "LightVolumeDepth");
// Fill the render target array
m_RTIDs[0] = m_LightCountBuffer;
m_RTIDs[1] = m_ColorAccumulationBuffer;
}
internal void InitializeXRSystemData(XRSystemData data)
{
if (data)
{
if (occlusionMeshMaterial != null)
{
CoreUtils.Destroy(occlusionMeshMaterial);
}
if (mirrorViewMaterial != null)
{
CoreUtils.Destroy(mirrorViewMaterial);
}
occlusionMeshMaterial = CoreUtils.CreateEngineMaterial(data.shaders.xrOcclusionMeshPS);
mirrorViewMaterial = CoreUtils.CreateEngineMaterial(data.shaders.xrMirrorViewPS);
}
}
void InitializeSubsurfaceScattering()
{
// Disney SSS (compute + combine)
string kernelName = asset.currentPlatformRenderPipelineSettings.increaseSssSampleCount ? "SubsurfaceScatteringHQ" : "SubsurfaceScatteringMQ";
string kernelNameMSAA = asset.currentPlatformRenderPipelineSettings.increaseSssSampleCount ? "SubsurfaceScatteringHQ_MSAA" : "SubsurfaceScatteringMQ_MSAA";
m_SubsurfaceScatteringCS = defaultResources.shaders.subsurfaceScatteringCS;
m_SubsurfaceScatteringKernel = m_SubsurfaceScatteringCS.FindKernel(kernelName);
m_SubsurfaceScatteringKernelMSAA = m_SubsurfaceScatteringCS.FindKernel(kernelNameMSAA);
m_CombineLightingPass = CoreUtils.CreateEngineMaterial(defaultResources.shaders.combineLightingPS);
m_CombineLightingPass.SetInt(HDShaderIDs._StencilMask, (int)HDRenderPipeline.StencilBitMask.LightingMask);
m_SSSCopyStencilForSplitLighting = CoreUtils.CreateEngineMaterial(defaultResources.shaders.copyStencilBufferPS);
m_SSSCopyStencilForSplitLighting.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.SplitLighting);
m_SSSCopyStencilForSplitLighting.SetInt(HDShaderIDs._StencilMask, (int)HDRenderPipeline.StencilBitMask.LightingMask);
m_SSSDefaultDiffusionProfile = defaultResources.assets.defaultDiffusionProfile;
}
public OverdrawPass(string profilerTag, RenderQueueRange renderQueueRange, Shader shader, bool isOpaque)
{
this.profilerTag = profilerTag;
this.isOpaque = isOpaque;
#if UNITY_2020_2_OR_NEWER
profilingSampler = new ProfilingSampler(nameof(OverdrawPass));
sampler = new ProfilingSampler(profilerTag);
#else
profilingSampler = new ProfilingSampler(profilerTag);
#endif
tagIdList.Add(new ShaderTagId("UniversalForward"));
tagIdList.Add(new ShaderTagId("LightweightForward"));
tagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
filteringSettings = new FilteringSettings(renderQueueRange, LayerMask.NameToLayer("Everything"));
material = CoreUtils.CreateEngineMaterial(shader);
}
public void Setup(Shader shader, ScriptableRenderer renderer, RenderingData renderingData)
{
if (material == null)
{
material = CoreUtils.CreateEngineMaterial(shader);
}
#if !URP_10_0_0_OR_NEWER
source = renderer.cameraColorTarget;
cameraData = renderingData.cameraData;
// Configures where the render pass should be injected.
FetchVolumeComponent();
renderPassEvent = hbao.debugMode.value == HBAO.DebugMode.Disabled ?
RenderPassEvent.BeforeRenderingTransparents :
RenderPassEvent.AfterRenderingTransparents;
#endif
}
public ScriptableRenderer(LightweightRenderPipelineAsset pipelineAsset)
{
if (pipelineAsset == null)
{
throw new ArgumentNullException("pipelineAsset");
}
m_Materials = new[]
{
CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader"),
CoreUtils.CreateEngineMaterial(pipelineAsset.copyDepthShader),
CoreUtils.CreateEngineMaterial(pipelineAsset.samplingShader),
CoreUtils.CreateEngineMaterial(pipelineAsset.blitShader),
CoreUtils.CreateEngineMaterial(pipelineAsset.screenSpaceShadowShader),
};
postProcessingContext = new PostProcessRenderContext();
}
public ForwardRendererSetup(ForwardRendererData data)
{
Material blitMaterial = CoreUtils.CreateEngineMaterial(data.blitShader);
Material copyDepthMaterial = CoreUtils.CreateEngineMaterial(data.copyDepthShader);
Material samplingMaterial = CoreUtils.CreateEngineMaterial(data.samplingShader);
Material screenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.screenSpaceShadowShader);
m_DepthOnlyPass = new DepthOnlyPass();
m_MainLightShadowCasterPass = new MainLightShadowCasterPass();
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass();
m_SetupForwardRenderingPass = new SetupForwardRenderingPass();
m_ScreenSpaceShadowResolvePass = new ScreenSpaceShadowResolvePass(screenspaceShadowsMaterial);
m_CreateLightweightRenderTexturesPass = new CreateLightweightRenderTexturesPass();
m_BeginXrRenderingPass = new BeginXRRenderingPass();
m_SetupLightweightConstants = new SetupLightweightConstanstPass();
m_RenderOpaqueForwardPass = new RenderOpaqueForwardPass();
m_OpaquePostProcessPass = new PostProcessPass();
m_DrawSkyboxPass = new DrawSkyboxPass();
m_CopyDepthPass = new CopyDepthPass(copyDepthMaterial);
m_CopyColorPass = new CopyColorPass(samplingMaterial);
m_RenderTransparentForwardPass = new RenderTransparentForwardPass();
m_PostProcessPass = new PostProcessPass();
m_FinalBlitPass = new FinalBlitPass(blitMaterial);
m_CapturePass = new CapturePass();
m_EndXrRenderingPass = new EndXRRenderingPass();
#if UNITY_EDITOR
m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(copyDepthMaterial);
m_LitGizmoRenderingPass = new GizmoRenderingPass();
m_UnlitGizmoRenderingPass = new GizmoRenderingPass();
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_ColorAttachment.Init("_CameraColorTexture");
m_ColorAttachmentAfterOpaquePost.Init("_CameraColorTextureAfterOpaquePost");
m_ColorAttachmentAfterTransparentPost.Init("_CameraColorTextureAfterTransparentPost");
m_DepthAttachment.Init("_CameraDepthAttachment");
m_DepthTexture.Init("_CameraDepthTexture");
m_OpaqueColor.Init("_CameraOpaqueTexture");
m_MainLightShadowmap.Init("_MainLightShadowmapTexture");
m_AdditionalLightsShadowmap.Init("_AdditionalLightsShadowmapTexture");
m_ScreenSpaceShadowmap.Init("_ScreenSpaceShadowmapTexture");
}
// Compute the lux value in the upper hemisphere of the HDRI skybox
public void GetUpperHemisphereLuxValue()
{
// null material can happen when no HDRP asset was present at startup
if (m_IntegrateHDRISkyMaterial == null)
{
if (HDRenderPipeline.isReady)
{
m_IntegrateHDRISkyMaterial = CoreUtils.CreateEngineMaterial(HDRenderPipelineGlobalSettings.instance.renderPipelineResources.shaders.integrateHdriSkyPS);
}
else
{
return;
}
}
Cubemap hdri = m_hdriSky.value.objectReferenceValue as Cubemap;
if (hdri == null)
{
return;
}
m_IntegrateHDRISkyMaterial.SetTexture(HDShaderIDs._Cubemap, hdri);
Graphics.Blit(Texture2D.whiteTexture, m_IntensityTexture.rt, m_IntegrateHDRISkyMaterial);
// Copy the rendertexture containing the lux value inside a Texture2D
RenderTexture.active = m_IntensityTexture.rt;
m_ReadBackTexture.ReadPixels(new Rect(0.0f, 0.0f, 1, 1), 0, 0);
RenderTexture.active = null;
// And then the value inside this texture
Color hdriIntensity = m_ReadBackTexture.GetPixel(0, 0);
m_UpperHemisphereLuxValue.value.floatValue = hdriIntensity.a;
float max = Mathf.Max(hdriIntensity.r, hdriIntensity.g, hdriIntensity.b);
if (max == 0.0f)
{
max = 1.0f;
}
m_UpperHemisphereLuxColor.value.vector3Value = new Vector3(hdriIntensity.r / max, hdriIntensity.g / max, hdriIntensity.b / max);
m_UpperHemisphereLuxColor.value.vector3Value *= 0.5f; // Arbitrary 25% to not have too dark or too bright shadow
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
var pass = new CopyColorPass(CoreUtils.CreateEngineMaterial(Shader.Find("Hidden/Lightweight Render Pipeline/Sampling")));
pass.Setup(colorHandle, afterAll);
pass.Execute(renderer, context, ref renderingData);
CommandBuffer cmd = CommandBufferPool.Get("Blit Pass");
cmd.SetRenderTarget(colorHandle.id, depthHandle.id);
cmd.SetViewProjectionMatrices(Matrix4x4.identity, Matrix4x4.identity);
cmd.SetViewport(new Rect(0, renderingData.cameraData.camera.pixelRect.height / 2.0f, renderingData.cameraData.camera.pixelRect.width / 3.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f));
cmd.SetGlobalTexture("_BlitTex", beforeAll.Identifier());
ScriptableRenderer.RenderFullscreenQuad(cmd, m_BlitMaterial);
cmd.SetViewport(new Rect(renderingData.cameraData.camera.pixelRect.width / 3.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f, renderingData.cameraData.camera.pixelRect.width / 3.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f));
cmd.SetGlobalTexture("_BlitTex", afterOpaque.Identifier());
ScriptableRenderer.RenderFullscreenQuad(cmd, m_BlitMaterial);
cmd.SetViewport(new Rect(renderingData.cameraData.camera.pixelRect.width / 3.0f * 2.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f, renderingData.cameraData.camera.pixelRect.width / 3.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f));
cmd.SetGlobalTexture("_BlitTex", afterOpaquePost.Identifier());
ScriptableRenderer.RenderFullscreenQuad(cmd, m_BlitMaterial);
cmd.SetViewport(new Rect(0f, 0f, renderingData.cameraData.camera.pixelRect.width / 3.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f));
cmd.SetGlobalTexture("_BlitTex", afterSkybox.Identifier());
ScriptableRenderer.RenderFullscreenQuad(cmd, m_BlitMaterial);
cmd.SetViewport(new Rect(renderingData.cameraData.camera.pixelRect.width / 3.0f, 0f, renderingData.cameraData.camera.pixelRect.width / 3.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f));
cmd.SetGlobalTexture("_BlitTex", afterTransparent.Identifier());
ScriptableRenderer.RenderFullscreenQuad(cmd, m_BlitMaterial);
cmd.SetViewport(new Rect(renderingData.cameraData.camera.pixelRect.width / 3.0f * 2.0f, 0f, renderingData.cameraData.camera.pixelRect.width / 3.0f, renderingData.cameraData.camera.pixelRect.height / 2.0f));
cmd.SetGlobalTexture("_BlitTex", afterAll.Identifier());
ScriptableRenderer.RenderFullscreenQuad(cmd, m_BlitMaterial);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public HDShadowManager(int width, int height, int maxShadowRequests, DepthBits atlasDepthBits, Shader clearShader)
{
Material clearMaterial = CoreUtils.CreateEngineMaterial(clearShader);
// Prevent the list from resizing their internal container when we add shadow requests
m_ShadowDatas.Capacity = maxShadowRequests;
m_ShadowResolutionRequests.Capacity = maxShadowRequests;
m_ShadowRequests = new HDShadowRequest[maxShadowRequests];
// The cascade atlas will be allocated only if there is a directional light
m_Atlas = new HDShadowAtlas(width, height, HDShaderIDs._ShadowAtlasSize, clearMaterial, depthBufferBits: atlasDepthBits, name: "Shadow Map Atlas");
// Cascade atlas render texture will only be allocated if there is a shadow casting directional light
m_CascadeAtlas = new HDShadowAtlas(1, 1, HDShaderIDs._CascadeShadowAtlasSize, clearMaterial, depthBufferBits: atlasDepthBits, name: "Cascade Shadow Map Atlas");
m_ShadowDataBuffer = new ComputeBuffer(maxShadowRequests, System.Runtime.InteropServices.Marshal.SizeOf(typeof(HDShadowData)));
m_DirectionalShadowDataBuffer = new ComputeBuffer(1, System.Runtime.InteropServices.Marshal.SizeOf(typeof(HDDirectionalShadowData)));
m_MaxShadowRequests = maxShadowRequests;
}
public MotionBlurPass(MotionBlurSettings settings)
{
this.renderPassEvent = settings.Event;
this.isSupportedFloatBuffer = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGB2101010);
this.blitMaterial = CoreUtils.CreateEngineMaterial(settings.shader);
this.resetHistory = true;
this.triangle = new Mesh();
this.triangle.name = "Fullscreen Triangle";
// Because we have to support older platforms (GLES2/3, DX9 etc) we can't do all of
// this directly in the vertex shader using vertex ids :(
this.triangle.SetVertices(new[] {
new Vector3(-1f, -1f, 0f),
new Vector3(-1f, 3f, 0f),
new Vector3(3f, -1f, 0f)
});
this.triangle.SetIndices(new[] { 0, 1, 2 }, MeshTopology.Triangles, 0, false);
this.triangle.UploadMeshData(true);
}
protected override void OnEnable()
{
base.OnEnable();
// These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime
m_ProfileMaterial = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawSssProfile");
m_TransmittanceMaterial = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawTransmittanceGraph");
int count = SssConstants.SSS_N_PROFILES - 1;
m_Profiles = new List <Profile>();
m_UseDisneySSS = properties.Find(x => x.useDisneySSS);
var serializedProfiles = properties.Find(x => x.profiles);
for (int i = 0; i < count; i++)
{
var serializedProfile = serializedProfiles.GetArrayElementAtIndex(i);
var rp = new RelativePropertyFetcher <SubsurfaceScatteringProfile>(serializedProfile);
var profile = new Profile
{
self = serializedProfile,
objReference = m_Target.profiles[i],
name = rp.Find(x => x.name),
scatteringDistance = rp.Find(x => x.scatteringDistance),
transmissionTint = rp.Find(x => x.transmissionTint),
texturingMode = rp.Find(x => x.texturingMode),
transmissionMode = rp.Find(x => x.transmissionMode),
thicknessRemap = rp.Find(x => x.thicknessRemap),
worldScale = rp.Find(x => x.worldScale),
fresnel0 = rp.Find(x => x.fresnel0),
scatterDistance1 = rp.Find(x => x.scatterDistance1),
scatterDistance2 = rp.Find(x => x.scatterDistance2),
lerpWeight = rp.Find(x => x.lerpWeight)
};
m_Profiles.Add(profile);
}
}