void RenderDirectionalShadow(ref ScriptableRenderContext context, ref CullingResults cullingResults, int shadowMapSize, int index, ref VisibleLight visibleLight)
{
if (shadowData.lights[index] == null)
{
return;
}
CoreUtils.SetRenderTarget(buffer, shadowData.shadowMaps, ClearFlag.Depth, 0, CubemapFace.Unknown, index);
SubmitBuffer(ref context, buffer);
for (int j = 0; j < 4; j++)
{
if (shadowData.lights[index].cascades[j] == null)
{
continue;
}
Rect tileViewport = new Rect(shadowData.lights[index].cascades[j].tileOffset.x * shadowData.lights[index].tileSize, shadowData.lights[index].cascades[j].tileOffset.y * shadowData.lights[index].tileSize, shadowData.lights[index].tileSize, shadowData.lights[index].tileSize);
buffer.SetViewport(new Rect(tileViewport));
buffer.EnableScissorRect(new Rect(tileViewport.x + 4f, tileViewport.y + 4f, shadowData.lights[index].tileSize - 8f, shadowData.lights[index].tileSize - 8f));
buffer.SetViewProjectionMatrices(shadowData.lights[index].cascades[j].viewMatrix, shadowData.lights[index].cascades[j].projectionMatrix);
ShaderInput.SetShadowBias(buffer, visibleLight.light.shadowBias);
SubmitBuffer(ref context, buffer);
ShadowDrawingSettings shadowSettings = new ShadowDrawingSettings(cullingResults, index);
shadowSettings.splitData = shadowData.lights[index].cascades[j].splitData;
context.DrawShadows(ref shadowSettings);
}
buffer.DisableScissorRect();
SubmitBuffer(ref context, buffer);
}
public void RenderSpotShadow(int index, int splitCount, int tileSize)
{
OtherShadow otherShadow = otherShadows[index];
ShadowDrawingSettings shadowDrawingSettings = new ShadowDrawingSettings(cullingResults, otherShadow.VisibleLightIndex);
cullingResults.ComputeSpotShadowMatricesAndCullingPrimitives(otherShadow.VisibleLightIndex,
out Matrix4x4 viewMatrix, out Matrix4x4 projectionMatrix, out ShadowSplitData shadowSplitData);
shadowDrawingSettings.splitData = shadowSplitData;
SetShadowMapViewport(index, splitCount, tileSize, out Vector2 offset);
float inversedSplitCount = 1f / splitCount;
// !!
// ??
float texelSize = 2f / (tileSize * projectionMatrix.m00);
float filterSize = texelSize * ((float)shadowSettings.OtherShadowSettings.PCFMode + 1f);
float bias = otherShadow.NoramlBias * filterSize * 1.4142136f;
SetOtherTileData(index, offset, inversedSplitCount, bias);
otherShadowMatrices[index] = ConvertClipSpaceToTileSpace(projectionMatrix * viewMatrix, offset, inversedSplitCount);
commandBuffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
commandBuffer.SetGlobalDepthBias(0f, otherShadow.SlopeScaleBias);
ExecuteBuffer();
renderContext.DrawShadows(ref shadowDrawingSettings);
commandBuffer.SetGlobalDepthBias(0f, 0f);
}
void RenderSpotShadow(ref ScriptableRenderContext context, ref CullingResults cullingResults, int shadowMapSize, int index, ref VisibleLight visibleLight)
{
if (shadowData.lights[index] == null)
{
return;
}
CoreUtils.SetRenderTarget(buffer, shadowData.shadowMaps, ClearFlag.Depth, 0, CubemapFace.Unknown, index);
SubmitBuffer(ref context, buffer);
if (shadowData.lights[index].cascades[0] == null)
{
return;
}
Rect tileViewport = new Rect(0, 0, shadowMapSize, shadowMapSize);
buffer.SetViewport(new Rect(tileViewport));
buffer.SetViewProjectionMatrices(shadowData.lights[index].cascades[0].viewMatrix, shadowData.lights[index].cascades[0].projectionMatrix);
ShaderInput.SetShadowBias(buffer, visibleLight.light.shadowBias);
SubmitBuffer(ref context, buffer);
ShadowDrawingSettings shadowSettings = new ShadowDrawingSettings(cullingResults, index);
shadowSettings.splitData = shadowData.lights[index].cascades[0].splitData;
context.DrawShadows(ref shadowSettings);
}
void RenderSpotShadows(int index, int split, int tileSize)
{
ShadowedOtherLight light = shadowedOtherLights[index];
var shadowSettings =
new ShadowDrawingSettings(cullingResults, light.visibleLightIndex)
{
useRenderingLayerMaskTest = true
};
cullingResults.ComputeSpotShadowMatricesAndCullingPrimitives(
light.visibleLightIndex, out Matrix4x4 viewMatrix,
out Matrix4x4 projectionMatrix, out ShadowSplitData splitData
);
shadowSettings.splitData = splitData;
float texelSize = 2f / (tileSize * projectionMatrix.m00);
float filterSize = texelSize * ((float)settings.other.filter + 1f);
float bias = light.normalBias * filterSize * 1.4142136f;
Vector2 offset = SetTileViewport(index, split, tileSize);
float tileScale = 1f / split;
SetOtherTileData(index, offset, tileScale, bias);
otherShadowMatrices[index] = ConvertToAtlasMatrix(
projectionMatrix * viewMatrix, offset, tileScale
);
buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
buffer.SetGlobalDepthBias(0f, light.slopeScaleBias);
ExecuteBuffer();
context.DrawShadows(ref shadowSettings);
buffer.SetGlobalDepthBias(0f, 0f);
}
private void RenderDirectionalShadow(CullingResults cull, int sunlightIndex, Light sunlight) {
ResetRenderTarget(SunlightShadowmapId, true, false, 1, Color.black);
var shadowSettings = new ShadowDrawingSettings(cull, sunlightIndex);
if (!cull.ComputeDirectionalShadowMatricesAndCullingPrimitives(sunlightIndex, 0, 1, new Vector3(1, 0, 0), @params.sunlightParams.shadowResolution, sunlight.shadowNearPlane, out var viewMatrix, out var projectionMatrix, out var splitData)) {
ExecuteCurrentBuffer();
return;
}
shadowSettings.splitData = splitData;
_currentBuffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
if (_reversedZBuffer) {
projectionMatrix.m20 = -projectionMatrix.m20;
projectionMatrix.m21 = -projectionMatrix.m21;
projectionMatrix.m22 = -projectionMatrix.m22;
projectionMatrix.m23 = -projectionMatrix.m23;
}
var scaleOffset = Matrix4x4.identity;
scaleOffset.m00 = scaleOffset.m11 = scaleOffset.m22 = scaleOffset.m03 = scaleOffset.m13 = scaleOffset.m23 = 0.5f;
var sunlightInverseVP = scaleOffset * (projectionMatrix * viewMatrix);
_currentBuffer.SetGlobalMatrix(ShaderManager.SUNLIGHT_INVERSE_VP, sunlightInverseVP);
ExecuteCurrentBuffer();
_context.DrawShadows(ref shadowSettings);
}
void RenderDirectionalShadows(int index, int split, int tileSize)
{
ShadowDirectionalLight light = shadowDirectionalLights[index];
var shadowSettings = new ShadowDrawingSettings(shadowParams.cullingResults, light.visibleLightIndex);
int cascadeCount = shadowParams.settings.directional.cascadeCount;
int tileOffset = index * cascadeCount;
Vector3 ratios = shadowParams.settings.directional.CasadeRatios;
for (int i = 0; i < cascadeCount; ++i)
{
shadowParams.cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(light.visibleLightIndex, i, cascadeCount, ratios, tileSize, 0f,
out Matrix4x4 viewMatrix, out Matrix4x4 projectionMatrix, out ShadowSplitData splitData);
shadowSettings.splitData = splitData;
if (index == 0)
{
//cullingSphere是以摄像机位置为球心的
Vector4 cullingSphere = splitData.cullingSphere;
cullingSphere.w *= cullingSphere.w;
cascadeCullingSpheres[i] = cullingSphere;
}
int tileIndex = tileOffset + i;
dirShadowMatrices[tileIndex] = ConvertToAtlasMatrix(projectionMatrix * viewMatrix, SetTileViewPort(tileIndex, split, tileSize), split);
//绘制指定区域的
buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
buffer.SetGlobalDepthBias(50000f, 0f);
ExecuteBuffer();
GlobalUniqueParamsForRP.context.DrawShadows(ref shadowSettings);
buffer.SetGlobalDepthBias(0f, 0f);
}
}
private void RenderPointShadows(int index, int split, int tileSize)
{
ShadowedOtherLight light = shadowedOtherLights[index];
ShadowDrawingSettings shadowSettings = new ShadowDrawingSettings(cullingResults, light.visibleLightIndex);
float texelSize = 2f / tileSize;
float filterSize = texelSize * ((float)this.shadowSettings.other.filter + 1f);
float bias = light.normalBias * filterSize * 1.4142136f;
float tileScale = 1f / split;
float fovBias = Mathf.Atan(1f + bias + filterSize) * Mathf.Rad2Deg * 2f - 90f;
for (int i = 0; i < 6; ++i)
{
cullingResults.ComputePointShadowMatricesAndCullingPrimitives(
light.visibleLightIndex, (CubemapFace)i, fovBias, out Matrix4x4 viewMatrix,
out Matrix4x4 projectionMatrix, out ShadowSplitData splitData);
viewMatrix.m11 = -viewMatrix.m11;
viewMatrix.m12 = -viewMatrix.m12;
viewMatrix.m13 = -viewMatrix.m13;
shadowSettings.splitData = splitData;
int tileIndex = index + i;
//float texelSize = 2f / (tileSize * projectionMatrix.m00);
//float filterSize = texelSize * ((float)this.shadowSettings.other.filter + 1f);
//float bias = light.normalBias * filterSize * 1.4142136f;
Vector2 offset = SetTileViewport(tileIndex, split, tileSize);
//float tileScale = 1f / split;
SetOtherTileData(tileIndex, offset, tileScale, bias);
otherShadowMatrices[tileIndex] = ConvertToAtlasMatrix(projectionMatrix * viewMatrix, offset, tileScale);
buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
buffer.SetGlobalDepthBias(0f, light.slopeScaleBias);
ExecuteBuffer();
context.DrawShadows(ref shadowSettings);
buffer.SetGlobalDepthBias(0f, 0f);
}
}
void RenderDirectionalShadows(int index, int split, int tileSize)
{
var light = ShadowedDirectionalLights[index];
var shadowSettings = new ShadowDrawingSettings(cullingResults, index);
cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(
light.VisibleLightIndex,
0,
1,
Vector3.zero,
tileSize,
0f,
out Matrix4x4 viewMatrix,
out Matrix4x4 projMatrix,
out ShadowSplitData shadowSplitData);
shadowSettings.splitData = shadowSplitData;
// SetTileViewport(index, split, tileSize);
DirShadowMatrices[index] = ConvertToAtlasMatrix(
projMatrix * viewMatrix,
SetTileViewport(index, split, tileSize),
split);
buffer.SetGlobalMatrixArray(DirShadowMatricesID, DirShadowMatrices);
buffer.SetViewProjectionMatrices(viewMatrix, projMatrix);
ExecuteBuffer();
context.DrawShadows(ref shadowSettings);
}
void RenderDirectionalShadows(int index, int split, int tileSize)
{
ShadowedDirectionalLight light = shadowedDirectionalLights[index];
var shadowSettings = new ShadowDrawingSettings(cullingResults, light.visibleLightIndex);
var cascadeCount = settings.directional.cascadeCount;
int tileOffset = index * cascadeCount;
Vector3 ratios = settings.directional.CascadeRatios;
float cullingFactor = Mathf.Max(0, 0.8f - settings.directional.cascadeFade);
for (int i = 0; i < cascadeCount; i++)
{
cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(light.visibleLightIndex, i, cascadeCount,
ratios, tileSize, light.nearPlaneOffset,
out Matrix4x4 viewMatrix, out Matrix4x4 projectionMatrix,
out ShadowSplitData splitData);
splitData.shadowCascadeBlendCullingFactor = cullingFactor;
shadowSettings.splitData = splitData;
if (index == 0)
{
SetCascadeData(i, splitData.cullingSphere, tileSize);
}
int tileOffIndex = tileOffset + i;
dirShadowMatrices[tileOffIndex] = ConvertToAtlasMatrix(projectionMatrix * viewMatrix, SetTileViewport(tileOffIndex, split, tileSize), split);
buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
buffer.SetGlobalDepthBias(0f, light.slopeScaleBias);
ExecuteBuffer();
context.DrawShadows(ref shadowSettings);
buffer.SetGlobalDepthBias(0f, 0f);
}
}
public void Render(ref RenderingData context)
{
cmd.BeginSample("Shadow");
cmd.Clear();
ShadowDrawingSettings drawSetting = new ShadowDrawingSettings(context.cullResult, 0);
Matrix4x4 view;
Matrix4x4 proj;
ShadowSplitData splitData;
context.cullResult.ComputeDirectionalShadowMatricesAndCullingPrimitives(0, 0, 1, Vector3.zero, (int)context.asset.ShadowSetting.directional.altasSize, 0f, out view, out proj, out splitData);
drawSetting.splitData = splitData;
cmd.SetViewProjectionMatrices(view, proj);
int texSize = (int)context.asset.ShadowSetting.directional.altasSize;
var ren = new RenderTargetIdentifier(BuiltinRenderTextureType.CameraTarget);
cmd.GetTemporaryRT(dirShadowAtlasId, texSize, texSize, 24, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
cmd.SetRenderTarget(dirShadowAtlasId, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
cmd.ClearRenderTarget(true, false, Color.clear);
context.context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.context.DrawShadows(ref drawSetting);
// cmd.SetRenderTarget(ren);
// context.context.ExecuteCommandBuffer(cmd);
cmd.EndSample("Shadow");
}
void RenderShadows(ScriptableRenderContext context)
{
shadowBuffer.GetTemporaryRT(shadowMapId, 512, 512, 16, FilterMode.Bilinear, RenderTextureFormat.Depth);
shadowMap = RenderTexture.GetTemporary(512, 512, 16, RenderTextureFormat.Shadowmap);
shadowMap.filterMode = FilterMode.Bilinear;
shadowMap.wrapMode = TextureWrapMode.Clamp;
CoreUtils.SetRenderTarget(shadowBuffer, shadowMap, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Depth);
shadowBuffer.BeginSample("Render Shadows");
context.ExecuteCommandBuffer(shadowBuffer);
shadowBuffer.Clear();
Matrix4x4 viewMatrix, projectMatrix;
ShadowSplitData splitData;
cullingResults.ComputeSpotShadowMatricesAndCullingPrimitives(0, out viewMatrix, out projectMatrix, out splitData);
shadowBuffer.SetViewProjectionMatrices(viewMatrix, projectMatrix);
context.ExecuteCommandBuffer(shadowBuffer);
// draw shadow
var shadowSettings = new ShadowDrawingSettings(cullingResults, 0);
context.DrawShadows(ref shadowSettings);
shadowBuffer.EndSample("Render Shadows");
context.ExecuteCommandBuffer(shadowBuffer);
shadowBuffer.Clear();
}
private void RenderCascadedShadows(ScriptableRenderContext context)
{
float tileSize = ShadowMapSize / 2;
cascadedShadowMap = SetShadowRenderTarget();
shadowBuffer.BeginSample(shadowBufferName);
context.ExecuteCommandBuffer(shadowBuffer);
shadowBuffer.Clear();
Light shadowLight = cullingResults.visibleLights[0].light;
shadowBuffer.SetGlobalFloat(shadowBiasId, shadowLight.shadowBias);
var shadowSettings = new ShadowDrawingSettings(cullingResults, 0);
var tileMatrix = Matrix4x4.identity;
tileMatrix.m00 = tileMatrix.m11 = 0.5f;
for (int i = 0; i < ShadowCascades; i++)
{
Matrix4x4 viewMatrix, projectionMatrix;
ShadowSplitData splitData;
cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(
0, i, ShadowCascades, ShadowCascadeSplit, (int)tileSize,
shadowLight.shadowNearPlane,
out viewMatrix, out projectionMatrix, out splitData
);
Vector2 tileOffset = ConfigureShadowTile(i, 2, tileSize);
shadowBuffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
context.ExecuteCommandBuffer(shadowBuffer);
shadowBuffer.Clear();
shadowSettings.splitData = splitData;
cascadeCullingSpheres[i] = splitData.cullingSphere; // xyz分量描述球的位置，w分量定义球的半径。
cascadeCullingSpheres[i].w *= splitData.cullingSphere.w;
Vector3 pos = new Vector3(splitData.cullingSphere.x, splitData.cullingSphere.y, splitData.cullingSphere.z);
context.DrawShadows(ref shadowSettings);
CalculateWorldToShadowMatrix(ref viewMatrix, ref projectionMatrix, out worldToShadowCascadeMatrices[i]);
tileMatrix.m03 = tileOffset.x * 0.5f;
tileMatrix.m13 = tileOffset.y * 0.5f;
worldToShadowCascadeMatrices[i] = tileMatrix * worldToShadowCascadeMatrices[i];
}
shadowBuffer.DisableScissorRect();
shadowBuffer.SetGlobalTexture(cascadedShadowMapId, cascadedShadowMap);
shadowBuffer.SetGlobalVectorArray(cascadeCullingSpheresId, cascadeCullingSpheres);
shadowBuffer.SetGlobalMatrixArray(worldToShadowCascadeMatricesId, worldToShadowCascadeMatrices);
float invShadowMapSize = 1f / ShadowMapSize;
shadowBuffer.SetGlobalVector(cascadedShadowMapSizeId, new Vector4(invShadowMapSize, invShadowMapSize, ShadowMapSize, ShadowMapSize));
shadowBuffer.SetGlobalFloat(cascadedShadoStrengthId, shadowLight.shadowStrength);
bool hard = shadowLight.shadows == LightShadows.Hard;
CoreUtils.SetKeyword(shadowBuffer, cascadedShadowsHardKeyword, hard);
CoreUtils.SetKeyword(shadowBuffer, cascadedShadowsSoftKeyword, !hard);
shadowBuffer.EndSample(shadowBufferName);
context.ExecuteCommandBuffer(shadowBuffer);
shadowBuffer.Clear();
}
void RenderDirectionalShadows(int index, int split, int tileSize)
{
ShadowedDirectionalLight light = ShadowedDirectionalLights[index];
var shadowSettings =
new ShadowDrawingSettings(cullingResults, light.visibleLightIndex);
int cascadeCount = settings.directional.cascadeCount;
int tileOffset = index * cascadeCount;
for (int i = 0; i < cascadeCount; i++)
{
cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(
light.visibleLightIndex, i, cascadeCount, cascadeRatio,
tileSize, 0f, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix, out ShadowSplitData shadowSplitData
);
shadowSettings.splitData = shadowSplitData;
int tileIndex = tileOffset + i;
dirShadowMatrices[tileIndex] = ConvertToAtlasMatrix(
projMatrix * viewMatrix,
SetTileViewport(tileIndex, split, tileSize), split
);
buffer.SetViewProjectionMatrices(viewMatrix, projMatrix);
ExecuteBuffer();
context.DrawShadows(ref shadowSettings);
}
}
void RenderOneSpotShadows(int shadowedLightIdx, int atlasSplitFactor, int atlasTileSize)
{
ShadowedLight shadowedLight = _shadowedSpotLights[shadowedLightIdx];
_cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowedLight.visibleIndex, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix, out ShadowSplitData shadowSplitData);
_cmdBuffer.SetViewProjectionMatrices(viewMatrix, projMatrix);
Rect tileViewPort = Rect.zero;
int tileIdx = shadowedLightIdx;
tileViewPort.x = tileIdx % atlasSplitFactor * atlasTileSize;
tileViewPort.y = tileIdx / atlasSplitFactor * atlasTileSize;
tileViewPort.width = tileViewPort.height = atlasTileSize;
_cmdBuffer.SetViewport(tileViewPort);
_cmdBuffer.SetGlobalDepthBias(0, shadowedLight.light.shadowBias);
ExecuteCommandBuffer();
int atlasSize = atlasSplitFactor * atlasTileSize;
Vector4 normalizeViewPort = Vector4.zero;
float texelSize = 1f / atlasSize;
normalizeViewPort.x = tileViewPort.x / atlasSize + texelSize;
normalizeViewPort.y = tileViewPort.y / atlasSize + texelSize;
normalizeViewPort.z = tileViewPort.width / atlasSize - texelSize;
normalizeViewPort.w = tileViewPort.height / atlasSize - texelSize;
_spotShadowMatrixs[tileIdx] = ShadowMatrixToAtlasTileMatrix(projMatrix * viewMatrix, tileViewPort, atlasSize);
_spotShadowTileViewPorts[tileIdx] = normalizeViewPort;
ShadowDrawingSettings shadowDrawSetting = new ShadowDrawingSettings(_cullResults, shadowedLight.visibleIndex);
shadowDrawSetting.splitData = shadowSplitData;
_srContext.DrawShadows(ref shadowDrawSetting);
_cmdBuffer.SetGlobalDepthBias(0, 0);
}
void RenderDirectionalShadows(int index, int split, int tileSize)
{
ShadowedDirectionalLight light = ShadowedDirectionalLights[index];
//create a shadowdrawsetting based on the light index
var shadowDSettings = new ShadowDrawingSettings(cullingResults, light.visibleLightIndex)
{
useRenderingLayerMaskTest = true
}; //make shadow effcted by rendering layer mask
//take into count that each light will render max 4 cascades
int cascadeCount = shadowSettings.directional.cascadeCount;
int tileOffset = index * cascadeCount;
Vector3 ratios = shadowSettings.directional.CascadeRatios;
//cal the cascade culling factor, make it 0.8-fade to make sure casters in transition not being culled
float cullingfactor = Mathf.Max(0f, 0.8f - shadowSettings.directional.cascadeFade);
float tileScale = 1f / split;
//get the lightviewMatrix, lightprojectionMatrix, clip space box for the dirctional lights
for (int i = 0; i < cascadeCount; i++)
{
cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(
light.visibleLightIndex, i, cascadeCount, ratios, tileSize, light.nearPlaneOffset,
out Matrix4x4 viewMatrix, out Matrix4x4 projectionMatrix,
out ShadowSplitData splitData);
//make UNITY to cull some shadow caster in large cascade if the smaller cascade is enough
splitData.shadowCascadeBlendCullingFactor = cullingfactor;
shadowDSettings.splitData = splitData;
//assign the cascade culling sphere, all lights uses the same culling spheres and same cascade datas
if (index == 0)
{
SetCascadeData(i, splitData.cullingSphere, tileSize);
}
int tileIdex = tileOffset + i;
//set the render view port and get the offset for modify the dir shadow matrix
//set the matrix from wolrd space to shadow Atlas space
dirShadowMatrices[tileIdex] = ConvertToAtlasMatrix(
projectionMatrix * viewMatrix,
SetTileViewport(tileIdex, split, tileSize),
tileScale
);
//set the ViewProjectionMatrices for the buffer
buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
//experimental depth bias
//buffer.SetGlobalDepthBias(50000f, 0f);
//using slop bias
buffer.SetGlobalDepthBias(0f, light.slopScaleBias);
ExecuteBuffer();
//draw shadow caster on the buffer
context.DrawShadows(ref shadowDSettings);
//Debug.Log(shadowDSettings
buffer.SetGlobalDepthBias(0f, 0f);
}
}
void RenderAdditionalShadowmapAtlas(ref ScriptableRenderContext context, ref CullingResults cullResults, ref LightData lightData, ref ShadowData shadowData)
{
NativeArray <VisibleLight> visibleLights = lightData.visibleLights;
bool additionalLightHasSoftShadows = false;
CommandBuffer cmd = CommandBufferPool.Get(k_RenderAdditionalLightShadows);
using (new ProfilingSample(cmd, k_RenderAdditionalLightShadows))
{
int shadowmapWidth = shadowData.additionalLightsShadowmapWidth;
int shadowmapHeight = shadowData.additionalLightsShadowmapHeight;
m_AdditionalLightsShadowmapTexture = RenderTexture.GetTemporary(shadowmapWidth, shadowmapHeight,
k_ShadowmapBufferBits, m_AdditionalShadowmapFormat);
m_AdditionalLightsShadowmapTexture.filterMode = FilterMode.Bilinear;
m_AdditionalLightsShadowmapTexture.wrapMode = TextureWrapMode.Clamp;
SetRenderTarget(cmd, m_AdditionalLightsShadowmapTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Depth, Color.black, TextureDimension.Tex2D);
for (int i = 0; i < m_AdditionalShadowCastingLightIndices.Count; ++i)
{
int shadowLightIndex = m_AdditionalShadowCastingLightIndices[i];
VisibleLight shadowLight = visibleLights[shadowLightIndex];
if (m_AdditionalShadowCastingLightIndices.Count > 1)
{
ShadowUtils.ApplySliceTransform(ref m_AdditionalLightSlices[i], shadowmapWidth, shadowmapHeight);
}
var settings = new ShadowDrawingSettings(cullResults, shadowLightIndex);
Vector4 shadowBias = ShadowUtils.GetShadowBias(ref shadowLight, shadowLightIndex,
ref shadowData, m_AdditionalLightSlices[i].projectionMatrix, m_AdditionalLightSlices[i].resolution);
ShadowUtils.SetupShadowCasterConstantBuffer(cmd, ref shadowLight, shadowBias);
ShadowUtils.RenderShadowSlice(cmd, ref context, ref m_AdditionalLightSlices[i], ref settings, m_AdditionalLightSlices[i].projectionMatrix, m_AdditionalLightSlices[i].viewMatrix);
additionalLightHasSoftShadows |= shadowLight.light.shadows == LightShadows.Soft;
}
SetupAdditionalLightsShadowReceiverConstants(cmd, ref shadowData);
}
// We share soft shadow settings for main light and additional lights to save keywords.
// So we check here if pipeline supports soft shadows and either main light or any additional light has soft shadows
// to enable the keyword.
// TODO: In PC and Consoles we can upload shadow data per light and branch on shader. That will be more likely way faster.
bool mainLightHasSoftShadows = shadowData.supportsMainLightShadows &&
lightData.mainLightIndex != -1 &&
visibleLights[lightData.mainLightIndex].light.shadows == LightShadows.Soft;
bool softShadows = shadowData.supportsSoftShadows && (mainLightHasSoftShadows || additionalLightHasSoftShadows);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.AdditionalLightShadows, true);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.SoftShadows, softShadows);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
private void RenderCascadedDirectionalShadow(CullingResults cull, int sunlightIndex, Light sunlight, float shadowDistance) {
_currentBuffer.GetTemporaryRTArray(ShaderManager.SUNLIGHT_SHADOWMAP_ARRAY, @params.sunlightParams.shadowResolution, @params.sunlightParams.shadowResolution, @params.sunlightParams.shadowCascades, 16, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
var shadowCascades = @params.sunlightParams.shadowCascades;
var shadowSettings = new ShadowDrawingSettings(cull, sunlightIndex);
var sunlightInverseVPArray = new Matrix4x4[shadowCascades];
var sunlightShadowSplitBoundArray = new Vector4[shadowCascades];
var scaleOffset = Matrix4x4.identity;
scaleOffset.m00 = scaleOffset.m11 = scaleOffset.m22 =scaleOffset.m03 = scaleOffset.m13 = scaleOffset.m23 = 0.5f;
_currentBuffer.SetGlobalFloat(ShaderManager.SHADOW_BIAS, sunlight.shadowBias);
_currentBuffer.SetGlobalFloat(ShaderManager.SHADOW_NORMAL_BIAS, sunlight.shadowNormalBias);
for (var i = 0; i < shadowCascades; i++) {
ResetRenderTarget(SunlightShadowmapArrayId, CubemapFace.Unknown, i, true, false, 1, Color.black);
if (!cull.ComputeDirectionalShadowMatricesAndCullingPrimitives(sunlightIndex, i, shadowCascades, @params.sunlightParams.shadowCascadeSplits, @params.sunlightParams.shadowResolution, sunlight.shadowNearPlane, out var viewMatrix, out var projectionMatrix, out var splitData)) {
ExecuteCurrentBuffer();
continue;
}
shadowSettings.splitData = splitData;
_currentBuffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
if (_reversedZBuffer) {
projectionMatrix.m20 = -projectionMatrix.m20;
projectionMatrix.m21 = -projectionMatrix.m21;
projectionMatrix.m22 = -projectionMatrix.m22;
projectionMatrix.m23 = -projectionMatrix.m23;
}
sunlightInverseVPArray[i] = scaleOffset * (projectionMatrix * viewMatrix);
sunlightShadowSplitBoundArray[i] = splitData.cullingSphere;
sunlightShadowSplitBoundArray[i].w *= splitData.cullingSphere.w;
ExecuteCurrentBuffer();
_context.DrawShadows(ref shadowSettings);
}
var inverseShadowmapSize = 1f / @params.sunlightParams.shadowResolution;
_currentBuffer.SetGlobalFloat(ShaderManager.SUNLIGHT_SHADOW_STRENGTH, sunlight.shadowStrength);
_currentBuffer.SetGlobalFloat(ShaderManager.SUNLIGHT_SHADOW_DISTANCE, shadowDistance);
_currentBuffer.SetGlobalVector(ShaderManager.SUNLIGHT_SHADOWMAP_SIZE, new Vector4(inverseShadowmapSize, inverseShadowmapSize, @params.sunlightParams.shadowResolution, @params.sunlightParams.shadowResolution));
_currentBuffer.SetGlobalMatrixArray(ShaderManager.SUNLIGHT_INVERSE_VP_ARRAY, sunlightInverseVPArray);
_currentBuffer.SetGlobalVectorArray(ShaderManager.SUNLIGHT_SHADOW_SPLIT_BOUND_ARRAY, sunlightShadowSplitBoundArray);
if (sunlight.shadows == LightShadows.Soft) _currentBuffer.EnableShaderKeyword(ShaderManager.SUNLIGHT_SOFT_SHADOWS);
else _currentBuffer.DisableShaderKeyword(ShaderManager.SUNLIGHT_SOFT_SHADOWS);
ExecuteCurrentBuffer();
}
static void RenderShadows(RenderShadowsParameters parameters,
RTHandle atlasRenderTexture,
ShadowDrawingSettings shadowDrawSettings,
ScriptableRenderContext renderContext,
CommandBuffer cmd)
{
cmd.SetRenderTarget(atlasRenderTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
cmd.SetGlobalVector(parameters.atlasSizeShaderID, new Vector4(atlasRenderTexture.rt.width, atlasRenderTexture.rt.height, 1.0f / atlasRenderTexture.rt.width, 1.0f / atlasRenderTexture.rt.height));
// Clear the whole atlas to avoid garbage outside of current request when viewing it.
if (parameters.debugClearAtlas)
{
CoreUtils.DrawFullScreen(cmd, parameters.clearMaterial, null, 0);
}
var hdrp = RenderPipelineManager.currentPipeline as HDRenderPipeline;
foreach (var shadowRequest in parameters.shadowRequests)
{
if (shadowRequest.shouldUseCachedShadow)
{
continue;
}
cmd.SetGlobalDepthBias(1.0f, shadowRequest.slopeBias);
cmd.SetViewport(shadowRequest.atlasViewport);
cmd.SetGlobalFloat(HDShaderIDs._ZClip, shadowRequest.zClip ? 1.0f : 0.0f);
CoreUtils.DrawFullScreen(cmd, parameters.clearMaterial, null, 0);
shadowDrawSettings.lightIndex = shadowRequest.lightIndex;
shadowDrawSettings.splitData = shadowRequest.splitData;
// Setup matrices for shadow rendering:
Matrix4x4 viewProjection = shadowRequest.deviceProjectionYFlip * shadowRequest.view;
cmd.SetGlobalMatrix(HDShaderIDs._ViewMatrix, shadowRequest.view);
cmd.SetGlobalMatrix(HDShaderIDs._InvViewMatrix, shadowRequest.view.inverse);
cmd.SetGlobalMatrix(HDShaderIDs._ProjMatrix, shadowRequest.deviceProjectionYFlip);
cmd.SetGlobalMatrix(HDShaderIDs._InvProjMatrix, shadowRequest.deviceProjectionYFlip.inverse);
cmd.SetGlobalMatrix(HDShaderIDs._ViewProjMatrix, viewProjection);
cmd.SetGlobalMatrix(HDShaderIDs._InvViewProjMatrix, viewProjection.inverse);
cmd.SetGlobalVectorArray(HDShaderIDs._ShadowClipPlanes, shadowRequest.frustumPlanes);
// TODO: remove this execute when DrawShadows will use a CommandBuffer
renderContext.ExecuteCommandBuffer(cmd);
cmd.Clear();
renderContext.DrawShadows(ref shadowDrawSettings);
hdrp?.InvokeShadowMapRender(cmd, shadowRequest.worldTexelSize);
}
cmd.SetGlobalFloat(HDShaderIDs._ZClip, 1.0f); // Re-enable zclip globally
cmd.SetGlobalDepthBias(0.0f, 0.0f); // Reset depth bias.
}
private void RenderPointLightShadow(CullingResults cull, int shadowLightCount, Light[] shadowLights, int[] shadowLightIndices) {
var pointLightShadowmapDescriptor = new RenderTextureDescriptor(@params.pointLightParams.shadowResolution, @params.pointLightParams.shadowResolution, RenderTextureFormat.RHalf, 16) {
autoGenerateMips = false,
bindMS = false,
dimension = TextureDimension.CubeArray,
volumeDepth = shadowLightCount * 6,
enableRandomWrite = false,
msaaSamples = 1,
shadowSamplingMode = ShadowSamplingMode.None,
sRGB = false,
useMipMap = false,
vrUsage = VRTextureUsage.None
};
_currentBuffer.GetTemporaryRT(ShaderManager.POINT_LIGHT_SHADOWMAP_ARRAY, pointLightShadowmapDescriptor, FilterMode.Bilinear);
for (var i = 0; i < shadowLightCount; i++) {
if (!cull.GetShadowCasterBounds(shadowLightIndices[i], out var shadowBounds)) continue;
var light = shadowLights[i];
_currentBuffer.SetGlobalFloat(ShaderManager.SHADOW_BIAS, light.shadowBias);
_currentBuffer.SetGlobalFloat(ShaderManager.SHADOW_NORMAL_BIAS, light.shadowNormalBias);
var shadowSettings = new ShadowDrawingSettings(cull, shadowLightIndices[i]);
for (var j = 0; j < 6; j++) {
var shadowSlice = i * 6 + j;
ResetRenderTarget(PointLightShadowmapArrayId, CubemapFace.Unknown, shadowSlice, true, true, 1, Color.white);
if (!cull.ComputePointShadowMatricesAndCullingPrimitives(shadowLightIndices[i], (CubemapFace) j, 0, out var viewMatrix, out var projectionMatrix, out var splitData)) {
ExecuteCurrentBuffer();
continue;
}
shadowSettings.splitData = splitData;
Vector3 position = light.transform.position;
_currentBuffer.SetGlobalVector(ShaderManager.LIGHT_POS, new Vector4(position.x, position.y, position.z, light.range));
_currentBuffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
ExecuteCurrentBuffer();
_context.DrawShadows(ref shadowSettings);
}
}
var inverseShadowmapSize = 1f / @params.pointLightParams.shadowResolution;
_currentBuffer.SetGlobalVector(ShaderManager.POINT_LIGHT_SHADOWMAP_SIZE, new Vector4(inverseShadowmapSize, inverseShadowmapSize, @params.pointLightParams.shadowResolution, @params.pointLightParams.shadowResolution));
if (@params.pointLightParams.softShadow) _currentBuffer.EnableShaderKeyword(ShaderManager.POINT_LIGHT_SOFT_SHADOWS);
else _currentBuffer.DisableShaderKeyword(ShaderManager.POINT_LIGHT_SOFT_SHADOWS);
ExecuteCurrentBuffer();
}
private void RenderDirectionalShadows(int index, int tileSize)
{
ShadowDirectionalLight light = _shadowDirectionalLights[index];
var shadowDrawSettings = new ShadowDrawingSettings(_cullingResults, light.visibleLightIndex);
_cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(light.visibleLightIndex, 0, 1,
Vector3.zero, tileSize, 0f, out Matrix4x4 viewMatrix, out Matrix4x4 projectionMatrix,
out ShadowSplitData splitData);
shadowDrawSettings.splitData = splitData;
_buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
ExecuteBuffer();
_context.DrawShadows(ref shadowDrawSettings);
}
public static void RenderShadowSlice(CommandBuffer cmd, ref ScriptableRenderContext context,
ref ShadowSliceData shadowSliceData, ref ShadowDrawingSettings settings,
Matrix4x4 proj, Matrix4x4 view)
{
cmd.SetViewport(new Rect(shadowSliceData.offsetX, shadowSliceData.offsetY, shadowSliceData.resolution, shadowSliceData.resolution));
cmd.SetViewProjectionMatrices(view, proj);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.DrawShadows(ref settings);
cmd.DisableScissorRect();
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
public void SetupShadowSetting(ref RenderFrameContext context)
{
RenderShadow = false;
for (int i = 0; i < context.CullingResult.visibleLights.Length; i++)
{
var visibleLight = context.CullingResult.visibleLights[i];
if (visibleLight.lightType == LightType.Directional && visibleLight.light.shadows != LightShadows.None)
{
m_SadowSetting = new ShadowDrawingSettings(context.CullingResult, i);
RenderShadow = true;
}
}
}
void RenderPointShadows(int index, int split, int tileSize)
{
ShadowedOtherLight light = shadowedOtherLights[index];
//6 face FOV is fixed to 90 degree
float texelSize = 2f / (tileSize);
float filterSize = texelSize * ((float)shadowSettings.other.filter + 1f);
float bias = light.normalBias * filterSize * 1.414f;
float tileScale = 1f / split;
//create a shadowdrawsetting based on the light index
var shadowDSettings = new ShadowDrawingSettings(cullingResults, light.visibleLightIndex)
{
useRenderingLayerMaskTest = true
}; //make shadow effcted by rendering layer mask
//FOV bias to extend fov for a bit to get rid of seams
float fovBias = Mathf.Atan(1f + bias + filterSize) * Mathf.Rad2Deg * 2f - 90f;
for (int i = 0; i < 6; i++)
{
//get matrcies
cullingResults.ComputePointShadowMatricesAndCullingPrimitives(
light.visibleLightIndex, (CubemapFace)i, fovBias, out Matrix4x4 viewMatrix,
out Matrix4x4 projectionMatrix, out ShadowSplitData splitData);
//negate the unity reverse unity render shadow unside down(Stop light leak)
viewMatrix.m11 = -viewMatrix.m11;
viewMatrix.m12 = -viewMatrix.m12;
viewMatrix.m13 = -viewMatrix.m13;
shadowDSettings.splitData = splitData;
int tileIndex = index + i;
//m00 for projectiona matrix is the projection scale?
Vector2 offset = SetTileViewport(tileIndex, split, tileSize);
SetOtherTileData(tileIndex, offset, tileScale, bias);
otherShadowMatrices[tileIndex] = ConvertToAtlasMatrix(
projectionMatrix * viewMatrix,
offset, tileScale
);
buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
buffer.SetGlobalDepthBias(0f, light.slopeScaleBias);
ExecuteBuffer();
context.DrawShadows(ref shadowDSettings);
buffer.SetGlobalDepthBias(0f, 0f);
}
}
private void RenderSpotLightShadow(CullingResults cull, int shadowLightCount, Light[] shadowLights, int[] shadowLightIndices) {
_currentBuffer.GetTemporaryRTArray(ShaderManager.SPOT_LIGHT_SHADOWMAP_ARRAY, @params.spotLightParams.shadowResolution, @params.spotLightParams.shadowResolution, shadowLightCount, 16, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
var shadowLightInverseVPArray = new Matrix4x4[shadowLightCount];
var scaleOffset = Matrix4x4.identity;
scaleOffset.m00 = scaleOffset.m11 = scaleOffset.m22 = scaleOffset.m03 = scaleOffset.m13 = scaleOffset.m23 = 0.5f;
for (var i = 0; i < shadowLightCount; i++) {
var light = shadowLights[i];
_currentBuffer.SetGlobalFloat(ShaderManager.SHADOW_BIAS, light.shadowBias);
_currentBuffer.SetGlobalFloat(ShaderManager.SHADOW_NORMAL_BIAS, light.shadowNormalBias);
var shadowSettings = new ShadowDrawingSettings(cull, shadowLightIndices[i]);
ResetRenderTarget(SpotLightShadowmapArrayId, CubemapFace.Unknown, i, true, false, 1, Color.black);
if (!cull.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndices[i], out var viewMatrix, out var projectionMatrix, out var splitData)) {
ExecuteCurrentBuffer();
continue;
}
shadowSettings.splitData = splitData;
_currentBuffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
if (_reversedZBuffer) {
projectionMatrix.m20 = -projectionMatrix.m20;
projectionMatrix.m21 = -projectionMatrix.m21;
projectionMatrix.m22 = -projectionMatrix.m22;
projectionMatrix.m23 = -projectionMatrix.m23;
}
shadowLightInverseVPArray[i] = scaleOffset * (projectionMatrix * viewMatrix);
ExecuteCurrentBuffer();
_context.DrawShadows(ref shadowSettings);
}
Extensions.Resize(ref _spotLightInverseVPBuffer, shadowLightCount);
_spotLightInverseVPBuffer.SetData(shadowLightInverseVPArray);
var inverseShadowmapSize = 1f / @params.spotLightParams.shadowResolution;
_currentBuffer.SetGlobalBuffer(ShaderManager.SPOT_LIGHT_INVERSE_VP_BUFFER, _spotLightInverseVPBuffer);
_currentBuffer.SetGlobalVector(ShaderManager.SPOT_LIGHT_SHADOWMAP_SIZE, new Vector4(inverseShadowmapSize, inverseShadowmapSize, @params.spotLightParams.shadowResolution, @params.spotLightParams.shadowResolution));
if (@params.spotLightParams.softShadow) _currentBuffer.EnableShaderKeyword(ShaderManager.SPOT_LIGHT_SOFT_SHADOWS);
else _currentBuffer.DisableShaderKeyword(ShaderManager.SPOT_LIGHT_SOFT_SHADOWS);
ExecuteCurrentBuffer();
}
void RenderDirectionalShadows(int index, int split, int tileSize)
{
ShadowDirectionalLight light = ShadowDirectionalLights[index];
var shadowSettings = new ShadowDrawingSettings(cullingResults, light.visibleLightIndex)
{
useRenderingLayerMaskTest = true
};
int cascadeCount = settings.directional.cascadeCount;
int tileOffset = index * cascadeCount;
Vector3 ratios = settings.directional.CascadeRatios;
//裁剪参数
float cullingFactor = Mathf.Max(0f, 0.8f - settings.directional.cascadeFade);
float tileScale = 1f / split;
//遍历Cascade的数量
for (int i = 0; i < cascadeCount; i++)
{
//Debug.Log(light.nearPlaneOffset);
//Unity
cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(
light.visibleLightIndex, i, cascadeCount, ratios, tileSize, light.nearPlaneOffset, out Matrix4x4 viewMatrix, out Matrix4x4 projectionMatrix,
out ShadowSplitData splitData);
//??????？？？？？
splitData.shadowCascadeBlendCullingFactor = cullingFactor;
shadowSettings.splitData = splitData;
if (index == 0)
{
//裁剪球 判断片段在哪一级的Cascade里面 w为半径
Vector4 cullingSphere = splitData.cullingSphere;
SetCascadeData(i, splitData.cullingSphere, tileSize);
}
int tileIndex = tileOffset + i;
//设置ViewPort大小
//SetTileViewport(index, split, tileSize);
//从世界空间到灯光阴影投影空间
dirShadowMatrices[tileIndex] = ConvertToAtlasMatrix(projectionMatrix * viewMatrix, SetTileViewport(tileIndex, split, tileSize), tileScale);
buffer.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
//球覆盖
buffer.SetGlobalVectorArray(cascadeCullingSpheresId, cascadeCullingSpheres);
//Cascade数据
buffer.SetGlobalVectorArray(cascadeDataId, cascadeData);
//转换物体到灯光空间
buffer.SetGlobalMatrixArray(dirShadowMatricesId, dirShadowMatrices);
buffer.SetGlobalDepthBias(0f, light.slopeScaleBias);
ExecuteBuffer();
context.DrawShadows(ref shadowSettings);
buffer.SetGlobalDepthBias(0f, 0f);
}
}
public void RenderShadows(ScriptableRenderContext renderContext, CommandBuffer cmd, CullingResults cullResults)
{
// Avoid to do any commands if there is no shadow to draw
if (m_ShadowRequestCount == 0)
{
return;
}
// TODO remove DrawShadowSettings, lightIndex and splitData when scriptable culling is available
ShadowDrawingSettings dss = new ShadowDrawingSettings(cullResults, 0);
// Clear atlas render targets and draw shadows
m_Atlas.RenderShadows(renderContext, cmd, dss);
m_CascadeAtlas.RenderShadows(renderContext, cmd, dss);
}
public void RenderDirectionalShadows(int index, int splitCount, int size)
{
ShadowedDirectionalLight light = ShadowedDirectionalLights[index];
var shadowSetting = new ShadowDrawingSettings(_results, light.visibleLightIndex);
//https://docs.unity3d.com/2019.1/Documentation/ScriptReference/Rendering.CullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives.html
//利用光源的方向（-transform.forward）方向可以求出view matrix，nearclip 和 最远的阴影距离等可以求出project matrix等等
_results.ComputeDirectionalShadowMatricesAndCullingPrimitives(light.visibleLightIndex, 0, 1, Vector3.zero,
size, 0, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix,
out ShadowSplitData shadowSplitData);
shadowSetting.splitData = shadowSplitData;
SetTileViewport(index, splitCount, size);
_commandBuffer.SetViewProjectionMatrices(viewMatrix, projMatrix);
ExecuteCommandBuffer();
_context.DrawShadows(ref shadowSetting);
}
public static void RenderShadowSlice(CommandBuffer cmd, ref ScriptableRenderContext context,
ref ShadowSliceData shadowSliceData, ref ShadowDrawingSettings settings,
Matrix4x4 proj, Matrix4x4 view, Vector4 shadowBias, VisibleLight shadowLight, int cascadeIndex)
{
cmd.SetViewport(new Rect(shadowSliceData.offsetX, shadowSliceData.offsetY, shadowSliceData.resolution, shadowSliceData.resolution));
cmd.EnableScissorRect(new Rect(shadowSliceData.offsetX + 4, shadowSliceData.offsetY + 4, shadowSliceData.resolution - 8, shadowSliceData.resolution - 8));
cmd.SetViewProjectionMatrices(view, proj);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.DrawShadows(ref settings);
CustomRenderShadowSlice?.Invoke(cmd, GL.GetGPUProjectionMatrix(proj, true) * view, shadowBias, shadowLight, cascadeIndex);
cmd.DisableScissorRect();
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
private bool RenderShadowMaps(ref ScriptableRenderContext context, ref CullingResults cullingResults, ref Matrix4x4 worldToShadowMatrix)
{
if (cullingResults.visibleLights.Length == 0)
{
return(false);
}
int lightIndex = 0; // Just use first light (index 0) for shadows and assume it's a directional light
bool needToRender = cullingResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(lightIndex, 0, 1, Vector3.forward, 1024, cullingResults.visibleLights[0].light.shadowNearPlane, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix, out ShadowSplitData shadowSplitData);
if (!needToRender)
{
return(false);
}
CommandBuffer cb = new CommandBuffer();
cb.name = "Set up shadow data";
cb.SetRenderTarget(m_ShadowMap);
cb.ClearRenderTarget(true, true, Color.clear);
cb.SetViewProjectionMatrices(viewMatrix, projMatrix);
context.ExecuteCommandBuffer(cb);
ShadowDrawingSettings shadowDrawSettings = new ShadowDrawingSettings(cullingResults, lightIndex);
shadowDrawSettings.splitData = shadowSplitData;
context.DrawShadows(ref shadowDrawSettings);
if (SystemInfo.usesReversedZBuffer)
{
projMatrix.m20 = -projMatrix.m20;
projMatrix.m21 = -projMatrix.m21;
projMatrix.m22 = -projMatrix.m22;
projMatrix.m23 = -projMatrix.m23;
}
var scaleOffset = Matrix4x4.TRS(
Vector3.one * 0.5f, Quaternion.identity, Vector3.one * 0.5f
);
worldToShadowMatrix =
scaleOffset * (projMatrix * viewMatrix);
return(true);
}
public static void RenderShadowSlice(CommandBuffer cmd, ref ScriptableRenderContext context,
ref ShadowSliceData shadowSliceData, ref ShadowDrawingSettings settings,
Matrix4x4 proj, Matrix4x4 view)
{
cmd.SetGlobalDepthBias(1.0f, 2.5f); // these values match HDRP defaults (see https://github.com/Unity-Technologies/Graphics/blob/9544b8ed2f98c62803d285096c91b44e9d8cbc47/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/HDShadowAtlas.cs#L197 )
cmd.SetViewport(new Rect(shadowSliceData.offsetX, shadowSliceData.offsetY, shadowSliceData.resolution, shadowSliceData.resolution));
cmd.SetViewProjectionMatrices(view, proj);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.DrawShadows(ref settings);
cmd.DisableScissorRect();
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetGlobalDepthBias(0.0f, 0.0f); // Restore previous depth bias values
}
