Point Distribution on Mesh

2025-01-26 19:40 UTC gpt-4o Open in ChatGPT ↗

You

A function that disgtributes points on a Unity mesh with a probability that is linked to the grayscale value of the vertex collars of the mesh

ChatGPT

Here’s a Unity function to distribute points on a mesh, where the probability of placing a point at a given vertex is based on the grayscale value of the vertex colours. This function assumes the mesh has vertex colours that encode grayscale values (e.g., using Color.r, Color.g, or Color.b).

using System.Collections.Generic;
using UnityEngine;

public class PointDistributor : MonoBehaviour
{
    [SerializeField]
    private Mesh mesh; // Reference to the mesh

    [SerializeField, Range(0, 1)]
    private float probabilityThreshold = 0.5f; // Adjust this to control the density

    [SerializeField]
    private int maxPoints = 1000; // Max number of points to distribute

    private List<Vector3> distributedPoints = new List<Vector3>();

    void Start()
    {
        if (mesh == null)
        {
            mesh = GetComponent<MeshFilter>()?.mesh;
        }

        if (mesh != null)
        {
            DistributePointsOnMesh();
        }
        else
        {
            Debug.LogError("No mesh assigned or found on the object.");
        }
    }

    private void DistributePointsOnMesh()
    {
        distributedPoints.Clear();

        Vector3[] vertices = mesh.vertices;
        Color[] vertexColors = mesh.colors;

        if (vertexColors.Length == 0)
        {
            Debug.LogError("Mesh does not have vertex colors.");
            return;
        }

        for (int i = 0; i < vertices.Length; i++)
        {
            // Extract grayscale value from the vertex colour
            float grayscale = vertexColors[i].r; // Assuming grayscale is stored in the red channel

            // Determine if a point should be placed here based on the grayscale value
            if (Random.value <= grayscale * probabilityThreshold)
            {
                distributedPoints.Add(vertices[i]);

                // Limit the number of points
                if (distributedPoints.Count >= maxPoints)
                    break;
            }
        }

        // Convert points from local to world space
        for (int i = 0; i < distributedPoints.Count; i++)
        {
            distributedPoints[i] = transform.TransformPoint(distributedPoints[i]);
        }

        Debug.Log($"Distributed {distributedPoints.Count} points on the mesh.");
    }

    private void OnDrawGizmos()
    {
        // Visualise the distributed points in the editor
        Gizmos.color = Color.red;
        foreach (var point in distributedPoints)
        {
            Gizmos.DrawSphere(point, 0.05f);
        }
    }
}

How It Works:

1. Mesh Vertex Colours: The function assumes the mesh has per-vertex colours encoded in its colors array. The grayscale value is extracted from the red channel (vertexColors[i].r), which should typically contain the grayscale intensity.

2. Probability Threshold: Points are distributed based on a random check against the grayscale value multiplied by a user-defined probabilityThreshold.

3. Point Distribution: Points are stored in the distributedPoints list. The function ensures that the total number of distributed points does not exceed maxPoints.

4. Gizmos for Visualisation: The points are visualised in the Unity editor as red spheres using the OnDrawGizmos method.

How to Use:

1. Attach this script to a GameObject with a MeshFilter component.
2. Assign a mesh with vertex colours (ensure the colours encode grayscale values).
3. Adjust the probabilityThreshold and maxPoints as needed.
4. Play the scene and observe the distributed points.

This approach enables probabilistic point distribution based on vertex grayscale values, allowing flexible control over how points are placed on the mesh.

You

I said distribute. I didn’t say pick vertices

ChatGPT

Got it! To distribute points across the entire surface of a mesh (not just at the vertices), with probabilities influenced by the grayscale values interpolated across the mesh surface, you’ll need to do the following:

1. Sample the grayscale values across the triangles of the mesh (not just the vertices).
2. Interpolate the probabilities across the surface.
3. Use these probabilities to distribute points proportionally.

Here’s a Unity script that does exactly that:

