//void OnVegetationCellClearCache(VegetationCell vegetationCell)
//{
// List<BillboardCell> overlappingBillboards = BillboardCellQuadTree.Query(vegetationCell.Rectangle);
// for (var i = 0; i <= overlappingBillboards.Count - 1; i++)
// {
// if (overlappingBillboards[i].HasBillboards)
// {
// overlappingBillboards[i].ClearMeshes();
// }
// }
//}
private void GetVegetationSystem()
{
if (VegetationSystem == null)
{
VegetationSystem = gameObject.GetComponent <VegetationSystem>();
}
}
//Prepare
public void CheckAddComponent(Chunk chunk)
{
#if VEGETATION_STUDIO
Profiler.BeginSample("VS Prepare");
//adding the main vegetation object
VegetationStudioManager.AddVegetationStudioManagerToScene();
//checking if all packs for all of the generators are the same
if (packageShared == null)
{
packageShared = package;
}
else
{
package = packageShared;
}
//finding/creating vegetation system component
VegetationSystem vetSys = chunk.terrain.gameObject.GetComponentInChildren <VegetationSystem>();
if (vetSys == null)
{
vetSys = VegetationStudioManager.AddVegetationSystemToTerrain(chunk.terrain, package, createPersistentVegetationStoragePackage: true);
}
if (vetSys.VegetationPackageList.Count == 0)
{
vetSys.VegetationPackageList.Add(package);
}
if (vetSys.VegetationPackageList.Count == 1 && vetSys.VegetationPackageList[0] == null)
{
vetSys.VegetationPackageList[0] = package;
}
if (!vetSys.VegetationPackageList.Contains(package))
{
vetSys.VegetationPackageList.Add(package);
}
if (!vetSys.InitDone)
{
vetSys.SetupVegetationSystem();
vetSys.RefreshVegetationPackage();
}
cellSize = vetSys.CellSize;
//saving per-chunk storage (to access it from thread)
PersistentVegetationStorage storage = vetSys.gameObject.GetComponent <PersistentVegetationStorage>();
if (!vetStorComponents.ContainsKey(chunk.rect))
{
vetStorComponents.Add(chunk.rect, null);
}
vetStorComponents[chunk.rect] = storage;
Profiler.EndSample();
#endif
}
public VegetationSystem CopyVegetationSystem(GameObject srcGameObj, Terrain terrain)
{
GameObject vegetationSystemObject = GameObject.Instantiate(srcGameObj);
vegetationSystemObject.transform.SetParent(terrain.transform);
VegetationSystem vegetationSystem = vegetationSystemObject.GetComponent <VegetationSystem>();
if (vegetationSystem == null)
{
vegetationSystem = vegetationSystemObject.AddComponent <VegetationSystem>();
}
if (package != null)
{
vegetationSystem.AddVegetationPackage(package, true);
}
if (vegetationSystemObject.GetComponent <TerrainSystem>() == null)
{
vegetationSystemObject.AddComponent <TerrainSystem>();
}
BillboardSystem billboardSystem = vegetationSystemObject.GetComponent <BillboardSystem>();
if (billboardSystem == null)
{
billboardSystem = vegetationSystemObject.AddComponent <BillboardSystem>();
}
billboardSystem.VegetationSystem = vegetationSystem;
PersistentVegetationStorage srcStorage = vegetationSystemObject.GetComponent <PersistentVegetationStorage>();
if (srcStorage != null)
{
GameObject.DestroyImmediate(srcStorage);
}
PersistentVegetationStorage persistentVegetationStorage = vegetationSystemObject.AddComponent <PersistentVegetationStorage>();
persistentVegetationStorage.VegetationSystem = vegetationSystem;
vegetationSystem.AutoselectTerrain = false;
vegetationSystem.currentTerrain = terrain;
//vegetationSystem.AutomaticWakeup = true;
PersistentVegetationStoragePackage persistentVegetationStoragePackage = ScriptableObject.CreateInstance <PersistentVegetationStoragePackage>();
persistentVegetationStorage.PersistentVegetationStoragePackage = persistentVegetationStoragePackage;
persistentVegetationStorage.AutoInitPersistentVegetationStoragePackage = true;
vegetationSystem.SetSleepMode(false);
return(vegetationSystem);
}
void DoAddPersistentStorage(VegetationSystem _vegetationSystem)
{
_vegetationSystem.AutomaticWakeup = true;
// NB seems redundant to recurse into parent object - but this is needed to get the terrain name
GameObject parentTerrainGo = _vegetationSystem.gameObject.transform.parent.gameObject;
PersistentVegetationStorage _persistentVegetationStorage = parentTerrainGo.GetComponentInChildren <PersistentVegetationStorage>();
PersistentVegetationStoragePackage newPersistentVegetationStoragePackage = ScriptableObject.CreateInstance <PersistentVegetationStoragePackage>();
AssetDatabase.CreateAsset(newPersistentVegetationStoragePackage, _assetsPath + "/" + parentTerrainGo.name + _DEFAULT_SUFFIX + ".asset");
_persistentVegetationStorage.PersistentVegetationStoragePackage = newPersistentVegetationStoragePackage;
// initialize
_persistentVegetationStorage.InitializePersistentStorage();
if (_debugToLog)
{
Debug.Log("Added storage asset for " + parentTerrainGo.name);
}
if (_autoBake)
{
if (_debugToLog)
{
Debug.Log("Auto Baking " + parentTerrainGo.name);
}
//if (_vegetationSystem.GetSleepMode())
//{
_vegetationSystem.SetSleepMode(false); // wake up VegetationSystem, needed for prefab
//}
// now bake
List <string> vegetationItemIdList =
VegetationPackageEditorTools.CreateVegetationInfoIdList(_persistentVegetationStorage.VegetationSystem.CurrentVegetationPackage);
for (int i = 0; i <= vegetationItemIdList.Count - 1; i++)
{
_persistentVegetationStorage.BakeVegetationItem(vegetationItemIdList[i]);
}
_persistentVegetationStorage.VegetationSystem.DelayedClearVegetationCellCache();
EditorUtility.SetDirty(_persistentVegetationStorage.PersistentVegetationStoragePackage);
EditorUtility.SetDirty(_persistentVegetationStorage.VegetationSystem.CurrentVegetationPackage);
if (_debugToLog)
{
Debug.Log("Finished Baking for " + parentTerrainGo.name);
}
}
}
public void AssignTerrainToFreeVS(Terrain terrain)
{
if (useDebug)
{
Debug.Log("<b>Starting trying</b> to AssignTerrainToFreeVS() on " + shortenTerrainName(terrain.name));
}
//VegetationSystem targetVS = existingVS.Find(x => x.currentTerrain == null);
VegetationSystem targetVS = null;
for (int i = 0; i < existingVS.Count; i++)
{
if (existingVS[i].currentTerrain == null)
{
if (useDebug)
{
Debug.Log(shortenTerrainName(terrain.name) + " > i=" + i.ToString() + ". <color=green>VS System" + existingVS[i].name + " has currentTerrain as NULL</color>");
}
targetVS = existingVS[i];
break;
}
else
{
if (useDebug)
{
Debug.Log(shortenTerrainName(terrain.name) + " " + i.ToString() + ". <color=red>VS System: " + existingVS[i].name + " has currentTerrain " + existingVS[i].currentTerrain.name + "</color>");
}
}
}
if (targetVS != null)
{
var storagePackage = persistentStorageBundle.LoadAsset <PersistentVegetationStoragePackage> (persistentStorageAssetPrefix + terrain.name + persistentStorageAssetSuffix + ".asset");
if (useDebug)
{
Debug.Log("<color=green>Adding PersistentVSPackage to terrain: " + shortenTerrainName(terrain.name) + "</color>");
}
AssignTerrainToVS(terrain, targetVS, vsPackage, storagePackage);
}
else
{
if (useDebug)
{
Debug.Log("<color=red>targetVS is null</color> on terrain: " + shortenTerrainName(terrain.name) + " _<b>can't assign</b>");
}
}
}
public static void SetupTerrain(Terrain terrain, ref VegetationPackage package, out VegetationSystem system, out PersistentVegetationStorage storage)
{
var vetSystems = GetVegetationSystemsForTerrain(terrain);
VegetationSystem vetSys = null;
for (var i = 0; i < vetSystems.Count; ++i)
{
var candidate = vetSystems[i];
if (candidate.CurrentVegetationPackage == package)
{
vetSys = candidate;
break;
}
}
if (vetSys == null)
{
vetSys = VegetationStudioManager.AddVegetationSystemToTerrain(terrain, package, createPersistentVegetationStoragePackage: true);
}
if (package != null)
{
if (vetSys.VegetationPackageList.Count == 0)
{
vetSys.VegetationPackageList.Add(package);
}
if (vetSys.VegetationPackageList.Count == 1 && vetSys.VegetationPackageList[0] == null)
{
vetSys.VegetationPackageList[0] = package;
}
if (!vetSys.VegetationPackageList.Contains(package))
{
vetSys.VegetationPackageList.Add(package);
}
}
if (!vetSys.InitDone)
{
vetSys.SetupVegetationSystem();
vetSys.RefreshVegetationPackage();
}
vetSys.SetSleepMode(false);
package = vetSys.CurrentVegetationPackage;
system = vetSys;
storage = vetSys.GetComponent <PersistentVegetationStorage>();
}
void AssignTerrainToVS(Terrain terrain, VegetationSystem vs, VegetationPackage vegetationPackage, PersistentVegetationStoragePackage storagePackage)
{
vs.AutoselectTerrain = false;
vs.CurrentVegetationPackage = vegetationPackage;
PersistentVegetationStorage storage = vs.GetComponent <PersistentVegetationStorage>();
if (storage != null)
{
storage.SetPersistentVegetationStoragePackage(storagePackage);
}
if (vs.InitDone)
{
vs.HotswapTerrain(terrain, new UnityTerrainData(terrain));
}
else
{
vs.SetTerrain(terrain);
}
}
// ReSharper disable once UnusedMember.Local
void OnEnable()
{
VegetationSystem = gameObject.GetComponent <VegetationSystem>();
if (VegetationSystem)
{
VegetationSystem.OnVegetationCellVisibleDelegate += OnVegetationCellVisible;
VegetationSystem.OnVegetationCellInvisibleDelegate += OnVegetationInvisible;
VegetationSystem.OnResetVisibleCellListDelegate += OnResetVisibleCellList;
VegetationSystem.OnVegetationCellChangeDistanceBandDelegate += OnVegetationCellChangeDistanceBand;
VegetationSystem.OnSetVegetationPackageDelegate += OnSetVegetationPackage;
}
_vegetationCellColliderList = new List <VegetationCellCollider>();
if (!ColliderParent)
{
CreateColliderParent();
}
RefreshColliders();
}
public static IEnumerator Apply(CoordRect rect, Terrain terrain, object dataBox, Func <float, bool> stop = null)
{
Profiler.BeginSample("VS Apply");
#if VEGETATION_STUDIO
//clear cache
VegetationSystem vetSys = terrain.gameObject.GetComponentInChildren <VegetationSystem>();
for (int i = 0; i < vetSys.VegetationCellList.Count; i++)
{
vetSys.VegetationCellList[i].ClearCache();
}
vetSys.UnityTerrainData = new UnityTerrainData(terrain, false, false);
//refresh billboards
BillboardSystem billboardSystem = vetSys.GetComponent <BillboardSystem>();
billboardSystem.RefreshBillboards();
Profiler.EndSample();
#endif
yield return(null);
}
//v1 just deletes all and rebakes
//void ReBakeAllStorage()
//{
// ClearAllVegetationSystems();
// if (_usePrefab)
// {
// SetupFromPrefab();
// }
// else
// {
// SetupFromVegetationPackage();
// }
//}
void AddAdditionalPackage()
{
// do a rebake of existing persistent storage packages.
// Not quite working as expected - adds additional VegetationPackages to the VegetationSystem component, rather than replacing the existing one
// Also, buggy?... seems to work first time but not on subsequent rebakes (baked storage ends up empty).
// take care of storage (path)
_assetsPath = RemoveTrailingSlash(_assetsPath); // ensures that there isn't an ending slash
if (!AssetDatabase.IsValidFolder(_assetsPath))
{
if (_debugToLog)
{
Debug.Log("Asset path is invalid. Creating your folders");
}
CreateAssetFolders();
}
ClearAllStorageInPath();
if (_vegetationPackage == null)
{
Debug.LogWarning("You need to assign a vegetation package");
EditorUtility.DisplayDialog("No Vegetation Package",
"You need to drag and drop a vegetation package into the utility window", "OK");
return;
}
if (_forceItemsEnabled) // Make sure all Vegetation is enabled on Vegetation Package
{
SetAllItemsToRuntimeSpawn();
}
var terrains = _rootObject ? _rootObject.GetComponentsInChildren <Terrain>() : GameObject.FindObjectsOfType <Terrain>();
int totalNum = terrains.Length;
int counter = 0;
foreach (Terrain terrain in terrains)
{
counter++;
if (_addPersistentStorage)
{
// first check if a Vegetation System already exists
VegetationSystem _vegetationSystem = terrain.gameObject.GetComponentInChildren <VegetationSystem>();
if (_vegetationSystem == null)
{ // add if not already there
_vegetationSystem = VegetationStudioManager.AddVegetationSystemToTerrain(terrain, _vegetationPackage, true);
if (_debugToLog)
{
Debug.Log("Rebaking: Added missing VS to " + terrain.name + " (" + counter + " of " + totalNum + ")");
}
}
else
{
if (_debugToLog)
{
Debug.Log("Rebaking VS already existed on " + terrain.name + " (" + counter + " of " + totalNum + ")");
}
_vegetationSystem.AddVegetationPackage(_vegetationPackage, true);
}
if (_debugToLog)
{
Debug.Log("Adding Persistent Storage " + terrain.name + " (" + counter + " of " + totalNum + ")");
}
DoAddPersistentStorage(_vegetationSystem);
}
else
{
// just add a Vegetation System
VegetationStudioManager.AddVegetationSystemToTerrain(terrain, _vegetationPackage);
}
}
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
}
void SetupFromPrefab()
{
_assetsPath = RemoveTrailingSlash(_assetsPath); // ensures that there isn't an ending slash
if (!AssetDatabase.IsValidFolder(_assetsPath))
{
if (_debugToLog)
{
Debug.Log("Asset path is invalid. Creating your folders");
}
CreateAssetFolders();
}
if (_forceItemsEnabled) // Make sure all Vegetation is enabled on Vegetation Package
{
_vegetationPackage = _vegetationSystemPrefab.GetComponent <VegetationSystem>().CurrentVegetationPackage;
SetAllItemsToRuntimeSpawn();
}
if (_autoBake) // if going to rebake then delete any existing packages
{
ClearAllStorageInPath();
}
var terrains = _rootObject ? _rootObject.GetComponentsInChildren <Terrain>() : GameObject.FindObjectsOfType <Terrain>();
int totalNum = terrains.Length;
int counter = 0;
foreach (Terrain terrain in terrains)
{
// first check if a Vegetation System already exists
VegetationSystem _vegetationSystem = terrain.gameObject.GetComponentInChildren <VegetationSystem>();
if (_vegetationSystem != null)
{ // add if already there, destroy
DestroyImmediate(_vegetationSystem.gameObject);
}
GameObject vegetationSystemObject = Instantiate(_vegetationSystemPrefab, terrain.gameObject.transform);
VegetationSystem vegetationSystem = vegetationSystemObject.GetComponent <VegetationSystem>();
if (vegetationSystem)
{
vegetationSystem.AutoselectTerrain = false;
vegetationSystem.SetTerrain(terrain);
counter++;
if (_debugToLog)
{
Debug.Log("Added VS Prefab to " + terrain.name + " (" + counter + " of " + totalNum + ")");
}
if (_addPersistentStorage)
{
if (_debugToLog)
{
Debug.Log("Adding Persistent Storage " + terrain.name + " (" + counter + " of " + totalNum + ")");
}
DoAddPersistentStorage(vegetationSystem);
}
}
}
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
}
void SetupFromVegetationPackage()
{
_assetsPath = RemoveTrailingSlash(_assetsPath); // ensures that there isn't an ending slash
if (!AssetDatabase.IsValidFolder(_assetsPath))
{
if (_debugToLog)
{
Debug.Log("Asset path is invalid. Creating your folders");
}
CreateAssetFolders();
}
if (_forceItemsEnabled) // Make sure all Vegetation is enabled on Vegetation Package
{
SetAllItemsToRuntimeSpawn();
}
if (_autoBake) // if going to rebake then delete any existing packages
{
ClearAllStorageInPath();
}
var terrains = _rootObject ? _rootObject.GetComponentsInChildren <Terrain>() : GameObject.FindObjectsOfType <Terrain>();
int totalNum = terrains.Length;
int counter = 0;
foreach (Terrain terrain in terrains)
{
counter++;
if (_addPersistentStorage)
{
if (_debugToLog)
{
Debug.Log("---------------------------------------------------------------");
}
// first check if a Vegetation System already exists
VegetationSystem _vegetationSystem = terrain.gameObject.GetComponentInChildren <VegetationSystem>();
if (_vegetationSystem != null)
{
DestroyImmediate(_vegetationSystem.gameObject);
}
// add
_vegetationSystem = VegetationStudioManager.AddVegetationSystemToTerrain(terrain, _vegetationPackage, true);
if (_debugToLog)
{
Debug.Log("Added VS to " + terrain.name + " (" + counter + " of " + totalNum + ")");
}
if (_debugToLog)
{
Debug.Log("Adding Persistent Storage " + terrain.name + " (" + counter + " of " + totalNum + ")");
}
DoAddPersistentStorage(_vegetationSystem);
}
else
{
VegetationStudioManager.AddVegetationSystemToTerrain(terrain, _vegetationPackage); // just add a Vegetation System
}
}
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
}
