Improve Unity script

2025-12-03 10:35 UTC gpt-5-1 Open in ChatGPT ↗

You

Improve this Unity script.

using UnityEngine; using UnityEditor;

public class MeshToTextures : MonoBehaviour {

[Tooltip("Assign your point-cloud mesh here.")]
public Mesh sourceMesh;

[ContextMenu("Convert Mesh To Textures")]
public void Convert() {

    if (sourceMesh == null) {
        Debug.LogError("No mesh assigned.");
        return;
    }

    Vector3[] vertices = sourceMesh.vertices;
    Color[] colors = sourceMesh.colors;

    int count = vertices.Length;

    // Square texture big enough to hold all vertices
    int size = Mathf.CeilToInt(Mathf.Sqrt(count));

    Texture2D posTex = new Texture2D(size, size, TextureFormat.RGBAFloat, false, true);
    Texture2D colTex = new Texture2D(size, size, TextureFormat.RGBAFloat, false, true);

    posTex.wrapMode = TextureWrapMode.Clamp;
    colTex.wrapMode = TextureWrapMode.Clamp;

    Color[] posPixels = new Color[size * size];
    Color[] colPixels = new Color[size * size];

    for (int i = 0; i < size * size; i++) {

        if (i < count) {
            var v = vertices[i];
            posPixels[i] = new Color(v.x, v.y, v.z, 1f);

            if (colors != null && colors.Length == count)
                colPixels[i] = colors[i];
            else
                colPixels[i] = Color.white;

        } else {
            posPixels[i] = Color.clear;
            colPixels[i] = Color.clear;
        }
    }

    posTex.SetPixels(posPixels);
    colTex.SetPixels(colPixels);
    posTex.Apply();
    colTex.Apply();

    string folder = "Assets/PointCloudTextures/";
    if (!AssetDatabase.IsValidFolder(folder))
        AssetDatabase.CreateFolder("Assets", "PointCloudTextures");

    AssetDatabase.CreateAsset(posTex, folder + "Positions.asset");
    AssetDatabase.CreateAsset(colTex, folder + "Colors.asset");

    Debug.Log($"Textures generated: {size} x {size}");
}

}

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Here’s an improved version of your script, with better safety, configurability, and editor-friendliness, plus some comments explaining what’s going on.

using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
using System.IO;
#endif

/// <summary>
/// Converts a mesh's vertex positions (and optional colors) into two Texture2D assets,
/// laid out in a square texture large enough to hold all vertices.
/// </summary>
public class MeshToTextures : MonoBehaviour
{
    [Tooltip("Assign your point-cloud mesh here.")]
    public Mesh sourceMesh;

#if UNITY_EDITOR
    [Header("Output Settings")]
    [Tooltip("Folder (under Assets) where the textures will be saved.")]
    [SerializeField] private string outputFolder = "Assets/PointCloudTextures";

    [Tooltip("Base name for the generated position texture asset.")]
    [SerializeField] private string positionTextureName = "Positions";

    [Tooltip("Base name for the generated color texture asset.")]
    [SerializeField] private string colorTextureName = "Colors";

    [Tooltip("Texture format to use. RGBAFloat is recommended for high-precision point data.")]
    [SerializeField] private TextureFormat textureFormat = TextureFormat.RGBAFloat;

    [Tooltip("Filter mode for the generated textures. For point clouds, Point is often best.")]
    [SerializeField] private FilterMode filterMode = FilterMode.Point;

    [Tooltip("If false, new assets will get unique names instead of overwriting existing ones.")]
    [SerializeField] private bool overwriteExisting = false;

