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); }