Example #1
0
    List <Vector3> GeneratePoisson(float width, float height, float minDistance, int tries)
    {
        var   points   = new List <Vector3>();
        float cellSize = minDistance / Mathf.Sqrt(2f);
        var   grid     = new Vector3[Mathf.CeilToInt(width / cellSize), Mathf.CeilToInt(height / cellSize)];

        for (int x = 0; x <= grid.GetUpperBound(0); x++)
        {
            for (int y = 0; y <= grid.GetUpperBound(1); y++)
            {
                grid[x, y] = Vector3.positiveInfinity;
            }
        }
        var processPoints = new List <Vector3>();
        var firstPoint    = new Vector3(Random.Range(0, width), 0, Random.Range(0, height));

        points.Add(firstPoint);
        processPoints.Add(firstPoint);
        InsertPointIntoGrid(firstPoint, ref grid, cellSize);

        while (processPoints.Count > 0)
        {
            Vector3 activePoint   = processPoints[Random.Range(0, processPoints.Count)];
            bool    foundNewPoint = false;
            for (int i = 0; i < tries; i++)
            {
                var newPoint = GenerateRandomPointNear(activePoint, minDistance);
                if (newPoint.x >= 0f && newPoint.x <= width &&
                    newPoint.z >= 0f && newPoint.z <= height &&
                    !HasCloseNeighbor(newPoint, ref grid, cellSize, minDistance))
                {
                    foundNewPoint = true;
                    processPoints.Add(newPoint);
                    points.Add(newPoint);
                    InsertPointIntoGrid(newPoint, ref grid, cellSize);
                    break;
                }
            }
            if (!foundNewPoint)
            {
                processPoints.Remove(activePoint);
            }
        }

        return(points);
    }
Example #2
0
    private void DrawDebugCircle(Vector3 debugCircleCenter, float debugCircleRadius, int debugCircleVertices, Color debugCircleColor)
    {
        Vector3[] visionCircle = new Vector3[debugCircleVertices];
        float     degree       = (float)360 / debugCircleVertices;

        for (int i = 0; i < debugCircleVertices; i++)
        {
            Vector3 newPoint = new Vector3(
                (Mathf.Cos((degree * i) * Mathf.Deg2Rad) * debugCircleRadius) + debugCircleCenter.x, 0,
                (Mathf.Sin((degree * i) * Mathf.Deg2Rad) * debugCircleRadius) + debugCircleCenter.z);
            visionCircle[i] = newPoint;
        }
        Vector3 lastPt = visionCircle[visionCircle.GetUpperBound(0)];

        foreach (Vector3 pt in visionCircle)
        {
            Debug.DrawLine(lastPt, pt, debugCircleColor);
            lastPt = pt;
        }
    }
Example #3
0
    List <Vector3[, ]> CutVertical(Vector3[,] initalArray)
    {
        List <Vector3[, ]> itemList = new List <Vector3[, ]>();

        Vector3[,] arrayBlock = new Vector3[(initalArray.GetUpperBound(0) / 2) + 1, initalArray.GetUpperBound(1) + 1];

        for (int z = 0; z <= initalArray.GetUpperBound(1); z++)
        {
            for (int x = 0; x <= initalArray.GetUpperBound(0) / 2 - 1; x++)
            {
                // Gizmos.color = Color.green;
                // Gizmos.DrawSphere(initalArray[x, z], 0.5f);
                arrayBlock[x, z] = initalArray[x, z];
            }
        }

        itemList.Add(arrayBlock);

        Vector3[,] UpdatedInitArry = new Vector3[arrayBlock.GetUpperBound(0), arrayBlock.GetUpperBound(1) + 1];

        // print($"Updated Init array Size x:{UpdatedInitArry.GetUpperBound(0)} z: {UpdatedInitArry.GetUpperBound(1)}");

        for (int z = 0, zIndex = 0; z <= arrayBlock.GetUpperBound(1); z++, zIndex++)

        {
            for (int x = arrayBlock.GetUpperBound(0) + 1, xIndex = 0; x <= initalArray.GetUpperBound(0); x++, xIndex++)
            {
                // Gizmos.color = Color.red;
                // Gizmos.DrawSphere(initalArray[x, z], 0.5f);
                UpdatedInitArry[xIndex, zIndex] = initalArray[x, z];
            }
        }

        itemList.Add(UpdatedInitArry);


        for (int z = 0; z < arrayBlock.GetUpperBound(1) + 1; z++)
        {
            // Gizmos.color = Color.magenta;
            // Gizmos.DrawSphere(initalArray[arrayBlock.GetUpperBound(0), z], 0.5f);
            removeObject.Add(initalArray[arrayBlock.GetUpperBound(0), z]);
        }


        return(itemList);
    }
