public void SetVegetationItemInstanceInfo(VegetationItemInstanceInfo vegetationItemInstanceInfo)
{
Position = vegetationItemInstanceInfo.Position;
VegetationType = vegetationItemInstanceInfo.VegetationType;
_vegetationItemID = vegetationItemInstanceInfo.VegetationItemID;
_isDirty = true;
}
static bool GetVegetationInfo(
GameObject @object, VegetationLayers layers, out VegetationType type, out Bounds bounds)
{
if (@object)
{
if ((layers.undergrowthLayerMask & (1 << @object.layer)) != 0)
{
type = VegetationType.Undergrowth;
}
else
{
goto bail;
}
var renderer = @object.GetComponentInChildren <Renderer>();
if (!renderer)
{
goto bail;
}
bounds = renderer.bounds;
return(true);
}
bail:
type = VegetationType.None;
bounds = default(Bounds);
return(false);
}
public override void OnActionPerformed(VegetationPackagePro vegetationPackagePro, VegetationItemInfoPro vegetationItemInfoPro)
{
// apply settings
GameObject vegetationPrefab = vegetationItemInfoPro.VegetationPrefab;
VegetationType vegetationType = vegetationItemInfoPro.VegetationType;
// support only grass & plants. doesn't make much sense to have trees and objects use touch react
if (vegetationType != VegetationType.Grass && vegetationType != VegetationType.Plant)
{
Debug.Log("Only Grass & Plant supported. Skipping " + vegetationPrefab.name);
return;
}
// get materials
Material[] vegetationItemMaterials = AwesomeTechnologies.Shaders.ShaderSelector.GetVegetationItemMaterials(vegetationPrefab);
// process items
foreach (Material material in vegetationItemMaterials)
{
if (material.HasProperty(propertyId))
{
Debug.Log("Setting _TouchReactActive of " + vegetationItemInfoPro.Name + ", material: " + material.name + " from " + material.GetFloat(propertyId) + " to " + propertyValue);
material.SetFloat(propertyId, propertyValue);
}
}
}
public void SetVegetationItemInstanceInfo(Vector3 position, VegetationType vegetationType, string vegetationItemID)
{
Position = position;
VegetationType = vegetationType;
_vegetationItemID = vegetationItemID;
_isDirty = true;
}
public bool Query(Bounds bounds, out Vector3 outPosition, out VegetationType outType)
{
if (_octree != null)
{
_results.Clear();
_octree.QueryIntersecting(bounds, _results);
var position = bounds.center;
position.y = bounds.min.y; // foot approximation
float minDistance = Mathf.Infinity;
int index = -1;
for (int i = 0, n = _results.Count; i < n; ++i)
{
var sqrDistance = (_results[i].bounds.ClosestPoint(position) - position).sqrMagnitude;
if (minDistance > sqrDistance)
{
minDistance = sqrDistance;
index = i;
}
}
const float sqrTouchingDistance = 0.01f;
if (index >= 0 && minDistance <= sqrTouchingDistance)
{
outPosition = _results[index].bounds.center;
outType = _results[index].value;
return(true);
}
}
outPosition = Vector3.zero;
outType = VegetationType.None;
return(false);
}
void AddVegetationItemInstanceInfo(GameObject go, Matrix4x4 positionMatrix, VegetationType vegetationType, string vegetationItemID)
{
var vegetationItemInstanceInfo = go.AddComponent <VegetationItemInstanceInfo>();
vegetationItemInstanceInfo.Position = MatrixTools.ExtractTranslationFromMatrix(positionMatrix);
vegetationItemInstanceInfo.VegetationItemInstanceID = Mathf.RoundToInt(vegetationItemInstanceInfo.Position.x * 100f).ToString() + "_" +
Mathf.RoundToInt(vegetationItemInstanceInfo.Position.y * 100f).ToString() + "_" +
Mathf.RoundToInt(vegetationItemInstanceInfo.Position.z * 100f).ToString();
vegetationItemInstanceInfo.Rotation = MatrixTools.ExtractRotationFromMatrix(positionMatrix);
vegetationItemInstanceInfo.Scale = MatrixTools.ExtractScaleFromMatrix(positionMatrix);
vegetationItemInstanceInfo.VegetationType = vegetationType;
vegetationItemInstanceInfo.VegetationItemID = vegetationItemID;
}
/// <summary>
/// Ensure the prefab has a VegetationItemID
/// </summary>
/// <param name="prefabSettings"></param>
private void updateVSProSettings(PrefabSettings prefabSettings, bool forceVegetationItemIDUpdate)
{
#if VEGETATION_STUDIO_PRO
GameObject prefab = prefabSettings.prefab;
// check if we have a VegetationItemID, otherwise create it using the current prefab
if (string.IsNullOrEmpty(prefabSettings.vspro_VegetationItemID) || forceVegetationItemIDUpdate)
{
// get the asset guid
if (string.IsNullOrEmpty(prefabSettings.assetGUID))
{
string assetPath = AssetDatabase.GetAssetPath(prefab);
if (!string.IsNullOrEmpty(assetPath))
{
string assetGUID = AssetDatabase.AssetPathToGUID(assetPath);
prefabSettings.assetGUID = assetGUID;
}
}
// if we have a guid, get the vs pro id
if (!string.IsNullOrEmpty(prefabSettings.assetGUID))
{
// get the VegetationItemID
prefabSettings.vspro_VegetationItemID = VegetationStudioManager.GetVegetationItemID(prefabSettings.assetGUID);
// if the vegetation item id doesn't exist, create a new vegetation item
if (string.IsNullOrEmpty(prefabSettings.vspro_VegetationItemID))
{
VegetationType vegetationType = VegetationType.Objects;
bool enableRuntimeSpawn = false; // no runtime spawn, we want it spawned from persistent storage
BiomeType biomeType = BiomeType.Default;
prefabSettings.vspro_VegetationItemID = VegetationStudioManager.AddVegetationItem(prefab, vegetationType, enableRuntimeSpawn, biomeType);
}
}
else
{
Debug.LogError("Can't get assetGUID for prefab " + prefab);
}
}
if (string.IsNullOrEmpty(prefabSettings.vspro_VegetationItemID))
{
Debug.LogError("Can't get VegetationItemId for prefab " + prefab);
}
#endif
}
private LayerMask GetColliderLayer(VegetationType vegetationType)
{
switch (vegetationType)
{
case VegetationType.Tree:
return(TreeLayer);
case VegetationType.Objects:
return(ObjectLayer);
case VegetationType.LargeObjects:
return(LargeObjectLayer);
default:
return(0);
}
}
AxelF.Patch GetFootstepAsset(
PlayerFoleyAsset foley, Vector3 position, PhysicMaterial physicalMaterial,
float speedScalar, VegetationType type, bool landing = false)
{
var footstep = default(PlayerFoleyAsset.Footstep);
int footstepIndex;
bool validFootstep = false;
if (physicalMaterial != null)
{
if (_materialMap.TryGetValue(physicalMaterial, out footstepIndex))
{
footstep = foley.footsteps[footstepIndex];
validFootstep = true;
}
}
if (!validFootstep)
{
var terrainFoley = TerrainFoleyManager.current;
footstepIndex = _foleyMap.GetFoleyIndexAtPosition(position, terrainFoley.splatMap);
footstep = foley.footsteps[footstepIndex];
validFootstep = true;
}
Debug.Assert(validFootstep);
bool running = speedScalar >= 0.7f;
bool jogging = !running && speedScalar >= 0.2f;
var asset =
type == VegetationType.None ?
(landing ? footstep.landing :
running ? footstep.running :
jogging ? footstep.jogging :
footstep.walking) :
type == VegetationType.Undergrowth ?
(running ? footstep.runningUndergrowth :
jogging ? footstep.joggingUndergrowth :
footstep.walkingUndergrowth) :
null;
return(asset);
}
bool RenderVegetationType(VegetationType vegetationType, ShadowMaskCreator shadowMaskCreator)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(false);
case VegetationType.Plant:
return(false);
case VegetationType.Tree:
return(shadowMaskCreator.IncludeTrees);
case VegetationType.Objects:
return(false);
case VegetationType.LargeObjects:
return(shadowMaskCreator.IncludeLargeObjects);
}
return(false);
}
public LayerMask GetLayer(VegetationType vegetationType)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(GrassLayer);
case VegetationType.Plant:
return(PlantLayer);
case VegetationType.Tree:
return(TreeLayer);
case VegetationType.Objects:
return(ObjectLayer);
case VegetationType.LargeObjects:
return(LargeObjectLayer);
}
return(0);
}
public override JobHandle SampleMask(VegetationInstanceData instanceData, VegetationType vegetationType,
JobHandle dependsOn)
{
if (VegetationType != vegetationType)
{
return(dependsOn);
}
SampleVegetatiomMaskCircleJob sampleVegetatiomMaskCircleJob =
new SampleVegetatiomMaskCircleJob
{
MaskPosition = Position,
Radius = Radius,
Position = instanceData.Position.ToDeferredJobArray(),
Excluded = instanceData.Excluded.ToDeferredJobArray()
};
dependsOn = sampleVegetatiomMaskCircleJob.Schedule(instanceData.Excluded, 32, dependsOn);
return(dependsOn);
}
public ShadowCastingMode GetShadowCastingMode(VegetationType vegetationType)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(GrassShadows ? ShadowCastingMode.On : ShadowCastingMode.Off);
case VegetationType.Plant:
return(PlantShadows ? ShadowCastingMode.On : ShadowCastingMode.Off);
case VegetationType.Tree:
return(TreeShadows ? ShadowCastingMode.On : ShadowCastingMode.Off);
case VegetationType.Objects:
return(ObjectShadows ? ShadowCastingMode.On : ShadowCastingMode.Off);
case VegetationType.LargeObjects:
return(LargeObjectShadows ? ShadowCastingMode.On : ShadowCastingMode.Off);
}
return(ShadowCastingMode.Off);
}
/// <summary>
///
/// </summary>
/// <param name="texture"></param>
/// <param name="vegetationType"></param>
/// <param name="enableRuntimeSpawn"></param>
/// <param name="biomeType"></param>
/// <returns></returns>
public static string AddVegetationItem(Texture2D texture, VegetationType vegetationType, bool enableRuntimeSpawn, BiomeType biomeType = BiomeType.Default)
{
if (!Instance)
{
FindInstance();
}
if (Instance)
{
string newVegetationItemID = System.Guid.NewGuid().ToString();
List <VegetationPackagePro> vegetationPackageList = GetVegetationPackageList(biomeType);
for (int i = 0; i <= vegetationPackageList.Count - 1; i++)
{
vegetationPackageList[i]
.AddVegetationItem(texture, vegetationType, enableRuntimeSpawn, newVegetationItemID);
}
RefreshVegetationSystem();
return(newVegetationItemID);
}
return("");
}
bool RenderVegetationType(VegetationType vegetationType, VegetationColorMaskCreator colorMaskCreator)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(colorMaskCreator.IncludeGrass);
case VegetationType.Plant:
return(colorMaskCreator.IncludePlants);
case VegetationType.Tree:
return(colorMaskCreator.IncludeTrees);
case VegetationType.Objects:
return(colorMaskCreator.IncludeObjects);
case VegetationType.LargeObjects:
return(colorMaskCreator.IncludeLargeObjects);
}
return(false);
}
public float GetPerlinScale(VegetationType vegetationType)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(NoiseScaleGrass);
case VegetationType.Plant:
return(NoiseScalePlant);
case VegetationType.Tree:
return(NoiseScaleTree);
case VegetationType.Objects:
return(NoiseScaleObject);
case VegetationType.LargeObjects:
return(NoiseScaleLargeObject);
}
return(0);
}
public float GetAdditionalWidthMax(VegetationType vegetationType)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(AdditionalGrassWidthMax);
case VegetationType.Plant:
return(AdditionalPlantWidthMax);
case VegetationType.Tree:
return(AdditionalTreeWidthMax);
case VegetationType.Objects:
return(AdditionalObjectWidthMax);
case VegetationType.LargeObjects:
return(AdditionalLargeObjectWidthMax);
}
return(0);
}
public bool ExcludeVegetationType(VegetationType vegetationType)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(RemoveGrass);
case VegetationType.Plant:
return(RemovePlants);
case VegetationType.Tree:
return(RemoveTrees);
case VegetationType.Objects:
return(RemoveObjects);
case VegetationType.LargeObjects:
return(RemoveLargeObjects);
}
return(false);
}
public override JobHandle SampleMask(VegetationInstanceData instanceData, VegetationType vegetationType,
JobHandle dependsOn)
{
if (!ExcludeVegetationType(vegetationType))
{
return(dependsOn);
}
SampleVegetatiomMaskPolygonJob sampleVegetatiomMaskPolygonJob =
new SampleVegetatiomMaskPolygonJob
{
Position = instanceData.Position.ToDeferredJobArray(),
Excluded = instanceData.Excluded.ToDeferredJobArray(),
PolygonArray = PolygonArray,
SegmentArray = SegmentArray,
AdditionalWidth = GetAdditionalWidth(vegetationType),
AdditionalWidthMax = GetAdditionalWidthMax(vegetationType),
NoiseScale = GetPerlinScale(vegetationType)
};
dependsOn = sampleVegetatiomMaskPolygonJob.Schedule(instanceData.Excluded, 32, dependsOn);
return(dependsOn);
}
public float GetVegetationItemDensity(VegetationType vegetationType)
{
switch (vegetationType)
{
case VegetationType.Grass:
return(GrassDensity);
case VegetationType.Plant:
return(PlantDensity);
case VegetationType.Tree:
return(TreeDensity);
case VegetationType.Objects:
return(ObjectDensity);
case VegetationType.LargeObjects:
return(LargeObjectDensity);
default:
return(1);
}
}
public bool QueryVegetation(Bounds bounds, out Vector3 outPosition, out VegetationType outType)
{
return(vegetationMap.Query(bounds, out outPosition, out outType));
}
//public virtual bool Contains(Vector3 point, VegetationType vegetationType, bool useAdditionalDistance, bool useExcludeFilter)
//{
// return false;
//}
public virtual JobHandle SampleMask(VegetationInstanceData instanceData,
VegetationType vegetationType,
JobHandle dependsOn)
{
return(dependsOn);
}
