< Summary

Class:DCL.Helpers.PrimitiveMeshBuilder
Assembly:Utils
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Helpers/Utils/PrimitiveMeshBuilder.cs
Covered lines:396
Uncovered lines:26
Coverable lines:422
Total lines:754
Line coverage:93.8% (396 of 422)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
BuildSphere(...)0%12120100%
BuildPlane(...)0%110100%
BuildCube(...)0%110100%
BuildConeOrCylinder(...)0%108.4672080.84%
BuildCone(...)0%110100%
BuildCylinder(...)0%110100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Helpers/Utils/PrimitiveMeshBuilder.cs

#LineLine coverage
 1using UnityEngine;
 2
 3/*
 4* PrimitiveMeshBuilder originated in the DecentralandUnityPlugin that can be found at:
 5* https://github.com/fairwood/DecentralandUnityPlugin
 6*/
 7
 8namespace DCL.Helpers
 9{
 10    public class PrimitiveMeshBuilder
 11    {
 12        public static Mesh BuildSphere(float radius)
 13        {
 114            Mesh mesh = new Mesh();
 115            mesh.name = "DCL Sphere";
 16
 17            //float radius = 1f;
 18            // Longitude |||
 119            int nbLong = 24;
 20            // Latitude ---
 121            int nbLat = 16;
 22
 23            #region Vertices
 24
 125            Vector3[] vertices = new Vector3[(nbLong + 1) * nbLat + 2];
 126            float _pi = Mathf.PI;
 127            float _2pi = _pi * 2f;
 28
 129            vertices[0] = Vector3.up * radius;
 3430            for (int lat = 0; lat < nbLat; lat++)
 31            {
 1632                float a1 = _pi * (float) (lat + 1) / (nbLat + 1);
 1633                float sin1 = Mathf.Sin(a1);
 1634                float cos1 = Mathf.Cos(a1);
 35
 83236                for (int lon = 0; lon <= nbLong; lon++)
 37                {
 40038                    float a2 = _2pi * (float) (lon == nbLong ? 0 : lon) / nbLong;
 40039                    float sin2 = Mathf.Sin(a2);
 40040                    float cos2 = Mathf.Cos(a2);
 41
 40042                    vertices[lon + lat * (nbLong + 1) + 1] = new Vector3(sin1 * cos2, cos1, sin1 * sin2) * radius;
 43                }
 44            }
 45
 146            vertices[vertices.Length - 1] = Vector3.up * -radius;
 47
 48            #endregion
 49
 50            #region Normales
 51
 152            Vector3[] normales = new Vector3[vertices.Length];
 80653            for (int n = 0; n < vertices.Length; n++)
 54            {
 40255                normales[n] = vertices[n].normalized;
 56            }
 57
 58            #endregion
 59
 60            #region UVs
 61
 162            Vector2[] uvs = new Vector2[vertices.Length];
 163            uvs[0] = Vector2.up;
 164            uvs[uvs.Length - 1] = Vector2.zero;
 3465            for (int lat = 0; lat < nbLat; lat++)
 66            {
 83267                for (int lon = 0; lon <= nbLong; lon++)
 68                {
 40069                    uvs[lon + lat * (nbLong + 1) + 1] =
 70                        new Vector2(1f - (float) lon / nbLong, (float) (lat + 1) / (nbLat + 1));
 71                }
 72            }
 73            //uvs[lon + lat * (nbLong + 1) + 1] = new Vector2( (float)lon / nbLong, 1f - (float)(lat+1) / (nbLat+1) );
 74
 75            #endregion
 76
 77            #region Triangles
 78
 179            int nbFaces = vertices.Length;
 180            int nbTriangles = nbFaces * 2;
 181            int nbIndexes = nbTriangles * 3;
 182            int[] triangles = new int[nbIndexes];
 83
 84            //Top Cap
 185            int i = 0;
 5086            for (int lon = 0; lon < nbLong; lon++)
 87            {
 2488                triangles[i++] = lon + 2;
 2489                triangles[i++] = lon + 1;
 2490                triangles[i++] = 0;
 91            }
 92
 93            //Middle
 3294            for (int lat = 0; lat < nbLat - 1; lat++)
 95            {
 75096                for (int lon = 0; lon < nbLong; lon++)
 97                {
 36098                    int current = lon + lat * (nbLong + 1) + 1;
 36099                    int next = current + nbLong + 1;
 100
 360101                    triangles[i++] = current;
 360102                    triangles[i++] = current + 1;
 360103                    triangles[i++] = next + 1;
 104
 360105                    triangles[i++] = current;
 360106                    triangles[i++] = next + 1;
 360107                    triangles[i++] = next;
 108                }
 109            }
 110
 111            //Bottom Cap
 50112            for (int lon = 0; lon < nbLong; lon++)
 113            {
 24114                triangles[i++] = vertices.Length - 1;
 24115                triangles[i++] = vertices.Length - (lon + 2) - 1;
 24116                triangles[i++] = vertices.Length - (lon + 1) - 1;
 117            }
 118
 119            #endregion
 120
 1121            mesh.vertices = vertices;
 1122            mesh.normals = normales;
 1123            mesh.uv = uvs;
 1124            mesh.triangles = triangles;
 125
 1126            mesh.RecalculateBounds();
 1127            return mesh;
 128        }
 129
 130        public static Mesh BuildPlane(float _size)
 131        {
 35132            Mesh mesh = new Mesh();
 35133            mesh.name = "DCL Plane";
 35134            Vector3[] vertices = new Vector3[8];
 35135            Vector3[] normals = new Vector3[8];
 35136            Vector2[] uvs = new Vector2[8];
 35137            Color[] colors = new Color[8];
 138
 35139            int[] tris = new int[4 * 3];
 140
 35141            int vIndex = 0;
 35142            Vector3 start = new Vector3(-_size / 2, _size / 2, 0);
 35143            vertices[vIndex++] = new Vector3(-start.x, -start.y, 0);
 35144            vertices[vIndex++] = new Vector3(start.x, -start.y, 0);
 35145            vertices[vIndex++] = new Vector3(start.x, start.y, 0);
 35146            vertices[vIndex++] = new Vector3(-start.x, start.y, 0);
 147
 35148            vertices[vIndex++] = new Vector3(-start.x, -start.y, 0);
 35149            vertices[vIndex++] = new Vector3(start.x, -start.y, 0);
 35150            vertices[vIndex++] = new Vector3(start.x, start.y, 0);
 35151            vertices[vIndex++] = new Vector3(-start.x, start.y, 0);
 152
 35153            vIndex = 0;
 35154            uvs[vIndex++] = new Vector2(0f, 1f);
 35155            uvs[vIndex++] = new Vector2(1f, 1f);
 35156            uvs[vIndex++] = new Vector2(1f, 0f);
 35157            uvs[vIndex++] = new Vector2(0f, 0f);
 158
 35159            uvs[vIndex++] = new Vector2(0f, 1f);
 35160            uvs[vIndex++] = new Vector2(1f, 1f);
 35161            uvs[vIndex++] = new Vector2(1f, 0f);
 35162            uvs[vIndex++] = new Vector2(0f, 0f);
 163
 35164            vIndex = 0;
 35165            normals[vIndex++] = Vector3.forward;
 35166            normals[vIndex++] = Vector3.forward;
 35167            normals[vIndex++] = Vector3.forward;
 35168            normals[vIndex++] = Vector3.forward;
 169
 35170            normals[vIndex++] = Vector3.back;
 35171            normals[vIndex++] = Vector3.back;
 35172            normals[vIndex++] = Vector3.back;
 35173            normals[vIndex++] = Vector3.back;
 174
 35175            vIndex = 0;
 35176            colors[vIndex++] = Color.white;
 35177            colors[vIndex++] = Color.white;
 35178            colors[vIndex++] = Color.white;
 35179            colors[vIndex++] = Color.white;
 180
 35181            colors[vIndex++] = Color.white;
 35182            colors[vIndex++] = Color.white;
 35183            colors[vIndex++] = Color.white;
 35184            colors[vIndex++] = Color.white;
 185
 35186            int cnt = 0;
 35187            tris[cnt++] = 2;
 35188            tris[cnt++] = 1;
 35189            tris[cnt++] = 0;
 35190            tris[cnt++] = 3;
 35191            tris[cnt++] = 2;
 35192            tris[cnt++] = 0;
 193
 35194            tris[cnt++] = 4 + 1;
 35195            tris[cnt++] = 4 + 2;
 35196            tris[cnt++] = 4 + 0;
 35197            tris[cnt++] = 4 + 2;
 35198            tris[cnt++] = 4 + 3;
 35199            tris[cnt++] = 4 + 0;
 200
 35201            mesh.vertices = vertices;
 35202            mesh.normals = normals;
 35203            mesh.uv = uvs;
 35204            mesh.colors = colors;
 205
 35206            mesh.triangles = tris;
 35207            return mesh;
 208        }
 209
 210        public static Mesh BuildCube(float _size)
 211        {
 1212            Mesh mesh = new Mesh();
 1213            mesh.name = "DCL Box";
 1214            Vector3[] vertices = new Vector3[24]; //top bottom left right front back
 1215            Vector3[] normals = new Vector3[24];
 1216            Vector2[] uvs = new Vector2[24];
 1217            Vector2[] uvs2 = new Vector2[24];
 1218            int[] tris = new int[12 * 3];
 219
 1220            int vIndex = 0;
 221            //top and bottom
 1222            Vector3 start = new Vector3(-_size / 2, _size / 2, _size / 2);
 1223            vertices[vIndex++] = start;
 1224            vertices[vIndex++] = start + Vector3.right * _size;
 1225            vertices[vIndex++] = start + Vector3.right * _size + Vector3.back * _size;
 1226            vertices[vIndex++] = start + Vector3.back * _size;
 227
 1228            start = new Vector3(-_size / 2, -_size / 2, _size / 2);
 1229            vertices[vIndex++] = start;
 1230            vertices[vIndex++] = start + Vector3.right * _size;
 1231            vertices[vIndex++] = start + Vector3.right * _size + Vector3.back * _size;
 1232            vertices[vIndex++] = start + Vector3.back * _size;
 233
 234            //left and right
 1235            start = new Vector3(-_size / 2, _size / 2, _size / 2);
 1236            vertices[vIndex++] = start;
 1237            vertices[vIndex++] = start + Vector3.back * _size;
 1238            vertices[vIndex++] = start + Vector3.back * _size + Vector3.down * _size;
 1239            vertices[vIndex++] = start + Vector3.down * _size;
 240
 1241            start = new Vector3(_size / 2, _size / 2, _size / 2);
 1242            vertices[vIndex++] = start;
 1243            vertices[vIndex++] = start + Vector3.back * _size;
 1244            vertices[vIndex++] = start + Vector3.back * _size + Vector3.down * _size;
 1245            vertices[vIndex++] = start + Vector3.down * _size;
 246
 247            //front and back
 1248            start = new Vector3(-_size / 2, _size / 2, _size / 2);
 1249            vertices[vIndex++] = start;
 1250            vertices[vIndex++] = start + Vector3.right * _size;
 1251            vertices[vIndex++] = start + Vector3.right * _size + Vector3.down * _size;
 1252            vertices[vIndex++] = start + Vector3.down * _size;
 253
 1254            start = new Vector3(-_size / 2, _size / 2, -_size / 2);
 1255            vertices[vIndex++] = start;
 1256            vertices[vIndex++] = start + Vector3.right * _size;
 1257            vertices[vIndex++] = start + Vector3.right * _size + Vector3.down * _size;
 1258            vertices[vIndex++] = start + Vector3.down * _size;
 259
 260            //uv
 1261            vIndex = 0;
 262            //top and bottom
 1263            uvs[vIndex++] = new Vector2(1f, 1f);
 1264            uvs[vIndex++] = new Vector2(1f, 0f);
 1265            uvs[vIndex++] = new Vector2(0f, 0f);
 1266            uvs[vIndex++] = new Vector2(0f, 1f);
 267
 1268            uvs[vIndex++] = new Vector2(1f, 0f);
 1269            uvs[vIndex++] = new Vector2(1f, 1f);
 1270            uvs[vIndex++] = new Vector2(0f, 1f);
 1271            uvs[vIndex++] = new Vector2(0f, 0f);
 272
 273            //left and right
 1274            uvs[vIndex++] = new Vector2(1f, 1f);
 1275            uvs[vIndex++] = new Vector2(1f, 0f);
 1276            uvs[vIndex++] = new Vector2(0f, 0f);
 1277            uvs[vIndex++] = new Vector2(0f, 1f);
 278
 1279            uvs[vIndex++] = new Vector2(1f, 0f);
 1280            uvs[vIndex++] = new Vector2(1f, 1f);
 1281            uvs[vIndex++] = new Vector2(0f, 1f);
 1282            uvs[vIndex++] = new Vector2(0f, 0f);
 283
 284            //front and back
 1285            uvs[vIndex++] = new Vector2(0f, 0f);
 1286            uvs[vIndex++] = new Vector2(1f, 0f);
 1287            uvs[vIndex++] = new Vector2(1f, 1f);
 1288            uvs[vIndex++] = new Vector2(0f, 1f);
 289
 1290            uvs[vIndex++] = new Vector2(0f, 1f);
 1291            uvs[vIndex++] = new Vector2(1f, 1f);
 1292            uvs[vIndex++] = new Vector2(1f, 0f);
 1293            uvs[vIndex++] = new Vector2(0f, 0f);
 294
 295            //uv2
 1296            vIndex = 0;
 297            //top and bottom
 1298            uvs2[vIndex++] = new Vector2(1f, 1f);
 1299            uvs2[vIndex++] = new Vector2(1f, 0f);
 1300            uvs2[vIndex++] = new Vector2(0f, 0f);
 1301            uvs2[vIndex++] = new Vector2(0f, 1f);
 302
 1303            uvs2[vIndex++] = new Vector2(1f, 0f);
 1304            uvs2[vIndex++] = new Vector2(1f, 1f);
 1305            uvs2[vIndex++] = new Vector2(0f, 1f);
 1306            uvs2[vIndex++] = new Vector2(0f, 0f);
 307
 308            //left and right
 1309            uvs2[vIndex++] = new Vector2(1f, 1f);
 1310            uvs2[vIndex++] = new Vector2(1f, 0f);
 1311            uvs2[vIndex++] = new Vector2(0f, 0f);
 1312            uvs2[vIndex++] = new Vector2(0f, 1f);
 313
 1314            uvs2[vIndex++] = new Vector2(1f, 0f);
 1315            uvs2[vIndex++] = new Vector2(1f, 1f);
 1316            uvs2[vIndex++] = new Vector2(0f, 1f);
 1317            uvs2[vIndex++] = new Vector2(0f, 0f);
 318
 319            //front and back
 1320            uvs2[vIndex++] = new Vector2(0f, 0f);
 1321            uvs2[vIndex++] = new Vector2(1f, 0f);
 1322            uvs2[vIndex++] = new Vector2(1f, 1f);
 1323            uvs2[vIndex++] = new Vector2(0f, 1f);
 324
 1325            uvs2[vIndex++] = new Vector2(0f, 1f);
 1326            uvs2[vIndex++] = new Vector2(1f, 1f);
 1327            uvs2[vIndex++] = new Vector2(1f, 0f);
 1328            uvs2[vIndex++] = new Vector2(0f, 0f);
 329
 330            //normal
 1331            vIndex = 0;
 332            //top and bottom
 1333            normals[vIndex++] = Vector3.up;
 1334            normals[vIndex++] = Vector3.up;
 1335            normals[vIndex++] = Vector3.up;
 1336            normals[vIndex++] = Vector3.up;
 337
 1338            normals[vIndex++] = Vector3.down;
 1339            normals[vIndex++] = Vector3.down;
 1340            normals[vIndex++] = Vector3.down;
 1341            normals[vIndex++] = Vector3.down;
 342
 343            //left and right
 1344            normals[vIndex++] = Vector3.left;
 1345            normals[vIndex++] = Vector3.left;
 1346            normals[vIndex++] = Vector3.left;
 1347            normals[vIndex++] = Vector3.left;
 348
 1349            normals[vIndex++] = Vector3.right;
 1350            normals[vIndex++] = Vector3.right;
 1351            normals[vIndex++] = Vector3.right;
 1352            normals[vIndex++] = Vector3.right;
 353
 354            //front and back
 1355            normals[vIndex++] = Vector3.forward;
 1356            normals[vIndex++] = Vector3.forward;
 1357            normals[vIndex++] = Vector3.forward;
 1358            normals[vIndex++] = Vector3.forward;
 359
 1360            normals[vIndex++] = Vector3.back;
 1361            normals[vIndex++] = Vector3.back;
 1362            normals[vIndex++] = Vector3.back;
 1363            normals[vIndex++] = Vector3.back;
 364
 365
 1366            int cnt = 0;
 367
 368            //top and bottom
 1369            tris[cnt++] = 0;
 1370            tris[cnt++] = 1;
 1371            tris[cnt++] = 2;
 1372            tris[cnt++] = 0;
 1373            tris[cnt++] = 2;
 1374            tris[cnt++] = 3;
 375
 1376            tris[cnt++] = 4 + 0;
 1377            tris[cnt++] = 4 + 2;
 1378            tris[cnt++] = 4 + 1;
 1379            tris[cnt++] = 4 + 0;
 1380            tris[cnt++] = 4 + 3;
 1381            tris[cnt++] = 4 + 2;
 382
 383            //left and right
 1384            tris[cnt++] = 8 + 0;
 1385            tris[cnt++] = 8 + 1;
 1386            tris[cnt++] = 8 + 2;
 1387            tris[cnt++] = 8 + 0;
 1388            tris[cnt++] = 8 + 2;
 1389            tris[cnt++] = 8 + 3;
 390
 1391            tris[cnt++] = 12 + 0;
 1392            tris[cnt++] = 12 + 2;
 1393            tris[cnt++] = 12 + 1;
 1394            tris[cnt++] = 12 + 0;
 1395            tris[cnt++] = 12 + 3;
 1396            tris[cnt++] = 12 + 2;
 397
 398            //front and back
 1399            tris[cnt++] = 16 + 0;
 1400            tris[cnt++] = 16 + 2;
 1401            tris[cnt++] = 16 + 1;
 1402            tris[cnt++] = 16 + 0;
 1403            tris[cnt++] = 16 + 3;
 1404            tris[cnt++] = 16 + 2;
 405
 1406            tris[cnt++] = 20 + 0;
 1407            tris[cnt++] = 20 + 1;
 1408            tris[cnt++] = 20 + 2;
 1409            tris[cnt++] = 20 + 0;
 1410            tris[cnt++] = 20 + 2;
 1411            tris[cnt++] = 20 + 3;
 412
 1413            mesh.vertices = vertices;
 1414            mesh.normals = normals;
 1415            mesh.uv = uvs;
 1416            mesh.uv2 = uvs2;
 417
 1418            mesh.triangles = tris;
 419
 1420            return mesh;
 421        }
 422
 423        public static Mesh BuildConeOrCylinder(int numVertices, float radiusTop, float radiusBottom, float length,
 424            float openingAngle, bool outside, bool inside, bool isCylinder, Vector3 offsetPos = default(Vector3))
 425        {
 18426            if (openingAngle > 0 && openingAngle < 180)
 427            {
 0428                radiusTop = 0;
 0429                radiusBottom = length * Mathf.Tan(openingAngle * Mathf.Deg2Rad / 2);
 430            }
 431
 18432            string meshName = isCylinder
 433                ? "DCL Cylinder"
 434                : "DCL Cone" + numVertices + "v" + radiusTop + "t" + radiusBottom + "b" + length + "l" + length +
 435                  (outside ? "o" : "") + (inside ? "i" : "");
 436            //string meshPrefabPath = "Assets/Decentraland/Internal/" + meshName + ".asset";
 18437            Mesh mesh = null; //(Mesh)AssetDatabase.LoadAssetAtPath(meshPrefabPath, typeof(Mesh));
 18438            if (mesh == null)
 439            {
 18440                int numVertices2 = numVertices + 1;
 441
 18442                mesh = new Mesh();
 18443                mesh.name = meshName;
 444                // can't access Camera.current
 445                //newCone.transform.position = Camera.current.transform.position + Camera.current.transform.forward * 5.
 18446                int multiplier = (outside ? 1 : 0) + (inside ? 1 : 0);
 18447                int offset = (outside && inside ? 2 * numVertices2 : 0);
 448
 18449                bool bTopCap = isCylinder ? true : false;
 18450                bool bBottomCap = true;
 451
 18452                Vector3[] vertices =
 453                    new Vector3[
 454                        2 * multiplier * numVertices2 + (bTopCap ? (numVertices + 1) : 0) +
 455                        (bBottomCap ? (numVertices + 1) : 0)];
 456                // 0..n-1: top, n..2n-1: bottom
 18457                Vector3[] normals =
 458                    new Vector3[
 459                        2 * multiplier * numVertices2 + (bTopCap ? (numVertices + 1) : 0) +
 460                        (bBottomCap ? (numVertices + 1) : 0)];
 18461                Vector2[] uvs =
 462                    new Vector2[
 463                        2 * multiplier * numVertices2 + (bTopCap ? (numVertices + 1) : 0) +
 464                        (bBottomCap ? (numVertices + 1) : 0)];
 465                int[] tris;
 18466                float slope = Mathf.Atan((radiusBottom - radiusTop) / length); // (rad difference)/height
 18467                float slopeSin = Mathf.Sin(slope);
 18468                float slopeCos = Mathf.Cos(slope);
 469                int i;
 470
 1836471                for (i = 0; i < numVertices; i++)
 472                {
 900473                    float angle = 2 * Mathf.PI * i / numVertices;
 900474                    float angleSin = Mathf.Sin(angle);
 900475                    float angleCos = Mathf.Cos(angle);
 900476                    float angleHalf = 2 * Mathf.PI * (i + 0.5f) / numVertices; // for degenerated normals at cone tips
 900477                    float angleHalfSin = Mathf.Sin(angleHalf);
 900478                    float angleHalfCos = Mathf.Cos(angleHalf);
 479
 900480                    vertices[i] = new Vector3(radiusTop * angleCos, length, radiusTop * angleSin) + offsetPos;
 900481                    vertices[i + numVertices2] =
 482                        new Vector3(radiusBottom * angleCos, 0, radiusBottom * angleSin) + offsetPos;
 483
 900484                    if (radiusTop == 0)
 485                    {
 300486                        normals[i] = new Vector3(angleHalfCos * slopeCos, -slopeSin, angleHalfSin * slopeCos);
 300487                    }
 488                    else
 489                    {
 600490                        normals[i] = new Vector3(angleCos * slopeCos, -slopeSin, angleSin * slopeCos);
 491                    }
 492
 900493                    if (radiusBottom == 0)
 494                    {
 300495                        normals[i + numVertices2] =
 496                            new Vector3(angleHalfCos * slopeCos, -slopeSin, angleHalfSin * slopeCos);
 300497                    }
 498                    else
 499                    {
 600500                        normals[i + numVertices2] = new Vector3(angleCos * slopeCos, -slopeSin, angleSin * slopeCos);
 501                    }
 502
 900503                    uvs[i] = new Vector2(1.0f - 1.0f * i / numVertices, 1);
 900504                    uvs[i + numVertices2] = new Vector2(1.0f - 1.0f * i / numVertices, 0);
 505
 900506                    if (outside && inside)
 507                    {
 508                        // vertices and uvs are identical on inside and outside, so just copy
 0509                        vertices[i + 2 * numVertices2] = vertices[i];
 0510                        vertices[i + 3 * numVertices2] = vertices[i + numVertices2];
 0511                        uvs[i + 2 * numVertices2] = uvs[i];
 0512                        uvs[i + 3 * numVertices2] = uvs[i + numVertices2];
 513                    }
 514
 900515                    if (inside)
 516                    {
 517                        // invert normals
 0518                        normals[i + offset] = -normals[i];
 0519                        normals[i + numVertices2 + offset] = -normals[i + numVertices2];
 520                    }
 521                }
 522
 18523                vertices[numVertices] = vertices[0];
 18524                vertices[numVertices + numVertices2] = vertices[0 + numVertices2];
 18525                uvs[numVertices] = new Vector2(1.0f - 1.0f * numVertices / numVertices, 1);
 18526                uvs[numVertices + numVertices2] = new Vector2(1.0f - 1.0f * numVertices / numVertices, 0);
 18527                normals[numVertices] = normals[0];
 18528                normals[numVertices + numVertices2] = normals[0 + numVertices2];
 529
 530
 18531                int coverTopIndexStart = 2 * multiplier * numVertices2;
 18532                int coverTopIndexEnd = 2 * multiplier * numVertices2 + numVertices;
 533
 18534                if (bTopCap)
 535                {
 612536                    for (i = 0; i < numVertices; i++)
 537                    {
 300538                        float angle = 2 * Mathf.PI * i / numVertices;
 300539                        float angleSin = Mathf.Sin(angle);
 300540                        float angleCos = Mathf.Cos(angle);
 541
 300542                        vertices[coverTopIndexStart + i] =
 543                            new Vector3(radiusTop * angleCos, length, radiusTop * angleSin) + offsetPos;
 300544                        normals[coverTopIndexStart + i] = new Vector3(0, 1, 0);
 300545                        uvs[coverTopIndexStart + i] = new Vector2(angleCos / 2 + 0.5f, angleSin / 2 + 0.5f);
 546                    }
 547
 6548                    vertices[coverTopIndexStart + numVertices] = new Vector3(0, length, 0) + offsetPos;
 6549                    normals[coverTopIndexStart + numVertices] = new Vector3(0, 1, 0);
 6550                    uvs[coverTopIndexStart + numVertices] = new Vector2(0.5f, 0.5f);
 551                }
 552
 553
 18554                int coverBottomIndexStart = coverTopIndexStart + (bTopCap ? 1 : 0) * (numVertices + 1);
 18555                int coverBottomIndexEnd = coverBottomIndexStart + numVertices;
 18556                if (bBottomCap)
 557                {
 1836558                    for (i = 0; i < numVertices; i++)
 559                    {
 900560                        float angle = 2 * Mathf.PI * i / numVertices;
 900561                        float angleSin = Mathf.Sin(angle);
 900562                        float angleCos = Mathf.Cos(angle);
 563
 900564                        vertices[coverBottomIndexStart + i] =
 565                            new Vector3(radiusBottom * angleCos, 0f, radiusBottom * angleSin) +
 566                            offsetPos;
 900567                        normals[coverBottomIndexStart + i] = new Vector3(0, -1, 0);
 900568                        uvs[coverBottomIndexStart + i] = new Vector2(angleCos / 2 + 0.5f, angleSin / 2 + 0.5f);
 569                    }
 570
 18571                    vertices[coverBottomIndexStart + numVertices] = new Vector3(0, 0f, 0) + offsetPos;
 18572                    normals[coverBottomIndexStart + numVertices] = new Vector3(0, -1, 0);
 18573                    uvs[coverBottomIndexStart + numVertices] = new Vector2(0.5f, 0.5f);
 574                }
 575
 18576                mesh.vertices = vertices;
 18577                mesh.normals = normals;
 18578                mesh.uv = uvs;
 579
 580                // create triangles
 581                // here we need to take care of point order, depending on inside and outside
 18582                int cnt = 0;
 18583                if (radiusTop == 0)
 584                {
 585                    // top cone
 6586                    tris =
 587                        new int[numVertices2 * 3 * multiplier + ((bTopCap ? 1 : 0) * numVertices * 3) +
 588                                ((bBottomCap ? 1 : 0) * numVertices * 3)
 589                        ];
 6590                    if (outside)
 591                    {
 612592                        for (i = 0; i < numVertices; i++)
 593                        {
 300594                            tris[cnt++] = i + numVertices2;
 300595                            tris[cnt++] = i;
 300596                            tris[cnt++] = i + 1 + numVertices2;
 597                            //              if(i==numVertices-1)
 598                            //                tris[cnt++]=numVertices;
 599                            //              else
 600                            //                tris[cnt++]=i+1+numVertices;
 601                        }
 602                    }
 603
 6604                    if (inside)
 605                    {
 0606                        for (i = offset; i < numVertices + offset; i++)
 607                        {
 0608                            tris[cnt++] = i;
 0609                            tris[cnt++] = i + numVertices2;
 0610                            tris[cnt++] = i + 1 + numVertices2;
 611                            //              if(i==numVertices-1+offset)
 612                            //                tris[cnt++]=numVertices+offset;
 613                            //              else
 614                            //                tris[cnt++]=i+1+numVertices;
 615                        }
 616                    }
 0617                }
 12618                else if (radiusBottom == 0)
 619                {
 620                    // bottom cone
 6621                    tris =
 622                        new int[numVertices2 * 3 * multiplier + ((bTopCap ? 1 : 0) * numVertices * 3) +
 623                                ((bBottomCap ? 1 : 0) * numVertices * 3)
 624                        ];
 6625                    if (outside)
 626                    {
 612627                        for (i = 0; i < numVertices; i++)
 628                        {
 300629                            tris[cnt++] = i;
 300630                            tris[cnt++] = i + 1;
 631                            //              if(i==numVertices-1)
 632                            //                tris[cnt++]=0;
 633                            //              else
 634                            //                tris[cnt++]=i+1;
 300635                            tris[cnt++] = i + numVertices2;
 636                        }
 637                    }
 638
 6639                    if (inside)
 640                    {
 0641                        for (i = offset; i < numVertices + offset; i++)
 642                        {
 643                            //              if(i==numVertices-1+offset)
 644                            //                tris[cnt++]=offset;
 645                            //              else
 646                            //                tris[cnt++]=i+1;
 0647                            tris[cnt++] = i + 1;
 0648                            tris[cnt++] = i;
 0649                            tris[cnt++] = i + numVertices2;
 650                        }
 651                    }
 0652                }
 653                else
 654                {
 655                    // truncated cone
 6656                    tris =
 657                        new int[numVertices2 * 6 * multiplier + ((bTopCap ? 1 : 0) * numVertices * 3) +
 658                                ((bBottomCap ? 1 : 0) * numVertices * 3)
 659                        ];
 6660                    if (outside)
 661                    {
 612662                        for (i = 0; i < numVertices; i++)
 663                        {
 300664                            int ip1 = i + 1;
 665                            //              if(ip1==numVertices)
 666                            //                ip1=0;
 667
 300668                            tris[cnt++] = i;
 300669                            tris[cnt++] = ip1;
 300670                            tris[cnt++] = i + numVertices2;
 671
 300672                            tris[cnt++] = ip1 + numVertices2;
 300673                            tris[cnt++] = i + numVertices2;
 300674                            tris[cnt++] = ip1;
 675                        }
 676                    }
 677
 6678                    if (inside)
 679                    {
 0680                        for (i = offset; i < numVertices + offset; i++)
 681                        {
 0682                            int ip1 = i + 1;
 683                            //              if(ip1==numVertices+offset)
 684                            //                ip1=offset;
 685
 0686                            tris[cnt++] = ip1;
 0687                            tris[cnt++] = i;
 0688                            tris[cnt++] = i + numVertices2;
 689
 0690                            tris[cnt++] = i + numVertices2;
 0691                            tris[cnt++] = ip1 + numVertices2;
 0692                            tris[cnt++] = ip1;
 693                        }
 694                    }
 695                }
 696
 18697                if (bTopCap)
 698                {
 612699                    for (i = 0; i < numVertices; ++i)
 700                    {
 300701                        int next = coverTopIndexStart + i + 1;
 702
 300703                        if (next == coverTopIndexEnd)
 704                        {
 6705                            next = coverTopIndexStart;
 706                        }
 707
 300708                        tris[cnt++] = next;
 300709                        tris[cnt++] = coverTopIndexStart + i;
 300710                        tris[cnt++] = coverTopIndexEnd;
 711                    }
 712                }
 713
 18714                if (bBottomCap)
 715                {
 1836716                    for (i = 0; i < numVertices; ++i)
 717                    {
 900718                        int next = coverBottomIndexStart + i + 1;
 900719                        if (next == coverBottomIndexEnd)
 720                        {
 18721                            next = coverBottomIndexStart;
 722                        }
 723
 900724                        tris[cnt++] = coverBottomIndexEnd;
 900725                        tris[cnt++] = coverBottomIndexStart + i;
 900726                        tris[cnt++] = next;
 727                    }
 728                }
 729
 18730                mesh.triangles = tris;
 731                //AssetDatabase.CreateAsset(mesh, meshPrefabPath);
 732                //AssetDatabase.SaveAssets();
 733            }
 734
 18735            return mesh;
 736        }
 737
 738        public static Mesh BuildCone(int numVertices, float radiusTop, float radiusBottom, float length,
 739            float openingAngle, bool outside, bool inside)
 740        {
 12741            return BuildConeOrCylinder(numVertices, radiusTop, radiusBottom, length, openingAngle, outside, inside,
 742                false,
 743                new Vector3(0f, -length / 2, 0f));
 744        }
 745
 746        public static Mesh BuildCylinder(int numVertices, float radiusTop, float radiusBottom, float length,
 747            float openingAngle, bool outside, bool inside)
 748        {
 6749            return BuildConeOrCylinder(numVertices, radiusTop, radiusBottom, length, openingAngle, outside, inside,
 750                true,
 751                new Vector3(0f, -length / 2, 0f));
 752        }
 753    }
 754}
Generated by: ReportGenerator 4.8.9.0
03/15/2022 - 08:46:05
GitHub | www.palmmedia.de

Methods/Properties

BuildSphere(System.Single)
BuildPlane(System.Single)
BuildCube(System.Single)
BuildConeOrCylinder(System.Int32, System.Single, System.Single, System.Single, System.Single, System.Boolean, System.Boolean, System.Boolean, UnityEngine.Vector3)
BuildCone(System.Int32, System.Single, System.Single, System.Single, System.Single, System.Boolean, System.Boolean)
BuildCylinder(System.Int32, System.Single, System.Single, System.Single, System.Single, System.Boolean, System.Boolean)