private MyShadowMapData TSMShadowMap(ScriptableRenderContext context, MyRenderingData renderingData,
ShadowSettings settings, int lightIndex)
{
var camera = renderingData.camera;
if (settings.debug)
{
camera = GameObject.Find("Main Camera").GetComponent <Camera>();
}
var(view, projection) = GetShadowViewProjection(settings, renderingData, lightIndex);
var cmd = CommandBufferPool.Get();
cmd.Clear();
var depthBuf = IdentifierPool.Get();
cmd.GetTemporaryRT(depthBuf, settings.resolution, settings.resolution, 32, FilterMode.Point,
RenderTextureFormat.Depth);
RenderTargetBinding binding = new RenderTargetBinding();
binding.depthRenderTarget = depthBuf;
cmd.SetRenderTarget(depthBuf);
cmd.ClearRenderTarget(true, true, Color.black);
MyShadowMapData shadowMapData = new MyShadowMapData()
{
shadowMapIdentifier = depthBuf,
bias = settings.bias,
shadowType = ShadowAlgorithms.TSM,
world2Light = GL.GetGPUProjectionMatrix(projection, true) * view,
};
var trapezoidalTransfrom = TSMTransform(camera, shadowMapData.world2Light, settings);
shadowMapData.postTransform = trapezoidalTransfrom;
cmd.SetViewProjectionMatrices(view, projection);
cmd.SetGlobalDepthBias(settings.depthBias, settings.normalBias);
cmd.SetGlobalMatrix("_ShadowPostTransform", trapezoidalTransfrom);
cmd.SetGlobalFloat("_SlopeDepthBias", -settings.normalBias);
cmd.SetGlobalFloat("_DepthBias", -Mathf.Pow(2, settings.depthBias));
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
DrawShadowCasters(context, renderingData, shadowMapData, PassTSM);
cmd.SetViewProjectionMatrices(renderingData.camera.worldToCameraMatrix,
renderingData.camera.projectionMatrix);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
return(shadowMapData);
}
ShadowMapData PSMShadowMap(ScriptableRenderContext context, RenderingData renderingData, ShadowSettings settings, int lightIndex)
{
var(view, projection, inverseZ) = PSMProjection(lightIndex, renderingData);
//Debug.Log(inverseZ);
Vector4 p = new Vector4(-0.46017f, 0.16764f, 0.01015f, 1.00f);
var p1 = projection * view * p;
var p2 = GL.GetGPUProjectionMatrix(projection, false) * Matrix4x4.Scale(new Vector3(1, 1, -1)) * view * p;
ShadowMapData shadowMapData = new ShadowMapData()
{
shadowMapIdentifier = IdentifierPool.Get(),
world2Light = GL.GetGPUProjectionMatrix(projection, true) * Matrix4x4.Scale(new Vector3(1, 1, -1)) * view,
bias = settings.Bias,
ShadowType = ShadowAlgorithms.PSM,
ShadowParameters = new Vector4(inverseZ ? 1 : 0, 0, 0),
};
var cmd = CommandBufferPool.Get();
cmd.GetTemporaryRT(shadowMapData.shadowMapIdentifier, settings.Resolution, settings.Resolution, 32, FilterMode.Point, RenderTextureFormat.Depth);
cmd.SetRenderTarget(shadowMapData.shadowMapIdentifier);
cmd.SetGlobalVector("_ShadowParameters", shadowMapData.ShadowParameters);
cmd.SetGlobalDepthBias(1, 1);
//cmd.SetViewProjectionMatrices(renderingData.camera.worldToCameraMatrix, renderingData.camera.projectionMatrix);
cmd.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
DrawShadowCasters(context, renderingData, shadowMapData, PassPSM);
CommandBufferPool.Release(cmd);
return(shadowMapData);
}
private MyShadowMapData StandardShadowMap(ScriptableRenderContext context, MyRenderingData renderingData,
ShadowSettings settings, int lightIndex)
{
var cmd = CommandBufferPool.Get();
cmd.Clear();
var depthBuf = IdentifierPool.Get();
cmd.GetTemporaryRT(depthBuf, settings.resolution, settings.resolution, 32, FilterMode.Point,
RenderTextureFormat.Depth);
RenderTargetBinding binding = new RenderTargetBinding();
binding.depthRenderTarget = depthBuf;
cmd.SetRenderTarget(depthBuf);
cmd.ClearRenderTarget(true, true, Color.black);
MyShadowMapData shadowMapData = new MyShadowMapData()
{
shadowMapIdentifier = depthBuf,
bias = settings.bias,
shadowType = ShadowAlgorithms.Standard,
};
var(view, projection) = GetShadowViewProjection(settings, renderingData, lightIndex);
cmd.SetViewProjectionMatrices(view, projection);
shadowMapData.world2Light = projection * view;
cmd.SetGlobalDepthBias(settings.depthBias, settings.normalBias);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
DrawShadowCasters(context, renderingData, shadowMapData, PassSimple);
cmd.SetViewProjectionMatrices(renderingData.camera.worldToCameraMatrix,
renderingData.camera.projectionMatrix);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
return(shadowMapData);
}
//Debug 用
private void RenderVolumeDepth(CommandBuffer cmd, MyRenderingData renderingData)
{
var debugRT = IdentifierPool.Get();
cmd.GetTemporaryRT(debugRT, renderingData.camera.pixelWidth, renderingData.camera.pixelHeight, 0,
FilterMode.Point, RenderTextureFormat.ARGBFloat);
cmd.SetRenderTarget(debugRT);
cmd.SetGlobalTexture("_RWVolumeDepthTexture", volumeDepthTexID);
foreach (var volumeData in visibleVolumes)
{
cmd.SetGlobalInt("_VolumeIndex", volumeData.volumeIndex);
cmd.DrawMesh(volumeData.volume.VolumeMesh, volumeData.volume.transform.localToWorldMatrix, volumeMat, 0,
volumeDepthPass);
}
cmd.ReleaseTemporaryRT(debugRT);
IdentifierPool.Release(debugRT);
}
void RenderVolumeDepth(ScriptableRenderContext context, RenderingData renderingData)
{
var cmd = CommandBufferPool.Get("Light Volume Depth");
var debugRT = IdentifierPool.Get();
cmd.GetTemporaryRT(debugRT, renderingData.camera.pixelWidth, renderingData.camera.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGBFloat);
cmd.SetRenderTarget(debugRT);
cmd.SetGlobalTexture("_RWVolumeDepthTexture", VolumeDepthTex);
foreach (var volumeData in visibleVolumes)
{
cmd.SetGlobalInt("_VolumeIndex", volumeData.VolumeIndex);
cmd.DrawMesh(volumeData.Volume.VolumeMesh, volumeData.Volume.transform.localToWorldMatrix, volumeMat, 0, PassVolumeDepth);
}
cmd.ReleaseTemporaryRT(debugRT);
IdentifierPool.Release(debugRT);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
void RenderLightVolume(ScriptableRenderContext context, RenderingData renderingData)
{
var cmd = CommandBufferPool.Get("Light Volume");
var renderSize = new Vector2Int(renderingData.camera.pixelWidth, renderingData.camera.pixelHeight) / asset.VolumeResolutionScale;
var rt = IdentifierPool.Get();
cmd.GetTemporaryRT(rt, renderSize.x, renderSize.y, 0, FilterMode.Point, RenderTextureFormat.Default);
cmd.SetRenderTarget(rt, rt);
cmd.ClearRenderTarget(false, true, Color.black);
cmd.SetGlobalTexture("_CameraDepthTex", renderingData.DepthTarget);
cmd.SetCameraParams(renderingData.camera, true);
float globalExtinction = Mathf.Log(1 / (0.1f)) / asset.VisibilityDistance;
foreach (var volumeData in visibleVolumes)
{
if (!volumeData.Volume.enabled)
{
continue;
}
var light = renderingData.cullResults.visibleLights[volumeData.LightIndex];
Vector4 lightPos;
if (light.lightType == LightType.Directional)
{
lightPos = (-light.light.transform.forward).ToVector4(0);
}
else
{
lightPos = light.light.transform.position.ToVector4(1);
}
cmd.SetGlobalVector("_LightPosition", lightPos);
cmd.SetGlobalVector("_LightDirection", -light.light.transform.forward);
cmd.SetGlobalFloat("_LightAngle", Mathf.Cos(Mathf.Deg2Rad * light.spotAngle / 2));
cmd.SetGlobalVector("_LightColor", light.finalColor * volumeData.Volume.IntensityMultiplier);
cmd.SetGlobalVector("_WorldCameraPos", renderingData.camera.transform.position);
cmd.SetGlobalVector("_FrameSize", new Vector4(renderSize.x, renderSize.y, 1f / renderSize.x, 1f / renderSize.y));
cmd.SetGlobalInt("_Steps", volumeData.Volume.RayMarchingSteps);
cmd.SetGlobalVector("_RangeLimit", volumeData.Volume.RayMarchingRange);
cmd.SetGlobalFloat("_IncomingLoss", volumeData.Volume.IncomingLoss);
cmd.SetGlobalFloat("_LightDistance", volumeData.Volume.LightDistance);
var extinction = globalExtinction;
if (volumeData.Volume.ExtinctionOverride)
{
extinction = Mathf.Log(1 / (0.1f)) / volumeData.Volume.VisibilityDistance;
}
cmd.SetGlobalVector("_TransmittanceExtinction", new Vector3(extinction, extinction, extinction));
if (asset.JitterPatterns.Length > 0)
{
cmd.SetGlobalTexture("_SampleNoise", asset.JitterPatterns[renderingData.FrameID % asset.JitterPatterns.Length]);
}
if (renderingData.shadowMapData.ContainsKey(volumeData.Volume.light))
{
var shadowData = renderingData.shadowMapData[volumeData.Volume.light];
cmd.SetGlobalTexture("_ShadowMap", shadowData.shadowMapIdentifier);
cmd.SetGlobalMatrix("_WorldToLight", shadowData.world2Light);
cmd.SetGlobalMatrix("_WorldToLight", shadowData.world2Light);
cmd.SetGlobalTexture("_ShadowMap", shadowData.shadowMapIdentifier);
cmd.SetGlobalFloat("_ShadowBias", shadowData.bias);
cmd.SetGlobalInt("_ShadowType", (int)shadowData.ShadowType);
cmd.SetGlobalVector("_ShadowParameters", shadowData.ShadowParameters);
cmd.SetGlobalMatrix("_ShadowPostTransform", shadowData.postTransform);
//cmd.SetGlobalMatrix("_")
cmd.SetGlobalInt("_UseShadow", 1);
}
else
{
cmd.SetGlobalInt("_UseShadow", 0);
}
var boundaryPlanes = volumeData.Volume.GetVolumeBoundFaces(renderingData.camera);
cmd.SetGlobalVectorArray("_BoundaryPlanes", boundaryPlanes);
cmd.SetGlobalInt("_BoundaryPlaneCount", boundaryPlanes.Count);
switch (light.lightType)
{
case LightType.Point:
case LightType.Spot:
cmd.DrawMesh(volumeData.Volume.VolumeMesh, volumeData.Volume.transform.localToWorldMatrix, volumeMat, 0, PassVolumeScattering);
break;
case LightType.Directional:
cmd.BlitFullScreen(BuiltinRenderTextureType.None, rt, volumeMat, PassFullScreenVolumeScattering);
break;
}
//cmd.DrawMesh(volumeData.Volume.VolumeMesh, volumeData.Volume.transform.localToWorldMatrix, volumeMat, 0, PassVolumeScattering);
}
cmd.SetGlobalTexture("_CameraDepthTex", renderingData.DepthTarget);
cmd.SetGlobalFloat("_GlobalFogExtinction", globalExtinction);
cmd.SetGlobalColor("_AmbientLight", asset.FogLight);
//cmd.Blit(BuiltinRenderTextureType.None, renderingData.ColorTarget, volumeMat, PassGlobalFog);
cmd.BlitFullScreen(BuiltinRenderTextureType.None, renderingData.ColorTarget, volumeMat, PassGlobalFog);
cmd.Blit(rt, renderingData.ColorTarget, volumeMat, PassVolumeResolve);
//cmd.ReleaseTemporaryRT(rt);
//IdentifierPool.Release(rt);
cmd.ReleaseTemporaryRT(rt);
IdentifierPool.Release(rt);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}