772 lines
37 KiB
C#
772 lines
37 KiB
C#
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
using UnityEngine.Rendering.HighDefinition;
|
|
|
|
namespace Artngame.LUMINA {
|
|
|
|
[System.Serializable]
|
|
[VolumeComponentMenu("Post-processing/ARTnGAME/LuminaHDRP Before Post Process")]
|
|
public sealed class LuminaHDRPVolumeBeforePostProcess
|
|
: CustomPostProcessVolumeComponent, IPostProcessComponent
|
|
{
|
|
#region Effect parameters
|
|
|
|
public ClampedFloatParameter opacity
|
|
= new ClampedFloatParameter(0, 0, 1);
|
|
|
|
public ColorParameter edgeColor
|
|
= new ColorParameter(Color.black);
|
|
|
|
public ClampedFloatParameter edgeContrast
|
|
= new ClampedFloatParameter(1.2f, 0.01f, 4);
|
|
|
|
public ColorParameter fillColor
|
|
= new ColorParameter(Color.white);
|
|
|
|
public ClampedFloatParameter blurWidth
|
|
= new ClampedFloatParameter(1, 0, 2);
|
|
|
|
public ClampedFloatParameter blurFrequency
|
|
= new ClampedFloatParameter(0.5f, 0, 1);
|
|
|
|
public ClampedFloatParameter hueShift
|
|
= new ClampedFloatParameter(0.1f, 0, 0.3f);
|
|
|
|
public ClampedFloatParameter interval
|
|
= new ClampedFloatParameter(1, 0.1f, 5);
|
|
|
|
public ClampedIntParameter iteration
|
|
= new ClampedIntParameter(20, 4, 32);
|
|
|
|
public VolumeParameter<OverlayMode> overlayMode
|
|
= new VolumeParameter<OverlayMode>();
|
|
|
|
public NoInterpTextureParameter overlayTexture
|
|
= new NoInterpTextureParameter(null);
|
|
|
|
public ClampedFloatParameter overlayOpacity
|
|
= new ClampedFloatParameter(0, 0, 1);
|
|
|
|
#endregion
|
|
|
|
#region Private members
|
|
|
|
static readonly string ShaderName
|
|
= "Hidden/Kino/Aqua/HighDefinition";
|
|
|
|
Material _material;
|
|
|
|
#endregion
|
|
|
|
#region IPostProcessComponent implementation
|
|
|
|
public bool IsActive()
|
|
=> _material != null && opacity.value > 0;
|
|
|
|
#endregion
|
|
|
|
#region CustomPostProcessVolumeComponent implementation
|
|
|
|
public override CustomPostProcessInjectionPoint injectionPoint
|
|
=> CustomPostProcessInjectionPoint.AfterOpaqueAndSky;
|
|
|
|
//LUMINA
|
|
//RTHandle lrDepthBuffer;
|
|
RTHandle skyA;
|
|
RTHandle gi1;
|
|
RTHandle gi2;
|
|
RTHandle gi3;
|
|
RTHandle gi4;
|
|
RTHandle reflections;
|
|
RTHandle currentDepth;
|
|
RTHandle currentNormal;
|
|
|
|
//gi2.filterMode = FilterMode.Point;
|
|
// gi4.filterMode = FilterMode.Point;
|
|
// gi3.filterMode = FilterMode.Point;
|
|
// RenderTexture skyA = RenderTexture.GetTemporary(srcRT.rt.width, srcRT.rt.height, 0, RenderTextureFormat.ARGBHalf);
|
|
//RenderTexture gi1 = RenderTexture.GetTemporary(source.width / segi.giRenderRes, source.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBHalf);
|
|
//RenderTexture gi2 = RenderTexture.GetTemporary(source.width / segi.giRenderRes, source.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBHalf);
|
|
//reflections = RenderTexture.GetTemporary(source.width, source.height, 0, RenderTextureFormat.ARGBHalf);
|
|
// RenderTexture currentDepth = RenderTexture.GetTemporary(source.width / segi.giRenderRes, source.height / segi.giRenderRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);
|
|
//RenderTexture currentNormal = RenderTexture.GetTemporary(source.width / segi.giRenderRes, source.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
|
|
//currentNormal.filterMode = FilterMode.Point;
|
|
|
|
|
|
public override void Setup()
|
|
{
|
|
if (Camera.main == null || Camera.current != null)//v0.2
|
|
{
|
|
//Debug.Log("No cam5b");
|
|
return;
|
|
}
|
|
|
|
_material = CoreUtils.CreateEngineMaterial(ShaderName);
|
|
|
|
//LUMINA
|
|
var hdrpAsset = (GraphicsSettings.defaultRenderPipeline as HDRenderPipelineAsset);
|
|
var colorBufferFormat = hdrpAsset.currentPlatformRenderPipelineSettings.colorBufferFormat;
|
|
//if (lrDepthBuffer == null)
|
|
//{
|
|
// lrDepthBuffer = RTHandles.Alloc(
|
|
// Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
// colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)colorBufferFormat, // We don't need alpha in the blur
|
|
// useDynamicScale: true, name: "lrDepthBuffer"
|
|
// );
|
|
//}
|
|
|
|
UnityEngine.Experimental.Rendering.GraphicsFormat format1 = UnityEngine.Experimental.Rendering.GraphicsFormat.R16G16B16A16_SFloat;
|
|
|
|
if (gi1 == null)
|
|
{
|
|
gi1 = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "gi1"
|
|
);
|
|
}
|
|
if (gi2== null)
|
|
{
|
|
gi2 = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "gi2"
|
|
);
|
|
}
|
|
if (gi3 == null)
|
|
{
|
|
gi3 = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "gi3"
|
|
);
|
|
}
|
|
if (gi4 == null)
|
|
{
|
|
gi4 = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "gi4"
|
|
);
|
|
}
|
|
if (reflections == null)
|
|
{
|
|
reflections = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "reflections"
|
|
);
|
|
}
|
|
if (currentDepth == null)
|
|
{
|
|
currentDepth = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "currentDepth"
|
|
);
|
|
}
|
|
if (currentNormal == null)
|
|
{
|
|
currentNormal = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "currentNormal"
|
|
);
|
|
}
|
|
if (skyA == null)
|
|
{
|
|
skyA = RTHandles.Alloc(
|
|
Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
|
|
colorFormat: (UnityEngine.Experimental.Rendering.GraphicsFormat)format1, // We don't need alpha in the blur
|
|
useDynamicScale: true, name: "skyA"
|
|
);
|
|
}
|
|
|
|
}
|
|
//=> _material = CoreUtils.CreateEngineMaterial(ShaderName);
|
|
|
|
public override void Render
|
|
(CommandBuffer cmd, HDCamera camera, RTHandle srcRT, RTHandle destRT)
|
|
{
|
|
|
|
|
|
//v0.1
|
|
bool enableGI = false;
|
|
if (Camera.main != null)
|
|
{
|
|
LuminaHDRP segi = Camera.main.GetComponent<LuminaHDRP>();
|
|
if (segi != null)
|
|
{
|
|
enableGI = !segi.disableGI;
|
|
}
|
|
}
|
|
if (//RenderSettings.sun == null || !RenderSettings.sun.enabled ||
|
|
!enableGI || (Camera.main != null && Camera.current != null && Camera.current != Camera.main) || Camera.main == null || Camera.current != null //v0.2
|
|
) { return; }
|
|
|
|
|
|
ShaderHelper.SetProperties
|
|
(_material, srcRT,
|
|
opacity: opacity.value,
|
|
edgeColor: edgeColor.value,
|
|
edgeContrast: edgeContrast.value,
|
|
fillColor: fillColor.value,
|
|
blurWidth: blurWidth.value,
|
|
blurFrequency: blurFrequency.value,
|
|
hueShift: hueShift.value,
|
|
interval: interval.value,
|
|
iteration: iteration.value);
|
|
|
|
ShaderHelper.SetOverlayProperties
|
|
(_material,
|
|
overlayMode.value,
|
|
overlayTexture.value,
|
|
overlayOpacity.value);
|
|
|
|
|
|
//LUMINA
|
|
//// Target ID
|
|
//var rt = camera.camera.targetTexture;
|
|
//var rtid = rt != null ?
|
|
// new RenderTargetIdentifier(rt) :
|
|
// new RenderTargetIdentifier(BuiltinRenderTextureType.CameraTarget);
|
|
|
|
|
|
|
|
//Camera cameraA = renderingData.cameraData.camera;
|
|
//RenderTextureDescriptor cameraTextureDescriptor = renderingData.cameraData.cameraTargetDescriptor;
|
|
// RenderTexture skyA = RenderTexture.GetTemporary(srcRT.rt.width, srcRT.rt.height, 0, RenderTextureFormat.ARGBHalf);
|
|
//var skyA_RTID = new RenderTargetIdentifier(skyA);
|
|
//HDUtils.BlitCameraTexture()
|
|
//Graphics.Blit(destRT, skyA); //Blit(cmd, source, skyA);
|
|
RenderTexture.active = skyA;
|
|
GL.ClearWithSkybox(false, camera.camera);
|
|
|
|
|
|
// RenderTexture gi1 = RenderTexture.GetTemporary(srcRT.rt.width, srcRT.rt.height, 0, RenderTextureFormat.ARGBHalf);
|
|
|
|
OnRenderImageA(camera.camera, cmd, srcRT, gi1);
|
|
|
|
// Graphics.Blit(gi1, destRT);
|
|
//Blit(cmd, gi1, _cameraColorTargetIdent);
|
|
//context.ExecuteCommandBuffer(cmd);
|
|
//CommandBufferPool.Release(cmd);
|
|
|
|
|
|
|
|
//var downsampleProperties = new MaterialPropertyBlock();
|
|
//downsampleProperties.SetTexture("_InputTextureA", destRT);
|
|
//downsampleProperties.SetFloat("_Height", Camera.main.transform.position.y);
|
|
//HDUtils.DrawFullScreen(cmd, sheetSHAFTS, m_TemporaryColorTextureScaled, downsampleProperties, 11);
|
|
|
|
|
|
|
|
|
|
// Change render target type
|
|
// RenderTargetHandle renderTarget;
|
|
// RTHandle renderTarget;
|
|
// Associate the shader property with the render target using RTHandles.Alloc instead of renderTarget.Init
|
|
// renderTarget.Init("_ShaderProperty");
|
|
// renderTarget = RTHandles.Alloc("_ShaderProperty", name: "_ShaderProperty");
|
|
// Assign temporary render texture using the shader property identifier
|
|
// cmd.GetTemporaryRT(renderTarget.id, targetDescriptor, filterMode);
|
|
// cmd.GetTemporaryRT(Shader.PropertyToID(renderTarget.name), targetDescriptor, filterMode);
|
|
// Modify ConfigureTarget to use the new RTHandle instead of the old RenderTargetIdentifier
|
|
// ConfigureTarget(renderTarget.id);
|
|
// ConfigureTarget(renderTarget);
|
|
// Get the render texture identifier from the shader property
|
|
// cmd.ReleaseTemporaryRT(renderTarget.id);
|
|
// cmd.ReleaseTemporaryRT(Shader.PropertyToID(renderTarget.name));
|
|
////END LUMINA
|
|
|
|
HDUtils.BlitCameraTexture(cmd, gi1, destRT);
|
|
//HDUtils.DrawFullScreen(cmd, _material, destRT, null, 0);
|
|
//HDUtils.DrawFullScreen(cmd, _material, destRT, null, 0);
|
|
|
|
//LUMINA
|
|
// RenderTexture.ReleaseTemporary(skyA);
|
|
// RenderTexture.ReleaseTemporary(gi1);
|
|
|
|
//ExecuteCommandBuffer(cmd);
|
|
//CommandBufferPool.Release(cmd);
|
|
}
|
|
|
|
//LUMINA
|
|
void BlitG(CommandBuffer cmd, RenderTexture source, RenderTexture destination)
|
|
{
|
|
//material.SetTexture(ShaderIDs.MainTex, source);
|
|
Graphics.Blit(source, destination);
|
|
}
|
|
void BlitG(CommandBuffer cmd, RenderTexture source, RenderTexture destination, Material material, int pass)
|
|
{
|
|
//material.SetTexture(ShaderIDs.MainTex, source);
|
|
Graphics.Blit(source, destination, material, pass, pass);
|
|
}
|
|
void Blit(CommandBuffer cmd, RTHandle source, RTHandle destination)
|
|
{
|
|
_material.SetTexture(ShaderIDs.MainTex, source.rt);
|
|
HDUtils.DrawFullScreen(cmd, _material, destination, null, 0);//CORRECT
|
|
}
|
|
void BlitCMD(CommandBuffer cmd, RenderTexture source, RenderTexture destination)
|
|
{
|
|
//_material.SetTexture(ShaderIDs.MainTex, source.rt);
|
|
cmd.Blit(source, destination);
|
|
}
|
|
void BlitCMDF(CommandBuffer cmd, RenderTexture source, RenderTexture destination, Material material, int pass)
|
|
{
|
|
//_material.SetTexture(ShaderIDs.MainTex, source.rt);
|
|
cmd.Blit(source, destination, material,pass);
|
|
}
|
|
void BlitCMDF3D(CommandBuffer cmd, RenderTexture source, RenderTexture destination, Material material, int pass)
|
|
{
|
|
// material.SetTexture("_MainTexARRAY", source);
|
|
cmd.Blit(source, destination, material, pass);
|
|
}
|
|
void Blit(CommandBuffer cmd, RTHandle source, RTHandle destination, Material material, int pass)
|
|
{
|
|
material.SetTexture(ShaderIDs.MainTex, source.rt);
|
|
HDUtils.DrawFullScreen(cmd, material, destination, null, pass);
|
|
}
|
|
void Blit3D(CommandBuffer cmd, RTHandle source, RTHandle destination, Material material, int pass)
|
|
{
|
|
material.SetTexture("_MainTexARRAY", source.rt);
|
|
HDUtils.DrawFullScreen(cmd, material, destination, null, pass);
|
|
}
|
|
void OnRenderImageA(Camera camera, CommandBuffer cmd, RTHandle source, RTHandle destination) //void OnRenderImageA(Camera camera, CommandBuffer cmd, RenderTexture source, RenderTexture destination)
|
|
{
|
|
// Graphics.Blit(source, destination);
|
|
//Blit(cmd, source, destination);
|
|
//return;
|
|
|
|
if (Camera.main == null || Camera.current != null)//v0.2
|
|
{
|
|
//Debug.Log("No cam5b");
|
|
return;
|
|
}
|
|
|
|
if (Camera.main != null && camera != Camera.main || Camera.current != null)//v0.2
|
|
{
|
|
return;
|
|
}
|
|
|
|
//Debug.Log(Camera.main.orthographic);
|
|
Camera.main.depthTextureMode = DepthTextureMode.Depth;
|
|
|
|
//v0.1
|
|
if (Camera.main != null)
|
|
{
|
|
LuminaHDRP segi = Camera.main.GetComponent<LuminaHDRP>(); //LUMINA segi = Camera.main.GetComponent<LUMINA>();
|
|
if (segi != null && segi.enabled)
|
|
{
|
|
if (segi.notReadyToRender)
|
|
{
|
|
//Blit(cmd, source, source);
|
|
//Graphics.Blit(source, destination);
|
|
//Graphics.Blit();
|
|
//HDUtils.BlitCameraTexture()
|
|
//Blit(cmd, source, destination);
|
|
cmd.Blit(source, destination);
|
|
return;
|
|
}
|
|
|
|
//Set parameters
|
|
Shader.SetGlobalFloat("SEGIVoxelScaleFactor", segi.voxelScaleFactor);
|
|
|
|
if (!segi.material)//v0.2a
|
|
{
|
|
segi.material = new Material(Shader.Find("Hidden/SEGI"));
|
|
//material.hideFlags = HideFlags.HideAndDontSave;//v0.2
|
|
}
|
|
|
|
segi.material.SetMatrix("CameraToWorld", segi.attachedCamera.cameraToWorldMatrix);
|
|
segi.material.SetMatrix("WorldToCamera", segi.attachedCamera.worldToCameraMatrix);
|
|
segi.material.SetMatrix("ProjectionMatrixInverse", segi.attachedCamera.projectionMatrix.inverse);
|
|
segi.material.SetMatrix("ProjectionMatrix", segi.attachedCamera.projectionMatrix);
|
|
segi.material.SetInt("FrameSwitch", segi.frameCounter);
|
|
Shader.SetGlobalInt("SEGIFrameSwitch", segi.frameCounter);
|
|
segi.material.SetVector("CameraPosition", segi.transform.position);
|
|
segi.material.SetFloat("DeltaTime", Time.deltaTime);
|
|
|
|
segi.material.SetInt("StochasticSampling", segi.stochasticSampling ? 1 : 0);
|
|
segi.material.SetInt("TraceDirections", segi.cones);
|
|
segi.material.SetInt("TraceSteps", segi.coneTraceSteps);
|
|
segi.material.SetFloat("TraceLength", segi.coneLength);
|
|
segi.material.SetFloat("ConeSize", segi.coneWidth);
|
|
segi.material.SetFloat("OcclusionStrength", segi.occlusionStrength);
|
|
segi.material.SetFloat("OcclusionPower", segi.occlusionPower);
|
|
segi.material.SetFloat("ConeTraceBias", segi.coneTraceBias);
|
|
segi.material.SetFloat("GIGain", segi.giGain);
|
|
segi.material.SetFloat("NearLightGain", segi.nearLightGain);
|
|
segi.material.SetFloat("NearOcclusionStrength", segi.nearOcclusionStrength);
|
|
segi.material.SetInt("DoReflections", segi.doReflections ? 1 : 0);
|
|
segi.material.SetInt("HalfResolution", segi.halfResolution ? 1 : 0);
|
|
segi.material.SetInt("ReflectionSteps", segi.reflectionSteps);
|
|
segi.material.SetFloat("ReflectionOcclusionPower", segi.reflectionOcclusionPower);
|
|
segi.material.SetFloat("SkyReflectionIntensity", segi.skyReflectionIntensity);
|
|
segi.material.SetFloat("FarOcclusionStrength", segi.farOcclusionStrength);
|
|
segi.material.SetFloat("FarthestOcclusionStrength", segi.farthestOcclusionStrength);
|
|
segi.material.SetTexture("NoiseTexture", segi.blueNoise[segi.frameCounter % 64]);
|
|
segi.material.SetFloat("BlendWeight", segi.temporalBlendWeight);
|
|
|
|
//v0.4
|
|
segi.material.SetFloat("contrastA", segi.contrastA);
|
|
segi.material.SetVector("ReflectControl", segi.ReflectControl);
|
|
|
|
//v0.7
|
|
segi.material.SetVector("ditherControl",
|
|
new Vector4(segi.DitherControl.x,
|
|
Mathf.Clamp(segi.DitherControl.y, 0.1f, 10),
|
|
Mathf.Clamp(segi.DitherControl.z, 0.1f, 10),
|
|
Mathf.Clamp(segi.DitherControl.w, 0.1f, 10))); //v1.2b
|
|
|
|
//v1.2
|
|
segi.material.SetFloat("smoothNormals", segi.smoothNormals);
|
|
|
|
//If Visualize Voxels is enabled, just render the voxel visualization shader pass and return
|
|
if (segi.visualizeVoxels)
|
|
{
|
|
//Blit(cmd, source, destination);
|
|
//Debug.Log("AA");
|
|
//segi.material.SetTexture("_MainTexARRAY", source.rt);
|
|
Blit3D(cmd, source, destination, segi.material, LuminaHDRP.Pass.VisualizeVoxels);
|
|
//Blit(cmd, source, destination, segi.material, LUMINA.Pass.VisualizeVoxels);
|
|
return;
|
|
}
|
|
|
|
//Setup temporary textures
|
|
// RenderTexture gi1 = RenderTexture.GetTemporary(source.rt.width / segi.giRenderRes, source.rt.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBHalf);
|
|
//RenderTexture gi2 = RenderTexture.GetTemporary(source.rt.width / segi.giRenderRes, source.rt.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBHalf);
|
|
RenderTexture gi11 = RenderTexture.GetTemporary(source.rt.width / segi.giRenderRes, source.rt.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBFloat);
|
|
RenderTexture gi22 = RenderTexture.GetTemporary(source.rt.width / segi.giRenderRes, source.rt.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBFloat);
|
|
RenderTexture reflectionsA = null;
|
|
|
|
//If reflections are enabled, create a temporary render buffer to hold them
|
|
if (segi.doReflections)
|
|
{
|
|
reflectionsA = RenderTexture.GetTemporary(source.rt.width, source.rt.height, 0, RenderTextureFormat.ARGBHalf);
|
|
}
|
|
|
|
|
|
|
|
|
|
//Setup textures to hold the current camera depth and normal
|
|
// RenderTexture currentDepth = RenderTexture.GetTemporary(source.rt.width / segi.giRenderRes, source.rt.height / segi.giRenderRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);
|
|
// currentDepth.filterMode = FilterMode.Point;
|
|
|
|
// RenderTexture currentNormal = RenderTexture.GetTemporary(source.width / segi.giRenderRes, source.height / segi.giRenderRes, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
|
|
// currentNormal.filterMode = FilterMode.Point;
|
|
|
|
|
|
// //HDRP2
|
|
// cmd.Blit(segi.DepthBUFFER, currentDepth);
|
|
|
|
//Get the camera depth and normals
|
|
//// Blit(cmd, source, currentDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);//v0.1
|
|
//Blit(cmd, source, currentDepth, segi.material, VolumeLitSEGI.Pass.GetCameraDepthTexture);
|
|
// cmd.Blit(source, currentDepth, segi.material, 13);// LUMINA.Pass.GetCameraDepthTexture);
|
|
// cmd.Blit(source, currentDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);// LUMINA.Pass.GetCameraDepthTexture);
|
|
// segi.material.SetTexture("CurrentDepth", currentDepth);
|
|
//Graphics.Blit(segi.NormalBUFFER, segi.DepthBUFFERH);
|
|
//cmd.Blit(segi.NormalBUFFER, segi.DepthBUFFERH);
|
|
segi.material.SetTexture("CurrentDepth", segi.DepthBUFFER);// currentDepth); //segi.NormalBUFFER);
|
|
|
|
//v1.5
|
|
if (!segi.useInternalDepth)
|
|
{
|
|
segi.material.SetTexture("_CameraDepthTexture", segi.DepthBUFFER); //currentDepth); //// HDRP !!!! //HDRP2
|
|
}
|
|
else
|
|
{
|
|
segi.material.SetTexture("_CameraDepthTexture", segi.DepthBUFFERInternal);//v1.6
|
|
}
|
|
|
|
//// Blit(cmd, source, currentNormal, segi.material, LUMINA.Pass.GetWorldNormals);
|
|
//// segi.material.SetTexture("CurrentNormal", currentNormal);
|
|
//cmd.Blit(segi.NormalBUFFER, segi.NormalBUFFERH);
|
|
segi.material.SetTexture("CurrentNormal", segi.NormalBUFFER);// segi.DepthBUFFER);
|
|
|
|
|
|
//v0.1 - check depths
|
|
if (segi.visualizeNORMALS)
|
|
{
|
|
cmd.Blit(segi.NormalBUFFER, destination);
|
|
// Blit(cmd, segi.NormalBUFFERH, destination);
|
|
//BlitG(cmd, segi.NormalBUFFER, destination);
|
|
//Blit(cmd, currentNormal, destination);
|
|
//RenderTexture.ReleaseTemporary(currentDepth);
|
|
RenderTexture.ReleaseTemporary(gi11);
|
|
RenderTexture.ReleaseTemporary(gi22);
|
|
return;
|
|
}
|
|
if (segi.visualizeDEPTH)
|
|
{
|
|
|
|
//cmd.Blit(segi.DepthBUFFER, destination); //HDRP2
|
|
if (!segi.useInternalDepth)
|
|
{
|
|
cmd.Blit(segi.DepthBUFFER, destination);
|
|
}
|
|
else
|
|
{
|
|
cmd.Blit(segi.DepthBUFFERInternal, destination);
|
|
}
|
|
//Blit(cmd, currentDepth, destination);
|
|
// RenderTexture.ReleaseTemporary(currentDepth);
|
|
RenderTexture.ReleaseTemporary(gi11);
|
|
RenderTexture.ReleaseTemporary(gi22);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
//Set the previous GI result and camera depth textures to access them in the shader
|
|
segi.material.SetTexture("PreviousGITexture", segi.previousGIResult);
|
|
Shader.SetGlobalTexture("PreviousGITexture", segi.previousGIResult);
|
|
segi.material.SetTexture("PreviousDepth", segi.previousCameraDepth);
|
|
|
|
//Render diffuse GI tracing result
|
|
// Blit3D(cmd, source, gi2, segi.material, LUMINA.Pass.DiffuseTrace);
|
|
segi.material.SetTexture("currentNormals", segi.NormalBUFFER);//HDRP
|
|
//Blit3D(cmd, source, gi22, segi.material, LUMINA.Pass.DiffuseTrace);
|
|
//Blit3D(cmd, source, destination, segi.material, LUMINA.Pass.DiffuseTrace); return;
|
|
|
|
|
|
cmd.Blit(source, gi22, segi.material, LuminaHDRP.Pass.DiffuseTrace);
|
|
// cmd.Blit(gi22, destination);
|
|
//RenderTexture.ReleaseTemporary(gi11);
|
|
//RenderTexture.ReleaseTemporary(gi22);
|
|
//return;
|
|
|
|
if (segi.visualizeGI)
|
|
{
|
|
//Blit(cmd, gi2, destination);
|
|
cmd.Blit(gi22, destination);
|
|
|
|
//RenderTexture.ReleaseTemporary(currentDepth);
|
|
RenderTexture.ReleaseTemporary(gi11);
|
|
RenderTexture.ReleaseTemporary(gi22);
|
|
return;
|
|
}
|
|
|
|
if (segi.doReflections)
|
|
{
|
|
//Render GI reflections result
|
|
BlitCMDF3D(cmd, source, reflectionsA, segi.material, LuminaHDRP.Pass.SpecularTrace);
|
|
//Blit(cmd, source, reflections, segi.material, LuminaHDRP.Pass.SpecularTrace);
|
|
segi.material.SetTexture("Reflections", reflectionsA);
|
|
}
|
|
|
|
|
|
//Perform bilateral filtering
|
|
if (segi.useBilateralFiltering)
|
|
{
|
|
segi.material.SetVector("Kernel", new Vector2(0.0f, 1.0f));
|
|
BlitCMDF(cmd, gi22, gi11, segi.material, LuminaHDRP.Pass.BilateralBlur);
|
|
|
|
segi.material.SetVector("Kernel", new Vector2(1.0f, 0.0f));
|
|
BlitCMDF(cmd, gi11, gi22, segi.material, LuminaHDRP.Pass.BilateralBlur);
|
|
|
|
segi.material.SetVector("Kernel", new Vector2(0.0f, 1.0f));
|
|
BlitCMDF(cmd, gi22, gi11, segi.material, LuminaHDRP.Pass.BilateralBlur);
|
|
|
|
segi.material.SetVector("Kernel", new Vector2(1.0f, 0.0f));
|
|
BlitCMDF(cmd, gi11, gi22, segi.material, LuminaHDRP.Pass.BilateralBlur);
|
|
}
|
|
|
|
//If Half Resolution tracing is enabled
|
|
if (segi.giRenderRes == 2)
|
|
{
|
|
// Debug.Log("HALF RES");
|
|
|
|
// RenderTexture.ReleaseTemporary(gi1);
|
|
RenderTexture.ReleaseTemporary(gi11);//HDRP
|
|
//RenderTexture.ReleaseTemporary(gi22);
|
|
|
|
//Setup temporary textures
|
|
// RenderTexture gi3 = RenderTexture.GetTemporary(source.width, source.height, 0, RenderTextureFormat.ARGBHalf);
|
|
// RenderTexture gi4 = RenderTexture.GetTemporary(source.width, source.height, 0, RenderTextureFormat.ARGBHalf);
|
|
RenderTexture gi33 = RenderTexture.GetTemporary(source.rt.width, source.rt.height, 0, RenderTextureFormat.ARGBHalf);
|
|
RenderTexture gi44 = RenderTexture.GetTemporary(source.rt.width, source.rt.height, 0, RenderTextureFormat.ARGBHalf);
|
|
|
|
|
|
//Prepare the half-resolution diffuse GI result to be bilaterally upsampled
|
|
// gi2.filterMode = FilterMode.Point;
|
|
gi22.filterMode = FilterMode.Point;
|
|
// Blit(cmd, gi2, gi4);
|
|
cmd.Blit(gi22, gi44);
|
|
|
|
// RenderTexture.ReleaseTemporary(gi2);
|
|
//RenderTexture.ReleaseTemporary(gi22);
|
|
|
|
// gi4.filterMode = FilterMode.Point;
|
|
// gi3.filterMode = FilterMode.Point;
|
|
gi44.filterMode = FilterMode.Point;
|
|
gi33.filterMode = FilterMode.Point;
|
|
|
|
|
|
//Perform bilateral upsampling on half-resolution diffuse GI result
|
|
segi.material.SetVector("Kernel", new Vector2(1.0f, 0.0f));
|
|
//Blit3D(cmd, gi4, gi3, segi.material, LuminaHDRP.Pass.BilateralUpsample);
|
|
BlitCMDF3D(cmd, gi44, gi33, segi.material, LuminaHDRP.Pass.BilateralUpsample);
|
|
segi.material.SetVector("Kernel", new Vector2(0.0f, 1.0f));
|
|
|
|
//Perform temporal reprojection and blending
|
|
if (segi.temporalBlendWeight < 1.0f)
|
|
{
|
|
cmd.Blit(gi33, gi44); //Blit(cmd, gi3, gi4);
|
|
BlitCMDF3D(cmd, gi44, gi33, segi.material, LuminaHDRP.Pass.TemporalBlend);
|
|
//Blit3D(cmd, gi4, gi3, segi.material, LUMINA.Pass.TemporalBlend);
|
|
//Blit(cmd, gi3, segi.previousGIResult);
|
|
//Blit(cmd, source, segi.previousCameraDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);
|
|
//BlitG(cmd, gi3, segi.previousGIResult);
|
|
//BlitG(cmd, source, segi.previousCameraDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);
|
|
cmd.Blit(gi33, segi.previousGIResult);
|
|
//cmd.Blit(source, segi.previousCameraDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);
|
|
cmd.Blit(segi.DepthBUFFER, segi.previousCameraDepth);
|
|
}
|
|
|
|
//Set the result to be accessed in the shader
|
|
segi.material.SetTexture("GITexture", gi33);
|
|
|
|
//Actually apply the GI to the scene using gbuffer data
|
|
segi.material.SetTexture("_MainTexSKY", source.rt); //skyA.rt); // source.rt);
|
|
segi.material.SetTexture("currentNormals", segi.NormalBUFFER);//HDRP
|
|
//Blit3D(cmd, source, destination, segi.material, segi.visualizeGI ? LUMINA.Pass.VisualizeGI : LUMINA.Pass.BlendWithScene);
|
|
|
|
//v1.1
|
|
//BlitCMDF3D(cmd, source, destination, segi.material, segi.visualizeGI ? LuminaHDRP.Pass.VisualizeGI : LuminaHDRP.Pass.BlendWithScene);
|
|
cmd.Blit(gi33, destination, segi.material, segi.visualizeGI ? LuminaHDRP.Pass.VisualizeGI : LuminaHDRP.Pass.BlendWithScene);
|
|
|
|
//Release temporary textures
|
|
// RenderTexture.ReleaseTemporary(gi3);
|
|
// RenderTexture.ReleaseTemporary(gi4);
|
|
RenderTexture.ReleaseTemporary(gi33);
|
|
RenderTexture.ReleaseTemporary(gi44);
|
|
RenderTexture.ReleaseTemporary(gi22);
|
|
}
|
|
else //If Half Resolution tracing is disabled
|
|
{
|
|
//Perform temporal reprojection and blending
|
|
if (segi.temporalBlendWeight < 1.0f)
|
|
{
|
|
BlitCMDF3D(cmd, gi22, gi11, segi.material, LuminaHDRP.Pass.TemporalBlend);
|
|
//Blit3D(cmd, gi2, gi1, segi.material, LUMINA.Pass.TemporalBlend);
|
|
// Blit(cmd, gi1, segi.previousGIResult);
|
|
// Blit(cmd, source, segi.previousCameraDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);
|
|
//BlitG(cmd, gi1, segi.previousGIResult);
|
|
//BlitG(cmd, source, segi.previousCameraDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);
|
|
cmd.Blit(gi11, segi.previousGIResult);
|
|
//cmd.Blit(source, segi.previousCameraDepth, segi.material, LUMINA.Pass.GetCameraDepthTexture);
|
|
cmd.Blit(segi.DepthBUFFER, segi.previousCameraDepth);
|
|
}
|
|
|
|
//Actually apply the GI to the scene using gbuffer data
|
|
segi.material.SetTexture("GITexture", segi.temporalBlendWeight < 1.0f ? gi11 : gi22);
|
|
|
|
//cmd.Blit(gi11, destination);
|
|
//RenderTexture.ReleaseTemporary(gi11);
|
|
//RenderTexture.ReleaseTemporary(gi22);
|
|
//return;
|
|
segi.material.SetTexture("_MainTexSKY", source.rt); //skyA.rt); // source.rt);
|
|
segi.material.SetTexture("currentNormals", segi.NormalBUFFER);//HDRP
|
|
|
|
//v1.1
|
|
//Blit3D(cmd, source, destination, segi.material, segi.visualizeGI ? LuminaHDRP.Pass.VisualizeGI : LuminaHDRP.Pass.BlendWithScene);
|
|
cmd.Blit(gi22, destination, segi.material, segi.visualizeGI ? LuminaHDRP.Pass.VisualizeGI : LuminaHDRP.Pass.BlendWithScene);
|
|
|
|
segi.material.SetTexture("currentNormals", segi.NormalBUFFER);//HDRP
|
|
//Release temporary textures
|
|
// RenderTexture.ReleaseTemporary(gi1);
|
|
// RenderTexture.ReleaseTemporary(gi2);
|
|
RenderTexture.ReleaseTemporary(gi11);
|
|
RenderTexture.ReleaseTemporary(gi22);
|
|
}
|
|
|
|
//Release temporary textures
|
|
// RenderTexture.ReleaseTemporary(currentDepth);
|
|
// RenderTexture.ReleaseTemporary(currentNormal);
|
|
|
|
//Visualize the sun depth texture
|
|
if (segi.visualizeSunDepthTexture)
|
|
{
|
|
//Blit(cmd, segi.sunDepthTexture, destination);
|
|
//BlitG(cmd, segi.sunDepthTexture, destination);
|
|
cmd.Blit(segi.sunDepthTexture, destination);
|
|
}
|
|
|
|
|
|
//Release the temporary reflections result texture
|
|
if (segi.doReflections)
|
|
{
|
|
RenderTexture.ReleaseTemporary(reflectionsA);
|
|
}
|
|
|
|
//Set matrices/vectors for use during temporal reprojection
|
|
segi.material.SetMatrix("ProjectionPrev", segi.attachedCamera.projectionMatrix);
|
|
segi.material.SetMatrix("ProjectionPrevInverse", segi.attachedCamera.projectionMatrix.inverse);
|
|
segi.material.SetMatrix("WorldToCameraPrev", segi.attachedCamera.worldToCameraMatrix);
|
|
segi.material.SetMatrix("CameraToWorldPrev", segi.attachedCamera.cameraToWorldMatrix);
|
|
segi.material.SetVector("CameraPositionPrev", segi.transform.position);
|
|
|
|
//Advance the frame counter
|
|
segi.frameCounter = (segi.frameCounter + 1) % (64);
|
|
|
|
RenderTexture.ReleaseTemporary(gi11);
|
|
RenderTexture.ReleaseTemporary(gi22);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override void Cleanup()
|
|
{
|
|
//Debug.Log("Clean AQUA");
|
|
//=> CoreUtils.Destroy(_material);
|
|
CoreUtils.Destroy(_material);//v0.2
|
|
if (gi1 != null)
|
|
{
|
|
gi1.Release();
|
|
}
|
|
if (gi2 != null)
|
|
{
|
|
gi2.Release();
|
|
}
|
|
if (gi3 != null)
|
|
{
|
|
gi3.Release();
|
|
}
|
|
if (gi4 != null)
|
|
{
|
|
gi4.Release();
|
|
}
|
|
if (skyA != null)
|
|
{
|
|
skyA.Release();
|
|
}
|
|
if (reflections != null)
|
|
{
|
|
reflections.Release();
|
|
}
|
|
if (currentDepth != null)
|
|
{
|
|
currentDepth.Release();
|
|
}
|
|
if (currentNormal != null)
|
|
{
|
|
currentNormal.Release();
|
|
}
|
|
//currentDepth.Release();
|
|
//currentNormal.Release();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
}
|