1305 lines
59 KiB
C#
1305 lines
59 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using AwesomeTechnologies.BillboardSystem;
|
|
using AwesomeTechnologies.Utility;
|
|
using AwesomeTechnologies.Utility.Culling;
|
|
using AwesomeTechnologies.Utility.Quadtree;
|
|
using AwesomeTechnologies.Vegetation.Masks;
|
|
using AwesomeTechnologies.Vegetation.PersistentStorage;
|
|
using AwesomeTechnologies.VegetationStudio;
|
|
using AwesomeTechnologies.VegetationSystem.Wind;
|
|
using Unity.Collections;
|
|
using Unity.Jobs;
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
using UnityEngine;
|
|
using UnityEngine.Profiling;
|
|
using UnityEngine.Rendering;
|
|
|
|
namespace AwesomeTechnologies.VegetationSystem
|
|
{
|
|
[AwesomeTechnologiesScriptOrder(100)]
|
|
[ExecuteInEditMode]
|
|
public partial class VegetationSystemPro : MonoBehaviour
|
|
{
|
|
public QuadTree<VegetationCell> VegetationCellQuadTree;
|
|
public QuadTree<BillboardCell> BillboardCellQuadTree;
|
|
[NonSerialized] public readonly List<VegetationCell> VegetationCellList = new List<VegetationCell>();
|
|
[NonSerialized] public readonly List<BillboardCell> BillboardCellList = new List<BillboardCell>();
|
|
[NonSerialized] public readonly List<VegetationCell> LoadedVegetationCellList = new List<VegetationCell>();
|
|
|
|
[NonSerialized]
|
|
public readonly List<VegetationCell> ProcessInstancedIndirectCellList = new List<VegetationCell>();
|
|
|
|
[NonSerialized] public readonly List<VegetationCell> CompactMemoryCellList = new List<VegetationCell>();
|
|
[NonSerialized] public readonly List<VegetationCell> PredictiveCellLoaderList = new List<VegetationCell>();
|
|
|
|
public VegetationCellSpawner VegetationCellSpawner = new VegetationCellSpawner();
|
|
|
|
public Bounds VegetationSystemBounds;
|
|
public bool AutomaticBoundsCalculation = true;
|
|
|
|
public PersistentVegetationStorage PersistentVegetationStorage;
|
|
|
|
public PredictiveCellLoader PredictiveCellLoader;
|
|
public int PredictiveCellLoaderCellsPerFrame = 1;
|
|
public bool LoadPotentialVegetationCells = true;
|
|
|
|
public int CurrentTabIndex;
|
|
public int VegetationPackageIndex;
|
|
public float SeaLevel;
|
|
public bool ExcludeSeaLevelCells;
|
|
public float VegetationCellSize = 100;
|
|
public float BillboardCellSize = 500;
|
|
|
|
public bool UseCacheCompacter = false;
|
|
|
|
[NonSerialized] public float AdditionalBoundingSphereRadius;
|
|
|
|
public int SelectedTextureMaskGroupTextureIndex;
|
|
public int SelectedTextureMaskGroupIndex;
|
|
|
|
public TextureMask DebugTextureMask;
|
|
|
|
[NonSerialized] public bool InitDone;
|
|
|
|
private JobHandle _prepareVegetationHandle;
|
|
|
|
public VegetationSettings VegetationSettings = new VegetationSettings();
|
|
public VegetationRenderSettings VegetationRenderSettings = new VegetationRenderSettings();
|
|
public EnvironmentSettings EnvironmentSettings = new EnvironmentSettings();
|
|
public List<VegetationStudioCamera> VegetationStudioCameraList = new List<VegetationStudioCamera>();
|
|
|
|
public bool ShowVegetationCells;
|
|
public bool ShowBillboardCells;
|
|
public bool ShowVisibleBillboardCells;
|
|
public bool ShowPotentialVisibleCells;
|
|
public bool ShowVisibleCells;
|
|
public bool ShowBiomeCells;
|
|
public bool ShowVegetationMaskCells;
|
|
public bool ShowHeatMap;
|
|
public bool ShowTerrainTextures = true;
|
|
public bool ShowLODDebug = false;
|
|
|
|
public bool ShowVegetationPackageGeneralSettingsMenu = true;
|
|
public bool ShowVegetationPackageNoiseMenu = true;
|
|
public bool ShowTerrainTextureRulesMenu = true;
|
|
public bool ShowTextureMaskRulesMenu = true;
|
|
public bool ShowVegetationMaskRulesMenu = true;
|
|
public bool ShowShaderSettingsMenu = true;
|
|
public bool ShowPositionMenu = true;
|
|
public bool ShowDistanceFalloffMenu = true;
|
|
public bool ShowBiomeRulesMenu = true;
|
|
public bool ShowConcaveLocationRulesMenu = true;
|
|
public bool ShowColliderRulesMenu = true;
|
|
public bool ShowBillboardsMenu = true;
|
|
public bool ShowVegetationItemSettingsMenu = true;
|
|
public bool ShowTerrainSourceSettingsMenu = true;
|
|
public bool ShowAddVegetationItemMenu = true;
|
|
public bool ShowLODMenu = true;
|
|
|
|
//public bool ForceBillboardCellLoadinComplete = false;
|
|
|
|
public List<IVegetationStudioTerrain> VegetationStudioTerrainList = new List<IVegetationStudioTerrain>();
|
|
public List<GameObject> VegetationStudioTerrainObjectList = new List<GameObject>();
|
|
public List<VegetationPackagePro> VegetationPackageProList = new List<VegetationPackagePro>();
|
|
|
|
public List<VegetationPackageProModelInfo> VegetationPackageProModelsList =
|
|
new List<VegetationPackageProModelInfo>();
|
|
|
|
public List<WindControllerSettings> WindControllerSettingsList = new List<WindControllerSettings>();
|
|
|
|
public delegate void MultiOnAddCameraDelegate(VegetationStudioCamera vegetationStudioCamera);
|
|
|
|
public MultiOnAddCameraDelegate OnAddCameraDelegate;
|
|
|
|
public delegate void MultiOnRemoveCameraDelegate(VegetationStudioCamera vegetationStudioCamera);
|
|
|
|
public MultiOnRemoveCameraDelegate OnRemoveCameraDelegate;
|
|
|
|
public delegate void MultiOnVegetationStudioRefreshDelegate(VegetationSystemPro vegetationSystemPro);
|
|
|
|
public MultiOnVegetationStudioRefreshDelegate OnRefreshVegetationSystemDelegate;
|
|
public MultiOnVegetationStudioRefreshDelegate OnRefreshColliderSystemDelegate;
|
|
public MultiOnVegetationStudioRefreshDelegate OnRefreshRuntimePrefabSpawnerDelegate;
|
|
|
|
public delegate void MultiOnClearCacheDelegate(VegetationSystemPro vegetationSystemPro);
|
|
|
|
public delegate void MultiOnClearCacheVegetationCellDelegate(VegetationSystemPro vegetationSystemPro,
|
|
VegetationCell vegetationCell);
|
|
|
|
public delegate void MultiOnClearCacheVegetationItemDelegate(VegetationSystemPro vegetationSystemPro,
|
|
int vegetationPackageIndex, int vegetationItemIndex);
|
|
|
|
public delegate void MultiOnClearCacheVegetationCellVegetationItemDelegate(
|
|
VegetationSystemPro vegetationSystemPro, VegetationCell vegetationCell, int vegetationPackageIndex,
|
|
int vegetationItemIndex);
|
|
|
|
public delegate void MultiOnVegetationCellSpawnedDelegate(VegetationCell vegetationCell);
|
|
|
|
public MultiOnVegetationCellSpawnedDelegate OnVegetationCellLoaded;
|
|
|
|
public MultiOnClearCacheDelegate OnClearCacheDelegate;
|
|
public MultiOnClearCacheVegetationItemDelegate OnClearCacheVegetationItemDelegate;
|
|
public MultiOnClearCacheVegetationCellDelegate OnClearCacheVegetationCellDelegate;
|
|
public MultiOnClearCacheVegetationCellVegetationItemDelegate OnClearCacheVegetationCellVegetatonItemDelegate;
|
|
|
|
public delegate void MultOnRenderCompleteDelegate(VegetationSystemPro vegetationSystemPro);
|
|
|
|
public MultOnRenderCompleteDelegate OnRenderCompleteDelegate;
|
|
|
|
[NonSerialized] private readonly List<IWindController> _windControllerList = new List<IWindController>();
|
|
|
|
public WindZone SelectedWindZone;
|
|
public float WindSpeedFactor = 1f;
|
|
public Light SunDirectionalLight;
|
|
|
|
// ReSharper disable once UnusedMember.Local
|
|
|
|
//private Texture _dummyMaskTexture;
|
|
private ComputeBuffer _dummyComputeBuffer;
|
|
|
|
public int FrustumKernelHandle;
|
|
|
|
//public int DistanceKernelHandle;
|
|
public ComputeShader FrusumMatrixShader;
|
|
private int _cameraFrustumPlan0;
|
|
private int _cameraFrustumPlan1;
|
|
private int _cameraFrustumPlan2;
|
|
private int _cameraFrustumPlan3;
|
|
private int _cameraFrustumPlan4;
|
|
private int _cameraFrustumPlan5;
|
|
|
|
public int MergeBufferKernelHandle;
|
|
public ComputeShader MergeBufferShader;
|
|
|
|
private int _floatingOriginOffsetID = -1;
|
|
|
|
private int _mergeBufferID = -1;
|
|
private int _mergeSourceBuffer0ID = -1;
|
|
private int _mergeSourceBuffer1ID = -1;
|
|
private int _mergeSourceBuffer2ID = -1;
|
|
private int _mergeSourceBuffer3ID = -1;
|
|
private int _mergeSourceBuffer4ID = -1;
|
|
private int _mergeSourceBuffer5ID = -1;
|
|
private int _mergeSourceBuffer6ID = -1;
|
|
private int _mergeSourceBuffer7ID = -1;
|
|
private int _mergeSourceBuffer8ID = -1;
|
|
private int _mergeSourceBuffer9ID = -1;
|
|
private int _mergeSourceBuffer10ID = -1;
|
|
private int _mergeSourceBuffer11ID = -1;
|
|
private int _mergeSourceBuffer12ID = -1;
|
|
private int _mergeSourceBuffer13ID = -1;
|
|
private int _mergeSourceBuffer14ID = -1;
|
|
|
|
private int _mergeInstanceCount0ID = -1;
|
|
private int _mergeInstanceCount1ID = -1;
|
|
private int _mergeInstanceCount2ID = -1;
|
|
private int _mergeInstanceCount3ID = -1;
|
|
private int _mergeInstanceCount4ID = -1;
|
|
private int _mergeInstanceCount5ID = -1;
|
|
private int _mergeInstanceCount6ID = -1;
|
|
private int _mergeInstanceCount7ID = -1;
|
|
private int _mergeInstanceCount8ID = -1;
|
|
private int _mergeInstanceCount9ID = -1;
|
|
private int _mergeInstanceCount10ID = -1;
|
|
private int _mergeInstanceCount11ID = -1;
|
|
private int _mergeInstanceCount12ID = -1;
|
|
private int _mergeInstanceCount13ID = -1;
|
|
private int _mergeInstanceCount14ID = -1;
|
|
|
|
private int _visibleBufferLod0ID = -1;
|
|
private int _visibleBufferLod1ID = -1;
|
|
private int _visibleBufferLod2ID = -1;
|
|
private int _visibleBufferLod3ID = -1;
|
|
|
|
private int _shadowBufferLod0ID = -1;
|
|
private int _shadowBufferLod1ID = -1;
|
|
private int _shadowBufferLod2ID = -1;
|
|
private int _shadowBufferLod3ID = -1;
|
|
|
|
private int _sourceBufferID = -1;
|
|
private int _instanceCountID = -1;
|
|
|
|
private int _boundingSphereRadiusID = -1;
|
|
private int _useLodsID = -1;
|
|
private int _noFrustumCullingID = -1;
|
|
private int _shadowCullingID = -1;
|
|
|
|
private int _cullFarStartID;
|
|
private int _visibleShaderDataBufferID;
|
|
private int _indirectShaderDataBufferID;
|
|
|
|
private int _cameraPositionID;
|
|
private int _cullDistanceID;
|
|
private int _farCullDistanceID;
|
|
private static readonly int _nearFadeDistanceID = Shader.PropertyToID("_NearFadeDistance");
|
|
|
|
private int _unityLODFadeID;
|
|
|
|
private int _lod1Distance = -1;
|
|
private int _lod2Distance = -1;
|
|
private int _lod3Distance = -1;
|
|
|
|
private int _lightDirection = -1;
|
|
private int _planeOrigin = -1;
|
|
private int _boundsSize = -1;
|
|
|
|
private int _lodFactor = -1;
|
|
private int _lodBias = -1;
|
|
private int _lodFadeDistance = -1;
|
|
private int _lodCount = -1;
|
|
|
|
private readonly List<VegetationCell> _hasBufferList = new List<VegetationCell>();
|
|
|
|
private readonly Matrix4x4[] _renderArray = new Matrix4x4[1000];
|
|
private readonly float[] _renderingLayerArray = new float[1000];
|
|
|
|
private readonly Vector4[] _renderLodFadeArray = new Vector4[1000];
|
|
//private Vector4[] _lodFadeSingleArray = new Vector4[1];
|
|
|
|
//Floating origin variables
|
|
public Transform FloatingOriginAnchor;
|
|
public Vector3 FloatingOriginOffset;
|
|
public Vector3 FloatingOriginStartPosition;
|
|
private static readonly int UnityRenderingLayerID = Shader.PropertyToID("unity_RenderingLayer");
|
|
|
|
public Vector3 VegetationSystemPosition
|
|
{
|
|
get
|
|
{
|
|
Vector3 position = VegetationSystemBounds.center - VegetationSystemBounds.extents;
|
|
position.y = 0;
|
|
return position;
|
|
}
|
|
}
|
|
|
|
public void DetectPersistentVegetationStorage()
|
|
{
|
|
if (!PersistentVegetationStorage)
|
|
{
|
|
PersistentVegetationStorage = GetComponent<PersistentVegetationStorage>();
|
|
}
|
|
}
|
|
|
|
// ReSharper disable once UnusedMember.Local
|
|
void Reset()
|
|
{
|
|
AutoSelectCamera();
|
|
FindWindZone();
|
|
FindDirectionalLight();
|
|
DetectPersistentVegetationStorage();
|
|
}
|
|
|
|
void FindDirectionalLight()
|
|
{
|
|
if (SunDirectionalLight) return;
|
|
|
|
Light selectedLight = null;
|
|
float intensity = float.MinValue;
|
|
|
|
Light[] lights = FindObjectsOfType<Light>();
|
|
for (int i = 0; i <= lights.Length - 1; i++)
|
|
{
|
|
if (lights[i].type == LightType.Directional)
|
|
{
|
|
if (lights[i].intensity > intensity)
|
|
{
|
|
intensity = lights[i].intensity;
|
|
selectedLight = lights[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
SunDirectionalLight = selectedLight;
|
|
}
|
|
|
|
void AutoSelectCamera()
|
|
{
|
|
Camera selectedCamera = Camera.main;
|
|
|
|
if (selectedCamera == null)
|
|
{
|
|
Camera[] cameras = FindObjectsOfType<Camera>();
|
|
for (int i = 0; i <= cameras.Length - 1; i++)
|
|
{
|
|
if (cameras[i].gameObject.name.Contains("Main Camera") ||
|
|
cameras[i].gameObject.name.Contains("MainCamera"))
|
|
{
|
|
selectedCamera = cameras[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
AddCamera(selectedCamera);
|
|
}
|
|
|
|
public void RefreshVegetationSystem()
|
|
{
|
|
SetupVegetationSystem();
|
|
}
|
|
|
|
public void RefreshColliderSystem()
|
|
{
|
|
OnRefreshColliderSystemDelegate?.Invoke(this);
|
|
}
|
|
|
|
public void RefreshRuntimePrefabSpawner()
|
|
{
|
|
OnRefreshRuntimePrefabSpawnerDelegate?.Invoke(this);
|
|
}
|
|
|
|
void SetupVegetationSystem()
|
|
{
|
|
CompleteCellLoading();
|
|
|
|
ProcessInstancedIndirectCellList.Clear();
|
|
DisposeVegetationStudioCameras();
|
|
DisposeVegetationCells();
|
|
DisposeBillboardCells();
|
|
|
|
if (VegetationSystemBounds.size.magnitude < 1) return;
|
|
SetupWindSamplers();
|
|
|
|
SetupVegetationItemModels();
|
|
RefreshVegetationStudioTerrains();
|
|
CreateVegetationCells();
|
|
CreateBillboardCells();
|
|
SetVegetationStudioCamerasDirty();
|
|
|
|
RefreshMaterials();
|
|
OnRefreshVegetationSystemDelegate?.Invoke(this);
|
|
}
|
|
|
|
public void CompleteCellLoading()
|
|
{
|
|
_prepareVegetationHandle.Complete();
|
|
}
|
|
|
|
// ReSharper disable once UnusedMember.Local
|
|
void OnEnable()
|
|
{
|
|
VegetationStudioManager.RegisterVegetationSystem(this);
|
|
DetectPersistentVegetationStorage();
|
|
FindDirectionalLight();
|
|
EnableEditorApi();
|
|
|
|
LoadSettingsFromQualityManager();
|
|
|
|
SetupPredictiveCellLoader();
|
|
SetupVegetationCellSpawner();
|
|
|
|
SetupSceneviewCamera();
|
|
SetupFloatingOrigin();
|
|
|
|
SetupComputeShaders();
|
|
SetupBillboardShaderIDs();
|
|
SetupInstancedRenderMaterialPropertiesIDs();
|
|
SetupRenderingLayerData();
|
|
|
|
SetupVegetationSystem();
|
|
VegetationCellSpawner.Init();
|
|
SetupWind();
|
|
InitDone = true;
|
|
}
|
|
|
|
public void SetupRenderingLayerData()
|
|
{
|
|
int flags = VegetationRenderSettings.RenderingLayerMask;
|
|
float flagsFloat = BitConverter.ToSingle(System.BitConverter.GetBytes(flags), 0);
|
|
for (int i = 0; i < _renderingLayerArray.Length; i++)
|
|
{
|
|
_renderingLayerArray[i] = flagsFloat;
|
|
}
|
|
|
|
Shader.SetGlobalFloat("VSPRenderingLayerMask", flagsFloat);
|
|
}
|
|
|
|
void LoadSettingsFromQualityManager()
|
|
{
|
|
if (!Application.isPlaying)
|
|
{
|
|
return;
|
|
}
|
|
|
|
QualityManager qualityManager = GetComponent<QualityManager>();
|
|
if (qualityManager)
|
|
{
|
|
qualityManager.SetQualityLevel(false);
|
|
}
|
|
}
|
|
|
|
|
|
void EnableEditorApi()
|
|
{
|
|
#if UNITY_EDITOR
|
|
if (!Application.isPlaying)
|
|
{
|
|
SceneViewDetector.OnSceneViewTransformChangeDelegate += OnSceneviewTransformChanged;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void DisableEditorApi()
|
|
{
|
|
#if UNITY_EDITOR
|
|
if (!Application.isPlaying)
|
|
{
|
|
// ReSharper disable once DelegateSubtraction
|
|
SceneViewDetector.OnSceneViewTransformChangeDelegate -= OnSceneviewTransformChanged;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void OnSceneviewTransformChanged(Camera currentCamera)
|
|
{
|
|
#if UNITY_EDITOR
|
|
EditorUtility.SetDirty(this);
|
|
#endif
|
|
}
|
|
|
|
void SetupSceneviewCamera()
|
|
{
|
|
for (int i = VegetationStudioCameraList.Count - 1; i >= 0; i--)
|
|
{
|
|
if (VegetationStudioCameraList[i].VegetationStudioCameraType == VegetationStudioCameraType.SceneView ||
|
|
VegetationStudioCameraList[i].SelectedCamera == null)
|
|
{
|
|
RemoveVegetationStudioCamera(VegetationStudioCameraList[i]);
|
|
}
|
|
}
|
|
|
|
if (!Application.isPlaying)
|
|
{
|
|
VegetationStudioCamera sceneviewCamera =
|
|
new VegetationStudioCamera(VegetationStudioCameraType.SceneView)
|
|
{
|
|
CameraCullingMode = CameraCullingMode.Frustum,
|
|
RenderDirectToCamera = false,
|
|
VegetationSystemPro = this
|
|
};
|
|
|
|
AddVegetationStudioCamera(sceneviewCamera);
|
|
//VegetationStudioCameraList.Add(sceneviewCamera);
|
|
}
|
|
|
|
if (Application.isPlaying && VegetationStudioCameraList.Count == 0)
|
|
{
|
|
AutoSelectCamera();
|
|
}
|
|
}
|
|
|
|
void SetupFloatingOrigin()
|
|
{
|
|
Transform anchor = GetFloatingOriginAnchor();
|
|
FloatingOriginStartPosition = anchor.position;
|
|
}
|
|
|
|
void UpdateFloatingOrigin()
|
|
{
|
|
if (Application.isPlaying)
|
|
{
|
|
Transform anchor = GetFloatingOriginAnchor();
|
|
FloatingOriginOffset = anchor.transform.position - FloatingOriginStartPosition;
|
|
}
|
|
else
|
|
{
|
|
FloatingOriginOffset = Vector3.zero;
|
|
}
|
|
}
|
|
|
|
Transform GetFloatingOriginAnchor()
|
|
{
|
|
if (FloatingOriginAnchor) return FloatingOriginAnchor;
|
|
return transform;
|
|
}
|
|
|
|
// void PrepareRenderLists()
|
|
// {
|
|
// for (int i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
// {
|
|
// VegetationStudioCameraList[i].PrepareRenderLists(VegetationPackageProList);
|
|
// }
|
|
// }
|
|
|
|
// ReSharper disable once UnusedMember.Local
|
|
void Update()
|
|
{
|
|
if (!InitDone) return;
|
|
|
|
UpdateFloatingOrigin();
|
|
|
|
if (VegetationCellList.Count <= 0) return;
|
|
|
|
JobHandle cullingHandle = default(JobHandle);
|
|
for (int i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
VegetationStudioCameraList[i].SetFloatingOriginOffset(FloatingOriginOffset);
|
|
VegetationStudioCameraList[i].PreCullVegetation(false);
|
|
VegetationStudioCameraList[i].PrepareRenderLists(VegetationPackageProList);
|
|
}
|
|
|
|
//PrepareRenderLists();
|
|
|
|
for (int i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
if (!VegetationStudioCameraList[i].Enabled) continue;
|
|
cullingHandle = VegetationStudioCameraList[i].ScheduleCullVegetationJob(cullingHandle);
|
|
}
|
|
|
|
Profiler.BeginSample("VegetationCell culling");
|
|
cullingHandle.Complete();
|
|
Profiler.EndSample();
|
|
|
|
Profiler.BeginSample("Process culling events");
|
|
for (int i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
if (!VegetationStudioCameraList[i].Enabled) continue;
|
|
VegetationStudioCameraList[i].ProcessEvents();
|
|
}
|
|
|
|
Profiler.EndSample();
|
|
|
|
VerifySplatmapAccess();
|
|
|
|
Profiler.BeginSample("Prepare cell loading jobs");
|
|
VegetationCellSpawner.CellJobHandleList.Clear();
|
|
|
|
float worldspaceMinHeight = VegetationSystemBounds.center.y -
|
|
VegetationSystemBounds.extents.y;
|
|
float worldspaceSeaLevel = worldspaceMinHeight + SeaLevel;
|
|
VegetationCellSpawner.WorldspaceSeaLevel = worldspaceSeaLevel;
|
|
|
|
PredictiveCellLoaderList.Clear();
|
|
PredictiveCellLoader.GetCellsToLoad(PredictiveCellLoaderList);
|
|
for (int i = 0; i <= PredictiveCellLoaderList.Count - 1; i++)
|
|
{
|
|
VegetationCell vegetationCell = PredictiveCellLoaderList[i];
|
|
|
|
bool hasData = vegetationCell.LoadedDistanceBand != 99;
|
|
|
|
bool hasInstancedIndirect;
|
|
JobHandle vegetationCellHandle =
|
|
VegetationCellSpawner.SpawnVegetationCell(vegetationCell, 0, out hasInstancedIndirect, false);
|
|
OnVegetationCellLoaded?.Invoke(vegetationCell);
|
|
|
|
if (!hasData)
|
|
{
|
|
if (!LoadedVegetationCellList.Contains(vegetationCell))
|
|
{
|
|
LoadedVegetationCellList.Add(vegetationCell);
|
|
}
|
|
}
|
|
|
|
if (hasInstancedIndirect)
|
|
{
|
|
ProcessInstancedIndirectCellList.Add(vegetationCell);
|
|
}
|
|
|
|
VegetationCellSpawner.CellJobHandleList.Add(vegetationCellHandle);
|
|
}
|
|
|
|
for (int i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
if (!VegetationStudioCameraList[i].Enabled) continue;
|
|
|
|
for (int j = 0; j <= VegetationStudioCameraList[i].JobCullingGroup.VisibleCellIndexList.Length - 1; j++)
|
|
{
|
|
int potentialVisibleCellIndex =
|
|
VegetationStudioCameraList[i].JobCullingGroup.VisibleCellIndexList[j];
|
|
VegetationCell vegetationCell = VegetationStudioCameraList[i]
|
|
.PotentialVisibleVegetationCellList[potentialVisibleCellIndex];
|
|
|
|
BoundingSphereInfo boundingSphereInfo =
|
|
VegetationStudioCameraList[i].GetBoundingSphereInfo(potentialVisibleCellIndex);
|
|
if (vegetationCell.LoadedDistanceBand <= boundingSphereInfo.CurrentDistanceBand) continue;
|
|
|
|
// if (!Application.isPlaying && !vegetationCell.Prepared)
|
|
// {
|
|
// VegetationCellSpawner.PrepareVegetationCell(vegetationCell);
|
|
// }
|
|
|
|
// ReSharper disable once InlineOutVariableDeclaration
|
|
bool hasInstancedIndirect;
|
|
JobHandle vegetationCellHandle = VegetationCellSpawner.SpawnVegetationCell(vegetationCell,
|
|
boundingSphereInfo.CurrentDistanceBand, out hasInstancedIndirect, false);
|
|
OnVegetationCellLoaded?.Invoke(vegetationCell);
|
|
LoadedVegetationCellList.Add(vegetationCell);
|
|
|
|
if (hasInstancedIndirect)
|
|
{
|
|
ProcessInstancedIndirectCellList.Add(vegetationCell);
|
|
}
|
|
|
|
VegetationCellSpawner.CellJobHandleList.Add(vegetationCellHandle);
|
|
}
|
|
}
|
|
|
|
_prepareVegetationHandle = JobHandle.CombineDependencies(VegetationCellSpawner.CellJobHandleList);
|
|
Profiler.EndSample();
|
|
|
|
JobHandle.ScheduleBatchedJobs();
|
|
|
|
Profiler.BeginSample("Prepare render list jobs");
|
|
float lodBias = QualitySettings.lodBias * VegetationSettings.LODDistanceFactor;
|
|
Vector3 sunLightDirection =
|
|
SunDirectionalLight ? SunDirectionalLight.transform.forward : new Vector3(0, 0, 0);
|
|
float minBoundsHeight = VegetationSystemBounds.center.y - VegetationSystemBounds.extents.y;
|
|
Vector3 planeOrigin = new Vector3(0, minBoundsHeight, 0);
|
|
bool shadowCulling = (SunDirectionalLight != null);
|
|
bool isPlaying = Application.isPlaying;
|
|
|
|
VegetationCellSpawner.CellJobHandleList.Clear();
|
|
for (int i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
if (!VegetationStudioCameraList[i].Enabled) continue;
|
|
if (VegetationStudioCameraList[i].RenderBillboardsOnly) continue;
|
|
|
|
for (int j = 0; j <= VegetationPackageProList.Count - 1; j++)
|
|
{
|
|
for (int k = 0; k <= VegetationPackageProList[j].VegetationInfoList.Count - 1; k++)
|
|
{
|
|
NativeList<MatrixInstance> vegetationItemMatrixList =
|
|
VegetationStudioCameraList[i].VegetationStudioCameraRenderList[j]
|
|
.VegetationItemMergeMatrixList[k];
|
|
vegetationItemMatrixList.Clear();
|
|
|
|
VegetationItemModelInfo vegetationItemModelInfo =
|
|
VegetationPackageProModelsList[j].VegetationItemModelList[k];
|
|
|
|
bool useInstancedIndirect = VegetationRenderSettings.UseInstancedIndirect();
|
|
if (useInstancedIndirect && vegetationItemModelInfo.VegetationItemInfo.VegetationRenderMode ==
|
|
VegetationRenderMode.InstancedIndirect) continue;
|
|
|
|
//if (isPlaying && vegetationItemModelInfo.VegetationItemInfo.VegetationRenderMode ==
|
|
// VegetationRenderMode.InstancedIndirect) continue;
|
|
|
|
//if (!vegetationItemModelInfo.VegetationItemInfo.EnableRuntimeSpawn) continue;
|
|
|
|
JobHandle vegetationItemMergeJobHandle = _prepareVegetationHandle;
|
|
for (int l = 0;
|
|
l <= VegetationStudioCameraList[i].JobCullingGroup.VisibleCellIndexList.Length - 1;
|
|
l++)
|
|
{
|
|
int potentialVisibleCellIndex =
|
|
VegetationStudioCameraList[i].JobCullingGroup.VisibleCellIndexList[l];
|
|
VegetationCell vegetationCell = VegetationStudioCameraList[i]
|
|
.PotentialVisibleVegetationCellList[potentialVisibleCellIndex];
|
|
BoundingSphereInfo boundingSphereInfo = VegetationStudioCameraList[i]
|
|
.GetBoundingSphereInfo(potentialVisibleCellIndex);
|
|
|
|
int vegetationItemDistanceBand = vegetationItemModelInfo.DistanceBand;
|
|
// if (vegetationItemModelInfo.VegetationItemInfo.VegetationType == VegetationType.Objects)
|
|
// {
|
|
// vegetationItemDistanceBand = 0;
|
|
// }
|
|
|
|
if (boundingSphereInfo.CurrentDistanceBand > vegetationItemDistanceBand) continue;
|
|
|
|
MergeCellInstancesJob mergeCellInstancesJob =
|
|
new MergeCellInstancesJob
|
|
{
|
|
OutputNativeList = vegetationItemMatrixList,
|
|
InputNativeList = vegetationCell.VegetationPackageInstancesList[j]
|
|
.VegetationItemMatrixList[k]
|
|
};
|
|
Profiler.BeginSample("Schedule");
|
|
vegetationItemMergeJobHandle = mergeCellInstancesJob.Schedule(vegetationItemMergeJobHandle);
|
|
Profiler.EndSample();
|
|
}
|
|
|
|
NativeList<Matrix4x4> lod0MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD0MatrixList[k];
|
|
NativeList<Matrix4x4> lod1MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD1MatrixList[k];
|
|
NativeList<Matrix4x4> lod2MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD2MatrixList[k];
|
|
NativeList<Matrix4x4> lod3MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD3MatrixList[k];
|
|
|
|
NativeList<Matrix4x4> lod0ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD0ShadowMatrixList[k];
|
|
NativeList<Matrix4x4> lod1ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD1ShadowMatrixList[k];
|
|
NativeList<Matrix4x4> lod2ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD2ShadowMatrixList[k];
|
|
NativeList<Matrix4x4> lod3ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD3ShadowMatrixList[k];
|
|
|
|
NativeList<Vector4> lod0FadeList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD0LodFadeList[k];
|
|
NativeList<Vector4> lod1FadeList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD1LodFadeList[k];
|
|
NativeList<Vector4> lod2FadeList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD2LodFadeList[k];
|
|
NativeList<Vector4> lod3FadeList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD3LodFadeList[k];
|
|
|
|
lod0MatrixList.Clear();
|
|
lod1MatrixList.Clear();
|
|
lod2MatrixList.Clear();
|
|
lod3MatrixList.Clear();
|
|
|
|
lod0ShadowMatrixList.Clear();
|
|
lod1ShadowMatrixList.Clear();
|
|
lod2ShadowMatrixList.Clear();
|
|
lod3ShadowMatrixList.Clear();
|
|
|
|
lod0FadeList.Clear();
|
|
lod1FadeList.Clear();
|
|
lod2FadeList.Clear();
|
|
lod3FadeList.Clear();
|
|
|
|
float vegetationItemCullDistance;
|
|
|
|
float renderDistanceFactor = vegetationItemModelInfo.VegetationItemInfo.RenderDistanceFactor;
|
|
if (VegetationSettings.DisableRenderDistanceFactor) renderDistanceFactor = 1;
|
|
|
|
//if (vegetationItemModelInfo.DistanceBand == 0)
|
|
if (vegetationItemModelInfo.VegetationItemInfo.VegetationType == VegetationType.Tree ||
|
|
vegetationItemModelInfo.VegetationItemInfo.VegetationType == VegetationType.LargeObjects)
|
|
{
|
|
vegetationItemCullDistance = VegetationSettings.GetTreeDistance() * renderDistanceFactor;
|
|
}
|
|
else
|
|
{
|
|
vegetationItemCullDistance =
|
|
VegetationSettings.GetVegetationDistance() * renderDistanceFactor;
|
|
}
|
|
|
|
ShadowCastingMode shadowCastingMode =
|
|
VegetationSettings.GetShadowCastingMode(vegetationItemModelInfo.VegetationItemInfo
|
|
.VegetationType);
|
|
bool useShadowCulling = shadowCulling && shadowCastingMode == ShadowCastingMode.On;
|
|
useShadowCulling = useShadowCulling && vegetationItemModelInfo.DistanceBand == 1;
|
|
|
|
if (VegetationStudioCameraList[i].SelectedCamera == null)
|
|
{
|
|
VegetationCellSpawner.CellJobHandleList.Add(vegetationItemMergeJobHandle);
|
|
continue;
|
|
}
|
|
|
|
float crossFadeDistance = 0;
|
|
|
|
if (vegetationItemModelInfo.VegetationItemInfo.EnableCrossFade)
|
|
{
|
|
crossFadeDistance = VegetationRenderSettings.CrossFadeDistance;
|
|
}
|
|
|
|
#if USING_HDRP
|
|
if (vegetationItemModelInfo.VegetationItemInfo.VegetationRenderMode ==
|
|
VegetationRenderMode.Instanced)
|
|
{
|
|
crossFadeDistance = 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
VegetationItemLODSplitAndFrustumCullingJob lodJob =
|
|
new VegetationItemLODSplitAndFrustumCullingJob
|
|
{
|
|
BoundingSphereRadius = vegetationItemModelInfo.BoundingSphereRadius,
|
|
BoundsSize = vegetationItemModelInfo.VegetationItemInfo.Bounds.size,
|
|
VegetationItemDistanceBand = vegetationItemModelInfo.DistanceBand,
|
|
VegetationItemMatrixList = vegetationItemMatrixList,
|
|
VegetationItemLOD0MatrixList = lod0MatrixList,
|
|
VegetationItemLOD1MatrixList = lod1MatrixList,
|
|
VegetationItemLOD2MatrixList = lod2MatrixList,
|
|
VegetationItemLOD3MatrixList = lod3MatrixList,
|
|
VegetationItemLOD0ShadowMatrixList = lod0ShadowMatrixList,
|
|
VegetationItemLOD1ShadowMatrixList = lod1ShadowMatrixList,
|
|
VegetationItemLOD2ShadowMatrixList = lod2ShadowMatrixList,
|
|
VegetationItemLOD3ShadowMatrixList = lod3ShadowMatrixList,
|
|
LOD0FadeList = lod0FadeList,
|
|
LOD1FadeList = lod1FadeList,
|
|
LOD2FadeList = lod2FadeList,
|
|
LOD3FadeList = lod3FadeList,
|
|
LightDirection = sunLightDirection,
|
|
ShadowCulling = useShadowCulling,
|
|
PlaneOrigin = planeOrigin,
|
|
FrustumPlanes = VegetationStudioCameraList[i].JobCullingGroup.FrustumPlanes,
|
|
CameraPosition = VegetationStudioCameraList[i].SelectedCamera.transform.position,
|
|
NoFrustumCulling = VegetationStudioCameraList[i].CameraCullingMode ==
|
|
CameraCullingMode.Complete360,
|
|
CullDistance = vegetationItemCullDistance,
|
|
LOD1Distance = vegetationItemModelInfo.LOD1Distance,
|
|
LOD2Distance = vegetationItemModelInfo.LOD2Distance,
|
|
LOD3Distance = vegetationItemModelInfo.LOD3Distance,
|
|
LODFactor = vegetationItemModelInfo.VegetationItemInfo.LODFactor,
|
|
LODBias = lodBias,
|
|
LODCount = vegetationItemModelInfo.LODCount,
|
|
LODFadeDistance = crossFadeDistance,
|
|
LODFadePercentage = vegetationItemModelInfo.LODFadePercentage,
|
|
LODFadeCrossfade = vegetationItemModelInfo.LODFadeCrossfade,
|
|
FloatingOriginOffset = FloatingOriginOffset
|
|
};
|
|
|
|
vegetationItemMergeJobHandle = lodJob.Schedule(vegetationItemMergeJobHandle);
|
|
VegetationCellSpawner.CellJobHandleList.Add(vegetationItemMergeJobHandle);
|
|
|
|
//#if UNITY_EDITOR
|
|
// if (JobsUtility.JobDebuggerEnabled) vegetationItemMergeJobHandle.Complete();
|
|
//#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
Profiler.EndSample();
|
|
|
|
if (VegetationCellSpawner.CellJobHandleList.Length > 0)
|
|
{
|
|
_prepareVegetationHandle = JobHandle.CombineDependencies(VegetationCellSpawner.CellJobHandleList);
|
|
}
|
|
|
|
JobHandle.ScheduleBatchedJobs();
|
|
|
|
//TODO add merge vegetation instances for buillboards here
|
|
}
|
|
|
|
void SetShadowMapVariables()
|
|
{
|
|
if (SunDirectionalLight)
|
|
{
|
|
Vector3 sundirection = -SunDirectionalLight.transform.forward * 2.5f;
|
|
Vector4 gVsSunDirection = new Vector4(sundirection.x, sundirection.y, sundirection.z,
|
|
SunDirectionalLight.intensity);
|
|
Shader.SetGlobalVector("gVSSunDirection", gVsSunDirection);
|
|
Shader.SetGlobalVector("gVSSunSettings",
|
|
new Vector4(SunDirectionalLight.shadowStrength, SunDirectionalLight.shadowBias, 0, 0));
|
|
}
|
|
else
|
|
{
|
|
Shader.SetGlobalVector("gVSSunDirection", Vector4.zero);
|
|
Shader.SetGlobalVector("gVSSunSettings", new Vector4(0, 0, 0, 0));
|
|
}
|
|
}
|
|
|
|
void InitGlobalShaderProperties()
|
|
{
|
|
float minVegetationDistance = Mathf.Clamp(VegetationSettings.GetVegetationDistance(), 20,
|
|
VegetationSettings.GetVegetationDistance() - 20);
|
|
Shader.SetGlobalVector("_VSGrassFade", new Vector4(minVegetationDistance, 20, 0, 0));
|
|
Shader.SetGlobalVector("_VSShadowMapFadeScale", new Vector4(QualitySettings.shadowDistance - 30, 20, 1, 1));
|
|
}
|
|
|
|
|
|
// ReSharper disable once UnusedMember.Local
|
|
void LateUpdate()
|
|
{
|
|
if (!InitDone) return;
|
|
UpdateWind();
|
|
SetShadowMapVariables();
|
|
InitGlobalShaderProperties();
|
|
|
|
Profiler.BeginSample("Complete spawning jobs");
|
|
_prepareVegetationHandle.Complete();
|
|
Profiler.EndSample();
|
|
|
|
VerifySplatmapAccess();
|
|
|
|
LoadBillboardCells();
|
|
RenderBillboardCells();
|
|
|
|
JobHandle prepareInstancedIndirectHandle = default(JobHandle);
|
|
|
|
bool useInstancedIndirect = VegetationRenderSettings.UseInstancedIndirect();
|
|
if (Application.isPlaying && useInstancedIndirect)
|
|
{
|
|
prepareInstancedIndirectHandle = PrepareInstancedIndirectSetupJobs();
|
|
}
|
|
|
|
RenderInstancedVegetation();
|
|
|
|
if (Application.isPlaying && useInstancedIndirect)
|
|
{
|
|
prepareInstancedIndirectHandle.Complete();
|
|
SetupInstancedIndirectComputeBuffers();
|
|
RenderInstancedIndirectVegetation();
|
|
}
|
|
|
|
DisposeTemporaryTerrainMemory();
|
|
ReturnVegetationCellTemporaryMemory();
|
|
|
|
if (UseCacheCompacter)
|
|
{
|
|
CompactCache();
|
|
}
|
|
|
|
OnRenderCompleteDelegate?.Invoke(this);
|
|
}
|
|
|
|
JobHandle PrepareInstancedIndirectSetupJobs()
|
|
{
|
|
VegetationCellSpawner.CellJobHandleList.Clear();
|
|
|
|
for (int i = 0; i <= ProcessInstancedIndirectCellList.Count - 1; i++)
|
|
{
|
|
VegetationCell vegetationCell = ProcessInstancedIndirectCellList[i];
|
|
for (int j = 0; j <= vegetationCell.VegetationPackageInstancesList.Count - 1; j++)
|
|
{
|
|
for (int k = 0;
|
|
k <= vegetationCell.VegetationPackageInstancesList[j].VegetationItemMatrixList.Count - 1;
|
|
k++)
|
|
{
|
|
VegetationItemInfoPro vegetationItemInfoPro = VegetationPackageProList[j].VegetationInfoList[k];
|
|
IndirectInstanceInfo indirectInstanceInfo = vegetationCell.VegetationPackageInstancesList[j]
|
|
.VegetationItemInstancedIndirectInstanceList[k];
|
|
|
|
VegetationItemModelInfo vegetationItemModelInfo =
|
|
VegetationPackageProModelsList[j].VegetationItemModelList[k];
|
|
|
|
bool hasTreesLoaded = vegetationCell.LoadedBillboards && vegetationItemInfoPro.UseBillboards &&
|
|
vegetationItemInfoPro.VegetationType == VegetationType.Tree;
|
|
if (vegetationItemModelInfo.DistanceBand < vegetationCell.LoadedDistanceBand &&
|
|
!hasTreesLoaded) continue;
|
|
|
|
if (vegetationItemInfoPro.VegetationRenderMode == VegetationRenderMode.InstancedIndirect &&
|
|
!indirectInstanceInfo.Created)
|
|
{
|
|
NativeArray<MatrixInstance> vegetationItemMatrixList =
|
|
vegetationCell.VegetationPackageInstancesList[j].VegetationItemMatrixList[k];
|
|
|
|
indirectInstanceInfo.InstancedIndirectInstanceList =
|
|
new NativeArray<InstancedIndirectInstance>(vegetationItemMatrixList.Length,
|
|
Allocator.Persistent);
|
|
indirectInstanceInfo.Created = true;
|
|
|
|
CreateInstancedIndirectInstancesJob createInstancedIndirectInstancesJob =
|
|
new CreateInstancedIndirectInstancesJob
|
|
{
|
|
InstanceList = vegetationItemMatrixList,
|
|
IndirectInstanceList = indirectInstanceInfo.InstancedIndirectInstanceList
|
|
};
|
|
JobHandle handle = createInstancedIndirectInstancesJob.Schedule(
|
|
indirectInstanceInfo.InstancedIndirectInstanceList.Length, 32);
|
|
VegetationCellSpawner.CellJobHandleList.Add(handle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
JobHandle processHandle = JobHandle.CombineDependencies(VegetationCellSpawner.CellJobHandleList);
|
|
VegetationCellSpawner.CellJobHandleList.Clear();
|
|
JobHandle.ScheduleBatchedJobs();
|
|
return processHandle;
|
|
}
|
|
|
|
void SetupInstancedIndirectComputeBuffers()
|
|
{
|
|
bool useInstancedIndirect = VegetationRenderSettings.UseInstancedIndirect();
|
|
if (!useInstancedIndirect) return;
|
|
|
|
Profiler.BeginSample("Update compute buffers");
|
|
for (int i = 0; i <= ProcessInstancedIndirectCellList.Count - 1; i++)
|
|
{
|
|
VegetationCell vegetationCell = ProcessInstancedIndirectCellList[i];
|
|
for (int j = 0; j <= vegetationCell.VegetationPackageInstancesList.Count - 1; j++)
|
|
{
|
|
for (int k = 0;
|
|
k <= vegetationCell.VegetationPackageInstancesList[j].VegetationItemMatrixList.Count - 1;
|
|
k++)
|
|
{
|
|
VegetationItemInfoPro vegetationItemInfoPro = VegetationPackageProList[j].VegetationInfoList[k];
|
|
IndirectInstanceInfo indirectInstanceInfo = vegetationCell.VegetationPackageInstancesList[j]
|
|
.VegetationItemInstancedIndirectInstanceList[k];
|
|
ComputeBufferInfo computeBufferInfo = vegetationCell.VegetationPackageInstancesList[j]
|
|
.VegetationItemComputeBufferList[k];
|
|
|
|
VegetationItemModelInfo vegetationItemModelInfo =
|
|
VegetationPackageProModelsList[j].VegetationItemModelList[k];
|
|
|
|
//if (vegetationItemModelInfo.DistanceBand < vegetationCell.LoadedDistanceBand) continue;
|
|
bool hasTreesLoaded = vegetationCell.LoadedBillboards && vegetationItemInfoPro.UseBillboards &&
|
|
vegetationItemInfoPro.VegetationType == VegetationType.Tree;
|
|
if (vegetationItemModelInfo.DistanceBand < vegetationCell.LoadedDistanceBand &&
|
|
!hasTreesLoaded) continue;
|
|
|
|
if (vegetationItemInfoPro.VegetationRenderMode == VegetationRenderMode.InstancedIndirect &&
|
|
!computeBufferInfo.Created)
|
|
{
|
|
int length = indirectInstanceInfo.InstancedIndirectInstanceList.Length;
|
|
if (length == 0) length = 1;
|
|
|
|
//TODO handle 0 length cells better
|
|
|
|
computeBufferInfo.ComputeBuffer = new ComputeBuffer(length, 16 * 4 + 4 * 4); //*2
|
|
computeBufferInfo.ComputeBuffer.SetData(indirectInstanceInfo.InstancedIndirectInstanceList);
|
|
computeBufferInfo.Created = true;
|
|
//TODO clear indirectInstanceInfo.InstancedIndirectInstanceList; //might be needed if unity clears buffers
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ProcessInstancedIndirectCellList.Clear();
|
|
Profiler.EndSample();
|
|
}
|
|
|
|
void RenderInstancedIndirectVegetation()
|
|
{
|
|
DrawCellsIndirectComputeShader();
|
|
}
|
|
|
|
void DisposeTemporaryTerrainMemory()
|
|
{
|
|
for (int i = 0; i <= VegetationStudioTerrainList.Count - 1; i++)
|
|
{
|
|
VegetationStudioTerrainList[i].DisposeTemporaryMemory();
|
|
}
|
|
}
|
|
|
|
//public List<Matrix4x4> RenderList = new List<Matrix4x4>();
|
|
|
|
|
|
// private readonly byte[] _renderbyteArray = new byte[1000 * 16 * 4];
|
|
// private readonly byte[] _renderbyteLodFadeArray = new byte[1000 * 4 * 4];
|
|
|
|
void RenderInstancedVegetation()
|
|
{
|
|
Profiler.BeginSample("Draw instanced vegetation");
|
|
bool isPlaying = Application.isPlaying;
|
|
|
|
for (int i = 0; i <= VegetationStudioCameraList.Count - 1; i++)
|
|
{
|
|
if (!VegetationStudioCameraList[i].Enabled) continue;
|
|
if (VegetationStudioCameraList[i].RenderBillboardsOnly) continue;
|
|
|
|
var targetCamera = VegetationStudioCameraList[i].RenderDirectToCamera
|
|
? VegetationStudioCameraList[i].SelectedCamera
|
|
: null;
|
|
|
|
if (!Application.isPlaying) targetCamera = null;
|
|
|
|
for (int j = 0; j <= VegetationPackageProList.Count - 1; j++)
|
|
{
|
|
for (int k = 0; k <= VegetationPackageProList[j].VegetationInfoList.Count - 1; k++)
|
|
{
|
|
VegetationItemInfoPro vegetationItemInfoPro = VegetationPackageProList[j].VegetationInfoList[k];
|
|
bool useInstancedIndirect = VegetationRenderSettings.UseInstancedIndirect();
|
|
if (useInstancedIndirect && vegetationItemInfoPro.VegetationRenderMode ==
|
|
VegetationRenderMode.InstancedIndirect) continue;
|
|
//if (isPlaying && vegetationItemInfoPro.VegetationRenderMode == VegetationRenderMode.InstancedIndirect) continue;
|
|
//if (!vegetationItemInfoPro.EnableRuntimeSpawn) continue;
|
|
|
|
ShadowCastingMode shadowCastingMode =
|
|
VegetationSettings.GetShadowCastingMode(vegetationItemInfoPro.VegetationType);
|
|
|
|
if (vegetationItemInfoPro.DisableShadows)
|
|
{
|
|
shadowCastingMode = ShadowCastingMode.Off;
|
|
}
|
|
|
|
LayerMask layer = VegetationSettings.GetLayer(vegetationItemInfoPro.VegetationType);
|
|
|
|
VegetationItemModelInfo vegetationItemModelInfo =
|
|
VegetationPackageProModelsList[j].VegetationItemModelList[k];
|
|
|
|
NativeList<Matrix4x4> lod0MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD0MatrixList[k];
|
|
NativeList<Matrix4x4> lod1MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD1MatrixList[k];
|
|
NativeList<Matrix4x4> lod2MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD2MatrixList[k];
|
|
NativeList<Matrix4x4> lod3MatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD3MatrixList[k];
|
|
|
|
NativeList<Vector4> lod0Fadeist = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD0LodFadeList[k];
|
|
NativeList<Vector4> lod1Fadeist = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD1LodFadeList[k];
|
|
NativeList<Vector4> lod2Fadeist = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD2LodFadeList[k];
|
|
NativeList<Vector4> lod3Fadeist = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD3LodFadeList[k];
|
|
|
|
if (vegetationItemInfoPro.VegetationRenderMode == VegetationRenderMode.Normal)
|
|
{
|
|
RenderVegetationItemLODDrawMesh(lod0MatrixList, lod0Fadeist, vegetationItemModelInfo, 0,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
RenderVegetationItemLODDrawMesh(lod1MatrixList, lod1Fadeist, vegetationItemModelInfo, 1,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
RenderVegetationItemLODDrawMesh(lod2MatrixList, lod2Fadeist, vegetationItemModelInfo, 2,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
RenderVegetationItemLODDrawMesh(lod3MatrixList, lod3Fadeist, vegetationItemModelInfo, 3,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
}
|
|
else
|
|
{
|
|
RenderVegetationItemLOD(lod0MatrixList, lod0Fadeist, vegetationItemModelInfo, 0,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
RenderVegetationItemLOD(lod1MatrixList, lod1Fadeist, vegetationItemModelInfo, 1,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
RenderVegetationItemLOD(lod2MatrixList, lod2Fadeist, vegetationItemModelInfo, 2,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
RenderVegetationItemLOD(lod3MatrixList, lod3Fadeist, vegetationItemModelInfo, 3,
|
|
targetCamera, i, shadowCastingMode, layer);
|
|
}
|
|
|
|
if (shadowCastingMode == ShadowCastingMode.On)
|
|
{
|
|
NativeList<Matrix4x4> lod0ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD0ShadowMatrixList[k];
|
|
NativeList<Matrix4x4> lod1ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD1ShadowMatrixList[k];
|
|
NativeList<Matrix4x4> lod2ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD2ShadowMatrixList[k];
|
|
NativeList<Matrix4x4> lod3ShadowMatrixList = VegetationStudioCameraList[i]
|
|
.VegetationStudioCameraRenderList[j].VegetationItemLOD3ShadowMatrixList[k];
|
|
|
|
if (vegetationItemInfoPro.VegetationRenderMode == VegetationRenderMode.Normal)
|
|
{
|
|
RenderVegetationItemLODDrawMesh(lod0ShadowMatrixList, lod0Fadeist,
|
|
vegetationItemModelInfo, 0, targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
RenderVegetationItemLODDrawMesh(lod1ShadowMatrixList, lod1Fadeist,
|
|
vegetationItemModelInfo, 1, targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
RenderVegetationItemLODDrawMesh(lod2ShadowMatrixList, lod2Fadeist,
|
|
vegetationItemModelInfo, 2, targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
RenderVegetationItemLODDrawMesh(lod3ShadowMatrixList, lod3Fadeist,
|
|
vegetationItemModelInfo, 3, targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
}
|
|
else
|
|
{
|
|
RenderVegetationItemLOD(lod0ShadowMatrixList, lod0Fadeist, vegetationItemModelInfo, 0,
|
|
targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
RenderVegetationItemLOD(lod1ShadowMatrixList, lod1Fadeist, vegetationItemModelInfo, 1,
|
|
targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
RenderVegetationItemLOD(lod2ShadowMatrixList, lod2Fadeist, vegetationItemModelInfo, 2,
|
|
targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
RenderVegetationItemLOD(lod3ShadowMatrixList, lod3Fadeist, vegetationItemModelInfo, 3,
|
|
targetCamera, i, ShadowCastingMode.ShadowsOnly, layer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Profiler.EndSample();
|
|
}
|
|
|
|
|
|
void SetupInstancedRenderMaterialPropertiesIDs()
|
|
{
|
|
_unityLODFadeID = Shader.PropertyToID("unity_LODFade");
|
|
}
|
|
|
|
|
|
//float[] _singleFloatArray = new float[1];
|
|
void RenderVegetationItemLODDrawMesh(NativeList<Matrix4x4> matrixList, NativeList<Vector4> lodFadeList,
|
|
VegetationItemModelInfo vegetationItemModelInfo, int lodIndex, Camera targetCamera, int cameraIndex,
|
|
ShadowCastingMode shadowCastingMode, LayerMask layer)
|
|
{
|
|
if (matrixList.Length == 0) return;
|
|
if (lodIndex >= vegetationItemModelInfo.LODCount) return;
|
|
|
|
Mesh mesh = vegetationItemModelInfo.GetLODMesh(lodIndex);
|
|
Material[] materials = vegetationItemModelInfo.GetLODMaterials(lodIndex);
|
|
|
|
MaterialPropertyBlock materialPropertyBlock = vegetationItemModelInfo.GetLODMaterialPropertyBlock(lodIndex);
|
|
materialPropertyBlock.Clear();
|
|
|
|
|
|
if (vegetationItemModelInfo.ShaderControler != null &&
|
|
vegetationItemModelInfo.ShaderControler.Settings.SampleWind)
|
|
{
|
|
MeshRenderer meshRenderer = vegetationItemModelInfo.WindSamplerMeshRendererList[cameraIndex];
|
|
if (meshRenderer)
|
|
{
|
|
meshRenderer.GetPropertyBlock(materialPropertyBlock);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i <= matrixList.Length - 1; i++)
|
|
{
|
|
int submeshesToRender = Mathf.Min(mesh.subMeshCount, materials.Length);
|
|
for (int m = 0; m <= submeshesToRender - 1; m++)
|
|
{
|
|
Graphics.DrawMesh(mesh, matrixList[i], materials[m], layer, targetCamera, m, materialPropertyBlock,
|
|
shadowCastingMode, true, null, LightProbeUsage.Off);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderVegetationItemLOD(NativeList<Matrix4x4> matrixList, NativeList<Vector4> lodFadeList,
|
|
VegetationItemModelInfo vegetationItemModelInfo, int lodIndex, Camera targetCamera, int cameraIndex,
|
|
ShadowCastingMode shadowCastingMode, LayerMask layer)
|
|
{
|
|
if (matrixList.Length == 0) return;
|
|
if (lodIndex >= vegetationItemModelInfo.LODCount) return;
|
|
|
|
//bool uniqueMaterialPropertyBlock = matrixList.Length > 999;
|
|
|
|
int count = Mathf.CeilToInt(matrixList.Length / 1000f);
|
|
// count = Mathf.Clamp(count, 0, 1);
|
|
int totalCount = matrixList.Length;
|
|
for (int l = 0; l <= count - 1; l++)
|
|
{
|
|
int copyCount = 1000;
|
|
if (totalCount < 1000) copyCount = totalCount;
|
|
|
|
NativeSlice<Matrix4x4> matrixSlice = new NativeSlice<Matrix4x4>(matrixList, l * 1000, copyCount);
|
|
matrixSlice.CopyToFast(_renderArray);
|
|
|
|
Mesh mesh = vegetationItemModelInfo.GetLODMesh(lodIndex);
|
|
Material[] materials = vegetationItemModelInfo.GetLODMaterials(lodIndex);
|
|
|
|
MaterialPropertyBlock materialPropertyBlock =
|
|
vegetationItemModelInfo.GetLODMaterialPropertyBlock(lodIndex);
|
|
materialPropertyBlock.Clear();
|
|
|
|
if (vegetationItemModelInfo.ShaderControler != null &&
|
|
vegetationItemModelInfo.ShaderControler.Settings.SampleWind)
|
|
{
|
|
MeshRenderer meshRenderer = vegetationItemModelInfo.WindSamplerMeshRendererList[cameraIndex];
|
|
if (meshRenderer)
|
|
{
|
|
meshRenderer.GetPropertyBlock(materialPropertyBlock);
|
|
}
|
|
}
|
|
|
|
if (shadowCastingMode != ShadowCastingMode.ShadowsOnly)
|
|
{
|
|
if (lodFadeList.Length == matrixList.Length)
|
|
{
|
|
NativeSlice<Vector4> lodFadeSlice = new NativeSlice<Vector4>(lodFadeList, l * 1000, copyCount);
|
|
lodFadeSlice.CopyToFast(_renderLodFadeArray);
|
|
materialPropertyBlock.SetVectorArray(_unityLODFadeID, _renderLodFadeArray);
|
|
}
|
|
}
|
|
|
|
if (VegetationRenderSettings.EnableInstancedRenderingLayers)
|
|
{
|
|
materialPropertyBlock.SetFloatArray(UnityRenderingLayerID, _renderingLayerArray);
|
|
}
|
|
|
|
int submeshesToRender = Mathf.Min(mesh.subMeshCount, materials.Length);
|
|
for (int m = 0; m <= submeshesToRender - 1; m++)
|
|
{
|
|
Graphics.DrawMeshInstanced(mesh, m,
|
|
materials[m], _renderArray, copyCount,
|
|
materialPropertyBlock, shadowCastingMode, true, layer,
|
|
targetCamera,
|
|
LightProbeUsage.Off);
|
|
}
|
|
|
|
totalCount -= 1000;
|
|
}
|
|
}
|
|
|
|
// ReSharper disable once UnusedMember.Local
|
|
void OnDisable()
|
|
{
|
|
VegetationStudioManager.UnregisterVegetationSystem(this);
|
|
DisableEditorApi();
|
|
DisposeVegetationStudioCameras();
|
|
RemoveVegetationStudioCameraDelegates();
|
|
DisposeVegetationCells();
|
|
DisposeBillboardCells();
|
|
ClearVegetationItemModels();
|
|
DisposeComputeShaders();
|
|
VegetationCellSpawner.Dispose();
|
|
InitDone = false;
|
|
}
|
|
}
|
|
} |