public JobHandle SampleConcaveLocation(VegetationInstanceData instanceData, float minHeightDifference,
float distance, bool inverse, bool average, Rect spawnRect,
JobHandle dependsOn)
{
if (!_initDone)
{
return(dependsOn);
}
if (spawnRect.Overlaps(_terrainRect))
{
UnityTerrainSampleConcaveJob unityTerrainSampleConcaveLocationJob = new UnityTerrainSampleConcaveJob
{
InputHeights = Heights,
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
HeightMapScale = _heightmapScale,
HeightmapHeight = _heightmapHeight,
HeightmapWidth = _heightmapWidth,
TerrainPosition = TerrainPosition,
Size = _size,
Distance = distance,
MinHeightDifference = minHeightDifference,
Inverse = inverse,
Average = average
};
JobHandle handle = unityTerrainSampleConcaveLocationJob.Schedule(instanceData.Excluded, 64, dependsOn);
return(handle);
}
return(dependsOn);
}
public override JobHandle SampleIncludeVegetationMask(VegetationInstanceData instanceData,
VegetationTypeIndex vegetationTypeIndex,
JobHandle dependsOn)
{
VegetationTypeSettings vegetationTypeSettings = GetVegetationTypeSettings(vegetationTypeIndex);
if (vegetationTypeSettings != null)
{
IncludeVegetationMaskLineJob includeVegetationMaskLineJob =
new IncludeVegetationMaskLineJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
VegetationMaskDensity = instanceData.VegetationMaskDensity.ToDeferredJobArray(),
VegetationMaskScale = instanceData.VegetationMaskScale.ToDeferredJobArray(),
Denisty = vegetationTypeSettings.Density,
Scale = vegetationTypeSettings.Size,
LineSegment2D = _line2D,
Width = _width
};
dependsOn = includeVegetationMaskLineJob.Schedule(instanceData.Excluded, 32, dependsOn);
}
return(dependsOn);
}
public override JobHandle SampleIncludeVegetationMask(VegetationInstanceData instanceData,
VegetationTypeIndex vegetationTypeIndex,
JobHandle dependsOn)
{
VegetationTypeSettings vegetationTypeSettings = GetVegetationTypeSettings(vegetationTypeIndex);
if (vegetationTypeSettings != null)
{
IncludeVegetatiomMaskBeaconJob includeVegetatiomMaskBeaconJob =
new IncludeVegetatiomMaskBeaconJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
VegetationMaskDensity = instanceData.VegetationMaskDensity.ToDeferredJobArray(),
VegetationMaskScale = instanceData.VegetationMaskScale.ToDeferredJobArray(),
Denisty = vegetationTypeSettings.Density,
Scale = vegetationTypeSettings.Size,
FalloutCurveArray = FalloutCurveArray,
MaskPosition = Position,
Radius = Radius
};
dependsOn = includeVegetatiomMaskBeaconJob.Schedule(instanceData.Excluded, 32, dependsOn);
}
return(dependsOn);
}
void ReturnVegetationCellTemporaryMemory(VegetationCell vegetationCell)
{
for (int i = 0; i <= vegetationCell.VegetationInstanceDataList.Count - 1; i++)
{
VegetationInstanceData vegetationInstanceData = vegetationCell.VegetationInstanceDataList[i];
VegetationCellSpawner.VegetationInstanceDataPool.ReturnObject(vegetationInstanceData);
}
vegetationCell.VegetationInstanceDataList.Clear();
}
public JobHandle SampleConcaveLocation(VegetationInstanceData instanceData, float minHeightDifference, float distance, bool inverse, bool average, Rect spawnRect,
JobHandle dependsOn)
{
if (!_initDone)
{
return(dependsOn);
}
//TODO implement concave sampling for mesh terrain
return(dependsOn);
}
public JobHandle SampleExcludeMask(VegetationInstanceData instanceData, Rect spawnRect,
TextureMaskRule textureMaskRule, JobHandle dependsOn)
{
for (int i = 0; i <= TextureMaskList.Count - 1; i++)
{
dependsOn = TextureMaskList[i]
.SampleExcludeMask(instanceData, spawnRect, TextureMaskType, textureMaskRule, dependsOn);
}
return(dependsOn);
}
public JobHandle ProcessSplatmapRules(List <TerrainTextureRule> terrainTextureRuleList,
VegetationInstanceData instanceData, bool include, Rect cellRect, JobHandle dependsOn)
{
if (cellRect.Overlaps(_terrainRect))
{
if (!IsSplatmapArraysValid())
{
return(dependsOn);
}
int width = _terrain.terrainData.alphamapWidth;
int height = _terrain.terrainData.alphamapHeight;
Vector2 splatCellSize = new Vector2(_terrain.terrainData.size.x / (width - 1),
_terrain.terrainData.size.z / (height - 1));
for (int i = 0; i <= terrainTextureRuleList.Count - 1; i++)
{
int splatmapIndex = terrainTextureRuleList[i].TextureIndex / 4;
int localIndex = terrainTextureRuleList[i].TextureIndex - (4 * splatmapIndex);
if (splatmapIndex < _splatMapArrayList.Count)
{
SplatMapRuleJob splatMapRuleJob = new SplatMapRuleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
TerrainTextureData = instanceData.TerrainTextureData.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
SplatMapArray = _splatMapArrayList[splatmapIndex],
MinValue = terrainTextureRuleList[i].MinimumValue,
MaxValue = terrainTextureRuleList[i].MaximumValue,
SplatmapIndex = localIndex,
Width = width,
Height = height,
TerrainPosition = TerrainPosition,
SplatCellSize = splatCellSize
};
dependsOn = splatMapRuleJob.Schedule(instanceData.Excluded, 32, dependsOn);
}
}
SplatMapRuleCompleteJob splatMapRuleCompleteJob =
new SplatMapRuleCompleteJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
TerrainTextureData = instanceData.TerrainTextureData.ToDeferredJobArray(),
Include = include
};
return(splatMapRuleCompleteJob.Schedule(instanceData.Excluded, 32, dependsOn));
}
return(dependsOn);
}
public JobHandle SampleIncludeMask(VegetationInstanceData instanceData, Rect spawnRect,
TextureMaskType textureMaskType, TextureMaskRule textureMaskRule, JobHandle dependsOn)
{
if (!spawnRect.Overlaps(TextureRect))
{
return(dependsOn);
}
if (MaskTexture == null)
{
return(dependsOn);
}
switch (textureMaskType)
{
case TextureMaskType.RGBAChannel:
if (!_rgbaNativeArray.IsCreated)
{
_rgbaNativeArray = MaskTexture.GetRawTextureData <RGBABytes>();
}
bool inverse = textureMaskRule.GetBooleanPropertyValue("Inverse");
int selectedChannel = textureMaskRule.GetIntPropertyValue("ChannelSelector");
if (MaskTexture.format == TextureFormat.RGBA32)
{
selectedChannel--;
if (selectedChannel == -1)
{
selectedChannel = 3;
}
}
SampleRgbaChannelIncludeMaskJob sampleRgbaChannelIncludeMaskJob =
new SampleRgbaChannelIncludeMaskJob();
sampleRgbaChannelIncludeMaskJob.Width = MaskTexture.width;
sampleRgbaChannelIncludeMaskJob.Height = MaskTexture.height;
sampleRgbaChannelIncludeMaskJob.Excluded = instanceData.Excluded.ToDeferredJobArray();
sampleRgbaChannelIncludeMaskJob.Position = instanceData.Position.ToDeferredJobArray();
sampleRgbaChannelIncludeMaskJob.TextureMaskData = instanceData.TextureMaskData.ToDeferredJobArray();
sampleRgbaChannelIncludeMaskJob.RgbaNativeArray = _rgbaNativeArray;
sampleRgbaChannelIncludeMaskJob.SelectedChannel = selectedChannel;
sampleRgbaChannelIncludeMaskJob.Inverse = inverse;
sampleRgbaChannelIncludeMaskJob.TextureRect = TextureRect;
sampleRgbaChannelIncludeMaskJob.MinValue = textureMaskRule.MinDensity;
sampleRgbaChannelIncludeMaskJob.MaxValue = textureMaskRule.MaxDensity;
return(sampleRgbaChannelIncludeMaskJob.Schedule(instanceData.Excluded, 32, dependsOn));
}
return(dependsOn);
}
void ReturnVegetationCellTemporaryMemory()
{
for (int i = 0; i <= CompactMemoryCellList.Count - 1; i++)
{
VegetationCell vegetationCell = CompactMemoryCellList[i];
for (int j = 0; j <= vegetationCell.VegetationInstanceDataList.Count - 1; j++)
{
VegetationInstanceData vegetationInstanceData = vegetationCell.VegetationInstanceDataList[j];
VegetationCellSpawner.VegetationInstanceDataPool.ReturnObject(vegetationInstanceData);
}
vegetationCell.VegetationInstanceDataList.Clear();
}
CompactMemoryCellList.Clear();
}
public JobHandle SampleTerrain(NativeList <VegetationSpawnLocationInstance> spawnLocationList,
VegetationInstanceData instanceData, int sampleCount, Rect spawnRect, JobHandle dependsOn)
{
if (!_initDone)
{
return(dependsOn);
}
if (spawnRect.Overlaps(_terrainRect))
{
UnityTerrainSampleJob unityTerrainSampleJob = new UnityTerrainSampleJob
{
InputHeights = Heights,
SpawnLocationList = spawnLocationList.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
Rotation = instanceData.Rotation.ToDeferredJobArray(),
Scales = instanceData.Scale.ToDeferredJobArray(),
TerrainNormal = instanceData.TerrainNormal.ToDeferredJobArray(),
BiomeDistance = instanceData.BiomeDistance.ToDeferredJobArray(),
TerrainTextureData = instanceData.TerrainTextureData.ToDeferredJobArray(),
RandomNumberIndex = instanceData.RandomNumberIndex.ToDeferredJobArray(),
DistanceFalloff = instanceData.DistanceFalloff.ToDeferredJobArray(),
VegetationMaskDensity = instanceData.VegetationMaskDensity.ToDeferredJobArray(),
VegetationMaskScale = instanceData.VegetationMaskScale.ToDeferredJobArray(),
TerrainSourceIDs = instanceData.TerrainSourceID.ToDeferredJobArray(),
TextureMaskData = instanceData.TextureMaskData.ToDeferredJobArray(),
Excluded = instanceData.Excluded.ToDeferredJobArray(),
HeightmapSampled = instanceData.HeightmapSampled.ToDeferredJobArray(),
HeightMapScale = _heightmapScale,
HeightmapHeight = _heightmapHeight,
HeightmapWidth = _heightmapWidth,
TerrainPosition = TerrainPosition,
Scale = _scale,
Size = _size,
TerrainSourceID = (byte)TerrainSourceID
};
JobHandle handle = unityTerrainSampleJob.Schedule(sampleCount, 64, dependsOn);
return(handle);
}
return(dependsOn);
}
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 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);
}
JobHandle ExecuteSpawnRules(VegetationCell vegetationCell, Rect vegetationCellRect, int vegetationPackageIndex, int vegetationItemIndex)
{
int firstUnityTerrainIndex = GetFirstUnityTerrainIndex();
VegetationItemInfoPro vegetationItemInfoPro = VegetationPackageProList[vegetationPackageIndex].VegetationInfoList[vegetationItemIndex];
VegetationPackagePro vegetationPackagePro = VegetationPackageProList[vegetationPackageIndex];
VegetationItemModelInfo vegetationItemModelInfo =
VegetationPackageProModelsList[vegetationPackageIndex].VegetationItemModelList[vegetationItemIndex];
BiomeType currentBiome = VegetationPackageProList[vegetationPackageIndex].BiomeType;
int currentBiomeSortOrder = VegetationPackageProList[vegetationPackageIndex].BiomeSortOrder;
float globalDensity =
VegetationSettings.GetVegetationItemDensity(vegetationItemInfoPro.VegetationType);
if (vegetationCell.VegetationPackageInstancesList[vegetationPackageIndex].LoadStateList[vegetationItemIndex] == 1)
{
return(default(JobHandle));
}
vegetationCell.VegetationPackageInstancesList[vegetationPackageIndex].LoadStateList[vegetationItemIndex] = 1;
bool doRuntimeSpawn = !(currentBiome != BiomeType.Default && !vegetationCell.HasBiome(currentBiome));
NativeList <MatrixInstance> matrixList =
vegetationCell.VegetationPackageInstancesList[vegetationPackageIndex].VegetationItemMatrixList[vegetationItemIndex];
matrixList.Clear();
if (!vegetationItemInfoPro.EnableRuntimeSpawn)
{
doRuntimeSpawn = false;
}
if (vegetationItemInfoPro.UseVegetationMask)
{
bool hasVegetationTypeIndex = false;
if (vegetationCell.VegetationMaskList != null)
{
for (int k = 0; k <= vegetationCell.VegetationMaskList.Count - 1; k++)
{
if (vegetationCell.VegetationMaskList[k]
.HasVegetationTypeIndex(vegetationItemInfoPro.VegetationTypeIndex))
{
hasVegetationTypeIndex = true;
break;
}
}
}
if (!hasVegetationTypeIndex)
{
doRuntimeSpawn = false;
}
}
JobHandle vegetationItemHandle = default(JobHandle);
if (doRuntimeSpawn)
{
VegetationInstanceData instanceData = VegetationInstanceDataPool.GetObject();
instanceData.Clear();
vegetationCell.VegetationInstanceDataList.Add(instanceData);
float sampleDistance = vegetationItemInfoPro.SampleDistance / globalDensity;
float density = 1;
float calculatedSampleDistance = Mathf.Clamp(sampleDistance / density, 0.1f,
vegetationCell.VegetationCellBounds.size.x / 2f);
int xSamples = Mathf.CeilToInt(vegetationCell.VegetationCellBounds.size.x / calculatedSampleDistance);
int zSamples = Mathf.CeilToInt(vegetationCell.VegetationCellBounds.size.z / calculatedSampleDistance);
int sampleCount = xSamples * zSamples;
matrixList.Capacity = sampleCount;
instanceData.SpawnLocations.ResizeUninitialized(sampleCount);
if (firstUnityTerrainIndex > -1)
{
instanceData.ResizeUninitialized(sampleCount);
InitInstanceData initInstanceData = new InitInstanceData
{
HeightmapSampled = instanceData.HeightmapSampled.ToDeferredJobArray(),
Excluded = instanceData.Excluded.ToDeferredJobArray()
};
vegetationItemHandle = initInstanceData.Schedule(sampleCount, 256, vegetationItemHandle);
}
else
{
instanceData.SetCapasity(sampleCount);
}
float defaultSpawnChance = 0;
if (currentBiome == BiomeType.Default)
{
defaultSpawnChance = 1;
}
CalculateCellSpawnLocationsWideJob calculateCellSpawnLocationsWideJob =
new CalculateCellSpawnLocationsWideJob
{
SpawnLocations = instanceData.SpawnLocations.ToDeferredJobArray(),
CellSize = vegetationCell.VegetationCellBounds.size,
CellCorner =
vegetationCell.VegetationCellBounds.center -
vegetationCell.VegetationCellBounds.extents,
SampleDistance = sampleDistance,
RandomizePosition = vegetationItemInfoPro.RandomizePosition,
Density = 1,
DefaultSpawnChance = defaultSpawnChance,
RandomNumbers = RandomNumbers,
CellRect = vegetationCellRect,
CellIndex = vegetationCell.Index,
Seed = vegetationItemInfoPro.Seed + VegetationSettings.Seed,
UseSamplePointOffset = vegetationItemInfoPro.UseSamplePointOffset,
SamplePointMinOffset = vegetationItemInfoPro.SamplePointMinOffset,
SamplePointMaxOffset = vegetationItemInfoPro.SamplePointMaxOffset,
XSamples = xSamples,
ZSamples = zSamples,
CalculatedSampleDistance = calculatedSampleDistance
};
vegetationItemHandle = calculateCellSpawnLocationsWideJob.Schedule(sampleCount, 64, vegetationItemHandle);
if (vegetationCell.BiomeMaskList != null)
{
for (int k = 0; k <= vegetationCell.BiomeMaskList.Count - 1; k++)
{
if (vegetationCell.BiomeMaskList[k].BiomeSortOrder < currentBiomeSortOrder)
{
continue;
}
vegetationItemHandle = vegetationCell.BiomeMaskList[k]
.FilterSpawnLocations(instanceData.SpawnLocations, currentBiome, sampleCount, vegetationItemHandle);
}
}
if (vegetationItemInfoPro.UseNoiseCutoff)
{
PerlinNoiseCutoffJob perlinNoiseCutoffJob =
new PerlinNoiseCutoffJob
{
InversePerlinMask = vegetationItemInfoPro.NoiseCutoffInverse,
PerlinCutoff = vegetationItemInfoPro.NoiseCutoffValue,
PerlinScale = vegetationItemInfoPro.NoiseCutoffScale,
Offset = vegetationItemInfoPro.NoiseCutoffOffset,
SpawnLocationList = instanceData.SpawnLocations.ToDeferredJobArray()
};
vegetationItemHandle = perlinNoiseCutoffJob.Schedule(sampleCount, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseNoiseDensity)
{
PerlinNoiseDensityJob perlinNoiseDensityJob =
new PerlinNoiseDensityJob
{
InversePerlinMask = vegetationItemInfoPro.NoiseDensityInverse,
PerlinScale = vegetationItemInfoPro.NoiseDensityScale,
Offset = vegetationItemInfoPro.NoiseDensityOffset,
SpawnLocationList = instanceData.SpawnLocations.ToDeferredJobArray()
};
vegetationItemHandle = perlinNoiseDensityJob.Schedule(sampleCount, 64, vegetationItemHandle);
}
FilterSpawnLocationsChanceJob filterSpawnLocationsChanceJob =
new FilterSpawnLocationsChanceJob
{
SpawnLocationList = instanceData.SpawnLocations.ToDeferredJobArray(),
RandomNumbers = RandomNumbers,
Density = vegetationItemInfoPro.Density
};
vegetationItemHandle = filterSpawnLocationsChanceJob.Schedule(sampleCount, 64, vegetationItemHandle);
for (int k = 0; k <= VegetationStudioTerrainList.Count - 1; k++)
{
vegetationItemHandle = VegetationStudioTerrainList[k]
.SampleTerrain(instanceData.SpawnLocations, instanceData, sampleCount, vegetationCellRect,
vegetationItemHandle);
}
if (vegetationItemInfoPro.UseTerrainSourceExcludeRule)
{
TerrainSourceExcludeRuleJob terrainSourceExcludeRuleJob =
new TerrainSourceExcludeRuleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
TerrainSourceID = instanceData.TerrainSourceID.ToDeferredJobArray(),
TerrainSourceRule = vegetationItemInfoPro.TerrainSourceExcludeRule
};
vegetationItemHandle = terrainSourceExcludeRuleJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseTerrainSourceIncludeRule)
{
TerrainSourceIncludeRuleJob terrainSourceIncludeRuleJob =
new TerrainSourceIncludeRuleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
TerrainSourceID = instanceData.TerrainSourceID.ToDeferredJobArray(),
TerrainSourceRule = vegetationItemInfoPro.TerrainSourceIncludeRule
};
vegetationItemHandle = terrainSourceIncludeRuleJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseSteepnessRule)
{
InstanceSteepnessRuleJob instanceSteepnessRuleJob =
new InstanceSteepnessRuleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
TerrainNormal = instanceData.TerrainNormal.ToDeferredJobArray(),
RandomNumberIndex = instanceData.RandomNumberIndex.ToDeferredJobArray(),
MinSteepness = vegetationItemInfoPro.MinSteepness,
MaxSteepness = vegetationItemInfoPro.MaxSteepness,
Advanced = vegetationItemInfoPro.UseAdvancedSteepnessRule,
SteepnessRuleCurveArray = vegetationItemModelInfo.SteepnessRuleCurveArray,
RandomNumbers = RandomNumbers
};
vegetationItemHandle = instanceSteepnessRuleJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseHeightRule)
{
InstanceHeightRuleJob instanceHeightRuleJob =
new InstanceHeightRuleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
RandomNumberIndex = instanceData.RandomNumberIndex.ToDeferredJobArray(),
MinHeight = vegetationItemInfoPro.MinHeight + WorldspaceSeaLevel,
MaxHeight = vegetationItemInfoPro.MaxHeight + WorldspaceSeaLevel,
Advanced = vegetationItemInfoPro.UseAdvancedHeightRule,
HeightRuleCurveArray = vegetationItemModelInfo.HeightRuleCurveArray,
RandomNumbers = RandomNumbers,
MaxCurveHeight = vegetationItemInfoPro.MaxCurveHeight
};
vegetationItemHandle = instanceHeightRuleJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (!vegetationItemInfoPro.UseVegetationMask && vegetationCell.VegetationMaskList != null)
{
for (int k = 0; k <= vegetationCell.VegetationMaskList.Count - 1; k++)
{
vegetationItemHandle = vegetationCell.VegetationMaskList[k].SampleMask(instanceData,
vegetationItemInfoPro.VegetationType, vegetationItemHandle);
}
}
else
{
if (vegetationCell.VegetationMaskList != null)
{
for (int k = 0; k <= vegetationCell.VegetationMaskList.Count - 1; k++)
{
vegetationItemHandle = vegetationCell.VegetationMaskList[k].SampleIncludeVegetationMask(
instanceData,
vegetationItemInfoPro.VegetationTypeIndex, vegetationItemHandle);
}
if (vegetationCell.VegetationMaskList.Count > 0)
{
ProcessIncludeVegetationMaskJob processIncludeVegetationMaskJob =
new ProcessIncludeVegetationMaskJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Scale = instanceData.Scale.ToDeferredJobArray(),
RandomNumberIndex = instanceData.RandomNumberIndex.ToDeferredJobArray(),
VegetationMaskDensity = instanceData.VegetationMaskDensity.ToDeferredJobArray(),
VegetationMaskScale = instanceData.VegetationMaskScale.ToDeferredJobArray(),
RandomNumbers = RandomNumbers
};
vegetationItemHandle = processIncludeVegetationMaskJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
}
}
if (vegetationItemInfoPro.UseConcaveLocationRule)
{
for (int k = 0; k <= VegetationStudioTerrainList.Count - 1; k++)
{
vegetationItemHandle = VegetationStudioTerrainList[k].SampleConcaveLocation(instanceData,
vegetationItemInfoPro.ConcaveLoactionMinHeightDifference,
vegetationItemInfoPro.ConcaveLoactionDistance, vegetationItemInfoPro.ConcaveLocationInverse,
vegetationItemInfoPro.ConcaveLoactionAverage, vegetationCellRect, vegetationItemHandle);
}
}
if (vegetationItemInfoPro.UseTextureMaskIncludeRules)
{
for (int k = 0; k <= vegetationItemInfoPro.TextureMaskIncludeRuleList.Count - 1; k++)
{
TextureMaskGroup textureMaskGroup =
vegetationPackagePro.GetTextureMaskGroup(vegetationItemInfoPro
.TextureMaskIncludeRuleList[k].TextureMaskGroupID);
if (textureMaskGroup != null)
{
vegetationItemHandle = textureMaskGroup.SampleIncludeMask(instanceData, vegetationCellRect,
vegetationItemInfoPro.TextureMaskIncludeRuleList[k], vegetationItemHandle);
}
}
FilterIncludeMaskJob filterIncludeMaskJob =
new FilterIncludeMaskJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
TextureMaskData = instanceData.TextureMaskData.ToDeferredJobArray()
};
vegetationItemHandle = filterIncludeMaskJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseTextureMaskExcludeRules)
{
for (int k = 0; k <= vegetationItemInfoPro.TextureMaskExcludeRuleList.Count - 1; k++)
{
TextureMaskGroup textureMaskGroup =
vegetationPackagePro.GetTextureMaskGroup(vegetationItemInfoPro
.TextureMaskExcludeRuleList[k].TextureMaskGroupID);
if (textureMaskGroup != null)
{
vegetationItemHandle = textureMaskGroup.SampleExcludeMask(instanceData, vegetationCellRect,
vegetationItemInfoPro.TextureMaskExcludeRuleList[k], vegetationItemHandle);
}
}
}
OffsetAndRotateScaleVegetationInstanceMathJob offsetAndRotateScaleVegetationInstanceJob =
new OffsetAndRotateScaleVegetationInstanceMathJob
{
RandomNumbers = RandomNumbers,
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Scale = instanceData.Scale.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
Rotation = instanceData.Rotation.ToDeferredJobArray(),
RandomNumberIndex = instanceData.RandomNumberIndex.ToDeferredJobArray(),
TerrainNormal = instanceData.TerrainNormal.ToDeferredJobArray(),
VegetationRotationType = vegetationItemInfoPro.Rotation,
MinScale = vegetationItemInfoPro.MinScale,
MaxScale = vegetationItemInfoPro.MaxScale,
Offset = vegetationItemInfoPro.Offset,
RotationOffset = vegetationItemInfoPro.RotationOffset,
ScaleMultiplier = vegetationItemInfoPro.ScaleMultiplier
};
vegetationItemHandle = offsetAndRotateScaleVegetationInstanceJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
if (vegetationItemInfoPro.UseNoiseScaleRule)
{
PerlinNoiseScaleJob perlinNoiseScaleJob =
new PerlinNoiseScaleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Position = instanceData.Position.ToDeferredJobArray(),
Scale = instanceData.Scale.ToDeferredJobArray(),
PerlinScale = vegetationItemInfoPro.NoiseScaleScale,
MinScale = vegetationItemInfoPro.NoiseScaleMinScale,
MaxScale = vegetationItemInfoPro.NoiseScaleMaxScale,
InversePerlinMask = vegetationItemInfoPro.NoiseScaleInverse,
Offset = vegetationItemInfoPro.NoiseScaleOffset
};
vegetationItemHandle = perlinNoiseScaleJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseBiomeEdgeScaleRule && currentBiome != BiomeType.Default)
{
BiomeEdgeDistanceScaleRuleJob biomeEdgeDistanceScaleRuleJob =
new BiomeEdgeDistanceScaleRuleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
Scale = instanceData.Scale.ToDeferredJobArray(),
BiomeDistance = instanceData.BiomeDistance.ToDeferredJobArray(),
MinScale = vegetationItemInfoPro.BiomeEdgeScaleMinScale,
MaxScale = vegetationItemInfoPro.BiomeEdgeScaleMaxScale,
MaxDistance = vegetationItemInfoPro.BiomeEdgeScaleDistance,
InverseScale = vegetationItemInfoPro.BiomeEdgeScaleInverse
};
vegetationItemHandle = biomeEdgeDistanceScaleRuleJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseBiomeEdgeIncludeRule && currentBiome != BiomeType.Default)
{
BiomeEdgeDistanceIncludeRuleJob biomeEdgeDistanceIncludeRuleJob =
new BiomeEdgeDistanceIncludeRuleJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
BiomeDistance = instanceData.BiomeDistance.ToDeferredJobArray(),
MaxDistance = vegetationItemInfoPro.BiomeEdgeIncludeDistance,
Inverse = vegetationItemInfoPro.BiomeEdgeIncludeInverse
};
vegetationItemHandle = biomeEdgeDistanceIncludeRuleJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
if (vegetationItemInfoPro.UseTerrainTextureIncludeRules)
{
for (int k = 0; k <= VegetationStudioTerrainList.Count - 1; k++)
{
vegetationItemHandle = VegetationStudioTerrainList[k]
.ProcessSplatmapRules(vegetationItemInfoPro.TerrainTextureIncludeRuleList, instanceData,
true,
vegetationCellRect,
vegetationItemHandle);
}
}
if (vegetationItemInfoPro.UseTerrainTextureExcludeRules)
{
for (int k = 0; k <= VegetationStudioTerrainList.Count - 1; k++)
{
vegetationItemHandle = VegetationStudioTerrainList[k]
.ProcessSplatmapRules(vegetationItemInfoPro.TerrainTextureExcludeRuleList, instanceData,
false,
vegetationCellRect,
vegetationItemHandle);
}
}
if (vegetationItemInfoPro.UseDistanceFalloff)
{
DistanceFalloffJob distanceFalloffJob =
new DistanceFalloffJob
{
Excluded = instanceData.Excluded.ToDeferredJobArray(),
RandomNumberIndex = instanceData.RandomNumberIndex.ToDeferredJobArray(),
DistanceFalloff = instanceData.DistanceFalloff.ToDeferredJobArray(),
RandomNumbers = RandomNumbers,
DistanceFalloffStartDistance = vegetationItemInfoPro.DistanceFalloffStartDistance
};
vegetationItemHandle = distanceFalloffJob.Schedule(instanceData.Excluded, 64, vegetationItemHandle);
}
NewCreateInstanceMatrixJob createInstanceMatrixJob =
new NewCreateInstanceMatrixJob
{
Excluded = instanceData.Excluded,
Position = instanceData.Position,
Scale = instanceData.Scale,
Rotation = instanceData.Rotation,
DistanceFalloff = instanceData.DistanceFalloff,
VegetationInstanceMatrixList = matrixList
};
vegetationItemHandle = createInstanceMatrixJob.Schedule(vegetationItemHandle);
}
if (!doRuntimeSpawn)
{
if (PersistentVegetationStorage && !PersistentVegetationStorage.DisablePersistentStorage)
{
PersistentVegetationCell persistentVegetationCell = PersistentVegetationStorage.GetPersistentVegetationCell(vegetationCell.Index);
PersistentVegetationInfo persistentVegetationInfo = persistentVegetationCell?.GetPersistentVegetationInfo(vegetationItemInfoPro.VegetationItemID);
if (persistentVegetationInfo != null && persistentVegetationInfo.VegetationItemList.Count > 0)
{
persistentVegetationInfo.CopyToNativeArray();
matrixList.ResizeUninitialized(persistentVegetationInfo.NativeVegetationItemArray.Length);
LoadPersistentStorageToMatrixWideJob loadPersistentStorageToMatrixJob =
new LoadPersistentStorageToMatrixWideJob
{
InstanceList = persistentVegetationInfo.NativeVegetationItemArray,
VegetationInstanceMatrixList = matrixList.ToDeferredJobArray(),
VegetationSystemPosition = VegetationSystemPro.VegetationSystemPosition
};
vegetationItemHandle = loadPersistentStorageToMatrixJob.Schedule(matrixList, 64, vegetationItemHandle);
}
}
}
else
{
if (PersistentVegetationStorage && !PersistentVegetationStorage.DisablePersistentStorage)
{
PersistentVegetationCell persistentVegetationCell = PersistentVegetationStorage.GetPersistentVegetationCell(vegetationCell.Index);
PersistentVegetationInfo persistentVegetationInfo = persistentVegetationCell?.GetPersistentVegetationInfo(vegetationItemInfoPro.VegetationItemID);
if (persistentVegetationInfo != null && persistentVegetationInfo.VegetationItemList.Count > 0)
{
persistentVegetationInfo.CopyToNativeArray();
LoadPersistentStorageToMatrixJob loadPersistentStorageToMatrixJob =
new LoadPersistentStorageToMatrixJob
{
InstanceList = persistentVegetationInfo.NativeVegetationItemArray,
VegetationInstanceMatrixList = matrixList,
VegetationSystemPosition = VegetationSystemPro.VegetationSystemPosition
};
vegetationItemHandle = loadPersistentStorageToMatrixJob.Schedule(vegetationItemHandle);
}
}
}
Profiler.BeginSample("Schedule batched jobs");
JobHandle.ScheduleBatchedJobs();
Profiler.EndSample();
return(vegetationItemHandle);
}
//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);
}
public virtual JobHandle SampleIncludeVegetationMask(VegetationInstanceData instanceData,
VegetationTypeIndex vegetationTypeIndex,
JobHandle dependsOn)
{
return(dependsOn);
}
public JobHandle SampleTerrain(NativeList <VegetationSpawnLocationInstance> spawnLocationList, VegetationInstanceData instanceData, int sampleCount, Rect spawnRect,
JobHandle dependsOn)
{
if (!_initDone)
{
return(dependsOn);
}
if (!_nativeNodes.IsCreated)
{
CreateNativeArrays();
}
Rect terrainRect = RectExtension.CreateRectFromBounds(TerrainBounds);
if (!spawnRect.Overlaps(terrainRect))
{
return(dependsOn);
}
BVHRaycastContainer raycastContainer = new BVHRaycastContainer
{
Rays = new NativeArray <BVHRay>(sampleCount, Allocator.TempJob),
RaycastHits = new NativeArray <HitInfo>(sampleCount, Allocator.TempJob),
RaycastHitList = new NativeList <HitInfo>(sampleCount * 2, Allocator.TempJob),
TempHi = new NativeArray <HitInfo>(sampleCount, Allocator.TempJob)
};
RaycastContainerList.Add(raycastContainer);
CreateBVHRaycastJob createBVHRaysJob =
new CreateBVHRaycastJob
{
SpawnLocationList = spawnLocationList.ToDeferredJobArray(),
Rays = raycastContainer.Rays,
TerrainRect = terrainRect
};
dependsOn = createBVHRaysJob.Schedule(dependsOn);
if (MultiLevelRaycast)
{
SampleBVHTreeMultiLevelJob jobData = new SampleBVHTreeMultiLevelJob()
{
Rays = raycastContainer.Rays,
HitInfos = raycastContainer.RaycastHitList,
NativeNodes = _nativeNodes,
NativePrims = _nativePrims,
TempHi = raycastContainer.TempHi
};
dependsOn = jobData.Schedule(dependsOn);
UpdateBVHInstanceListMultiLevelJob updateInstanceListJob = new UpdateBVHInstanceListMultiLevelJob
{
Position = instanceData.Position,
Rotation = instanceData.Rotation,
Scale = instanceData.Scale,
TerrainNormal = instanceData.TerrainNormal,
BiomeDistance = instanceData.BiomeDistance,
TerrainTextureData = instanceData.TerrainTextureData,
RandomNumberIndex = instanceData.RandomNumberIndex,
DistanceFalloff = instanceData.DistanceFalloff,
VegetationMaskDensity = instanceData.VegetationMaskDensity,
VegetationMaskScale = instanceData.VegetationMaskScale,
TerrainSourceID = instanceData.TerrainSourceID,
TextureMaskData = instanceData.TextureMaskData,
Excluded = instanceData.Excluded,
HeightmapSampled = instanceData.HeightmapSampled,
RaycastHits = raycastContainer.RaycastHitList.ToDeferredJobArray(),
};
dependsOn = updateInstanceListJob.Schedule(dependsOn);
}
else
{
SampleBVHTreeJob jobData = new SampleBVHTreeJob()
{
Rays = raycastContainer.Rays,
HitInfos = raycastContainer.RaycastHits,
NativeNodes = _nativeNodes,
NativePrims = _nativePrims,
TempHi = raycastContainer.TempHi
};
dependsOn = jobData.Schedule(sampleCount, 32, dependsOn);
UpdateBVHInstanceListJob updateInstanceListJob = new UpdateBVHInstanceListJob
{
Position = instanceData.Position,
Rotation = instanceData.Rotation,
Scale = instanceData.Scale,
TerrainNormal = instanceData.TerrainNormal,
BiomeDistance = instanceData.BiomeDistance,
TerrainTextureData = instanceData.TerrainTextureData,
RandomNumberIndex = instanceData.RandomNumberIndex,
DistanceFalloff = instanceData.DistanceFalloff,
VegetationMaskDensity = instanceData.VegetationMaskDensity,
VegetationMaskScale = instanceData.VegetationMaskScale,
TerrainSourceID = instanceData.TerrainSourceID,
TextureMaskData = instanceData.TextureMaskData,
Excluded = instanceData.Excluded,
RaycastHits = raycastContainer.RaycastHits,
HeightmapSampled = instanceData.HeightmapSampled,
SpawnLocationList = spawnLocationList.ToDeferredJobArray()
};
dependsOn = updateInstanceListJob.Schedule(dependsOn);
}
return(dependsOn);
}
public JobHandle SampleTerrain(NativeList <VegetationSpawnLocationInstance> spawnLocationList,
VegetationInstanceData instanceData, int sampleCount,
Rect spawnRect, JobHandle dependsOn)
{
if (!_initDone)
{
return(dependsOn);
}
Vector3 floatingOriginOffset = VegetationStudioManager.GetFloatingOriginOffset();
Rect terrainRect = RectExtension.CreateRectFromBounds(TerrainBounds);
if (!spawnRect.Overlaps(terrainRect))
{
return(dependsOn);
}
MaxHits = 1;
RaycastContainers raycastContainers = RaycastContainerPool.Get();
raycastContainers.RaycastCommands = new NativeArray <RaycastCommand>(sampleCount, Allocator.TempJob);
raycastContainers.RaycastHits = new NativeArray <RaycastHit>(sampleCount * MaxHits, Allocator.TempJob);
RaycastContainerList.Add(raycastContainers);
CreateRaycastCommandsJob createRaycastCommandsJob =
new CreateRaycastCommandsJob
{
SpawnLocationList = spawnLocationList.ToDeferredJobArray(),
LayerMask = RaycastLayerMask,
MaxHits = MaxHits,
RaycastCommands = raycastContainers.RaycastCommands,
FloatingOriginOffset = floatingOriginOffset
};
dependsOn = createRaycastCommandsJob.Schedule(dependsOn);
dependsOn = RaycastCommand.ScheduleBatch(raycastContainers.RaycastCommands, raycastContainers.RaycastHits,
32, dependsOn);
UpdateInstanceListJob updateInstanceListJob = new UpdateInstanceListJob
{
Position = instanceData.Position,
Rotation = instanceData.Rotation,
Scale = instanceData.Scale,
TerrainNormal = instanceData.TerrainNormal,
BiomeDistance = instanceData.BiomeDistance,
TerrainTextureData = instanceData.TerrainTextureData,
RandomNumberIndex = instanceData.RandomNumberIndex,
DistanceFalloff = instanceData.DistanceFalloff,
VegetationMaskDensity = instanceData.VegetationMaskDensity,
VegetationMaskScale = instanceData.VegetationMaskScale,
TerrainSourceIDs = instanceData.TerrainSourceID,
TextureMaskData = instanceData.TextureMaskData,
Excluded = instanceData.Excluded,
RaycastHits = raycastContainers.RaycastHits,
HeightmapSampled = instanceData.HeightmapSampled,
SpawnLocationList = spawnLocationList.ToDeferredJobArray(),
TerrainRect = terrainRect,
FloatingOriginOffset = floatingOriginOffset,
TerrainSourceID = (byte)TerrainSourceID
};
dependsOn = updateInstanceListJob.Schedule(dependsOn);
return(dependsOn);
}
public JobHandle ProcessSplatmapRules(List <TerrainTextureRule> terrainTextureRuleList,
VegetationInstanceData instanceData, bool include, Rect cellRect, JobHandle dependsOn)
{
return(dependsOn);
}
