mirror of
https://github.com/maxartz15/VolumetricLighting.git
synced 2024-11-10 01:02:55 +01:00
595 lines
17 KiB
C#
595 lines
17 KiB
C#
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
[ExecuteInEditMode]
|
|
[RequireComponent(typeof(Camera))]
|
|
public class VolumetricFog : MonoBehaviour
|
|
{
|
|
[HideInInspector]
|
|
public Shader m_ShadowmapShader;
|
|
[HideInInspector]
|
|
public ComputeShader m_InjectLightingAndDensity;
|
|
[HideInInspector]
|
|
public ComputeShader m_Scatter;
|
|
Material m_ApplyToOpaqueMaterial;
|
|
[HideInInspector]
|
|
public Shader m_ApplyToOpaqueShader;
|
|
Material m_BlurShadowmapMaterial;
|
|
[HideInInspector]
|
|
public Shader m_BlurShadowmapShader;
|
|
[HideInInspector]
|
|
public Texture2D m_Noise;
|
|
|
|
[Header("Size")]
|
|
[MinValue(0.1f)]
|
|
public float m_NearClip = 0.1f;
|
|
[MinValue(0.1f)]
|
|
public float m_FarClipMax = 100.0f;
|
|
[SerializeField]
|
|
private Vector3Int froxelResolution = new Vector3Int(160, 90, 128);
|
|
|
|
[Header("Fog Density")]
|
|
[FormerlySerializedAs("m_Density")]
|
|
public float m_GlobalDensityMult = 1.0f;
|
|
Vector3Int m_InjectNumThreads = new Vector3Int(16, 2, 16);
|
|
Vector3Int m_ScatterNumThreads = new Vector3Int(32, 2, 1);
|
|
RenderTexture m_VolumeInject;
|
|
RenderTexture m_VolumeScatter;
|
|
Camera m_Camera;
|
|
|
|
// Density
|
|
public float m_ConstantFog = 0;
|
|
public float m_HeightFogAmount = 0;
|
|
public float m_HeightFogExponent = 0;
|
|
public float m_HeightFogOffset = 0;
|
|
|
|
[Tooltip("Noise multiplies with constant fog and height fog, but not with fog ellipsoids.")]
|
|
[Range(0.0f, 1.0f)]
|
|
public float m_NoiseFogAmount = 0;
|
|
public float m_NoiseFogScale = 1;
|
|
public Wind m_Wind;
|
|
|
|
[Range(0.0f, 0.999f)]
|
|
public float m_Anisotropy = 0.0f;
|
|
|
|
[Header("Lights")]
|
|
[FormerlySerializedAs("m_Intensity")]
|
|
public float m_GlobalIntensityMult = 1.0f;
|
|
[MinValue(0)]
|
|
public float m_AmbientLightIntensity = 0.0f;
|
|
public Color m_AmbientLightColor = Color.white;
|
|
|
|
[Header("Debug")]
|
|
public int m_AntiAliasing = 1;
|
|
public FilterMode m_FilterMode = FilterMode.Bilinear;
|
|
public bool m_ShowFroxelSlices = false;
|
|
private Material m_DebugMaterial;
|
|
[HideInInspector]
|
|
public Shader m_DebugShader;
|
|
[HideInInspector]
|
|
public bool m_Debug = false;
|
|
[HideInInspector]
|
|
[Range(0.0f, 1.0f)]
|
|
public float m_Z = 1.0f;
|
|
|
|
[SerializeField]
|
|
private float m_dirLightOffset;
|
|
[SerializeField]
|
|
private float m_vsmBias;
|
|
[SerializeField]
|
|
private float m_dirBias;
|
|
|
|
struct PointLightParams
|
|
{
|
|
public Vector3 pos;
|
|
public float range;
|
|
public Vector3 color;
|
|
float padding;
|
|
}
|
|
|
|
PointLightParams[] m_PointLightParams;
|
|
ComputeBuffer m_PointLightParamsCB;
|
|
|
|
struct FogEllipsoidParams
|
|
{
|
|
public Vector3 pos;
|
|
public float radius;
|
|
public Vector3 axis;
|
|
public float stretch;
|
|
public float density;
|
|
public float noiseAmount;
|
|
public float noiseSpeed;
|
|
public float noiseScale;
|
|
public float feather;
|
|
public float blend;
|
|
public float padding1;
|
|
public float padding2;
|
|
}
|
|
|
|
FogEllipsoidParams[] m_FogEllipsoidParams;
|
|
ComputeBuffer m_FogEllipsoidParamsCB;
|
|
|
|
ComputeBuffer m_DummyCB;
|
|
|
|
Camera cam { get { if (m_Camera == null) m_Camera = GetComponent<Camera>(); return m_Camera; } }
|
|
|
|
float nearClip { get { return Mathf.Max(0, m_NearClip); } }
|
|
float farClip { get { return Mathf.Min(cam.farClipPlane, m_FarClipMax); } }
|
|
|
|
void ReleaseComputeBuffer(ref ComputeBuffer buffer)
|
|
{
|
|
if (buffer != null)
|
|
buffer.Release();
|
|
buffer = null;
|
|
}
|
|
|
|
void OnDestroy()
|
|
{
|
|
Cleanup();
|
|
}
|
|
|
|
void OnDisable()
|
|
{
|
|
Cleanup();
|
|
}
|
|
|
|
void Cleanup()
|
|
{
|
|
DestroyImmediate(m_VolumeInject);
|
|
DestroyImmediate(m_VolumeScatter);
|
|
ReleaseComputeBuffer(ref m_PointLightParamsCB);
|
|
ReleaseComputeBuffer(ref m_FogEllipsoidParamsCB);
|
|
ReleaseComputeBuffer(ref m_DummyCB);
|
|
m_VolumeInject = null;
|
|
m_VolumeScatter = null;
|
|
}
|
|
|
|
void SanitizeInput()
|
|
{
|
|
m_GlobalDensityMult = Mathf.Max(m_GlobalDensityMult, 0);
|
|
m_ConstantFog = Mathf.Max(m_ConstantFog, 0);
|
|
m_HeightFogAmount = Mathf.Max(m_HeightFogAmount, 0);
|
|
}
|
|
|
|
void SetUpPointLightBuffers(int kernel)
|
|
{
|
|
int count = m_PointLightParamsCB == null ? 0 : m_PointLightParamsCB.count;
|
|
m_InjectLightingAndDensity.SetFloat("_PointLightsCount", count);
|
|
if (count == 0)
|
|
{
|
|
// Can't not set the buffer
|
|
m_InjectLightingAndDensity.SetBuffer(kernel, "_PointLights", m_DummyCB);
|
|
return;
|
|
}
|
|
|
|
if (m_PointLightParams == null || m_PointLightParams.Length != count)
|
|
m_PointLightParams = new PointLightParams[count];
|
|
|
|
HashSet<FogLight> fogLights = LightManagerFogLights.Get();
|
|
|
|
int j = 0;
|
|
for (var x = fogLights.GetEnumerator(); x.MoveNext();)
|
|
{
|
|
var fl = x.Current;
|
|
if (fl == null || fl.type != FogLight.Type.Point || !fl.isOn)
|
|
continue;
|
|
|
|
Light light = fl.light;
|
|
m_PointLightParams[j].pos = light.transform.position;
|
|
float range = light.range * fl.m_RangeMult;
|
|
m_PointLightParams[j].range = 1.0f / (range * range);
|
|
m_PointLightParams[j].color = new Vector3(light.color.r, light.color.g, light.color.b) * light.intensity * fl.m_IntensityMult;
|
|
j++;
|
|
}
|
|
|
|
// TODO: try a constant buffer with setfloats instead for perf
|
|
m_PointLightParamsCB.SetData(m_PointLightParams);
|
|
m_InjectLightingAndDensity.SetBuffer(kernel, "_PointLights", m_PointLightParamsCB);
|
|
}
|
|
|
|
void SetUpFogEllipsoidBuffers(int kernel)
|
|
{
|
|
int count = 0;
|
|
HashSet<FogEllipsoid> fogEllipsoids = LightManagerFogEllipsoids.Get();
|
|
for (var x = fogEllipsoids.GetEnumerator(); x.MoveNext();)
|
|
{
|
|
var fe = x.Current;
|
|
if (fe != null && fe.enabled && fe.gameObject.activeSelf)
|
|
count++;
|
|
}
|
|
|
|
m_InjectLightingAndDensity.SetFloat("_FogEllipsoidsCount", count);
|
|
if (count == 0)
|
|
{
|
|
// Can't not set the buffer
|
|
m_InjectLightingAndDensity.SetBuffer(kernel, "_FogEllipsoids", m_DummyCB);
|
|
return;
|
|
}
|
|
|
|
if (m_FogEllipsoidParams == null || m_FogEllipsoidParams.Length != count)
|
|
m_FogEllipsoidParams = new FogEllipsoidParams[count];
|
|
|
|
int j = 0;
|
|
for (var x = fogEllipsoids.GetEnumerator(); x.MoveNext();)
|
|
{
|
|
var fe = x.Current;
|
|
if (fe == null || !fe.enabled || !fe.gameObject.activeSelf)
|
|
continue;
|
|
|
|
Transform t = fe.transform;
|
|
|
|
m_FogEllipsoidParams[j].pos = t.position;
|
|
m_FogEllipsoidParams[j].radius = fe.m_Radius * fe.m_Radius;
|
|
m_FogEllipsoidParams[j].axis = -t.up;
|
|
m_FogEllipsoidParams[j].stretch = 1.0f / fe.m_Stretch - 1.0f;
|
|
m_FogEllipsoidParams[j].density = fe.m_Density;
|
|
m_FogEllipsoidParams[j].noiseAmount = fe.m_NoiseAmount;
|
|
m_FogEllipsoidParams[j].noiseSpeed = fe.m_NoiseSpeed;
|
|
m_FogEllipsoidParams[j].noiseScale = fe.m_NoiseScale;
|
|
m_FogEllipsoidParams[j].feather = 1.0f - fe.m_Feather;
|
|
m_FogEllipsoidParams[j].blend = fe.m_Blend == FogEllipsoid.Blend.Additive ? 0 : 1;
|
|
j++;
|
|
}
|
|
|
|
m_FogEllipsoidParamsCB.SetData(m_FogEllipsoidParams);
|
|
m_InjectLightingAndDensity.SetBuffer(kernel, "_FogEllipsoids", m_FogEllipsoidParamsCB);
|
|
}
|
|
|
|
FogLight GetDirectionalLight()
|
|
{
|
|
HashSet<FogLight> fogLights = LightManagerFogLights.Get();
|
|
FogLight fogLight = null;
|
|
|
|
for (var x = fogLights.GetEnumerator(); x.MoveNext();)
|
|
{
|
|
var fl = x.Current;
|
|
if (fl == null || fl.type != FogLight.Type.Directional || !fl.isOn)
|
|
continue;
|
|
|
|
fogLight = fl;
|
|
break;
|
|
}
|
|
|
|
return fogLight;
|
|
}
|
|
|
|
FogLight m_DirectionalLight;
|
|
|
|
void OnPreRender()
|
|
{
|
|
m_DirectionalLight = GetDirectionalLight();
|
|
|
|
if (m_DirectionalLight != null)
|
|
m_DirectionalLight.UpdateDirectionalShadowmap();
|
|
}
|
|
|
|
float[] m_dirLightColor;
|
|
float[] m_dirLightDir;
|
|
|
|
void SetUpDirectionalLight(int kernel)
|
|
{
|
|
if (m_dirLightColor == null || m_dirLightColor.Length != 3)
|
|
m_dirLightColor = new float[3];
|
|
if (m_dirLightDir == null || m_dirLightDir.Length != 3)
|
|
m_dirLightDir = new float[3];
|
|
|
|
if (m_DirectionalLight == null)
|
|
{
|
|
m_dirLightColor[0] = 0;
|
|
m_dirLightColor[1] = 0;
|
|
m_dirLightColor[2] = 0;
|
|
m_InjectLightingAndDensity.SetFloats("_DirLightColor", m_dirLightColor);
|
|
return;
|
|
}
|
|
|
|
m_DirectionalLight.SetUpDirectionalShadowmapForSampling(m_DirectionalLight.m_Shadows, m_InjectLightingAndDensity, kernel);
|
|
// TODO: if above fails, disable shadows
|
|
|
|
Light light = m_DirectionalLight.light;
|
|
Vector4 color = light.color;
|
|
color *= light.intensity * m_DirectionalLight.m_IntensityMult;
|
|
m_dirLightColor[0] = color.x;
|
|
m_dirLightColor[1] = color.y;
|
|
m_dirLightColor[2] = color.z;
|
|
m_InjectLightingAndDensity.SetFloats("_DirLightColor", m_dirLightColor);
|
|
Vector3 dir = light.GetComponent<Transform>().forward;
|
|
m_dirLightDir[0] = dir.x;
|
|
m_dirLightDir[1] = dir.y;
|
|
m_dirLightDir[2] = dir.z;
|
|
m_InjectLightingAndDensity.SetFloats("_DirLightDir", m_dirLightDir);
|
|
m_InjectLightingAndDensity.SetFloat("_DirLightOffset", m_dirLightOffset);
|
|
m_InjectLightingAndDensity.SetFloat("_VSMBias", m_vsmBias);
|
|
m_InjectLightingAndDensity.SetFloat("_DirBias", m_dirBias);
|
|
}
|
|
|
|
float[] m_fogParams;
|
|
float[] m_windDir;
|
|
float[] m_ambientLight;
|
|
float[] m_froxelResolution;
|
|
|
|
void SetUpForScatter(int kernel)
|
|
{
|
|
SanitizeInput();
|
|
InitResources();
|
|
SetFrustumRays();
|
|
|
|
if (m_froxelResolution == null)
|
|
{
|
|
m_froxelResolution = new float[3];
|
|
m_froxelResolution[0] = froxelResolution.x;
|
|
m_froxelResolution[1] = froxelResolution.y;
|
|
m_froxelResolution[2] = froxelResolution.z;
|
|
}
|
|
m_Scatter.SetFloats("_FroxelResolution", m_froxelResolution);
|
|
m_InjectLightingAndDensity.SetFloats("_FroxelResolution", m_froxelResolution);
|
|
// Compensate for more light and density being injected in per world space meter when near and far are closer.
|
|
// TODO: Not quite correct yet.
|
|
float depthCompensation = (farClip - nearClip) * 0.01f;
|
|
m_InjectLightingAndDensity.SetFloat("_Density", m_GlobalDensityMult * 0.128f * depthCompensation);
|
|
m_InjectLightingAndDensity.SetFloat("_Intensity", m_GlobalIntensityMult);
|
|
m_InjectLightingAndDensity.SetFloat("_Anisotropy", m_Anisotropy);
|
|
m_InjectLightingAndDensity.SetTexture(kernel, "_VolumeInject", m_VolumeInject);
|
|
m_InjectLightingAndDensity.SetTexture(kernel, "_Noise", m_Noise);
|
|
|
|
if (m_fogParams == null || m_fogParams.Length != 4)
|
|
m_fogParams = new float[4];
|
|
if (m_windDir == null || m_windDir.Length != 3)
|
|
m_windDir = new float[3];
|
|
if (m_ambientLight == null || m_ambientLight.Length != 3)
|
|
m_ambientLight = new float[3];
|
|
m_fogParams[0] = m_ConstantFog;
|
|
m_fogParams[1] = m_HeightFogExponent;
|
|
m_fogParams[2] = m_HeightFogOffset;
|
|
m_fogParams[3] = m_HeightFogAmount;
|
|
|
|
m_InjectLightingAndDensity.SetFloats("_FogParams", m_fogParams);
|
|
m_InjectLightingAndDensity.SetFloat("_NoiseFogAmount", m_NoiseFogAmount);
|
|
m_InjectLightingAndDensity.SetFloat("_NoiseFogScale", m_NoiseFogScale);
|
|
m_InjectLightingAndDensity.SetFloat("_WindSpeed", m_Wind == null ? 0 : m_Wind.m_Speed);
|
|
Vector3 windDir = m_Wind == null ? Vector3.forward : m_Wind.transform.forward;
|
|
m_windDir[0] = windDir.x;
|
|
m_windDir[1] = windDir.y;
|
|
m_windDir[2] = windDir.z;
|
|
m_InjectLightingAndDensity.SetFloats("_WindDir", m_windDir);
|
|
m_InjectLightingAndDensity.SetFloat("_Time", Time.time);
|
|
m_InjectLightingAndDensity.SetFloat("_NearOverFarClip", nearClip / farClip);
|
|
Color ambient = m_AmbientLightColor * m_AmbientLightIntensity * 0.1f;
|
|
m_ambientLight[0] = ambient.r;
|
|
m_ambientLight[1] = ambient.g;
|
|
m_ambientLight[2] = ambient.b;
|
|
m_InjectLightingAndDensity.SetFloats("_AmbientLight", m_ambientLight);
|
|
|
|
SetUpPointLightBuffers(kernel);
|
|
SetUpFogEllipsoidBuffers(kernel);
|
|
SetUpDirectionalLight(kernel);
|
|
}
|
|
|
|
void Scatter()
|
|
{
|
|
// Inject lighting and density
|
|
int kernel = m_InjectLightingAndDensity.FindKernel("CSMain");
|
|
SetUpForScatter(kernel);
|
|
m_InjectLightingAndDensity.Dispatch(kernel, froxelResolution.x / m_InjectNumThreads.x, froxelResolution.y / m_InjectNumThreads.y, froxelResolution.z / m_InjectNumThreads.z);
|
|
|
|
// Solve scattering
|
|
kernel = m_Scatter.FindKernel("CSMain");
|
|
m_Scatter.SetTexture(kernel, "_VolumeInject", m_VolumeInject);
|
|
m_Scatter.SetTexture(kernel, "_VolumeScatter", m_VolumeScatter);
|
|
m_Scatter.Dispatch(kernel, froxelResolution.x / m_ScatterNumThreads.x, froxelResolution.y / m_ScatterNumThreads.y, 1);
|
|
}
|
|
|
|
void DebugDisplay(RenderTexture src, RenderTexture dest)
|
|
{
|
|
InitMaterial(ref m_DebugMaterial, m_DebugShader);
|
|
|
|
m_DebugMaterial.SetTexture("_VolumeInject", m_VolumeInject);
|
|
m_DebugMaterial.SetTexture("_VolumeScatter", m_VolumeScatter);
|
|
m_DebugMaterial.SetFloat("_Z", m_Z);
|
|
|
|
m_DebugMaterial.SetTexture("_MainTex", src);
|
|
|
|
Graphics.Blit(src, dest, m_DebugMaterial);
|
|
}
|
|
|
|
void SetUpGlobalFogSamplingUniforms(int width, int height)
|
|
{
|
|
Shader.SetGlobalTexture("_VolumeScatter", m_VolumeScatter);
|
|
Shader.SetGlobalVector("_Screen_TexelSize", new Vector4(1.0f / width, 1.0f / height, width, height));
|
|
Shader.SetGlobalVector("_VolumeScatter_TexelSize", new Vector4(1.0f / froxelResolution.x, 1.0f / froxelResolution.y, 1.0f / froxelResolution.z, 0));
|
|
Shader.SetGlobalFloat("_CameraFarOverMaxFar", cam.farClipPlane / farClip);
|
|
Shader.SetGlobalFloat("_NearOverFarClip", nearClip / farClip);
|
|
}
|
|
|
|
[ImageEffectOpaque]
|
|
void OnRenderImage(RenderTexture src, RenderTexture dest)
|
|
{
|
|
if (!CheckSupport())
|
|
{
|
|
Debug.LogError(GetUnsupportedErrorMessage());
|
|
Graphics.Blit(src, dest);
|
|
enabled = false;
|
|
return;
|
|
}
|
|
|
|
if (m_Debug)
|
|
{
|
|
DebugDisplay(src, dest);
|
|
return;
|
|
}
|
|
|
|
Scatter();
|
|
|
|
InitMaterial(ref m_ApplyToOpaqueMaterial, m_ApplyToOpaqueShader);
|
|
|
|
// TODO: This shouldn't be needed. Is it because the shader doesn't have the Property block?
|
|
m_ApplyToOpaqueMaterial.SetTexture("_MainTex", src);
|
|
|
|
SetUpGlobalFogSamplingUniforms(src.width, src.height);
|
|
|
|
Graphics.Blit(src, dest, m_ApplyToOpaqueMaterial);
|
|
|
|
VolumetricFogInForward(true);
|
|
}
|
|
|
|
void OnPostRender()
|
|
{
|
|
VolumetricFogInForward(false);
|
|
}
|
|
|
|
void VolumetricFogInForward(bool enable)
|
|
{
|
|
if (enable)
|
|
Shader.EnableKeyword("VOLUMETRIC_FOG");
|
|
else
|
|
Shader.DisableKeyword("VOLUMETRIC_FOG");
|
|
}
|
|
|
|
Vector3 ViewportToLocalPoint(Camera c, Transform t, Vector3 p)
|
|
{
|
|
// TODO: viewporttoworldpoint inverts the clip-to-world matrix every time without caching it.
|
|
return t.InverseTransformPoint(c.ViewportToWorldPoint(p));
|
|
}
|
|
|
|
static readonly Vector2[] frustumUVs =
|
|
new Vector2[] { new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1) };
|
|
static float[] frustumRays = new float[16];
|
|
|
|
void SetFrustumRays()
|
|
{
|
|
float far = farClip;
|
|
Vector3 cameraPos = cam.transform.position;
|
|
Vector2[] uvs = frustumUVs;
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
Vector3 ray = cam.ViewportToWorldPoint(new Vector3(uvs[i].x, uvs[i].y, far)) - cameraPos;
|
|
frustumRays[i * 4 + 0] = ray.x;
|
|
frustumRays[i * 4 + 1] = ray.y;
|
|
frustumRays[i * 4 + 2] = ray.z;
|
|
frustumRays[i * 4 + 3] = 0;
|
|
}
|
|
|
|
m_InjectLightingAndDensity.SetVector("_CameraPos", cameraPos);
|
|
m_InjectLightingAndDensity.SetFloats("_FrustumRays", frustumRays);
|
|
}
|
|
|
|
void InitVolume(ref RenderTexture volume)
|
|
{
|
|
if (volume)
|
|
return;
|
|
|
|
volume = new RenderTexture(froxelResolution.x, froxelResolution.y, 0, RenderTextureFormat.ARGBHalf);
|
|
volume.volumeDepth = froxelResolution.z;
|
|
volume.dimension = UnityEngine.Rendering.TextureDimension.Tex3D;
|
|
volume.enableRandomWrite = true;
|
|
volume.antiAliasing = m_AntiAliasing;
|
|
volume.filterMode = m_FilterMode;
|
|
volume.Create();
|
|
}
|
|
|
|
void CreateBuffer(ref ComputeBuffer buffer, int count, int stride)
|
|
{
|
|
if (buffer != null && buffer.count == count)
|
|
return;
|
|
|
|
if (buffer != null)
|
|
{
|
|
buffer.Release();
|
|
buffer = null;
|
|
}
|
|
|
|
if (count <= 0)
|
|
return;
|
|
|
|
buffer = new ComputeBuffer(count, stride);
|
|
}
|
|
|
|
void InitResources()
|
|
{
|
|
// Volume
|
|
InitVolume(ref m_VolumeInject);
|
|
InitVolume(ref m_VolumeScatter);
|
|
|
|
// Compute buffers
|
|
int pointLightCount = 0, tubeLightCount = 0, areaLightCount = 0;
|
|
HashSet<FogLight> fogLights = LightManagerFogLights.Get();
|
|
for (var x = fogLights.GetEnumerator(); x.MoveNext();)
|
|
{
|
|
var fl = x.Current;
|
|
if (fl == null)
|
|
continue;
|
|
|
|
bool isOn = fl.isOn;
|
|
|
|
switch (fl.type)
|
|
{
|
|
case FogLight.Type.Point: if (isOn) pointLightCount++; break;
|
|
case FogLight.Type.Tube: if (isOn) tubeLightCount++; break;
|
|
case FogLight.Type.Area: if (isOn) areaLightCount++; break;
|
|
}
|
|
}
|
|
|
|
CreateBuffer(ref m_PointLightParamsCB, pointLightCount, Marshal.SizeOf(typeof(PointLightParams)));
|
|
HashSet<FogEllipsoid> fogEllipsoids = LightManagerFogEllipsoids.Get();
|
|
CreateBuffer(ref m_FogEllipsoidParamsCB, fogEllipsoids == null ? 0 : fogEllipsoids.Count, Marshal.SizeOf(typeof(FogEllipsoidParams)));
|
|
CreateBuffer(ref m_DummyCB, 1, 4);
|
|
|
|
//
|
|
}
|
|
|
|
void ReleaseTemporary(ref RenderTexture rt)
|
|
{
|
|
if (rt == null)
|
|
return;
|
|
|
|
RenderTexture.ReleaseTemporary(rt);
|
|
rt = null;
|
|
}
|
|
|
|
void InitMaterial(ref Material material, Shader shader)
|
|
{
|
|
if (material)
|
|
return;
|
|
|
|
if (!shader)
|
|
{
|
|
Debug.LogError("Missing shader");
|
|
return;
|
|
}
|
|
|
|
material = new Material(shader);
|
|
material.hideFlags = HideFlags.HideAndDontSave;
|
|
}
|
|
|
|
void OnDrawGizmosSelected()
|
|
{
|
|
Gizmos.matrix = transform.localToWorldMatrix;
|
|
|
|
if (m_ShowFroxelSlices)
|
|
{
|
|
Gizmos.color = Color.yellow * 0.25f;
|
|
|
|
for (int i = 0; i < froxelResolution.z; i++)
|
|
{
|
|
Gizmos.DrawFrustum(Vector3.zero, cam.fieldOfView, farClip / froxelResolution.z * i, nearClip, cam.aspect);
|
|
}
|
|
}
|
|
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawFrustum(Vector3.zero, cam.fieldOfView, farClip, nearClip, cam.aspect);
|
|
}
|
|
|
|
public static bool CheckSupport()
|
|
{
|
|
return SystemInfo.supportsComputeShaders;
|
|
}
|
|
|
|
public static string GetUnsupportedErrorMessage()
|
|
{
|
|
return "Volumetric Fog requires compute shaders and this platform doesn't support them. Disabling. \nDetected device type: " +
|
|
SystemInfo.graphicsDeviceType + ", version: " + SystemInfo.graphicsDeviceVersion;
|
|
}
|
|
}
|