public override void Setup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
visibleVolumes.Clear();
for (int i = 0; i < renderingData.cullResults.visibleLights.Length; i++)
{
var light = renderingData.cullResults.visibleLights[i];
VolumeLightRenderer vlr = light.light.GetComponent <VolumeLightRenderer>();
if (vlr)
{
visibleVolumes.Add(new LightVolumeData()
{
lightIndex = i,
volumeIndex = visibleVolumes.Count,
volume = vlr,
});
}
}
// 第一帧数 初始化
if (renderingData.frameID == 0)
{
var cmd = CommandBufferPool.Get();
cmd.SetGlobalVectorArray("_BoundaryPlanes", new Vector4[6]);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
}
private void SetupLights(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get();
renderingData.lights = renderingData.cullResults.visibleLights;
var mainLightIdx = GetMainLightIndex(ref renderingData);
if (mainLightIdx >= 0)
{
var mainLight = renderingData.lights[GetMainLightIndex(ref renderingData)];
cmd.SetGlobalColor("_MainLightColor", mainLight.finalColor);
cmd.SetGlobalVector("_MainLightDirection", mainLight.light.transform.forward);
}
else
{
cmd.SetGlobalColor("_MainLightColor", Color.black);
cmd.SetGlobalVector("_MainLightPosition", Vector4.zero);
}
cmd.SetGlobalColor("_AmbientSkyColor", RenderSettings.ambientSkyColor);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
if (boidBuffer == null)
{
needUpdate = true;
}
if (needUpdate)
{
return;
}
boidBuffer.Flip();
var cmd = CommandBufferPool.Get(k_profilingTag);
using (new ProfilingScope(cmd, profilingSampler))
{
cmd.BeginSample("Boid Compute");
cmd.SetComputeIntParam(computeShader, "TotalSize", count);
cmd.SetComputeFloatParam(computeShader, "SensoryRadius", sensoryRadius);
cmd.SetComputeFloatParam(computeShader, "AlignmentFactor", alignment);
cmd.SetComputeFloatParam(computeShader, "SeprationFactor", seperation);
cmd.SetComputeFloatParam(computeShader, "CohesionFactor", cohesion);
cmd.SetComputeFloatParam(computeShader, "DeltaTime", Time.deltaTime);
cmd.SetComputeVectorParam(computeShader, "SpeedLimit", new Vector2(minSpeed, maxSpeed));
cmd.SetComputeVectorParam(computeShader, "AngularSpeedLimit", angularLimit);
cmd.SetComputeFloatParam(computeShader, "AccelerationLimit", accelerationLimit);
cmd.SetComputeVectorParam(computeShader, "Target",
targetPoint.transform.position.ToVector4(forceTarget ? 1 : 0));
cmd.SetComputeBufferParam(computeShader, KernelBoid, "InputBuffer", boidBuffer.Current);
cmd.SetComputeBufferParam(computeShader, KernelBoid, "OutputBuffer", boidBuffer.Next);
cmd.DispatchCompute(computeShader, KernelBoid, Mathf.CeilToInt(count / ComputeThreads), 1, 1);
cmd.EndSample("Boid Compute");
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.BeginSample("Boid Rendering");
var light = GetMainLight(renderingData);
if (light.light)
{
cmd.SetGlobalVector("_MainLightPosition", light.light.transform.forward.ToVector4(0.0f));
cmd.SetGlobalColor("_MainLightColor", light.finalColor);
}
cmd.SetGlobalColor("_AmbientLight", RenderSettings.ambientLight);
cmd.SetGlobalVector("_WorldCameraPos", renderingData.camera.transform.position);
cmd.SetGlobalBuffer("boidBuffer", boidBuffer.Next);
//https://docs.unity3d.com/ScriptReference/Graphics.DrawMeshInstancedIndirect.html
//argsBuffer GPU缓冲区包含要绘制多少网格实例的参数。
//请使用此函数。网格不会被视图视锥体或烘焙遮挡器进一步剔除，也不会为透明度或z效率进行排序
cmd.DrawMeshInstancedIndirect(mesh, 0, material, 0, argsBuffer);
cmd.EndSample("Boid Rendering");
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public override void Setup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
if (patterns.Capacity < asset.Samples)
{
patterns.Capacity = asset.Samples;
}
if (asset.SamplingPatterns == SamplingPatterns.Uniform)
{
asset.Samples = Mathf.ClosestPowerOfTwo(asset.Samples);
var size = Mathf.Sqrt(asset.Samples);
patterns.Clear();
for (int y = 0; y < Mathf.Sqrt(asset.Samples); y++)
{
for (int x = 0; x < Mathf.Sqrt(asset.Samples); x++)
{
patterns.Add(new Vector2(x / size + .5f * size, y / size + .5f * size));
}
}
}
else if (asset.SamplingPatterns == SamplingPatterns.Halton2_3)
{
//linq 配合 迭代器 可以拿到指定数量的
patterns = Sampler.HaltonSequence2(2, 3).Skip(1).Take(asset.Samples).ToList();
}
renderingData.nextProjectionJitter = patterns[renderingData.frameID % asset.Samples];
HistoricalRT.Swap();
}
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);
}
private void SetupGlobalLight(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get();
var mainLightIdx = GetMainLightIndex(ref renderingData);
if (mainLightIdx >= 0)
{
var mainLight = renderingData.lights[mainLightIdx];
//mainLight dir 是要翻转下
if (mainLight.light.type == LightType.Directional)
{
cmd.SetGlobalVector("_MainLightPosition", -mainLight.light.transform.forward.ToVector4(0));
}
else
{
cmd.SetGlobalVector("_MainLightPosition", mainLight.light.transform.position.ToVector4(1));
}
cmd.SetGlobalColor("_MainLightColor", mainLight.finalColor);
}
else
{
cmd.SetGlobalColor("_MainLightColor", Color.black);
cmd.SetGlobalVector("_MainLightPosition", Vector4.zero);
}
cmd.SetGlobalColor("_AmbientLight", RenderSettings.ambientLight);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
private int GetMainLightIndex(ref MyRenderingData renderingData)
{
var lights = renderingData.cullResults.visibleLights;
var sun = RenderSettings.sun;
if (sun == null)
{
for (var index = 0; index < lights.Length; index++)
{
var light = lights[index];
if (light.light.type == LightType.Directional)
{
return(index);
}
}
}
else
{
for (var index = 0; index < lights.Length; index++)
{
var light = lights[index];
if (light.light == sun)
{
return(index);
}
}
}
return(-1);
}
private VisibleLight GetMainLight(MyRenderingData renderingData)
{
var lights = renderingData.cullResults.visibleLights;
var sun = RenderSettings.sun;
if (sun == null)
{
return(default);
public override void Cleanup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get();
cmd.ReleaseTemporaryRT(velocityBuffer);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get(k_profilingTag);
using (new ProfilingScope(cmd, profilingSampler))
{
RenderVolumeLight(cmd, renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Setup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
//基本不运行
if (curlNoiseMotionRenderer == null && asset.curlNoiseMotionComputeShader && asset.curlNoiseTexture)
{
curlNoiseMotionRenderer = new CurlNoiseMotionRenderer(asset.curlNoiseTexture,
asset.curlNoiseMotionComputeShader,
new Vector3Int(asset.curlNoiseTexture.width, asset.curlNoiseTexture.height,
asset.curlNoiseTexture.volumeDepth));
}
SetupLights(context, ref renderingData);
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var camera = renderingData.camera;
var cmd = CommandBufferPool.Get("Velocity Pass");
using (new ProfilingSample(cmd, "Velocity Pass"))
{
cmd.SetGlobalMatrix("_PreviousGPUViewProjection", previousGPUVPMatrix);
cmd.SetGlobalTexture("_CameraDepthTex", renderingData.depthTarget);
cmd.SetGlobalVector("_PreviousJitterOffset", previousJitterOffset);
var jitterOffset = renderingData.projectionJitter - new Vector2(0.5f, 0.5f);
cmd.SetGlobalVector("_CurrentJitterOffset", jitterOffset);
cmd.SetCameraParams(renderingData.camera, false);
cmd.SetViewProjectionMatrices(renderingData.viewMatrix, renderingData.jitteredProjectionMatrix);
cmd.SetRenderTarget(velocityBuffer);
cmd.ClearRenderTarget(true, true, Color.black);
cmd.BlitFullScreen(BuiltinRenderTextureType.None, velocityBuffer, ShaderPool.Get(ShaderName),
(int)ShaderPass.StaticVelocity);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
FilteringSettings filteringSettings = new FilteringSettings(RenderQueueRange.opaque);
SortingSettings sortingSettings = new SortingSettings(renderingData.camera)
{
criteria = SortingCriteria.CommonOpaque
};
DrawingSettings drawingSettings = new DrawingSettings(VelocityPassName, sortingSettings)
{
enableDynamicBatching = false,
enableInstancing = true,
perObjectData = PerObjectData.MotionVectors,
};
RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Nothing);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings,
ref stateBlock);
}
previousGPUVPMatrix = SaveGPUViewProjection(renderingData);
previousJitterOffset = renderingData.projectionJitter - new Vector2(.5f, .5f);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
private void SetupLight(ScriptableRenderContext context, MyRenderingData renderingData, int lightIndex)
{
var cmd = CommandBufferPool.Get();
var light = renderingData.cullResults.visibleLights[lightIndex];
if (light.lightType == LightType.Directional)
{
cmd.SetGlobalVector("_LightPosition", -light.light.transform.forward.ToVector4(0));
cmd.SetGlobalColor("_LightColor", light.finalColor);
cmd.SetGlobalVector("_LightDirection", -light.light.transform.forward);
cmd.SetGlobalFloat("_LightCosHalfAngle", -2);
}
else
{
cmd.SetGlobalVector("_LightPosition", light.light.transform.position.ToVector4(1));
cmd.SetGlobalColor("_LightColor", light.finalColor);
cmd.SetGlobalVector("_LightDirection", -light.light.transform.forward.normalized);
if (light.lightType == LightType.Spot)
{
cmd.SetGlobalFloat("_LightCosHalfAngle", Mathf.Cos(Mathf.Deg2Rad * light.spotAngle / 2));
}
else
{
cmd.SetGlobalFloat("_LightCosHalfAngle", -2);
}
}
if (renderingData.shadowMapData.ContainsKey(light.light))
{
var shadowData = renderingData.shadowMapData[light.light];
cmd.SetGlobalInt("_UseShadow", 1);
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);
}
else
{
cmd.SetGlobalInt("_UseShadow", 0);
cmd.SetGlobalMatrix("_WorldToLight", Matrix4x4.identity);
cmd.SetGlobalTexture("_ShadowMap", renderingData.defaultShadowMap);
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
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);
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get("TAA Resolve");
var(previousColor, nextColor) = GetHistoricalColorBuffer(renderingData);
cmd.SetGlobalTexture("_PreviousFrameBuffer", previousColor);
cmd.SetGlobalTexture("_CurrentFrameBuffer", renderingData.colorTarget);
cmd.SetGlobalFloat("_Alpha", asset.BlendAlpha);
cmd.SetGlobalTexture("_VelocityBuffer", renderingData.velocityBuffer);
cmd.Blit(renderingData.colorTarget, nextColor, material, 0);
cmd.Blit(nextColor, renderingData.colorTarget);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
private void DrawShadowCasters(ScriptableRenderContext context, MyRenderingData renderingData,
MyShadowMapData shadowMapData, int pass)
{
var cmd = CommandBufferPool.Get();
cmd.SetGlobalMatrix("_LightViewProjection", shadowMapData.world2Light);
//如果用cullResults 则范围太小 , 一些摄像机外的阴影没有绘制
//而且现在shadowMap shader 是单独区分的
foreach (var renderer in GameObject.FindObjectsOfType <UnityEngine.Renderer>())
{
cmd.DrawRenderer(renderer, shadowMapMat, 0, pass);
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
if (shadowMapMat == null)
{
shadowMapMat = new Material(Shader.Find(shaderName));
}
for (var i = 0; i < renderingData.cullResults.visibleLights.Length; ++i)
{
var light = renderingData.cullResults.visibleLights[i];
if (light.light.GetComponent <ShadowSettings>() is ShadowSettings shadowSettings)
{
if (!shadowSettings.shadow)
{
continue;
}
MyShadowMapData data = new MyShadowMapData();
var hasData = false;
switch (shadowSettings.algorithms)
{
case ShadowAlgorithms.Standard:
data = StandardShadowMap(context, renderingData, shadowSettings, i);
hasData = true;
break;
case ShadowAlgorithms.PSM:
data = PSMShadowMap(context, renderingData, shadowSettings, i);
hasData = true;
break;
case ShadowAlgorithms.TSM:
data = TSMShadowMap(context, renderingData, shadowSettings, i);
hasData = true;
break;
}
if (hasData)
{
renderingData.shadowMapData[light.light] = data;
lightMaps[light.light] = data;
}
}
}
}
public override void Setup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
if (defaultShadowMap <= 0)
{
var cmd = CommandBufferPool.Get();
defaultShadowMap = Shader.PropertyToID("_DefaultShadowMapTex");
cmd.GetTemporaryRT(defaultShadowMap, 16, 16, 32, FilterMode.Point, RenderTextureFormat.Depth);
cmd.SetRenderTarget(defaultShadowMap, defaultShadowMap);
cmd.ClearRenderTarget(true, true, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
renderingData.defaultShadowMap = defaultShadowMap;
lightMaps.Clear();
}
public override void Cleanup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get();
foreach (var light in renderingData.lights)
{
if (lightMaps.ContainsKey(light.light))
{
IdentifierPool.Release(lightMaps[light.light].shadowMapIdentifier);
cmd.ReleaseTemporaryRT(lightMaps[light.light].shadowMapIdentifier);
}
}
lightMaps.Clear();
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public override void Setup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get();
renderingData.camera.depthTextureMode |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth;
cmd.GetTemporaryRT(velocityBuffer, renderingData.resolutionX, renderingData.resolutionY, 32,
FilterMode.Point, RenderTextureFormat.RGFloat);
if (renderingData.frameID == 0)
{
previousGPUVPMatrix = SaveGPUViewProjection(renderingData);
}
renderingData.velocityBuffer = velocityBuffer;
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
void RenderLight(ScriptableRenderContext context, ref MyRenderingData renderingData, int lightIndex,
ShaderTagId shaderTagId)
{
SetupLight(context, renderingData, lightIndex);
FilteringSettings filteringSettings = new FilteringSettings(RenderQueueRange.opaque);
SortingSettings sortingSettings = new SortingSettings(renderingData.camera);
sortingSettings.criteria = SortingCriteria.CommonOpaque;
DrawingSettings drawingSettings = new DrawingSettings(shaderTagId, sortingSettings)
{
mainLightIndex = GetMainLightIndex(ref renderingData),
enableDynamicBatching = false
};
RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Nothing);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings,
ref stateBlock);
}
//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);
}
private int GetMainLightIndex(ref MyRenderingData renderingData)
{
var lights = renderingData.cullResults.visibleLights;
var sun = RenderSettings.sun;
if (sun == null)
{
return(-1);
}
for (var i = 0; i < lights.Length; i++)
{
if (lights[i].light == sun)
{
return(i);
}
}
return(-1);
}
private void RenderDefaultTransparent(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var camera = renderingData.camera;
FilteringSettings filteringSettings = new FilteringSettings(RenderQueueRange.transparent);
SortingSettings sortingSettings = new SortingSettings(camera);
sortingSettings.criteria = SortingCriteria.CommonTransparent;
DrawingSettings drawingSettings = new DrawingSettings(new ShaderTagId("TransparentBack"), sortingSettings)
{
enableDynamicBatching = false,
perObjectData = PerObjectData.ReflectionProbes,
};
drawingSettings.SetShaderPassName(1, new ShaderTagId("TransparentFront"));
drawingSettings.SetShaderPassName(1, new ShaderTagId("Transparent"));
RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Nothing);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings,
ref stateBlock);
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var cmd = CommandBufferPool.Get(k_profilerTag_transparent);
using (new ProfilingScope(cmd, profilingSampler_transparent))
{
cmd.SetRenderTarget(renderingData.colorTarget, renderingData.depthTarget);
if (!asset.useDepthPeeling)
{
RenderDefaultTransparent(context, ref renderingData);
}
else
{
RenderDepthPeeling(context, ref renderingData);
}
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public override void Render(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
var camera = renderingData.camera;
var cmd = CommandBufferPool.Get(k_profilerTag);
using (new ProfilingScope(cmd, profilingSampler))
{
//开始profilling 并且 清理之前可能没有处理的cmd
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetRenderTarget(renderingData.colorTarget, renderingData.depthTarget);
cmd.SetViewProjectionMatrices(renderingData.viewMatrix, renderingData.jitteredProjectionMatrix);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
//SetupGlobalLight(context, ref renderingData);
var mainLightIndex = GetMainLightIndex(ref renderingData);
// Render Main Light
if (mainLightIndex >= 0)
{
RenderLight(context, ref renderingData, mainLightIndex, new ShaderTagId("ForwardBase"));
}
for (var i = 0; i < renderingData.cullResults.visibleLights.Length; i++)
{
if (i == mainLightIndex)
{
continue;
}
RenderLight(context, ref renderingData, i, new ShaderTagId("ForwardAdd"));
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
private MyShadowMapData PSMShadowMap(ScriptableRenderContext context, MyRenderingData renderingData,
ShadowSettings settings, int lightIndex)
{
var(view, projection, inverseZ) = PSMProjection(lightIndex, renderingData, settings);
//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;
MyShadowMapData shadowMapData = new MyShadowMapData()
{
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);
}
public override void Setup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
SetupGlobalLight(context, ref renderingData);
}
public virtual void Cleanup(ScriptableRenderContext context, ref MyRenderingData renderingData)
{
}
private void RenderVolumeLight(CommandBuffer cmd, MyRenderingData renderingData)
{
var rendererSize = new Vector2Int(renderingData.camera.pixelWidth, renderingData.camera.pixelHeight) /
asset.volumeResolutionScale;
var rt = IdentifierPool.Get();
cmd.GetTemporaryRT(rt, rendererSize.x, rendererSize.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(10) / asset.visibilityDistance; //全局 每单位距离衰减
foreach (var volumeData in visibleVolumes)
{
if (!volumeData.volume.enabled)
{
return;
}
var light = renderingData.cullResults.visibleLights[volumeData.lightIndex];
Vector4 lightPos;
if (light.lightType == LightType.Directional)
{
lightPos = (-light.light.transform.forward).ToVector4(0);
cmd.SetGlobalFloat("_LightCosHalfAngle", -2);
}
else
{
lightPos = light.light.transform.position.ToVector4(1);
cmd.SetGlobalFloat("_LightCosHalfAngle", Mathf.Cos(Mathf.Deg2Rad * light.spotAngle / 2));
}
cmd.SetGlobalVector("_LightPosition", lightPos);
cmd.SetGlobalVector("_LightDirection", -light.light.transform.forward);
cmd.SetGlobalVector("_LightColor", light.finalColor * volumeData.volume.intensityMultiplier);
cmd.SetGlobalVector("_WorldCameraPos", renderingData.camera.transform.position);
cmd.SetGlobalVector("_FrameSize",
new Vector4(rendererSize.x, rendererSize.y, 1f / rendererSize.x, 1f / rendererSize.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(10) / 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.TryGetValue(volumeData.volume.TheLight, out var shadowData))
{
cmd.SetGlobalTexture("_ShadowMap", shadowData.shadowMapIdentifier);
cmd.SetGlobalMatrix("_WorldToLight", shadowData.world2Light);
cmd.SetGlobalFloat("_ShadowBias", shadowData.bias);
cmd.SetGlobalInt("_ShadowType", (int)shadowData.shadowType);
cmd.SetGlobalVector("_ShadowParameters", shadowData.shadowParameters);
cmd.SetGlobalMatrix("_ShadowPostTransform", shadowData.postTransform);
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, volumeScatteringPass);
break;
case LightType.Directional:
cmd.BlitFullScreen(BuiltinRenderTextureType.None, rt, volumeMat,
fullScreenVolumeScatteringPass);
break;
}
}
if (asset.globalFog)
{
cmd.SetGlobalTexture("_CameraDepthTex", renderingData.depthTarget);
cmd.SetGlobalFloat("_GlobalFogExtinction", globalExtinction);
cmd.SetGlobalColor("_AmbientLight", asset.fogLight);
cmd.BlitFullScreen(BuiltinRenderTextureType.None, renderingData.colorTarget, volumeMat, globalFogPass);
}
cmd.Blit(rt, renderingData.colorTarget, volumeMat, volumeResolvePass);
cmd.ReleaseTemporaryRT(rt);
IdentifierPool.Release(rt);
}
