Cannot split mesh up into different parts

[Sammyueru1]

So I’ve been following Sebastian Lague’s tutorial series on how to generate planets but created a problem once I wanted to add a mesh collider to it, being that I need to use Convex however convex bridges mountains and stuff like that so I decided that splitting a lower resolution mesh into different objects and meshes but I did it way wrong and am not the best with this type of thing so if someone could show me what’s wrong and how to fix it, that would be great!

Sebastian Lague’s tutorial series on how to generate planets:

PlanetTerrainFace Script:

using System.Collections.Generic;
using UnityEngine;
using Utitity;

public class PlanetTerrainFace
{
    GameObject meshObj;
    PlanetShapeGenerator shapeGenerator;
    Mesh mesh;
    int resolution;
    int colRes;
    Vector3 localUp;
    Vector3 axisA;
    Vector3 axisB;

    public PlanetTerrainFace(GameObject meshObj, PlanetShapeGenerator shapeGenerator, Mesh mesh, int resolution, int colRes, Vector3 localUp)
    {
        this.meshObj = meshObj;
        this.shapeGenerator = shapeGenerator;
        this.mesh = mesh;
        this.resolution = resolution;
        this.colRes = colRes;
        this.localUp = localUp;

        axisA = new Vector3(localUp.y, localUp.z, localUp.x);
        axisB = Vector3.Cross(localUp, axisA);
    }

    public void ConstructMesh(bool createCollision = false)
    {
        Vector3[] vertices = new Vector3[resolution * resolution];
        int[] triangles = new int [(resolution - 1)*(resolution - 1)*6];
        int triIndex = 0;

        for(int y = 0; y < resolution; y++)
        {
            for(int x = 0; x < resolution; x++)
            {
                int i = x+y*resolution;
                Vector2 percent = new Vector2(x, y) / (resolution - 1);
                Vector3 pointOnUnitCube = localUp + (percent.x - 0.5f) * 2 * axisA + (percent.y - 0.5f) * 2 * axisB;
                Vector3 pointOnUnitSphere = pointOnUnitCube.normalized;
                vertices[i] = shapeGenerator.CalculatePointOnPlanet(pointOnUnitSphere);

                if(x!=resolution-1 && y!=resolution-1)
                {
                    triangles[triIndex] = i;
                    triangles[triIndex+1] = i+resolution+1;
                    triangles[triIndex+2] = i+resolution;

                    triangles[triIndex+3] = i;
                    triangles[triIndex+4] = i+1;
                    triangles[triIndex+5] = i+resolution+1;
                  
                    triIndex += 6;
                }
            }
        }

        mesh.Clear();
        mesh.vertices = vertices;
        mesh.triangles = triangles;
        mesh.RecalculateNormals();

        triIndex = 0;

        if(createCollision)
        {
            List<Vector3> colVertices = new List<Vector3>(1);
            List<int> colTriangles = new List<int>(1);

            for(int i = 0; i < 8; i++)
            {
                GameObject colObj = new GameObject("ColOBJ_"+i.ToString());
                colObj.transform.parent = meshObj.transform;
                Mesh colMesh = new Mesh();
                //Vector3[] colVertices = new Vector3[(int)(colRes / 6f) * (int)(colRes / 6f)];
                //int[] colTriangles = new int [(colRes - 1)*(colRes - 1)*6];

                //colVertices.RemoveRange(0, colVertices.Count);
                //colTriangles.RemoveRange(0, colTriangles.Count);
                colVertices.Clear();
                colTriangles.Clear();

                colVertices.Capacity = 1;
                colTriangles.Capacity = 1;

                for(int iy = 0; iy < (int)(colRes / 8); iy++)
                {
                    for(int ix = 0; ix < (int)(colRes / 8); ix++)
                    {
                        //int iz = ((((i+1)*ix)+((i+1)*iy))*colRes);
                        int iz = (ix+iy)*colRes;
                        //Vector2 percent = new Vector2((i+1)*ix, (i+1)*iy) / (colRes - 1);
                        Vector2 percent = new Vector2((ix*(i+1)), iy*(i+1)) / (colRes - 1);
                        Vector3 pointOnUnitCube = localUp + (percent.x - 0.5f) * 2 * axisA + (percent.y - 0.5f) * 2 * axisB;
                        //Vector3 pointOnUnitCube = localUp * 2 * axisA * 2 * axisB;
                        Vector3 pointOnUnitSphere = pointOnUnitCube.normalized;
                        //colVertices[iz+1] = shapeGenerator.CalculatePointOnPlanet(pointOnUnitSphere);
                        colVertices.Add(shapeGenerator.CalculatePointOnPlanet(pointOnUnitSphere));

                        if(ix/(i+1)!=colRes-1 && iy/(i+1)!=colRes-1)
                        {
                          
                            colTriangles.Add(iz);
                            colTriangles.Add(iz+1);

                            if(iz + 2 < colRes)
                            {
                                colTriangles.Add(iz-1);
                            }
                            else
                            {
                                colTriangles.Add(iz+2);
                            }
                          

                            /*
                            colTriangles.Add(iz);
                            colTriangles.Add(iz+colRes+1);
                            colTriangles.Add(iz+colRes);

                            colTriangles.Add(iz);
                            colTriangles.Add(iz+1);
                            colTriangles.Add(iz+colRes);
                            */

                            /*
                            colTriangles[triIndex] = iz;
                            colTriangles[triIndex+1] = iz+colRes+1;
                            colTriangles[triIndex+2] = iz+colRes;

                            colTriangles[triIndex+3] = iz;
                            colTriangles[triIndex+4] = iz+1;
                            colTriangles[triIndex+5] = iz+colRes+1;

                            triIndex += 6;
                            */
                        }
                    }
                }

                colMesh.Clear();
                colMesh.vertices  = colVertices.ToArray(); //MeshUtilities.ClearVertBlanks(colVertices.ToArray(), colTriangles.ToArray());
                colMesh.triangles = colTriangles.ToArray(); //MeshUtilities.ClearTriBlanks(colVertices.ToArray(), colTriangles.ToArray());
              
                //colMesh.vertices  = colVertices;
                //colMesh.triangles = colTriangles;
                //colMesh = MeshUtilities.ClearBlanksVertTri(colMesh);
              
                colMesh.RecalculateNormals();
                colMesh.name = "ColMesh_"+i.ToString();

                MeshCollider colMeshCol = colObj.AddComponent<MeshCollider>();
                colMeshCol.sharedMesh = colMesh;
                colMeshCol.convex = true;
              
                Rigidbody colRb = colObj.AddComponent<Rigidbody>();
                colRb.isKinematic = false;
                colRb.constraints = RigidbodyConstraints.FreezeAll;
            }
        }
    }

