1820 lines
73 KiB
C#
1820 lines
73 KiB
C#
|
using System;
|
|||
|
|
using System.Collections;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using System.Runtime.InteropServices;
|
|||
|
|
//using Unity.Mathematics;
|
|||
|
|
using UnityEngine;
|
|||
|
|
using UnityEngine.SceneManagement;
|
|||
|
|
using UnityEngine.Rendering;
|
|||
|
|
using UnityEngine.Experimental.Rendering;
|
|||
|
|
using UnityEngine.Rendering.Universal;
|
|||
|
|
using UnityEngine.XR;
|
|||
|
|
using Unity.Profiling;
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
using UnityEditor;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
class VolumeRenderingUtils //Importing some functions from HDRP to have simular terms
|
|||
|
|
{
|
|||
|
|
public static float MeanFreePathFromExtinction(float extinction)
|
|||
|
|
{
|
|||
|
|
return 1.0f / extinction;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static float ExtinctionFromMeanFreePath(float meanFreePath)
|
|||
|
|
{
|
|||
|
|
return 1.0f / meanFreePath;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static Vector3 AbsorptionFromExtinctionAndScattering(float extinction, Vector3 scattering)
|
|||
|
|
{
|
|||
|
|
return new Vector3(extinction, extinction, extinction) - scattering;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static Vector3 ScatteringFromExtinctionAndAlbedo(float extinction, Vector3 albedo)
|
|||
|
|
{
|
|||
|
|
return extinction * albedo;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static Vector3 AlbedoFromMeanFreePathAndScattering(float meanFreePath, Vector3 scattering)
|
|||
|
|
{
|
|||
|
|
return meanFreePath * scattering;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//TODO: Add semi dynamic lighting which is generated in the clipmap and not previously baked out. Will need smarter clipmap gen to avoid hitching.
|
|||
|
|
//Add cascading clipmaps to have higher detail up close and include father clipping without exploding memory.
|
|||
|
|
//Convert this to a render feature. This should remove the need for the platform switcher too because that would be handled by the quality settings pipeline asset instead
|
|||
|
|
|
|||
|
|
|
|||
|
|
//[RequireComponent(typeof( Camera ) )]
|
|||
|
|
[ExecuteInEditMode]
|
|||
|
|
public class VolumetricRendering : MonoBehaviour
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
#region variables
|
|||
|
|
static ProfilingSampler profileUpdateFunc = new ProfilingSampler("VolumetricRendering.UpdateFunc");
|
|||
|
|
static ProfilingSampler profileUpdateClipmap = new ProfilingSampler("VolumetricRendering.UpdateClipmap");
|
|||
|
|
|
|||
|
|
public float tempOffset = 0;
|
|||
|
|
Texture3D BlackTex; //Temp texture for
|
|||
|
|
Color clearColor = new Color(0.0f, 0.0f, 0.0f, 0f);
|
|||
|
|
|
|||
|
|
static VolumetricRendering lastClipmapUpdate;
|
|||
|
|
static VolumetricRendering lastBlur;
|
|||
|
|
static VolumetricRendering lastFroxelFog;
|
|||
|
|
static VolumetricRendering lastFroxelIntegrate;
|
|||
|
|
|
|||
|
|
|
|||
|
|
public Camera cam; //Main camera to base settings on
|
|||
|
|
private Camera activeCam;
|
|||
|
|
private UniversalAdditionalCameraData activeCamData;
|
|||
|
|
// Prevent script from trying to initialize itself twice
|
|||
|
|
bool hasInitialized;
|
|||
|
|
|
|||
|
|
// Sometimes, the volumetric register gets filled after the volumetric script initializes.
|
|||
|
|
// This means that the clipmaps will be empty until the player moves far enough to trigger
|
|||
|
|
// a clipmap update. Instead, set a bool that triggers the clipmaps to try to update every
|
|||
|
|
// frame until the volumtric registry contains >0 volumes
|
|||
|
|
bool VolumetricRegisterEmpty;
|
|||
|
|
|
|||
|
|
[HideInInspector] public bool VolumetricRegisterForceRefresh = false;
|
|||
|
|
|
|||
|
|
|
|||
|
|
// Debug counter to print a message every x frames
|
|||
|
|
int debugHeartBeatCount = 30;
|
|||
|
|
int debugHeartBeat = 0;
|
|||
|
|
|
|||
|
|
public VolumetricData volumetricData;
|
|||
|
|
[Range(0, 1)]
|
|||
|
|
public float reprojectionAmount = 0.95f;
|
|||
|
|
// [Tooltip("Does a final blur pass on the rendered fog")]
|
|||
|
|
// public bool FroxelBlur = false;
|
|||
|
|
|
|||
|
|
[HideInInspector]
|
|||
|
|
public enum BlurType {None, Gaussian};
|
|||
|
|
public BlurType FroxelBlur = BlurType.None;
|
|||
|
|
[Range(0, 1)]
|
|||
|
|
public float SliceDistributionUniformity = 0.5f;
|
|||
|
|
|
|||
|
|
[HideInInspector] public bool enableEditorPreview = false;
|
|||
|
|
//public Texture skytex;
|
|||
|
|
//[Header("Volumetric camera settings")]
|
|||
|
|
//[Tooltip("Near Clip plane")]
|
|||
|
|
//public float near = 1;
|
|||
|
|
//[Tooltip("Far Clip plane")]
|
|||
|
|
//public float far = 40;
|
|||
|
|
//[Tooltip("Resolution")]
|
|||
|
|
//public int FroxelWidthResolution = 128;
|
|||
|
|
//[Tooltip("Resolution")]
|
|||
|
|
//public int FroxelHeightResolution = 128;
|
|||
|
|
//[Tooltip("Resolution")]
|
|||
|
|
//public int FroxelDepthResolution = 64;
|
|||
|
|
////[Tooltip("Controls the bias of the froxel dispution. A value of 1 is linear. ")]
|
|||
|
|
////public float FroxelDispution;
|
|||
|
|
|
|||
|
|
//[Header("Prebaked clipmap settings")]
|
|||
|
|
//[Tooltip("Textile resolution per unit")]
|
|||
|
|
//public int ClipMapResolution = 128;
|
|||
|
|
//[Tooltip("Size of clipmap in units")]
|
|||
|
|
//public float ClipmapScale = 80;
|
|||
|
|
//[Tooltip("Distance (m) from previous sampling point to trigger resampling clipmap")]
|
|||
|
|
//public float ClipmapResampleThreshold = 1;
|
|||
|
|
|
|||
|
|
|
|||
|
|
Vector3 ClipmapTransform; //Have this follow the camera and resample when the camera moves enough
|
|||
|
|
Vector3 ClipmapCurrentPos; //chached location of previous sample point
|
|||
|
|
|
|||
|
|
private ComputeBuffer participatingMediaSphereBuffer;
|
|||
|
|
|
|||
|
|
[StructLayout(LayoutKind.Sequential)]
|
|||
|
|
struct MediaSphere
|
|||
|
|
{
|
|||
|
|
public Vector3 CenterPosition;
|
|||
|
|
public float LocalExtinction;
|
|||
|
|
public float LocalFalloff;
|
|||
|
|
public float LocalRange;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private const int MediaSphereStride = (3 + 1 + 1 + 1) * sizeof(float);
|
|||
|
|
int MediaCount;
|
|||
|
|
|
|||
|
|
|
|||
|
|
//public Matrix4x4 randomatrix;
|
|||
|
|
|
|||
|
|
//Required shaders
|
|||
|
|
[SerializeField, HideInInspector] ComputeShader FroxelFogCompute;
|
|||
|
|
[SerializeField, HideInInspector] ComputeShader FroxelIntegrationCompute;
|
|||
|
|
[SerializeField, HideInInspector] ComputeShader FroxelLocalFogCompute;
|
|||
|
|
[SerializeField, HideInInspector] ComputeShader ClipmapCompute;
|
|||
|
|
[SerializeField, HideInInspector] ComputeShader BlurCompute;
|
|||
|
|
|
|||
|
|
//Texture buffers
|
|||
|
|
RenderTexture ClipmapBufferA; //Sampling and combining baked maps asynchronously
|
|||
|
|
RenderTexture ClipmapBufferB; //Sampling and combining baked maps asynchronously
|
|||
|
|
RenderTexture ClipmapBufferC; //Sampling and combining baked maps asynchronously
|
|||
|
|
RenderTexture ClipmapBufferD; //Sampling and combining baked maps asynchronously //TODO: get rid of this extra buffer and bool
|
|||
|
|
bool FlipClipBufferNear = true;
|
|||
|
|
bool FlipClipBufferFar = true;
|
|||
|
|
|
|||
|
|
|
|||
|
|
RenderTexture FroxelBufferA; //Single froxel projection use for scattering and history reprojection
|
|||
|
|
RenderTexture FroxelBufferB; //for history reprojection
|
|||
|
|
|
|||
|
|
RenderTexture IntegrationBuffer; //Integration and stereo reprojection
|
|||
|
|
// RenderTexture IntegrationBufferB; //Integration and stereo reprojection
|
|||
|
|
RenderTexture BlurBuffer; //blur
|
|||
|
|
RenderTexture BlurBufferB; //blur
|
|||
|
|
|
|||
|
|
RenderTexture VolumetricResult;
|
|||
|
|
|
|||
|
|
// This is a sequence of 7 equidistant numbers from 1/14 to 13/14.
|
|||
|
|
// Each of them is the centroid of the interval of length 2/14.
|
|||
|
|
// They've been rearranged in a sequence of pairs {small, large}, s.t. (small + large) = 1.
|
|||
|
|
// That way, the running average position is close to 0.5.
|
|||
|
|
// | 6 | 2 | 4 | 1 | 5 | 3 | 7 |
|
|||
|
|
// | | | | o | | | |
|
|||
|
|
// | | o | | x | | | |
|
|||
|
|
// | | x | | x | | o | |
|
|||
|
|
// | | x | o | x | | x | |
|
|||
|
|
// | | x | x | x | o | x | |
|
|||
|
|
// | o | x | x | x | x | x | |
|
|||
|
|
// | x | x | x | x | x | x | o |
|
|||
|
|
// | x | x | x | x | x | x | x |
|
|||
|
|
float[] m_zSeq = { 7.0f / 14.0f, 3.0f / 14.0f, 11.0f / 14.0f, 5.0f / 14.0f, 9.0f / 14.0f, 1.0f / 14.0f, 13.0f / 14.0f };
|
|||
|
|
|
|||
|
|
|
|||
|
|
// Ref: https://en.wikipedia.org/wiki/Close-packing_of_equal_spheres
|
|||
|
|
// The returned {x, y} coordinates (and all spheres) are all within the (-0.5, 0.5)^2 range.
|
|||
|
|
// The pattern has been rotated by 15 degrees to maximize the resolution along X and Y:
|
|||
|
|
// https://www.desmos.com/calculator/kcpfvltz7c
|
|||
|
|
static void GetHexagonalClosePackedSpheres7(Vector2[] coords)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
float r = 0.17054068870105443882f;
|
|||
|
|
float d = 2 * r;
|
|||
|
|
float s = r * Mathf.Sqrt(3);
|
|||
|
|
|
|||
|
|
// Try to keep the weighted average as close to the center (0.5) as possible.
|
|||
|
|
// (7)(5) ( )( ) ( )( ) ( )( ) ( )( ) ( )(o) ( )(x) (o)(x) (x)(x)
|
|||
|
|
// (2)(1)(3) ( )(o)( ) (o)(x)( ) (x)(x)(o) (x)(x)(x) (x)(x)(x) (x)(x)(x) (x)(x)(x) (x)(x)(x)
|
|||
|
|
// (4)(6) ( )( ) ( )( ) ( )( ) (o)( ) (x)( ) (x)(o) (x)(x) (x)(x)
|
|||
|
|
coords[0] = new Vector2(0, 0);
|
|||
|
|
coords[1] = new Vector2(-d, 0);
|
|||
|
|
coords[2] = new Vector2(d, 0);
|
|||
|
|
coords[3] = new Vector2(-r, -s);
|
|||
|
|
coords[4] = new Vector2(r, s);
|
|||
|
|
coords[5] = new Vector2(r, -s);
|
|||
|
|
coords[6] = new Vector2(-r, s);
|
|||
|
|
|
|||
|
|
// Rotate the sampling pattern by 15 degrees.
|
|||
|
|
const float cos15 = 0.96592582628906828675f;
|
|||
|
|
const float sin15 = 0.25881904510252076235f;
|
|||
|
|
|
|||
|
|
for (int i = 0; i < 7; i++)
|
|||
|
|
{
|
|||
|
|
Vector2 coord = coords[i];
|
|||
|
|
|
|||
|
|
coords[i].x = coord.x * cos15 - coord.y * sin15;
|
|||
|
|
coords[i].y = coord.x * sin15 + coord.y * cos15;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Vector2[] m_xySeq = new Vector2[7];
|
|||
|
|
|
|||
|
|
//camera.aspect no longer returns the XR aspect ratio but rather the final viewport's. Rather worthless now.
|
|||
|
|
float CamAspectRatio;
|
|||
|
|
//camera.fieldOfView is unreliable because the physical camera toggle will return the incorrect fov.
|
|||
|
|
// float CamFieldOfView = XRSettings.vi
|
|||
|
|
|
|||
|
|
|
|||
|
|
//Unity implemented their own cookie method, so we'll just tie into that system instead. This is no longer needed.
|
|||
|
|
/// Dynamic Light Projection///
|
|||
|
|
// [SerializeField, HideInInspector] List<Light> Lights; // TODO: Make this a smart dynamic list not living here
|
|||
|
|
// public struct LightObject
|
|||
|
|
// {
|
|||
|
|
// public Matrix4x4 LightProjectionMatrix;
|
|||
|
|
// public Vector3 LightPosition;
|
|||
|
|
// public Vector4 LightColor;
|
|||
|
|
// public int LightCookie; //TODO: Add general light cookie system to render engine
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
//Figure out how much data is in the struct above
|
|||
|
|
// int LightObjectStride = sizeof(float) * 4 * 4 + sizeof(float) * 3 + sizeof(float) * 4 + sizeof(int);
|
|||
|
|
// Texture2DArray LightProjectionTextures; // TODO: Make this a smart dynamic list pulling from light cookies
|
|||
|
|
// private static List<LightObject> LightObjects;
|
|||
|
|
// ComputeBuffer LightBuffer;
|
|||
|
|
|
|||
|
|
/// END Dynamic Light Projection///
|
|||
|
|
///
|
|||
|
|
|
|||
|
|
// public Texture2D BlueNoise; //Temp ref
|
|||
|
|
|
|||
|
|
//AABB
|
|||
|
|
|
|||
|
|
//Stored compute shader IDs and numbers
|
|||
|
|
|
|||
|
|
protected int ScatteringKernel = 0;
|
|||
|
|
protected int IntegrateKernel = 0;
|
|||
|
|
protected int BlurKernelX = 0;
|
|||
|
|
protected int BlurKernelY = 0;
|
|||
|
|
|
|||
|
|
Matrix4x4 matScaleBias;
|
|||
|
|
Vector3 ThreadsToDispatch;
|
|||
|
|
|
|||
|
|
//Stored shader variable name IDs
|
|||
|
|
|
|||
|
|
// Constants so the VolumetricConstant script can access the names
|
|||
|
|
// The texture/buffers associated with each name will get set
|
|||
|
|
// as shader globals just before the camera associated with this
|
|||
|
|
// script renders by the render pipeline, so only that camera uses
|
|||
|
|
// the volumetrics rendered by this script.
|
|||
|
|
public const string resultTextureName = "_VolumetricResult";
|
|||
|
|
public const string shaderCBName = "VolumetricsCB";
|
|||
|
|
public const string volumetricKWName = "_VOLUMETRICS_ENABLED";
|
|||
|
|
|
|||
|
|
int ID_VolumetricResult = Shader.PropertyToID(resultTextureName);
|
|||
|
|
int ID_VolumetricsCB = Shader.PropertyToID(shaderCBName); // not actually used now since this script doesn't set the constant buffer as the global
|
|||
|
|
|
|||
|
|
int ID_Result = Shader.PropertyToID("Result");
|
|||
|
|
int ID_InLightingTexture = Shader.PropertyToID("InLightingTexture");
|
|||
|
|
int ID_InTex = Shader.PropertyToID("InTex");
|
|||
|
|
int ID_LightProjectionTextureArray = Shader.PropertyToID("LightProjectionTextureArray");
|
|||
|
|
int ID_VolumetricClipmapTexture = Shader.PropertyToID("_VolumetricClipmapTexture");
|
|||
|
|
int ID_VolumetricClipmapTexture2 = Shader.PropertyToID("_VolumetricClipmapTexture2");
|
|||
|
|
int ID_PreResult = Shader.PropertyToID("PreResult");
|
|||
|
|
int ID_VolumeMap = Shader.PropertyToID("VolumeMap");
|
|||
|
|
int ID_PreviousFrameLighting = Shader.PropertyToID("PreviousFrameLighting");
|
|||
|
|
int ID_HistoryBuffer = Shader.PropertyToID("HistoryBuffer");
|
|||
|
|
int ID_LeftEyeMatrix = Shader.PropertyToID("LeftEyeMatrix");
|
|||
|
|
int ID_RightEyeMatrix = Shader.PropertyToID("RightEyeMatrix");
|
|||
|
|
int ID_ClipmapScale0 = Shader.PropertyToID("ClipmapScale");
|
|||
|
|
int ID_ClipmapScale1 = Shader.PropertyToID("_ClipmapScale");
|
|||
|
|
int ID_ClipmapScale2 = Shader.PropertyToID("_ClipmapScale2");
|
|||
|
|
int ID_ClipmapWorldPosition = Shader.PropertyToID("ClipmapWorldPosition");
|
|||
|
|
int ID_VBufferUnitDepthTexelSpacing = Shader.PropertyToID("_VBufferUnitDepthTexelSpacing");
|
|||
|
|
int ID_VolZBufferParams = Shader.PropertyToID("_VolZBufferParams");
|
|||
|
|
int ID_GlobalExtinction = Shader.PropertyToID("_GlobalExtinction");
|
|||
|
|
int ID_StaticLightMultiplier = Shader.PropertyToID("_StaticLightMultiplier");
|
|||
|
|
int ID_GlobalScattering = Shader.PropertyToID("_GlobalScattering");
|
|||
|
|
int ID_VolumeWorldSize = Shader.PropertyToID("VolumeWorldSize");
|
|||
|
|
int ID_VolumeWorldPosition = Shader.PropertyToID("VolumeWorldPosition");
|
|||
|
|
|
|||
|
|
private int ID_media_sphere_buffer_length = Shader.PropertyToID("media_sphere_buffer_length");
|
|||
|
|
private int ID_media_sphere_buffer = Shader.PropertyToID("media_sphere_buffer");
|
|||
|
|
|
|||
|
|
int ID_ClipMapGenKern;
|
|||
|
|
int ID_ClipMapClearKern;
|
|||
|
|
int ID_ClipMapHeightKern;
|
|||
|
|
|
|||
|
|
//Froxel Ids
|
|||
|
|
int PerFrameConstBufferID = Shader.PropertyToID("PerFrameCB");
|
|||
|
|
|
|||
|
|
//int CameraProjectionMatrixID = Shader.PropertyToID("CameraProjectionMatrix");
|
|||
|
|
//int TransposedCameraProjectionMatrixID = Shader.PropertyToID("TransposedCameraProjectionMatrix");
|
|||
|
|
//int inverseCameraProjectionMatrixID = Shader.PropertyToID("inverseCameraProjectionMatrix");
|
|||
|
|
int PreviousFrameMatrixID = Shader.PropertyToID("PreviousFrameMatrix");
|
|||
|
|
//int Camera2WorldID = Shader.PropertyToID("Camera2World");
|
|||
|
|
//int CameraPositionID = Shader.PropertyToID("CameraPosition");
|
|||
|
|
//Clipmap IDs
|
|||
|
|
//int CameraMotionVectorID = Shader.PropertyToID("CameraMotionVector");
|
|||
|
|
//int ClipmapTextureID = Shader.PropertyToID("_ClipmapTexture");
|
|||
|
|
//int ClipmapTextureID2 = Shader.PropertyToID("_VolumetricClipmapTexture"); //TODO: Make these two the same name
|
|||
|
|
|
|||
|
|
int ClipmapScaleID = Shader.PropertyToID("_ClipmapScale");
|
|||
|
|
int ClipmapTransformID = Shader.PropertyToID("_ClipmapPosition");
|
|||
|
|
|
|||
|
|
// int LightObjectsID = Shader.PropertyToID("LightObjects");
|
|||
|
|
|
|||
|
|
//Temp Jitter stuff
|
|||
|
|
int tempjitter = 0; //TEMP jitter switcher thing
|
|||
|
|
[Header("Extra variables"), Range(0, 1)]
|
|||
|
|
float[] jitters = new float[2] { 0.0f, 0.5f };
|
|||
|
|
|
|||
|
|
//GlobalKeyword VolumetricsKW;
|
|||
|
|
//Previous view matrix data
|
|||
|
|
|
|||
|
|
Matrix4x4 PreviousFrameMatrix = Matrix4x4.identity;
|
|||
|
|
Matrix4x4 LeftEyeMatrix;
|
|||
|
|
Matrix4x4 RightEyeMatrix;
|
|||
|
|
Vector3 PreviousCameraPosition;
|
|||
|
|
Vector3 previousPos;
|
|||
|
|
Quaternion previousQuat;
|
|||
|
|
Vector4 VolZBufferParams;
|
|||
|
|
|
|||
|
|
float ZPlaneTexelSpacing;
|
|||
|
|
//float Extinction;
|
|||
|
|
//Color ExtinctionColor;
|
|||
|
|
|
|||
|
|
//General fog settings
|
|||
|
|
// [HideInInspector]
|
|||
|
|
[Header("Base values that are overridden by Volumes")]
|
|||
|
|
public Color albedo = Color.white;
|
|||
|
|
// public Color extinctionTint = Color.white;
|
|||
|
|
public float meanFreePath = 15.0f;
|
|||
|
|
public float StaticLightMultiplier = 1.0f;
|
|||
|
|
|
|||
|
|
private ComputeBuffer ShaderConstantBuffer;
|
|||
|
|
private ComputeBuffer ComputePerFrameConstantBuffer;
|
|||
|
|
private ComputeBuffer StepAddPerFrameConstantBuffer;
|
|||
|
|
|
|||
|
|
[StructLayout(LayoutKind.Sequential)]
|
|||
|
|
struct ShaderConstants
|
|||
|
|
{
|
|||
|
|
public Matrix4x4 TransposedCameraProjectionMatrix;
|
|||
|
|
public Matrix4x4 CameraProjectionMatrix;
|
|||
|
|
public Vector4 _VBufferDistanceEncodingParams;
|
|||
|
|
public Vector4 _VolumetricResultDim;
|
|||
|
|
public Vector3 _VolCameraPos;
|
|||
|
|
}
|
|||
|
|
public const int ShaderConstantsCount = 43;
|
|||
|
|
public const int ShaderConstantsSize = ShaderConstantsCount * sizeof(float);
|
|||
|
|
|
|||
|
|
|
|||
|
|
[StructLayout(LayoutKind.Sequential)]
|
|||
|
|
struct ScatteringPerFrameConstants
|
|||
|
|
{
|
|||
|
|
public Matrix4x4 _VBufferCoordToViewDirWS;
|
|||
|
|
public Matrix4x4 _PrevViewProjMatrix;
|
|||
|
|
public Matrix4x4 _ViewMatrix;
|
|||
|
|
public Matrix4x4 TransposedCameraProjectionMatrix;
|
|||
|
|
public Matrix4x4 CameraProjectionMatrix;
|
|||
|
|
public Vector4 _VBufferDistanceEncodingParams;
|
|||
|
|
public Vector4 _VBufferDistanceDecodingParams;
|
|||
|
|
public Vector4 SeqOffset;
|
|||
|
|
public Vector4 CameraPosition;
|
|||
|
|
public Vector4 CameraMotionVector;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private const int ScatterPerFrameCount = 100;
|
|||
|
|
|
|||
|
|
|
|||
|
|
[StructLayout(LayoutKind.Sequential)]
|
|||
|
|
struct StepAddPerFrameConstants
|
|||
|
|
{
|
|||
|
|
public Vector4 _VBufferDistanceDecodingParams;
|
|||
|
|
public Vector3 SeqOffset;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private const int StepAddPerFrameCount = 7;
|
|||
|
|
|
|||
|
|
private static float[] VolStructToArray<T>(T rawData, int count, int size) where T : struct
|
|||
|
|
{
|
|||
|
|
var pinnedRawData = GCHandle.Alloc(rawData, GCHandleType.Pinned);
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
var pinnedRawDataPtr = pinnedRawData.AddrOfPinnedObject();
|
|||
|
|
float[] data = new float[size];
|
|||
|
|
Marshal.Copy(pinnedRawDataPtr, data, 0, count);
|
|||
|
|
return data;
|
|||
|
|
}
|
|||
|
|
finally
|
|||
|
|
{
|
|||
|
|
pinnedRawData.Free();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
private void Awake()
|
|||
|
|
{
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
|
|||
|
|
if (Application.isPlaying || activeCam == null)
|
|||
|
|
{
|
|||
|
|
activeCam = cam;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
//Debug.Log("Volumetric Editor On Awake");
|
|||
|
|
activeCam = SceneView.lastActiveSceneView.camera;
|
|||
|
|
}
|
|||
|
|
#else
|
|||
|
|
activeCam = cam;
|
|||
|
|
activeCamData = cam.GetComponent<UniversalAdditionalCameraData>();
|
|||
|
|
if (activeCam.usePhysicalProperties == true) Debug.LogError("Physical camera is not properlly supportted by Unity and WILL mess up XR calulations like voulmetrics and LoDs");
|
|||
|
|
// cam = GetComponent<Camera>();
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
void Start() {
|
|||
|
|
//#if !UNITY_EDITOR
|
|||
|
|
Intialize();
|
|||
|
|
//#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// bool createdLightProjectionTexture = false;
|
|||
|
|
// void CheckCookieList()
|
|||
|
|
// {
|
|||
|
|
// if (LightProjectionTextures != null) return;
|
|||
|
|
// LightProjectionTextures = new Texture2DArray(1, 1, 1, TextureFormat.RGBA32, false);
|
|||
|
|
// LightProjectionTextures.hideFlags = HideFlags.DontSave;
|
|||
|
|
// LightProjectionTextures.name = activeCam.name + " Volumetric Light Cookies";
|
|||
|
|
// createdLightProjectionTexture = true;
|
|||
|
|
// //Debug.Log("Made blank cookie sheet");
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
//void dedbugRTC()
|
|||
|
|
//{
|
|||
|
|
// RenderTexture.active = (RenderTexture)skytex;
|
|||
|
|
// GL.Clear(true, true, Color.yellow);
|
|||
|
|
// RenderTexture.active = null;
|
|||
|
|
|
|||
|
|
//}
|
|||
|
|
//void SetSkyTexture(Texture cubemap)
|
|||
|
|
//{
|
|||
|
|
// // cam.RenderToCubemap((Cubemap)cubemap);
|
|||
|
|
// // dedbugRTC();
|
|||
|
|
// Shader.SetGlobalTexture("_SkyTexture", cubemap);
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
bool VerifyVolumetricRegisters()
|
|||
|
|
{
|
|||
|
|
//Add realtime light check here too
|
|||
|
|
if (VolumetricRegisters.volumetricAreas.Count > 0) //brute force check
|
|||
|
|
// if (VolumetricRegisters.volumetricAreas.Count > 0)
|
|||
|
|
{
|
|||
|
|
Debug.Log(VolumetricRegisters.volumetricAreas.Count + " Volumes ready to render");
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
Debug.Log("No Volumetric volumes in " + SceneManager.GetActiveScene().name + ". Disabling froxel rendering.");
|
|||
|
|
this.enabled = false;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void CheckOverrideVolumes() //TODO: Is there a better way to do this?
|
|||
|
|
{
|
|||
|
|
//UniversalRenderPipeline.UpdateVolumeFramework(activeCam, activeCamData);
|
|||
|
|
|
|||
|
|
var stack = VolumeManager.instance.stack;
|
|||
|
|
|
|||
|
|
var Volumetrics = stack.GetComponent<Volumetrics>();
|
|||
|
|
if (Volumetrics != null)
|
|||
|
|
Volumetrics.PushFogShaderParameters();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void IntializeBlur(RenderTextureDescriptor rtdiscrpt)
|
|||
|
|
{
|
|||
|
|
BlurBuffer = new RenderTexture(rtdiscrpt);
|
|||
|
|
BlurBuffer.name = activeCam.name + "_BlurBuffer";
|
|||
|
|
BlurBuffer.graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat;
|
|||
|
|
BlurBuffer.enableRandomWrite = true;
|
|||
|
|
BlurBuffer.Create();
|
|||
|
|
Clear3DTexture(BlurBuffer);
|
|||
|
|
|
|||
|
|
|
|||
|
|
BlurBufferB = new RenderTexture(rtdiscrpt);
|
|||
|
|
BlurBuffer.name = activeCam.name + "_BlurBufferB";
|
|||
|
|
BlurBufferB.graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat;
|
|||
|
|
BlurBufferB.enableRandomWrite = true;
|
|||
|
|
BlurBufferB.Create();
|
|||
|
|
Clear3DTexture(BlurBufferB);
|
|||
|
|
|
|||
|
|
BlurKernelX = BlurCompute.FindKernel("VolBlurX");
|
|||
|
|
BlurKernelY = BlurCompute.FindKernel("VolBlurY");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void Intialize()
|
|||
|
|
{
|
|||
|
|
if (hasInitialized)
|
|||
|
|
{
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (cam == null)
|
|||
|
|
{
|
|||
|
|
Debug.LogWarning("Volumetric Rendering Script with no camera assigned, disabling");
|
|||
|
|
this.enabled = false;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
AssemblyReloadEvents.beforeAssemblyReload += CleanupOnReload;
|
|||
|
|
#endif
|
|||
|
|
activeCam = cam;
|
|||
|
|
activeCamData = activeCam?.GetComponent<UniversalAdditionalCameraData>();
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
if (!Application.isPlaying && !enableEditorPreview)
|
|||
|
|
{
|
|||
|
|
//Debug.Log("Intialize disabled volumetrics");
|
|||
|
|
disable();
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
if (activeCamData == null)
|
|||
|
|
{
|
|||
|
|
activeCam = null;
|
|||
|
|
Debug.LogWarning("Volumetric Rendering: Assigned camera is missing a Universal Additional Camera Data component, disabling");
|
|||
|
|
this.enabled = false;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//Debug.Log("Volumetric Renderer Initialized");
|
|||
|
|
//DebugPrintTextureIDs();
|
|||
|
|
ShaderConstantBuffer = new ComputeBuffer(1, ShaderConstantsSize, ComputeBufferType.Constant);
|
|||
|
|
ComputePerFrameConstantBuffer = new ComputeBuffer(1, ScatterPerFrameCount * sizeof(float), ComputeBufferType.Constant);
|
|||
|
|
StepAddPerFrameConstantBuffer = new ComputeBuffer(1, StepAddPerFrameCount * sizeof(float), ComputeBufferType.Constant);
|
|||
|
|
int mediaCount = VolumetricRegisters.VolumetricMediaEntities.Count;
|
|||
|
|
MediaCount = Math.Max(mediaCount, 1);
|
|||
|
|
participatingMediaSphereBuffer = new ComputeBuffer(MediaCount, MediaSphereStride, ComputeBufferType.Structured);
|
|||
|
|
|
|||
|
|
|
|||
|
|
//activeCameraState = activeCam.isActiveAndEnabled;
|
|||
|
|
CheckOverrideVolumes();
|
|||
|
|
// if (VerifyVolumetricRegisters() == false) return; //Check registers to see if there's anything to render. If not, then disable system. TODO: Remove this
|
|||
|
|
// CheckCookieList();
|
|||
|
|
|
|||
|
|
|
|||
|
|
// SetSkyTexture( skytex);
|
|||
|
|
|
|||
|
|
//Making prescaled matrix
|
|||
|
|
matScaleBias = Matrix4x4.identity;
|
|||
|
|
matScaleBias.m00 = -0.5f;
|
|||
|
|
matScaleBias.m11 = -0.5f;
|
|||
|
|
matScaleBias.m22 = 0.5f;
|
|||
|
|
matScaleBias.m03 = 0.5f;
|
|||
|
|
matScaleBias.m13 = 0.5f;
|
|||
|
|
matScaleBias.m23 = 0.5f;
|
|||
|
|
|
|||
|
|
//Create 3D Render Texture 1
|
|||
|
|
RenderTextureDescriptor rtdiscrpt = new RenderTextureDescriptor();
|
|||
|
|
rtdiscrpt.enableRandomWrite = true;
|
|||
|
|
rtdiscrpt.dimension = TextureDimension.Tex3D;
|
|||
|
|
rtdiscrpt.width = volumetricData.FroxelWidthResolution;
|
|||
|
|
rtdiscrpt.height = volumetricData.FroxelHeightResolution;
|
|||
|
|
rtdiscrpt.volumeDepth = volumetricData.FroxelDepthResolution;
|
|||
|
|
rtdiscrpt.graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat;
|
|||
|
|
rtdiscrpt.msaaSamples = 1;
|
|||
|
|
|
|||
|
|
FroxelBufferA = new RenderTexture(rtdiscrpt);
|
|||
|
|
FroxelBufferA.name = activeCam.name + "_FroxelBufferA";
|
|||
|
|
|
|||
|
|
FroxelBufferA.Create();
|
|||
|
|
|
|||
|
|
//Ugh... extra android buffer mess. Can I use a custom RT double buffer instead?
|
|||
|
|
FroxelBufferB = new RenderTexture(rtdiscrpt);
|
|||
|
|
FroxelBufferB.name = activeCam.name + "_FroxelBufferB";
|
|||
|
|
FroxelBufferB.Create();
|
|||
|
|
|
|||
|
|
rtdiscrpt.width = volumetricData.FroxelWidthResolution * 2; // Make double wide texture for stereo use. Make smarter for non VR use case?
|
|||
|
|
IntegrationBuffer = new RenderTexture(rtdiscrpt);
|
|||
|
|
IntegrationBuffer.name = activeCam.name + "_IntegrationBuffer";
|
|||
|
|
// IntegrationBuffer.format = RenderTextureFormat.ARGB32;
|
|||
|
|
IntegrationBuffer.graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat;
|
|||
|
|
IntegrationBuffer.filterMode = FilterMode.Trilinear;
|
|||
|
|
IntegrationBuffer.enableRandomWrite = true;
|
|||
|
|
IntegrationBuffer.Create();
|
|||
|
|
|
|||
|
|
//IntegrationBufferB = new RenderTexture(rtdiscrpt);
|
|||
|
|
//IntegrationBufferB.format = RenderTextureFormat.ARGB32;
|
|||
|
|
//IntegrationBufferB.enableRandomWrite = true;
|
|||
|
|
//IntegrationBufferB.Create();
|
|||
|
|
|
|||
|
|
//Extinction = VolumeRenderingUtils.ExtinctionFromMeanFreePath(meanFreePath);
|
|||
|
|
//ExtinctionColor = albedo * Extinction;
|
|||
|
|
|
|||
|
|
if (FroxelBlur == BlurType.Gaussian) IntializeBlur(rtdiscrpt);
|
|||
|
|
|
|||
|
|
// LightObjects = new List<LightObject>();
|
|||
|
|
|
|||
|
|
ScatteringKernel = FroxelFogCompute.FindKernel("Scatter");
|
|||
|
|
|
|||
|
|
ZPlaneTexelSpacing = ComputZPlaneTexelSpacing(1, activeCam.fieldOfView, volumetricData.FroxelHeightResolution);
|
|||
|
|
|
|||
|
|
|
|||
|
|
//UpdateClipmap(Clipmap.Far);
|
|||
|
|
// FroxelFogCompute.SetTexture(ScatteringKernel, ClipmapTextureID, ClipmapBufferA);
|
|||
|
|
// temp light cookie array. TODO: Make dynamic. Add to lighting engine too.
|
|||
|
|
// FroxelFogCompute.SetTexture(FogFroxelKernel, "BlueNoise", BlueNoise); // temp light cookie array. TODO: Make dynamic. Add to lighting engine too.
|
|||
|
|
|
|||
|
|
///Second compute pass setup
|
|||
|
|
|
|||
|
|
IntegrateKernel = FroxelIntegrationCompute.FindKernel("StepAdd");
|
|||
|
|
|
|||
|
|
|
|||
|
|
//Make view projection matricies
|
|||
|
|
|
|||
|
|
Matrix4x4 CenterProjectionMatrix = matScaleBias * Matrix4x4.Perspective(activeCam.fieldOfView, CamAspectRatio, volumetricData.near, volumetricData.far);
|
|||
|
|
Matrix4x4 LeftProjectionMatrix = matScaleBias * Matrix4x4.Perspective(activeCam.fieldOfView, CamAspectRatio, volumetricData.near, volumetricData.far) * Matrix4x4.Translate(new Vector3(activeCam.stereoSeparation * 0.5f, 0, 0)); //temp ipd scaler. Combine factors when confirmed
|
|||
|
|
Matrix4x4 RightProjectionMatrix = matScaleBias * Matrix4x4.Perspective(activeCam.fieldOfView, CamAspectRatio, volumetricData.near, volumetricData.far) * Matrix4x4.Translate(new Vector3(-activeCam.stereoSeparation * 0.5f, 0, 0));
|
|||
|
|
|
|||
|
|
|
|||
|
|
Matrix4x4 CenterProjectionMatrixInverse = CenterProjectionMatrix.inverse;
|
|||
|
|
LeftEyeMatrix = LeftProjectionMatrix * CenterProjectionMatrixInverse;
|
|||
|
|
RightEyeMatrix = RightProjectionMatrix * CenterProjectionMatrixInverse;
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
//Global Variable setup
|
|||
|
|
|
|||
|
|
if (FroxelBlur == BlurType.Gaussian)
|
|||
|
|
{
|
|||
|
|
//Shader.SetGlobalTexture(ID_VolumetricResult, BlurBufferB);
|
|||
|
|
VolumetricResult = BlurBufferB;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
//FroxelFogCompute.SetTexture(ScatteringKernel, ID_VolumetricResult, IntegrationBuffer);
|
|||
|
|
//Shader.SetGlobalTexture(ID_VolumetricResult, IntegrationBuffer);
|
|||
|
|
VolumetricResult = IntegrationBuffer;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ThreadsToDispatch = new Vector3(
|
|||
|
|
Mathf.Max(Mathf.CeilToInt(volumetricData.FroxelWidthResolution / 4.0f), 1.0f),
|
|||
|
|
Mathf.Max(Mathf.CeilToInt(volumetricData.FroxelHeightResolution / 4.0f), 1.0f),
|
|||
|
|
Mathf.Max(Mathf.CeilToInt(volumetricData.FroxelDepthResolution / 4.0f), 1.0f)
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
// ComputZPlaneTexelSpacing(1.0f, vFoV, parameters.resolution.y);
|
|||
|
|
|
|||
|
|
// Unused as far as I can tell, declared in the VolumetricCore but not actually used
|
|||
|
|
//Shader.SetGlobalVector("_VolumePlaneSettings", new Vector4(volumetricData.near, volumetricData.far, volumetricData.far - volumetricData.near, volumetricData.near * volumetricData.far));
|
|||
|
|
|
|||
|
|
VolZBufferParams = new Vector4();
|
|||
|
|
VolZBufferParams.x = 1.0f - volumetricData.far / volumetricData.near;
|
|||
|
|
VolZBufferParams.y = volumetricData.far / volumetricData.near;
|
|||
|
|
VolZBufferParams.z = VolZBufferParams.x / volumetricData.far;
|
|||
|
|
VolZBufferParams.w = VolZBufferParams.y / volumetricData.far;
|
|||
|
|
|
|||
|
|
|
|||
|
|
ID_ClipMapGenKern = ClipmapCompute.FindKernel("ClipMapGen");
|
|||
|
|
ID_ClipMapClearKern = ClipmapCompute.FindKernel("ClipMapClear");
|
|||
|
|
ID_ClipMapHeightKern = ClipmapCompute.FindKernel("ClipMapHeight");
|
|||
|
|
|
|||
|
|
//Debug.Log("Dispatching " + ThreadsToDispatch);
|
|||
|
|
|
|||
|
|
SkyManager.CheckSky();
|
|||
|
|
|
|||
|
|
Clear3DTexture(FroxelBufferA);
|
|||
|
|
Clear3DTexture(FroxelBufferB);
|
|||
|
|
Clear3DTexture(IntegrationBuffer);
|
|||
|
|
|
|||
|
|
SetVariables();
|
|||
|
|
SetupClipmap();
|
|||
|
|
UpdateClipmaps();
|
|||
|
|
SetFroxelFogUniforms(true);
|
|||
|
|
SetFroxelIntegrationUniforms(true);
|
|||
|
|
SetBlurUniforms(true);
|
|||
|
|
|
|||
|
|
hasInitialized = true;
|
|||
|
|
VolumetricRegisters.RegisterVolumetricRenderer(this);
|
|||
|
|
//RenderPipelineManager.beginCameraRendering += UpdatePreRender;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SetFroxelFogUniforms(bool forceUpdate = false)
|
|||
|
|
{
|
|||
|
|
if (lastFroxelFog != this || forceUpdate)
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetFloat(ID_VBufferUnitDepthTexelSpacing, ZPlaneTexelSpacing);
|
|||
|
|
FroxelFogCompute.SetFloat(ID_ClipmapScale1, volumetricData.ClipmapScale);
|
|||
|
|
FroxelFogCompute.SetFloat(ID_ClipmapScale2, volumetricData.ClipmapScale2);
|
|||
|
|
//FroxelFogCompute.SetFloat(ID_GlobalExtinction, Extinction);
|
|||
|
|
//FroxelFogCompute.SetFloat(ID_StaticLightMultiplier, StaticLightMultiplier);
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_Result, FroxelBufferA);
|
|||
|
|
// CheckCookieList();
|
|||
|
|
// FroxelFogCompute.SetTexture(ScatteringKernel, ID_LightProjectionTextureArray, LightProjectionTextures);
|
|||
|
|
FroxelFogCompute.SetConstantBuffer(PerFrameConstBufferID, StepAddPerFrameConstantBuffer, 0, StepAddPerFrameCount * sizeof(float));
|
|||
|
|
lastFroxelFog = this;
|
|||
|
|
}
|
|||
|
|
if (lastClipmapUpdate != this || forceUpdate)
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetFloat(ClipmapScaleID, volumetricData.ClipmapScale);
|
|||
|
|
FroxelFogCompute.SetVector(ClipmapTransformID, ClipmapTransform);
|
|||
|
|
if (FlipClipBufferNear)
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_VolumetricClipmapTexture, ClipmapBufferB);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_VolumetricClipmapTexture, ClipmapBufferA);
|
|||
|
|
}
|
|||
|
|
if (FlipClipBufferFar)
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_VolumetricClipmapTexture2, ClipmapBufferC);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_VolumetricClipmapTexture2, ClipmapBufferD);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SetFroxelIntegrationUniforms(bool forceUpdate = false)
|
|||
|
|
{
|
|||
|
|
if (lastFroxelIntegrate != this || forceUpdate)
|
|||
|
|
{
|
|||
|
|
FroxelIntegrationCompute.SetMatrix(ID_LeftEyeMatrix, LeftEyeMatrix);
|
|||
|
|
FroxelIntegrationCompute.SetMatrix(ID_RightEyeMatrix, RightEyeMatrix);
|
|||
|
|
FroxelIntegrationCompute.SetVector(ID_VolZBufferParams, VolZBufferParams);
|
|||
|
|
//FroxelIntegrationCompute.SetVector(ID_GlobalScattering, ExtinctionColor);
|
|||
|
|
FroxelIntegrationCompute.SetTexture(IntegrateKernel, ID_Result, IntegrationBuffer);
|
|||
|
|
FroxelIntegrationCompute.SetTexture(IntegrateKernel, ID_InLightingTexture, FroxelBufferA);
|
|||
|
|
FroxelIntegrationCompute.SetConstantBuffer(PerFrameConstBufferID, StepAddPerFrameConstantBuffer, 0, StepAddPerFrameCount * sizeof(float));
|
|||
|
|
lastFroxelIntegrate = this;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SetBlurUniforms(bool forceUpdate = false)
|
|||
|
|
{
|
|||
|
|
if (FroxelBlur == BlurType.Gaussian && (lastBlur != this || forceUpdate))
|
|||
|
|
{
|
|||
|
|
BlurCompute.SetTexture(BlurKernelX, ID_InTex, IntegrationBuffer);
|
|||
|
|
BlurCompute.SetTexture(BlurKernelX, ID_Result, BlurBuffer);
|
|||
|
|
BlurCompute.SetTexture(BlurKernelY, ID_InTex, BlurBuffer);
|
|||
|
|
BlurCompute.SetTexture(BlurKernelY, ID_Result, BlurBufferB);
|
|||
|
|
lastBlur = this;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void ClearAllBuffers()
|
|||
|
|
{
|
|||
|
|
ClearClipmap(ClipmapBufferA);
|
|||
|
|
ClearClipmap(ClipmapBufferB);
|
|||
|
|
ClearClipmap(ClipmapBufferC);
|
|||
|
|
ClearClipmap(ClipmapBufferD);
|
|||
|
|
|
|||
|
|
Clear3DTexture(FroxelBufferA);
|
|||
|
|
Clear3DTexture(FroxelBufferB);
|
|||
|
|
Clear3DTexture(IntegrationBuffer);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// void UpdateLights()
|
|||
|
|
// {
|
|||
|
|
// LightObjects.Clear(); //clear and rebuild for now. TODO: Make a smarter constructor
|
|||
|
|
// if (LightBuffer != null) LightBuffer.Release();
|
|||
|
|
//
|
|||
|
|
// for (int i = 0; i < Lights.Count; i++)
|
|||
|
|
// {
|
|||
|
|
// LightObject lightObject = new LightObject();
|
|||
|
|
// lightObject.LightPosition = Lights[i].transform.position;
|
|||
|
|
// lightObject.LightColor = new Color(
|
|||
|
|
// Lights[i].color.r * Lights[i].intensity,
|
|||
|
|
// Lights[i].color.g * Lights[i].intensity,
|
|||
|
|
// Lights[i].color.b * Lights[i].intensity,
|
|||
|
|
// Lights[i].color.a);
|
|||
|
|
// lightObject.LightProjectionMatrix = matScaleBias
|
|||
|
|
// * Matrix4x4.Perspective(Lights[i].spotAngle, 1, 0.1f, Lights[i].range)
|
|||
|
|
// * Matrix4x4.Rotate(Lights[i].transform.rotation).inverse;
|
|||
|
|
//
|
|||
|
|
// LightObjects.Add(lightObject);
|
|||
|
|
// }
|
|||
|
|
// LightBuffer = new ComputeBuffer(LightObjects.Count, LightObjectStride);
|
|||
|
|
// LightBuffer.SetData(LightObjects);
|
|||
|
|
// FroxelFogCompute.SetBuffer(ScatteringKernel, LightObjectsID, LightBuffer);
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
|
|||
|
|
#region Clipmap funtions
|
|||
|
|
void SetupClipmap()
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
RenderTextureDescriptor ClipRTdiscrpt = new RenderTextureDescriptor();
|
|||
|
|
ClipRTdiscrpt.enableRandomWrite = true;
|
|||
|
|
ClipRTdiscrpt.dimension = UnityEngine.Rendering.TextureDimension.Tex3D;
|
|||
|
|
ClipRTdiscrpt.width = volumetricData.ClipMapResolution;
|
|||
|
|
ClipRTdiscrpt.height = volumetricData.ClipMapResolution;
|
|||
|
|
ClipRTdiscrpt.volumeDepth = volumetricData.ClipMapResolution;
|
|||
|
|
ClipRTdiscrpt.graphicsFormat = UnityEngine.Experimental.Rendering.GraphicsFormat.R16G16B16A16_SFloat;
|
|||
|
|
ClipRTdiscrpt.msaaSamples = 1;
|
|||
|
|
|
|||
|
|
ClipmapBufferA = new RenderTexture(ClipRTdiscrpt);
|
|||
|
|
ClipmapBufferA.name = activeCam.name + "_ClipmapBufferA";
|
|||
|
|
ClipmapBufferA.Create();
|
|||
|
|
ClipmapBufferB = new RenderTexture(ClipRTdiscrpt);
|
|||
|
|
ClipmapBufferB.name = activeCam.name + "_ClipmapBufferB";
|
|||
|
|
ClipmapBufferB.Create();
|
|||
|
|
ClipmapBufferC = new RenderTexture(ClipRTdiscrpt);
|
|||
|
|
ClipmapBufferC.name = activeCam.name + "_ClipmapBufferC";
|
|||
|
|
ClipmapBufferC.Create();
|
|||
|
|
ClipmapBufferD = new RenderTexture(ClipRTdiscrpt);
|
|||
|
|
ClipmapBufferD.name = activeCam.name + "_ClipmapBufferD";
|
|||
|
|
ClipmapBufferD.Create();
|
|||
|
|
|
|||
|
|
////TODO: Loop through and remove one of the buffers
|
|||
|
|
|
|||
|
|
ClearClipmap(ClipmapBufferA);
|
|||
|
|
ClearClipmap(ClipmapBufferB);
|
|||
|
|
ClearClipmap(ClipmapBufferC);
|
|||
|
|
ClearClipmap(ClipmapBufferD);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ClearClipmap(RenderTexture buffer)
|
|||
|
|
{
|
|||
|
|
int clipMapDispatchNum = Mathf.Max(volumetricData.ClipMapResolution / 4, 1);
|
|||
|
|
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapClearKern, ID_Result, buffer);
|
|||
|
|
ClipmapCompute.Dispatch(ID_ClipMapClearKern, clipMapDispatchNum, clipMapDispatchNum, clipMapDispatchNum);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool ClipFar = false;
|
|||
|
|
void CheckClipmap() //Check distance from previous sample and recalulate if over threshold. TODO: make it resample chunks
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
if (Vector3.Distance(ClipmapCurrentPos, activeCam.transform.position) > volumetricData.ClipmapResampleThreshold || VolumetricRegisterEmpty || VolumetricRegisterForceRefresh)
|
|||
|
|
{
|
|||
|
|
//TODO: seperate the frames where this is rendered
|
|||
|
|
UpdateClipmaps();
|
|||
|
|
//if (ClipFar == false) UpdateClipmap(Clipmap.Near);
|
|||
|
|
//else {
|
|||
|
|
// UpdateClipmap(Clipmap.Far);
|
|||
|
|
// ClipFar = false;
|
|||
|
|
// };
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void UpdateClipmaps()
|
|||
|
|
{
|
|||
|
|
//Debug.Log("Clipmap Update: " + activeCam.transform.position);
|
|||
|
|
if (VolumetricRegisters.volumetricAreas.Count == 0)
|
|||
|
|
{
|
|||
|
|
VolumetricRegisterEmpty = true;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
else if (VolumetricRegisterEmpty)
|
|||
|
|
{
|
|||
|
|
VolumetricRegisterEmpty = false;
|
|||
|
|
}
|
|||
|
|
UpdateClipmap(Clipmap.Near);
|
|||
|
|
UpdateClipmap(Clipmap.Far);
|
|||
|
|
if (VolumetricRegisterForceRefresh) VolumetricRegisterForceRefresh = false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public enum Clipmap { Near,Far};
|
|||
|
|
|
|||
|
|
|
|||
|
|
public void UpdateClipmap(Clipmap clipmap)
|
|||
|
|
{
|
|||
|
|
ClipmapTransform = activeCam.transform.position;
|
|||
|
|
|
|||
|
|
float farscale = volumetricData.ClipmapScale2;
|
|||
|
|
|
|||
|
|
RenderTexture BufferA;
|
|||
|
|
RenderTexture BufferB;
|
|||
|
|
//TODO: bake out variables at start to avoid extra math per clip gen
|
|||
|
|
|
|||
|
|
//ClipmapCompute.SetFloat(ID_GlobalExtinction, Extinction);
|
|||
|
|
|
|||
|
|
if (clipmap == Clipmap.Near)
|
|||
|
|
{
|
|||
|
|
BufferA = ClipmapBufferB;
|
|||
|
|
BufferB = ClipmapBufferA;
|
|||
|
|
ClipmapCompute.SetFloat(ID_ClipmapScale0, volumetricData.ClipmapScale);
|
|||
|
|
ClipmapCompute.SetVector(ID_ClipmapWorldPosition, ClipmapTransform - (0.5f * volumetricData.ClipmapScale * Vector3.one));
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
BufferA = ClipmapBufferC;
|
|||
|
|
BufferB = ClipmapBufferD;
|
|||
|
|
|
|||
|
|
ClipmapCompute.SetFloat(ID_ClipmapScale0, volumetricData.ClipmapScale2);
|
|||
|
|
ClipmapCompute.SetVector(ID_ClipmapWorldPosition, ClipmapTransform - (0.5f * volumetricData.ClipmapScale2 * Vector3.one));
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Clipmap variables
|
|||
|
|
//ClipmapCompute.SetVector("ClipmapWorldPosition", ClipmapTransform - (0.5f * volumetricData.ClipmapScale * Vector3.one));
|
|||
|
|
// ClipmapCompute.SetFloat("ClipmapScale", volumetricData.ClipmapScale);
|
|||
|
|
|
|||
|
|
bool FlipClipBuffer = false;
|
|||
|
|
//Clear previous capture
|
|||
|
|
int clipMapDispatchNum = Mathf.Max(volumetricData.ClipMapResolution / 4, 1);
|
|||
|
|
// ClipmapCompute.SetVector("clearColor", RenderSettings.ambientProbe.Evaluate);
|
|||
|
|
|
|||
|
|
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapClearKern, ID_Result, BufferA);
|
|||
|
|
//Debug.Log("Dispatching 0");
|
|||
|
|
ClipmapCompute.Dispatch(ID_ClipMapClearKern, clipMapDispatchNum, clipMapDispatchNum, clipMapDispatchNum);
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapClearKern, ID_Result, BufferB);
|
|||
|
|
//Debug.Log("Dispatching 1");
|
|||
|
|
ClipmapCompute.Dispatch(ID_ClipMapClearKern, clipMapDispatchNum, clipMapDispatchNum, clipMapDispatchNum);
|
|||
|
|
|
|||
|
|
//ClipmapCompute.SetFloat("VolumeDensity", 0); //
|
|||
|
|
|
|||
|
|
//Loop through bake texture volumes and put into clipmap //TODO: Add pass for static unbaked elements
|
|||
|
|
//Debug.Log("VolumetricRegisters.volumetricAreas.Count: " + VolumetricRegisters.volumetricAreas.Count);
|
|||
|
|
for (int i = 0; i < VolumetricRegisters.volumetricAreas.Count; i++)
|
|||
|
|
{
|
|||
|
|
FlipClipBuffer = !FlipClipBuffer;
|
|||
|
|
|
|||
|
|
if (FlipClipBuffer)
|
|||
|
|
{
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapGenKern, ID_PreResult, BufferB);
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapGenKern, ID_Result, BufferA);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapGenKern, ID_PreResult, BufferA);
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapGenKern, ID_Result, BufferB);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Volumetric variables
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapGenKern, ID_VolumeMap, VolumetricRegisters.volumetricAreas[i].bakedTexture);
|
|||
|
|
ClipmapCompute.SetVector(ID_VolumeWorldSize, VolumetricRegisters.volumetricAreas[i].NormalizedScale);
|
|||
|
|
ClipmapCompute.SetVector(ID_VolumeWorldPosition, VolumetricRegisters.volumetricAreas[i].Corner);
|
|||
|
|
//Debug.Log("Dispatching 2");
|
|||
|
|
ClipmapCompute.Dispatch(ID_ClipMapGenKern, clipMapDispatchNum, clipMapDispatchNum, clipMapDispatchNum);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Height Densitiy
|
|||
|
|
|
|||
|
|
//FlipClipBuffer = !FlipClipBuffer;
|
|||
|
|
|
|||
|
|
//if (FlipClipBuffer)
|
|||
|
|
//{
|
|||
|
|
// ClipmapCompute.SetTexture(HeightClipmapKernal, "PreResult", BufferB);
|
|||
|
|
// ClipmapCompute.SetTexture(HeightClipmapKernal, "Result", BufferA);
|
|||
|
|
//}
|
|||
|
|
//else
|
|||
|
|
//{
|
|||
|
|
// ClipmapCompute.SetTexture(HeightClipmapKernal, "PreResult", BufferA);
|
|||
|
|
// ClipmapCompute.SetTexture(HeightClipmapKernal, "Result", BufferB);
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
////Volumetric variables
|
|||
|
|
////ClipmapCompute.SetTexture(HeightClipmapKernal, "VolumeMap", VolumetricRegisters.volumetricAreas[i].bakedTexture);
|
|||
|
|
////ClipmapCompute.SetVector("VolumeWorldSize", VolumetricRegisters.volumetricAreas[i].NormalizedScale);
|
|||
|
|
////ClipmapCompute.SetVector("VolumeWorldPosition", VolumetricRegisters.volumetricAreas[i].Corner);
|
|||
|
|
|
|||
|
|
//ClipmapCompute.Dispatch(HeightClipmapKernal, clipMapDispatchNum, clipMapDispatchNum, clipMapDispatchNum);
|
|||
|
|
|
|||
|
|
//End Height Densitiy
|
|||
|
|
|
|||
|
|
if (FlipClipBuffer)
|
|||
|
|
{
|
|||
|
|
SetClipmap(BufferA, volumetricData.ClipmapScale, ClipmapTransform, clipmap);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
SetClipmap(BufferB, volumetricData.ClipmapScale, ClipmapTransform, clipmap);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
switch (clipmap)
|
|||
|
|
{
|
|||
|
|
case Clipmap.Near:
|
|||
|
|
FlipClipBufferNear = FlipClipBuffer;
|
|||
|
|
break;
|
|||
|
|
case Clipmap.Far:
|
|||
|
|
FlipClipBufferFar = FlipClipBuffer;
|
|||
|
|
break;
|
|||
|
|
default:
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ClipmapCurrentPos = ClipmapTransform; //Set History
|
|||
|
|
lastClipmapUpdate = this;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
void SetClipmap(RenderTexture ClipmapTexture, float ClipmapScale, Vector3 ClipmapTransform, Clipmap clipmap)
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetFloat(ClipmapScaleID, ClipmapScale);
|
|||
|
|
FroxelFogCompute.SetVector(ClipmapTransformID, ClipmapTransform);
|
|||
|
|
|
|||
|
|
if (clipmap == Clipmap.Far)
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_VolumetricClipmapTexture2, ClipmapTexture);
|
|||
|
|
// Debug.Log("Added clipmap far :" + ClipmapTexture.name);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{ //TODO COMBINE THESE
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_VolumetricClipmapTexture, ClipmapTexture); //Set clipmap for
|
|||
|
|
//FroxelFogCompute.SetTexture(ScatteringKernel, ClipmapTextureID, ClipmapTexture); //Set clipmap for
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
bool FlopIntegralBuffer = false;
|
|||
|
|
void FlopIntegralBuffers(){
|
|||
|
|
|
|||
|
|
FlopIntegralBuffer = !FlopIntegralBuffer;
|
|||
|
|
|
|||
|
|
if (FlopIntegralBuffer)
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_PreviousFrameLighting, FroxelBufferA);
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_Result, FroxelBufferB);
|
|||
|
|
FroxelIntegrationCompute.SetTexture(IntegrateKernel, ID_InLightingTexture, FroxelBufferB);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_PreviousFrameLighting, FroxelBufferB);
|
|||
|
|
FroxelFogCompute.SetTexture(ScatteringKernel, ID_Result, FroxelBufferA);
|
|||
|
|
FroxelIntegrationCompute.SetTexture(IntegrateKernel, ID_InLightingTexture, FroxelBufferA);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
FroxelIntegrationCompute.SetTexture(IntegrateKernel, ID_HistoryBuffer, IntegrationBuffer);
|
|||
|
|
FroxelIntegrationCompute.SetTexture(IntegrateKernel, ID_Result, IntegrationBuffer);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Matrix4x4 PrevViewProjMatrix = Matrix4x4.identity;
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
public void SetVariables()
|
|||
|
|
{
|
|||
|
|
//Global multiplier for static lights
|
|||
|
|
//ScatteringFromExtinctionAndAlbedo
|
|||
|
|
//THESE ARE GLOBAL VARIABLES. THEY NEED TO STAY GLOBAL
|
|||
|
|
|
|||
|
|
// The volumetrics script should be in charge of setting these,
|
|||
|
|
// if there's no volume component then all volumetric
|
|||
|
|
// scripts will use the last camera to be enabled's values
|
|||
|
|
// Not ideal, but for now it should be fine
|
|||
|
|
|
|||
|
|
if (!Volumetrics.hasSetGlobals) // Added check so volumetric rendering scripts don't overwrite the volumetrics scripts values
|
|||
|
|
{
|
|||
|
|
float extinction = VolumeRenderingUtils.ExtinctionFromMeanFreePath(meanFreePath);
|
|||
|
|
Shader.SetGlobalFloat(ID_GlobalExtinction, extinction); //ExtinctionFromMeanFreePath
|
|||
|
|
Shader.SetGlobalFloat(ID_StaticLightMultiplier, StaticLightMultiplier); //Global multiplier for static lights
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
float GetAspectRatio()
|
|||
|
|
{
|
|||
|
|
if (activeCam.stereoTargetEye == StereoTargetEyeMask.None) return activeCam.aspect;
|
|||
|
|
return XRSettings.eyeTextureHeight == 0 ? activeCam.aspect : (float)XRSettings.eyeTextureHeight / (float)XRSettings.eyeTextureWidth;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// void Update()
|
|||
|
|
// {
|
|||
|
|
//#if UNITY_EDITOR
|
|||
|
|
// if (Application.isPlaying)
|
|||
|
|
// {
|
|||
|
|
// UpdateFunc();
|
|||
|
|
// }
|
|||
|
|
//#else
|
|||
|
|
// UpdateFunc();
|
|||
|
|
//#endif
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
void UpdatePreRender(ScriptableRenderContext ctxt, Camera cam1)
|
|||
|
|
{
|
|||
|
|
if (activeCam == cam1) UpdateFunc();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void UpdateFunc()
|
|||
|
|
{
|
|||
|
|
using (new ProfilingScope(null, profileUpdateFunc))
|
|||
|
|
{
|
|||
|
|
if (!hasInitialized)
|
|||
|
|
{
|
|||
|
|
//Debug.LogWarning("Volumetric Rendering: Volumetrics trying to render without initializing");
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (activeCam == null)
|
|||
|
|
{
|
|||
|
|
Debug.LogError("Volumetric Rendering: Active camera destroyed or de-assigned, disabling");
|
|||
|
|
this.enabled = false;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
if ((Application.isPlaying && !activeCam.isActiveAndEnabled && !enableEditorPreview))
|
|||
|
|
#else
|
|||
|
|
if (!activeCam.isActiveAndEnabled)
|
|||
|
|
#endif
|
|||
|
|
{
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
CheckOverrideVolumes();
|
|||
|
|
//camera.aspect no longer returns the correct value & this workaround only works when XR is fully intialized otherwise it returns 0 and divs by 0; >W<
|
|||
|
|
//bleh
|
|||
|
|
CamAspectRatio = GetAspectRatio();
|
|||
|
|
|
|||
|
|
Matrix4x4 projectionMatrix = Matrix4x4.Perspective(activeCam.fieldOfView, CamAspectRatio, activeCam.nearClipPlane, volumetricData.far) * Matrix4x4.Rotate(activeCam.transform.rotation).inverse;
|
|||
|
|
projectionMatrix = matScaleBias * projectionMatrix;
|
|||
|
|
|
|||
|
|
//Previous frame's matrix//!!!!!!!!!
|
|||
|
|
FroxelFogCompute.SetMatrix(PreviousFrameMatrixID, PreviousFrameMatrix);///
|
|||
|
|
// FroxelFogCompute.SetMatrix(PreviousFrameMatrixID, PreviousFrameMatrix );///
|
|||
|
|
// var controller = hdCamera.volumeStack.GetComponent<Fog>(); //TODO: Link with controller
|
|||
|
|
// UpdateLights();
|
|||
|
|
|
|||
|
|
CheckClipmap(); // UpdateClipmap();
|
|||
|
|
|
|||
|
|
SetFroxelFogUniforms();
|
|||
|
|
SetFroxelIntegrationUniforms();
|
|||
|
|
SetBlurUniforms();
|
|||
|
|
|
|||
|
|
FlopIntegralBuffers();
|
|||
|
|
// Matrix4x4 lightMatrix = matScaleBias * Matrix4x4.Perspective(LightPosition.spotAngle, 1, 0.1f, LightPosition.range) * Matrix4x4.Rotate(LightPosition.transform.rotation).inverse;
|
|||
|
|
VBufferParameters vbuff = new VBufferParameters(
|
|||
|
|
new Vector3Int(volumetricData.FroxelWidthResolution, volumetricData.FroxelWidthResolution, volumetricData.FroxelDepthResolution),
|
|||
|
|
volumetricData.far,
|
|||
|
|
activeCam.nearClipPlane,
|
|||
|
|
activeCam.farClipPlane,
|
|||
|
|
activeCam.fieldOfView,
|
|||
|
|
SliceDistributionUniformity);
|
|||
|
|
|
|||
|
|
// Vector2Int sharedBufferSize = new Vector2Int(volumetricData.FroxelWidthResolution, volumetricData.FroxelHeightResolution); //Taking scaler functuion from HDRP for reprojection
|
|||
|
|
// Shader.SetGlobalVector("_VBufferSharedUvScaleAndLimit", vbuff.ComputeUvScaleAndLimit(sharedBufferSize) ); //Just assuming same scale
|
|||
|
|
|
|||
|
|
Vector4 vres = new Vector4(volumetricData.FroxelWidthResolution, volumetricData.FroxelHeightResolution, 1.0f / volumetricData.FroxelWidthResolution, 1.0f / volumetricData.FroxelHeightResolution);
|
|||
|
|
//Vector4 vres = new Vector4(cam.pixelWidth, cam.pixelHeight, 1.0f / cam.pixelWidth, cam.pixelHeight);
|
|||
|
|
|
|||
|
|
Matrix4x4 PixelCoordToViewDirWS = ComputePixelCoordToWorldSpaceViewDirectionMatrix(activeCam, vres);
|
|||
|
|
|
|||
|
|
GetHexagonalClosePackedSpheres7(m_xySeq);
|
|||
|
|
int sampleIndex = Time.renderedFrameCount % 7;
|
|||
|
|
Vector3 seqOffset = new Vector3(m_xySeq[sampleIndex].x, m_xySeq[sampleIndex].y, m_zSeq[sampleIndex]);
|
|||
|
|
|
|||
|
|
Span<ShaderConstants> shaderConsts = stackalloc ShaderConstants[1];
|
|||
|
|
shaderConsts[0].TransposedCameraProjectionMatrix = projectionMatrix.transpose;
|
|||
|
|
shaderConsts[0].CameraProjectionMatrix = projectionMatrix;
|
|||
|
|
shaderConsts[0]._VBufferDistanceEncodingParams = vbuff.depthEncodingParams;
|
|||
|
|
shaderConsts[0]._VolumetricResultDim = new Vector3(FroxelBlur != BlurType.Gaussian ? volumetricData.FroxelWidthResolution * 2 : volumetricData.FroxelWidthResolution,
|
|||
|
|
volumetricData.FroxelHeightResolution, volumetricData.FroxelDepthResolution);
|
|||
|
|
shaderConsts[0]._VolCameraPos = activeCam.transform.position;
|
|||
|
|
if (ShaderConstantBuffer == null)
|
|||
|
|
{
|
|||
|
|
ShaderConstantBuffer = new ComputeBuffer(ShaderConstantsCount, sizeof(float), ComputeBufferType.Constant);
|
|||
|
|
//Shader.SetGlobalConstantBuffer(ID_VolumetricsCB, ShaderConstantBuffer, 0, ShaderConstantsSize);
|
|||
|
|
//Debug.Log("Created New Compute Buffer");
|
|||
|
|
}
|
|||
|
|
ShaderConstantBuffer.SetData<ShaderConstants>(shaderConsts);
|
|||
|
|
|
|||
|
|
|
|||
|
|
Span<StepAddPerFrameConstants> stepAddConst = stackalloc StepAddPerFrameConstants[1];
|
|||
|
|
stepAddConst[0] = new StepAddPerFrameConstants();
|
|||
|
|
stepAddConst[0]._VBufferDistanceDecodingParams = vbuff.depthDecodingParams;
|
|||
|
|
stepAddConst[0].SeqOffset = seqOffset;
|
|||
|
|
if (StepAddPerFrameConstantBuffer == null)
|
|||
|
|
{
|
|||
|
|
StepAddPerFrameConstantBuffer = new ComputeBuffer(1, StepAddPerFrameCount * sizeof(float), ComputeBufferType.Constant);
|
|||
|
|
//Shader.SetGlobalConstantBuffer(PerFrameConstBufferID, StepAddPerFrameConstantBuffer, 0, StepAddPerFrameCount * sizeof(float));
|
|||
|
|
//Debug.Log("Created New Compute Buffer");
|
|||
|
|
}
|
|||
|
|
StepAddPerFrameConstantBuffer.SetData<StepAddPerFrameConstants>(stepAddConst);
|
|||
|
|
|
|||
|
|
Span<ScatteringPerFrameConstants> VolScatteringCB = stackalloc ScatteringPerFrameConstants[1];
|
|||
|
|
VolScatteringCB[0] = new ScatteringPerFrameConstants()
|
|||
|
|
{
|
|||
|
|
_VBufferCoordToViewDirWS = PixelCoordToViewDirWS,
|
|||
|
|
_PrevViewProjMatrix = PrevViewProjMatrix,
|
|||
|
|
_ViewMatrix = activeCam.worldToCameraMatrix,
|
|||
|
|
TransposedCameraProjectionMatrix = projectionMatrix.transpose,
|
|||
|
|
CameraProjectionMatrix = projectionMatrix,
|
|||
|
|
_VBufferDistanceEncodingParams = vbuff.depthEncodingParams,
|
|||
|
|
_VBufferDistanceDecodingParams = vbuff.depthDecodingParams,
|
|||
|
|
SeqOffset = seqOffset,
|
|||
|
|
CameraPosition = activeCam.transform.position,
|
|||
|
|
CameraMotionVector = activeCam.transform.position - PreviousCameraPosition
|
|||
|
|
};
|
|||
|
|
//float[] VolScatteringCBArray = VolStructToArray(VolScatteringCB, PerFrameConstantsCount, PerFrameConstantsSize);
|
|||
|
|
//Debug.Log(VolScatteringCB._VBufferCoordToViewDirWS);
|
|||
|
|
//Debug.Log(VolScatteringCBArray[4] + " " + VolScatteringCBArray[5] + " " + VolScatteringCBArray[6] + " " + VolScatteringCBArray[7]);
|
|||
|
|
if (ComputePerFrameConstantBuffer == null)
|
|||
|
|
{
|
|||
|
|
ComputePerFrameConstantBuffer = new ComputeBuffer(1, ScatterPerFrameCount * sizeof(float), ComputeBufferType.Constant);
|
|||
|
|
//Debug.Log("Created New Compute Buffer");
|
|||
|
|
}
|
|||
|
|
ComputePerFrameConstantBuffer.SetData<ScatteringPerFrameConstants>(VolScatteringCB);
|
|||
|
|
FroxelFogCompute.SetConstantBuffer(PerFrameConstBufferID, ComputePerFrameConstantBuffer, 0, ScatterPerFrameCount * sizeof(float));
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
int mediaCount = VolumetricRegisters.VolumetricMediaEntities.Count;
|
|||
|
|
int maxCount = Math.Max(mediaCount, 1);
|
|||
|
|
|
|||
|
|
if (object.ReferenceEquals(participatingMediaSphereBuffer, null) || participatingMediaSphereBuffer == null)
|
|||
|
|
{
|
|||
|
|
participatingMediaSphereBuffer = new ComputeBuffer(maxCount, MediaSphereStride, ComputeBufferType.Structured);
|
|||
|
|
//Debug.Log("Created New Compute Buffer");
|
|||
|
|
}
|
|||
|
|
else if (maxCount > MediaCount)
|
|||
|
|
{
|
|||
|
|
participatingMediaSphereBuffer.Release();
|
|||
|
|
participatingMediaSphereBuffer = new ComputeBuffer(maxCount, MediaSphereStride, ComputeBufferType.Structured);
|
|||
|
|
MediaCount = maxCount;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
MediaSphere[] mediadata = new MediaSphere[maxCount];
|
|||
|
|
|
|||
|
|
if (mediaCount < 1)
|
|||
|
|
{
|
|||
|
|
//mediadata[0].CenterPosition = Vector3.zero;
|
|||
|
|
//mediadata[0].LocalExtinction = 0;
|
|||
|
|
//mediadata[0].LocalRange = 0;
|
|||
|
|
//mediadata[0].LocalFalloff = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < mediadata.Length; i++)
|
|||
|
|
{
|
|||
|
|
//TODO: generalize the strut between the classes so we don't have to recast it here
|
|||
|
|
mediadata[i].CenterPosition = VolumetricRegisters.VolumetricMediaEntities[i].gameObject.transform.position;
|
|||
|
|
mediadata[i].LocalExtinction = VolumetricRegisters.VolumetricMediaEntities[i].LocalExtinction();
|
|||
|
|
mediadata[i].LocalRange = VolumetricRegisters.VolumetricMediaEntities[i].Scale.magnitude; // temp mag
|
|||
|
|
mediadata[i].LocalFalloff = VolumetricRegisters.VolumetricMediaEntities[i].falloffDistance;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (participatingMediaSphereBuffer != null)
|
|||
|
|
{
|
|||
|
|
participatingMediaSphereBuffer.SetData(mediadata);
|
|||
|
|
FroxelFogCompute.SetBuffer(ScatteringKernel, ID_media_sphere_buffer, participatingMediaSphereBuffer);
|
|||
|
|
FroxelFogCompute.SetFloat(ID_media_sphere_buffer_length, mediaCount);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
if (VolumetricConstantBuffer != null && projectionMatrix != null && activeCam != null && vbuff.depthEncodingParams != null)
|
|||
|
|
{
|
|||
|
|
VolumetricConstants vConst = new VolumetricConstants();
|
|||
|
|
vConst.CameraProjectionMatrix = projectionMatrix.transpose;
|
|||
|
|
vConst.TransposedCameraProjectionMatrix = projectionMatrix;
|
|||
|
|
vConst._VBufferDistanceEncodingParams = vbuff.depthEncodingParams;
|
|||
|
|
vConst._VolCameraPos = activeCam.transform.position;
|
|||
|
|
float[] vConstArray = VolStructToArray(vConst);
|
|||
|
|
VolumetricConstantBuffer.SetData(vConstArray);
|
|||
|
|
Shader.SetGlobalConstantBuffer("VolumetricCB", VolumetricConstantBuffer, 0, VolCBCount * sizeof(float));
|
|||
|
|
}
|
|||
|
|
*/
|
|||
|
|
PreviousFrameMatrix = projectionMatrix;
|
|||
|
|
PreviousCameraPosition = activeCam.transform.position;
|
|||
|
|
////MATRIX
|
|||
|
|
///
|
|||
|
|
///camera.projectionMatrix is ALSO broken and returns the final viewport's projection rather than the center XR projection.
|
|||
|
|
///cam.GetStereoProjectionMatrix returns the skewed XR projection matrix per eye. Just doing our own calulation
|
|||
|
|
var gpuProj = GL.GetGPUProjectionMatrix(Matrix4x4.Perspective(activeCam.fieldOfView, CamAspectRatio, activeCam.nearClipPlane, 100000f), true);
|
|||
|
|
PrevViewProjMatrix = gpuProj * activeCam.worldToCameraMatrix;
|
|||
|
|
//Debug.Log("Dispatching 3");
|
|||
|
|
FroxelFogCompute.Dispatch(ScatteringKernel, (int)ThreadsToDispatch.x, (int)ThreadsToDispatch.y, (int)ThreadsToDispatch.z);
|
|||
|
|
// FroxelStackingCompute.DispatchIndirect
|
|||
|
|
//CONVERT TO DISPATCH INDIRECT to avoid CPU callback?
|
|||
|
|
//Debug.Log("Dispatching 4");
|
|||
|
|
FroxelIntegrationCompute.Dispatch(IntegrateKernel, (int)ThreadsToDispatch.x * 2, (int)ThreadsToDispatch.y, (int)ThreadsToDispatch.z); //x2 for stereo
|
|||
|
|
|
|||
|
|
if (FroxelBlur == BlurType.Gaussian)
|
|||
|
|
{
|
|||
|
|
BlurCompute.Dispatch(BlurKernelX, (int)ThreadsToDispatch.x * 2, (int)ThreadsToDispatch.y, (int)ThreadsToDispatch.z); // Final blur
|
|||
|
|
BlurCompute.Dispatch(BlurKernelY, (int)ThreadsToDispatch.x * 2, (int)ThreadsToDispatch.y, (int)ThreadsToDispatch.z); // Final blur
|
|||
|
|
}
|
|||
|
|
/* Give the shader constant buffer and volumetric render texture to the
|
|||
|
|
* additional camera data so that on render the camera can set them as
|
|||
|
|
* globals
|
|||
|
|
*/
|
|||
|
|
SetCameraData();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//Coping the parms from HDRP to get the log encoded depth.
|
|||
|
|
struct VBufferParameters
|
|||
|
|
{
|
|||
|
|
public Vector3Int viewportSize;
|
|||
|
|
public Vector4 depthEncodingParams;
|
|||
|
|
public Vector4 depthDecodingParams;
|
|||
|
|
|
|||
|
|
public VBufferParameters(Vector3Int viewportResolution, float depthExtent, float camNear, float camFar, float camVFoV, float sliceDistributionUniformity)
|
|||
|
|
{
|
|||
|
|
viewportSize = viewportResolution;
|
|||
|
|
|
|||
|
|
// The V-Buffer is sphere-capped, while the camera frustum is not.
|
|||
|
|
// We always start from the near plane of the camera.
|
|||
|
|
|
|||
|
|
float aspectRatio = viewportResolution.x / (float)viewportResolution.y;
|
|||
|
|
float farPlaneHeight = 2.0f * Mathf.Tan(0.5f * camVFoV) * camFar;
|
|||
|
|
float farPlaneWidth = farPlaneHeight * aspectRatio;
|
|||
|
|
float farPlaneMaxDim = Mathf.Max(farPlaneWidth, farPlaneHeight);
|
|||
|
|
float farPlaneDist = Mathf.Sqrt(camFar * camFar + 0.25f * farPlaneMaxDim * farPlaneMaxDim);
|
|||
|
|
|
|||
|
|
float nearDist = camNear;
|
|||
|
|
float farDist = Mathf.Min(nearDist + depthExtent, farPlaneDist);
|
|||
|
|
|
|||
|
|
float c = 2 - 2 * sliceDistributionUniformity; // remap [0, 1] -> [2, 0]
|
|||
|
|
c = Mathf.Max(c, 0.001f); // Avoid NaNs
|
|||
|
|
|
|||
|
|
depthEncodingParams = ComputeLogarithmicDepthEncodingParams(nearDist, farDist, c);
|
|||
|
|
depthDecodingParams = ComputeLogarithmicDepthDecodingParams(nearDist, farDist, c);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal Vector4 ComputeUvScaleAndLimit(Vector2Int bufferSize)
|
|||
|
|
{
|
|||
|
|
// The slice count is fixed for now.
|
|||
|
|
return ComputeUvScaleAndLimitFun(new Vector2Int(viewportSize.x, viewportSize.y), bufferSize);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal float ComputeLastSliceDistance(int sliceCount)
|
|||
|
|
{
|
|||
|
|
float d = 1.0f - 0.5f / sliceCount;
|
|||
|
|
float ln2 = 0.69314718f;
|
|||
|
|
|
|||
|
|
// DecodeLogarithmicDepthGeneralized(1 - 0.5 / sliceCount)
|
|||
|
|
return depthDecodingParams.x * Mathf.Exp(ln2 * d * depthDecodingParams.y) + depthDecodingParams.z;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// See EncodeLogarithmicDepthGeneralized().
|
|||
|
|
static Vector4 ComputeLogarithmicDepthEncodingParams(float nearPlane, float farPlane, float c)
|
|||
|
|
{
|
|||
|
|
Vector4 depthParams = new Vector4();
|
|||
|
|
|
|||
|
|
float n = nearPlane;
|
|||
|
|
float f = farPlane;
|
|||
|
|
|
|||
|
|
depthParams.y = 1.0f / Mathf.Log(c * (f - n) + 1, 2);
|
|||
|
|
depthParams.x = Mathf.Log(c, 2) * depthParams.y;
|
|||
|
|
depthParams.z = n - 1.0f / c; // Same
|
|||
|
|
depthParams.w = 0.0f;
|
|||
|
|
|
|||
|
|
return depthParams;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// See DecodeLogarithmicDepthGeneralized().
|
|||
|
|
static Vector4 ComputeLogarithmicDepthDecodingParams(float nearPlane, float farPlane, float c)
|
|||
|
|
{
|
|||
|
|
Vector4 depthParams = new Vector4();
|
|||
|
|
|
|||
|
|
float n = nearPlane;
|
|||
|
|
float f = farPlane;
|
|||
|
|
|
|||
|
|
depthParams.x = 1.0f / c;
|
|||
|
|
depthParams.y = Mathf.Log(c * (f - n) + 1, 2);
|
|||
|
|
depthParams.z = n - 1.0f / c; // Same
|
|||
|
|
depthParams.w = 0.0f;
|
|||
|
|
|
|||
|
|
return depthParams;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal static float ComputZPlaneTexelSpacing(float planeDepth, float verticalFoV, float resolutionY)
|
|||
|
|
{
|
|||
|
|
float tanHalfVertFoV = Mathf.Tan(0.5f * verticalFoV);
|
|||
|
|
return tanHalfVertFoV * (2.0f / resolutionY) * planeDepth;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal static Vector4 ComputeUvScaleAndLimitFun(Vector2Int viewportResolution, Vector2Int bufferSize)
|
|||
|
|
{
|
|||
|
|
Vector2 rcpBufferSize = new Vector2(1.0f / bufferSize.x, 1.0f / bufferSize.y);
|
|||
|
|
|
|||
|
|
// vp_scale = vp_dim / tex_dim.
|
|||
|
|
Vector2 uvScale = new Vector2(viewportResolution.x * rcpBufferSize.x,
|
|||
|
|
viewportResolution.y * rcpBufferSize.y);
|
|||
|
|
|
|||
|
|
// clamp to (vp_dim - 0.5) / tex_dim.
|
|||
|
|
Vector2 uvLimit = new Vector2((viewportResolution.x - 0.5f) * rcpBufferSize.x,
|
|||
|
|
(viewportResolution.y - 0.5f) * rcpBufferSize.y);
|
|||
|
|
|
|||
|
|
return new Vector4(uvScale.x, uvScale.y, uvLimit.x, uvLimit.y);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void disable()
|
|||
|
|
{
|
|||
|
|
//Debug.Log("Volumetric Rendering: Disable Called");
|
|||
|
|
hasInitialized = false;
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
RenderPipelineManager.beginCameraRendering -= UpdatePreRender;
|
|||
|
|
AssemblyReloadEvents.beforeAssemblyReload -= CleanupOnReload;
|
|||
|
|
#else
|
|||
|
|
RenderPipelineManager.beginCameraRendering -= UpdatePreRender;
|
|||
|
|
#endif
|
|||
|
|
ReleaseAssets();
|
|||
|
|
CleanupCameraData();
|
|||
|
|
VolumetricRegisters.UnregisterVolumetricRenderer(this);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void enable()
|
|||
|
|
{
|
|||
|
|
StartSceneViewRendering();
|
|||
|
|
Intialize();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void StartSceneViewRendering()
|
|||
|
|
{
|
|||
|
|
//#if UNITY_EDITOR
|
|||
|
|
// if (enableEditorPreview && !Application.isPlaying) RenderPipelineManager.beginCameraRendering += UpdatePreRender;
|
|||
|
|
//#else
|
|||
|
|
RenderPipelineManager.beginCameraRendering += UpdatePreRender;
|
|||
|
|
//#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void UpdateStateAfterReload()
|
|||
|
|
{
|
|||
|
|
if (enableEditorPreview && this.isActiveAndEnabled)
|
|||
|
|
{
|
|||
|
|
enable();
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
disable();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void CleanupOnReload()
|
|||
|
|
{
|
|||
|
|
disable();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void OnEnable()
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
if (!Application.isPlaying)
|
|||
|
|
{
|
|||
|
|
// Every time scripts get re-compiled, everything gets reset without calling OnDisable or OnDestroy, and the keyword gets left on
|
|||
|
|
enableEditorPreview = false;
|
|||
|
|
AssemblyReloadEvents.afterAssemblyReload += UpdateStateAfterReload;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
enable();
|
|||
|
|
}
|
|||
|
|
#else
|
|||
|
|
enable();
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
private void OnDisable() //Disable this if we decide to just pause rendering instead of removing.
|
|||
|
|
{
|
|||
|
|
disable();
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
if (!Application.isPlaying)
|
|||
|
|
{
|
|||
|
|
AssemblyReloadEvents.afterAssemblyReload -= UpdateStateAfterReload;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
private void OnDestroy()
|
|||
|
|
{
|
|||
|
|
disable();
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
if (!Application.isPlaying)
|
|||
|
|
{
|
|||
|
|
AssemblyReloadEvents.afterAssemblyReload -= UpdateStateAfterReload;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void DestroyAllTextureAssets()
|
|||
|
|
{
|
|||
|
|
ClipmapBufferA.Clear();
|
|||
|
|
ClipmapBufferB.Clear();
|
|||
|
|
ClipmapBufferC.Clear();
|
|||
|
|
ClipmapBufferD.Clear();
|
|||
|
|
|
|||
|
|
FroxelBufferA.Clear();
|
|||
|
|
FroxelBufferB.Clear();
|
|||
|
|
IntegrationBuffer.Clear();
|
|||
|
|
|
|||
|
|
BlurBuffer.Clear();
|
|||
|
|
BlurBufferB.Clear();
|
|||
|
|
|
|||
|
|
// if (createdLightProjectionTexture && LightProjectionTextures != null) { CoreUtils.Destroy(LightProjectionTextures); }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
Matrix4x4 ComputePixelCoordToWorldSpaceViewDirectionMatrix(Camera cam, Vector4 resolution)
|
|||
|
|
{
|
|||
|
|
// var proj = cam.projectionMatrix; // GL.GetGPUProjectionMatrix(cameraProj, true); //Use this if we run into platform issues
|
|||
|
|
//bandaid fix. There's an issue with the far clip plane in the matrix projection.
|
|||
|
|
var proj = Matrix4x4.Perspective(cam.fieldOfView, CamAspectRatio, cam.nearClipPlane, 100000f);
|
|||
|
|
var view = cam.worldToCameraMatrix ;
|
|||
|
|
|
|||
|
|
var invViewProjMatrix = (proj * view).inverse;
|
|||
|
|
|
|||
|
|
var transform = Matrix4x4.Scale(new Vector3(-1.0f, -1.0f, -1.0f)) * invViewProjMatrix; // (gpuProj * gpuView).inverse
|
|||
|
|
// transform = transform * Matrix4x4.Scale(new Vector3(1.0f, -1.0f, 1.0f));
|
|||
|
|
transform = transform * Matrix4x4.Translate(new Vector3(-1.0f, -1.0f, 0.0f));
|
|||
|
|
transform = transform * Matrix4x4.Scale(new Vector3(2.0f * resolution.z, 2.0f * resolution.w, 1.0f)) ;
|
|||
|
|
|
|||
|
|
return transform.transpose;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void SetComputeVariables()
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SetComputeBuffer(string name, ComputeShader shader, int kernel, ComputeBuffer buffer)
|
|||
|
|
{
|
|||
|
|
// Debug.Log("Setting buffer");
|
|||
|
|
if (buffer != null)
|
|||
|
|
{
|
|||
|
|
shader.SetBuffer(kernel, name, buffer);
|
|||
|
|
|
|||
|
|
// Debug.Log(name + " set");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static void CreateComputeBuffer<T>(ref ComputeBuffer buffer, List<T> data, int stride)
|
|||
|
|
where T : struct
|
|||
|
|
{
|
|||
|
|
//Debug.Log("Making computebuffer ");
|
|||
|
|
//buffer = new ComputeBuffer(data.Count, stride);
|
|||
|
|
|
|||
|
|
// Do we already have a compute buffer?
|
|||
|
|
if (buffer != null && data != null && stride != null)
|
|||
|
|
{
|
|||
|
|
// If no data or buffer doesn't match the given criteria, release it
|
|||
|
|
if (data.Count == 0 || buffer.count != data.Count || buffer.stride != stride)
|
|||
|
|
{
|
|||
|
|
// Debug.Log("Buffer count = " + buffer.count);
|
|||
|
|
|
|||
|
|
buffer.Release();
|
|||
|
|
buffer = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (data.Count != 0)
|
|||
|
|
{
|
|||
|
|
// If the buffer has been released or wasn't there to
|
|||
|
|
// begin with, create it
|
|||
|
|
if (buffer == null)
|
|||
|
|
{
|
|||
|
|
buffer = new ComputeBuffer(data.Count, stride);
|
|||
|
|
|
|||
|
|
// Debug.Log("Buffer count = " + buffer.count);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Set data on the buffer
|
|||
|
|
buffer.SetData(data);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Editor
|
|||
|
|
/// </summary>
|
|||
|
|
///
|
|||
|
|
private void OnDrawGizmosSelected()
|
|||
|
|
{
|
|||
|
|
if (cam == null || volumetricData == null) return;
|
|||
|
|
|
|||
|
|
Gizmos.color = Color.black;
|
|||
|
|
;
|
|||
|
|
Gizmos.matrix = Matrix4x4.TRS(cam.transform.position, cam.transform.rotation, Vector3.one);
|
|||
|
|
Gizmos.DrawFrustum(Vector3.zero, cam.fieldOfView, volumetricData.near, volumetricData.far, CamAspectRatio);
|
|||
|
|
|
|||
|
|
Gizmos.color = Color.cyan;
|
|||
|
|
Gizmos.matrix = Matrix4x4.TRS(ClipmapCurrentPos, Quaternion.identity, Vector3.one * volumetricData.ClipmapScale);
|
|||
|
|
Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|||
|
|
|
|||
|
|
Gizmos.color = Color.blue;
|
|||
|
|
Gizmos.matrix = Matrix4x4.TRS(ClipmapCurrentPos, Quaternion.identity, Vector3.one * volumetricData.ClipmapScale2);
|
|||
|
|
Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|||
|
|
|
|||
|
|
|
|||
|
|
//Gizmos.color = Color.red;
|
|||
|
|
//Gizmos.matrix = cam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
|
|||
|
|
//Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|||
|
|
|
|||
|
|
//Gizmos.color = Color.yellow;
|
|||
|
|
//Gizmos.matrix = cam.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
|
|||
|
|
//Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|||
|
|
|
|||
|
|
//Gizmos.color = Color.green;
|
|||
|
|
//Gizmos.matrix = Matrix4x4.Perspective(cam.fieldOfView, CamAspectRatio, cam.nearClipPlane, 100000f);
|
|||
|
|
//Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|||
|
|
|
|||
|
|
//Gizmos.color = Color.magenta;
|
|||
|
|
//Gizmos.matrix = Matrix4x4.Perspective(cam.fieldOfView, CamAspectRatio, volumetricData.near, volumetricData.far) * Matrix4x4.Translate(new Vector3(cam.stereoSeparation * 0.5f, 0, 0));
|
|||
|
|
//Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|||
|
|
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ReleaseAssets()
|
|||
|
|
{
|
|||
|
|
DestroyAllTextureAssets();
|
|||
|
|
|
|||
|
|
if (ComputePerFrameConstantBuffer != null)
|
|||
|
|
{
|
|||
|
|
ComputePerFrameConstantBuffer.Release();
|
|||
|
|
ComputePerFrameConstantBuffer = null;
|
|||
|
|
}
|
|||
|
|
if (StepAddPerFrameConstantBuffer != null)
|
|||
|
|
{
|
|||
|
|
StepAddPerFrameConstantBuffer.Release();
|
|||
|
|
StepAddPerFrameConstantBuffer = null;
|
|||
|
|
}
|
|||
|
|
if (ShaderConstantBuffer != null)
|
|||
|
|
{
|
|||
|
|
ShaderConstantBuffer.Release();
|
|||
|
|
ShaderConstantBuffer = null;
|
|||
|
|
}
|
|||
|
|
if (participatingMediaSphereBuffer != null)
|
|||
|
|
{
|
|||
|
|
participatingMediaSphereBuffer.Release();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void CleanupCameraData()
|
|||
|
|
{
|
|||
|
|
if (activeCamData != null)
|
|||
|
|
{
|
|||
|
|
activeCamData.m_EnableVolumetrics = false;
|
|||
|
|
activeCamData.m_VolumetricClipMap = null;
|
|||
|
|
activeCamData.m_VolumetricShaderGlobals = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SetCameraData()
|
|||
|
|
{
|
|||
|
|
if (activeCamData != null && VolumetricResult != null && ShaderConstantBuffer != null)
|
|||
|
|
{
|
|||
|
|
activeCamData.m_EnableVolumetrics = true;
|
|||
|
|
activeCamData.m_VolumetricClipMap = VolumetricResult;
|
|||
|
|
activeCamData.m_VolumetricShaderGlobals = ShaderConstantBuffer;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
Debug.LogWarning("Volumetric Rendering: Null extra camera data, volumetric result, or constant buffer!");
|
|||
|
|
activeCamData.m_EnableVolumetrics = false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if UNITY_EDITOR
|
|||
|
|
|
|||
|
|
void assignVaris()
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
//cam = GetComponentInChildren<Camera>();
|
|||
|
|
//Get shaders and seri
|
|||
|
|
if (FroxelFogCompute == null)
|
|||
|
|
FroxelFogCompute = AssetDatabase.LoadAssetAtPath<ComputeShader>("Packages/com.unity.render-pipelines.universal/Shaders/Volumetrics/VolumetricScattering.compute");
|
|||
|
|
if (FroxelFogCompute == null)
|
|||
|
|
FroxelFogCompute = AssetDatabase.LoadAssetAtPath<ComputeShader>("Packages/com.unity.render-pipelines.universal/Shaders/Volumetrics/VolumetricScattering.compute");
|
|||
|
|
if (FroxelIntegrationCompute == null)
|
|||
|
|
FroxelIntegrationCompute = AssetDatabase.LoadAssetAtPath<ComputeShader>("Packages/com.unity.render-pipelines.universal/Shaders/Volumetrics/StepAdd.compute");
|
|||
|
|
if (ClipmapCompute == null)
|
|||
|
|
ClipmapCompute = AssetDatabase.LoadAssetAtPath<ComputeShader>("Packages/com.unity.render-pipelines.universal/Shaders/Volumetrics/ClipMapGenerator.compute");
|
|||
|
|
if (BlurCompute == null)
|
|||
|
|
BlurCompute = AssetDatabase.LoadAssetAtPath<ComputeShader>("Packages/com.unity.render-pipelines.universal/Shaders/Volumetrics/VolumetricBlur.compute");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
private void Reset()
|
|||
|
|
{
|
|||
|
|
cam = GetComponentInChildren<Camera>();
|
|||
|
|
assignVaris();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
private void OnValidate()
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
//Black Texture in editor to not get in the way. Isolated h ere because shaders should skip volumetric tex in precompute otherwise.
|
|||
|
|
// TODO: Add proper scene preview feature
|
|||
|
|
if (BlackTex == null) BlackTex = CoreUtils.blackVolumeTexture; //(Texture3D)MakeBlack3DTex();
|
|||
|
|
|
|||
|
|
// UnityEditor.SceneManagement.EditorSceneManager.sceneUnloaded += UnloadKeyword; //adding function when scene is unloaded
|
|||
|
|
assignVaris();
|
|||
|
|
//if (cam == null) cam = GetComponent<Camera>();
|
|||
|
|
//if (volumetricData.near < cam.nearClipPlane || volumetricData.far > cam.farClipPlane)
|
|||
|
|
//{
|
|||
|
|
// //Auto clamp to inside of the camera's clip planes
|
|||
|
|
// volumetricData.near = Mathf.Max(volumetricData.near, cam.nearClipPlane);
|
|||
|
|
// volumetricData.far = Mathf.Min(volumetricData.far, cam.farClipPlane);
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
//Shader.EnableKeyword(VolumetricsKW); //enabling here so the editor knows that it exists
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
//Using core blackVolumeTexture instead
|
|||
|
|
//Texture MakeBlack3DTex()
|
|||
|
|
//{
|
|||
|
|
// Debug.Log("Made blank texture");
|
|||
|
|
|
|||
|
|
// int size = 1;
|
|||
|
|
|
|||
|
|
// Texture3D BlackTex = new Texture3D(1, 1, 1, TextureFormat.ARGB32, false);
|
|||
|
|
// var cols = new Color[size * size * size];
|
|||
|
|
// float mul = 1.0f / (size - 1);
|
|||
|
|
// int idx = 0;
|
|||
|
|
// Color c = Color.white;
|
|||
|
|
// for (int z = 0; z < size; ++z)
|
|||
|
|
// {
|
|||
|
|
// for (int y = 0; y < size; ++y)
|
|||
|
|
// {
|
|||
|
|
// for (int x = 0; x < size; ++x, ++idx)
|
|||
|
|
// {
|
|||
|
|
// c.r = 0;
|
|||
|
|
// c.g = 0;
|
|||
|
|
// c.b = 0;
|
|||
|
|
// c.a = 1;
|
|||
|
|
// cols[idx] = c;
|
|||
|
|
// }
|
|||
|
|
// }
|
|||
|
|
// }
|
|||
|
|
|
|||
|
|
// BlackTex.SetPixels(cols);
|
|||
|
|
// BlackTex.Apply();
|
|||
|
|
// // SetClipmap(BlackTex, 50, Vector3.zero);
|
|||
|
|
|
|||
|
|
// Shader.SetGlobalTexture(ID_VolumetricResult, BlackTex);
|
|||
|
|
|
|||
|
|
// // Shader.SetGlobalTexture("_VolumetricClipmapTexture", BlackTex); //Set clipmap for
|
|||
|
|
// return BlackTex;
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
|
|||
|
|
//public void UnloadKeyword<Scene>(Scene scene)
|
|||
|
|
//{
|
|||
|
|
// Shader.DisableKeyword("_VOLUMETRICS_ENABLED");
|
|||
|
|
|
|||
|
|
// print("The scene was unloaded!");
|
|||
|
|
//}
|
|||
|
|
|
|||
|
|
void Clear3DTexture(RenderTexture buffer)
|
|||
|
|
{
|
|||
|
|
ClipmapCompute.SetTexture(ID_ClipMapClearKern, ID_Result, buffer);
|
|||
|
|
ClipmapCompute.Dispatch(ID_ClipMapClearKern, Mathf.Max(buffer.width / 4, 1), Mathf.Max(buffer.height / 4, 1), Mathf.Max(buffer.volumeDepth / 4, 1));
|
|||
|
|
|
|||
|
|
//RenderTexture activeRT = RenderTexture.active;
|
|||
|
|
//RenderTexture.active = rt;
|
|||
|
|
//GL.sRGBWrite = rt.sRGB;
|
|||
|
|
//if (rt.dimension == TextureDimension.Tex3D)
|
|||
|
|
//{
|
|||
|
|
// CoreUtils.SetRenderTarget(
|
|||
|
|
// command,
|
|||
|
|
// rt,
|
|||
|
|
// ClearFlag.Color, Color.clear,
|
|||
|
|
// 0, CubemapFace.Unknown, -1
|
|||
|
|
// );
|
|||
|
|
|
|||
|
|
//}
|
|||
|
|
//else if (rt.dimension == TextureDimension.Cube)
|
|||
|
|
//{
|
|||
|
|
// Graphics.SetRenderTarget(rt, 0, CubemapFace.PositiveX, 0);
|
|||
|
|
// GL.Clear(false, true, color);
|
|||
|
|
// Graphics.SetRenderTarget(rt, 0, CubemapFace.PositiveY, 0);
|
|||
|
|
// GL.Clear(false, true, color);
|
|||
|
|
// Graphics.SetRenderTarget(rt, 0, CubemapFace.PositiveZ, 0);
|
|||
|
|
// GL.Clear(false, true, color);
|
|||
|
|
// Graphics.SetRenderTarget(rt, 0, CubemapFace.NegativeX, 0);
|
|||
|
|
// GL.Clear(false, true, color);
|
|||
|
|
// Graphics.SetRenderTarget(rt, 0, CubemapFace.NegativeY, 0);
|
|||
|
|
// GL.Clear(false, true, color);
|
|||
|
|
// Graphics.SetRenderTarget(rt, 0, CubemapFace.NegativeZ, 0);
|
|||
|
|
// GL.Clear(false, true, color);
|
|||
|
|
//}
|
|||
|
|
// CoreUtils.SetRenderTarget(
|
|||
|
|
// rt,
|
|||
|
|
// BuiltinRenderTextureType.CameraTarget
|
|||
|
|
//);
|
|||
|
|
// RenderTexture.active = activeRT;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void RefreshOnSceneChange(Scene oldS, Scene newS)
|
|||
|
|
{
|
|||
|
|
if (hasInitialized && oldS != null)
|
|||
|
|
{
|
|||
|
|
Debug.Log("Volumetric Rendering: Refreshing after scene swap");
|
|||
|
|
this.disable();
|
|||
|
|
this.enable();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|