554 lines
32 KiB
C#
554 lines
32 KiB
C#
//pipelinedefine
|
|
#define H_URP
|
|
|
|
using HTraceWSGI.Scripts.Data.Private;
|
|
using HTraceWSGI.Scripts.Extensions;
|
|
using HTraceWSGI.Scripts.Globals;
|
|
using UnityEngine;
|
|
using UnityEngine.Experimental.Rendering;
|
|
using UnityEngine.Rendering;
|
|
using UnityEngine.Rendering.Universal;
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
using HTraceWSGI.Scripts.Passes.Shared;
|
|
using HTraceWSGI.Scripts.Services.VoxelCameras;
|
|
using UnityEngine.Rendering.RendererUtils;
|
|
using UnityEngine.Rendering.RenderGraphModule;
|
|
#endif
|
|
|
|
namespace HTraceWSGI.Scripts.Passes.URP
|
|
{
|
|
internal class VoxelizationPassURP : ScriptableRenderPass
|
|
{
|
|
#region --------------------------- Non Render Graph ---------------------------
|
|
|
|
#if !UNITY_6000_4_OR_NEWER
|
|
private ScriptableRenderer _renderer;
|
|
|
|
protected internal void Initialize(ScriptableRenderer renderer)
|
|
{
|
|
_renderer = renderer;
|
|
}
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
[System.Obsolete]
|
|
#endif
|
|
public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
|
|
{
|
|
|
|
}
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
[System.Obsolete]
|
|
#endif
|
|
public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
|
|
{
|
|
ConfigureInput(ScriptableRenderPassInput.Depth); // | ScriptableRenderPassInput.Normal);
|
|
}
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
[System.Obsolete]
|
|
#endif
|
|
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
|
|
{
|
|
var cmd = CommandBufferPool.Get(HNames.HTRACE_SHADOWMAP_PASS_NAME);
|
|
|
|
Camera camera = renderingData.cameraData.camera;
|
|
int width = (int)(camera.scaledPixelWidth * renderingData.cameraData.renderScale);
|
|
int height = (int)(camera.scaledPixelHeight * renderingData.cameraData.renderScale);
|
|
|
|
// switch (HSettings.VoxelizationSettings.VoxelizationUpdateMode)
|
|
// {
|
|
// case VoxelizationUpdateMode.Constant:
|
|
// using (new HTraceProfilingScope(cmd, s_RenderShadowmapProfilingSampler))
|
|
// //ExecuteConstant(cmd, camera, width, height, ref renderingData.cullResults);
|
|
// break;
|
|
// case VoxelizationUpdateMode.Partial:
|
|
// using (new HTraceProfilingScope(cmd, s_RenderShadowmapProfilingSampler))
|
|
// //ExecutePartial(cmd, camera, width, height);
|
|
// break;
|
|
// }
|
|
|
|
VoxelizationShared.History.Update();
|
|
|
|
context.ExecuteCommandBuffer(cmd);
|
|
cmd.Clear();
|
|
CommandBufferPool.Release(cmd);
|
|
}
|
|
#endif
|
|
|
|
#endregion --------------------------- Non Render Graph ---------------------------
|
|
|
|
#region --------------------------- Render Graph ---------------------------
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
private class PassData
|
|
{
|
|
public RendererListHandle RendererListHandle;
|
|
public UniversalCameraData UniversalCameraData;
|
|
}
|
|
|
|
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
|
|
{
|
|
using (var builder = renderGraph.AddUnsafePass<PassData>(HNames.HTRACE_VOXELIZATION_PASS_NAME, out PassData passData, new ProfilingSampler(HNames.HTRACE_VOXELIZATION_PASS_NAME)))
|
|
{
|
|
UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
|
|
UniversalCameraData universalCameraData = frameData.Get<UniversalCameraData>();
|
|
UniversalRenderingData universalRenderingData = frameData.Get<UniversalRenderingData>();
|
|
UniversalLightData lightData = frameData.Get<UniversalLightData>();
|
|
CullContextData cullContextData = frameData.Get<CullContextData>();
|
|
|
|
ConfigureInput(ScriptableRenderPassInput.Depth);
|
|
|
|
builder.AllowGlobalStateModification(true);
|
|
builder.AllowPassCulling(true);
|
|
|
|
passData.UniversalCameraData = universalCameraData;
|
|
|
|
if (VoxelizationShared.VoxelizationShader == null) VoxelizationShared.VoxelizationShader = Shader.Find("Hidden/HTraceWSGI/VoxelizationURP");
|
|
if (VoxelizationShared.HVoxelization == null) VoxelizationShared.HVoxelization = HExtensions.LoadComputeShader("Voxelization");
|
|
if (VoxelizationShared.VoxelVisualization == null) VoxelizationShared.VoxelVisualization = HExtensions.LoadComputeShader("VoxelVisualization");
|
|
|
|
if (VoxelizationShared.DummyVoxelBuffer == null) VoxelizationShared.DummyVoxelBuffer = new ComputeBuffer(1, sizeof(int));
|
|
|
|
int voxelResX = HSettings.VoxelizationSettings.ExactData.Resolution.x;
|
|
int voxelResY = HSettings.VoxelizationSettings.ExactData.Resolution.z;
|
|
int voxelResZ = HSettings.VoxelizationSettings.ExactData.Resolution.y;
|
|
|
|
RenderTextureDescriptor desc = new RenderTextureDescriptor(voxelResX, voxelResY);
|
|
|
|
VoxelizationShared.VoxelPositionPyramid.ReAllocateIfNeeded(name: "_VoxelPositionPyramid", ref desc, graphicsFormat: GraphicsFormat.R8_UInt,voxelResX, voxelResY, volumeDepth: voxelResZ, dimension: TextureDimension.Tex3D, useMipMap: true);
|
|
VoxelizationShared.VoxelPositionIntermediate.ReAllocateIfNeeded(name: "_VoxelPositionIntermediate", ref desc, GraphicsFormat.R8_UInt, voxelResX / 4, voxelResY / 4, volumeDepth: voxelResZ / 4, dimension: TextureDimension.Tex3D);
|
|
renderGraph.ImportTexture(VoxelizationShared.VoxelPositionPyramid.rt);
|
|
renderGraph.ImportTexture(VoxelizationShared.VoxelPositionIntermediate.rt);
|
|
|
|
switch (HSettings.VoxelizationSettings.VoxelizationUpdateMode)
|
|
{
|
|
case VoxelizationUpdateMode.Constant:
|
|
VoxelizationShared.VoxelData.ReAllocateIfNeeded(name: "_VoxelData", ref desc, GraphicsFormat.R32_UInt, voxelResX, voxelResY, volumeDepth: voxelResZ, dimension: TextureDimension.Tex3D);
|
|
VoxelizationShared.DummyVoxelizationTarget.ReAllocateIfNeeded(name: "_DummyVoxelizationDynamicTarget", ref desc, GraphicsFormat.R8_UNorm, voxelResX * 2, voxelResZ * 2);
|
|
|
|
renderGraph.ImportTexture(VoxelizationShared.DummyVoxelizationTarget.rt);
|
|
renderGraph.ImportTexture(VoxelizationShared.VoxelData.rt);
|
|
|
|
VoxelizationShared.DummyVoxelizationStaticTarget?.HRelease();
|
|
VoxelizationShared.DummyVoxelizationDynamicTarget?.HRelease();
|
|
VoxelizationShared.VoxelData_A?.HRelease();
|
|
VoxelizationShared.VoxelData_B?.HRelease();
|
|
break;
|
|
case VoxelizationUpdateMode.Partial:
|
|
VoxelizationShared.DummyVoxelizationStaticTarget.ReAllocateIfNeeded(name: "_DummyVoxelizationStaticTarget", ref desc, GraphicsFormat.R8_UNorm,voxelResX, voxelResZ);
|
|
VoxelizationShared.DummyVoxelizationDynamicTarget.ReAllocateIfNeeded(name: "_DummyVoxelizationDynamicTarget", ref desc, GraphicsFormat.R8_UNorm, voxelResX * 2, voxelResZ * 2);
|
|
VoxelizationShared.VoxelData_A.ReAllocateIfNeeded(name: "_VoxelData_A", ref desc, GraphicsFormat.R32_UInt,voxelResX, voxelResY, volumeDepth: voxelResZ, dimension: TextureDimension.Tex3D);
|
|
VoxelizationShared.VoxelData_B.ReAllocateIfNeeded(name: "_VoxelData_B", ref desc, GraphicsFormat.R32_UInt,voxelResX, voxelResY, volumeDepth: voxelResZ, dimension: TextureDimension.Tex3D);
|
|
|
|
renderGraph.ImportTexture(VoxelizationShared.DummyVoxelizationStaticTarget.rt);
|
|
renderGraph.ImportTexture(VoxelizationShared.DummyVoxelizationDynamicTarget.rt);
|
|
renderGraph.ImportTexture(VoxelizationShared.VoxelData_A.rt);
|
|
renderGraph.ImportTexture(VoxelizationShared.VoxelData_B.rt);
|
|
|
|
VoxelizationShared.DummyVoxelizationTarget?.HRelease();
|
|
VoxelizationShared.VoxelData?.HRelease();
|
|
break;
|
|
}
|
|
|
|
if (VoxelizationShared.History.VoxelizationUpdateMode != HSettings.VoxelizationSettings.VoxelizationUpdateMode && HSettings.VoxelizationSettings.VoxelizationUpdateMode == VoxelizationUpdateMode.Partial)
|
|
VoxelizationRuntimeData.FullVoxelization = true;
|
|
|
|
VoxelizationRuntimeData.VoxelCamera.ExecuteUpdate(universalCameraData.camera);
|
|
AddRendererList(renderGraph, universalCameraData, universalRenderingData, lightData, passData, builder, cullContextData);
|
|
|
|
builder.SetRenderFunc((PassData data, UnsafeGraphContext context) => ExecutePass(data, context));
|
|
}
|
|
}
|
|
|
|
private static void AddRendererList(RenderGraph renderGraph, UniversalCameraData universalCameraData, UniversalRenderingData universalRenderingData, UniversalLightData lightData, PassData passData,
|
|
IUnsafeRenderGraphBuilder builder, CullContextData cullContextData)
|
|
{
|
|
LayerMask voxelizationLayer = HSettings.VoxelizationSettings.VoxelizationMask;
|
|
|
|
if (HSettings.VoxelizationSettings.VoxelizationUpdateMode == VoxelizationUpdateMode.Partial && VoxelizationRuntimeData.OctantIndex == OctantIndex.DynamicObjects)
|
|
{
|
|
voxelizationLayer = HSettings.VoxelizationSettings.DynamicObjectsMask & HSettings.VoxelizationSettings.VoxelizationMask;
|
|
}
|
|
|
|
SortingCriteria sortFlags = universalCameraData.defaultOpaqueSortFlags;
|
|
RenderQueueRange renderQueueRange = RenderQueueRange.opaque;
|
|
FilteringSettings filterSettings = new FilteringSettings(renderQueueRange, voxelizationLayer);
|
|
|
|
ShaderTagId tag = new ShaderTagId("ShadowCaster"); //todo: use only one now, i will upgrade it if needed, because it's not easy
|
|
// Create drawing settings
|
|
DrawingSettings drawSettings = RenderingUtils.CreateDrawingSettings(tag, universalRenderingData, universalCameraData, lightData, sortFlags);
|
|
drawSettings.overrideShader = VoxelizationShared.VoxelizationShader;
|
|
drawSettings.overrideShaderPassIndex = 0;
|
|
|
|
var cullingCamera = VoxelizationRuntimeData.VoxelCamera.Camera;
|
|
if (HSettings.VoxelizationSettings.VoxelizationUpdateMode == VoxelizationUpdateMode.Partial)
|
|
cullingCamera = VoxelizationRuntimeData.FullVoxelization ? VoxelizationRuntimeData.VoxelCamera.Camera : VoxelizationRuntimeData.CullingCamera.Camera;
|
|
|
|
var maximumLODLevelBackup = QualitySettings.maximumLODLevel;
|
|
var lodBiasBackup = QualitySettings.lodBias;
|
|
QualitySettings.SetLODSettings(1, HSettings.VoxelizationSettings.LODMax, false);
|
|
|
|
if (cullingCamera.TryGetCullingParameters(out ScriptableCullingParameters cullingParams))
|
|
{
|
|
cullingParams.cullingOptions = CullingOptions.None;
|
|
cullingParams.isOrthographic = true;
|
|
|
|
LODParameters lodParameters = cullingParams.lodParameters;
|
|
lodParameters.cameraPosition = cullingCamera.transform.position;
|
|
lodParameters.isOrthographic = true;
|
|
lodParameters.orthoSize = 0;
|
|
cullingParams.lodParameters = lodParameters;
|
|
cullingParams.cullingMask = (uint)voxelizationLayer.value;
|
|
|
|
var directionalLightCullResults = cullContextData.Cull(ref cullingParams);
|
|
var rendererListParameters = new RendererListParams(directionalLightCullResults, drawSettings, filterSettings);
|
|
passData.RendererListHandle = renderGraph.CreateRendererList(rendererListParameters);
|
|
builder.UseRendererList(passData.RendererListHandle);
|
|
}
|
|
|
|
QualitySettings.SetLODSettings(lodBiasBackup, maximumLODLevelBackup, false);
|
|
}
|
|
|
|
private static void ExecutePass(PassData data, UnsafeGraphContext rgContext)
|
|
{
|
|
var cmd = CommandBufferHelpers.GetNativeCommandBuffer(rgContext.cmd);
|
|
|
|
Camera camera = data.UniversalCameraData.camera;
|
|
int width = (int)(data.UniversalCameraData.camera.scaledPixelWidth * data.UniversalCameraData.renderScale);
|
|
int height = (int)(data.UniversalCameraData.camera.scaledPixelHeight * data.UniversalCameraData.renderScale);
|
|
|
|
switch (HSettings.VoxelizationSettings.VoxelizationUpdateMode)
|
|
{
|
|
case VoxelizationUpdateMode.Constant:
|
|
using (new HTraceProfilingScope(cmd, VoxelizationShared.s_VoxelizationConstantProfilingSampler))
|
|
VoxelizationConstant(cmd, camera, width, height, data);
|
|
break;
|
|
case VoxelizationUpdateMode.Partial:
|
|
using (new HTraceProfilingScope(cmd, VoxelizationShared.s_VoxelizationPartialProfilingSampler))
|
|
VoxelizationPartial(cmd, camera, width, height, data);
|
|
break;
|
|
}
|
|
|
|
VoxelizationShared.History.Update();
|
|
VoxelizationRuntimeData.FullVoxelization = false;
|
|
}
|
|
|
|
private static void VoxelizationConstant(CommandBuffer cmd, Camera camera, int cameraWidth, int cameraHeight, PassData data)
|
|
{
|
|
if (VoxelizationRuntimeData.VoxelCamera == null)
|
|
return;
|
|
|
|
// Clear 3D textures
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelData.rt, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 1, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 2, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 3, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 4, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 5, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionIntermediate.rt, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
|
|
|
|
// Pass voxel camera pos to shaders
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelCameraPos, VoxelizationRuntimeData.VoxelCamera.transform.position);
|
|
|
|
// Load our voxelization camera //
|
|
var voxelizationCamera = VoxelizationRuntimeData.VoxelCamera.Camera;
|
|
|
|
// Render voxels
|
|
if (true)
|
|
{
|
|
// Pass main voxelization parameters to shaders
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelResolution, (Vector3)HSettings.VoxelizationSettings.ExactData.Resolution);
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelBounds, HSettings.VoxelizationSettings.ExactData.Bounds);
|
|
cmd.SetGlobalFloat(VoxelizationShared.g_VoxelPerMeter, HSettings.VoxelizationSettings.ExactData.VoxelsPerMeter);
|
|
cmd.SetGlobalFloat(VoxelizationShared.g_VoxelSize, HSettings.VoxelizationSettings.ExactData.VoxelSize);
|
|
|
|
Vector3 BoundsSwizzled = new Vector3(HSettings.VoxelizationSettings.ExactData.Bounds.x, HSettings.VoxelizationSettings.ExactData.Bounds.z, HSettings.VoxelizationSettings.ExactData.Bounds.y);
|
|
Bounds voxelizationAABB = new Bounds(VoxelizationRuntimeData.VoxelCamera.transform.position, BoundsSwizzled);
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelizationAABB_Min, voxelizationAABB.min);
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelizationAABB_Max, voxelizationAABB.max);
|
|
|
|
if (voxelizationCamera.farClipPlane > 0) //always in constant
|
|
{
|
|
// Cache main camera matrices
|
|
var viewMatrixCached = camera.worldToCameraMatrix;
|
|
var projectionMatrixCached = camera.projectionMatrix;
|
|
|
|
// Set voxelization camera matrices
|
|
cmd.SetViewProjectionMatrices(voxelizationCamera.worldToCameraMatrix, voxelizationCamera.projectionMatrix);
|
|
|
|
// Set rendering targets
|
|
cmd.ClearRandomWriteTargets();
|
|
cmd.SetRandomWriteTarget(1, VoxelizationShared.VoxelData.rt);
|
|
cmd.SetRandomWriteTarget(2, VoxelizationShared.DummyVoxelBuffer, false);
|
|
|
|
Shader.EnableKeyword(VoxelizationShared.CONSTANT_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.PARTIAL_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.DYNAMIC_VOXELIZATION);
|
|
|
|
var maximumLODLevelBackup = QualitySettings.maximumLODLevel;
|
|
var lodBiasBackup = QualitySettings.lodBias;
|
|
QualitySettings.SetLODSettings(1, HSettings.VoxelizationSettings.LODMax, false);
|
|
|
|
// Render voxels
|
|
cmd.SetRenderTarget(VoxelizationShared.DummyVoxelizationTarget.rt, VoxelizationShared.DummyVoxelizationTarget.rt);
|
|
cmd.ClearRenderTarget(true, true, Color.black);
|
|
cmd.DrawRendererList(data.RendererListHandle);
|
|
|
|
QualitySettings.SetLODSettings(lodBiasBackup, maximumLODLevelBackup, false);
|
|
|
|
// Reset rendering targets
|
|
cmd.ClearRandomWriteTargets();
|
|
|
|
// Restore matrices and culling of the main camera
|
|
cmd.SetViewProjectionMatrices(viewMatrixCached, projectionMatrixCached);
|
|
}
|
|
}
|
|
|
|
// Generate mip pyramid for 3D position texture
|
|
using (new HTraceProfilingScope(cmd, VoxelizationShared.s_GeneratePositionPyramidProfilingSampler))
|
|
{
|
|
// Generate 0-2 mip levels
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared.g_VoxelData, VoxelizationShared.VoxelData.rt);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionPyramid_Mip0, VoxelizationShared.VoxelPositionPyramid.rt, 0);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionPyramid_Mip1, VoxelizationShared.VoxelPositionPyramid.rt, 1);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionPyramid_Mip2, VoxelizationShared.VoxelPositionPyramid.rt, 2);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionIntermediate_Output, VoxelizationShared.VoxelPositionIntermediate.rt);
|
|
cmd.DispatchCompute(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1,
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.x / 8f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.z / 8f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.y / 8f));
|
|
|
|
// Generate 3-5 mip levels
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionIntermediate, VoxelizationShared.VoxelPositionIntermediate.rt);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionPyramid_Mip3, VoxelizationShared.VoxelPositionPyramid.rt, 3);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionPyramid_Mip4, VoxelizationShared.VoxelPositionPyramid.rt, 4);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionPyramid_Mip5, VoxelizationShared.VoxelPositionPyramid.rt, 5);
|
|
cmd.DispatchCompute(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2,
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.x / 32f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.z / 32f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.y / 32f));
|
|
}
|
|
|
|
// Pass voxelized textures to shaders in the Main Pass
|
|
cmd.SetGlobalTexture(VoxelizationShared.g_VoxelPositionPyramid, VoxelizationShared.VoxelPositionPyramid.rt);
|
|
cmd.SetGlobalTexture(VoxelizationShared.g_VoxelData, VoxelizationShared.VoxelData.rt);
|
|
}
|
|
|
|
|
|
private static void VoxelizationPartial(CommandBuffer cmd, Camera camera, int cameraWidth, int cameraHeight, PassData data)
|
|
{
|
|
#if UNITY_EDITOR
|
|
if (UnityEditor.EditorApplication.isPaused) // This is required to avoid flickering in the Frame Debugger.
|
|
return;
|
|
#endif
|
|
if (VoxelizationRuntimeData.VoxelCamera == null)
|
|
return;
|
|
|
|
bool isFullVoxelization = VoxelizationRuntimeData.FullVoxelization;
|
|
bool isDynamicOctant = (int)VoxelizationRuntimeData.OctantIndex == 5 ? true : false;
|
|
bool isFirstOctant = (int)VoxelizationRuntimeData.OctantIndex == 1 ? true : false;
|
|
|
|
// Swap counter, flips at the start of every cycle
|
|
if (isFirstOctant && !isFullVoxelization)
|
|
VoxelizationRuntimeData.TextureSwapCounter++;
|
|
|
|
// Output counter, flips at the end of every cycle
|
|
if (isDynamicOctant && !isFullVoxelization)
|
|
{
|
|
VoxelizationRuntimeData.TextureOutputCounter = VoxelizationRuntimeData.TextureSwapCounter;
|
|
}
|
|
|
|
// Clear 3D textures
|
|
if (isDynamicOctant || isFullVoxelization)
|
|
{
|
|
HSettings.DebugSettings.TestCheckbox = false;
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 1, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 2, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 3, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 4, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionPyramid.rt, ClearFlag.Color, Color.clear, 5, CubemapFace.Unknown, -1);
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationShared.VoxelPositionIntermediate.rt, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
|
|
}
|
|
if (isFirstOctant || isFullVoxelization)
|
|
CoreUtils.SetRenderTarget(cmd, VoxelizationRuntimeData.TextureSwapCounter % 2 == 0 ? VoxelizationShared.VoxelData_B.rt : VoxelizationShared.VoxelData_A.rt, ClearFlag.Color, Color.clear, 0, CubemapFace.Unknown, -1);
|
|
|
|
// Pass voxel camera pos to shaders at the end of the cycle
|
|
if (isDynamicOctant || isFullVoxelization)
|
|
{
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelCameraPos, VoxelizationRuntimeData.VoxelCamera.transform.position);
|
|
}
|
|
|
|
// Pass actual voxel camera pos to voxelization shader for geometry trimming
|
|
if (isFirstOctant || isFullVoxelization)
|
|
{
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelCameraPosActual, VoxelizationRuntimeData.VoxelCamera.transform.position);
|
|
}
|
|
|
|
// Scroll voxels by copying them
|
|
using (new HTraceProfilingScope(cmd, VoxelizationShared.s_CopyVoxelsProfilingSampler))
|
|
{
|
|
if (!isDynamicOctant && !isFullVoxelization)
|
|
{
|
|
Vector3 octantCopyOffset = VoxelizationFunctionsShared.CalculateOctantOffsetsForCopyShader();
|
|
|
|
cmd.SetComputeVectorParam(VoxelizationShared.HVoxelization, VoxelizationShared._OctantCopyOffset, octantCopyOffset);
|
|
cmd.SetComputeVectorParam(VoxelizationShared.HVoxelization, VoxelizationShared._VoxelOffset, VoxelizationRuntimeData.VoxelCamera.transform.position - VoxelizationShared.History.VoxelCameraPosition);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.CopyData, VoxelizationShared._VoxelData_A, VoxelizationRuntimeData.TextureSwapCounter % 2 == 0 ? VoxelizationShared.VoxelData_B.rt : VoxelizationShared.VoxelData_A.rt);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.CopyData, VoxelizationShared._VoxelData_B, VoxelizationRuntimeData.TextureSwapCounter % 2 == 0 ? VoxelizationShared.VoxelData_A.rt : VoxelizationShared.VoxelData_B.rt);
|
|
cmd.DispatchCompute(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.CopyData,
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.x / 8f / 2),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.z / 4f / 2),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.y / 8f / 2));
|
|
}
|
|
}
|
|
|
|
// Render voxels
|
|
if (true)
|
|
{
|
|
Vector3 BoundsSwizzled = new Vector3(HSettings.VoxelizationSettings.ExactData.Bounds.x, HSettings.VoxelizationSettings.ExactData.Bounds.z, HSettings.VoxelizationSettings.ExactData.Bounds.y);
|
|
Bounds voxelizationAABB = new Bounds(VoxelizationRuntimeData.VoxelCamera.transform.position, BoundsSwizzled);
|
|
// Pass main voxelization parameters to shaders
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelResolution, (Vector3)HSettings.VoxelizationSettings.ExactData.Resolution);
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelBounds, HSettings.VoxelizationSettings.ExactData.Bounds);
|
|
cmd.SetGlobalFloat(VoxelizationShared.g_VoxelPerMeter, HSettings.VoxelizationSettings.ExactData.VoxelsPerMeter);
|
|
cmd.SetGlobalFloat(VoxelizationShared.g_VoxelSize, HSettings.VoxelizationSettings.ExactData.VoxelSize);
|
|
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelizationAABB_Min, voxelizationAABB.min);
|
|
cmd.SetGlobalVector(VoxelizationShared.g_VoxelizationAABB_Max, voxelizationAABB.max);
|
|
|
|
// Load our culling & voxelization camera
|
|
Camera cullingCamera = isFullVoxelization ? VoxelizationRuntimeData.VoxelCamera.Camera : VoxelizationRuntimeData.CullingCamera.Camera;
|
|
Camera voxelizationCamera = isFullVoxelization ? VoxelizationRuntimeData.VoxelCamera.Camera : VoxelizationRuntimeData.VoxelOctantCamera.Camera;
|
|
|
|
if (cullingCamera.farClipPlane > 0 && data.RendererListHandle.IsValid()) // always correct for Dynamic objects
|
|
{
|
|
// Cache main camera matrices
|
|
var viewMatrixCached = camera.worldToCameraMatrix;
|
|
var projectionMatrixCached = camera.projectionMatrix;
|
|
|
|
// Set voxelization camera matrices
|
|
cmd.SetViewProjectionMatrices(voxelizationCamera.worldToCameraMatrix, voxelizationCamera.projectionMatrix);
|
|
|
|
if ((int)VoxelizationRuntimeData.OctantIndex != 5)
|
|
VoxelizationFunctionsShared.CalculateOctantOffsets(cmd);
|
|
|
|
// Set rendering targets
|
|
cmd.ClearRandomWriteTargets();
|
|
cmd.SetRandomWriteTarget(1, VoxelizationRuntimeData.TextureSwapCounter % 2 == 0 ? VoxelizationShared.VoxelData_B.rt : VoxelizationShared.VoxelData_A.rt);
|
|
cmd.SetRandomWriteTarget(2, VoxelizationShared.DummyVoxelBuffer, false);
|
|
|
|
Shader.EnableKeyword(VoxelizationShared.PARTIAL_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.DYNAMIC_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.CONSTANT_VOXELIZATION);
|
|
|
|
var voxelizationRenderTarget = VoxelizationShared.DummyVoxelizationStaticTarget;
|
|
|
|
if (isFullVoxelization)
|
|
{
|
|
voxelizationRenderTarget = VoxelizationShared.DummyVoxelizationDynamicTarget;
|
|
Shader.EnableKeyword(VoxelizationShared.CONSTANT_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.PARTIAL_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.DYNAMIC_VOXELIZATION);
|
|
}
|
|
else if ((int)VoxelizationRuntimeData.OctantIndex == 5)
|
|
{
|
|
voxelizationRenderTarget = VoxelizationShared.DummyVoxelizationDynamicTarget;
|
|
Shader.EnableKeyword(VoxelizationShared.DYNAMIC_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.PARTIAL_VOXELIZATION);
|
|
Shader.DisableKeyword(VoxelizationShared.CONSTANT_VOXELIZATION);
|
|
}
|
|
|
|
var maximumLODLevelBackup = QualitySettings.maximumLODLevel;
|
|
var lodBiasBackup = QualitySettings.lodBias;
|
|
QualitySettings.SetLODSettings(1, HSettings.VoxelizationSettings.LODMax, false);
|
|
|
|
// Render voxels
|
|
cmd.SetRenderTarget(voxelizationRenderTarget.rt, voxelizationRenderTarget.rt);
|
|
cmd.ClearRenderTarget(true, true, Color.black);
|
|
cmd.DrawRendererList(data.RendererListHandle);
|
|
|
|
QualitySettings.SetLODSettings(lodBiasBackup, maximumLODLevelBackup, false);
|
|
|
|
// Reset rendering targets
|
|
cmd.ClearRandomWriteTargets();
|
|
|
|
// Restore matrices and culling of the main camera
|
|
cmd.SetViewProjectionMatrices(viewMatrixCached, projectionMatrixCached);
|
|
}
|
|
}
|
|
|
|
// Generate mip pyramid for 3D position texture
|
|
using (new HTraceProfilingScope(cmd, VoxelizationShared.s_GeneratePositionPyramidProfilingSampler))
|
|
{
|
|
if (isDynamicOctant || isFullVoxelization)
|
|
{
|
|
// Generate 0-2 mip levels
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared.g_VoxelData, VoxelizationRuntimeData.TextureSwapCounter % 2 == 0 ? VoxelizationShared.VoxelData_B.rt : VoxelizationShared.VoxelData_A.rt);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionPyramid_Mip0, VoxelizationShared.VoxelPositionPyramid.rt, 0);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionPyramid_Mip1, VoxelizationShared.VoxelPositionPyramid.rt, 1);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionPyramid_Mip2, VoxelizationShared.VoxelPositionPyramid.rt, 2);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1, VoxelizationShared._VoxelPositionIntermediate_Output, VoxelizationShared.VoxelPositionIntermediate.rt);
|
|
cmd.DispatchCompute(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid1,
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.x / 8f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.z / 8f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.y / 8f));
|
|
|
|
// Generate 3-5 mip levels
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionIntermediate, VoxelizationShared.VoxelPositionIntermediate.rt);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionPyramid_Mip3, VoxelizationShared.VoxelPositionPyramid.rt, 3);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionPyramid_Mip4, VoxelizationShared.VoxelPositionPyramid.rt, 4);
|
|
cmd.SetComputeTextureParam(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2, VoxelizationShared._VoxelPositionPyramid_Mip5, VoxelizationShared.VoxelPositionPyramid.rt, 5);
|
|
cmd.DispatchCompute(VoxelizationShared.HVoxelization, (int)VoxelizationShared.HVoxelizationKernel.GeneratePositionPyramid2,
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.x / 32f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.z / 32f),
|
|
Mathf.CeilToInt(HSettings.VoxelizationSettings.ExactData.Resolution.y / 32f));
|
|
}
|
|
}
|
|
|
|
if (isDynamicOctant || isFullVoxelization)
|
|
{
|
|
VoxelizationShared.History.VoxelCameraPosition = VoxelizationRuntimeData.VoxelCamera.transform.position;
|
|
}
|
|
|
|
// Pass voxelized textures to shaders in the Main Pass
|
|
cmd.SetGlobalTexture(VoxelizationShared.g_VoxelPositionPyramid, VoxelizationShared.VoxelPositionPyramid.rt);
|
|
cmd.SetGlobalTexture(VoxelizationShared.g_VoxelData, VoxelizationRuntimeData.TextureOutputCounter % 2 == 0 ? VoxelizationShared.VoxelData_B.rt : VoxelizationShared.VoxelData_A.rt);
|
|
|
|
// Copy to the opposite data buffer to make sure we have full voxelization in both of them
|
|
if (isFullVoxelization)
|
|
{
|
|
cmd.CopyTexture(VoxelizationRuntimeData.TextureSwapCounter % 2 == 0 ? VoxelizationShared.VoxelData_B.rt : VoxelizationShared.VoxelData_A.rt, VoxelizationRuntimeData.TextureSwapCounter % 2 == 0 ? VoxelizationShared.VoxelData_A.rt : VoxelizationShared.VoxelData_B.rt);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endregion --------------------------- Render Graph ---------------------------
|
|
|
|
#region --------------------------- Shared ---------------------------
|
|
|
|
|
|
protected internal void Dispose()
|
|
{
|
|
VoxelizationShared.DummyVoxelBuffer.HRelease();
|
|
VoxelizationShared.DummyVoxelBuffer = null;
|
|
|
|
VoxelizationShared.DummyVoxelizationTarget.HRelease();
|
|
VoxelizationShared.VoxelPositionPyramid.HRelease();
|
|
VoxelizationShared.VoxelPositionIntermediate.HRelease();
|
|
VoxelizationShared.VoxelData.HRelease();
|
|
VoxelizationShared.DummyVoxelizationStaticTarget.HRelease();
|
|
VoxelizationShared.DummyVoxelizationDynamicTarget.HRelease();
|
|
VoxelizationShared.VoxelData_A.HRelease();
|
|
VoxelizationShared.VoxelData_B.HRelease();
|
|
|
|
|
|
}
|
|
|
|
#endregion --------------------------- Shared ---------------------------
|
|
}
|
|
}
|