dev_zjj/3d-gangjiegou
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix:代码提初始化

Browse Source
This commit is contained in:
zhangjiajia
2026-05-08 15:34:53 +08:00
parent af67dcce8c
commit 2540141343
4131 changed files with 1239331 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroHDRPCustomPass.cs Normal file
View File

@@ -0,0 +1,285 @@
#if ENVIRO_HDRP
using UnityEngine;
using System.Collections.Generic;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.Rendering;
using UnityEngine.Experimental.Rendering;
namespace Enviro
{
class EnviroHDRPCustomPass : CustomPass
{
private Material blitTrough;
private List<EnviroVolumetricCloudRenderer> volumetricCloudsRender = new List<EnviroVolumetricCloudRenderer>();
private Vector3 floatingPointOriginMod = Vector3.zero;
private RTHandle sourceHandle;
private RTHandle temp1Handle;
private RTHandle temp2Handle;
protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
{
if (blitTrough == null)
blitTrough = new Material(Shader.Find("Hidden/Enviro/BlitTroughHDRP"));
// We allocate persistent RTHandles dynamically when Execute runs for the first time
sourceHandle = null;
temp1Handle = null;
temp2Handle = null;
}
public RTHandle ReallocateIfNeeded(RTHandle handle, RenderTextureDescriptor desc, string name)
{
bool needsRealloc = handle == null || handle.rt == null;
if (!needsRealloc)
{
var hDesc = handle.rt.descriptor;
// Compare only the format & dimension
if (hDesc.graphicsFormat != desc.graphicsFormat ||
hDesc.dimension != desc.dimension)
{
needsRealloc = true;
}
}
if (needsRealloc)
{
if (handle != null)
RTHandles.Release(handle);
// Allocate with scale = 1, dynamic scaling will adjust automatically
handle = RTHandles.Alloc(
Vector2.one,
colorFormat: desc.graphicsFormat,
dimension: desc.dimension,
enableRandomWrite: false,
useMipMap: desc.useMipMap,
name: name,
useDynamicScale: true
);
}
return handle;
}
protected override void Execute(CustomPassContext ctx)
{
HDCamera camera = ctx.hdCamera;
if (ctx.cameraColorBuffer == null || ctx.cameraColorBuffer.rt == null ||
camera.camera.cameraType == CameraType.Preview ||
!EnviroHelper.CanRenderOnCamera(camera.camera) || EnviroManager.instance == null && EnviroManager.instance.configuration != null)
return;
var desc = ctx.cameraColorBuffer.rt.descriptor;
// Reallocate only if needed
sourceHandle = ReallocateIfNeeded(sourceHandle, desc, "Enviro Source");
temp1Handle = ReallocateIfNeeded(temp1Handle, desc, "Enviro Temp1");
if (EnviroManager.instance.VolumetricClouds != null && EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows)
temp2Handle = ReallocateIfNeeded(temp2Handle, desc, "Enviro Temp2");
// Copy camera buffer to persistent source
HDUtils.BlitCameraTexture(ctx.cmd, ctx.cameraColorBuffer, sourceHandle);
// Get quality and flags
EnviroQuality myQuality = EnviroHelper.GetQualityForCamera(camera.camera);
bool renderVolumetricClouds = EnviroManager.instance.VolumetricClouds != null && myQuality.volumetricCloudsOverride.volumetricClouds;
bool renderFog = EnviroManager.instance.Fog != null && myQuality.fogOverride.fog;
floatingPointOriginMod = EnviroManager.instance.Objects?.worldAnchor != null
? EnviroManager.instance.Objects.worldAnchor.transform.position
: Vector3.zero;
// Ensure clouds renderer exists
if (renderVolumetricClouds && GetCloudsRenderer(camera.camera) == null)
CreateCloudsRenderer(camera.camera);
SetMatrix(camera.camera);
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(camera.camera);
// ----- Depth-aware render logic -----
if (renderVolumetricClouds && renderFog)
{
if (camera.camera.transform.position.y - floatingPointOriginMod.y < EnviroManager.instance.VolumetricClouds.settingsVolume.bottomCloudsHeight)
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera, ctx.cmd, sourceHandle, temp1Handle, renderer, myQuality);
if (EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows &&
camera.camera.cameraType != CameraType.Reflection)
{
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsHDRP(camera.camera, ctx.cmd, temp1Handle, temp2Handle, renderer);
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera, ctx.cmd, temp2Handle, ctx.cameraColorBuffer);
}
else
{
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera, ctx.cmd, temp1Handle, ctx.cameraColorBuffer);
}
}
else
{
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera, ctx.cmd, sourceHandle, temp1Handle);
if (EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows &&
camera.camera.cameraType != CameraType.Reflection)
{
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsHDRP(camera.camera, ctx.cmd, temp1Handle, temp2Handle, renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera, ctx.cmd, temp2Handle, ctx.cameraColorBuffer, renderer, myQuality);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera, ctx.cmd, temp1Handle, ctx.cameraColorBuffer, renderer, myQuality);
}
}
}
else if (renderVolumetricClouds)
{
if (EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows &&
camera.camera.cameraType != CameraType.Reflection)
{
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsHDRP(camera.camera, ctx.cmd, sourceHandle, temp1Handle, renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera, ctx.cmd, temp1Handle, ctx.cameraColorBuffer, renderer, myQuality);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera, ctx.cmd, sourceHandle, ctx.cameraColorBuffer, renderer, myQuality);
}
}
else if (renderFog)
{
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera, ctx.cmd, sourceHandle, ctx.cameraColorBuffer);
}
else
{
// blitTrough.SetTexture("_InputTexture", sourceHandle);
// CoreUtils.SetRenderTarget(ctx.cmd, ctx.cameraColorBuffer, ctx.cameraDepthBuffer, ClearFlag.None);
// HDUtils.DrawFullScreen(ctx.cmd, blitTrough);
}
if (!renderVolumetricClouds)
Shader.SetGlobalTexture("_EnviroClouds", Texture2D.blackTexture);
}
protected override void Cleanup()
{
if (blitTrough != null) CoreUtils.Destroy(blitTrough);
if (sourceHandle != null) RTHandles.Release(sourceHandle);
if (temp1Handle != null) RTHandles.Release(temp1Handle);
if (temp2Handle != null) RTHandles.Release(temp2Handle);
for (int i = 0; i < volumetricCloudsRender.Count; i++)
CleanCloudsRenderer(volumetricCloudsRender[i]);
}
// ---- Cloud renderer helpers -----
private EnviroVolumetricCloudRenderer CreateCloudsRenderer(Camera cam)
{
EnviroVolumetricCloudRenderer r = new EnviroVolumetricCloudRenderer();
r.camera = cam;
volumetricCloudsRender.Add(r);
return r;
}
private void CleanCloudsRenderer(EnviroVolumetricCloudRenderer renderer)
{
if (renderer.fullBuffer != null)
foreach (var b in renderer.fullBuffer) if (b != null) CoreUtils.Destroy(b);
if (renderer.undersampleBuffer != null) CoreUtils.Destroy(renderer.undersampleBuffer);
if (renderer.downsampledDepth != null) CoreUtils.Destroy(renderer.downsampledDepth);
if (renderer.raymarchMat != null) CoreUtils.Destroy(renderer.raymarchMat);
if (renderer.reprojectMat != null) CoreUtils.Destroy(renderer.reprojectMat);
if (renderer.blendAndLightingMat != null) CoreUtils.Destroy(renderer.blendAndLightingMat);
if (renderer.depthMat != null) CoreUtils.Destroy(renderer.depthMat);
if (renderer.shadowMat != null) CoreUtils.Destroy(renderer.shadowMat);
}
private EnviroVolumetricCloudRenderer GetCloudsRenderer(Camera cam)
{
foreach (var r in volumetricCloudsRender)
if (r.camera == cam) return r;
return CreateCloudsRenderer(cam);
}
private void SetMatrix(Camera myCam)
{
#if ENABLE_VR && ENABLE_XR_MODULE
if (UnityEngine.XR.XRSettings.enabled && UnityEngine.XR.XRSettings.stereoRenderingMode == UnityEngine.XR.XRSettings.StereoRenderingMode.SinglePassInstanced)
{
// Both stereo eye inverse view matrices
Matrix4x4 left_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Left).inverse;
Matrix4x4 right_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
// Both stereo eye inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 left_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
Matrix4x4 right_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(left_screen_from_view, true).inverse;
Matrix4x4 right_view_from_screen = GL.GetGPUProjectionMatrix(right_screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
{
left_view_from_screen[1, 1] *= -1;
right_view_from_screen[1, 1] *= -1;
}
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_RightWorldFromView", right_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
Shader.SetGlobalMatrix("_RightViewFromScreen", right_view_from_screen);
}
else
{
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
}
#else
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
#endif
}
}
}
#endif