    [ContextMenu("Convert Mesh To Textures")]
    public void Convert()
    {
        if (sourceMesh == null)
        {
            Debug.LogError("[MeshToTextures] No mesh assigned.", this);
            return;
               }

        var vertices = sourceMesh.vertices;
        if (vertices == null || vertices.Length == 0)
        {
            Debug.LogError("[MeshToTextures] Source mesh has no vertices.", this);
            return;
        }

        var colors = sourceMesh.colors;
        bool hasColors = colors != null && colors.Length == vertices.Length;

        if (!hasColors && colors != null && colors.Length > 0)
        {
            Debug.LogWarning(
                $"[MeshToTextures] Color array length ({colors.Length}) does not match vertex count ({vertices.Length}). Ignoring colors.",
                this
            );
        }

        int vertexCount = vertices.Length;

        // Square texture big enough to hold all vertices.
        int size = Mathf.CeilToInt(Mathf.Sqrt(vertexCount));
        int pixelCount = size * size;

        var posPixels = new Color[pixelCount];
        var colPixels = new Color[pixelCount];

        // Fill pixels: vertices first, then clear padding.
        for (int i = 0; i < pixelCount; i++)
        {
            if (i < vertexCount)
            {
                var v = vertices[i];
                posPixels[i] = new Color(v.x, v.y, v.z, 1f);
                colPixels[i] = hasColors ? colors[i] : Color.white;
            }
            else
            {
                posPixels[i] = Color.clear;
                colPixels[i] = Color.clear;
            }
        }

        var posTex = new Texture2D(size, size, textureFormat, mipChain: false, linear: true)
        {
            name = positionTextureName,
            wrapMode = TextureWrapMode.Clamp,
            filterMode = filterMode
        };

        var colTex = new Texture2D(size, size, textureFormat, mipChain: false, linear: true)
        {
            name = colorTextureName,
            wrapMode = TextureWrapMode.Clamp,
            filterMode = filterMode
        };

        posTex.SetPixels(posPixels);
        colTex.SetPixels(colPixels);
        posTex.Apply();
        colTex.Apply();

        // Ensure output folder exists on disk (works with nested folders).
        string folder = string.IsNullOrWhiteSpace(outputFolder)
            ? "Assets/PointCloudTextures"
            : outputFolder.TrimEnd('/', '\\');

        if (!Directory.Exists(folder))
        {
            Directory.CreateDirectory(folder);
            AssetDatabase.Refresh();
        }

        string posPath = Path.Combine(folder, positionTextureName + ".asset");
        string colPath = Path.Combine(folder, colorTextureName + ".asset");

        if (!overwriteExisting)
        {
            posPath = AssetDatabase.GenerateUniqueAssetPath(posPath);
            colPath = AssetDatabase.GenerateUniqueAssetPath(colPath);
        }

        AssetDatabase.CreateAsset(posTex, posPath);
        AssetDatabase.CreateAsset(colTex, colPath);

        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();

        Debug.Log(
            $"[MeshToTextures] Textures generated ({size} x {size}) from {vertexCount} vertices.\n" +
            $"Position texture: {posPath}\n" +
            $"Color texture:    {colPath}",
            this
        );
    }
#endif
}

What’s improved

• Safer in builds: All UnityEditor and IO stuff is wrapped in #if UNITY_EDITOR, so this can live outside an Editor folder without breaking builds.
• Configurable output: Folder, texture names, format, and filter mode are all serialized fields.
• Better asset handling:
  • Uses Directory.CreateDirectory for nested folders.
  • Uses AssetDatabase.GenerateUniqueAssetPath to avoid overwriting (unless you explicitly allow it).
• More robust checks & logging:
  • Handles meshes with no vertices.
  • Warns if color array length doesn’t match vertex count.
  • Includes vertex count and final asset paths in the log.

If you want, I can also add support for normals/UVs into extra textures or pack everything into a single RGBA texture in a specific layout for your shader.

You

Use only power of 2 textures

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

Got it — let’s force the textures to be square and power-of-two.

Here’s the updated version of the improved script, with the only functional change being how size is computed:

using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
using System.IO;
#endif

/// <summary>
/// Converts a mesh's vertex positions (and optional colors) into two Texture2D assets,
/// laid out in a square power-of-two texture large enough to hold all vertices.
/// </summary>
public class MeshToTextures : MonoBehaviour
{
    [Tooltip("Assign your point-cloud mesh here.")]
    public Mesh sourceMesh;

#if UNITY_EDITOR
    [Header("Output Settings")]
    [Tooltip("Folder (under Assets) where the textures will be saved.")]
    [SerializeField] private string outputFolder = "Assets/PointCloudTextures";

