Пример #1
0
    public void updateMesh()
    {
        vertexPoints.Clear();
        indexPoints.Clear();
        uvPoints.Clear();

        oobb.update(gameObject);

        Vector3 dirUp    = gameObject.transform.TransformDirection(Vector3.up);
        Vector3 dirUpPos = gameObject.transform.position - (dirUp * gameObject.transform.localScale.y);

        Vector3 dirDown    = gameObject.transform.TransformDirection(Vector3.down);
        Vector3 dirDownPos = gameObject.transform.position - (dirDown * gameObject.transform.localScale.y);

        Vector3 dirForward    = gameObject.transform.TransformDirection(Vector3.forward);
        Vector3 dirForwardPos = gameObject.transform.position - (dirForward * gameObject.transform.localScale.z);

        Vector3 dirBack    = gameObject.transform.TransformDirection(Vector3.back);
        Vector3 dirBackPos = gameObject.transform.position - (dirBack * gameObject.transform.localScale.z);

        Vector3 dirLeft    = gameObject.transform.TransformDirection(Vector3.left);
        Vector3 dirLeftPos = gameObject.transform.position - (dirLeft * gameObject.transform.localScale.x);

        Vector3 dirRight    = gameObject.transform.TransformDirection(Vector3.right);
        Vector3 dirRightPos = gameObject.transform.position - (dirRight * gameObject.transform.localScale.x);


        yPosPlane.SetValues(dirUp, dirUpPos);
        yNegPlane.SetValues(dirDown, dirDownPos);

        zPosPlane.SetValues(dirForward, dirForwardPos);
        zNegPlane.SetValues(dirBack, dirBackPos);

        xPosPlane.SetValues(dirLeft, dirLeftPos);
        xNegPlane.SetValues(dirRight, dirRightPos);

        if (data != null)
        {
            List <TriangleData> tris = data.getTrianglesInOOBB(oobb);

            //Debug.Log(tris.Count);

            Vector3 lineInt = new Vector3();

            for (int i = 0; i < tris.Count; i++)
            {
                Vector3[] pts = tris[i].getTransformedPoints();

                Vector3 point1 = pts[0];
                Vector3 point2 = pts[1];
                Vector3 point3 = pts[2];

                Vector3 n = Vector3.Cross(point2 - point1, point3 - point1);
                n.Normalize();

                points.Clear();
                newTris.Clear();
                lpoints.Clear();

                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[0], ref oobb.oobbCoordsTrans[1], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[0], ref oobb.oobbCoordsTrans[2], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[0], ref oobb.oobbCoordsTrans[4], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[1], ref oobb.oobbCoordsTrans[3], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[1], ref oobb.oobbCoordsTrans[5], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[2], ref oobb.oobbCoordsTrans[6], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[2], ref oobb.oobbCoordsTrans[3], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[3], ref oobb.oobbCoordsTrans[7], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[4], ref oobb.oobbCoordsTrans[5], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[4], ref oobb.oobbCoordsTrans[6], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[5], ref oobb.oobbCoordsTrans[7], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }
                if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[6], ref oobb.oobbCoordsTrans[7], ref point1, ref point2, ref point3, ref lineInt))
                {
                    lpoints.Add(lineInt);
                }

                NDPlane.IntersectSixPlanesTriangle(xPosPlane, xNegPlane, yPosPlane, yNegPlane, zPosPlane, zNegPlane, ref point1, ref point2, ref point3, lpoints);
                NDPlane.SideOfSixPlanesFilter(xPosPlane, xNegPlane, yPosPlane, yNegPlane, zPosPlane, zNegPlane, lpoints, points);

                HullTests.ConvexHull2DTriangulated(points, newTris, ref n);

                for (int j = 0; j < newTris.Count; j += 3)
                {
                    Vector3 v1 = newTris[j + 0];
                    Vector3 v2 = newTris[j + 1];
                    Vector3 v3 = newTris[j + 2];

                    float   tolerance = layer * offset;
                    Vector3 dist      = n * tolerance;

                    v1 = v1 + dist;
                    v2 = v2 + dist;
                    v3 = v3 + dist;

                    int vec1 = 0;
                    int vec2 = 0;
                    int vec3 = 0;

                    // point is new, compute new UV coordinates for it
                    if (!NearestPointTest.approxContains(vertexPoints, v1, tolerance, ref vec1))
                    {
                        Vector3 transVec = gameObject.transform.InverseTransformPoint(vertexPoints[vec1]);

                        if (!cubeMap)
                        {
                            uvPoints.Add(new Vector2((transVec.y + 1) / 2, (transVec.z + 1) / 2));
                        }
                        else
                        {
                            uvPoints.Add(HullTests.CubeMap3DV(ref transVec, ref n));
                        }
                    }

                    if (!NearestPointTest.approxContains(vertexPoints, v2, tolerance, ref vec2))
                    {
                        Vector3 transVec = gameObject.transform.InverseTransformPoint(vertexPoints[vec2]);

                        if (!cubeMap)
                        {
                            uvPoints.Add(new Vector2((transVec.y + 1) / 2, (transVec.z + 1) / 2));
                        }
                        else
                        {
                            uvPoints.Add(HullTests.CubeMap3DV(ref transVec, ref n));
                        }
                    }

                    if (!NearestPointTest.approxContains(vertexPoints, v3, tolerance, ref vec3))
                    {
                        Vector3 transVec = gameObject.transform.InverseTransformPoint(vertexPoints[vec3]);

                        if (!cubeMap)
                        {
                            uvPoints.Add(new Vector2((transVec.y + 1) / 2, (transVec.z + 1) / 2));
                        }
                        else
                        {
                            uvPoints.Add(HullTests.CubeMap3DV(ref transVec, ref n));
                        }
                    }


                    //Debug.Log(vertexPoints.Count + " " + vec1 + " " + vec2 + " " + vec3);
                    if (HullTests.IsTriClockwise(vertexPoints[vec1], vertexPoints[vec2], vertexPoints[vec3], n))
                    {
                        indexPoints.Add(vec1);
                        indexPoints.Add(vec2);
                        indexPoints.Add(vec3);
                    }
                    else
                    {
                        indexPoints.Add(vec1);
                        indexPoints.Add(vec3);
                        indexPoints.Add(vec2);
                    }
                }
            }
        }
    }