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); }