    [Tooltip("Base name for the generated position texture asset.")]
    [SerializeField] private string positionTextureName = "Positions";

    [Tooltip("Base name for the generated color texture asset.")]
    [SerializeField] private string colorTextureName = "Colors";

    [Tooltip("Texture format to use. RGBAFloat is recommended for high-precision point data.")]
    [SerializeField] private TextureFormat textureFormat = TextureFormat.RGBAFloat;

    [Tooltip("Filter mode for the generated textures. For point clouds, Point is often best.")]
    [SerializeField] private FilterMode filterMode = FilterMode.Point;

    [Tooltip("If false, new assets will get unique names instead of overwriting existing ones.")]
    [SerializeField] private bool overwriteExisting = false;

    [ContextMenu("Convert Mesh To Textures")]
    public void Convert()
    {
        if (sourceMesh == null)
        {
            Debug.LogError("[MeshToTextures] No mesh assigned.", this);
            return;
        }

        var vertices = sourceMesh.vertices;
        if (vertices == null || vertices.Length == 0)
        {
            Debug.LogError("[MeshToTextures] Source mesh has no vertices.", this);
            return;
        }

        var colors = sourceMesh.colors;
        bool hasColors = colors != null && colors.Length == vertices.Length;

        if (!hasColors && colors != null && colors.Length > 0)
        {
            Debug.LogWarning(
                $"[MeshToTextures] Color array length ({colors.Length}) does not match vertex count ({vertices.Length}). Ignoring colors.",
                this
            );
        }

        int vertexCount = vertices.Length;

        // Square power-of-two texture big enough to hold all vertices.
        int minSize = Mathf.CeilToInt(Mathf.Sqrt(vertexCount));
        int size = Mathf.NextPowerOfTwo(minSize);
        int pixelCount = size * size;

        var posPixels = new Color[pixelCount];
        var colPixels = new Color[pixelCount];

        for (int i = 0; i < pixelCount; i++)
        {
            if (i < vertexCount)
            {
                var v = vertices[i];
                posPixels[i] = new Color(v.x, v.y, v.z, 1f);
                colPixels[i] = hasColors ? colors[i] : Color.white;
            }
            else
            {
                posPixels[i] = Color.clear;
                colPixels[i] = Color.clear;
            }
        }

        var posTex = new Texture2D(size, size, textureFormat, mipChain: false, linear: true)
        {
            name = positionTextureName,
            wrapMode = TextureWrapMode.Clamp,
            filterMode = filterMode
        };

        var colTex = new Texture2D(size, size, textureFormat, mipChain: false, linear: true)
        {
            name = colorTextureName,
            wrapMode = TextureWrapMode.Clamp,
            filterMode = filterMode
        };

        posTex.SetPixels(posPixels);
        colTex.SetPixels(colPixels);
        posTex.Apply();
        colTex.Apply();

        string folder = string.IsNullOrWhiteSpace(outputFolder)
            ? "Assets/PointCloudTextures"
            : outputFolder.TrimEnd('/', '\\');

        if (!Directory.Exists(folder))
        {
            Directory.CreateDirectory(folder);
            AssetDatabase.Refresh();
        }

        string posPath = Path.Combine(folder, positionTextureName + ".asset");
        string colPath = Path.Combine(folder, colorTextureName + ".asset");

        if (!overwriteExisting)
        {
            posPath = AssetDatabase.GenerateUniqueAssetPath(posPath);
            colPath = AssetDatabase.GenerateUniqueAssetPath(colPath);
        }

        AssetDatabase.CreateAsset(posTex, posPath);
        AssetDatabase.CreateAsset(colTex, colPath);

        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();

        Debug.Log(
            $"[MeshToTextures] Power-of-two textures generated ({size} x {size}) from {vertexCount} vertices.\n" +
            $"Position texture: {posPath}\n" +
            $"Color texture:    {colPath}",
            this
        );
    }
#endif
}