11
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroHDRPCustomPass.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6e7ac1f0b8835dd49ae0c2334bb590a6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

296
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroHDRPRenderer.cs Normal file
View File

@@ -0,0 +1,296 @@
//Deprecated since 3.3. Please use the custom pass system now!
/*
#if ENVIRO_HDRP
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using System;
using System.Collections.Generic;
namespace Enviro
{
[Serializable, VolumeComponentMenu("Post-processing/Enviro/Effects Renderer (DEPRECATED)")]
public class EnviroHDRPRenderer : CustomPostProcessVolumeComponent, IPostProcessComponent
{
public bool IsActive() => EnviroManager.instance != null;
public override CustomPostProcessInjectionPoint injectionPoint => (CustomPostProcessInjectionPoint)0;
private Material blitTrough;
private List<EnviroVolumetricCloudRenderer> volumetricCloudsRender = new List<EnviroVolumetricCloudRenderer>();
private Vector3 floatingPointOriginMod = Vector3.zero;
public BoolParameter activated = new(value: true);
public override void Setup()
{
if (blitTrough == null)
blitTrough = new Material(Shader.Find("Hidden/Enviro/BlitTroughHDRP"));
}
public override void Cleanup()
{
if (blitTrough != null)
CoreUtils.Destroy(blitTrough);
for(int i = 0; i < volumetricCloudsRender.Count; i++)
{
CleanCloudsRenderer(volumetricCloudsRender[i]);
}
}
public override void Render(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination)
{
//Do nothing
if (activated.value == false || !EnviroHelper.CanRenderOnCamera(camera.camera) || camera.camera.cameraType == CameraType.Preview)
{
blitTrough.SetTexture("_InputTexture", source);
CoreUtils.DrawFullScreen(cmd, blitTrough);
return;
}
if(EnviroHelper.ResetMatrix(camera.camera))
camera.camera.ResetProjectionMatrix();
EnviroQuality myQuality = EnviroHelper.GetQualityForCamera(camera.camera);
//Set what to render on this camera.
bool renderVolumetricClouds = false;
bool renderFog = false;
if(EnviroManager.instance.Quality != null)
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = myQuality.volumetricCloudsOverride.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = myQuality.fogOverride.fog;
}
else
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = EnviroManager.instance.VolumetricClouds.settingsQuality.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = EnviroManager.instance.Fog.Settings.fog;
}
if (EnviroManager.instance.Objects.worldAnchor != null)
floatingPointOriginMod = EnviroManager.instance.Objects.worldAnchor.transform.position;
else
floatingPointOriginMod = Vector3.zero;
if (renderVolumetricClouds)
{
//Create us a volumetric clouds renderer if null.
if(GetCloudsRenderer(camera.camera) == null)
{
CreateCloudsRenderer(camera.camera);
}
}
//Set some global matrixes used for all the enviro effects.
SetMatrix(camera.camera);
//Clouds
if(EnviroManager.instance.Fog != null && EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && renderFog)
{
RenderTexture temp1 = RenderTexture.GetTemporary(source.rt.descriptor);
RTHandle temp1Handle = RTHandles.Alloc(temp1);
if(camera.camera.transform.position.y - floatingPointOriginMod.y < EnviroManager.instance.VolumetricClouds.settingsVolume.bottomCloudsHeight)
{
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(camera.camera);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera,cmd, source, temp1Handle, renderer, myQuality);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && camera.camera.cameraType != CameraType.Reflection)
{
RenderTexture temp2 = RenderTexture.GetTemporary(source.rt.descriptor);
RTHandle temp2Handle = RTHandles.Alloc(temp2);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsHDRP(camera.camera,cmd,temp1Handle,temp2Handle,renderer);
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera,cmd,temp2Handle,destination);
RenderTexture.ReleaseTemporary(temp2);
}
else
{
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera,cmd,temp1Handle,destination);
}
}
else
{
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera,cmd,source,temp1Handle);
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(camera.camera);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && camera.camera.cameraType != CameraType.Reflection)
{
RenderTexture temp2 = RenderTexture.GetTemporary(source.rt.descriptor);
RTHandle temp2Handle = RTHandles.Alloc(temp2);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsHDRP(camera.camera,cmd,temp1Handle,temp2Handle,renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera,cmd, temp2Handle, destination, renderer, myQuality);
RenderTexture.ReleaseTemporary(temp2);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera,cmd, temp1Handle, destination, renderer, myQuality);
}
}
RenderTexture.ReleaseTemporary(temp1);
//temp1Handle.Release();
}
else if(EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && !renderFog)
{
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(camera.camera);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && camera.camera.cameraType != CameraType.Reflection)
{
RenderTexture temp1 = RenderTexture.GetTemporary(source.rt.descriptor);
RTHandle temp1Handle = RTHandles.Alloc(temp1);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsHDRP(camera.camera,cmd,source,temp1Handle,renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera,cmd, temp1Handle, destination, renderer, myQuality);
RenderTexture.ReleaseTemporary(temp1);
//temp1Handle.Release();
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsHDRP(camera.camera,cmd, source, destination, renderer, myQuality);
}
}
else if (Enviro.EnviroManager.instance.Fog != null && renderFog)
{
EnviroManager.instance.Fog.RenderHeightFogHDRP(camera.camera,cmd,source,destination);
}
else
{
blitTrough.SetTexture("_InputTexture", source);
CoreUtils.DrawFullScreen(cmd, blitTrough);
}
if(!renderVolumetricClouds)
Shader.SetGlobalTexture("_EnviroClouds", Texture2D.blackTexture);
}
private EnviroVolumetricCloudRenderer CreateCloudsRenderer(Camera cam)
{
EnviroVolumetricCloudRenderer r = new EnviroVolumetricCloudRenderer();
r.camera = cam;
volumetricCloudsRender.Add(r);
return r;
}
private void CleanCloudsRenderer(EnviroVolumetricCloudRenderer renderer)
{
if (renderer.fullBuffer != null)
{
for (int i = 0; i < renderer.fullBuffer.Length; i++)
{
if (renderer.fullBuffer[i] != null)
{
CoreUtils.Destroy(renderer.fullBuffer[i]);
}
}
}
if (renderer.undersampleBuffer)
{
CoreUtils.Destroy(renderer.undersampleBuffer);
}
if (renderer.downsampledDepth)
{
CoreUtils.Destroy(renderer.downsampledDepth);
}
if(renderer.raymarchMat != null)
CoreUtils.Destroy(renderer.raymarchMat);
if(renderer.reprojectMat != null)
CoreUtils.Destroy(renderer.reprojectMat);
if(renderer.blendAndLightingMat != null)
CoreUtils.Destroy(renderer.blendAndLightingMat);
if(renderer.depthMat != null)
CoreUtils.Destroy (renderer.depthMat);
if(renderer.shadowMat != null)
CoreUtils.Destroy (renderer.shadowMat);
}
private EnviroVolumetricCloudRenderer GetCloudsRenderer(Camera cam)
{
for (int i = 0; i < volumetricCloudsRender.Count; i++)
{
if(volumetricCloudsRender[i].camera == cam)
return volumetricCloudsRender[i];
}
return CreateCloudsRenderer(cam);
}
private void SetMatrix(Camera myCam)
{
#if ENABLE_VR && ENABLE_XR_MODULE
if (UnityEngine.XR.XRSettings.enabled && UnityEngine.XR.XRSettings.stereoRenderingMode == UnityEngine.XR.XRSettings.StereoRenderingMode.SinglePassInstanced)
{
// Both stereo eye inverse view matrices
Matrix4x4 left_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Left).inverse;
Matrix4x4 right_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
// Both stereo eye inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 left_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
Matrix4x4 right_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(left_screen_from_view, true).inverse;
Matrix4x4 right_view_from_screen = GL.GetGPUProjectionMatrix(right_screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
{
left_view_from_screen[1, 1] *= -1;
right_view_from_screen[1, 1] *= -1;
}
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_RightWorldFromView", right_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
Shader.SetGlobalMatrix("_RightViewFromScreen", right_view_from_screen);
}
else
{
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
}
#else
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
#endif
}
}
}
#endif
*/

