Optimise code for beginners

2025-01-30 23:16 UTC gpt-4o Open in ChatGPT ↗

align with this

using UnityEngine;

public class SimpleGenerator : MonoBehaviour { public GameObject prefab;

[Range(1,10000)]
public int count;

[Range(0.5f, 100)]
public float circleRadius;


// Start is called once before the first execution of Update after the MonoBehaviour is created
void Start()
{

    for (int i = 0; i < count; i++)
    {
        // Generate random position on the plane, and scale it
        var random2D = circleRadius * Random.insideUnitCircle;

        // Generate a random rotation
        var randomRot = Random.rotation;

        // Pick Random Names
        var randomNameIndex = Random.Range(0, DataHolder.NAMES.Length);
        var randomName = DataHolder.NAMES[randomNameIndex];
        var randomSurname = DataHolder.SURNAMES[randomNameIndex];


        // instantiate a new object and place it as a child of this generator object
        var go = Instantiate(prefab,
            new Vector3(random2D.x, 0, random2D.y),
            randomRot,
            transform);

        // This means: this generator will be the parent of the  "go" object
        // go.transform.parent = transform;

        go.name = $"id: {i} | Name: {randomName} | Surname: {randomSurname}";
      //  Debug.Log(go.name);

       var script = go.GetComponent<MyFirstScript>();

       // Error handling
       if (script != null)
       {
           script.personName = randomName;
           script.personSurname = randomSurname;
           script.personAge = Random.Range(0, 100);
           script.personHeight = Random.Range(120.0f, 200.0f);
           script.agingRate = Random.Range(0.5f, 10f);
           script.personGender = (Gender) Random.Range(0, 3);
           script.id = i;
       }
    }
}

// Update is called once per frame
void Update()
{

}

}

but also align with this, in term of prefab generation logic

using System; using System.Collections.Generic; using UnityEngine; using Random = UnityEngine.Random;

public class RandomPointOnMesh : MonoBehaviour { // Assign these in the Unity Inspector public MeshFilter mf; // Reference to the mesh filter component public GameObject prefab; // Prefab to instantiate on the mesh public Transform container; // Parent object to hold instantiated prefabs public KeyCode trigger = KeyCode.G; // Key to trigger point generation

[Range(1,10)]
public float scale = 1; // Scale of the instantiated objects
public int pointCount = 10; // Number of points to generate

private Vector3[] vertices; // Array storing mesh vertices
private int[] triangleIndices; // Array storing triangle indices
private List<GameObject> instantiatedPrefabs = new List<GameObject>(); // List to store created prefabs

public Vector3[] pts; // Array storing generated points
public Vector3[] norms; // Array storing corresponding normals

void Start()
{
    // Get mesh data from the MeshFilter
    var sharedMesh = mf.sharedMesh;
    vertices = sharedMesh.vertices;
    triangleIndices = sharedMesh.triangles;

    instantiatedPrefabs = new List<GameObject>(); // Initialise the prefab list
}

void Update()
{
    // Check if the trigger key is pressed
    if (Input.GetKeyDown(trigger))
    {
        // Initialise point and normal arrays
        pts = new Vector3[pointCount];
        norms = new Vector3[pointCount];

        // Clear any previously instantiated prefabs
        ClearInstantiatedPrefabs();

        // Generate and place new prefabs
        for (int i = 0; i < pointCount; i++)
        {
            // Select a random triangle
            var triangle = Random.Range(0, triangleIndices.Length / 3) * 3;

            // Generate a random point on the selected triangle
            var (pt, norm) = Generate(vertices, triangleIndices, mf.transform, triangle);

            // Create a random rotation along the Y-axis
            var rot = Quaternion.Euler(0, Random.Range(-180f, 180f), 0);

            // Instantiate the prefab at the generated position with proper rotation
            var go = Instantiate(prefab, pt, Quaternion.FromToRotation(Vector3.up, -norm) * rot, container);

            // Set the scale of the instantiated object
            go.transform.localScale = new Vector3(scale, scale, scale);

            // Store the created object and generated values
            instantiatedPrefabs.Add(go);
            pts[i] = pt;
            norms[i] = norm;
        }
    }
}

private void OnDrawGizmos()
{
    if (pts == null) return; // Avoid errors if no points exist

    // Draw rays at each generated point to visualize normals
    for (int i = 0; i < pts.Length; i++)
    {
        Gizmos.DrawRay(pts[i], norms[i]);
    }
}

private void ClearInstantiatedPrefabs()
{
    // Remove and destroy all instantiated prefabs
    foreach (var obj in instantiatedPrefabs)
    {
        if (obj != null)
        {
            Destroy(obj);
        }
    }
    instantiatedPrefabs.Clear(); // Clear the list
}

// Generates a random point on a triangle and calculates the normal
private static (Vector3, Vector3) Generate(Vector3[] verts, int[] tris, Transform xform, int triangleIndex)
{
    // Get the vertex indices of the triangle
    var i_A = tris[triangleIndex];
    var i_B = tris[triangleIndex + 1];
    var i_C = tris[triangleIndex + 2];

    // Retrieve the actual vertex positions
    var v_A = verts[i_A];
    var v_B = verts[i_B];
    var v_C = verts[i_C];

    // Compute two edges of the triangle
    var AB = v_A - v_B;
    var CB = v_C - v_B;

    // Generate a random point inside the triangle
    var newPointOnMesh = GetRandomPointInTriangle(v_A, v_B, v_C);

    // Compute the normal of the triangle using cross product
    var normal = Vector3.Cross(AB.normalized, CB.normalized);

    // Convert local space positions to world space
    newPointOnMesh = xform.TransformPoint(newPointOnMesh);
    normal = xform.TransformDirection(normal);

    return (newPointOnMesh, normal);
}

// Computes a random point inside a triangle using barycentric coordinates
private static Vector3 GetRandomPointInTriangle(Vector3 v0, Vector3 v1, Vector3 v2)
{
    float u = Random.value;
    float v = Random.value;

    // Ensure the point is inside the triangle
    if (u + v > 1f)
    {
        u = 1f - u;
        v = 1f - v;
    }

    // Compute the final position
    return v0 + u * (v1 - v0) + v * (v2 - v0);
}

}