// Here you can implement the rendering logic.
// Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
// https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
// You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
var RangeDrawCommand = GroundEffectsManagerV2.Get().RangeDrawCommand;
if (RangeDrawCommand != null)
{
context.ExecuteCommandBuffer(RangeDrawCommand);
}
}
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
Camera camera = renderingData.cameraData.camera;
var cmd = CommandBufferPool.Get(m_ProfilerTag);
cmd.SetViewProjectionMatrices(Matrix4x4.identity, Matrix4x4.identity);
cmd.DrawMesh(UnityEngine.Rendering.Universal.RenderingUtils.fullscreenMesh, Matrix4x4.identity, m_Settings.material);
cmd.SetViewProjectionMatrices(camera.worldToCameraMatrix, camera.projectionMatrix);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingSample(cmd, m_ProfilerTag))
{
cmd.SetRandomWriteTarget(1, portalRenderContext.computeBuffer);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
// Here you can implement the rendering logic.
// Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
// https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
// You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
var levelManager = LevelManager.Get();
if (levelManager != null && levelManager.CurrentLevelType != LevelType.STARTMENU)
{
var selectableObjectManagerV2 = SelectableObjectManagerV2.Get();
if (selectableObjectManagerV2.SelectableObjectRendererManager != null &&
selectableObjectManagerV2.SelectableObjectRendererManager.CommandBufer != null)
{
context.ExecuteCommandBuffer(selectableObjectManagerV2.SelectableObjectRendererManager.CommandBufer);
}
}
}
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_RenderWaterFXTag);
using (new ProfilingSample(cmd, k_RenderWaterFXTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var drawSettings = CreateDrawingSettings(m_WaterFXShaderTag, ref renderingData, SortingCriteria.CommonTransparent);
var filteringSettings = transparentFilterSettings;
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (m_WaterCausticMaterial == null)
{
Debug.LogErrorFormat(
"Missing caustic material. {0} render pass will not execute. Check for missing reference in the renderer resources.",
GetType().Name);
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderWaterCausticsTag);
cmd.SetViewProjectionMatrices(Matrix4x4.identity, Matrix4x4.identity);
cmd.DrawMesh(UnityEngine.Rendering.Universal.RenderingUtils.fullscreenMesh, Matrix4x4.identity, m_WaterCausticMaterial, 0, 0);
cmd.SetViewProjectionMatrices(renderingData.cameraData.camera.worldToCameraMatrix, renderingData.cameraData.camera.projectionMatrix);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
RenderTextureDescriptor opaqueDesc = renderingData.cameraData.cameraTargetDescriptor;
opaqueDesc.depthBufferBits = 0;
// Can't read and write to same color target, create a temp render target to blit.
if (destination == UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget)
{
cmd.GetTemporaryRT(m_TemporaryColorTexture.id, opaqueDesc, filterMode);
RenderTargetIdentifier mainID;
if (setMainTexTo != null)
{
mainID = new RenderTargetIdentifier(setMainTexTo);
Blit(cmd, mainID, m_TemporaryColorTexture.Identifier(), blitMaterial, blitShaderPassIndex);
}
else
{
Blit(cmd, source, m_TemporaryColorTexture.Identifier(), blitMaterial, blitShaderPassIndex);
}
Blit(cmd, m_TemporaryColorTexture.Identifier(), source);
}
else
{
Blit(cmd, source, destination.Identifier(), blitMaterial, blitShaderPassIndex);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
renderer.EnqueuePass(m_WaterFXPass);
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (EnviroSkyMgr.instance != null && EnviroSky.instance != null && EnviroSkyMgr.instance.useVolumeClouds && EnviroSky.instance.PlayerCamera != null)
{
if (renderingData.cameraData.camera.cameraType == CameraType.Preview)
{
return;
}
myCam = renderingData.cameraData.camera;
var src = renderer.cameraColorTarget;
var dest = UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget;
if (currentReprojectionPixelSize != EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize)
{
currentReprojectionPixelSize = EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize;
SetReprojectionPixelSize(EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize);
}
if (renderingData.cameraData.isSceneViewCamera && !EnviroSky.instance.showVolumeCloudsInEditor)
{
return;
}
RenderVolumeClouds(renderingData.cameraData.cameraTargetDescriptor);
if (blitPass == null)
{
Create();
}
blitPass.Setup(src, dest);
renderer.EnqueuePass(blitPass);
}
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (renderingData.cameraData.camera.cameraType == CameraType.Preview || renderingData.cameraData.camera.cameraType == CameraType.SceneView || renderingData.cameraData.camera.cameraType == CameraType.Reflection)
{
return;
}
if (EnviroSkyMgr.instance != null && EnviroSkyMgr.instance.useMoonShafts && EnviroSkyMgr.instance.Camera != null)
{
var src = renderer.cameraColorTarget;
var dest = UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget;
if (myCam == null)
{
myCam = EnviroSkyMgr.instance.Camera;
}
RenderTextureDescriptor descriptor = renderingData.cameraData.cameraTargetDescriptor;
descriptor.graphicsFormat = Experimental.Rendering.GraphicsFormat.R32G32B32A32_SFloat;
RenderTexture newSource = RenderTexture.GetTemporary(descriptor);
RenderTargetIdentifier newSourceID = new RenderTargetIdentifier(newSource);
if (getSouceTexture == null || blitPassFinal == null)
{
Create();
}
getSouceTexture.Setup(src, newSourceID);
renderer.EnqueuePass(getSouceTexture);
RenderLightShaft(renderer, newSource, src, dest, sunShaftsMaterial, simpleSunClearMaterial, EnviroSkyMgr.instance.Components.Moon.transform, EnviroSkyMgr.instance.LightShaftsSettings.thresholdColorMoon.Evaluate(EnviroSkyMgr.instance.Time.solarTime), EnviroSkyMgr.instance.LightShaftsSettings.lightShaftsColorMoon.Evaluate(EnviroSkyMgr.instance.Time.solarTime));
RenderTexture.ReleaseTemporary(newSource);
}
}
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_RenderGrassDisplacementFXTag);
using (new ProfilingSample(cmd, k_RenderGrassDisplacementFXTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
var drawSettings = CreateDrawingSettings(m_GrassDisplacementFXShaderTag, ref renderingData, SortingCriteria.CommonTransparent);
var filteringSettings = transparentFilterSettings;
var camera = renderingData.cameraData.camera;
var cameraTransform = camera.transform;
var cameraPos = cameraTransform.position;
var isStereoEnabled = renderingData.cameraData.isStereoEnabled;
if (isStereoEnabled)
{
cmd.SetSinglePassStereo(SinglePassStereoMode.None);
}
// Push cameraPos forward – if enabled
var camForward = cameraTransform.forward;
// unstable
// cameraPos.x += camForward.x * m_Size * 0.5f;
// cameraPos.z += camForward.z * m_Size * 0.5f;
if (m_ShiftRenderTex)
{
var t_camForward = new Vector2(camForward.x, camForward.z);
t_camForward.Normalize();
// still rather unstable...
cameraPos.x += t_camForward.x * m_Size * 0.33f;
cameraPos.z += t_camForward.y * m_Size * 0.33f;
}
// Store original Camera matrices
var worldToCameraMatrixOrig = camera.worldToCameraMatrix;
var projectionMatrixOrig = camera.projectionMatrix;
// Quantize movement to fit texel size of RT – this stabilzes the final visual result
Vector2 positionRT = Vector2.zero; // bad
positionRT.x = Mathf.Floor(cameraPos.x * oneOverStepSize) * stepSize;
positionRT.y = Mathf.Floor(cameraPos.z * oneOverStepSize) * stepSize;
// Update the custom worldToCameraMatrix – we only have to update the translation/position
worldToCameraMatrix.SetColumn(3, new Vector4(-positionRT.x, -positionRT.y, -cameraPos.y - 40.0f, 1));
cmd.SetViewProjectionMatrices(worldToCameraMatrix, projectionMatrix);
// ---------------------------------------------------------
// Calc and set grass shader params
posSize.x = positionRT.x - m_Size * 0.5f;
posSize.y = positionRT.y - m_Size * 0.5f;
posSize.z = 1.0f / m_Size;
cmd.SetGlobalVector(DisplacementTexPosSizePID, posSize);
// ---------------------------------------------------------
// Call execute
context.ExecuteCommandBuffer(cmd);
context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
// ---------------------------------------------------------
// Restore Camera matrices
cmd.Clear();
cmd.SetViewProjectionMatrices(worldToCameraMatrixOrig, projectionMatrixOrig);
if (isStereoEnabled)
{
//if (m_SinglePassInstancing) {
// cmd.SetSinglePassStereo(SinglePassStereoMode.Instancing);
//cmd.SetGlobalTexture("_Lux_DisplacementRT", m_GrassDisplacementFX.id);
//cmd.SetGlobalTexture("_Lux_DisplacementRT", m_GrassDisplacementFX.Identifier() );
//}
//else {
cmd.SetSinglePassStereo(SinglePassStereoMode.SideBySide);
//}
}
}
// ---------------------------------------------------------
// Call execute a 2nd time
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (renderingData.cameraData.camera.cameraType == CameraType.Preview || renderingData.cameraData.camera.cameraType == CameraType.SceneView || renderingData.cameraData.camera.cameraType == CameraType.Reflection)
{
return;
}
myCam = renderingData.cameraData.camera;
if (EnviroSkyMgr.instance != null && EnviroSkyMgr.instance.HasInstance() && EnviroSkyMgr.instance.useMoonShafts)
{
if (renderingData.cameraData.isSceneViewCamera)
{
return;
}
var src = renderer.cameraColorTarget;
var dest = UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget;
blitPass.Setup(myCam, src, dest, EnviroSkyMgr.instance.Components.Moon.transform, EnviroSkyMgr.instance.LightShaftsSettings.thresholdColorMoon.Evaluate(EnviroSkyMgr.instance.Time.solarTime), EnviroSkyMgr.instance.LightShaftsSettings.lightShaftsColorMoon.Evaluate(EnviroSkyMgr.instance.Time.solarTime));
renderer.EnqueuePass(blitPass);
}
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get("Light Shafts");
int divider = 4;
if (EnviroSkyMgr.instance.LightShaftsSettings.resolution == EnviroPostProcessing.SunShaftsResolution.Normal)
{
divider = 2;
}
else if (EnviroSkyMgr.instance.LightShaftsSettings.resolution == EnviroPostProcessing.SunShaftsResolution.High)
{
divider = 1;
}
Vector3 v = Vector3.one * 0.5f;
if (lightSource)
{
v = myCam.WorldToViewportPoint(lightSource.position);
}
else
{
v = new Vector3(0.5f, 0.5f, 0.0f);
}
int rtW = renderingData.cameraData.cameraTargetDescriptor.width / divider;
int rtH = renderingData.cameraData.cameraTargetDescriptor.height / divider;
RenderTextureDescriptor textureDescriptor = renderingData.cameraData.cameraTargetDescriptor;
textureDescriptor.width = rtW;
textureDescriptor.height = rtH;
textureDescriptor.depthBufferBits = 0;
textureDescriptor.colorFormat = RenderTextureFormat.Default;
if (lrDepthBuffer == null)
{
lrDepthBuffer = new RenderTexture(textureDescriptor);
}
if (lrColorB == null)
{
lrColorB = new RenderTexture(textureDescriptor);
}
// lrDepthBuffer = RenderTexture.GetTemporary(textureDescriptor);
cmd.SetGlobalVector("_BlurRadius4", new Vector4(1.0f, 1.0f, 0.0f, 0.0f) * EnviroSkyMgr.instance.LightShaftsSettings.blurRadius);
cmd.SetGlobalVector("_SunPosition", new Vector4(v.x, v.y, v.z, EnviroSkyMgr.instance.LightShaftsSettings.maxRadius));
cmd.SetGlobalVector("_SunThreshold", treshold);
blitMaterial.SetVector("_BlurRadius4", new Vector4(1.0f, 1.0f, 0.0f, 0.0f) * EnviroSkyMgr.instance.LightShaftsSettings.blurRadius);
blitMaterial.SetVector("_SunPosition", new Vector4(v.x, v.y, v.z, EnviroSkyMgr.instance.LightShaftsSettings.maxRadius));
blitMaterial.SetVector("_SunThreshold", treshold);
RenderTextureDescriptor textureDescriptorSource = renderingData.cameraData.cameraTargetDescriptor;
textureDescriptorSource.graphicsFormat = Experimental.Rendering.GraphicsFormat.R32G32B32A32_SFloat;
textureDescriptorSource.depthBufferBits = 0;
RenderTexture sourceRT = RenderTexture.GetTemporary(textureDescriptorSource);
Blit(cmd, source, sourceRT);
Graphics.Blit(sourceRT, lrDepthBuffer, blitMaterial, 2);
//Blit(cmd, source, lrDepthBuffer, blitMaterial, 2);
// paint a small black small border to get rid of clamping problems
if (myCam.stereoActiveEye == Camera.MonoOrStereoscopicEye.Mono)
{
DrawBorder(lrDepthBuffer, clearMaterial);
}
// radial blur:
radialBlurIterations = Mathf.Clamp(radialBlurIterations, 1, 4);
float ofs = EnviroSkyMgr.instance.LightShaftsSettings.blurRadius * (1.0f / 768.0f);
cmd.SetGlobalVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
cmd.SetGlobalVector("_SunPosition", new Vector4(v.x, v.y, v.z, EnviroSkyMgr.instance.LightShaftsSettings.maxRadius));
blitMaterial.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
blitMaterial.SetVector("_SunPosition", new Vector4(v.x, v.y, v.z, EnviroSkyMgr.instance.LightShaftsSettings.maxRadius));
for (int it2 = 0; it2 < radialBlurIterations; it2++)
{
Graphics.Blit(lrDepthBuffer, lrColorB, blitMaterial, 1);
//Blit(cmd, lrDepthBuffer, lrColorB, blitMaterial, 1);
// RenderTexture.ReleaseTemporary(lrDepthBuffer);
ofs = EnviroSkyMgr.instance.LightShaftsSettings.blurRadius * (((it2 * 2.0f + 1.0f) * 6.0f)) / 768.0f;
cmd.SetGlobalVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
blitMaterial.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
//lrDepthBuffer = RenderTexture.GetTemporary(textureDescriptor);
Graphics.Blit(lrColorB, lrDepthBuffer, blitMaterial, 1);
//Blit(cmd, lrColorB, lrDepthBuffer, blitMaterial, 1);
//RenderTexture.ReleaseTemporary(lrColorB);
ofs = EnviroSkyMgr.instance.LightShaftsSettings.blurRadius * (((it2 * 2.0f + 2.0f) * 6.0f)) / 768.0f;
cmd.SetGlobalVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
blitMaterial.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
}
// put together:
if (v.z >= 0.0f)
{
cmd.SetGlobalVector("_SunColor", new Vector4(clr.r, clr.g, clr.b, clr.a) * EnviroSkyMgr.instance.LightShaftsSettings.intensity);
}
else
{
cmd.SetGlobalVector("_SunColor", Vector4.zero); // no backprojection !
}
//FINAL
// blitMaterial.SetTexture("_ColorBuffer", lrDepthBuffer);
cmd.SetGlobalTexture("_ColorBuffer", lrDepthBuffer);
Blit(cmd, sourceRT, source, blitMaterial, (EnviroSkyMgr.instance.LightShaftsSettings.screenBlendMode == EnviroPostProcessing.ShaftsScreenBlendMode.Screen) ? 0 : 4);
// RenderTexture.ReleaseTemporary(lrDepthBuffer);
RenderTexture.ReleaseTemporary(sourceRT);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (renderingData.cameraData.camera.cameraType == CameraType.Preview || renderingData.cameraData.camera.cameraType == CameraType.Reflection)
{
return;
}
myCam = renderingData.cameraData.camera;
if (EnviroSkyMgr.instance != null && EnviroSky.instance != null && EnviroSkyMgr.instance.useDistanceBlur)
{
if (renderingData.cameraData.isSceneViewCamera && !EnviroSky.instance.showDistanceBlurInEditor)
{
return;
}
var src = renderer.cameraColorTarget;
var dest = UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget;
if (blitPass == null)
{
blitPass = new EnviroDistanceBlurPass(UnityEngine.Rendering.Universal.RenderPassEvent.BeforeRenderingTransparents, postProcessMat, distributionTexture);
}
blitPass.Setup(myCam, src, dest);
renderer.EnqueuePass(blitPass);
}
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (m_Settings.material != null)
{
renderer.EnqueuePass(m_RenderQuadPass);
}
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
var src = renderer.cameraColorTarget;
var dest = (settings.destination == Target.Color) ? UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget : m_RenderTextureHandle;
if (settings.blitMaterial == null)
{
Debug.LogWarningFormat("Missing Blit Material. {0} blit pass will not execute. Check for missing reference in the assigned renderer.", GetType().Name);
return;
}
blitPass.Setup(src, dest);
renderer.EnqueuePass(blitPass);
}
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
SortingCriteria sortingCriteria = (renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings =
CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = overrideMaterial;
drawingSettings.overrideMaterialPassIndex = overrideMaterialPassIndex;
GraphicsFence portalsRenderedFence;
Camera camera = renderingData.cameraData.camera;
float cameraAspect = (float)camera.pixelWidth / (float)camera.pixelHeight;
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingSample(cmd, m_ProfilerTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetRandomWriteTarget(1, portalRenderContext.computeBuffer);
if (m_CameraSettings.overrideCamera)
{
//Matrix4x4 projectionMatrix = Matrix4x4.Perspective(m_CameraSettings.cameraFieldOfView, cameraAspect,
// camera.nearClipPlane, camera.farClipPlane);
//Matrix4x4 viewMatrix = camera.worldToCameraMatrix;
//Vector4 cameraTranslation = viewMatrix.GetColumn(3);
//viewMatrix.SetColumn(3, cameraTranslation + m_CameraSettings.offset);
//cmd.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
portalRenderContext.exitPortal = GameObject.FindGameObjectWithTag("ExitPortal");
Camera exitCam = portalRenderContext.exitPortal.GetComponentInChildren <Camera>();
GameObject entryGO = GameObject.FindGameObjectWithTag("EntryPortal");
//Vector3 normal = exitCam.transform.forward;
//Vector3 pos = exitCam.transform.position;
//Vector4 clipPlaneWorldSpace = new Vector4(normal.x, normal.y, normal.z, -Vector3.Dot(normal, pos));
//Vector4 clipPlaneCameraSpace = exitCam.worldToCameraMatrix * clipPlaneWorldSpace;
Matrix4x4 projectionMatrix = camera.projectionMatrix;//exitCam.CalculateObliqueMatrix(clipPlaneCameraSpace);
Matrix4x4 destView = camera.worldToCameraMatrix * entryGO.transform.localToWorldMatrix
* Matrix4x4.Rotate(entryGO.transform.rotation)
* exitCam.transform.localToWorldMatrix.inverse;
//* glm::rotate(glm::mat4(1.0f), 180.0f, glm::vec3(0.0f, 1.0f, 0.0f) * portal.orientation())
//* glm::inverse(portal.destination()->modelMat());
projectionMatrix = clippedProjMat(destView, projectionMatrix, entryGO.transform.position, entryGO.transform.rotation);
//cmd.Clear();
cmd.SetViewProjectionMatrices(destView, projectionMatrix);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings,
ref m_RenderStateBlock);
//ScriptableCullingParameters param;
//context.Cull()
if (m_CameraSettings.overrideCamera && m_CameraSettings.restoreCamera)
{
Matrix4x4 projectionMatrix = Matrix4x4.Perspective(camera.fieldOfView, cameraAspect,
camera.nearClipPlane, camera.farClipPlane);
cmd.Clear();
cmd.SetViewProjectionMatrices(camera.worldToCameraMatrix, projectionMatrix);
}
//portalsRenderedFence = cmd.CreateGraphicsFence(GraphicsFenceType.CPUSynchronisation,
// SynchronisationStageFlags.PixelProcessing);
//if (PortalDebugRenderOverlay.Instance?.renderTarget)
//{
// PortalDebugRenderOverlay.Instance?.renderTarget = new RenderTexture(depthAttachment)
//}
//PortalDebugRenderOverlay.Instance?.fullscreenOverlay?.mainTexture = this.depthAttachment;
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
//Debug.Log("Fence support:"+ SystemInfo.supportsGraphicsFence);
//while (!portalsRenderedFence.passed) ;
//Int32[] perPortalPixelCount = new Int32[255];
//portalRenderContext.computeBuffer.GetData(perPortalPixelCount, 0, 0, 255);
//for (int i = 0; i < 5; i++)
//{
// Debug.Log(i + "Portal count: " + perPortalPixelCount[i]);
//}
//portalRenderContext.computeBuffer.SetData(new Int32[255]);
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
// Enqueues the render pass for execution. Here you can inject one or more render passes in the renderer
// AddRenderPasses is called everyframe.
if (m_Settings.material != null)
{
renderer.EnqueuePass(m_RenderQuadPass);
}
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
renderer.EnqueuePass(m_GrassDisplacementPass);
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (renderingData.cameraData.camera.cameraType == CameraType.Preview)
{
return;
}
myCam = renderingData.cameraData.camera;
if (EnviroSky.instance != null && EnviroSky.instance.useFog && EnviroSky.instance.PlayerCamera != null)
{
var src = renderer.cameraColorTarget;
var dest = UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget;
if (renderingData.cameraData.isSceneViewCamera && !EnviroSky.instance.showFogInEditor)
{
return;
}
UpdateMatrix();
RenderFog();
if (blitPass == null)
{
Create();
}
blitPass.Setup(src, dest);
renderer.EnqueuePass(blitPass);
}
}
///
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get("Distance Blur");
UpdateMatrix();
// source texture size
var tw = renderingData.cameraData.cameraTargetDescriptor.width;
var th = renderingData.cameraData.cameraTargetDescriptor.height;
// halve the texture size for the low quality mode
if (!EnviroSky.instance.distanceBlurSettings.highQuality)
{
tw /= 2;
th /= 2;
}
blitMaterial.SetTexture("_DistTex", distributionTexture);
blitMaterial.SetFloat("_Distance", EnviroSky.instance.blurDistance);
blitMaterial.SetFloat("_Radius", EnviroSky.instance.distanceBlurSettings.radius);
// determine the iteration count
var logh = Mathf.Log(th, 2) + EnviroSky.instance.distanceBlurSettings.radius - 8;
var logh_i = (int)logh;
var iterations = Mathf.Clamp(logh_i, 1, kMaxIterations);
// update the shader properties
var lthresh = thresholdLinear;
blitMaterial.SetFloat("_Threshold", lthresh);
var knee = lthresh * 0.5f + 1e-5f;
var curve = new Vector3(lthresh - knee, knee * 2, 0.25f / knee);
blitMaterial.SetVector("_Curve", curve);
var pfo = !EnviroSky.instance.distanceBlurSettings.highQuality && EnviroSky.instance.distanceBlurSettings.antiFlicker;
blitMaterial.SetFloat("_PrefilterOffs", pfo ? -0.5f : 0.0f);
blitMaterial.SetFloat("_SampleScale", 0.5f + logh - logh_i);
blitMaterial.SetFloat("_Intensity", EnviroSky.instance.blurIntensity);
blitMaterial.SetFloat("_SkyBlurring", EnviroSky.instance.blurSkyIntensity);
// prefilter pass
RenderTextureDescriptor renderDescriptor = renderingData.cameraData.cameraTargetDescriptor;
renderDescriptor.width = tw;
renderDescriptor.height = th;
renderDescriptor.graphicsFormat = Experimental.Rendering.GraphicsFormat.R32G32B32A32_SFloat;
renderDescriptor.depthBufferBits = 0;
//if (!EnviroSky.instance.singlePassInstancedVR)
// renderDescriptor.vrUsage = VRTextureUsage.None;
var prefiltered = RenderTexture.GetTemporary(renderDescriptor);
var pass = EnviroSky.instance.distanceBlurSettings.antiFlicker ? 1 : 0;
Blit(cmd, source, prefiltered, blitMaterial, pass);
// construct a mip pyramid
var last = prefiltered;
for (var level = 0; level < iterations; level++)
{
RenderTextureDescriptor lastDescriptor = last.descriptor;
lastDescriptor.width = lastDescriptor.width / 2;
lastDescriptor.height = lastDescriptor.height / 2;
_blurBuffer1[level] = RenderTexture.GetTemporary(lastDescriptor);
pass = (level == 0) ? (EnviroSky.instance.distanceBlurSettings.antiFlicker ? 3 : 2) : 4;
Blit(cmd, last, _blurBuffer1[level], blitMaterial, pass);
last = _blurBuffer1[level];
}
// upsample and combine loop
for (var level = iterations - 2; level >= 0; level--)
{
var basetex = _blurBuffer1[level];
blitMaterial.SetTexture("_BaseTex", basetex);
RenderTextureDescriptor baseDescriptor = basetex.descriptor;
_blurBuffer2[level] = RenderTexture.GetTemporary(baseDescriptor);
pass = EnviroSky.instance.distanceBlurSettings.highQuality ? 6 : 5;
Blit(cmd, last, _blurBuffer2[level], blitMaterial, pass);
last = _blurBuffer2[level];
}
// finish process
RenderTexture sourceRT = RenderTexture.GetTemporary(renderDescriptor);
Blit(cmd, source, sourceRT);
blitMaterial.SetTexture("_BaseTex", sourceRT);
cmd.SetGlobalTexture("_BaseTex", sourceRT);
pass = EnviroSky.instance.distanceBlurSettings.highQuality ? 8 : 7;
Blit(cmd, last, source, blitMaterial, pass);
// release the temporary buffers
for (var i = 0; i < kMaxIterations; i++)
{
if (_blurBuffer1[i] != null)
{
RenderTexture.ReleaseTemporary(_blurBuffer1[i]);
}
if (_blurBuffer2[i] != null)
{
RenderTexture.ReleaseTemporary(_blurBuffer2[i]);
}
_blurBuffer1[i] = null;
_blurBuffer2[i] = null;
}
RenderTexture.ReleaseTemporary(prefiltered);
RenderTexture.ReleaseTemporary(sourceRT);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void AddRenderPasses(UnityEngine.Rendering.Universal.ScriptableRenderer renderer, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
{
if (renderingData.cameraData.camera.cameraType == CameraType.Preview)
{
return;
}
myCam = renderingData.cameraData.camera;
if (EnviroSkyLite.instance != null && EnviroSkyLite.instance.usePostEffectFog)
{
var src = renderer.cameraColorTarget;
var dest = UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget;
if (!renderingData.cameraData.isSceneViewCamera && renderingData.cameraData.camera == EnviroSkyLite.instance.PlayerCamera)
{
UpdateMatrix();
if (currentSimpleFog != EnviroSkyLite.instance.fogSettings.useSimpleFog)
{
CreateFogMaterial();
blitPass = new EnviroBlitPass(UnityEngine.Rendering.Universal.RenderPassEvent.BeforeRenderingTransparents, material, 0, name);
currentSimpleFog = EnviroSkyLite.instance.fogSettings.useSimpleFog;
}
RenderFog();
if (blitPass == null)
{
Create();
}
blitPass.Setup(src, dest);
renderer.EnqueuePass(blitPass);
}
}
}