18
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroHDRPRenderer.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: c2f1f84926178344e86b6d5fe65e258f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 236601
packageName: Enviro 3 - Sky and Weather
packageVersion: 3.2.2
assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroHDRPRenderer.cs
uploadId: 766468

235
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroRenderer.cs Normal file
View File

@@ -0,0 +1,235 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Enviro
{
[ExecuteInEditMode]
[ImageEffectAllowedInSceneView]
public class EnviroRenderer : MonoBehaviour
{
[Tooltip("Assign a quality here if you want to use different settings for this camera. Otherwise it takes settings from Enviro Manager.")]
private EnviroQuality myQuality;
private Camera myCam;
private EnviroVolumetricCloudRenderer volumetricCloudsRender;
private Vector3 floatingPointOriginMod = Vector3.zero;
void OnEnable()
{
myCam = GetComponent<Camera>();
//Disable this component in URP and HDRP.
#if ENVIRO_HDRP || ENVIRO_URP
this.enabled = false;
#endif
}
void OnDisable ()
{
CleanupVolumetricRenderer();
}
private void CleanupVolumetricRenderer()
{
if(volumetricCloudsRender != null)
{
if(volumetricCloudsRender.raymarchMat != null)
DestroyImmediate(volumetricCloudsRender.raymarchMat);
if(volumetricCloudsRender.blendAndLightingMat != null)
DestroyImmediate(volumetricCloudsRender.blendAndLightingMat);
if(volumetricCloudsRender.reprojectMat != null)
DestroyImmediate(volumetricCloudsRender.reprojectMat);
if(volumetricCloudsRender.undersampleBuffer != null)
DestroyImmediate(volumetricCloudsRender.undersampleBuffer);
if(volumetricCloudsRender.fullBuffer != null && volumetricCloudsRender.fullBuffer.Length > 0)
{
for (int i = 0; i < volumetricCloudsRender.fullBuffer.Length; i++)
{
if(volumetricCloudsRender.fullBuffer[i] != null)
DestroyImmediate(volumetricCloudsRender.fullBuffer[i]);
}
}
}
}
private void SetMatrix()
{
if (myCam.stereoEnabled)
{
// Both stereo eye inverse view matrices
Matrix4x4 left_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Left).inverse;
Matrix4x4 right_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
// Both stereo eye inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 left_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
Matrix4x4 right_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(left_screen_from_view, true).inverse;
Matrix4x4 right_view_from_screen = GL.GetGPUProjectionMatrix(right_screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
{
left_view_from_screen[1, 1] *= -1;
right_view_from_screen[1, 1] *= -1;
}
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_RightWorldFromView", right_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
Shader.SetGlobalMatrix("_RightViewFromScreen", right_view_from_screen);
}
else
{
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
// Store matrices
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
}
}
private void Update()
{
}
[ImageEffectOpaque]
private void OnRenderImage(RenderTexture src, RenderTexture dest)
{
if(EnviroManager.instance == null)
{
Graphics.Blit(src,dest);
return;
}
if(myCam == null)
myCam = GetComponent<Camera>();
if (myCam.actualRenderingPath == RenderingPath.Forward)
myCam.depthTextureMode |= DepthTextureMode.Depth;
if(EnviroHelper.ResetMatrix(myCam))
myCam.ResetProjectionMatrix();
myQuality = EnviroHelper.GetQualityForCamera(myCam);
//Set what to render on this camera.
bool renderVolumetricClouds = false;
bool renderFog = false;
if(EnviroManager.instance.Quality != null)
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = myQuality.volumetricCloudsOverride.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = myQuality.fogOverride.fog;
}
else
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = EnviroManager.instance.VolumetricClouds.settingsQuality.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = EnviroManager.instance.Fog.Settings.fog;
}
if (EnviroManager.instance.Objects.worldAnchor != null)
floatingPointOriginMod = EnviroManager.instance.Objects.worldAnchor.transform.position;
else
floatingPointOriginMod = Vector3.zero;
////////Rendering//////////
SetMatrix();
if(volumetricCloudsRender == null)
volumetricCloudsRender = new EnviroVolumetricCloudRenderer();
volumetricCloudsRender.camera = myCam;
//Render volumetrics mask first
if(EnviroManager.instance.Fog != null && renderFog)
EnviroManager.instance.Fog.RenderVolumetrics(myCam, src);
if(EnviroManager.instance.Fog != null && EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && renderFog)
{
//Change the order of clouds and fog
RenderTexture temp = RenderTexture.GetTemporary(src.descriptor);
RenderTexture temp2 = RenderTexture.GetTemporary(src.descriptor);
if(myCam.transform.position.y - floatingPointOriginMod.y < EnviroManager.instance.VolumetricClouds.settingsVolume.bottomCloudsHeight)
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricClouds(myCam, src, temp, volumetricCloudsRender, myQuality);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && myCam.cameraType != CameraType.Reflection)
{
EnviroManager.instance.VolumetricClouds.RenderCloudsShadows(temp,temp2,volumetricCloudsRender);
EnviroManager.instance.Fog.RenderHeightFog(myCam,temp2,dest);
}
else
{
EnviroManager.instance.Fog.RenderHeightFog(myCam,temp,dest);
}
}
else
{
EnviroManager.instance.Fog.RenderHeightFog(myCam,src,temp);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && myCam.cameraType != CameraType.Reflection)
{
EnviroManager.instance.VolumetricClouds.RenderCloudsShadows(temp,temp2,volumetricCloudsRender);
EnviroManager.instance.VolumetricClouds.RenderVolumetricClouds(myCam,temp2,dest,volumetricCloudsRender,myQuality);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricClouds(myCam,temp,dest,volumetricCloudsRender,myQuality);
}
}
RenderTexture.ReleaseTemporary(temp);
RenderTexture.ReleaseTemporary(temp2);
}
else if(EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && !renderFog)
{
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && myCam.cameraType != CameraType.Reflection)
{
RenderTexture temp = RenderTexture.GetTemporary(src.descriptor);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadows(src,temp,volumetricCloudsRender);
EnviroManager.instance.VolumetricClouds.RenderVolumetricClouds(myCam,temp,dest,volumetricCloudsRender, myQuality);
RenderTexture.ReleaseTemporary(temp);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricClouds(myCam,src,dest,volumetricCloudsRender, myQuality);
}
}
else if (Enviro.EnviroManager.instance.Fog != null && renderFog)
{
EnviroManager.instance.Fog.RenderHeightFog(myCam,src,dest);
}
else
{
Graphics.Blit(src,dest);
}
if(!renderVolumetricClouds)
Shader.SetGlobalTexture("_EnviroClouds", Texture2D.blackTexture);
}
}
}

