private void GenerateCactusClusters()
{
for (int i = 0; i < cactusCluster.subclusters; i++)
{
Vector3 subPos = cactusCluster.location.position + Random.insideUnitSphere * cactusCluster.radius;//y coord doesn't matter
subPos.y = 0;
List <Vector2> points = UniformPoissonDiskSampler.SampleCircle(new Vector2(subPos.x, subPos.z), cactusCluster.subclusterRadius, cactusCluster.objectRadius);
for (int j = 0; j < points.Count; j++)
{
Vector3 treePos = new Vector3(points[j].x, 0, points[j].y);
RaycastHit hit;
if (!Physics.Raycast(treePos + Vector3.up * 200, Vector3.down, out hit, 250, groundMask))
{
return;
}
treePos.y = hit.point.y;
//if (Physics.OverlapSphere(treePos, treeRadius, resourceMask).Length > 0)continue;
if (Random.value > cactusCluster.objectProbability)
{
continue;
}
GameObject go = Instantiate(GetRandom(cactusCluster.objectPrefab), treePos, Quaternion.identity);
float scaleFactor = (Vector3.Distance(subPos, treePos) / cactusCluster.subclusterRadius) * Random.Range(1f, 2f);
go.transform.localScale = go.transform.localScale * Mathf.Max(0.5f, scaleFactor);
go.transform.localRotation = Quaternion.Euler(0, Random.Range(0, 360f), 0);
cacti.Add(go);
}
}
}
private IEnumerable <Vector3> GetLightsDistributionPoisson(int size, float θFrom, float θTo)
{
Vector2[] poisson;
if (size >= 1000)
{
if (_poissonDisk == null && _poissonDiskWeak != null && _poissonDiskWeak.TryGetTarget(out var value))
{
_poissonDisk = value;
}
if (_poissonDisk?.Count != size)
{
_poissonDisk = UniformPoissonDiskSampler.SampleSquare(size, false);
_poissonDiskWeak = new WeakReference <List <Vector2> >(_poissonDisk);
}
poisson = _poissonDisk.ToArray();
}
else
{
poisson = UniformPoissonDiskSampler.SampleSquare(size, false).ToArray();
}
CropPoisson(poisson, (θFrom.ToRadians() + MathF.PI / 2f).Cos(), (θTo.ToRadians() + MathF.PI / 2f).Cos());
foreach (var point in poisson)
{
var θ = point.Y.Clamp(-0.9999f, 0.9999f).Acos() - MathF.PI / 2f;
var φ = point.X * MathF.PI;
var direction = MathF.ToVector3Rad(θ, φ);
yield return(direction);
}
}
void Go()
{
index = -1;
sampler = GetComponent <UniformPoissonDiskSampler>();
sampler.Initialize(topLeft, lowerRight, seed);
coroutine = StartCoroutine(sampler.Sample());
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
points.Clear();
Clear();
}
if (Input.GetKeyDown(KeyCode.Return))
{
Clear();
var sampler = UniformPoissonDiskSampler.SampleCircle(Vector2.zero, generationSize, generationMinDistance);
points = sampler.Select(point => new Vector2(point.x, point.y)).ToPoints().ToList();
Debug.Log($"Generated Points Count {points.Count}");
Create();
return;
}
if (!Input.GetMouseButtonDown(0))
{
return;
}
var target = Camera.main.ScreenToWorldPoint(Input.mousePosition);
points.Add(new Point(target.x, target.y));
Create();
}
public void Initialize()
{
UniformPoissonDiskSampler.Random = new Random(Seed);
Points = UniformPoissonDiskSampler.SampleRectangle(new Vector2(0, 0), new Vector2(Width, Height), Radius);
Delaunay = Delaunay.from(Points.Select(point => new double[] { point.X, point.Y }).ToArray());
Voronoi = Delaunay.voronoi(new Bounds {
x0 = 0.5, y0 = 0.5, x1 = Width - 0.5, y1 = Height - 0.5
});
CellPolygons = Voronoi.cellPolygons().ToList();
}
public void GenerateMap(float mapSize, float delaunayRMin)
{
blueNoisePoints = UniformPoissonDiskSampler.SampleCircle(Vector2.zero, mapSize / 2, delaunayRMin);
delaunator = new Delaunator(blueNoisePoints.ToPoints());
DrawDelaunay();
DrawVoronoi();
// fill heightmap into y coordinates
cellPoints = HeightField.PerlinIsland(blueNoisePoints, mapSize, 0.1f, 0.7f, 4f, 3f, 6);
map = new Map(cellPoints.Count);
SpawnCells(delaunator, cellPoints);
var camHeight = mapSize * 0.5f / Mathf.Tan(Camera.main.fieldOfView * 0.5f * Mathf.Deg2Rad);
Camera.main.transform.position = new Vector3(0, camHeight * 1.1f, 0);
}
private void GenerateRockClusters()
{
for (int i = 0; i < rockCluster.subclusters; i++)
{
Vector3 subPos = rockCluster.location.position + Random.insideUnitSphere * rockCluster.radius;//y coord doesn't matter
subPos.y = 0;
List <Vector2> points = UniformPoissonDiskSampler.SampleCircle(new Vector2(subPos.x, subPos.z), rockCluster.subclusterRadius, rockCluster.objectRadius);
// Debug.Log(points.Count);
for (int j = 0; j < points.Count; j++)
{
Vector3 treePos = new Vector3(points[j].x, 0, points[j].y);
treePos += (treePos - subPos) * UniformPoissonDiskSampler.NextGaussian();
RaycastHit hit;
if (!Physics.Raycast(treePos + Vector3.up * 200, Vector3.down, out hit, 250, groundMask))
{
return;
}
treePos.y = hit.point.y;
//if (Physics.OverlapSphere(treePos, treeRadius, resourceMask).Length > 0)continue;
if (Random.value > rockCluster.objectProbability)
{
continue;
}
GameObject go = Instantiate(GetRandom(rockCluster.objectPrefab), treePos, Quaternion.identity);
float scaleFactor = (1 / (1 + 0.1f * Vector3.Distance(treePos, subPos)));
go.transform.localScale = go.transform.localScale * scaleFactor * Random.Range(0.7f, 1f);
go.transform.localRotation = Quaternion.Euler(0, Random.Range(0, 360f), 0);
rocks.Add(go);
}
}
}
public static List <Vector2> GetRandomPoints(Polygon boundingArea, float density, float avoidRadius, List <Vector2> avoidPoints, SampleBehaviour behaviour, bool testInsideBounds, SeededRandom rnd, bool doShuffle = true, bool testAvoidPoints = true)
{
float num = boundingArea.bounds.width;
float num2 = boundingArea.bounds.height;
float num3 = num / 2f;
float num4 = num2 / 2f;
int num5 = (int)Mathf.Floor(num * num2 / density);
uint num6 = (uint)Mathf.Sqrt((float)num5);
int pointsPerIteration = 10;
uint num7 = (uint)((float)num5 * 0.98f);
Vector2 min = boundingArea.bounds.min;
Vector2 max = boundingArea.bounds.max;
List <Vector2> list = new List <Vector2>();
switch (behaviour)
{
case SampleBehaviour.PoissonDisk:
list = new UniformPoissonDiskSampler(rnd).SampleRectangle(min, max, density, pointsPerIteration);
break;
case SampleBehaviour.UniformSquare:
for (float num25 = 0f - num4 + density; num25 < num4 - density; num25 += density)
{
for (float num26 = 0f - num3 + density; num26 < num3 - density; num26 += density)
{
list.Add(boundingArea.Centroid() + new Vector2(num26, num25));
}
}
break;
case SampleBehaviour.UniformHex:
for (uint num10 = 0u; num10 < num6; num10++)
{
for (uint num11 = 0u; num11 < num6; num11++)
{
list.Add(boundingArea.Centroid() + new Vector2(0f - num3 + (0.5f + (float)(double)num10) / (float)(double)num6 * num, 0f - num4 + (0.25f + 0.5f * (float)(double)(num10 % 2u) + (float)(double)num11) / (float)(double)num6 * num2));
}
}
break;
case SampleBehaviour.UniformSpiral:
for (uint num19 = 0u; num19 < num7; num19++)
{
double num20 = (double)num19 / (32.0 * (double)density * 8.0);
double num21 = Math.Sqrt(num20 * 512.0 * (double)density);
double num22 = Math.Sqrt(num20);
double num23 = Math.Sin(num21) * num22;
double num24 = Math.Cos(num21) * num22;
list.Add(boundingArea.bounds.center + new Vector2((float)num23 * boundingArea.bounds.width, (float)num24 * boundingArea.bounds.height));
}
break;
case SampleBehaviour.UniformCircle:
{
float num12 = 6.28318548f * avoidRadius;
float num13 = num12 / density;
float num14 = rnd.RandomValue();
for (uint num15 = 1u; (float)(double)num15 < num13; num15++)
{
float num16 = num14 + (float)(double)num15 / num13 * 3.14159274f * 2f;
double num17 = Math.Cos((double)num16) * (double)avoidRadius;
double num18 = Math.Sin((double)num16) * (double)avoidRadius;
list.Add(boundingArea.bounds.center + new Vector2((float)num17, (float)num18));
}
break;
}
default:
for (float num8 = 0f - num4 + avoidRadius * 0.3f + rnd.RandomValue() * 2f; num8 < num4 - (avoidRadius * 0.3f + rnd.RandomValue() * 2f); num8 += density + rnd.RandomValue())
{
for (float num9 = 0f - num3 + avoidRadius * 0.3f + rnd.RandomValue() * 2f + rnd.RandomValue() * 2f; num9 < num3 - (avoidRadius * 0.3f + rnd.RandomValue() * 2f); num9 += density + rnd.RandomValue())
{
list.Add(boundingArea.Centroid() + new Vector2(num9, num8 + rnd.RandomValue() - 0.5f));
}
}
break;
}
List <Vector2> list2 = new List <Vector2>();
for (int i = 0; i < list.Count; i++)
{
if (!testInsideBounds || boundingArea.Contains(list[i]))
{
bool flag = false;
if (testAvoidPoints && avoidPoints != null)
{
for (int j = 0; j < avoidPoints.Count; j++)
{
if (Mathf.Abs((avoidPoints[j] - list[i]).magnitude) < avoidRadius)
{
flag = true;
break;
}
}
}
if (!flag)
{
list2.Add(list[i]);
}
}
}
if (doShuffle)
{
list2.ShuffleSeeded(rnd.RandomSource());
}
return(list2);
}
private void InitializeAccumulationDof()
{
_lazyAccumulationDofPoissonDiskSamples = Lazier.Create(() => Reorder(UniformPoissonDiskSampler.SampleCircle(_accumulationDofIterations)));
_lazyAccumulationDofPoissonSquareSamples = Lazier.Create(() => UniformPoissonDiskSampler.SampleSquare(_accumulationDofIterations, false).ToArray());
}
private void GenerateAround(List <GameObject> list)
{
for (int i = 0; i < list.Count; i++)
{
for (int j = 0; j < 50; j++)
{
Vector3 bushPos = list[i].transform.position + Random.insideUnitSphere * UniformPoissonDiskSampler.NextGaussian() * bushRadius;
RaycastHit hit;
if (!Physics.Raycast(bushPos + Vector3.up * 200, Vector3.down, out hit, 250, groundMask))
{
return;
}
bushPos.y = hit.point.y;
GameObject go = Instantiate(GetRandom(bushPrefab), bushPos, Quaternion.identity);
float scaleFactor = (1 / (1 + 0.2f * Vector3.Distance(bushPos, list[i].transform.position)));
go.transform.localScale = go.transform.localScale * Mathf.Min(scaleFactor, list[i].transform.localScale.x) * Random.Range(0.7f, 1f);
go.transform.localRotation = Quaternion.Euler(0, Random.Range(0, 360f), 0);
}
}
}
private void GenerateGeneralCluster()
{
List <Vector2> points = UniformPoissonDiskSampler.SampleCircle(new Vector2(generalCluster.location.position.x, generalCluster.location.position.z), generalCluster.radius, generalCluster.objectRadius);
// Debug.Log("Success " + points.Count);
for (int j = 0; j < points.Count; j++)
{
Vector3 treePos = new Vector3(points[j].x, 0, points[j].y);
treePos += treePos * (1 - UniformPoissonDiskSampler.NextGaussian());
RaycastHit hit;
if (!Physics.Raycast(treePos + Vector3.up * 200, Vector3.down, out hit, 250, groundMask))
{
continue;
}
treePos.y = hit.point.y;
// if (Physics.OverlapSphere(treePos, generalCluster.objectRadius, resourceMask).Length > 0)continue;
if (Random.value > generalCluster.objectProbability)
{
continue;
}
GameObject go = Instantiate(GetRandom(generalCluster.objectPrefab), treePos, Quaternion.identity);
float scaleFactor = 1;
go.transform.localScale = go.transform.localScale * scaleFactor * Random.Range(0.7f, 1f);
go.transform.localRotation = Quaternion.Euler(0, Random.Range(0, 360f), 0);
general.Add(go);
}
/*for (int i = 0; i < generalCluster.subclusters; i++)
* {
* Vector3 subPos = generalCluster.location.position + Random.insideUnitSphere * generalCluster.radius;//y coord doesn't matter
* subPos.y = 0;
*
* List<Vector2> points = UniformPoissonDiskSampler.SampleCircle(new Vector2(subPos.x, subPos.z), generalCluster.subclusterRadius, generalCluster.objectRadius);
* Debug.Log(points.Count);
*
* for (int j = 0; j < points.Count; j++)
* {
* Vector3 treePos = new Vector3(points[j].x, 0, points[j].y);
* treePos += (treePos - subPos) * UniformPoissonDiskSampler.NextGaussian();
*
* RaycastHit hit;
* if (!Physics.Raycast(treePos + Vector3.up * 200, Vector3.down, out hit, 250, groundMask)) return;
* treePos.y = hit.point.y;
*
* if (Physics.OverlapSphere(treePos, generalCluster.objectRadius, resourceMask).Length > 0)continue;
* if (Random.value > generalCluster.objectProbability) continue;
*
* GameObject go = Instantiate(GetRandom(generalCluster.objectPrefab), treePos, Quaternion.identity);
* float scaleFactor = 1;
* go.transform.localScale = go.transform.localScale * scaleFactor * Random.Range(0.7f, 1f);
* go.transform.localRotation = Quaternion.Euler(0, Random.Range(0, 360f), 0);
*
* general.Add(go);
* }
* }*/
}
public static List <Vector2> SampleUniformPoissonDiscInRectangle(Vector2 topLeft, Vector2 lowerRight, float minimumDistance, int pointsPerIteration, out Vector2?[,] pointGrid)
{
return(UniformPoissonDiskSampler.Sample(topLeft, lowerRight, null, minimumDistance, pointsPerIteration, out pointGrid));
}
public static List <Vector2> SampleUniformPoissonDiscInCircle(Vector2 center, float radius, float minimumDistance, int pointsPerIteration, out Vector2?[,] pointGrid)
{
return(UniformPoissonDiskSampler.Sample(center - new Vector2(radius, radius), center + new Vector2(radius, radius), radius, minimumDistance, pointsPerIteration, out pointGrid));
}