using System.Collections.Generic;
using UnityEngine;

public class PointDistributor : MonoBehaviour
{
    [SerializeField]
    private Mesh mesh; // Reference to the mesh

    [SerializeField]
    private int numberOfPoints = 1000; // Total points to distribute

    private List<Vector3> distributedPoints = new List<Vector3>();

    void Start()
    {
        if (mesh == null)
        {
            mesh = GetComponent<MeshFilter>()?.mesh;
        }

        if (mesh != null)
        {
            DistributePointsAcrossMesh();
        }
        else
        {
            Debug.LogError("No mesh assigned or found on the object.");
        }
    }

    private void DistributePointsAcrossMesh()
    {
        distributedPoints.Clear();

        Vector3[] vertices = mesh.vertices;
        int[] triangles = mesh.triangles;
        Color[] vertexColors = mesh.colors;

        if (vertexColors.Length == 0)
        {
            Debug.LogError("Mesh does not have vertex colours.");
            return;
        }

        // Create a list of triangle weights based on grayscale values
        List<float> triangleWeights = new List<float>();
        float totalWeight = 0;

        for (int i = 0; i < triangles.Length; i += 3)
        {
            // Get the vertex indices of the triangle
            int index0 = triangles[i];
            int index1 = triangles[i + 1];
            int index2 = triangles[i + 2];

            // Get the grayscale values of the vertices
            float grayscale0 = vertexColors[index0].r;
            float grayscale1 = vertexColors[index1].r;
            float grayscale2 = vertexColors[index2].r;

            // Average grayscale for the triangle
            float averageGrayscale = (grayscale0 + grayscale1 + grayscale2) / 3f;

            // Calculate the area of the triangle
            float area = CalculateTriangleArea(vertices[index0], vertices[index1], vertices[index2]);

            // Weight is proportional to area * average grayscale
            float weight = area * averageGrayscale;
            triangleWeights.Add(weight);

            totalWeight += weight;
        }

        // Normalise weights
        for (int i = 0; i < triangleWeights.Count; i++)
        {
            triangleWeights[i] /= totalWeight;
        }

        // Distribute points based on triangle weights
        for (int i = 0; i < numberOfPoints; i++)
        {
            // Choose a triangle based on its weight
            int chosenTriangle = ChooseTriangleByWeight(triangleWeights);

            // Get the vertex indices of the chosen triangle
            int index0 = triangles[chosenTriangle * 3];
            int index1 = triangles[chosenTriangle * 3 + 1];
            int index2 = triangles[chosenTriangle * 3 + 2];

            // Generate a random point within the triangle
            Vector3 randomPoint = GetRandomPointInTriangle(
                vertices[index0],
                vertices[index1],
                vertices[index2]
            );

            // Convert the point to world space and add to the list
            distributedPoints.Add(transform.TransformPoint(randomPoint));
        }

        Debug.Log($"Distributed {distributedPoints.Count} points on the mesh.");
    }

    private float CalculateTriangleArea(Vector3 v0, Vector3 v1, Vector3 v2)
    {
        // Area of the triangle using cross product
        return Vector3.Cross(v1 - v0, v2 - v0).magnitude / 2f;
    }

    private int ChooseTriangleByWeight(List<float> weights)
    {
        float randomValue = Random.value; // Between 0 and 1
        float cumulativeWeight = 0;

        for (int i = 0; i < weights.Count; i++)
        {
            cumulativeWeight += weights[i];
            if (randomValue <= cumulativeWeight)
            {
                return i;
            }
        }

        return weights.Count - 1; // Fallback to the last triangle
    }

    private Vector3 GetRandomPointInTriangle(Vector3 v0, Vector3 v1, Vector3 v2)
    {
        // Generate random barycentric coordinates
        float u = Random.value;
        float v = Random.value;

        if (u + v > 1f)
        {
            u = 1f - u;
            v = 1f - v;
        }

        return v0 + u * (v1 - v0) + v * (v2 - v0);
    }