18
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroRenderer.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: bfd6cec7710802146be56bb22888bf57
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 236601
packageName: Enviro 3 - Sky and Weather
packageVersion: 3.1.2
assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroRenderer.cs
uploadId: 660896

68
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderFeature.cs Normal file
View File

@@ -0,0 +1,68 @@
#if ENVIRO_URP
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering.Universal;
namespace Enviro
{
public class EnviroURPRenderFeature : ScriptableRendererFeature
{
#if UNITY_6000_0_OR_NEWER
private EnviroURPRenderGraph graph;
private EnviroURPRenderPass pass;
public override void Create()
{
// if(UnityEngine.Rendering.GraphicsSettings.GetRenderPipelineSettings< UnityEngine.Rendering.Universal.RenderGraphSettings>().enableRenderCompatibilityMode)
pass = new EnviroURPRenderPass("Enviro Render Pass");
graph = new EnviroURPRenderGraph();
graph.renderPassEvent = RenderPassEvent.BeforeRenderingTransparents;
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
if(UnityEngine.Rendering.GraphicsSettings.GetRenderPipelineSettings< UnityEngine.Rendering.Universal.RenderGraphSettings>().enableRenderCompatibilityMode)
{
if(pass != null && EnviroHelper.CanRenderOnCamera(renderingData.cameraData.camera))
{
pass.scriptableRenderer = renderer;
renderer.EnqueuePass(pass);
}
}
else
{
if(graph != null && EnviroHelper.CanRenderOnCamera(renderingData.cameraData.camera))
{
renderer.EnqueuePass(graph);
}
}
}
#else
private EnviroURPRenderPass pass;
public override void Create()
{
pass = new EnviroURPRenderPass("Enviro Render Pass");
}
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
if(pass != null && EnviroHelper.CanRenderOnCamera(renderingData.cameraData.camera))
{
pass.scriptableRenderer = renderer;
renderer.EnqueuePass(pass);
}
}
#endif
}
}
#endif

