Readd missing import files
This commit is contained in:
Lucien
+658
@@ -0,0 +1,658 @@
|
||||
#if ENVIRO_LWRP && ENVIRO_HD
|
||||
|
||||
namespace UnityEngine.Rendering.LWRP
|
||||
{
|
||||
/// <summary>
|
||||
/// Copy the given color buffer to the given destination color buffer.
|
||||
///
|
||||
/// You can use this pass to copy a color buffer to the destination,
|
||||
/// so you can use it later in rendering. For example, you can copy
|
||||
/// the opaque texture to use it for distortion effects.
|
||||
/// </summary>
|
||||
internal class EnviroBlitPassVolumeClouds : UnityEngine.Rendering.Universal.ScriptableRenderPass
|
||||
{
|
||||
|
||||
private Camera myCam;
|
||||
|
||||
public Material cloudsMat = null;
|
||||
public Material blitMat = null;
|
||||
private Material compose;
|
||||
private Material downsample;
|
||||
|
||||
public FilterMode filterMode { get; set; }
|
||||
|
||||
private RenderTargetIdentifier source { get; set; }
|
||||
private UnityEngine.Rendering.Universal.RenderTargetHandle destination { get; set; }
|
||||
|
||||
|
||||
#region Clouds Var
|
||||
private EnviroHaltonSequence sequence = new EnviroHaltonSequence() { radix = 3 };
|
||||
private RenderTexture subFrameTex;
|
||||
private RenderTexture prevFrameTex;
|
||||
private Matrix4x4 projection;
|
||||
private Matrix4x4 projectionSPVR;
|
||||
private Matrix4x4 inverseRotation;
|
||||
private Matrix4x4 inverseRotationSPVR;
|
||||
private Matrix4x4 rotation;
|
||||
private Matrix4x4 rotationSPVR;
|
||||
private Matrix4x4 previousRotation;
|
||||
private Matrix4x4 previousRotationSPVR;
|
||||
[HideInInspector]
|
||||
public EnviroVolumeCloudsQualitySettings.ReprojectionPixelSize currentReprojectionPixelSize;
|
||||
private int reprojectionPixelSize;
|
||||
private bool isFirstFrame;
|
||||
private int subFrameNumber;
|
||||
private int[] frameList;
|
||||
private int renderingCounter;
|
||||
private int subFrameWidth;
|
||||
private int subFrameHeight;
|
||||
private int frameWidth;
|
||||
private int frameHeight;
|
||||
private bool textureDimensionChanged;
|
||||
#endregion
|
||||
|
||||
|
||||
UnityEngine.Rendering.Universal.RenderTargetHandle m_TemporaryColorTexture;
|
||||
string m_ProfilerTag;
|
||||
|
||||
/// <summary>
|
||||
/// Create the CopyColorPass
|
||||
/// </summary>
|
||||
public EnviroBlitPassVolumeClouds(UnityEngine.Rendering.Universal.RenderPassEvent renderPassEvent,Material cloudsMaterial, Material blitMaterial,Material composeMaterial, Material downsampleMaterial, string tag)
|
||||
{
|
||||
this.renderPassEvent = renderPassEvent;
|
||||
this.blitMat = blitMaterial;
|
||||
this.cloudsMat = cloudsMaterial;
|
||||
this.compose = composeMaterial;
|
||||
this.downsample = downsampleMaterial;
|
||||
m_ProfilerTag = tag;
|
||||
m_TemporaryColorTexture.Init("_TemporaryColorTexture");
|
||||
|
||||
|
||||
if (EnviroSky.instance != null)
|
||||
SetReprojectionPixelSize(EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Configure the pass with the source and destination to execute on.
|
||||
/// </summary>
|
||||
/// <param name="source">Source Render Target</param>
|
||||
/// <param name="destination">Destination Render Target</param>
|
||||
public void Setup(RenderTargetIdentifier source, UnityEngine.Rendering.Universal.RenderTargetHandle destination, Camera cam)
|
||||
{
|
||||
this.source = source;
|
||||
this.destination = destination;
|
||||
this.myCam = cam;
|
||||
}
|
||||
|
||||
#region Volume Clouds Functions
|
||||
////////// Clouds Functions ///////////////
|
||||
private void SetCloudProperties(UnityEngine.Rendering.Universal.RenderingData renderingData)
|
||||
{
|
||||
if (EnviroSky.instance.cloudsSettings.cloudsQualitySettings.baseQuality == EnviroVolumeCloudsQualitySettings.CloudDetailQuality.Low)
|
||||
cloudsMat.SetTexture("_Noise", EnviroSky.instance.ressources.noiseTexture);
|
||||
else
|
||||
cloudsMat.SetTexture("_Noise", EnviroSky.instance.ressources.noiseTextureHigh);
|
||||
|
||||
if (EnviroSky.instance.cloudsSettings.cloudsQualitySettings.detailQuality == EnviroVolumeCloudsQualitySettings.CloudDetailQuality.Low)
|
||||
cloudsMat.SetTexture("_DetailNoise", EnviroSky.instance.ressources.detailNoiseTexture);
|
||||
else
|
||||
cloudsMat.SetTexture("_DetailNoise", EnviroSky.instance.ressources.detailNoiseTextureHigh);
|
||||
|
||||
if (EnviroSky.instance.floatingPointOriginAnchor != null)
|
||||
EnviroSky.instance.floatingPointOriginMod = EnviroSky.instance.floatingPointOriginAnchor.position;
|
||||
|
||||
cloudsMat.SetVector("_CameraPosition", myCam.transform.position - EnviroSky.instance.floatingPointOriginMod);
|
||||
|
||||
projection = renderingData.cameraData.GetProjectionMatrix();
|
||||
Matrix4x4 inverseProjection = projection.inverse;
|
||||
cloudsMat.SetMatrix("_InverseProjection", inverseProjection);
|
||||
inverseRotation = renderingData.cameraData.GetViewMatrix().inverse;
|
||||
cloudsMat.SetMatrix("_InverseRotation", inverseRotation);
|
||||
|
||||
/* switch (myCam.stereoActiveEye)
|
||||
{
|
||||
case Camera.MonoOrStereoscopicEye.Mono:
|
||||
projection = myCam.projectionMatrix;
|
||||
Matrix4x4 inverseProjection = projection.inverse;
|
||||
cloudsMat.SetMatrix("_InverseProjection", inverseProjection);
|
||||
inverseRotation = myCam.cameraToWorldMatrix;
|
||||
cloudsMat.SetMatrix("_InverseRotation", inverseRotation);
|
||||
break;
|
||||
|
||||
case Camera.MonoOrStereoscopicEye.Left:
|
||||
projection = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
|
||||
Matrix4x4 inverseProjectionLeft = projection.inverse;
|
||||
cloudsMat.SetMatrix("_InverseProjection", inverseProjectionLeft);
|
||||
inverseRotation = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Left).inverse;
|
||||
cloudsMat.SetMatrix("_InverseRotation", inverseRotation);
|
||||
|
||||
if (myCam.stereoEnabled && EnviroSky.instance.singlePassVR)
|
||||
{
|
||||
Matrix4x4 inverseProjectionRightSP = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right).inverse;
|
||||
cloudsMat.SetMatrix("_InverseProjection_SP", inverseProjectionRightSP);
|
||||
|
||||
inverseRotationSPVR = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
|
||||
cloudsMat.SetMatrix("_InverseRotation_SP", inverseRotationSPVR);
|
||||
}
|
||||
break;
|
||||
|
||||
case Camera.MonoOrStereoscopicEye.Right:
|
||||
projection = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
|
||||
Matrix4x4 inverseProjectionRight = projection.inverse;
|
||||
cloudsMat.SetMatrix("_InverseProjection_SP", inverseProjectionRight);
|
||||
inverseRotation = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
|
||||
cloudsMat.SetMatrix("_InverseRotation_SP", inverseRotation);
|
||||
break;
|
||||
}*/
|
||||
|
||||
//Weather Map
|
||||
if (EnviroSky.instance.cloudsSettings.customWeatherMap == null)
|
||||
cloudsMat.SetTexture("_WeatherMap", EnviroSky.instance.weatherMap);
|
||||
else
|
||||
cloudsMat.SetTexture("_WeatherMap", EnviroSky.instance.cloudsSettings.customWeatherMap);
|
||||
|
||||
//Curl Noise
|
||||
if (EnviroSky.instance.cloudsSettings.cloudsQualitySettings.useCurlNoise)
|
||||
{
|
||||
cloudsMat.EnableKeyword("ENVIRO_CURLNOISE");
|
||||
cloudsMat.SetTexture("_CurlNoise", EnviroSky.instance.ressources.curlMap);
|
||||
}
|
||||
else
|
||||
{
|
||||
cloudsMat.DisableKeyword("ENVIRO_CURLNOISE");
|
||||
}
|
||||
|
||||
//Optimizations
|
||||
if (EnviroSky.instance.cloudsSettings.useHaltonRaymarchOffset)
|
||||
{
|
||||
cloudsMat.EnableKeyword("ENVIRO_HALTONOFFSET");
|
||||
cloudsMat.SetFloat("_RaymarchOffset", sequence.Get());
|
||||
cloudsMat.SetVector("_TexelSize", subFrameTex.texelSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
cloudsMat.DisableKeyword("ENVIRO_HALTONOFFSET");
|
||||
}
|
||||
|
||||
//RaymarchOffset
|
||||
|
||||
if (!EnviroSky.instance.cloudsSettings.useLessSteps)
|
||||
cloudsMat.SetVector("_Steps", new Vector4(EnviroSky.instance.cloudsSettings.cloudsQualitySettings.raymarchSteps * EnviroSky.instance.cloudsConfig.raymarchingScale, EnviroSky.instance.cloudsSettings.cloudsQualitySettings.raymarchSteps * EnviroSky.instance.cloudsConfig.raymarchingScale, 0.0f, 0.0f));
|
||||
else
|
||||
cloudsMat.SetVector("_Steps", new Vector4((EnviroSky.instance.cloudsSettings.cloudsQualitySettings.raymarchSteps * EnviroSky.instance.cloudsConfig.raymarchingScale) * 0.75f, (EnviroSky.instance.cloudsSettings.cloudsQualitySettings.raymarchSteps * EnviroSky.instance.cloudsConfig.raymarchingScale) * 0.75f, 0.0f, 0.0f));
|
||||
|
||||
cloudsMat.SetFloat("_BaseNoiseUV", EnviroSky.instance.cloudsSettings.cloudsQualitySettings.baseNoiseUV);
|
||||
cloudsMat.SetFloat("_DetailNoiseUV", EnviroSky.instance.cloudsSettings.cloudsQualitySettings.detailNoiseUV);
|
||||
cloudsMat.SetFloat("_AmbientSkyColorIntensity", EnviroSky.instance.cloudsSettings.ambientLightIntensity.Evaluate(EnviroSky.instance.GameTime.solarTime));
|
||||
cloudsMat.SetVector("_CloudsLighting", new Vector4(EnviroSky.instance.cloudsConfig.scatteringCoef, EnviroSky.instance.cloudsSettings.hgPhase, EnviroSky.instance.cloudsSettings.silverLiningIntensity, EnviroSky.instance.cloudsSettings.silverLiningSpread.Evaluate(EnviroSky.instance.GameTime.solarTime)));
|
||||
cloudsMat.SetVector("_CloudsLightingExtended", new Vector4(EnviroSky.instance.cloudsConfig.edgeDarkness, EnviroSky.instance.cloudsConfig.ambientSkyColorIntensity, EnviroSky.instance.tonemapping ? 0f : 1f, EnviroSky.instance.cloudsSettings.cloudsExposure));
|
||||
cloudsMat.SetColor("_AmbientLightColor", EnviroSky.instance.cloudsSettings.volumeCloudsAmbientColor.Evaluate(EnviroSky.instance.GameTime.solarTime));
|
||||
|
||||
float bottomH = EnviroSky.instance.cloudsSettings.cloudsQualitySettings.bottomCloudHeight + EnviroSky.instance.cloudsSettings.cloudsHeightMod;
|
||||
float topH = EnviroSky.instance.cloudsSettings.cloudsQualitySettings.topCloudHeight + EnviroSky.instance.cloudsSettings.cloudsHeightMod;
|
||||
|
||||
cloudsMat.SetVector("_CloudsParameter", new Vector4(bottomH, topH, 1 / (topH - bottomH), EnviroSky.instance.cloudsSettings.cloudsWorldScale * 10));
|
||||
|
||||
if (EnviroSky.instance.cloudsSettings.useLessSteps)
|
||||
cloudsMat.SetVector("_CloudDensityScale", new Vector4(EnviroSky.instance.cloudsConfig.density * 1.5f, EnviroSky.instance.cloudsConfig.lightStepModifier, EnviroSky.instance.GameTime.dayNightSwitch, EnviroSky.instance.GameTime.solarTime));
|
||||
else
|
||||
cloudsMat.SetVector("_CloudDensityScale", new Vector4(EnviroSky.instance.cloudsConfig.density, EnviroSky.instance.cloudsConfig.lightStepModifier, EnviroSky.instance.GameTime.dayNightSwitch, EnviroSky.instance.GameTime.solarTime));
|
||||
|
||||
cloudsMat.SetFloat("_CloudsType", EnviroSky.instance.cloudsConfig.cloudType);
|
||||
cloudsMat.SetVector("_CloudsCoverageSettings", new Vector4(EnviroSky.instance.cloudsConfig.coverage * EnviroSky.instance.cloudsSettings.globalCloudCoverage, EnviroSky.instance.cloudsConfig.lightAbsorbtion, EnviroSky.instance.cloudsSettings.cloudsQualitySettings.transmissionToExit, 0f));
|
||||
cloudsMat.SetVector("_CloudsAnimation", new Vector4(EnviroSky.instance.cloudAnim.x, EnviroSky.instance.cloudAnim.y, EnviroSky.instance.cloudsSettings.cloudsWindDirectionX, EnviroSky.instance.cloudsSettings.cloudsWindDirectionY));
|
||||
cloudsMat.SetColor("_LightColor", EnviroSky.instance.cloudsSettings.volumeCloudsColor.Evaluate(EnviroSky.instance.GameTime.solarTime));
|
||||
cloudsMat.SetColor("_MoonLightColor", EnviroSky.instance.cloudsSettings.volumeCloudsMoonColor.Evaluate(EnviroSky.instance.GameTime.lunarTime));
|
||||
cloudsMat.SetFloat("_stepsInDepth", EnviroSky.instance.cloudsSettings.cloudsQualitySettings.stepsInDepthModificator);
|
||||
cloudsMat.SetFloat("_LODDistance", EnviroSky.instance.cloudsSettings.cloudsQualitySettings.lodDistance);
|
||||
|
||||
|
||||
if (EnviroSky.instance.lightSettings.directionalLightMode == EnviroLightSettings.LightingMode.Dual)
|
||||
{
|
||||
if (EnviroSky.instance.GameTime.dayNightSwitch < EnviroSky.instance.GameTime.solarTime)
|
||||
cloudsMat.SetVector("_LightDir", -EnviroSky.instance.Components.DirectLight.transform.forward);
|
||||
else if (EnviroSky.instance.Components.AdditionalDirectLight != null)
|
||||
cloudsMat.SetVector("_LightDir", -EnviroSky.instance.Components.AdditionalDirectLight.transform.forward);
|
||||
}
|
||||
else
|
||||
cloudsMat.SetVector("_LightDir", -EnviroSky.instance.Components.DirectLight.transform.forward);
|
||||
|
||||
cloudsMat.SetFloat("_LightIntensity", EnviroSky.instance.cloudsSettings.lightIntensity.Evaluate(EnviroSky.instance.GameTime.solarTime));
|
||||
cloudsMat.SetVector("_CloudsErosionIntensity", new Vector4(1f - EnviroSky.instance.cloudsConfig.baseErosionIntensity, EnviroSky.instance.cloudsConfig.detailErosionIntensity, EnviroSky.instance.cloudsSettings.attenuationClamp.Evaluate(EnviroSky.instance.GameTime.solarTime), EnviroSky.instance.cloudAnim.z));
|
||||
// cloudsMat.SetTexture("_BlueNoise", blueNoise);
|
||||
// cloudsMat.SetVector("_Randomness", new Vector4(UnityEngine.Random.value, UnityEngine.Random.value, UnityEngine.Random.value, UnityEngine.Random.value));
|
||||
}
|
||||
|
||||
private void SetBlitmaterialProperties()
|
||||
{
|
||||
Matrix4x4 inverseProjection = projection.inverse;
|
||||
|
||||
blitMat.SetMatrix("_PreviousRotation", previousRotation);
|
||||
blitMat.SetMatrix("_Projection", projection);
|
||||
blitMat.SetMatrix("_InverseRotation", inverseRotation);
|
||||
blitMat.SetMatrix("_InverseProjection", inverseProjection);
|
||||
|
||||
//if (myCam.stereoEnabled && EnviroSky.instance.singlePassVR)
|
||||
// {
|
||||
Matrix4x4 inverseProjectionSPVR = projectionSPVR.inverse;
|
||||
blitMat.SetMatrix("_PreviousRotationSPVR", previousRotationSPVR);
|
||||
blitMat.SetMatrix("_ProjectionSPVR", projectionSPVR);
|
||||
blitMat.SetMatrix("_InverseRotationSPVR", inverseRotationSPVR);
|
||||
blitMat.SetMatrix("_InverseProjectionSPVR", inverseProjectionSPVR);
|
||||
// }
|
||||
|
||||
if (myCam.stereoEnabled && EnviroSky.instance.singlePassInstancedVR)
|
||||
blitMat.EnableKeyword("ENVIRO_SINGLEPASSINSTANCED");
|
||||
|
||||
blitMat.SetFloat("_FrameNumber", subFrameNumber);
|
||||
blitMat.SetFloat("_ReprojectionPixelSize", reprojectionPixelSize);
|
||||
blitMat.SetVector("_SubFrameDimension", new Vector2(subFrameWidth, subFrameHeight));
|
||||
blitMat.SetVector("_FrameDimension", new Vector2(frameWidth, frameHeight));
|
||||
}
|
||||
RenderTexture DownsampleDepth(CommandBuffer cmd,RenderTextureDescriptor desc, Texture src, Material mat, int downsampleFactor)
|
||||
{
|
||||
int X = desc.width;
|
||||
int Y = desc.height;
|
||||
Vector2 offset = new Vector2(1.0f / X, 1.0f / Y);
|
||||
X /= downsampleFactor;
|
||||
Y /= downsampleFactor;
|
||||
RenderTextureDescriptor lowDepthDescr = desc;
|
||||
lowDepthDescr.width = X;
|
||||
lowDepthDescr.height = Y;
|
||||
lowDepthDescr.depthBufferBits = 0;
|
||||
RenderTexture lowDepth = RenderTexture.GetTemporary(lowDepthDescr);
|
||||
mat.SetVector("_PixelSize", offset);
|
||||
//Graphics.Blit(src, lowDepth, mat);
|
||||
RenderTargetIdentifier srcID = new RenderTargetIdentifier(src);
|
||||
RenderTargetIdentifier lowDepthID = new RenderTargetIdentifier(lowDepth);
|
||||
Blit(cmd,srcID,lowDepthID,mat);
|
||||
return lowDepth;
|
||||
}
|
||||
|
||||
private void CreateCloudsRenderTextures(RenderTextureDescriptor d)
|
||||
{
|
||||
if (subFrameTex != null)
|
||||
{
|
||||
MonoBehaviour.DestroyImmediate(subFrameTex);
|
||||
subFrameTex = null;
|
||||
}
|
||||
|
||||
if (prevFrameTex != null)
|
||||
{
|
||||
MonoBehaviour.DestroyImmediate(prevFrameTex);
|
||||
prevFrameTex = null;
|
||||
}
|
||||
|
||||
RenderTextureFormat format = myCam.allowHDR ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
|
||||
|
||||
if (subFrameTex == null)
|
||||
{
|
||||
RenderTextureDescriptor desc = d;
|
||||
desc.width = subFrameWidth;
|
||||
desc.height = subFrameHeight;
|
||||
desc.depthBufferBits = 0;
|
||||
desc.graphicsFormat = Experimental.Rendering.GraphicsFormat.R16G16B16A16_SFloat;
|
||||
|
||||
subFrameTex = new RenderTexture(desc);
|
||||
subFrameTex.filterMode = FilterMode.Bilinear;
|
||||
subFrameTex.hideFlags = HideFlags.HideAndDontSave;
|
||||
|
||||
isFirstFrame = true;
|
||||
}
|
||||
|
||||
if (prevFrameTex == null)
|
||||
{
|
||||
RenderTextureDescriptor desc = d;
|
||||
desc.width = frameWidth;
|
||||
desc.height = frameHeight;
|
||||
desc.depthBufferBits = 0;
|
||||
desc.graphicsFormat = Experimental.Rendering.GraphicsFormat.R16G16B16A16_SFloat;
|
||||
|
||||
prevFrameTex = new RenderTexture(desc);
|
||||
prevFrameTex.filterMode = FilterMode.Bilinear;
|
||||
prevFrameTex.hideFlags = HideFlags.HideAndDontSave;
|
||||
|
||||
isFirstFrame = true;
|
||||
}
|
||||
}
|
||||
private void SetReprojectionPixelSize(EnviroVolumeCloudsQualitySettings.ReprojectionPixelSize pSize)
|
||||
{
|
||||
switch (pSize)
|
||||
{
|
||||
case EnviroVolumeCloudsQualitySettings.ReprojectionPixelSize.Off:
|
||||
reprojectionPixelSize = 1;
|
||||
break;
|
||||
|
||||
case EnviroVolumeCloudsQualitySettings.ReprojectionPixelSize.Low:
|
||||
reprojectionPixelSize = 2;
|
||||
break;
|
||||
|
||||
case EnviroVolumeCloudsQualitySettings.ReprojectionPixelSize.Medium:
|
||||
reprojectionPixelSize = 4;
|
||||
break;
|
||||
|
||||
case EnviroVolumeCloudsQualitySettings.ReprojectionPixelSize.High:
|
||||
reprojectionPixelSize = 8;
|
||||
break;
|
||||
}
|
||||
|
||||
frameList = CalculateFrames(reprojectionPixelSize);
|
||||
}
|
||||
private void StartFrame(UnityEngine.Rendering.Universal.RenderingData renderingData)
|
||||
{
|
||||
textureDimensionChanged = UpdateFrameDimensions();
|
||||
|
||||
/*switch (myCam.stereoActiveEye)
|
||||
{
|
||||
case Camera.MonoOrStereoscopicEye.Mono:
|
||||
projection = myCam.projectionMatrix;
|
||||
rotation = myCam.worldToCameraMatrix;
|
||||
inverseRotation = myCam.cameraToWorldMatrix;
|
||||
break;
|
||||
|
||||
case Camera.MonoOrStereoscopicEye.Left:
|
||||
projection = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
|
||||
rotation = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Left);
|
||||
inverseRotation = rotation.inverse;
|
||||
|
||||
if (EnviroSky.instance.singlePassVR)
|
||||
{
|
||||
projectionSPVR = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
|
||||
rotationSPVR = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right);
|
||||
inverseRotationSPVR = rotationSPVR.inverse;
|
||||
}
|
||||
break;
|
||||
|
||||
case Camera.MonoOrStereoscopicEye.Right:
|
||||
projection = myCam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
|
||||
rotation = myCam.GetStereoViewMatrix(Camera.StereoscopicEye.Right);
|
||||
inverseRotation = rotation.inverse;
|
||||
break;
|
||||
}*/
|
||||
|
||||
projection = renderingData.cameraData.GetGPUProjectionMatrix();
|
||||
rotation = renderingData.cameraData.GetViewMatrix();
|
||||
inverseRotation = rotation.inverse;
|
||||
|
||||
projectionSPVR = renderingData.cameraData.GetGPUProjectionMatrix();
|
||||
rotationSPVR = renderingData.cameraData.GetViewMatrix();
|
||||
inverseRotationSPVR = rotationSPVR.inverse;
|
||||
|
||||
}
|
||||
private void FinalizeFrame()
|
||||
{
|
||||
renderingCounter++;
|
||||
|
||||
previousRotation = rotation;
|
||||
//if (EnviroSky.instance.singlePassVR)
|
||||
previousRotationSPVR = rotationSPVR;
|
||||
|
||||
int reproSize = reprojectionPixelSize * reprojectionPixelSize;
|
||||
subFrameNumber = frameList[renderingCounter % reproSize];
|
||||
}
|
||||
private bool UpdateFrameDimensions()
|
||||
{
|
||||
//Add downsampling
|
||||
int newFrameWidth = myCam.pixelWidth / EnviroSky.instance.cloudsSettings.cloudsQualitySettings.cloudsRenderResolution;
|
||||
int newFrameHeight = myCam.pixelHeight / EnviroSky.instance.cloudsSettings.cloudsQualitySettings.cloudsRenderResolution;
|
||||
|
||||
//Reset temporal reprojection size when zero. Needed if SkyManager starts deactivated
|
||||
if (EnviroSky.instance != null && reprojectionPixelSize == 0)
|
||||
SetReprojectionPixelSize(EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize);
|
||||
|
||||
//Calculate new frame width and height
|
||||
while (newFrameWidth % reprojectionPixelSize != 0)
|
||||
{
|
||||
newFrameWidth++;
|
||||
}
|
||||
|
||||
while (newFrameHeight % reprojectionPixelSize != 0)
|
||||
{
|
||||
newFrameHeight++;
|
||||
}
|
||||
|
||||
int newSubFrameWidth = newFrameWidth / reprojectionPixelSize;
|
||||
int newSubFrameHeight = newFrameHeight / reprojectionPixelSize;
|
||||
|
||||
//Check if diemensions changed
|
||||
if (newFrameWidth != frameWidth || newSubFrameWidth != subFrameWidth || newFrameHeight != frameHeight || newSubFrameHeight != subFrameHeight)
|
||||
{
|
||||
//Cache new dimensions
|
||||
frameWidth = newFrameWidth;
|
||||
frameHeight = newFrameHeight;
|
||||
subFrameWidth = newSubFrameWidth;
|
||||
subFrameHeight = newSubFrameHeight;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
//Cache new dimensions
|
||||
frameWidth = newFrameWidth;
|
||||
frameHeight = newFrameHeight;
|
||||
subFrameWidth = newSubFrameWidth;
|
||||
subFrameHeight = newSubFrameHeight;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
private int[] CalculateFrames(int reproSize)
|
||||
{
|
||||
subFrameNumber = 0;
|
||||
|
||||
int i = 0;
|
||||
int reproCount = reproSize * reproSize;
|
||||
int[] frameNumbers = new int[reproCount];
|
||||
|
||||
for (i = 0; i < reproCount; i++)
|
||||
{
|
||||
frameNumbers[i] = i;
|
||||
}
|
||||
|
||||
while (i-- > 0)
|
||||
{
|
||||
int frame = frameNumbers[i];
|
||||
int count = (int)(UnityEngine.Random.Range(0, 1) * 1000.0f) % reproCount;
|
||||
frameNumbers[i] = frameNumbers[count];
|
||||
frameNumbers[count] = frame;
|
||||
}
|
||||
|
||||
return frameNumbers;
|
||||
}
|
||||
#endregion
|
||||
|
||||
void UpdateMatrix(UnityEngine.Rendering.Universal.RenderingData renderingData)
|
||||
{
|
||||
if (UnityEngine.XR.XRSettings.enabled)
|
||||
{
|
||||
// Both stereo eye inverse view matrices
|
||||
Matrix4x4 left_world_from_view = renderingData.cameraData.GetViewMatrix().inverse;
|
||||
Matrix4x4 right_world_from_view = renderingData.cameraData.GetViewMatrix().inverse;
|
||||
|
||||
// Both stereo eye inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
|
||||
Matrix4x4 left_screen_from_view = renderingData.cameraData.GetProjectionMatrix();
|
||||
Matrix4x4 right_screen_from_view = renderingData.cameraData.GetProjectionMatrix();
|
||||
Matrix4x4 left_view_from_screen = renderingData.cameraData.GetGPUProjectionMatrix().inverse;
|
||||
Matrix4x4 right_view_from_screen = renderingData.cameraData.GetGPUProjectionMatrix().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 = renderingData.cameraData.GetViewMatrix().inverse;
|
||||
|
||||
// Inverse projection matrices, plumbed through GetGPUProjectionMatrix to compensate for render texture
|
||||
Matrix4x4 screen_from_view = renderingData.cameraData.GetProjectionMatrix();
|
||||
Matrix4x4 left_view_from_screen = renderingData.cameraData.GetGPUProjectionMatrix().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);
|
||||
}
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override void Execute(ScriptableRenderContext context, ref UnityEngine.Rendering.Universal.RenderingData renderingData)
|
||||
{
|
||||
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
|
||||
|
||||
if (currentReprojectionPixelSize != EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize)
|
||||
{
|
||||
currentReprojectionPixelSize = EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize;
|
||||
SetReprojectionPixelSize(EnviroSky.instance.cloudsSettings.cloudsQualitySettings.reprojectionPixelSize);
|
||||
}
|
||||
|
||||
if (blitMat == null)
|
||||
blitMat = new Material(Shader.Find("Enviro/Standard/Blit"));
|
||||
|
||||
StartFrame(renderingData);
|
||||
|
||||
if (subFrameTex == null || prevFrameTex == null || textureDimensionChanged)
|
||||
CreateCloudsRenderTextures(renderingData.cameraData.cameraTargetDescriptor);
|
||||
|
||||
if (cloudsMat == null)
|
||||
cloudsMat = new Material(Shader.Find("Enviro/Standard/RaymarchClouds"));
|
||||
|
||||
RenderTargetIdentifier prevFrameId = new RenderTargetIdentifier(prevFrameTex);
|
||||
RenderTargetIdentifier subFrameId = new RenderTargetIdentifier(subFrameTex);
|
||||
|
||||
if(EnviroSky.instance != null)
|
||||
EnviroSky.instance.RenderCloudMaps();
|
||||
|
||||
|
||||
SetCloudProperties(renderingData);
|
||||
|
||||
if(myCam != null)
|
||||
UpdateMatrix(renderingData);
|
||||
|
||||
//Render Clouds with downsampling tex
|
||||
//Graphics.Blit(null, subFrameTex, cloudsMat);
|
||||
|
||||
Blit(cmd,source,subFrameId,cloudsMat);
|
||||
|
||||
if (isFirstFrame)
|
||||
{
|
||||
// Graphics.Blit(subFrameTex, prevFrameTex);
|
||||
Blit(cmd,subFrameId,prevFrameId);
|
||||
isFirstFrame = false;
|
||||
}
|
||||
|
||||
//Set blending type:
|
||||
if (EnviroSky.instance.cloudsSettings.depthBlending)
|
||||
Shader.EnableKeyword("ENVIRO_DEPTHBLENDING");
|
||||
else
|
||||
Shader.DisableKeyword("ENVIRO_DEPTHBLENDING");
|
||||
|
||||
int downsampling = EnviroSky.instance.cloudsSettings.bilateralUpsampling ? reprojectionPixelSize * EnviroSky.instance.cloudsSettings.cloudsQualitySettings.cloudsRenderResolution : 1;
|
||||
|
||||
if (downsampling > 1)
|
||||
{
|
||||
|
||||
if (compose == null)
|
||||
compose = new Material(Shader.Find("Hidden/Enviro/Upsample"));
|
||||
|
||||
if (downsample == null)
|
||||
downsample = new Material(Shader.Find("Hidden/Enviro/DepthDownsample"));
|
||||
|
||||
|
||||
RenderTexture lowDepth = DownsampleDepth(cmd,renderingData.cameraData.cameraTargetDescriptor, null, downsample, downsampling);
|
||||
|
||||
compose.SetTexture("_CameraDepthLowRes", lowDepth);
|
||||
|
||||
RenderTextureDescriptor upsampleDesc = renderingData.cameraData.cameraTargetDescriptor;
|
||||
upsampleDesc.width = myCam.pixelWidth / downsampling * 2;
|
||||
upsampleDesc.height = myCam.pixelHeight / downsampling * 2;
|
||||
upsampleDesc.depthBufferBits = 0;
|
||||
upsampleDesc.graphicsFormat = Experimental.Rendering.GraphicsFormat.R16G16B16A16_SFloat;
|
||||
|
||||
RenderTexture upsampledTex = RenderTexture.GetTemporary(upsampleDesc);
|
||||
upsampledTex.filterMode = FilterMode.Bilinear;
|
||||
|
||||
RenderTargetIdentifier upsampledId = new RenderTargetIdentifier(upsampledTex);
|
||||
|
||||
// composite to screen
|
||||
Vector2 pixelSize = new Vector2(1.0f / lowDepth.width, 1.0f / lowDepth.height);
|
||||
compose.SetVector("_LowResPixelSize", pixelSize);
|
||||
compose.SetVector("_LowResTextureSize", new Vector2(lowDepth.width, lowDepth.height));
|
||||
compose.SetFloat("_DepthMult", 32.0f);
|
||||
compose.SetFloat("_Threshold", 0.0005f);
|
||||
compose.SetTexture("_LowResTexture", subFrameTex);
|
||||
|
||||
Blit(cmd,subFrameId,upsampledId,compose);
|
||||
//Graphics.Blit(subFrameTex, upsampledTex, compose);
|
||||
RenderTexture.ReleaseTemporary(lowDepth);
|
||||
|
||||
//Blit clouds to final image
|
||||
// blitMat.SetTexture("_MainTex", src);
|
||||
blitMat.SetTexture("_SubFrame", upsampledTex);
|
||||
blitMat.SetTexture("_PrevFrame", prevFrameTex);
|
||||
SetBlitmaterialProperties();
|
||||
|
||||
RenderTextureDescriptor opaqueDesc = renderingData.cameraData.cameraTargetDescriptor;
|
||||
opaqueDesc.depthBufferBits = 0;
|
||||
cmd.GetTemporaryRT(m_TemporaryColorTexture.id, opaqueDesc, filterMode);
|
||||
|
||||
Blit(cmd,source,m_TemporaryColorTexture.Identifier());
|
||||
Blit(cmd, m_TemporaryColorTexture.Identifier(), source,blitMat);
|
||||
//Graphics.Blit(src, dst, blitMat);
|
||||
|
||||
// Graphics.Blit(upsampledTex, prevFrameTex);
|
||||
Blit(cmd,upsampledId,prevFrameId);
|
||||
|
||||
RenderTexture.ReleaseTemporary(upsampledTex);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Blit clouds to final image
|
||||
// blitMat.SetTexture("_MainTex", src);
|
||||
blitMat.SetTexture("_SubFrame", subFrameTex);
|
||||
blitMat.SetTexture("_PrevFrame", prevFrameTex);
|
||||
SetBlitmaterialProperties();
|
||||
|
||||
// Graphics.Blit(src, dst, blitMat);
|
||||
RenderTextureDescriptor opaqueDesc = renderingData.cameraData.cameraTargetDescriptor;
|
||||
opaqueDesc.depthBufferBits = 0;
|
||||
|
||||
cmd.GetTemporaryRT(m_TemporaryColorTexture.id, opaqueDesc, filterMode);
|
||||
|
||||
Blit(cmd,source,m_TemporaryColorTexture.Identifier());
|
||||
Blit(cmd, m_TemporaryColorTexture.Identifier(), source,blitMat);
|
||||
|
||||
// Graphics.Blit(subFrameTex, prevFrameTex);
|
||||
Blit(cmd,subFrameId,prevFrameId);
|
||||
|
||||
}
|
||||
|
||||
FinalizeFrame();
|
||||
|
||||
context.ExecuteCommandBuffer(cmd);
|
||||
|
||||
cmd.ReleaseTemporaryRT(m_TemporaryColorTexture.id);
|
||||
|
||||
CommandBufferPool.Release(cmd);
|
||||
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override void FrameCleanup(CommandBuffer cmd)
|
||||
{
|
||||
// if (destination == UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget)
|
||||
// cmd.ReleaseTemporaryRT(m_TemporaryColorTexture.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 0baa5b4164132264eb134253da90bbcb
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine.Serialization;
|
||||
#if ENVIRO_LWRP && ENVIRO_HD
|
||||
namespace UnityEngine.Rendering.LWRP
|
||||
{
|
||||
public class EnviroDistanceBlurLWRP : UnityEngine.Rendering.Universal.ScriptableRendererFeature
|
||||
{
|
||||
EnviroDistanceBlurPass blitPass;
|
||||
|
||||
private Camera myCam;
|
||||
private Material postProcessMat;
|
||||
private Texture2D distributionTexture;
|
||||
|
||||
private void CreateMaterialsAndTextures()
|
||||
{
|
||||
if (postProcessMat == null)
|
||||
postProcessMat = new Material(Shader.Find("Hidden/EnviroDistanceBlur"));
|
||||
|
||||
if (distributionTexture == null)
|
||||
distributionTexture = Resources.Load("tex_enviro_linear", typeof(Texture2D)) as Texture2D;
|
||||
}
|
||||
|
||||
public override void Create()
|
||||
{
|
||||
if (EnviroSkyMgr.instance == null || EnviroSky.instance == null)
|
||||
return;
|
||||
|
||||
CreateMaterialsAndTextures();
|
||||
blitPass = new EnviroDistanceBlurPass(UnityEngine.Rendering.Universal.RenderPassEvent.BeforeRenderingTransparents, postProcessMat, distributionTexture);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
CreateMaterialsAndTextures();
|
||||
|
||||
if(blitPass == null)
|
||||
blitPass = new EnviroDistanceBlurPass(UnityEngine.Rendering.Universal.RenderPassEvent.BeforeRenderingTransparents, postProcessMat, distributionTexture);
|
||||
|
||||
blitPass.Setup(myCam, src, dest);
|
||||
renderer.EnqueuePass(blitPass);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: b106513901658574eb34bb662f591351
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
+219
@@ -0,0 +1,219 @@
|
||||
#if ENVIRO_LWRP && ENVIRO_HD
|
||||
|
||||
namespace UnityEngine.Rendering.LWRP
|
||||
{
|
||||
internal class EnviroDistanceBlurPass : UnityEngine.Rendering.Universal.ScriptableRenderPass
|
||||
{
|
||||
private Camera myCam;
|
||||
public Material blitMaterial = null;
|
||||
private RenderTargetIdentifier source { get; set; }
|
||||
private UnityEngine.Rendering.Universal.RenderTargetHandle destination { get; set; }
|
||||
|
||||
#region Blur Var
|
||||
/////////////////// Blur //////////////////////
|
||||
private const int kMaxIterations = 16;
|
||||
private RenderTexture[] _blurBuffer1 = new RenderTexture[kMaxIterations];
|
||||
private RenderTexture[] _blurBuffer2 = new RenderTexture[kMaxIterations];
|
||||
private Texture2D distributionTexture;
|
||||
public float thresholdGamma
|
||||
{
|
||||
get { return Mathf.Max(0f, 0); }
|
||||
}
|
||||
public float thresholdLinear
|
||||
{
|
||||
get { return Mathf.GammaToLinearSpace(thresholdGamma); }
|
||||
}
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Create the CopyColorPass
|
||||
/// </summary>
|
||||
public EnviroDistanceBlurPass(UnityEngine.Rendering.Universal.RenderPassEvent renderPassEvent, Material blitMaterial, Texture2D distributionTexture)
|
||||
{
|
||||
this.renderPassEvent = renderPassEvent;
|
||||
this.blitMaterial = blitMaterial;
|
||||
this.distributionTexture = distributionTexture;
|
||||
}
|
||||
|
||||
public void Setup(Camera myCam, RenderTargetIdentifier source, UnityEngine.Rendering.Universal.RenderTargetHandle destination)
|
||||
{
|
||||
this.myCam = myCam;
|
||||
this.source = source;
|
||||
this.destination = destination;
|
||||
}
|
||||
|
||||
private void UpdateMatrix()
|
||||
{
|
||||
///////////////////Matrix Information
|
||||
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);
|
||||
}
|
||||
//////////////////////////////
|
||||
|
||||
|
||||
}
|
||||
///
|
||||
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;
|
||||
}
|
||||
|
||||
if(blitMaterial == null)
|
||||
blitMaterial = new Material(Shader.Find("Hidden/EnviroDistanceBlur"));
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public override void FrameCleanup(CommandBuffer cmd)
|
||||
{
|
||||
//if (destination == RenderTargetHandle.CameraTarget)
|
||||
// cmd.ReleaseTemporaryRT(m_TemporaryColorTexture.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 3217e44dc8103964ead397e0d8b51696
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
+199
@@ -0,0 +1,199 @@
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine.Serialization;
|
||||
#if ENVIRO_LWRP && ENVIRO_HD
|
||||
namespace UnityEngine.Rendering.LWRP
|
||||
{
|
||||
public class EnviroFogLWRP : UnityEngine.Rendering.Universal.ScriptableRendererFeature
|
||||
{
|
||||
|
||||
EnviroBlitPass blitPass;
|
||||
|
||||
private Camera myCam;
|
||||
|
||||
#region Fog Var
|
||||
public enum FogType
|
||||
{
|
||||
Disabled,
|
||||
Simple,
|
||||
Standard
|
||||
}
|
||||
|
||||
[HideInInspector]
|
||||
public FogType currentFogType;
|
||||
private Material fogMat;
|
||||
private Texture2D dither;
|
||||
private Texture2D blackTexture;
|
||||
private Texture3D detailNoiseTexture = null;
|
||||
#endregion
|
||||
|
||||
private void RenderFog()
|
||||
{
|
||||
|
||||
if (fogMat == null)
|
||||
CreateFogMaterial();
|
||||
|
||||
//////////////// FOG
|
||||
float FdotC = myCam.transform.position.y - EnviroSky.instance.fogSettings.height;
|
||||
float paramK = (FdotC <= 0.0f ? 1.0f : 0.0f);
|
||||
var sceneMode = RenderSettings.fogMode;
|
||||
var sceneDensity = RenderSettings.fogDensity;
|
||||
var sceneStart = RenderSettings.fogStartDistance;
|
||||
var sceneEnd = RenderSettings.fogEndDistance;
|
||||
Vector4 sceneParams;
|
||||
bool linear = (sceneMode == FogMode.Linear);
|
||||
float diff = linear ? sceneEnd - sceneStart : 0.0f;
|
||||
float invDiff = Mathf.Abs(diff) > 0.0001f ? 1.0f / diff : 0.0f;
|
||||
sceneParams.x = sceneDensity * 1.2011224087f; // density / sqrt(ln(2)), used by Exp2 fog mode
|
||||
sceneParams.y = sceneDensity * 1.4426950408f; // density / ln(2), used by Exp fog mode
|
||||
sceneParams.z = linear ? -invDiff : 0.0f;
|
||||
sceneParams.w = linear ? sceneEnd * invDiff : 0.0f;
|
||||
//////////////////
|
||||
|
||||
if (!EnviroSky.instance.fogSettings.useSimpleFog)
|
||||
{
|
||||
Shader.SetGlobalVector("_FogNoiseVelocity", new Vector4(-EnviroSky.instance.Components.windZone.transform.forward.x * EnviroSky.instance.windIntensity * 5, -EnviroSky.instance.Components.windZone.transform.forward.z * EnviroSky.instance.windIntensity * 5) * EnviroSky.instance.fogSettings.noiseScale);
|
||||
Shader.SetGlobalVector("_FogNoiseData", new Vector4(EnviroSky.instance.fogSettings.noiseScale, EnviroSky.instance.fogSettings.noiseIntensity, EnviroSky.instance.fogSettings.noiseIntensityOffset));
|
||||
Shader.SetGlobalTexture("_FogNoiseTexture", detailNoiseTexture);
|
||||
}
|
||||
|
||||
Shader.SetGlobalFloat("_EnviroVolumeDensity", EnviroSky.instance.globalVolumeLightIntensity);
|
||||
Shader.SetGlobalVector("_SceneFogParams", sceneParams);
|
||||
Shader.SetGlobalVector("_SceneFogMode", new Vector4((int)sceneMode, EnviroSky.instance.fogSettings.useRadialDistance ? 1 : 0, 0, Application.isPlaying ? 1f : 0f));
|
||||
Shader.SetGlobalVector("_HeightParams", new Vector4(EnviroSky.instance.fogSettings.height, FdotC, paramK, EnviroSky.instance.fogSettings.heightDensity * 0.5f));
|
||||
Shader.SetGlobalVector("_DistanceParams", new Vector4(-Mathf.Max(EnviroSky.instance.fogSettings.startDistance, 0.0f), 0, 0, 0));
|
||||
fogMat.SetFloat("_DitheringIntensity", EnviroSky.instance.fogSettings.fogDithering);
|
||||
Shader.SetGlobalTexture("_EnviroVolumeLightingTex", blackTexture);
|
||||
}
|
||||
|
||||
private void CreateFogMaterial()
|
||||
{
|
||||
if (EnviroSky.instance == null)
|
||||
return;
|
||||
|
||||
if (dither == null)
|
||||
dither = Resources.Load("tex_enviro_dither") as Texture2D;
|
||||
|
||||
if (detailNoiseTexture == null)
|
||||
detailNoiseTexture = Resources.Load("enviro_clouds_detail_low") as Texture3D;
|
||||
|
||||
if (blackTexture == null)
|
||||
blackTexture = Resources.Load("tex_enviro_black") as Texture2D;
|
||||
|
||||
//Cleanup
|
||||
if (fogMat != null)
|
||||
DestroyImmediate(fogMat);
|
||||
|
||||
if (!EnviroSky.instance.useFog)
|
||||
{
|
||||
Shader shader = Shader.Find("Enviro/Standard/EnviroFogRenderingDisabled");
|
||||
fogMat = new Material(shader);
|
||||
if (shader == null)
|
||||
currentFogType = FogType.Disabled;
|
||||
}
|
||||
else if (!EnviroSky.instance.fogSettings.useSimpleFog)
|
||||
{
|
||||
Shader shader = Shader.Find("Enviro/Standard/EnviroFogRendering");
|
||||
fogMat = new Material(shader);
|
||||
if (shader == null)
|
||||
currentFogType = FogType.Standard;
|
||||
}
|
||||
else
|
||||
{
|
||||
Shader shader = Shader.Find("Enviro/Standard/EnviroFogRenderingSimple");
|
||||
if (shader == null)
|
||||
fogMat = new Material(shader);
|
||||
|
||||
currentFogType = FogType.Simple;
|
||||
}
|
||||
}
|
||||
private void UpdateMatrix()
|
||||
{
|
||||
///////////////////Matrix Information
|
||||
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);
|
||||
}
|
||||
//////////////////////////////
|
||||
|
||||
|
||||
}
|
||||
|
||||
public override void Create()
|
||||
{
|
||||
if (EnviroSkyMgr.instance == null || EnviroSky.instance == null)
|
||||
return;
|
||||
|
||||
CreateFogMaterial();
|
||||
|
||||
blitPass = new EnviroBlitPass(UnityEngine.Rendering.Universal.RenderPassEvent.BeforeRenderingTransparents, fogMat, 0, name);
|
||||
}
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 45b427b86238a7c4f8c50985b3a26017
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
+67
@@ -0,0 +1,67 @@
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine.Serialization;
|
||||
#if ENVIRO_LWRP && ENVIRO_HD
|
||||
namespace UnityEngine.Rendering.LWRP
|
||||
{
|
||||
public class EnviroVolumeCloudsLWRP : UnityEngine.Rendering.Universal.ScriptableRendererFeature
|
||||
{
|
||||
|
||||
EnviroBlitPassVolumeClouds blitPass;
|
||||
|
||||
private Material cloudsMat;
|
||||
private Material blitMat;
|
||||
private Material compose;
|
||||
private Material downsample;
|
||||
|
||||
private void CreateMaterialsAndTextures()
|
||||
{
|
||||
|
||||
if (cloudsMat == null)
|
||||
cloudsMat = new Material(Shader.Find("Enviro/Standard/RaymarchClouds"));
|
||||
|
||||
if (blitMat == null)
|
||||
blitMat = new Material(Shader.Find("Enviro/Standard/Blit"));
|
||||
|
||||
if (compose == null)
|
||||
compose = new Material(Shader.Find("Hidden/Enviro/Upsample"));
|
||||
|
||||
if (downsample == null)
|
||||
downsample = new Material(Shader.Find("Hidden/Enviro/DepthDownsample"));
|
||||
}
|
||||
|
||||
|
||||
public override void Create()
|
||||
{
|
||||
if (EnviroSkyMgr.instance == null || EnviroSky.instance == null)
|
||||
return;
|
||||
|
||||
CreateMaterialsAndTextures();
|
||||
|
||||
blitPass = new EnviroBlitPassVolumeClouds(UnityEngine.Rendering.Universal.RenderPassEvent.BeforeRenderingTransparents, cloudsMat,blitMat,compose,downsample, name);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
var src = renderer.cameraColorTarget;
|
||||
var dest = UnityEngine.Rendering.Universal.RenderTargetHandle.CameraTarget;
|
||||
|
||||
if (renderingData.cameraData.isSceneViewCamera && !EnviroSky.instance.showVolumeCloudsInEditor)
|
||||
return;
|
||||
|
||||
if (blitPass == null)
|
||||
Create();
|
||||
|
||||
CreateMaterialsAndTextures();
|
||||
blitPass.Setup(src, dest,renderingData.cameraData.camera);
|
||||
|
||||
renderer.EnqueuePass(blitPass);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 0fea8f98de0631548880c2c10a8e9dba
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
Reference in New Issue
Block a user