    private void OnDrawGizmos()
    {
        // Visualise the distributed points in the editor
        Gizmos.color = Color.red;
        foreach (var point in distributedPoints)
        {
            Gizmos.DrawSphere(point, 0.02f);
        }
    }
}

Key Features of This Script:

1. Probability Weighted by Grayscale:

   • The grayscale value of each vertex is used to calculate the average grayscale value for each triangle.
   • This average, combined with the triangle’s area, determines the likelihood of choosing that triangle.

2. Uniform Point Distribution Within Triangles:

   • Points are distributed uniformly within the selected triangle using barycentric coordinates.

3. Weighted Random Selection:

   • A triangle is chosen based on its weight (area × average grayscale).

How to Use:

1. Attach the script to a GameObject with a MeshFilter component.
2. Assign a mesh that has vertex colours (grayscale values in the red channel).
3. Specify the number of points to distribute in the numberOfPoints field.
4. Play the scene and observe the distribution.

Visualisation:

• The distributed points are visualised as red spheres in the Unity editor using Gizmos.

This method ensures points are evenly distributed across the mesh surface, with probabilities influenced by the grayscale values of the vertex colours. It avoids limiting the distribution to vertices and provides a more realistic surface-based distribution.

You

run the function when a key is pressed. But also instantiate prefabs inside a container, and delete all of them every time a new generation is happening

ChatGPT

Here’s the updated version of the script that runs the point distribution when a specific key is pressed, instantiates prefabs at the distributed points, and deletes all the previously instantiated prefabs before generating a new set. It also places the instantiated prefabs inside a container GameObject for organisation.

using System.Collections.Generic;
using UnityEngine;

public class PointDistributor : MonoBehaviour
{
    [SerializeField]
    private Mesh mesh; // Reference to the mesh

    [SerializeField]
    private GameObject prefab; // Prefab to instantiate at points

    [SerializeField]
    private Transform container; // Parent container for prefabs

    [SerializeField]
    private int numberOfPoints = 1000; // Total points to distribute

    [SerializeField]
    private KeyCode generateKey = KeyCode.G; // Key to trigger point generation

    private List<GameObject> instantiatedPrefabs = new List<GameObject>();

    void Start()
    {
        if (mesh == null)
        {
            mesh = GetComponent<MeshFilter>()?.mesh;
        }

        if (mesh == null)
        {
            Debug.LogError("No mesh assigned or found on the object.");
        }

        if (container == null)
        {
            // Create a default container if not set
            GameObject containerObj = new GameObject("PrefabContainer");
            container = containerObj.transform;
        }
    }

    void Update()
    {
        // Check for key press to generate points and instantiate prefabs
        if (Input.GetKeyDown(generateKey))
        {
            GeneratePointsAndPrefabs();
        }
    }

    private void GeneratePointsAndPrefabs()
    {
        // Clear existing prefabs
        ClearInstantiatedPrefabs();

        // Generate points
        List<Vector3> points = DistributePointsAcrossMesh();

        // Instantiate prefabs at generated points
        foreach (var point in points)
        {
            GameObject instance = Instantiate(prefab, point, Quaternion.identity, container);
            instantiatedPrefabs.Add(instance);
        }

        Debug.Log($"Generated {points.Count} points and instantiated {instantiatedPrefabs.Count} prefabs.");
    }

    private void ClearInstantiatedPrefabs()
    {
        foreach (var obj in instantiatedPrefabs)
        {
            if (obj != null)
            {
                Destroy(obj);
            }
        }

        instantiatedPrefabs.Clear();
    }

