Unity CSV Prefab Loader

2025-05-21 15:16 UTC gpt-4-5 Open in ChatGPT ↗

You

Write a Professional Unity 6000.1 script that loads this csv and populates the scene with assets. the point is for object to share meshes.

The script searches for prefabs by name to Instantiate them

ChatGPT

Based on the structure of your CSV file, here’s a professional Unity (C#) script (Unity 6000.1) that will:

• Load and parse the CSV file.
• Instantiate prefabs by matching ModelName with prefab names.
• Set each instantiated object’s position, rotation, and scale based on the CSV data.
• Reuse meshes through prefab instantiation, which is naturally efficient in Unity.

Here’s the Unity script:

ChatGPT

Setup Instructions:

1. CSV Location:

   • Place your CSV file into the Unity project’s StreamingAssets folder (Assets/StreamingAssets/).

2. Prefab Location:

   • Organize your prefabs under a folder called Prefabs within the Unity project’s Resources folder (Assets/Resources/Prefabs/).
   • Ensure prefab names exactly match the ModelName values from your CSV.

3. Attach Script:

   • Attach this CSVScenePopulator script to an empty GameObject in your scene.

4. Execution:

   • Run your Unity scene, and prefabs will populate automatically according to your CSV.

This approach ensures efficient mesh reuse and consistent object instantiation within Unity.

You

any way to 1. make this super fast and efficient 2. Use unity’s async operations in the editor ?

ChatGPT

Yes, you can significantly improve speed and efficiency by leveraging Unity’s Editor utilities and asynchronous loading. Here’s an optimized professional solution tailored specifically for Unity’s Editor environment:

Optimizations to be Included:

1. Batch Loading and Caching Prefabs

   • Load all prefabs asynchronously into a cache beforehand.

2. Parallel Asset Instantiation

   • Using parallel async operations to instantiate objects efficiently.

3. Unity’s Editor Coroutine Utilities

   • Utilize Editor Coroutines to perform asynchronous operations directly in the Unity Editor.

Here’s the enhanced and optimized Unity editor script:

ChatGPT

Enhancements Made:

• Editor Coroutine Utility:
  Enables asynchronous operations directly within the Unity Editor (EditorCoroutineUtility), enhancing responsiveness during heavy operations.

• Prefab Preloading and Caching:
  All unique prefabs are asynchronously preloaded and cached before instantiation to minimize load operations.

• Efficient Scene Instantiation:
  Assets are instantiated asynchronously, ensuring minimal impact on the Editor performance and responsiveness.

Setup Steps:

• Add Unity Editor Coroutines Package:
  Ensure you have the Editor Coroutines package installed via Unity’s Package Manager.

• CSV File & Prefabs:
  Maintain previous instructions for placing your CSV file and prefab setup.

This approach ensures your scene populates quickly, efficiently, and without noticeable Editor lag.

You

We need to change things a bit. Instead of individual assets, there’s one asset only, which contains all the objects like Coral, Barancle etc as children. Let’s modify the script so that it reads from this object

ChatGPT

Changes implemented:

• Single Parent Asset:

  • The script now expects a single parent asset (parentAsset) containing all child objects (like Coral, Barnacle, etc.).

• Child Object Caching:

  • Prefabs are now fetched directly from the child objects of the specified parent, greatly simplifying asset management.

• Editor-Friendly Setup:

  • This streamlined method ensures quick and efficient instantiation and maintains the performance of the editor.

How to use:

• Assign the single asset containing your prefabs to the parentAsset field in the Inspector.
• Ensure that each child object’s name exactly matches the ModelName from the CSV.

This approach maximizes performance and simplifies asset organization.

You

this is the script currently. I want the objects to be grouped per modelName, and all together under a single parent. When the script is executed, the old objects must be cleared:

using UnityEngine; using UnityEditor; using System.IO; using System.Collections.Generic; using Unity.EditorCoroutines.Editor;

[ExecuteInEditMode] public class CSVScenePopulator : MonoBehaviour { public string csvFileName = “05_ClonedAssets_export_20250516_1119.csv”; public GameObject parentAsset; // Single asset containing all children prefabs public float positionScale = 1;

private Dictionary<string, GameObject> prefabCache = new Dictionary<string, GameObject>();

void OnEnable()
{
    if (parentAsset == null)
    {
        Debug.LogError("Parent asset is not assigned.");
        return;
    }

    string path = Path.Combine(Application.streamingAssetsPath, csvFileName);
    if (File.Exists(path))
    {
        EditorCoroutineUtility.StartCoroutineOwnerless(PopulateSceneAsync(path));
    }
    else
    {
        Debug.LogError("CSV file not found at: " + path);
    }
}

private System.Collections.IEnumerator PopulateSceneAsync(string path)
{
    string[] lines = File.ReadAllLines(path);

    // Cache child prefabs from parent asset
    foreach (Transform child in parentAsset.transform)
    {
        prefabCache[child.name] = child.gameObject;
    }

    // Instantiate prefabs from CSV data
    foreach (var line in lines[1..]) // Skip header
    {
        var values = line.Split(',');

        string modelName = values[2].Trim().Replace(" ", "_");

        if (!prefabCache.ContainsKey(modelName))
        {
            Debug.LogWarning("Model not found in parent asset: " + modelName);
            continue;
        }

        Vector3 position = new Vector3(
            float.Parse(values[3]),
            float.Parse(values[4]),
            float.Parse(values[5])
        ) * positionScale;

        Quaternion rotation = Quaternion.Euler(
            float.Parse(values[7]),
            float.Parse(values[6]),
            float.Parse(values[8])
        );

        Vector3 scale = new Vector3(
            float.Parse(values[9]),
            float.Parse(values[10]),
            float.Parse(values[11])
        );

        GameObject instance = Instantiate(prefabCache[modelName]); // (GameObject)PrefabUtility.InstantiatePrefab(prefabCache[modelName]);

        instance.transform.SetPositionAndRotation(position, rotation);
        instance.transform.localScale = scale;


        yield return null; // Yield to avoid freezing editor
    }

    Debug.Log("Scene population complete.");
}

}

ChatGPT

Changes Implemented:

• Grouping by modelName: Each object instantiated is grouped under a parent container named [modelName]_Group.
• Clearing Previous Instances: On script execution, previous objects under the script’s parent are cleared first to ensure no duplicates persist.
• Adjustable Position Scale: Positions can be scaled using the positionScale parameter.

This ensures a clean and organized hierarchy within the Unity editor, facilitating easy management of grouped objects.

You

Instead of creating a gameobject for each, bake the positions, rotations and scales into 3 textures. These will feed a VFX graph

ChatGPT

Here’s the optimized version of the script that bakes positions, rotations, and scales into textures to feed into a VFX graph, instead of instantiating game objects directly.

ChatGPT

Changes Implemented:

• Baking Data into Textures: Positions, rotations, and scales from the CSV are now baked into three separate textures (positionTexture, rotationTexture, scaleTexture).
• Texture Generation: Efficiently calculates the texture size based on the total instance count.
• Texture Storage: Textures are stored as Unity assets (Assets/PositionTexture.asset, etc.), ready to feed directly into a VFX graph.

This setup is highly performant and optimized for GPU-driven effects via VFX Graph.

You

Hmm. VFX graph can only pick meshes per particle using sub-meshes. Combine all object’s meshes into one, as different submeshes using Unity’s high performance Mesh API. Also write a texture with the index of the mesh that each instance (particle)

ChatGPT

Here’s an enhanced and optimized version of your Unity script that:

• Combines multiple meshes into one with multiple submeshes using Unity’s high-performance Mesh.CombineMeshes.
• Creates an index texture, storing the submesh index each particle will use in the VFX Graph.
• Continues to bake positions, rotations, and scales into textures.

ChatGPT

Key Updates Made:

• Mesh Combining:

  • Combines all child meshes from a single parent asset into a single mesh with multiple submeshes for VFX Graph compatibility.

• Mesh Index Texture:

  • Creates a dedicated texture (meshIndexTexture) storing submesh indices per particle for the VFX Graph to utilize.

• Continued Texture Baking:

  • Retains baking positions, rotations, and scales for optimal GPU-driven instancing.

Usage:

• Ensure the parentAsset is assigned, containing all meshes as children.
• Textures and combined mesh are saved as assets (Assets/) for easy reference in the VFX Graph.

This setup allows efficient GPU-driven rendering via Unity’s VFX Graph.

You

Write per-object textures, and store them in appropriate folders. Keep track of the clone count of each object and create a 4x4 texture with this info. No need for index texture any more

ChatGPT

Here’s the revised script incorporating the following enhancements:

• Per-object textures: Each object type (modelName) gets its own textures for positions, rotations, and scales.
• Clone-count texture: A 4x4 texture that tracks the number of instances for each object.
• Organized storage: Assets stored in organized folders within Assets/BakedData.

ChatGPT

Updated Features:

• Per-Object Textures: Each object’s position, rotation, and scale textures are individually saved under Assets/BakedData/{ObjectName}/.

• Clone Count Texture: A single 4x4 texture (CloneCountTexture.asset) tracks the clone count for each unique object.

• Folder Organization: Improved asset management by organizing baked data neatly.

This refined setup efficiently supports integration with Unity’s VFX Graph or other GPU-driven systems.

You

Then instantiate VFX graphs and set their Pos, Rot, Scale, Count and Mesh properties

ChatGPT

Added Features:

• VFX Graph Instantiation: After baking data, the script now instantiates VFX graph instances, setting appropriate textures and parameters.
• Per-Object Setup: Each VFX instance receives its own position, rotation, scale textures, and clone count.
• Combined Mesh Assignment: Each VFX instance utilizes the combined mesh with submeshes.

Usage:

• Assign the vfxPrefab property in the Inspector with your VFX Graph asset.
• Ensure VFX Graph asset has exposed properties matching the script (PositionTexture, RotationTexture, ScaleTexture, InstanceCount, CombinedMesh).

This robust setup simplifies your workflow, maximizing the efficiency of GPU-driven rendering.

You

don’t combine any mesh! use the mesh of each object

ChatGPT

Modifications Implemented:

• Individual Mesh Usage: Removed combined mesh creation; each VFX instance now directly uses the mesh from its corresponding object.

• VFX Graph Setup: Each instantiated VFX graph has its specific mesh assigned based on the original objects, enhancing clarity and performance.

• Asset Organization: Continues to store textures per object neatly under Assets/BakedData/{ObjectName}/.

How to Use:

• Ensure each child object under parentAsset has a MeshFilter.
• Verify the VFX Graph asset exposes the parameters: PositionTexture, RotationTexture, ScaleTexture, InstanceCount, and Mesh.

This update provides improved clarity and efficiency by directly utilizing individual object meshes without unnecessary combination.

You

Great. read from a list of parent assets, not just one

ChatGPT

Update Overview:

• Multiple Parent Assets: Now supports reading and caching meshes from multiple parent assets, allowing for a broader, more flexible setup.
• Asset Validation: Checks if the provided list of parent assets is correctly assigned.

This enhancement makes your workflow more scalable and suitable for complex setups.