private void AddFactions(float minDistance)
{
foreach (Vector3 point in PoissonDiscSampling.Generate(minDistance, new Vector2(WorldSize, WorldSize)))
{
AddFaction(point);
}
}
private void Awake()
{
points = PoissonDiscSampling.GeneratePoints(radius, regionSize, rejectionSamples);
if (points != null)
{
int index = 0;
foreach (Vector2 point in points)
{
// var randMine = Random.value;
if (index % 100 == 1)
{
if (minePrefab != null)
{
Instantiate(minePrefab, point, Quaternion.identity,
transform.GetChild(1).transform);
}
}
else
{
int rand = Random.Range(0, objectTypes.Length);
GameObject elem = Instantiate(objectTypes[rand], point, Quaternion.identity,
transform.GetChild(0).transform);
elemList.Add(elem);
}
index++;
}
LenghtElemList = elemList.Count;
}
}
internal Vector3[] generateTreePoints(int chunkX, int chunkY, int precision, float heightMultiplier, Vector3[] vertices)
{
// use poisson disk sampling to generate clustered points
// multiply by vertex percision
int mapSize = ((int)Mathf.Sqrt(vertices.Length) - 1);
// depending on the precision of the vertices, we'll need to adjust the mapsize to be 1:1 with the precision
List <Vector2> poissonPoints = PoissonDiscSampling.GeneratePoints(propRadius, new Vector2(mapSize, mapSize), 30);
List <Vector3> trees = new List <Vector3>();
for (var i = 0; i < poissonPoints.Count; i++)
{
Vector2 current = poissonPoints[i];
int verticesIndex = (int)((mapSize + 1) * (int)current.x) + (int)current.y;
float height = vertices[verticesIndex].y;
// the heights aren't the heights from the heightmap, but the mesh. These
// need to be scaled back down to the noisemap values to get the correct
// data
float normalizedHeight = Mathf.Lerp(0f, 1f, height / heightMultiplier);
if (normalizedHeight >= minPropHeightThreshold && normalizedHeight <= maxPropHeightThreshold)
{
// position must scale with the precision
trees.Add(new Vector3(current.y * precision, height, current.x * precision));
}
}
return(trees.ToArray());
}
private void GenerateCacti()
{
List <Vector2> points = PoissonDiscSampling.GeneratePoints(cactusRadius, treeArea, 50);
for (int i = 0; i < points.Count; i++)
{
if (Random.value < cactusProbability)
{
points[i] = points[i] - treeArea * 0.5f;
Vector3 position = new Vector3(points[i].x, 0, points[i].y);
RaycastHit hit;
if (!Physics.Raycast(position + Vector3.up * 20, Vector3.down, out hit, 30, groundLayer))
{
return;
}
position.y = hit.point.y;
//Debug.Log(hit.point);
GameObject go = Instantiate(cactusPrefab, position, Quaternion.identity);
go.transform.localScale = go.transform.localScale * Random.Range(0.5f, 1.5f);
}
}
}
private void runTest(int samples, double radius)
{
double[] times = new double[samples];
Stopwatch watch = new Stopwatch();
Random rand = new Random();
Console.WriteLine("Cores: " + Environment.ProcessorCount);
Console.WriteLine("64bit:" + Environment.Is64BitProcess + Environment.NewLine);
for (int s = 0; s < samples; s++)
{
List <Vector3D> points = new List <Vector3D>();
List <PoissonDisc> tPoints = PoissonDiscSampling.Sample3D(84357, radius, new Vector3D(5, 5, 5), 4, false);
foreach (PoissonDisc disc in tPoints)
{
points.Add(new Vector3D(disc.position.X, disc.position.Y, disc.position.Z));
}
ConvexHull3D hull = new ConvexHull3D();
Console.WriteLine(points.Count);
watch.Restart();
points = hull.ConstructHull(points);
watch.Stop();
Console.WriteLine(points.Count);
times[s] = watch.Elapsed.TotalMilliseconds;
}
Console.WriteLine(samples + ": avg => " + times.Average() + " | best => " + times.Min() + " | worst => " + times.Max());
}
public static void GeneratesMinimumSpacedPoints(float width, float height, float minRadius)
{
var points = PoissonDiscSampling.BuildSamples(width, height, minRadius);
var rSqr = minRadius * minRadius;
var smallestDist = float.PositiveInfinity;
var point1 = new float2(0f, 0f);
var point2 = new float2(0f, 0f);
for (var i = 0; i < points.Length; i++)
{
for (var j = i + 1; j < points.Length; j++)
{
var dist = math.distancesq(points[i], points[j]);
if (dist >= smallestDist)
{
continue;
}
smallestDist = dist;
point1 = points[i];
point2 = points[j];
}
}
points.Dispose();
Assert.GreaterOrEqual(smallestDist, rSqr,
$"The points { point1 } and { point2 } are spaced less than the minimum square distance allowed");
}
private void GenerateTrees()
{
List <Vector2> points = PoissonDiscSampling.GeneratePoints(treeRadius, treeArea, 10);
trees = new List <GameObject>();
for (int i = 0; i < points.Count; i++)
{
if (Random.value < treeProbability)
{
points[i] = points[i] - treeArea * 0.5f;
Vector3 position = new Vector3(points[i].x, 0, points[i].y);
RaycastHit hit;
if (!Physics.Raycast(position + Vector3.up * 20, Vector3.down, out hit, 30, groundLayer))
{
return;
}
position.y = hit.point.y;
//Debug.Log(hit.point);
trees.Add(Instantiate(treePrefab, position, Quaternion.identity));
}
}
}
private void GenerateBush()
{
for (int i = 0; i < trees.Count; i++)
{
/*List<Vector2> points = PoissonDiscSampling.GeneratePoints(bushRadius, bushArea, 30);
*
* for(int j = 0; j < points.Count; j++)
* {
* if(Random.value > bushProbability)
* {
* Instantiate(bushPrefab, trees[j].transform.position + new Vector3(points[j].x, 0, points[j].y) - new Vector3(bushArea.x * 0.5f, 0, bushArea.y * 0.5f),
* Quaternion.identity);
* }
* }*/
for (int j = 0; j < 30; j++)
{
if (Random.value < bushProbability)
{
continue;
}
Vector2 direction = Random.insideUnitCircle * PoissonDiscSampling.NextGaussian() * bushArea;
Vector3 position = trees[i].transform.position + new Vector3(direction.x, 0, direction.y);
position.y = trees[i].transform.position.y;
Instantiate(bushPrefab, position,
Quaternion.identity);
}
}
}
private async Task Generate()
{
PoissonDiscSampling sampling = new PoissonDiscSampling((double)items.Find(r => r.Name == "Radius").Value, (uint)items.Find(r => r.Name == "Seed").Value);
sampling.Sample2D(new CP.Common.Maths.Vector3D((int)VisualElement.ResultImage.Width, (int)VisualElement.ResultImage.Height, 0));
PoissonDiscSampling sampling2 = new PoissonDiscSampling((double)items.Find(r => r.Name == "Radius").Value, (uint)items.Find(r => r.Name == "Seed").Value);
sampling2.Sample2D(new CP.Common.Maths.Vector3D((int)VisualElement.ResultImage.Width, (int)VisualElement.ResultImage.Height, 0));
System.Drawing.Pen blue = new System.Drawing.Pen(System.Drawing.Color.Blue, 8);
System.Drawing.Pen red = new System.Drawing.Pen(System.Drawing.Color.Red, 8);
System.Drawing.Pen blackPoint = new System.Drawing.Pen(System.Drawing.Color.Black, 5);
System.Drawing.Pen black = new System.Drawing.Pen(System.Drawing.Color.White, 10);
Random rand = new Random();
Bitmap src = new Bitmap((int)VisualElement.ResultImage.Width, (int)VisualElement.ResultImage.Height);
using var graphics = Graphics.FromImage(src);
/* foreach (var sites in sampling.points)
* {
* graphics.DrawLine(blue, new PointF((float)sites.position.X - 1, (float)sites.position.Y - 1), new PointF((float)sites.position.X + 1, (float)sites.position.Y + 1));
*
* }
* foreach (var sites in sampling2.points)
* {
* graphics.DrawLine(red, new PointF((float)sites.position.X - 1, (float)sites.position.Y - 1), new PointF((float)sites.position.X + 1, (float)sites.position.Y + 1));
*
* }*/
VisualElement.Image = Utilities.BitmapToImageSource(src);
}
private void Awake()
{
_playerGameObject = GameObject.FindGameObjectWithTag("Player");
if (_playerGameObject == null)
{
Debug.LogError("Player game object not found.");
}
_pet = GetComponent <Pet>();
_agent = GetComponent <NavMeshAgent>();
_animator = GetComponent <Animator>();
_waypoints = ScriptableObject.CreateInstance <WaypointsAsset>();
_waypoints.Waypoints = PoissonDiscSampling.Generate3D(WaypointRadius,
new Vector2(PlayGroundTransform.localScale.x, PlayGroundTransform.localScale.z));
List <Vector3> navMeshWaypoints = new List <Vector3>();
for (int i = 0; i < _waypoints.Waypoints.Count; i++)
{
NavMeshHit hit;
if (NavMesh.SamplePosition(_waypoints.Waypoints[i], out hit, 100f, NavMesh.AllAreas))
{
navMeshWaypoints.Add(hit.position);
}
}
_waypoints.Waypoints = navMeshWaypoints;
}
public void Initiate()
{
heights = new List <float>();
polygon = new Polygon();
if (randomPoints == true)
{
for (int i = 0; i < pointDensity; i++)
{
var x = Random.Range(.0f, sizeX);
var y = Random.Range(.0f, sizeY);
polygon.Add(new Vertex(x, y));
}
}
else
{
poissonPoints = PoissonDiscSampling.GeneratePoints(minDistancePerPoint, new Vector2(sizeX, sizeY), rejectionSamples);
for (int i = 0; i < poissonPoints.Count; i++)
{
polygon.Add(new Vertex(poissonPoints[i].x, poissonPoints[i].y));
}
}
ConstraintOptions constraints = new ConstraintOptions();
constraints.ConformingDelaunay = true;
mesh = polygon.Triangulate(constraints) as TriangleNet.Mesh;
ShapeTerrain();
GenerateMesh();
}
public static void InvalidArguments(
float width, float height, float minRadius, uint seed, int samplingResolution)
{
Assert.Throws <ArgumentException>(delegate
{
PoissonDiscSampling.BuildSamples(width, height, minRadius, seed, samplingResolution);
});
}
void OnValidate()
{
if (IsUsingStaticRadius)
{
points = PoissonDiscSampling.GeneratePoints(radius, regionSize, rejectionSamples);
}
else
{
pointsPlusRadius = PoissonDiscSampling.GeneratePointsOfDifferentSize(RadiusRange, regionSize, rejectionSamples);
}
}
public void GeneratePatches()
{
List <Vector2> points = PoissonDiscSampling.GeneratePoints(bushRadius, treeArea, 10);
for (int j = 0; j < points.Count; j++)
{
if (Random.value < patchProbability)
{
Instantiate(patchPrefab, new Vector3(points[j].x, 0, points[j].y) - new Vector3(treeArea.x * 0.5f, 0, treeArea.y * 0.5f),
Quaternion.identity);
}
}
}
public void UpdatePlatforms()
{
for (int i = 0; i < transform.childCount; i++)
{
DestroyImmediate(transform.GetChild(i).gameObject);
}
List <Vector2> positions = PoissonDiscSampling.GeneratePoints(minDistanceBetweenPoints, sampleRegionSize);
spawnPlatforms(positions.Count);
for (int i = 0; i < transform.childCount; i++)
{
transform.GetChild(i).position = new Vector3(positions[i].x - sampleRegionSize.x / 2 + MinimapCamera.transform.position.x, transform.position.y, positions[i].y - sampleRegionSize.y / 2 + MinimapCamera.transform.position.z);
}
}
private async Task Generate()
{
BowyerAlgorithm2D voronoiGen = new BowyerAlgorithm2D((int)items.Find(r => r.Name == "Seed").Value)
{
PointCount = (int)items.Find(r => r.Name == "Point Count").Value,
//UseDelaunay = (bool)items.Find(r => r.Name == "Use Delaunay").Value,
//UseNoisyEdges = (int)items.Find(r => r.Name == "Noisy Edges").Value > 0,
//NoisyEdgesNo = (int)items.Find(r => r.Name == "Noisy Edges").Value,
MaxX = 400,
MaxY = 400,
};
int seed = (int)items.Find(r => r.Name == "Seed").Value;
PoissonDiscSampling sampling = new PoissonDiscSampling(20, (uint)seed);
List <PoissonDisc> points = sampling.Sample2D(new CP.Common.Maths.Vector3D(400, 400, 0));
List <Triangle> triangulation = voronoiGen.Generate(points.Select(point => point.position).ToList(), true);
List <VoronoiCell> cells = voronoiGen.GenerateVoronoi();
//int relaxation = (int)items.Find(r => r.Name == "Relaxation").Value;
//if(relaxation > 0)
//voronoiGen.Relax(relaxation);
System.Drawing.Pen blue = new System.Drawing.Pen(System.Drawing.Color.Blue, 2);
System.Drawing.Pen red = new System.Drawing.Pen(System.Drawing.Color.Red, 2);
System.Drawing.Pen blackPoint = new System.Drawing.Pen(System.Drawing.Color.Black, 5);
System.Drawing.Pen black = new System.Drawing.Pen(System.Drawing.Color.White, 10);
Random rand = new Random();
Bitmap src = new Bitmap((int)VisualElement.ResultImage.Width, (int)VisualElement.ResultImage.Height);
using var graphics = Graphics.FromImage(src);
/* foreach (var sites in triangulation)
* {
* foreach (var edge in sites.Edges)
* {
* graphics.DrawLine(blue, new PointF((float)edge.PointA.X + 300, (float)edge.PointA.Y + 300), new PointF((float)edge.PointB.X + 300, (float)edge.PointB.Y + 300));
* }
* }*/
foreach (var sites in cells)
{
foreach (var edge in sites.Edges)
{
graphics.DrawLine(red, new PointF((float)edge.PointA.X + 300, (float)edge.PointA.Y + 300), new PointF((float)edge.PointB.X + 300, (float)edge.PointB.Y + 300));
}
}
VisualElement.Image = Utilities.BitmapToImageSource(src);
}
public List <Vector2> OnCreateNewTreesForChunk(TerrainChunk chunk)
{
if (chunk.hasCreatedTrees)
{
return(null);
}
float newSizeX = chunk.bounds.size.x / regionSize.x;
float newSizeY = chunk.bounds.size.y / regionSize.y;
points = PoissonDiscSampling.GeneratePoints(radius, regionSize, rejectionSamples);
chunk.hasCreatedTrees = true;
return(points);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
PoissonDiscSampling poissonDisc = target as PoissonDiscSampling;
if (GUILayout.Button("GeneratePoints"))
{
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Restart();
PoissonDiscSampling.circles.Clear();
poissonDisc.GeneratePoints();
Debug.Log(stopwatch.ElapsedMilliseconds.ToString());
}
if (GUILayout.Button("Clear"))
{
PoissonDiscSampling.circles.Clear();
}
}
void GenerateNatureSpawn()
{
Vector2 regionSize = new Vector2((float)size * screenScale, (float)size * screenScale);
if (grassUpdate)
{
List <Vector2> grassPoints = PoissonDiscSampling.GeneratePoints(grassItemRadius, regionSize, grassItemSampleAttempts);
List <Vector3> grassMap = Converter(grassPoints);
List <Vector3> finalGrassPoints = ObjectHeightAdjuster(grassMap);
GrassPlacer(finalGrassPoints);
}
if (flowerUpdate)
{
List <Vector2> flowerPoints = PoissonDiscSampling.GeneratePoints(flowerItemRadius, regionSize, flowerItemSampleAttempts);
List <Vector3> flowerMap = Converter(flowerPoints);
List <Vector3> finalFlowerPoints = ObjectHeightAdjuster(flowerMap);
FlowerPlacer(finalFlowerPoints);
}
if (bushUpdate)
{
List <Vector2> bushPoints = PoissonDiscSampling.GeneratePoints(bushItemRadius, regionSize, bushItemSampleAttempts);
List <Vector3> bushMap = Converter(bushPoints);
List <Vector3> finalBushPoints = ObjectHeightAdjuster(bushMap);
BushPlacer(finalBushPoints);
}
if (rockUpdate)
{
List <Vector2> rockPoints = PoissonDiscSampling.GeneratePoints(rockItemRadius, regionSize, rockItemSampleAttempts);
List <Vector3> rockMap = Converter(rockPoints);
List <Vector3> finalRockPoints = ObjectHeightAdjuster(rockMap);
RockPlacer(finalRockPoints);
}
if (treeUpdate)
{
List <Vector2> treePoints = PoissonDiscSampling.GeneratePoints(treeItemRadius, regionSize, treeItemSampleAttempts);
List <Vector3> treeMap = Converter(treePoints);
List <Vector3> finalTreePoints = ObjectHeightAdjuster(treeMap);
TreePlacer(finalTreePoints);
}
}
public void PoolActors()
{
points = PoissonDiscSampling.GeneratePoints(actorRadius, regionSize, rejectionSamples);
int pointsCounter = 1;
int shapeTypes = System.Enum.GetNames(typeof(Shape)).Length;
int playerType = Random.Range(0, shapeTypes);
GameObject playerPiece = Instantiate(piecePrefab);
ShapePieces shapePiece = playerPiece.GetComponent <ShapePieces>();
shapePiece.Instantiate((Shape)playerType, points[0]);
shapePiece.AllowControl = true;
pieces.Add(shapePiece);
GameObject homeToSpawn = Instantiate(homePrefab);
homeToSpawn.GetComponent <HomePieces>().Instantiate((Shape)playerType, points[pointsCounter]);
homes.Add(homeToSpawn);
pointsCounter++;
for (int i = 0; i < shapeTypes; i++)
{
GameObject pieceToSpawn = Instantiate(piecePrefab);
shapePiece = pieceToSpawn.GetComponent <ShapePieces>();
shapePiece.Instantiate((Shape)i, points[pointsCounter]);
shapePiece.transform.rotation = Quaternion.LookRotation(Vector3.forward, Random.insideUnitCircle);
pointsCounter++;
pieces.Add(shapePiece);
int homesToSpawn = Random.Range(minHomesPerType, maxHomesPerType);
for (int j = 0; j < homesToSpawn; j++)
{
homeToSpawn = Instantiate(homePrefab);
homeToSpawn.GetComponent <HomePieces>().Instantiate((Shape)i, points[pointsCounter]);
homeToSpawn.transform.rotation = Quaternion.LookRotation(Vector3.forward, Random.insideUnitCircle);
homes.Add(homeToSpawn);
pointsCounter++;
}
}
}
public Dictionary <Vector2Int, Chunk> GenerateChunks(Vector2Int position, float[] pointRadiuses, int rejectionSamples)
{
for (int yOffset = -chunksVisibleInViewDst; yOffset <= chunksVisibleInViewDst; yOffset++)
{
for (int xOffset = -chunksVisibleInViewDst; xOffset <= chunksVisibleInViewDst; xOffset++)
{
int coordPairingNumber = MathUtils.SignedCantorPair(position.x + xOffset, position.y + yOffset);
System.Random prng = new System.Random(seed + coordPairingNumber);
Vector2Int viewedChunkCoord = new Vector2Int(position.x + xOffset, position.y + yOffset);
Vector2Int chunkOffset = new Vector2Int((xOffset + position.x) * regionSize.x, (yOffset + position.y) * regionSize.y);
if (!terrainChunkDictionary.ContainsKey(viewedChunkCoord))
{
List <Vector3> points = PoissonDiscSampling.GeneratePoints(pointRadiuses, regionSize, prng, rejectionSamples);
terrainChunkDictionary.Add(viewedChunkCoord, new Chunk(points, chunkOffset, coordPairingNumber));
}
}
}
return(terrainChunkDictionary);
}
private void GenerateRock()
{
for (int i = 0; i < trees.Count; i++)
{
for (int j = 0; j < 10; j++)
{
if (Random.value < rockProbability)
{
continue;
}
Vector2 direction = Random.insideUnitCircle * PoissonDiscSampling.NextGaussian() * rockArea;
Vector3 position = trees[i].transform.position + new Vector3(direction.x, 0, direction.y);
position.y = trees[i].transform.position.y;
Instantiate(rockPrefab, position,
Quaternion.identity);
}
}
}
public void SpawnToothOnPlate(int samplesAmount)
{
points = PoissonDiscSampling.GeneratePoints(radius, regionSize, rejectionSamples, samplesAmount);
int foreachIndex = 0;
for (int i = 0; i < toothesPool.Length; i++)
{
toothesPool[i].SetActive(false);
}
if (points != null)
{
foreach (Vector2 point in points)
{
toothesPool[foreachIndex].transform.localPosition = new Vector3(doctorsPlate.transform.localPosition.x + point.x * 10, doctorsPlate.transform.localPosition.y + point.y * 10, -0.054f);
toothesPool[foreachIndex].SetActive(true);
foreachIndex++;
}
}
}
private void runTest(int samples, double radius)
{
double[] times = new double[samples];
Stopwatch watch = new Stopwatch();
Random rand = new Random();
Console.WriteLine("Cores: " + Environment.ProcessorCount);
Console.WriteLine("64bit:" + Environment.Is64BitProcess + Environment.NewLine);
int count = 0;
for (int s = 0; s < samples; s++)
{
watch.Restart();
List <PoissonDisc> discs = PoissonDiscSampling.Sample2D(13235, radius, new CP.Common.Maths.Vector3D(100, 100, 100), 8, false);
watch.Stop();
count = discs.Count;
times[s] = watch.Elapsed.TotalMilliseconds;
}
Console.WriteLine(samples + ": avg => " + times.Average() + " | best => " + times.Min() + " | worst => " + times.Max() + " | count => " + count);
}
public void Execute(int index)
{
var poissonPointRegionEntity = PoissonPointRegionEntities[index];
var pointRegion = PoissonPointRegions[poissonPointRegionEntity];
var poissonPointBuffer = PoissonPointBuffers[poissonPointRegionEntity].Reinterpret <float2>();
var poissonPoints = PoissonDiscSampling.Sample(
pointRegion.Size.x,
pointRegion.Size.y,
MinimumRadius,
RandomUtility.ParallelForRandomSeed(RandomSeed, index),
PoissonDiscSampling.defaultSamplingResolution,
Allocator.Temp);
var offset = pointRegion.Center - pointRegion.Size / 2f;
for (var i = 0; i < poissonPoints.Length; i++)
{
poissonPoints[i] += offset;
}
poissonPointBuffer.AddRange(poissonPoints);
}
// Start is called before the first frame update
void Start()
{
shapeCreator = GetComponent <ShapeCreator>();
foreach (Shape shape in shapeCreator.shapes)
{
top = -Mathf.Infinity;
left = -Mathf.Infinity;
bottom = Mathf.Infinity;
right = Mathf.Infinity;
// find the edges of the polygon
foreach (Vector3 v in shape.points)
{
if (v.z > top)
{
top = v.z;
}
if (v.z < bottom)
{
bottom = v.z;
}
if (v.x > left)
{
left = v.x;
}
if (v.x < right)
{
right = v.x;
}
}
points = PoissonDiscSampling.GeneratePoints(radius, new Vector2(left, top), new Vector2(right, bottom), shape, rejectionSamples);
foreach (Vector2 point in points)
{
GameObject go = Instantiate(tree, new Vector3(point.x, 10f, point.y), Quaternion.identity);
go.transform.parent = transform.parent;
}
}
}
public void Initiate()
{
polygon = new Polygon();
for (int i = 0; i < pointDensity; i++)
{
var x = Random.Range(.0f, sizeX);
var y = Random.Range(.0f, sizeY);
polygon.Add(new Vertex(x, y));
}
ConstraintOptions constraints = new ConstraintOptions();
constraints.ConformingDelaunay = true;
mesh = polygon.Triangulate() as TriangleNet.Mesh;
points = PoissonDiscSampling.GeneratePoints(radius, regionSize, rejectionSamples);
Debug.Log(points.Count);
ShapeTerrain();
GenerateMesh();
}
void OnValidate()
{
// GeneratePoints(float[] minRadii, float[] radii, Vector2 sampleRegionSize)
points = PoissonDiscSampling.GeneratePoints(minRadii, radius, regionSize);
}
private void OnValidate()
{
points = PoissonDiscSampling.GeneratePoints(radius, regionSize, Vector2.zero, rejectionSamples, 0);
}
void OnValidate()
{
points = PoissonDiscSampling.GeneratePoints(radius, regionSize, rejectionSamples);
}