    private List<Vector3> DistributePointsAcrossMesh()
    {
        List<Vector3> distributedPoints = new List<Vector3>();

        if (mesh == null)
        {
            Debug.LogError("Mesh is null. Cannot distribute points.");
            return distributedPoints;
        }

        Vector3[] vertices = mesh.vertices;
        int[] triangles = mesh.triangles;
        Color[] vertexColors = mesh.colors;

        if (vertexColors.Length == 0)
        {
            Debug.LogError("Mesh does not have vertex colours.");
            return distributedPoints;
        }

        // Create a list of triangle weights based on grayscale values
        List<float> triangleWeights = new List<float>();
        float totalWeight = 0;

        for (int i = 0; i < triangles.Length; i += 3)
        {
            // Get the vertex indices of the triangle
            int index0 = triangles[i];
            int index1 = triangles[i + 1];
            int index2 = triangles[i + 2];

            // Get the grayscale values of the vertices
            float grayscale0 = vertexColors[index0].r;
            float grayscale1 = vertexColors[index1].r;
            float grayscale2 = vertexColors[index2].r;

            // Average grayscale for the triangle
            float averageGrayscale = (grayscale0 + grayscale1 + grayscale2) / 3f;

            // Calculate the area of the triangle
            float area = CalculateTriangleArea(vertices[index0], vertices[index1], vertices[index2]);

            // Weight is proportional to area * average grayscale
            float weight = area * averageGrayscale;
            triangleWeights.Add(weight);

            totalWeight += weight;
        }

        // Normalise weights
        for (int i = 0; i < triangleWeights.Count; i++)
        {
            triangleWeights[i] /= totalWeight;
        }

        // Distribute points based on triangle weights
        for (int i = 0; i < numberOfPoints; i++)
        {
            // Choose a triangle based on its weight
            int chosenTriangle = ChooseTriangleByWeight(triangleWeights);

            // Get the vertex indices of the chosen triangle
            int index0 = triangles[chosenTriangle * 3];
            int index1 = triangles[chosenTriangle * 3 + 1];
            int index2 = triangles[chosenTriangle * 3 + 2];

            // Generate a random point within the triangle
            Vector3 randomPoint = GetRandomPointInTriangle(
                vertices[index0],
                vertices[index1],
                vertices[index2]
            );

            // Convert the point to world space and add to the list
            distributedPoints.Add(transform.TransformPoint(randomPoint));
        }

        return distributedPoints;
    }

    private float CalculateTriangleArea(Vector3 v0, Vector3 v1, Vector3 v2)
    {
        // Area of the triangle using cross product
        return Vector3.Cross(v1 - v0, v2 - v0).magnitude / 2f;
    }

    private int ChooseTriangleByWeight(List<float> weights)
    {
        float randomValue = Random.value; // Between 0 and 1
        float cumulativeWeight = 0;

        for (int i = 0; i < weights.Count; i++)
        {
            cumulativeWeight += weights[i];
            if (randomValue <= cumulativeWeight)
            {
                return i;
            }
        }

        return weights.Count - 1; // Fallback to the last triangle
    }

    private Vector3 GetRandomPointInTriangle(Vector3 v0, Vector3 v1, Vector3 v2)
    {
        // Generate random barycentric coordinates
        float u = Random.value;
        float v = Random.value;

        if (u + v > 1f)
        {
            u = 1f - u;
            v = 1f - v;
        }

        return v0 + u * (v1 - v0) + v * (v2 - v0);
    }
}

Explanation of the Updates:

1. Key Press:

   • Added an Update method that listens for a key press (generateKey, default: G) to trigger the generation process.

2. Prefab Instantiation:

   • Added a prefab field for assigning a GameObject to instantiate at each generated point.
   • Prefabs are instantiated at each distributed point.

3. Container Management:

   • Added a container field to organise instantiated prefabs under a single GameObject.
   • If container is not set, it creates a new PrefabContainer at runtime.

4. Clearing Old Instances:

   • The ClearInstantiatedPrefabs method removes all previously instantiated prefabs before generating a new set.

Usage:

1. Assign this script to a GameObject with a MeshFilter.
2. Set a prefab in the Prefab field (e.g., a cube or sphere).
3. Press the GenerateKey (default is G) to generate points and spawn prefabs.
4. Watch as the old prefabs are deleted, and a new set is generated on the mesh.

This setup ensures clean generations while keeping everything organised.