18
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderFeature.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: f5beaef983462df4a944c521f9064a91
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 236601
packageName: Enviro 3 - Sky and Weather
packageVersion: 3.1.2
assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderFeature.cs
uploadId: 660896

359
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderGraph.cs Normal file
View File

@@ -0,0 +1,359 @@
#if ENVIRO_URP && UNITY_6000_0_OR_NEWER
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RenderGraphModule;
namespace Enviro {
public class EnviroURPRenderGraph : ScriptableRenderPass
{
public class PassData
{
internal TextureHandle src;
internal TextureHandle target;
internal TextureHandle read1;
internal TextureHandle read2;
internal Vector4 scaleBias;
internal string srcName;
internal string read1Name;
internal string read2Name;
internal int pass;
internal Material material;
}
private Vector4 m_ScaleBias = new Vector4(1f, 1f, 0f, 0f);
private List<EnviroVolumetricCloudRenderer> volumetricCloudsRender = new List<EnviroVolumetricCloudRenderer>();
private Material blitThroughMat, fogMat;
private Vector3 floatingPointOriginMod = Vector3.zero;
private EnviroVolumetricCloudRenderer CreateCloudsRenderer(Camera cam)
{
EnviroVolumetricCloudRenderer r = new EnviroVolumetricCloudRenderer();
r.camera = cam;
volumetricCloudsRender.Add(r);
return r;
}
private EnviroVolumetricCloudRenderer GetCloudsRenderer(Camera cam)
{
for (int i = 0; i < volumetricCloudsRender.Count; i++)
{
if(volumetricCloudsRender[i].camera == cam)
return volumetricCloudsRender[i];
}
return CreateCloudsRenderer(cam);
}
public void Blit (string passName, RenderGraph renderGraph, Material mat, TextureHandle src, TextureHandle target, int pass)
{
using (var builder = renderGraph.AddRasterRenderPass<PassData>(passName, out var passData))
{
passData.src = src;
passData.target = target;
passData.material = mat;
passData.pass = pass;
passData.scaleBias = m_ScaleBias;
passData.srcName = "_MainTex";
builder.UseTexture(passData.src,AccessFlags.Read);
builder.SetRenderAttachment(passData.target, 0);
//builder.AllowPassCulling(false);
builder.SetRenderFunc((PassData data, RasterGraphContext context) =>
{
if(data.src.IsValid())
data.material.SetTexture(data.srcName, data.src);
Blitter.BlitTexture(context.cmd, data.scaleBias, data.material, data.pass);
});
}
}
public void Blit (string passName, RenderGraph renderGraph, Material mat, TextureHandle src, TextureHandle target, int pass, TextureHandle read1, string read1Name)
{
using (var builder = renderGraph.AddRasterRenderPass<PassData>(passName, out var passData))
{
passData.src = src;
passData.target = target;
passData.read1 = read1;
passData.read1Name = read1Name;
passData.material = mat;
passData.pass = pass;
passData.scaleBias = m_ScaleBias;
passData.srcName = "_MainTex";
builder.UseTexture(passData.src,AccessFlags.Read);
builder.UseTexture(passData.read1,AccessFlags.Read);
//builder.SetInputAttachment(read1,0);
builder.SetRenderAttachment(passData.target, 0);
//builder.AllowPassCulling(false);
builder.SetRenderFunc((PassData data, RasterGraphContext context) =>
{
if(data.src.IsValid())
data.material.SetTexture(data.srcName, data.src);
if(data.read1.IsValid())
data.material.SetTexture(data.read1Name, data.read1);
Blitter.BlitTexture(context.cmd,data.scaleBias, data.material, data.pass);
});
}
}
public void Blit (string passName, RenderGraph renderGraph, Material mat, TextureHandle src, TextureHandle target, int pass,TextureHandle read1, string read1Name,TextureHandle read2, string read2Name)
{
using (var builder = renderGraph.AddRasterRenderPass<PassData>(passName, out var passData))
{
passData.src = src;
passData.target = target;
passData.read1 = read1;
passData.read1Name = read1Name;
passData.read2 = read2;
passData.read2Name = read2Name;
passData.material = mat;
passData.pass = pass;
passData.scaleBias = m_ScaleBias;
passData.srcName = "_MainTex";
builder.UseTexture(passData.src,AccessFlags.Read);
builder.UseTexture(passData.read1,AccessFlags.Read);
builder.UseTexture(passData.read2,AccessFlags.Read);
//builder.SetInputAttachment(read1,0);
builder.SetRenderAttachment(passData.target, 0);
//builder.AllowPassCulling(false);
builder.SetRenderFunc((PassData data, RasterGraphContext context) =>
{
if(data.src.IsValid())
data.material.SetTexture(data.srcName, data.src);
if(data.read1.IsValid())
data.material.SetTexture(data.read1Name, data.read1);
if(data.read2.IsValid())
data.material.SetTexture(data.read2Name, data.read2);
Blitter.BlitTexture(context.cmd, data.scaleBias, data.material, data.pass);
});
}
}
private void SetMatrix(Camera myCam)
{
#if ENABLE_VR || ENABLE_XR_MODULE
if (UnityEngine.XR.XRSettings.enabled && UnityEngine.XR.XRSettings.stereoRenderingMode == UnityEngine.XR.XRSettings.StereoRenderingMode.SinglePassInstanced && myCam.stereoEnabled)
{
// Both stereo eye inverse view matrices
Matrix4x4 left_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Left).inverse;
Matrix4x4 right_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
// Both stereo eye inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 left_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
Matrix4x4 right_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(left_screen_from_view, true).inverse;
Matrix4x4 right_view_from_screen = GL.GetGPUProjectionMatrix(right_screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
{
left_view_from_screen[1, 1] *= -1;
right_view_from_screen[1, 1] *= -1;
}
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_RightWorldFromView", right_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
Shader.SetGlobalMatrix("_RightViewFromScreen", right_view_from_screen);
}
else
{
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
}
#else
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
#endif
}
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
{
if(EnviroManager.instance == null)
return;
UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
if(EnviroHelper.ResetMatrix(cameraData.camera))
cameraData.camera.ResetProjectionMatrix();
EnviroQuality myQuality = EnviroHelper.GetQualityForCamera(cameraData.camera);
//Set what to render on this camera.
bool renderVolumetricClouds = false;
bool renderFog = false;
if(EnviroManager.instance.Quality != null)
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = myQuality.volumetricCloudsOverride.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = myQuality.fogOverride.fog;
}
else
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = EnviroManager.instance.VolumetricClouds.settingsQuality.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = EnviroManager.instance.Fog.Settings.fog;
}
if (EnviroManager.instance.Objects.worldAnchor != null)
floatingPointOriginMod = EnviroManager.instance.Objects.worldAnchor.transform.position;
else
floatingPointOriginMod = Vector3.zero;
//Set some global matrixes used for all the enviro effects.
SetMatrix(cameraData.camera);
RenderTextureDescriptor desc = cameraData.cameraTargetDescriptor;
desc.colorFormat = RenderTextureFormat.ARGBHalf;
desc.msaaSamples = 1;
desc.depthBufferBits = 0;
TextureHandle source = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, "CopyTexture", false);
TextureHandle target = resourceData.activeColorTexture;
if(blitThroughMat == null)
blitThroughMat = new Material(Shader.Find("Hidden/EnviroBlitThroughURP17"));
// This check is to avoid an error from the material preview in the scene
if (!target.IsValid() || !source.IsValid())
return;
//Blit Main Texture
using ( var builder = renderGraph.AddRasterRenderPass<PassData>("Enviro 3 Copy Texture", out var passData))
{
passData.src = target;
passData.target = source;
passData.material = blitThroughMat;
passData.scaleBias = m_ScaleBias;
builder.UseTexture(passData.src);
builder.SetRenderAttachment(passData.target, 0);
builder.SetRenderFunc((PassData data, RasterGraphContext context) =>
{
data.material.SetTexture("_MainTex", data.src);
Blitter.BlitTexture(context.cmd, data.scaleBias, data.material, 0);
});
}
//Render volumetrics mask first
if(EnviroManager.instance.Fog != null && renderFog)
EnviroManager.instance.Fog.RenderVolumetricsURP(this,renderGraph,resourceData,cameraData,source);
if(EnviroManager.instance.Fog != null && EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && renderFog)
{
TextureHandle temp1 = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, "Temp1", false);
if(cameraData.camera.transform.position.y - floatingPointOriginMod.y < EnviroManager.instance.VolumetricClouds.settingsVolume.bottomCloudsHeight)
{
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(cameraData.camera);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(this,renderGraph, resourceData, cameraData,source,temp1, renderer, myQuality);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && cameraData.camera.cameraType != CameraType.Reflection)
{
TextureHandle temp2 = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, "Temp2", false);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsURP(this,renderGraph, resourceData, cameraData,temp1,temp2, renderer);
EnviroManager.instance.Fog.RenderHeightFogURP(this, renderGraph,resourceData,cameraData,temp2,resourceData.activeColorTexture);
}
else
{
EnviroManager.instance.Fog.RenderHeightFogURP(this, renderGraph,resourceData,cameraData,temp1,resourceData.activeColorTexture);
}
}
else
{
EnviroManager.instance.Fog.RenderHeightFogURP(this, renderGraph,resourceData,cameraData,source,temp1);
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(cameraData.camera);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && cameraData.camera.cameraType != CameraType.Reflection)
{
TextureHandle temp2 = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, "Temp2", false);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsURP(this,renderGraph, resourceData, cameraData,temp1,temp2, renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(this,renderGraph, resourceData, cameraData,temp2,resourceData.activeColorTexture, renderer, myQuality);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(this,renderGraph, resourceData, cameraData,temp1,resourceData.activeColorTexture, renderer, myQuality);
}
}
}
else if(EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && !renderFog)
{
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(cameraData.camera);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && cameraData.camera.cameraType != CameraType.Reflection)
{
TextureHandle temp1 = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, "Temp1", false);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsURP(this,renderGraph, resourceData, cameraData,source,temp1, renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(this,renderGraph, resourceData, cameraData,temp1,resourceData.activeColorTexture, renderer, myQuality);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(this,renderGraph, resourceData, cameraData,source,resourceData.activeColorTexture, renderer, myQuality);
}
}
else if (EnviroManager.instance.Fog != null && renderFog)
{
EnviroManager.instance.Fog.RenderHeightFogURP(this, renderGraph,resourceData,cameraData,source,resourceData.activeColorTexture);
}
else
{
}
}
}
}
#endif

