Unity Mesh Renderer 在错误的一侧生成多边形

Question

So I need to generate a polygon using the Unity Mesh component that has n number of vertices. I am using a custom Triangulate() function that is able to find the indices for the mesh.triangles.

The problem is that based on the vertices I feed that function, the polygon generates on the wrong side and sometimes is not visible to the camera (unless I flip the camera to the other side).

Now I know this has to do with Unity's clockwise winding order, but how can I make sure the polygon is always generated on the correct side, no matter the vertices I feed it? Or could there be a way to know on which side the mesh generated so I can adjust the camera accordingly?

The Triangulator function I use

Answer 1

This is the normal vector n of a triangle:

The visibility of the triangle is based on its normal. The math that calculates the light that hits the triangle, is reflected and goes to your eyes (Unity camera) uses the normal of the triangle for that. Basically, if that vector n points towards your eyes it means you can see [part of] the light that hits that surface.

To know if you can see the triangle, you need to know if the normal points to you. Without going further with the math, the normal is given by calculating the cross product of the vectors defined by the vertices of the triangle.

For example, a triangle ABC can be defined by the vectors AB and BC (not related with the figure above). Or you can invert the "direction" of this triangle and define it AC and CB. The normal of AB/BC has one direction and the normal of AC/CB has the opposite direction, because of... math - if you google this stuff you can learn why, there are tons of tutorials.

So I wrote all this to tell something you already know: the order of the vertices defines the visibility. But that's because it defines the direction of the normal. Now take a look at this code:

        var a = new Vector3(0f, 0f, 0f);
        var b = new Vector3(0.5f, 0.5f, 0f);
        var c = new Vector3(0f, 1f, 0f);

        var ab = b - a;
        var bc = c - b;
        Debug.Log(Vector3.Cross(ab, bc)); // this prints (0.0, 0.0, 0.5)

        var ac = c - a;
        var cb = b - c;
        Debug.Log(Vector3.Cross(ac, cb)); // this prints (0.0, 0.0, -0.5)

Notice that on the second case z is negative, so it's pointing towards you (your camera is probably set at (0, 0, -10) or something similar). So if you define the triangle that way you will be able to see it.

Long story short: to know if you can see a triangle, test the signal of the z component of the cross product of the vertices. If the result is not the signal you want, reverse the vertices.

I didn't read the code from your triangulator function, but I saw that it's using 2D. That means it can probably be simplified further. It also seems to be calculating the cross product in InsideTriangle() , so you can probably use the calculations that's already going on there to check the signal, with [almost] zero performance loss.