using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Entities;
using Unity.Jobs;
using UnityEngine;
using Rukhanka.Toolbox;
using Unity.Assertions;
using Unity.Rendering;
using Unity.Transforms;
using Hash128 = Unity.Entities.Hash128;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Rukhanka
{

[UpdateInGroup(typeof(RukhankaDeformationSystemGroup))]
[UpdateAfter(typeof(SkinnedMeshPreparationSystem))]
[UpdateBefore(typeof(MeshDeformationSystem))]
public partial class GPUAnimationSystem: SystemBase
{
	ComputeShader animationEngineCS;
	//	Buffers for persistent GPU data. Equivalent for blob asset store
	GraphicsBuffer animationClipsGB;
	GraphicsBuffer avatarMasksGB;
	GraphicsBuffer rigDefinitionGB;
	GraphicsBuffer rigHumanAvatarRotationDataGB;
	GraphicsBuffer rigBonesGB;
	GraphicsBuffer skinnedMeshBoneDataGB;
	
	SparseUploaderPool sparseUploaderPool;
	
	//	Buffers for per frame animation data (workload, animation to process). Equivalent for animation components 
	FrameFencedGPUBufferPool<GPUStructures.AnimationToProcess> frameAnimationToProcessGB;
	FrameFencedGPUBufferPool<GPUStructures.AnimatedBoneWorkload> framePerBoneAnimationWorkloadGB;
	FrameFencedGPUBufferPool<GPUStructures.AnimationJob> frameRigAnimationJobsGB;
	FrameFencedGPUBufferPool<GPUStructures.SkinnedMeshWorkload> frameSkinMatrixWorkloadGB;
	
	//	Buffers filled by compute shaders
	GraphicsBuffer animatedBonesGB;
	GraphicsBuffer rigSpaceAnimatedBonesGB;
	
	ComputeKernel processAnimationKernel;
	ComputeKernel makeRigSpaceBoneTransformsKernel;
	ComputeKernel makeSkinMatricesKernel;
	ComputeKernel copyBufferKernel;
	ComputeKernel copyMeshDataKernel;
	
	NativeParallelHashMap<Hash128, BlobAssetReference<BoneRemapTableBlob>> skinnedMeshToRigBoneRemapTables;
	EntityQuery gpuAnimatedRigQuery, gpuAnimatedRigNoChunkComponentsQuery, smrQuery;
	
#if RUKHANKA_DEBUG_INFO
	BoneVisualizationSystem boneVisualizationSystem;
#endif
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	protected override void OnCreate()
	{
		if (!SystemInfo.supportsComputeShaders)
		{
			Debug.LogWarning("Compute shaders is not supported on current platform. GPU animation engine is disabled.");
			Enabled = false;
			return;
		}
		
#if !HYBRID_RENDERER_DISABLED
        if (!EntitiesGraphicsUtils.IsEntitiesGraphicsSupportedOnSystem())
#endif
		{
			Enabled = false;
			return;
		}
		
		skinnedMeshToRigBoneRemapTables = new (0xff, Allocator.Persistent);
		
		CreateComputeBuffers();
		
		animationEngineCS = Resources.Load<ComputeShader>("GPUAnimationEngine");
		processAnimationKernel = new ComputeKernel(animationEngineCS, "ProcessAnimations");
		makeRigSpaceBoneTransformsKernel = new ComputeKernel(animationEngineCS, "MakeRigSpaceBoneTransforms");
		makeSkinMatricesKernel = new ComputeKernel(animationEngineCS, "ComputeSkinMatrices");
		
		gpuAnimatedRigQuery = new EntityQueryBuilder(Allocator.Temp)
			.WithAll<RigDefinitionComponent, AnimationToProcessComponent, GPUAnimationEngineTag>()
			.WithAllChunkComponent<GPURigFrameOffsetsComponent>()
			.WithNone<CullAnimationsTag>()
			.Build(EntityManager);
		
		gpuAnimatedRigNoChunkComponentsQuery = new EntityQueryBuilder(Allocator.Temp)
			.WithAll<RigDefinitionComponent, AnimationToProcessComponent, GPUAnimationEngineTag>()
			.WithNoneChunkComponent<GPURigFrameOffsetsComponent>()
			.WithNone<CullAnimationsTag>()
			.Build(EntityManager);
		
		smrQuery = new EntityQueryBuilder(Allocator.Temp)
			.WithAll<SkinnedMeshRendererComponent, LocalToWorld>()
			.Build(EntityManager);
		
		Assert.IsTrue(UnsafeUtility.SizeOf<GPUStructures.KeyFrame>() == UnsafeUtility.SizeOf<KeyFrame>());
	}
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	protected override void OnUpdate()
	{
		ref var runtimeAnimationData = ref SystemAPI.GetSingletonRW<GPURuntimeAnimationData>().ValueRW;
		
		EntityManager.AddChunkComponentData<GPURigFrameOffsetsComponent>(gpuAnimatedRigNoChunkComponentsQuery, default);
		
		PrepareFrameAnimationData(ref runtimeAnimationData, Dependency);
		DispatchAnimationCalculation(ref runtimeAnimationData);
		SetBuffersForBoneRenderer(ref runtimeAnimationData);
		GPUBuffersEndFrame();
		sparseUploaderPool.FrameCleanup();
	}
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	protected override void OnDestroy()
	{
		animationClipsGB?.Release();
		avatarMasksGB?.Release();
		rigDefinitionGB?.Release();
		rigHumanAvatarRotationDataGB?.Release();
		rigBonesGB?.Release();
		skinnedMeshBoneDataGB?.Release();
		
		sparseUploaderPool?.Dispose();
		
		frameAnimationToProcessGB?.Dispose();
		framePerBoneAnimationWorkloadGB?.Dispose();
		frameRigAnimationJobsGB?.Dispose();
		frameSkinMatrixWorkloadGB?.Dispose();	
		
		animatedBonesGB?.Dispose();
		rigSpaceAnimatedBonesGB?.Dispose();
		
		if (skinnedMeshToRigBoneRemapTables.IsCreated)
		{
			foreach (var remapTable in skinnedMeshToRigBoneRemapTables)
			{
				remapTable.Value.Dispose();
			}
		}
		skinnedMeshToRigBoneRemapTables.Dispose();
	}
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void CreateComputeBuffers()
	{
		var bufferInitialCapacity = 0x4;
		frameAnimationToProcessGB = new (bufferInitialCapacity, GraphicsBuffer.Target.Structured, GraphicsBuffer.UsageFlags.LockBufferForWrite);
		framePerBoneAnimationWorkloadGB = new (bufferInitialCapacity, GraphicsBuffer.Target.Structured, GraphicsBuffer.UsageFlags.LockBufferForWrite);
		frameRigAnimationJobsGB = new (bufferInitialCapacity, GraphicsBuffer.Target.Structured, GraphicsBuffer.UsageFlags.LockBufferForWrite);
		frameSkinMatrixWorkloadGB = new (bufferInitialCapacity, GraphicsBuffer.Target.Structured, GraphicsBuffer.UsageFlags.LockBufferForWrite);
		
		animatedBonesGB = new (GraphicsBuffer.Target.Structured, GraphicsBuffer.UsageFlags.None, bufferInitialCapacity, UnsafeUtility.SizeOf<GPUStructures.BoneTransform>());
		rigSpaceAnimatedBonesGB = new (GraphicsBuffer.Target.Structured, GraphicsBuffer.UsageFlags.None, bufferInitialCapacity, UnsafeUtility.SizeOf<GPUStructures.BoneTransform>());
		
		//	Persistent data buffers
		var persistentBuffersInitialCapacity = 0x4;
		animationClipsGB = new GraphicsBuffer(GraphicsBuffer.Target.Raw, GraphicsBuffer.UsageFlags.None, persistentBuffersInitialCapacity, UnsafeUtility.SizeOf<uint>());
		avatarMasksGB = new GraphicsBuffer(GraphicsBuffer.Target.Raw, GraphicsBuffer.UsageFlags.None, persistentBuffersInitialCapacity, UnsafeUtility.SizeOf<uint>());
		rigDefinitionGB = new GraphicsBuffer(GraphicsBuffer.Target.Raw, GraphicsBuffer.UsageFlags.None, persistentBuffersInitialCapacity, UnsafeUtility.SizeOf<GPUStructures.RigDefinition>());
		rigHumanAvatarRotationDataGB = new GraphicsBuffer(GraphicsBuffer.Target.Raw, GraphicsBuffer.UsageFlags.None, persistentBuffersInitialCapacity, UnsafeUtility.SizeOf<GPUStructures.HumanRotationData>());
		rigBonesGB = new GraphicsBuffer(GraphicsBuffer.Target.Raw, GraphicsBuffer.UsageFlags.None, persistentBuffersInitialCapacity, UnsafeUtility.SizeOf<GPUStructures.RigBone>());
		skinnedMeshBoneDataGB = new GraphicsBuffer(GraphicsBuffer.Target.Raw, GraphicsBuffer.UsageFlags.None, persistentBuffersInitialCapacity, UnsafeUtility.SizeOf<GPUStructures.SkinnedMeshBoneData>());
		
		sparseUploaderPool = new SparseUploaderPool();
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	unsafe JobHandle CalculateFrameWorksetData(ref GPURuntimeAnimationData rad, JobHandle dependsOn)
	{
		//	All following jobs should be sequential. Interlocked math for a few counters are significantly slower than
		//	sequential execution
		
		var gpuRigFrameOffsetsTypeHandle = SystemAPI.GetComponentTypeHandle<GPURigFrameOffsetsComponent>();
		var rigDefTypeHandle = SystemAPI.GetComponentTypeHandle<RigDefinitionComponent>(true);
		var atpBufHandle = SystemAPI.GetBufferTypeHandle<AnimationToProcessComponent>(true);
		
		//	Workload sizes for animation calculation per chunk
		var computeRigsWorkloadSizesJob = new ComputeFrameRigWorkloadSizesPerChunkJob()
		{
			frameOffsetsTypeHandle = gpuRigFrameOffsetsTypeHandle,
			atpBufTypeHandle = atpBufHandle,
			rigDefComponentTypeHandle = rigDefTypeHandle,
		};
		var computeRigsWorkloadSizesJH = computeRigsWorkloadSizesJob.ScheduleParallel(gpuAnimatedRigQuery, dependsOn);
		
		//	Make absolute chunk offsets
		var computeAbsChunkOffsetsJob = new ComputeFrameRigWorkloadSizesAbsChunkOffsetsJob()
		{
			frameAnimatedBonesCounter = (uint*)UnsafeUtility.AddressOf(ref rad.frameAnimatedBonesCounter),
			frameAnimatedRigsCounter = (uint*)UnsafeUtility.AddressOf(ref rad.frameAnimatedRigsCounter),
			frameAnimationToProcessCounter = (uint*)UnsafeUtility.AddressOf(ref rad.frameAnimationToProcessCounter),
			gpuRigChunkDataTypeHandle = gpuRigFrameOffsetsTypeHandle
		};
		var computeAbsChunkOffsetsJH = computeAbsChunkOffsetsJob.Schedule(gpuAnimatedRigQuery, computeRigsWorkloadSizesJH);
		
		//	Workload sizes for skin matrices calculation
		//	To avoid InterlockedAdd (it is slow when invocation count is really big), and single thread job I use 2-step
		//	process here: first job increments per-thread counters, and another single thread job do final accumulate.
		var computeSkinnedMeshCountJob = new ComputeFrameSkinnedMeshWorkloadSizesJob()
		{
			frameSkinnedMeshesPerThreadCounters = rad.frameSkinnedMeshesPerThreadCounters,
			gpuAnimationEngineTagLookup = SystemAPI.GetComponentLookup<GPUAnimationEngineTag>(true)
		};
		var computeSkinnedMeshCountTotalJob = new ComputeFrameSkinnedMeshWorkloadSizesTotalJob()
		{
			frameSkinnedMeshesPerThreadCounters = rad.frameSkinnedMeshesPerThreadCounters,
			frameSkinnedMeshesCounter =  (uint*)UnsafeUtility.AddressOf(ref rad.frameSkinnedMeshesCounter)
		};
		
		var computeSkinnedMeshCountJH = computeSkinnedMeshCountJob.ScheduleParallel(dependsOn);
		var computeSkinnedMeshCountTotalJH = computeSkinnedMeshCountTotalJob.Schedule(computeSkinnedMeshCountJH);
		
		var rv = JobHandle.CombineDependencies(computeAbsChunkOffsetsJH, computeSkinnedMeshCountTotalJH);
		return rv;
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void GPUBuffersBeginFrame()
	{
		frameAnimationToProcessGB.BeginFrame();
		framePerBoneAnimationWorkloadGB.BeginFrame();
		frameRigAnimationJobsGB.BeginFrame();
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void GPUBuffersEndFrame()
	{
		frameAnimationToProcessGB.EndFrame();
		framePerBoneAnimationWorkloadGB.EndFrame();
		frameRigAnimationJobsGB.EndFrame();
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	unsafe void FillFrameSkinMatrixCalculationWorkloadGPUBuffers
	(
		ref GPURuntimeAnimationData rad,
		in NativeParallelHashMap<Entity, SkinnedMeshRendererFrameDeformationData> entityToSMRFrameDataMap
	)
	{
		var frameSkinMatrixWorkloadBuf = frameSkinMatrixWorkloadGB.LockBufferForWrite(0, (int)rad.frameSkinnedMeshesCounter);
		rad.frameSkinnedMeshesCounter = 0;
		var frameSkinnedMeshesAtomicCounter = new UnsafeAtomicCounter32(UnsafeUtility.AddressOf(ref rad.frameSkinnedMeshesCounter));
		
		var fillFrameSkinMatrixWorkloadBuffersJob = new FillFrameSkinMatrixWorkloadBuffersJob()
		{
			frameSkinnedMeshesAtomicCounter = frameSkinnedMeshesAtomicCounter,
			frameSkinMatrixWorkloadBuf = frameSkinMatrixWorkloadBuf,
			skinnedMeshDataMap = rad.skinnedMeshesDataMap,
			rigDefLookup = SystemAPI.GetComponentLookup<RigDefinitionComponent>(true),
			gpuAnimationEngineTagLookup = SystemAPI.GetComponentLookup<GPUAnimationEngineTag>(true),
			localToWorldLookup = SystemAPI.GetComponentLookup<LocalToWorld>(true),
			entityToSMRFrameDataMap = entityToSMRFrameDataMap,
			gpuRigChunkDataTypeHandle = SystemAPI.GetComponentTypeHandle<GPURigFrameOffsetsComponent>(true),
			smrTypeHandle = SystemAPI.GetComponentTypeHandle<SkinnedMeshRendererComponent>(true),
			l2wTypeHandle = SystemAPI.GetComponentTypeHandle<LocalToWorld>(true),
			entityTypeHandle = SystemAPI.GetEntityTypeHandle(),
			frameOffsetsLookup = SystemAPI.GetComponentLookup<GPURigFrameOffsetsComponent>(true)
		};
		fillFrameSkinMatrixWorkloadBuffersJob.ScheduleParallel(smrQuery, default).Complete();
		
		frameSkinMatrixWorkloadGB.UnlockBufferAfterWrite((int)rad.frameSkinnedMeshesCounter);
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void FillFrameAnimationCalculationWorkloadGPUBuffers(ref GPURuntimeAnimationData rad)
	{
		var animatedBonesWorkloadBuf = framePerBoneAnimationWorkloadGB.LockBufferForWrite(0, (int)rad.frameAnimatedBonesCounter);
		var animationToProcessBuf = frameAnimationToProcessGB.LockBufferForWrite(0, (int)rad.frameAnimationToProcessCounter);
		var rigAnimationJobsBuf = frameRigAnimationJobsGB.LockBufferForWrite(0, (int)rad.frameAnimatedRigsCounter);
		
		//	Fill GPU buffer data for current frame animation calculation
		var fillFrameAnimatedRigWorkloadDataJob = new FillFrameAnimatedRigWorkloadBuffersJob()
		{
			animatedBonesWorkloadBuf = animatedBonesWorkloadBuf,
			animationToProcessBuf = animationToProcessBuf,
			frameRigAnimationJobs = rigAnimationJobsBuf,
			animationClipsOffsets = rad.animationClipsMap,
			rigDefinitionOffsets = rad.rigDefinitionsMap,
			avatarMasksOffsets = rad.avatarMasksDataMap,
			frameOffsetsTypeHandle = SystemAPI.GetComponentTypeHandle<GPURigFrameOffsetsComponent>(true),
			atpBufTypeHandle = SystemAPI.GetBufferTypeHandle<AnimationToProcessComponent>(true),
			rigDefComponentTypeHandle = SystemAPI.GetComponentTypeHandle<RigDefinitionComponent>(true),
			entityTypeHandle = SystemAPI.GetEntityTypeHandle()
		};
		fillFrameAnimatedRigWorkloadDataJob.ScheduleParallel(gpuAnimatedRigQuery, new JobHandle()).Complete();
		
		framePerBoneAnimationWorkloadGB.UnlockBufferAfterWrite((int)rad.frameAnimatedBonesCounter);
		frameAnimationToProcessGB.UnlockBufferAfterWrite((int)rad.frameAnimationToProcessCounter);
		frameRigAnimationJobsGB.UnlockBufferAfterWrite((int)rad.frameAnimatedRigsCounter);
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	unsafe JobHandle ResetFrameData(ref GPURuntimeAnimationData rad, JobHandle dependsOn)
	{
		var resetFrameDataJob = new ResetFrameDataJob()
		{
			frameAnimatedBonesCounter = new UnsafeAtomicCounter32(UnsafeUtility.AddressOf(ref rad.frameAnimatedBonesCounter)),
			frameAnimatedRigsCounter = new UnsafeAtomicCounter32(UnsafeUtility.AddressOf(ref rad.frameAnimatedRigsCounter)),
			frameSkinnedMeshesCounter = new UnsafeAtomicCounter32(UnsafeUtility.AddressOf(ref rad.frameSkinnedMeshesCounter)),
			frameAnimationToProcessCounter = new UnsafeAtomicCounter32(UnsafeUtility.AddressOf(ref rad.frameAnimationToProcessCounter)),
			frameSkinnedMeshesPerThreadCounters = rad.frameSkinnedMeshesPerThreadCounters
		};
		var rv = resetFrameDataJob.Schedule(dependsOn);
		return rv;
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void PrepareFrameAnimationData(ref GPURuntimeAnimationData runtimeAnimationData, JobHandle dependsOn)
	{
		var resetFrameDataJH = ResetFrameData(ref runtimeAnimationData, dependsOn);
		var calculateFrameWorksetDataJH = CalculateFrameWorksetData(ref runtimeAnimationData, resetFrameDataJH);
		
		//	Complete dependency because need to resize GPU buffers with actualized frame counts
		calculateFrameWorksetDataJH.Complete();
		
		ResizeGPUBuffers(ref runtimeAnimationData);
		CopyPersistentAnimationDataToGPUBuffers(ref runtimeAnimationData);
		GPUBuffersBeginFrame();
		FillFrameAnimationCalculationWorkloadGPUBuffers(ref runtimeAnimationData);
	}
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void CopyPersistentAnimationDataToGPUBuffers(ref GPURuntimeAnimationData rad)
	{
		CopyNewAnimationsToGPUBuffers(ref rad);	
		CopyNewRigsToGPUBuffer(ref rad);
		CopyNewBoneRemapTablesToGPUBuffers(ref rad);
		CopyNewAvatarMasksToGPUBuffer(ref rad);
		//DebugBufRead(ref rad);
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	GraphicsBuffer GrowPersistentDataComputeBuffer(GraphicsBuffer gb, uint newElementCount)
	{
		if (gb == null || gb.count >= newElementCount)
			return gb;
	
		var newBuf = new GraphicsBuffer(gb.target, gb.usageFlags, (int)newElementCount, gb.stride);
		ComputeBufferTools.Copy(gb, newBuf, 0, 0, (uint)(newElementCount * gb.stride));
		gb.Dispose();
		return newBuf;
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void ResizeGPUBuffers(ref GPURuntimeAnimationData rad)
	{
		//	Persistent data buffers
		animationClipsGB = GrowPersistentDataComputeBuffer(animationClipsGB, rad.totalGPUAnimationClipsSize.x / 4);
		avatarMasksGB = GrowPersistentDataComputeBuffer(avatarMasksGB, rad.totalGPUAvatarMasksDataCount.x);
		rigDefinitionGB = GrowPersistentDataComputeBuffer(rigDefinitionGB, rad.totalGPURigsCount.x);
		rigHumanAvatarRotationDataGB = GrowPersistentDataComputeBuffer(rigHumanAvatarRotationDataGB, rad.totalGPUHumanRotationDataEntriesCount.x);
		rigBonesGB = GrowPersistentDataComputeBuffer(rigBonesGB, rad.totalGPURigBonesCount.x);
		skinnedMeshBoneDataGB = GrowPersistentDataComputeBuffer(skinnedMeshBoneDataGB, rad.totalGPUSkinnedMeshBonesCount.x);
		
		//	Everyframe updated buffers
		frameAnimationToProcessGB.Grow((int)rad.frameAnimationToProcessCounter);
		framePerBoneAnimationWorkloadGB.Grow((int)rad.frameAnimatedBonesCounter);
		frameRigAnimationJobsGB.Grow((int)rad.frameAnimatedRigsCounter);
		frameSkinMatrixWorkloadGB.Grow((int)rad.frameSkinnedMeshesCounter);
		
		animatedBonesGB = ComputeBufferTools.GrowNoCopy(animatedBonesGB, (int)rad.frameAnimatedBonesCounter);
		rigSpaceAnimatedBonesGB = ComputeBufferTools.GrowNoCopy(rigSpaceAnimatedBonesGB, (int)rad.frameAnimatedBonesCounter);
		Shader.SetGlobalBuffer(ShaderID_rigSpaceBoneTransformsBuf, rigSpaceAnimatedBonesGB);
		Shader.SetGlobalBuffer(ShaderID_boneLocalTransforms, animatedBonesGB);
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void CopyNewBoneRemapTablesToGPUBuffers(ref GPURuntimeAnimationData rad)
	{
		if (rad.newSkinnedMeshesDataList.IsEmpty)
			return;
				
		var newSkinnedMeshBonesCount = (int)(rad.totalGPUSkinnedMeshBonesCount.x - rad.totalGPUSkinnedMeshBonesCount.y);
		
		var skinnedMeshBonesUploader = sparseUploaderPool.GetUploader(skinnedMeshBoneDataGB);
		var skinnedMeshBonesUploadSizeInBytes = newSkinnedMeshBonesCount * UnsafeUtility.SizeOf<GPUStructures.SkinnedMeshBoneData>();
		var skinnedMeshBonesThreadedUploader = skinnedMeshBonesUploader.Begin(skinnedMeshBonesUploadSizeInBytes, skinnedMeshBonesUploadSizeInBytes, newSkinnedMeshBonesCount);
		
		var copyNewBoneRemapTables = new CopyNewSkinnedMeshesDataJob()
		{
			newSkinnedMeshData = rad.newSkinnedMeshesDataList,
			gpuSkinnedMeshBonesData = skinnedMeshBonesThreadedUploader,
		};
			
		copyNewBoneRemapTables.ScheduleParallel(rad.newSkinnedMeshesDataList.Length, 1, default).Complete();
		
		skinnedMeshBonesUploader.EndAndCommit(skinnedMeshBonesThreadedUploader);
		sparseUploaderPool.PutUploader(skinnedMeshBonesUploader);
	}
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void CopyNewAvatarMasksToGPUBuffer(ref GPURuntimeAnimationData rad)
	{
		if (rad.newAvatarMasksList.IsEmpty)
			return;
		
		var newAvatarMasksEntriesCount = (int)(rad.totalGPUAvatarMasksDataCount.x - rad.totalGPUAvatarMasksDataCount.y);
		
		var avatarMaskUploader = sparseUploaderPool.GetUploader(avatarMasksGB);
		var avatarMaskUploadSizeInBytes = newAvatarMasksEntriesCount * UnsafeUtility.SizeOf<uint>();
		var avatarMaskThreadedUploader = avatarMaskUploader.Begin(avatarMaskUploadSizeInBytes, avatarMaskUploadSizeInBytes, newAvatarMasksEntriesCount);
		
		var copyNewAvatarMasksToGPUJob = new CopyNewAvatarMasksToGPUJob()
		{
			gpuAvatarMasks = avatarMaskThreadedUploader,
			newAvatarMasks = rad.newAvatarMasksList
		};
			
		copyNewAvatarMasksToGPUJob.ScheduleParallel(rad.newAvatarMasksList.Length, 1, default).Complete();
		
		avatarMaskUploader.EndAndCommit(avatarMaskThreadedUploader);
		sparseUploaderPool.PutUploader(avatarMaskUploader);
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void CopyNewRigsToGPUBuffer(ref GPURuntimeAnimationData rad)
	{
		if (rad.newRigsList.IsEmpty)
			return;
		
		var newRigBonesCount = (int)(rad.totalGPURigBonesCount.x - rad.totalGPURigBonesCount.y);
		var newRigsCount = (int)(rad.totalGPURigsCount.x - rad.totalGPURigsCount.y);
		var newHumanRotationDataEntriesCount = (int)(rad.totalGPUHumanRotationDataEntriesCount.x - rad.totalGPUHumanRotationDataEntriesCount.y);
		
		var rigBonesUploader = sparseUploaderPool.GetUploader(rigBonesGB);
		var rigBonesUploadSizeInBytes = newRigBonesCount * UnsafeUtility.SizeOf<GPUStructures.RigBone>();
		var rigBonesThreadedUploader = rigBonesUploader.Begin(rigBonesUploadSizeInBytes, rigBonesUploadSizeInBytes, newRigBonesCount);
		
		var rigDefinitionUploader = sparseUploaderPool.GetUploader(rigDefinitionGB);
		var rigDefinitionsUploadSizeInBytes = newRigsCount * UnsafeUtility.SizeOf<GPUStructures.RigDefinition>();
		var rigDefinitionsThreadedUploader = rigDefinitionUploader.Begin(rigDefinitionsUploadSizeInBytes, rigDefinitionsUploadSizeInBytes, newRigsCount);
		
		var rigHumanRotationDataUploader = sparseUploaderPool.GetUploader(rigHumanAvatarRotationDataGB);
		var rigHumanRotationDataUploadSizeInBytes = newHumanRotationDataEntriesCount * UnsafeUtility.SizeOf<GPUStructures.HumanRotationData>();
		var rigHumanRotationDataThreadedUploader = rigHumanRotationDataUploader.Begin(rigHumanRotationDataUploadSizeInBytes, rigHumanRotationDataUploadSizeInBytes, newRigsCount);
		
		var copyNewRigsToGPUJob = new CopyNewRigsToGPUJob()
		{
			newRigs = rad.newRigsList,
			gpuRigBones = rigBonesThreadedUploader,
			gpuRigDefs = rigDefinitionsThreadedUploader,
			gpuHumanRotationData = rigHumanRotationDataThreadedUploader
		};
			
		copyNewRigsToGPUJob.ScheduleParallel(rad.newRigsList.Length, 1, default).Complete();
		
		rigDefinitionUploader.EndAndCommit(rigDefinitionsThreadedUploader);
		rigBonesUploader.EndAndCommit(rigBonesThreadedUploader);
		rigHumanRotationDataUploader.EndAndCommit(rigHumanRotationDataThreadedUploader);
		
		sparseUploaderPool.PutUploader(rigDefinitionUploader);
		sparseUploaderPool.PutUploader(rigBonesUploader);
		sparseUploaderPool.PutUploader(rigHumanRotationDataUploader);
	}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void CopyNewAnimationsToGPUBuffers(ref GPURuntimeAnimationData rad)
	{
		if (rad.newAnimationsList.IsEmpty)
			return;
		
		var newAnimationClipsCount = rad.newAnimationsList.Length;
		//	Very conservative value
		var maxNumUploadsPerClip = 0xf;
		
		var animationClipsUploader = sparseUploaderPool.GetUploader(animationClipsGB);
		var maxAnimationClipSingleUploadSize = rad.totalGPUAnimationClipsSize.x - rad.totalGPUAnimationClipsSize.y;
		var animationClipsThreadedUploader = animationClipsUploader.Begin((int)maxAnimationClipSingleUploadSize, (int)maxAnimationClipSingleUploadSize, newAnimationClipsCount * maxNumUploadsPerClip);
		
		var createGPUAnimationClip = new CopyNewAnimationsToGPUJob()
		{
			newAnimationClips = rad.newAnimationsList,
			gpuAnimationClips = animationClipsThreadedUploader,
		};
		
		createGPUAnimationClip.ScheduleParallel(rad.newAnimationsList.Length, 1, default).Complete();
		
		animationClipsUploader.EndAndCommit(animationClipsThreadedUploader);
		sparseUploaderPool.PutUploader(animationClipsUploader);
	}
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	internal void BuildSkinMatrices(in NativeParallelHashMap<Entity, SkinnedMeshRendererFrameDeformationData> entityToSMRFrameDataMap, FrameFencedGPUBufferPool<SkinMatrix> outSkinMatrixGB)
	{
		if (!SystemAPI.TryGetSingletonRW<GPURuntimeAnimationData>(out var radRW))
			return;
		
		ref var runtimeAnimationData = ref radRW.ValueRW;
		
		frameSkinMatrixWorkloadGB.BeginFrame();
		
		FillFrameSkinMatrixCalculationWorkloadGPUBuffers(ref runtimeAnimationData, entityToSMRFrameDataMap);
		
		if (runtimeAnimationData.frameSkinnedMeshesCounter > 0)
		{
			animationEngineCS.SetBuffer(makeSkinMatricesKernel, ShaderID_skinMatrixWorkloadBuf, frameSkinMatrixWorkloadGB);
			animationEngineCS.SetBuffer(makeSkinMatricesKernel, ShaderID_rigSpaceBoneTransformsBuf, rigSpaceAnimatedBonesGB);
			animationEngineCS.SetBuffer(makeSkinMatricesKernel, ShaderID_outSkinMatrices, outSkinMatrixGB);
			animationEngineCS.SetBuffer(makeSkinMatricesKernel, ShaderID_skinnedMeshBoneData, skinnedMeshBoneDataGB);
			animationEngineCS.SetInt(ShaderID_totalSkinnedMeshes, (int)runtimeAnimationData.frameSkinnedMeshesCounter);
				
			makeSkinMatricesKernel.Dispatch(runtimeAnimationData.frameSkinnedMeshesCounter, 1, 1);
		}
		
		frameSkinMatrixWorkloadGB.EndFrame();
	}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void DispatchAnimationCalculation(ref GPURuntimeAnimationData rad)
	{
		if (rad.frameAnimatedBonesCounter == 0)
			return;
		
		//	Animation computation
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_outAnimatedBones, animatedBonesGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_animatedBoneWorkload, framePerBoneAnimationWorkloadGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_animationJobs, frameRigAnimationJobsGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_animationsToProcess, frameAnimationToProcessGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_rigDefinitions, rigDefinitionGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_rigBones, rigBonesGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_animationClips, animationClipsGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_humanRotationDataBuffer, rigHumanAvatarRotationDataGB);
		animationEngineCS.SetBuffer(processAnimationKernel, ShaderID_avatarMasksBuffer, avatarMasksGB);
		animationEngineCS.SetInt(ShaderID_animatedBonesCount, (int)rad.frameAnimatedBonesCounter);
		
		processAnimationKernel.Dispatch(rad.frameAnimatedBonesCounter, 1, 1);
		
		//	Compute rig space bone transforms
		animationEngineCS.SetBuffer(makeRigSpaceBoneTransformsKernel, ShaderID_boneLocalTransforms, animatedBonesGB);
		animationEngineCS.SetBuffer(makeRigSpaceBoneTransformsKernel, ShaderID_animatedBoneWorkload, framePerBoneAnimationWorkloadGB);
		animationEngineCS.SetBuffer(makeRigSpaceBoneTransformsKernel, ShaderID_animationJobs, frameRigAnimationJobsGB);
		animationEngineCS.SetBuffer(makeRigSpaceBoneTransformsKernel, ShaderID_rigDefinitions, rigDefinitionGB);
		animationEngineCS.SetBuffer(makeRigSpaceBoneTransformsKernel, ShaderID_rigBones, rigBonesGB);
		animationEngineCS.SetBuffer(makeRigSpaceBoneTransformsKernel, ShaderID_outBoneTransforms, rigSpaceAnimatedBonesGB);
		makeRigSpaceBoneTransformsKernel.Dispatch(rad.frameAnimatedBonesCounter, 1, 1);
	}
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	void SetBuffersForBoneRenderer(ref GPURuntimeAnimationData rad)
	{
	#if RUKHANKA_DEBUG_INFO
		boneVisualizationSystem	??= World.GetExistingSystemManaged<BoneVisualizationSystem>();
		boneVisualizationSystem.gpuBoneRenderer.SetGPUBuffersForFrame
		(
			framePerBoneAnimationWorkloadGB,
			frameRigAnimationJobsGB,
			rigDefinitionGB,
			rigBonesGB,
			rigSpaceAnimatedBonesGB,
			(int)rad.frameAnimatedBonesCounter
		);
	#endif
	}
}
}