372 lines
17 KiB
C#
372 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using AwesomeTechnologies.Billboards;
|
|
using AwesomeTechnologies.BillboardSystem;
|
|
using AwesomeTechnologies.Utility.Quadtree;
|
|
using Unity.Jobs;
|
|
using Unity.Jobs.LowLevel.Unsafe;
|
|
using UnityEngine;
|
|
using UnityEngine.Profiling;
|
|
using UnityEngine.Rendering;
|
|
|
|
namespace AwesomeTechnologies.VegetationSystem
|
|
{
|
|
public partial class VegetationSystemPro
|
|
{
|
|
[NonSerialized]
|
|
private readonly List<VegetationCell> _billboardTempVegetationCellList = new List<VegetationCell>();
|
|
|
|
[NonSerialized] private readonly List<BillboardCell> _loadBillboardCellList = new List<BillboardCell>();
|
|
|
|
|
|
private void DisposeBillboardCells()
|
|
{
|
|
_prepareVegetationHandle.Complete();
|
|
|
|
for (var i = 0; i <= BillboardCellList.Count - 1; i++) BillboardCellList[i].Dispose();
|
|
|
|
BillboardCellList.Clear();
|
|
}
|
|
|
|
public void UpdateBillboardCulling()
|
|
{
|
|
for (var i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
VegetationStudioCameraList[i].UpdateBillboardCullingGroup();
|
|
}
|
|
|
|
public void RefreshBillboards()
|
|
{
|
|
}
|
|
|
|
private void LoadBillboardCells()
|
|
{
|
|
_loadBillboardCellList.Clear();
|
|
Profiler.BeginSample("Load billboard cells");
|
|
_billboardTempVegetationCellList.Clear();
|
|
VegetationCellSpawner.CellJobHandleList.Clear();
|
|
|
|
Profiler.BeginSample("Find billboard cells with quadtree");
|
|
for (var i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
if (!VegetationStudioCameraList[i].Enabled) continue;
|
|
|
|
for (var j = 0;
|
|
j <= VegetationStudioCameraList[i].BillboardJobCullingGroup.VisibleCellIndexList.Length - 1;
|
|
j++)
|
|
{
|
|
var index = VegetationStudioCameraList[i].BillboardJobCullingGroup.VisibleCellIndexList[j];
|
|
var billboardCell = BillboardCellList[index];
|
|
if (billboardCell.Loaded) continue;
|
|
|
|
billboardCell.OverlapVegetationCells.Clear();
|
|
VegetationCellQuadTree.Query(billboardCell.Rectangle, billboardCell.OverlapVegetationCells);
|
|
|
|
_billboardTempVegetationCellList.AddRange(billboardCell.OverlapVegetationCells);
|
|
|
|
if (!_loadBillboardCellList.Contains(billboardCell)) _loadBillboardCellList.Add(billboardCell);
|
|
}
|
|
}
|
|
|
|
Profiler.EndSample();
|
|
|
|
Profiler.BeginSample("Load needed cells");
|
|
for (var i = 0; i <= _billboardTempVegetationCellList.Count - 1; i++)
|
|
{
|
|
var vegetationCell = _billboardTempVegetationCellList[i];
|
|
if (vegetationCell.LoadedDistanceBand <= 1) continue;
|
|
if (vegetationCell.LoadedBillboards) continue;
|
|
|
|
if (!Application.isPlaying && !vegetationCell.Prepared)
|
|
VegetationCellSpawner.PrepareVegetationCell(vegetationCell);
|
|
|
|
// ReSharper disable once InlineOutVariableDeclaration
|
|
bool hasInstancedIndirect;
|
|
|
|
var spawnVegetationCellHandle = VegetationCellSpawner.SpawnVegetationCell(vegetationCell, 1, out hasInstancedIndirect, true);
|
|
CompactMemoryCellList.Add(vegetationCell);
|
|
LoadedVegetationCellList.Add(vegetationCell);
|
|
#if UNITY_EDITOR
|
|
if (JobsUtility.JobDebuggerEnabled)
|
|
{
|
|
spawnVegetationCellHandle.Complete();
|
|
ReturnVegetationCellTemporaryMemory();
|
|
}
|
|
#endif
|
|
VegetationCellSpawner.CellJobHandleList.Add(spawnVegetationCellHandle);
|
|
if (hasInstancedIndirect) ProcessInstancedIndirectCellList.Add(vegetationCell);
|
|
}
|
|
|
|
var loadAllCellsHandle = JobHandle.CombineDependencies(VegetationCellSpawner.CellJobHandleList);
|
|
VegetationCellSpawner.CellJobHandleList.Clear();
|
|
|
|
Profiler.EndSample();
|
|
|
|
Profiler.BeginSample("Merge cells and create mesh data");
|
|
|
|
for (var i = 0; i <= _loadBillboardCellList.Count - 1; i++)
|
|
{
|
|
var billboardCell = _loadBillboardCellList[i];
|
|
if (billboardCell.Loaded) continue;
|
|
|
|
for (var j = 0; j <= billboardCell.VegetationPackageBillboardInstancesList.Count - 1; j++)
|
|
for (var k = 0;
|
|
k <= billboardCell.VegetationPackageBillboardInstancesList[j].BillboardInstanceList.Count - 1;
|
|
k++)
|
|
{
|
|
var vegetationItemInfoPro = VegetationPackageProList[j].VegetationInfoList[k];
|
|
if (vegetationItemInfoPro.VegetationType != VegetationType.Tree) continue;
|
|
|
|
var billboardInstance = billboardCell.VegetationPackageBillboardInstancesList[j]
|
|
.BillboardInstanceList[k];
|
|
if (billboardInstance.Loaded) continue;
|
|
|
|
var billboardPrepareMeshDataJobHandle = loadAllCellsHandle;
|
|
for (var l = 0; l <= billboardCell.OverlapVegetationCells.Count - 1; l++)
|
|
{
|
|
var vegetationCell = billboardCell.OverlapVegetationCells[l];
|
|
var cellInstanceList =
|
|
vegetationCell.VegetationPackageInstancesList[j].VegetationItemMatrixList[k];
|
|
|
|
var mergeCellInstancesJob = new MergeCellInstancesJob
|
|
{
|
|
OutputNativeList = billboardInstance.InstanceList, InputNativeList = cellInstanceList
|
|
};
|
|
|
|
billboardPrepareMeshDataJobHandle =
|
|
mergeCellInstancesJob.Schedule(billboardPrepareMeshDataJobHandle);
|
|
}
|
|
|
|
var vegetationItemSize = Mathf.Max(vegetationItemInfoPro.Bounds.extents.x,
|
|
vegetationItemInfoPro.Bounds.extents.y,
|
|
vegetationItemInfoPro.Bounds.extents.z) * 2f;
|
|
|
|
var createBillboardMeshJob = new BillboardGenerator.CreateBillboardMeshJob
|
|
{
|
|
InstanceList = billboardInstance.InstanceList,
|
|
VerticeList = billboardInstance.VerticeList,
|
|
NormalList = billboardInstance.NormalList,
|
|
UvList = billboardInstance.UvList,
|
|
Uv2List = billboardInstance.Uv2List,
|
|
Uv3List = billboardInstance.Uv3List,
|
|
IndexList = billboardInstance.IndexList,
|
|
BoundsYExtent = vegetationItemInfoPro.Bounds.extents.y,
|
|
VegetationItemSize = vegetationItemSize
|
|
};
|
|
|
|
billboardPrepareMeshDataJobHandle =
|
|
createBillboardMeshJob.Schedule(billboardPrepareMeshDataJobHandle);
|
|
VegetationCellSpawner.CellJobHandleList.Add(billboardPrepareMeshDataJobHandle);
|
|
}
|
|
}
|
|
|
|
var combinedMergeJobHandle = JobHandle.CombineDependencies(VegetationCellSpawner.CellJobHandleList);
|
|
VegetationCellSpawner.CellJobHandleList.Clear();
|
|
loadAllCellsHandle.Complete();
|
|
combinedMergeJobHandle.Complete();
|
|
Profiler.EndSample();
|
|
|
|
Profiler.BeginSample("Create Mesh Objects");
|
|
for (var i = 0; i <= _loadBillboardCellList.Count - 1; i++)
|
|
{
|
|
var billboardCell = _loadBillboardCellList[i];
|
|
if (billboardCell.Loaded) continue;
|
|
for (var j = 0; j <= billboardCell.VegetationPackageBillboardInstancesList.Count - 1; j++)
|
|
for (var k = 0;
|
|
k <= billboardCell.VegetationPackageBillboardInstancesList[j].BillboardInstanceList.Count - 1;
|
|
k++)
|
|
{
|
|
var billboardInstance = billboardCell.VegetationPackageBillboardInstancesList[j]
|
|
.BillboardInstanceList[k];
|
|
if (billboardInstance.Loaded) continue;
|
|
billboardInstance.InstanceCount = billboardInstance.InstanceList.Length;
|
|
if (billboardInstance.InstanceCount > 0)
|
|
billboardInstance.Mesh = BillboardGenerator.CreateMeshFromBillboardInstance(billboardInstance);
|
|
billboardInstance.Loaded = true;
|
|
}
|
|
|
|
billboardCell.Loaded = true;
|
|
}
|
|
|
|
_loadBillboardCellList.Clear();
|
|
Profiler.EndSample();
|
|
|
|
Profiler.EndSample();
|
|
}
|
|
|
|
private void ClearBillboardCellsCache()
|
|
{
|
|
for (var i = 0; i <= BillboardCellList.Count - 1; i++)
|
|
{
|
|
var billboardCell = BillboardCellList[i];
|
|
billboardCell.ClearCache();
|
|
}
|
|
}
|
|
|
|
private void ClearBillboardCellsCache(int vegetationPackageIndex, int vegetationItemIndex)
|
|
{
|
|
for (var i = 0; i <= BillboardCellList.Count - 1; i++)
|
|
{
|
|
var billboardCell = BillboardCellList[i];
|
|
billboardCell.ClearCache(vegetationPackageIndex, vegetationItemIndex);
|
|
}
|
|
}
|
|
|
|
private void ClearBillboardCellsCache(Bounds bounds)
|
|
{
|
|
_prepareVegetationHandle.Complete();
|
|
|
|
if (BillboardCellQuadTree == null) return;
|
|
var clearRect = RectExtension.CreateRectFromBounds(bounds);
|
|
var overlapBillboardCellList = new List<BillboardCell>();
|
|
BillboardCellQuadTree.Query(clearRect, overlapBillboardCellList);
|
|
for (var i = 0; i <= overlapBillboardCellList.Count - 1; i++)
|
|
{
|
|
var billboardCell = overlapBillboardCellList[i];
|
|
billboardCell.ClearCache();
|
|
}
|
|
}
|
|
|
|
private void ClearBillboardCellsCache(Bounds bounds,int vegetationPackageIndex, int vegetationItemIndex)
|
|
{
|
|
var clearRect = RectExtension.CreateRectFromBounds(bounds);
|
|
_prepareVegetationHandle.Complete();
|
|
|
|
var overlapBillboardCellList = new List<BillboardCell>();
|
|
BillboardCellQuadTree.Query(clearRect, overlapBillboardCellList);
|
|
for (var i = 0; i <= overlapBillboardCellList.Count - 1; i++)
|
|
{
|
|
var billboardCell = overlapBillboardCellList[i];
|
|
billboardCell.ClearCache(vegetationPackageIndex, vegetationItemIndex);
|
|
}
|
|
}
|
|
|
|
private void SetupBillboardShaderIDs()
|
|
{
|
|
_cameraPositionID = Shader.PropertyToID("_CameraPosition");
|
|
_cullDistanceID = Shader.PropertyToID("_CullDistance");
|
|
_farCullDistanceID = Shader.PropertyToID("_FarCullDistance");
|
|
}
|
|
|
|
public void RenderBillboardCells()
|
|
{
|
|
Profiler.BeginSample("Draw billboards");
|
|
var farCullDistance = Mathf.RoundToInt(VegetationSettings.GetBillboardDistance());
|
|
var isPlaying = Application.isPlaying;
|
|
|
|
var shadowCastingMode = VegetationSettings.GetBillboardShadowCastingMode();
|
|
var layer = VegetationSettings.GetBillboardLayer();
|
|
|
|
var positionMatrix = Matrix4x4.TRS(FloatingOriginOffset, Quaternion.identity, Vector3.one);
|
|
|
|
for (var i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
if (!VegetationStudioCameraList[i].Enabled) continue;
|
|
|
|
var targetCamera = VegetationStudioCameraList[i].RenderDirectToCamera
|
|
? VegetationStudioCameraList[i].SelectedCamera
|
|
: null;
|
|
|
|
if (!isPlaying) targetCamera = null;
|
|
|
|
for (var j = 0;
|
|
j <= VegetationStudioCameraList[i].BillboardJobCullingGroup.VisibleCellIndexList.Length - 1;
|
|
j++)
|
|
{
|
|
var index = VegetationStudioCameraList[i].BillboardJobCullingGroup.VisibleCellIndexList[j];
|
|
var billboardCell = BillboardCellList[index];
|
|
for (var k = 0; k <= billboardCell.VegetationPackageBillboardInstancesList.Count - 1; k++)
|
|
for (var l = 0;
|
|
l <= billboardCell.VegetationPackageBillboardInstancesList[k].BillboardInstanceList.Count - 1;
|
|
l++)
|
|
{
|
|
var billboardInstance = billboardCell.VegetationPackageBillboardInstancesList[k]
|
|
.BillboardInstanceList[l];
|
|
if (billboardInstance.Loaded && billboardInstance.InstanceCount > 0)
|
|
{
|
|
if (VegetationStudioCameraList[i].SelectedCamera == null) continue;
|
|
var vegetationItemModelInfo = VegetationPackageProModelsList[k].VegetationItemModelList[l];
|
|
|
|
var vegetationItemInfoPro = VegetationPackageProList[k].VegetationInfoList[l];
|
|
if (!vegetationItemInfoPro.UseBillboards) continue;
|
|
|
|
var camPos = VegetationStudioCameraList[i].SelectedCamera.transform.position;
|
|
|
|
var renderDistanceFactor = vegetationItemInfoPro.RenderDistanceFactor;
|
|
if (VegetationSettings.DisableRenderDistanceFactor) renderDistanceFactor = 1;
|
|
|
|
var cullDistance =
|
|
Mathf.RoundToInt(VegetationSettings.GetTreeDistance() * renderDistanceFactor);
|
|
if (vegetationItemModelInfo.BillboardLODFadeCrossfade)
|
|
cullDistance -= 10;
|
|
|
|
//vegetationItemModelInfo.BillboardMaterial.SetVector(_cameraPositionID, camPos);
|
|
|
|
MaterialPropertyBlock materialPropertyBlock =
|
|
vegetationItemModelInfo.CameraBillboardMaterialPropertyBlockList[i];
|
|
|
|
materialPropertyBlock.SetVector(_cameraPositionID, camPos);
|
|
|
|
materialPropertyBlock.SetInt(_cullDistanceID,
|
|
VegetationStudioCameraList[i].RenderBillboardsOnly ? 0 : cullDistance);
|
|
|
|
materialPropertyBlock.SetInt(_farCullDistanceID, farCullDistance);
|
|
materialPropertyBlock.SetFloat(_nearFadeDistanceID, VegetationRenderSettings.CrossFadeDistance);
|
|
|
|
|
|
Graphics.DrawMesh(billboardInstance.Mesh, positionMatrix,
|
|
vegetationItemModelInfo.BillboardMaterial, layer, targetCamera, 0, materialPropertyBlock,
|
|
shadowCastingMode, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Profiler.EndSample();
|
|
}
|
|
|
|
private void PrepareAllBillboardCells()
|
|
{
|
|
for (var i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
for (var j = 0; j <= BillboardCellList.Count - 1; j++)
|
|
{
|
|
var billboardCell = BillboardCellList[j];
|
|
if (!billboardCell.Prepared) billboardCell.PrepareBillboardCell(VegetationPackageProList);
|
|
}
|
|
}
|
|
|
|
private void CreateBillboardCells()
|
|
{
|
|
DisposeBillboardCells();
|
|
|
|
var expandedBounds = new Bounds(VegetationSystemBounds.center, VegetationSystemBounds.size);
|
|
|
|
var currentBillboardCellSize = BillboardCellSize;
|
|
if (!Application.isPlaying) currentBillboardCellSize = 400;
|
|
expandedBounds.Expand(new Vector3(currentBillboardCellSize * 2f, 0, currentBillboardCellSize * 2f));
|
|
|
|
BillboardCellQuadTree = new QuadTree<BillboardCell>(RectExtension.CreateRectFromBounds(expandedBounds));
|
|
var cellXCount = Mathf.CeilToInt(VegetationSystemBounds.size.x / currentBillboardCellSize);
|
|
var cellZCount = Mathf.CeilToInt(VegetationSystemBounds.size.z / currentBillboardCellSize);
|
|
|
|
var corner = new Vector2(VegetationSystemBounds.center.x - VegetationSystemBounds.size.x / 2f,
|
|
VegetationSystemBounds.center.z - VegetationSystemBounds.size.z / 2f);
|
|
|
|
for (var x = 0; x <= cellXCount - 1; x++)
|
|
for (var z = 0; z <= cellZCount - 1; z++)
|
|
{
|
|
var billboardCell = new BillboardCell(
|
|
new Rect(
|
|
new Vector2(currentBillboardCellSize * x + corner.x, currentBillboardCellSize * z + corner.y),
|
|
new Vector2(currentBillboardCellSize, currentBillboardCellSize)),
|
|
VegetationSystemBounds.center.y, VegetationSystemBounds.size.y);
|
|
BillboardCellList.Add(billboardCell);
|
|
billboardCell.Index = BillboardCellList.Count - 1;
|
|
BillboardCellQuadTree.Insert(billboardCell);
|
|
}
|
|
|
|
PrepareAllBillboardCells();
|
|
}
|
|
}
|
|
}
|
|
|