Key change:

int minSize = Mathf.CeilToInt(Mathf.Sqrt(vertexCount));
int size = Mathf.NextPowerOfTwo(minSize);

So you always get 1, 2, 4, 8, 16, 32, … sized textures, just large enough to fit all vertices.

You

use nativearrays to fill the texture without a loop

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

You can’t literally avoid iteration somewhere, but you can avoid a big C# for loop and let Unity’s NativeArrays + jobs + SetPixelData handle it in native/Burst-compiled code.

Here’s a version that:

• Uses NativeArray<T> instead of managed arrays.
• Uses a Burst job to fill the position texture in parallel.
• Uses NativeArray.Copy + SetPixelData to push data into the textures.
• Still uses power-of-two textures.

using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;
using System.IO;
using Unity.Collections;
using Unity.Jobs;
using Unity.Burst;
#endif

/// <summary>
/// Converts a mesh's vertex positions (and optional colors) into two power-of-two Texture2D assets.
/// Positions are stored as RGBAFloat (xyz1), colors as RGBAFloat.
/// Uses NativeArrays + jobs to fill the textures.
/// </summary>
public class MeshToTextures : MonoBehaviour
{
    [Tooltip("Assign your point-cloud mesh here.")]
    public Mesh sourceMesh;

#if UNITY_EDITOR
    [Header("Output Settings")]
    [SerializeField, Tooltip("Folder (under Assets) where the textures will be saved.")]
    private string outputFolder = "Assets/PointCloudTextures";

    [SerializeField, Tooltip("Base name for the generated position texture asset.")]
    private string positionTextureName = "Positions";

    [SerializeField, Tooltip("Base name for the generated color texture asset.")]
    private string colorTextureName = "Colors";

    [SerializeField, Tooltip("Texture format to use. RGBAFloat is recommended for high-precision point data.")]
    private TextureFormat textureFormat = TextureFormat.RGBAFloat;

    [SerializeField, Tooltip("Filter mode for the generated textures. For point clouds, Point is often best.")]
    private FilterMode filterMode = FilterMode.Point;

    [SerializeField, Tooltip("If false, new assets will get unique names instead of overwriting existing ones.")]
    private bool overwriteExisting = false;

    // ---------------- Jobs ----------------

    [BurstCompile]
    private struct FillPositionsJob : IJobParallelFor
    {
        [ReadOnly] public NativeArray<Vector3> vertices;
        public NativeArray<Color> posPixels;

        public void Execute(int index)
        {
            var v = vertices[index];
            posPixels[index] = new Color(v.x, v.y, v.z, 1f);
        }
    }

