//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 ---------------------------
	}
}