Example #4
0
    List <Vector3[, ]> CutHorizontal(Vector3[,] initalArray)
    {
        List <Vector3[, ]> itemList = new List <Vector3[, ]>();

        Vector3[,] arrayBlock = new Vector3[initalArray.GetUpperBound(0) + 1, (initalArray.GetUpperBound(1) / 2) + 1];

        for (int z = 0; z <= initalArray.GetUpperBound(1) / 2 - 1; z++)
        {
            for (int x = 0; x <= initalArray.GetUpperBound(0); x++)
            {
                // Gizmos.color = Color.blue;
                // Gizmos.DrawSphere(initalArray[x, z], 0.05f);
                arrayBlock[x, z] = initalArray[x, z];
            }
        }

        itemList.Add(arrayBlock);

        Vector3[,] UpdatedInitArry = new Vector3[arrayBlock.GetUpperBound(0) + 1, arrayBlock.GetUpperBound(1) + 1];
        // print($"x: {UpdatedInitArry.GetUpperBound(0)}, z: {UpdatedInitArry.GetUpperBound(1)}");


        for (int z = arrayBlock.GetUpperBound(1) + 1, zIndex = 0; z <= initalArray.GetUpperBound(1); z++, zIndex++)

        {
            for (int x = 0, xIndex = 0; x <= arrayBlock.GetUpperBound(0); x++, xIndex++)
            {
                // Gizmos.color = Color.green;
                // Gizmos.DrawSphere(initalArray[x, z], 0.05f);
                UpdatedInitArry[xIndex, zIndex] = initalArray[x, z];
            }

            print("ran");
        }

        itemList.Add(UpdatedInitArry);
        for (int x = 0; x < arrayBlock.GetUpperBound(0) + 1; x++)
        {
            // Gizmos.color = Color.magenta;
            // Gizmos.DrawSphere(initalArray[x, arrayBlock.GetUpperBound(1)], 0.05f);
            removeObject.Add(initalArray[x, arrayBlock.GetUpperBound(1)]);
        }

        return(itemList);
    }
        /// <summary>
        ///		Copies the entire <c>Vector3List</c> to a one-dimensional
        ///		<see cref="Vector3"/> array, starting at the specified index of the target array.
        /// </summary>
        /// <param name="array">The one-dimensional <see cref="Vector3"/> array to copy to.</param>
        /// <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
        public virtual void CopyTo(Vector3[] array, int start) {
            if (this.m_count > array.GetUpperBound(0) + 1 - start) {
                throw new System.ArgumentException("Destination array was not long enough.");
            }

            Array.Copy(this.m_array, 0, array, start, this.m_count);
        }
Example #6
0
    public void DrawVertices(Vector3[,,] vertexMatrix, bool drawOnPlay = false)
    {
        //do not draw vertices when playing, this is a performance hog
        if(Application.isPlaying && !drawOnPlay)
        return;

        Gizmos.color = vertexColor;

        for(int i=0;  i<= vertexMatrix.GetUpperBound(0); i++){
            for(int j=0;  j<= vertexMatrix.GetUpperBound(1); j++){
                for(int k=0;  k<= vertexMatrix.GetUpperBound(2); k++){
                    Gizmos.DrawSphere(vertexMatrix[i,j,k], 0.3f);
                }
            }
        }
    }
Example #7
0
 // return an entry from the vertex matrix in a cartesian fashion (central vertex is (0,0,0), first component is the x-axis, second one the y-axis,
 // third one the z-axis
 public override Vector3 ReadVertexMatrix(int x, int y, int z, Vector3[,,] vertexMatrix, bool warning = false)
 {
     if(Mathf.Abs(x)>vertexMatrix.GetUpperBound(0)/2 || Mathf.Abs(y) >vertexMatrix.GetUpperBound(1)/2 || Mathf.Abs(z) >vertexMatrix.GetUpperBound(2)/2){
         if(warning)
             Debug.LogWarning("coordinates too large for this matrix, will default to " + Vector3.zero);
         return vertexMatrix[(vertexMatrix.GetUpperBound(0)/2), (vertexMatrix.GetUpperBound(1)/2), (vertexMatrix.GetUpperBound(2)/2)];
     }
     return vertexMatrix[(vertexMatrix.GetUpperBound(0)/2) - x, (vertexMatrix.GetUpperBound(1)/2) - y, (vertexMatrix.GetUpperBound(2)/2) - z];
 }