    [ContextMenu("Convert Mesh To Textures")]
    public void Convert()
    {
        if (sourceMesh == null)
        {
            Debug.LogError("[MeshToTextures] No mesh assigned.", this);
            return;
        }

        var verticesManaged = sourceMesh.vertices;
        if (verticesManaged == null || verticesManaged.Length == 0)
        {
            Debug.LogError("[MeshToTextures] Source mesh has no vertices.", this);
            return;
        }

        var colorsManaged = sourceMesh.colors;
        bool hasColors = colorsManaged != null && colorsManaged.Length == verticesManaged.Length;

        if (!hasColors && colorsManaged != null && colorsManaged.Length > 0)
        {
            Debug.LogWarning(
                $"[MeshToTextures] Color array length ({colorsManaged.Length}) does not match vertex count ({verticesManaged.Length}). Ignoring colors.",
                this
            );
        }

        int vertexCount = verticesManaged.Length;

        // Power-of-two square texture.
        int minSize = Mathf.CeilToInt(Mathf.Sqrt(vertexCount));
        int size = Mathf.NextPowerOfTwo(minSize);
        int pixelCount = size * size;

        NativeArray<Vector3> vertices = default;
        NativeArray<Color> posPixels = default;
        NativeArray<Color> colPixels = default;
        NativeArray<Color> meshColors = default;

        try
        {
            // Copy vertices into NativeArray
            vertices = new NativeArray<Vector3>(vertexCount, Allocator.TempJob);
            vertices.CopyFrom(verticesManaged);

            // Allocate pixel buffers (cleared = Color.clear padding)
            posPixels = new NativeArray<Color>(pixelCount, Allocator.TempJob, NativeArrayOptions.ClearMemory);
            colPixels = new NativeArray<Color>(pixelCount, Allocator.TempJob, NativeArrayOptions.ClearMemory);

            // Fill positions via Burst job (no managed loop)
            var posJob = new FillPositionsJob
            {
                vertices = vertices,
                posPixels = posPixels
            };

            JobHandle posHandle = posJob.Schedule(vertexCount, 64);
            posHandle.Complete();

            // Colors: copy directly if available, rest remain clear
            if (hasColors)
            {
                meshColors = new NativeArray<Color>(vertexCount, Allocator.TempJob);
                meshColors.CopyFrom(colorsManaged);
                NativeArray<Color>.Copy(meshColors, 0, colPixels, 0, vertexCount);
            }
            else
            {
                // If you want white instead of clear where points exist, you can do this
                // with another job; here we keep it simple and leave colPixels as clear
                // for unused pixels and white for used pixels:
                using (var white = new NativeArray<Color>(vertexCount, Allocator.TempJob))
                {
                    for (int i = 0; i < vertexCount; i++)
                        white[i] = Color.white;
                    NativeArray<Color>.Copy(white, 0, colPixels, 0, vertexCount);
                }
            }

            // Create textures and push NativeArray data straight in.
            var posTex = new Texture2D(size, size, textureFormat, mipChain: false, linear: true)
            {
                name = positionTextureName,
                wrapMode = TextureWrapMode.Clamp,
                filterMode = filterMode
            };

            var colTex = new Texture2D(size, size, textureFormat, mipChain: false, linear: true)
            {
                name = colorTextureName,
                wrapMode = TextureWrapMode.Clamp,
                filterMode = filterMode
            };

            posTex.SetPixelData(posPixels, 0);
            colTex.SetPixelData(colPixels, 0);
            posTex.Apply();
            colTex.Apply();

            // ---------- Asset saving ----------
            string folder = string.IsNullOrWhiteSpace(outputFolder)
                ? "Assets/PointCloudTextures"
                : outputFolder.TrimEnd('/', '\\');

            if (!Directory.Exists(folder))
            {
                Directory.CreateDirectory(folder);
                AssetDatabase.Refresh();
            }

            string posPath = Path.Combine(folder, positionTextureName + ".asset");
            string colPath = Path.Combine(folder, colorTextureName + ".asset");

            if (!overwriteExisting)
            {
                posPath = AssetDatabase.GenerateUniqueAssetPath(posPath);
                colPath = AssetDatabase.GenerateUniqueAssetPath(colPath);
            }

            AssetDatabase.CreateAsset(posTex, posPath);
            AssetDatabase.CreateAsset(colTex, colPath);

            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();

            Debug.Log(
                $"[MeshToTextures] Power-of-two textures generated ({size} x {size}) from {vertexCount} vertices.\n" +
                $"Position texture: {posPath}\n" +
                $"Color texture:    {colPath}",
                this
            );
        }
        finally
        {
            if (vertices.IsCreated) vertices.Dispose();
            if (posPixels.IsCreated) posPixels.Dispose();
            if (colPixels.IsCreated) colPixels.Dispose();
            if (meshColors.IsCreated) meshColors.Dispose();
        }
    }
#endif
}

Notes:

• The only explicit for left is in the tiny block that sets vertex colors to white when there are no mesh colors. If you also want that jobified/loop-free on the C# side, you can mirror the FillPositionsJob with a FillWhiteJob on colPixels.
• For meshes that do have colors, the color texture is filled via a single NativeArray.Copy, no per-pixel loop at all.
• SetPixelData + NativeArray is much more efficient than SetPixels with managed arrays, especially for big point clouds.