18
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderGraph.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 193b426f7fef4dc459bfc73b17a3b4d6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 236601
packageName: Enviro 3 - Sky and Weather
packageVersion: 3.1.6b
assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderGraph.cs
uploadId: 680182

306
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderPass.cs Normal file
View File

@@ -0,0 +1,306 @@
#if ENVIRO_URP
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.Rendering;
namespace Enviro
{
public class EnviroURPRenderPass : ScriptableRenderPass
{
public ScriptableRenderer scriptableRenderer { get; set; }
private Material blitThroughMat;
private string pName;
private List<EnviroVolumetricCloudRenderer> volumetricCloudsRender = new List<EnviroVolumetricCloudRenderer>();
private Vector3 floatingPointOriginMod = Vector3.zero;
public EnviroURPRenderPass (string name)
{
renderPassEvent = RenderPassEvent.BeforeRenderingTransparents - 1;
pName = name;
}
public void CustomBlit(CommandBuffer cmd,Matrix4x4 matrix, RenderTargetIdentifier source, RenderTargetIdentifier target, Material mat, int pass)
{
cmd.SetGlobalTexture("_MainTex", source);
cmd.SetRenderTarget(target, 0, CubemapFace.Unknown, -1);
cmd.DrawMesh(RenderingUtils.fullscreenMesh, matrix, mat,0, pass);
}
public void CustomBlit(CommandBuffer cmd,Matrix4x4 matrix, RenderTargetIdentifier source, RenderTargetIdentifier target, Material mat)
{
cmd.SetGlobalTexture("_MainTex", source);
cmd.SetRenderTarget(target, 0, CubemapFace.Unknown, -1);
cmd.DrawMesh(RenderingUtils.fullscreenMesh, matrix, mat,0);
}
public void CustomBlit(CommandBuffer cmd,Matrix4x4 matrix, RenderTargetIdentifier source, RenderTargetIdentifier target)
{
if(blitThroughMat == null)
blitThroughMat = new Material(Shader.Find("Hidden/EnviroBlitThrough"));
cmd.SetGlobalTexture("_MainTex", source);
cmd.SetRenderTarget(target, 0, CubemapFace.Unknown, -1);
cmd.DrawMesh(RenderingUtils.fullscreenMesh, matrix, blitThroughMat);
}
#if UNITY_2022_3_OR_NEWER
public void CustomBlit(CommandBuffer cmd,RTHandle source, RTHandle target, Material mat)
{
Blitter.BlitCameraTexture(cmd,source,target,mat,0);
}
public void CustomBlit(CommandBuffer cmd,RTHandle source, RTHandle target, Material mat, int pass)
{
Blitter.BlitCameraTexture(cmd,source,target,mat,pass);
}
public void CustomBlit(CommandBuffer cmd,RTHandle source, RTHandle target)
{
Blitter.BlitCameraTexture(cmd,source,target);
}
#endif
#if UNITY_6000_0_OR_NEWER
[System.Obsolete]
#endif
public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
{
#if UNITY_2022_3_OR_NEWER
ConfigureTarget(scriptableRenderer.cameraColorTargetHandle);
#else
ConfigureTarget(scriptableRenderer.cameraColorTarget);
#endif
ConfigureInput(ScriptableRenderPassInput.Depth);
}
#if UNITY_6000_0_OR_NEWER
[System.Obsolete]
#endif
public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
{
if(GetCloudsRenderer(renderingData.cameraData.camera) == null)
{
CreateCloudsRenderer(renderingData.cameraData.camera);
}
}
private EnviroVolumetricCloudRenderer CreateCloudsRenderer(Camera cam)
{
EnviroVolumetricCloudRenderer r = new EnviroVolumetricCloudRenderer();
r.camera = cam;
volumetricCloudsRender.Add(r);
return r;
}
private EnviroVolumetricCloudRenderer GetCloudsRenderer(Camera cam)
{
for (int i = 0; i < volumetricCloudsRender.Count; i++)
{
if(volumetricCloudsRender[i].camera == cam)
return volumetricCloudsRender[i];
}
return CreateCloudsRenderer(cam);
}
private void SetMatrix(Camera myCam)
{
#if ENABLE_VR || ENABLE_XR_MODULE
if (UnityEngine.XR.XRSettings.enabled && UnityEngine.XR.XRSettings.stereoRenderingMode == UnityEngine.XR.XRSettings.StereoRenderingMode.SinglePassInstanced && myCam.stereoEnabled)
{
// Both stereo eye inverse view matrices
Matrix4x4 left_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Left).inverse;
Matrix4x4 right_world_from_view = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
// Both stereo eye inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 left_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
Matrix4x4 right_screen_from_view = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(left_screen_from_view, true).inverse;
Matrix4x4 right_view_from_screen = GL.GetGPUProjectionMatrix(right_screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
{
left_view_from_screen[1, 1] *= -1;
right_view_from_screen[1, 1] *= -1;
}
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_RightWorldFromView", right_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
Shader.SetGlobalMatrix("_RightViewFromScreen", right_view_from_screen);
}
else
{
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
}
#else
// Main eye inverse view matrix
Matrix4x4 left_world_from_view = myCam.cameraToWorldMatrix;
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
Matrix4x4 screen_from_view = myCam.projectionMatrix;
Matrix4x4 left_view_from_screen = GL.GetGPUProjectionMatrix(screen_from_view, true).inverse;
// Negate [1,1] to reflect Unity's CBuffer state
if (SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLCore && SystemInfo.graphicsDeviceType != UnityEngine.Rendering.GraphicsDeviceType.OpenGLES3)
left_view_from_screen[1, 1] *= -1;
Shader.SetGlobalMatrix("_LeftWorldFromView", left_world_from_view);
Shader.SetGlobalMatrix("_LeftViewFromScreen", left_view_from_screen);
#endif
}
#if UNITY_6000_0_OR_NEWER
[System.Obsolete]
#endif
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if(EnviroManager.instance == null)
return;
CommandBuffer cmd = CommandBufferPool.Get(pName);
if(EnviroHelper.ResetMatrix(renderingData.cameraData.camera))
renderingData.cameraData.camera.ResetProjectionMatrix();
EnviroQuality myQuality = EnviroHelper.GetQualityForCamera(renderingData.cameraData.camera);
//Set what to render on this camera.
bool renderVolumetricClouds = false;
bool renderFog = false;
if(EnviroManager.instance.Quality != null)
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = myQuality.volumetricCloudsOverride.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = myQuality.fogOverride.fog;
}
else
{
if(EnviroManager.instance.VolumetricClouds != null)
renderVolumetricClouds = EnviroManager.instance.VolumetricClouds.settingsQuality.volumetricClouds;
if(EnviroManager.instance.Fog != null)
renderFog = EnviroManager.instance.Fog.Settings.fog;
}
if (EnviroManager.instance.Objects.worldAnchor != null)
floatingPointOriginMod = EnviroManager.instance.Objects.worldAnchor.transform.position;
else
floatingPointOriginMod = Vector3.zero;
//Set some global matrixes used for all the enviro effects.
SetMatrix(renderingData.cameraData.camera);
//Create temporary texture and blit the camera content.
RenderTexture sourceTemp = RenderTexture.GetTemporary(renderingData.cameraData.cameraTargetDescriptor);
#if UNITY_2022_3_OR_NEWER
RenderTargetIdentifier cameraColorTarget = scriptableRenderer.cameraColorTargetHandle.nameID;
#else
RenderTargetIdentifier cameraColorTarget = scriptableRenderer.cameraColorTarget;
#endif
CustomBlit(cmd, Matrix4x4.identity,cameraColorTarget, new RenderTargetIdentifier(sourceTemp));
//Render volumetrics mask first
if(EnviroManager.instance.Fog != null && renderFog)
EnviroManager.instance.Fog.RenderVolumetricsURP(renderingData.cameraData.camera,this,cmd,sourceTemp);
if(EnviroManager.instance.Fog != null && EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && renderFog)
{
RenderTexture temp1 = RenderTexture.GetTemporary(renderingData.cameraData.cameraTargetDescriptor);
if(renderingData.cameraData.camera.transform.position.y - floatingPointOriginMod.y < EnviroManager.instance.VolumetricClouds.settingsVolume.bottomCloudsHeight)
{
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(renderingData.cameraData.camera);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(renderingData,this,cmd, sourceTemp, temp1, renderer, myQuality);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && renderingData.cameraData.camera.cameraType != CameraType.Reflection)
{
RenderTexture temp2 = RenderTexture.GetTemporary(renderingData.cameraData.cameraTargetDescriptor);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsURP(this,renderingData.cameraData.camera,cmd,temp1,temp2,renderer);
EnviroManager.instance.Fog.RenderHeightFogURP(renderingData.cameraData.camera,this,cmd,temp2,cameraColorTarget);
RenderTexture.ReleaseTemporary(temp2);
}
else
{
EnviroManager.instance.Fog.RenderHeightFogURP(renderingData.cameraData.camera,this,cmd,temp1,cameraColorTarget);
}
}
else
{
EnviroManager.instance.Fog.RenderHeightFogURP(renderingData.cameraData.camera,this,cmd,sourceTemp,temp1);
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(renderingData.cameraData.camera);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && renderingData.cameraData.camera.cameraType != CameraType.Reflection)
{
RenderTexture temp2 = RenderTexture.GetTemporary(renderingData.cameraData.cameraTargetDescriptor);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsURP(this,renderingData.cameraData.camera,cmd,temp1,temp2,renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(renderingData,this,cmd, temp2, cameraColorTarget, renderer, myQuality);
RenderTexture.ReleaseTemporary(temp2);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(renderingData,this,cmd, temp1, cameraColorTarget, renderer, myQuality);
}
}
context.ExecuteCommandBuffer(cmd);
RenderTexture.ReleaseTemporary(temp1);
}
else if(EnviroManager.instance.VolumetricClouds != null && renderVolumetricClouds && !renderFog)
{
EnviroVolumetricCloudRenderer renderer = GetCloudsRenderer(renderingData.cameraData.camera);
if(EnviroManager.instance.VolumetricClouds.settingsGlobal.cloudShadows && renderingData.cameraData.camera.cameraType != CameraType.Reflection)
{
RenderTexture temp1 = RenderTexture.GetTemporary(renderingData.cameraData.cameraTargetDescriptor);
EnviroManager.instance.VolumetricClouds.RenderCloudsShadowsURP(this,renderingData.cameraData.camera,cmd,sourceTemp,temp1,renderer);
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(renderingData,this,cmd, temp1, cameraColorTarget, renderer, myQuality);
RenderTexture.ReleaseTemporary(temp1);
}
else
{
EnviroManager.instance.VolumetricClouds.RenderVolumetricCloudsURP(renderingData,this,cmd, sourceTemp, cameraColorTarget, renderer, myQuality);
}
context.ExecuteCommandBuffer(cmd);
}
else if (Enviro.EnviroManager.instance.Fog != null && renderFog)
{
EnviroManager.instance.Fog.RenderHeightFogURP(renderingData.cameraData.camera,this,cmd,sourceTemp,cameraColorTarget);
context.ExecuteCommandBuffer(cmd);
}
else
{
//Render Nothing
}
if(!renderVolumetricClouds)
Shader.SetGlobalTexture("_EnviroClouds", Texture2D.blackTexture);
//Release source temp render texture
CommandBufferPool.Release(cmd);
RenderTexture.ReleaseTemporary(sourceTemp);
}
}
}
#endif

18
Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderPass.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 292862f9353b76e49b5f983de89d59b4
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 236601
packageName: Enviro 3 - Sky and Weather
packageVersion: 3.1.2
assetPath: Assets/Enviro 3 - Sky and Weather/Scripts/Runtime/Base/Renderer/EnviroURPRenderPass.cs
uploadId: 660896