    public Mesh GetMesh()
    {
        return this.mesh;
    }
}

Thanks in advance!

[Kurt-Dekker]

This just means you have logic or bookkeeping errors and you’re not slicing the geometry / vertices / triangles properly.

To debug it, create the simplest set of data that proves it, perhaps two triangles with six vertices, and debug your bookkeeping to get the indices correct.

Use lots of Debug.Log()

If you want examples of different approaches to making meshes, you’re welcome to check out my MakeGeo package.

MakeGeo is presently hosted at these locations:

https://bitbucket.org/kurtdekker/makegeo

GitHub - kurtdekker/makegeo: Make Geometry - Procedural Unity3D Geometry

Kurt Dekker / makegeo · GitLab

makegeo

You must find a way to get the information you need in order to reason about what the problem is.

What is often happening in these cases is one of the following:

• the code you think is executing is not actually executing at all
• the code is executing far EARLIER or LATER than you think
• the code is executing far LESS OFTEN than you think
• the code is executing far MORE OFTEN than you think
• the code is executing on another GameObject than you think it is
• you’re getting an error or warning and you haven’t noticed it in the console window

To help gain more insight into your problem, I recommend liberally sprinkling Debug.Log() statements through your code to display information in realtime.

Doing this should help you answer these types of questions:

• is this code even running? which parts are running? how often does it run? what order does it run in?
• what are the values of the variables involved? Are they initialized? Are the values reasonable?
• are you meeting ALL the requirements to receive callbacks such as triggers / colliders (review the documentation)

Knowing this information will help you reason about the behavior you are seeing.

You can also supply a second argument to Debug.Log() and when you click the message, it will highlight the object in scene, such as Debug.Log("Problem!",this);

If your problem would benefit from in-scene or in-game visualization, Debug.DrawRay() or Debug.DrawLine() can help you visualize things like rays (used in raycasting) or distances.

You can also call Debug.Break() to pause the Editor when certain interesting pieces of code run, and then study the scene manually, looking for all the parts, where they are, what scripts are on them, etc.

You can also call GameObject.CreatePrimitive() to emplace debug-marker-ish objects in the scene at runtime.

You could also just display various important quantities in UI Text elements to watch them change as you play the game.

If you are running a mobile device you can also view the console output. Google for how on your particular mobile target, such as this answer or iOS: How To - Capturing Device Logs on iOS or this answer for Android: How To - Capturing Device Logs on Android

Another useful approach is to temporarily strip out everything besides what is necessary to prove your issue. This can simplify and isolate compounding effects of other items in your scene or prefab.

Here’s an example of putting in a laser-focused Debug.Log() and how that can save you a TON of time wallowing around speculating what might be going wrong:

Coroutine missing hint and error

This is so unnecessary. Use the beauty and power of instantly and immediately putting a Debug.Log() statement into the very start of the coroutine, right at the top. Do this always at the very first sign of trouble or question in your mind. The instant you did this you would see “Oh man, this code is simply not getting run!” And you could LASER-FOCUS 100% your efforts on studying what you expect to run it, eg., the call location, and isolate why it is not running. You would look at literall…

When in doubt, print it out!™

Note: the print() function is an alias for Debug.Log() provided by the MonoBehaviour class.