// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
// Functions for mixed cached shadows that need to live in cached atlas
// ------------------------------------------------------------------------------------------
public void AddBlitRequestsForUpdatedShadows(HDDynamicShadowAtlas dynamicAtlas)
{
foreach (var request in m_ShadowRequests)
{
if (request.shouldRenderCachedComponent) // meaning it has been updated this time frame
{
dynamicAtlas.AddRequestToPendingBlitFromCache(request);
}
}
}
public void InitShadowManager(RenderPipelineResources renderPipelineResources, HDShadowInitParameters initParams, RenderGraph renderGraph, Shader clearShader)
{
// Even when shadows are disabled (maxShadowRequests == 0) we need to allocate compute buffers to avoid having
// resource not bound errors when dispatching a compute shader.
m_ShadowDataBuffer = new ComputeBuffer(Mathf.Max(initParams.maxShadowRequests, 1), System.Runtime.InteropServices.Marshal.SizeOf(typeof(HDShadowData)));
m_DirectionalShadowDataBuffer = new ComputeBuffer(1, System.Runtime.InteropServices.Marshal.SizeOf(typeof(HDDirectionalShadowData)));
m_MaxShadowRequests = initParams.maxShadowRequests;
m_ShadowRequestCount = 0;
if (initParams.maxShadowRequests == 0)
{
return;
}
m_ClearShadowMaterial = CoreUtils.CreateEngineMaterial(clearShader);
m_BlitShadowMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.shadowBlitPS);
// Prevent the list from resizing their internal container when we add shadow requests
m_ShadowDatas.Capacity = Math.Max(initParams.maxShadowRequests, m_ShadowDatas.Capacity);
m_ShadowResolutionRequests = new HDShadowResolutionRequest[initParams.maxShadowRequests];
m_ShadowRequests = new HDShadowRequest[initParams.maxShadowRequests];
m_CachedDirectionalShadowData = new HDDirectionalShadowData[1]; // we only support directional light shadow
for (int i = 0; i < initParams.maxShadowRequests; i++)
{
m_ShadowResolutionRequests[i] = new HDShadowResolutionRequest();
}
// The cascade atlas will be allocated only if there is a directional light
m_Atlas = new HDDynamicShadowAtlas(renderPipelineResources, renderGraph, useSharedTexture: false, initParams.punctualLightShadowAtlas.shadowAtlasResolution, initParams.punctualLightShadowAtlas.shadowAtlasResolution,
HDShaderIDs._ShadowmapAtlas, m_ClearShadowMaterial, initParams.maxShadowRequests, initParams, depthBufferBits: initParams.punctualLightShadowAtlas.shadowAtlasDepthBits, name: "Shadow Map Atlas");
// Cascade atlas render texture will only be allocated if there is a shadow casting directional light
HDShadowAtlas.BlurAlgorithm cascadeBlur = GetDirectionalShadowAlgorithm() == DirectionalShadowAlgorithm.IMS ? HDShadowAtlas.BlurAlgorithm.IM : HDShadowAtlas.BlurAlgorithm.None;
m_CascadeAtlas = new HDDynamicShadowAtlas(renderPipelineResources, renderGraph, useSharedTexture: false, 1, 1, HDShaderIDs._ShadowmapCascadeAtlas, m_ClearShadowMaterial, initParams.maxShadowRequests, initParams, cascadeBlur, depthBufferBits: initParams.directionalShadowsDepthBits, name: "Cascade Shadow Map Atlas");
if (ShaderConfig.s_AreaLights == 1)
{
m_AreaLightShadowAtlas = new HDDynamicShadowAtlas(renderPipelineResources, renderGraph, useSharedTexture: false, initParams.areaLightShadowAtlas.shadowAtlasResolution, initParams.areaLightShadowAtlas.shadowAtlasResolution,
HDShaderIDs._ShadowmapAreaAtlas, m_ClearShadowMaterial, initParams.maxShadowRequests, initParams, HDShadowAtlas.BlurAlgorithm.EVSM, depthBufferBits: initParams.areaLightShadowAtlas.shadowAtlasDepthBits, name: "Area Light Shadow Map Atlas");
}
cachedShadowManager.InitPunctualShadowAtlas(renderPipelineResources, renderGraph, useSharedTexture: true, initParams.cachedPunctualLightShadowAtlas, initParams.cachedPunctualLightShadowAtlas,
HDShaderIDs._CachedShadowmapAtlas, m_ClearShadowMaterial, initParams.maxShadowRequests, initParams: initParams, depthBufferBits: initParams.punctualLightShadowAtlas.shadowAtlasDepthBits, name: "Cached Shadow Map Atlas");
if (ShaderConfig.s_AreaLights == 1)
{
cachedShadowManager.InitAreaLightShadowAtlas(renderPipelineResources, renderGraph, useSharedTexture: true, initParams.cachedAreaLightShadowAtlas, initParams.cachedAreaLightShadowAtlas,
HDShaderIDs._CachedAreaLightShadowmapAtlas, m_ClearShadowMaterial, initParams.maxShadowRequests, initParams: initParams, HDShadowAtlas.BlurAlgorithm.EVSM, depthBufferBits: initParams.areaLightShadowAtlas.shadowAtlasDepthBits, name: "Cached Area Light Shadow Map Atlas");
}
}
public void InitShadowManager(RenderPipelineResources renderPipelineResources, HDShadowInitParameters initParams, Shader clearShader)
{
// Even when shadows are disabled (maxShadowRequests == 0) we need to allocate compute buffers to avoid having
// resource not bound errors when dispatching a compute shader.
m_ShadowDataBuffer = new ComputeBuffer(Mathf.Max(initParams.maxShadowRequests, 1), System.Runtime.InteropServices.Marshal.SizeOf(typeof(HDShadowData)));
m_DirectionalShadowDataBuffer = new ComputeBuffer(1, System.Runtime.InteropServices.Marshal.SizeOf(typeof(HDDirectionalShadowData)));
m_MaxShadowRequests = initParams.maxShadowRequests;
m_ShadowRequestCount = 0;
if (initParams.maxShadowRequests == 0)
{
return;
}
m_ClearShadowMaterial = CoreUtils.CreateEngineMaterial(clearShader);
m_BlitShadowMaterial = CoreUtils.CreateEngineMaterial(renderPipelineResources.shaders.shadowBlitPS);
// Prevent the list from resizing their internal container when we add shadow requests
m_ShadowDatas.Capacity = Math.Max(initParams.maxShadowRequests, m_ShadowDatas.Capacity);
m_ShadowResolutionRequests = new HDShadowResolutionRequest[initParams.maxShadowRequests];
m_ShadowRequests = new HDShadowRequest[initParams.maxShadowRequests];
m_CachedDirectionalShadowData = new HDDirectionalShadowData[1]; // we only support directional light shadow
m_GlobalShaderVariables = new ConstantBuffer <ShaderVariablesGlobal>();
for (int i = 0; i < initParams.maxShadowRequests; i++)
{
m_ShadowResolutionRequests[i] = new HDShadowResolutionRequest();
}
HDShadowAtlas.HDShadowAtlasInitParameters punctualAtlasInitParams = new HDShadowAtlas.HDShadowAtlasInitParameters(renderPipelineResources, initParams.punctualLightShadowAtlas.shadowAtlasResolution,
initParams.punctualLightShadowAtlas.shadowAtlasResolution, HDShaderIDs._ShadowmapAtlas, m_ClearShadowMaterial, initParams.maxShadowRequests, initParams, m_GlobalShaderVariables);
punctualAtlasInitParams.name = "Shadow Map Atlas";
// The cascade atlas will be allocated only if there is a directional light
m_Atlas = new HDDynamicShadowAtlas(punctualAtlasInitParams);
// Cascade atlas render texture will only be allocated if there is a shadow casting directional light
HDShadowAtlas.BlurAlgorithm cascadeBlur = GetDirectionalShadowAlgorithm() == DirectionalShadowAlgorithm.IMS ? HDShadowAtlas.BlurAlgorithm.IM : HDShadowAtlas.BlurAlgorithm.None;
HDShadowAtlas.HDShadowAtlasInitParameters dirAtlasInitParams = punctualAtlasInitParams;
dirAtlasInitParams.width = 1;
dirAtlasInitParams.height = 1;
dirAtlasInitParams.atlasShaderID = HDShaderIDs._ShadowmapCascadeAtlas;
dirAtlasInitParams.blurAlgorithm = cascadeBlur;
dirAtlasInitParams.depthBufferBits = initParams.directionalShadowsDepthBits;
dirAtlasInitParams.name = "Cascade Shadow Map Atlas";
m_CascadeAtlas = new HDDynamicShadowAtlas(dirAtlasInitParams);
HDShadowAtlas.HDShadowAtlasInitParameters areaAtlasInitParams = punctualAtlasInitParams;
if (ShaderConfig.s_AreaLights == 1)
{
areaAtlasInitParams.width = initParams.areaLightShadowAtlas.shadowAtlasResolution;
areaAtlasInitParams.height = initParams.areaLightShadowAtlas.shadowAtlasResolution;
areaAtlasInitParams.atlasShaderID = HDShaderIDs._ShadowmapAreaAtlas;
areaAtlasInitParams.blurAlgorithm = HDShadowAtlas.BlurAlgorithm.EVSM;
areaAtlasInitParams.depthBufferBits = initParams.areaLightShadowAtlas.shadowAtlasDepthBits;
areaAtlasInitParams.name = "Area Light Shadow Map Atlas";
m_AreaLightShadowAtlas = new HDDynamicShadowAtlas(areaAtlasInitParams);
}
HDShadowAtlas.HDShadowAtlasInitParameters cachedPunctualAtlasInitParams = punctualAtlasInitParams;
cachedPunctualAtlasInitParams.width = initParams.cachedPunctualLightShadowAtlas;
cachedPunctualAtlasInitParams.height = initParams.cachedPunctualLightShadowAtlas;
cachedPunctualAtlasInitParams.atlasShaderID = HDShaderIDs._CachedShadowmapAtlas;
cachedPunctualAtlasInitParams.name = "Cached Shadow Map Atlas";
cachedShadowManager.InitPunctualShadowAtlas(cachedPunctualAtlasInitParams);
if (ShaderConfig.s_AreaLights == 1)
{
HDShadowAtlas.HDShadowAtlasInitParameters cachedAreaAtlasInitParams = areaAtlasInitParams;
cachedAreaAtlasInitParams.width = initParams.cachedAreaLightShadowAtlas;
cachedAreaAtlasInitParams.height = initParams.cachedAreaLightShadowAtlas;
cachedAreaAtlasInitParams.atlasShaderID = HDShaderIDs._CachedAreaLightShadowmapAtlas;
cachedAreaAtlasInitParams.name = "Cached Area Light Shadow Map Atlas";
cachedShadowManager.InitAreaLightShadowAtlas(cachedAreaAtlasInitParams);
}
}
