Added optimization to use 16 bit indices if possible.

MeshBuilder .AddQuadrangle added.

examples/Example1/Program.cs

@@ -35,7 +35,7 @@ namespace Example1
             prim.AddTriangle(new VERTEX(10, 0, 0), new VERTEX(-10, 0, 0), new VERTEX(0, -10, 0));
 
             prim = mesh.UsePrimitive(material2);
-            prim.AddConvexPolygon(new VERTEX(-5, 0, 3), new VERTEX(0, -5, 3), new VERTEX(5, 0, 3), new VERTEX(0, 5, 3));
+            prim.AddQuadrangle(new VERTEX(-5, 0, 3), new VERTEX(0, -5, 3), new VERTEX(5, 0, 3), new VERTEX(0, 5, 3));
 
             // create a scene
 
@@ -51,22 +51,4 @@ namespace Example1
             model.SaveGLTF("mesh.gltf");
         }
     }
-
-    static class ToolkitUtils
-    {
-        public static void AddConvexPolygon<TMaterial, TvG, TvM, TvS>(this PrimitiveBuilder<TMaterial, TvG, TvM, TvS> primitive, params VertexBuilder<TvG, TvM, TvS>[] vertices)
-        where TvG : struct, IVertexGeometry
-        where TvM : struct, IVertexMaterial
-        where TvS : struct, IVertexSkinning
-        {
-            for (int i = 2; i < vertices.Length; ++i)
-            {
-                var a = vertices[0];
-                var b = vertices[i - 1];
-                var c = vertices[i];
-
-                primitive.AddTriangle(a, b, c);
-            }
-        }
-    }
 }

examples/InfiniteSkinnedTentacle/Program.cs

@@ -132,14 +132,14 @@ namespace InfiniteSkinnedTentacle
 
                 if (i == 0)
                 {
-                    prim.AddConvexPolygon(b0, b1, b2, b3);
+                    prim.AddQuadrangle(b0, b1, b2, b3);
                 }
                 else
                 {
-                    prim.AddConvexPolygon(b0, b1, a1, a0);
-                    prim.AddConvexPolygon(b1, b2, a2, a1);
-                    prim.AddConvexPolygon(b2, b3, a3, a2);
-                    prim.AddConvexPolygon(b3, b0, a0, a3);
+                    prim.AddQuadrangle(b0, b1, a1, a0);
+                    prim.AddQuadrangle(b1, b2, a2, a1);
+                    prim.AddQuadrangle(b2, b3, a3, a2);
+                    prim.AddQuadrangle(b3, b0, a0, a3);
                 }
 
                 a0 = b0;
@@ -148,27 +148,9 @@ namespace InfiniteSkinnedTentacle
                 a3 = b3;
             }
 
-            prim.AddConvexPolygon(a3, a2, a1, a0);
+            prim.AddQuadrangle(a3, a2, a1, a0);
 
             return mesh;
         }
-    }
-
-    static class ToolkitUtils
-    {
-        public static void AddConvexPolygon<TMaterial, TvG, TvM, TvS>(this PrimitiveBuilder<TMaterial, TvG, TvM, TvS> primitive, params VertexBuilder<TvG, TvM, TvS>[] vertices)
-        where TvG : struct, IVertexGeometry
-        where TvM : struct, IVertexMaterial
-        where TvS : struct, IVertexSkinning
-        {
-            for (int i = 2; i < vertices.Length; ++i)
-            {
-                var a = vertices[0];
-                var b = vertices[i - 1];
-                var c = vertices[i];
-
-                primitive.AddTriangle(a, b, c);
-            }
-        }
-    }
+    }    
 }

src/SharpGLTF.Toolkit/Geometry/MeshBuilderToolkit.cs

@@ -89,5 +89,22 @@ namespace SharpGLTF.Geometry
         {
             return mesh.Primitives.All(prim => prim.IsEmpty());
         }
+
+        /// <summary>
+        /// Given a set of 4 points defining a quadrangle, it determines which
+        /// is the optimal diagonal to choose to reprensent the quadrangle as two triangles.
+        /// </summary>
+        /// <param name="a"></param>
+        /// <param name="b"></param>
+        /// <param name="c"></param>
+        /// <param name="d"></param>
+        /// <returns></returns>
+        public static bool GetQuadrangleDiagonal(Vector3 a, Vector3 b, Vector3 c, Vector3 d)
+        {
+            var area1 = Vector3.Cross(a - b, c - b).Length() + Vector3.Cross(a - d, c - d).Length();
+            var area2 = Vector3.Cross(b - a, d - a).Length() + Vector3.Cross(b - c, d - c).Length();
+
+            return area1 <= area2;
+        }
     }
 }

src/SharpGLTF.Toolkit/Geometry/PrimitiveBuilder.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Text;
 using System.Linq;
@@ -6,7 +7,7 @@ using System.Numerics;
 
 using SharpGLTF.Collections;
 using SharpGLTF.Geometry.VertexTypes;
-using System.Collections;
+
 
 namespace SharpGLTF.Geometry
 {
@@ -60,6 +61,8 @@ namespace SharpGLTF.Geometry
         (int, int) AddLine(IVertexBuilder a, IVertexBuilder b);
 
         (int, int, int) AddTriangle(IVertexBuilder a, IVertexBuilder b, IVertexBuilder c);
+
+        (int, int, int, int) AddQuadrangle(IVertexBuilder a, IVertexBuilder b, IVertexBuilder c, IVertexBuilder d);
     }
 
     /// <summary>
@@ -300,6 +303,94 @@ namespace SharpGLTF.Geometry
                 if (!_Mesh.VertexPreprocessor.PreprocessVertex(ref c)) return (-1, -1, -1);
             }
 
+            return _AddTriangle(a, b, c);
+        }
+
+        /// <summary>
+        /// Adds a quadrangle.
+        /// </summary>
+        /// <param name="a">First corner of the quadrangle.</param>
+        /// <param name="b">Second corner of the quadrangle.</param>
+        /// <param name="c">Third corner of the quadrangle.</param>
+        /// <param name="d">Fourth corner of the quadrangle.</param>
+        /// <returns>The indices of the vertices, or, in case the quadrangle is degenerated, (-1,-1,-1,-1).</returns>
+        /// <remarks>
+        /// If only one of the vertices is degenerated, leading to a single triangle, the resulting indices would
+        /// have just one negative index, like this: (16,-1,17,18)
+        /// </remarks>
+        public (int, int, int, int) AddQuadrangle(IVertexBuilder a, IVertexBuilder b, IVertexBuilder c, IVertexBuilder d)
+        {
+            Guard.NotNull(a, nameof(a));
+            Guard.NotNull(b, nameof(b));
+            Guard.NotNull(c, nameof(c));
+            Guard.NotNull(d, nameof(d));
+
+            var aa = a.ConvertTo<TvG, TvM, TvS>();
+            var bb = b.ConvertTo<TvG, TvM, TvS>();
+            var cc = c.ConvertTo<TvG, TvM, TvS>();
+            var dd = d.ConvertTo<TvG, TvM, TvS>();
+
+            System.Diagnostics.Debug.Assert(aa.Position == a.GetGeometry().GetPosition());
+            System.Diagnostics.Debug.Assert(bb.Position == b.GetGeometry().GetPosition());
+            System.Diagnostics.Debug.Assert(cc.Position == c.GetGeometry().GetPosition());
+            System.Diagnostics.Debug.Assert(dd.Position == d.GetGeometry().GetPosition());
+
+            return AddQuadrangle(aa, bb, cc, dd);
+        }
+
+        /// <summary>
+        /// Adds a quadrangle.
+        /// </summary>
+        /// <param name="a">First corner of the quadrangle.</param>
+        /// <param name="b">Second corner of the quadrangle.</param>
+        /// <param name="c">Third corner of the quadrangle.</param>
+        /// <param name="d">Fourth corner of the quadrangle.</param>
+        /// <returns>The indices of the vertices, or, in case the quadrangle is degenerated, (-1,-1,-1,-1).</returns>
+        public (int, int, int, int) AddQuadrangle(VertexBuilder<TvG, TvM, TvS> a, VertexBuilder<TvG, TvM, TvS> b, VertexBuilder<TvG, TvM, TvS> c, VertexBuilder<TvG, TvM, TvS> d)
+        {
+            Guard.IsTrue(_PrimitiveVertexCount == 3, nameof(VerticesPerPrimitive), "Quadrangles are not supported for this primitive");
+
+            if (_Mesh.VertexPreprocessor != null)
+            {
+                if (!_Mesh.VertexPreprocessor.PreprocessVertex(ref a)) return (-1, -1, -1, -1);
+                if (!_Mesh.VertexPreprocessor.PreprocessVertex(ref b)) return (-1, -1, -1, -1);
+                if (!_Mesh.VertexPreprocessor.PreprocessVertex(ref c)) return (-1, -1, -1, -1);
+                if (!_Mesh.VertexPreprocessor.PreprocessVertex(ref d)) return (-1, -1, -1, -1);
+            }
+
+            // at some points it could be interesting to comply with https://github.com/KhronosGroup/glTF/pull/1620
+
+            var oddEven = MeshBuilderToolkit.GetQuadrangleDiagonal(a.Position, b.Position, c.Position, d.Position);
+
+            if (oddEven)
+            {
+                var f = _AddTriangle(a, b, c);
+                var s = _AddTriangle(a, c, d);
+                return
+                    (
+                    f.Item1 > s.Item1 ? f.Item1 : s.Item1,
+                    f.Item2,
+                    f.Item3 > s.Item2 ? f.Item3 : s.Item2,
+                    s.Item3
+                    );
+            }
+            else
+            {
+                var f = _AddTriangle(b, c, d);
+                var s = _AddTriangle(b, d, a);
+
+                return
+                    (
+                    s.Item3,
+                    f.Item1 > s.Item1 ? f.Item1 : s.Item1,
+                    f.Item2,
+                    f.Item3 > s.Item2 ? f.Item3 : s.Item2
+                    );
+            }
+        }
+
+        private (int, int, int) _AddTriangle(VertexBuilder<TvG, TvM, TvS> a, VertexBuilder<TvG, TvM, TvS> b, VertexBuilder<TvG, TvM, TvS> c)
+        {
             // check for degenerated triangle
             if (a.Equals(b) || a.Equals(c) || b.Equals(c)) return (-1, -1, -1);
 

src/SharpGLTF.Toolkit/Geometry/VertexTypes/VertexUtils.cs

@@ -261,13 +261,17 @@ namespace SharpGLTF.Geometry.VertexTypes
         {
             Guard.IsTrue(indexBlocks.Any(), nameof(indexBlocks));
 
-            // get attributes
+            // total number of indices
             var totalCount = indexBlocks.Sum(item => item.Count);
 
-            var attribute = new MemoryAccessInfo("INDEX", 0, totalCount, 0, Schema2.DimensionType.SCALAR, Schema2.EncodingType.UNSIGNED_INT);
+            // determine appropiate encoding
+            var maxIndex = totalCount == 0 ? 0 : indexBlocks.SelectMany(item => item).Max();
+            var encoding = maxIndex < 65535 ? Schema2.EncodingType.UNSIGNED_SHORT : Schema2.EncodingType.UNSIGNED_INT;
+
+            var attribute = new MemoryAccessInfo("INDEX", 0, totalCount, 0, Schema2.DimensionType.SCALAR, encoding);
 
             // create master index buffer
-            var ibytes = new Byte[4 * totalCount];
+            var ibytes = new Byte[encoding.ByteLength() * totalCount];
             var ibuffer = new ArraySegment<byte>(ibytes);
 
             var baseIndicesIndex = 0;

tests/SharpGLTF.Tests/Geometry/Parametric/SolidMeshUtils.cs

@@ -73,7 +73,7 @@ namespace SharpGLTF.Geometry.Parametric
             var p4 = Vector3.Transform(origin - axisX + axisY, xform);
             var n = Vector3.Normalize(Vector3.TransformNormal(origin, xform));
 
-            primitiveBuilder.AddConvexPolygon
+            primitiveBuilder.AddQuadrangle
                 (
                 new VERTEX( (p1, n), (Vector4.One, Vector2.Zero)  ),
                 new VERTEX( (p2, n), (Vector4.One, Vector2.UnitX) ),
@@ -259,7 +259,7 @@ namespace SharpGLTF.Geometry.Parametric
 
                     terrainMesh
                         .UsePrimitive(material)
-                        .AddConvexPolygon
+                        .AddQuadrangle
                         (
                             (a, at),
                             (b, bt),

tests/SharpGLTF.Tests/Scenes/SceneBuilderTests.cs

@@ -25,7 +25,7 @@ namespace SharpGLTF.Scenes
             TestContext.CurrentContext.AttachShowDirLink();
             TestContext.CurrentContext.AttachGltfValidatorLinks();
 
-            var mesh = new Cube<MaterialBuilder>(new MaterialBuilder())
+            var mesh = new Cube<MaterialBuilder>(MaterialBuilder.CreateDefault())
                 .ToMesh(Matrix4x4.Identity);
 
             var scene = new SceneBuilder();
@@ -35,6 +35,42 @@ namespace SharpGLTF.Scenes
             scene.AttachToCurrentTest("cube.glb");
         }
 
+        [Test]
+        public void CreateQuadsScene()
+        {
+            TestContext.CurrentContext.AttachShowDirLink();
+            TestContext.CurrentContext.AttachGltfValidatorLinks();            
+
+            // this test checks that non convex quads are created correctly.
+
+            var mesh = new MeshBuilder<VertexPosition>();
+            var prim = mesh.UsePrimitive(MaterialBuilder.CreateDefault());
+
+            var idx = prim.AddQuadrangle(new VertexPosition(0, -1, 0), new VertexPosition(1, 0, 0), new VertexPosition(0, 1, 0), new VertexPosition(-1, 0, 0));
+            Assert.AreEqual((0, 1, 2, 3), idx);
+
+            idx = prim.AddQuadrangle(new VertexPosition(0, -1, 1), new VertexPosition(1, 0, 1), new VertexPosition(0, 1, 1), new VertexPosition(0.5f, 0, 1));
+            Assert.AreEqual((7,4,5,6), idx);
+
+            idx = prim.AddQuadrangle(new VertexPosition(0, 0.5f, 2), new VertexPosition(1, 0, 2), new VertexPosition(0, 1, 2), new VertexPosition(-1, 0, 2));
+            Assert.AreEqual((8,9,10,11), idx);
+
+            idx = prim.AddQuadrangle(new VertexPosition(1, 0, 3), new VertexPosition(0, 1, 3), new VertexPosition(0.5f, 0, 3), new VertexPosition(0, -1, 3));
+            Assert.AreEqual((12,13,14,15), idx);
+
+            idx = prim.AddQuadrangle(new VertexPosition(1, 0, 4), new VertexPosition(1, 0, 4), new VertexPosition(0, 1, 4), new VertexPosition(-1, 0, 4));
+            Assert.AreEqual((16, -1, 17, 18), idx);
+
+            idx = prim.AddQuadrangle(new VertexPosition(1, 0, 4), new VertexPosition(1, 0, 4), new VertexPosition(0, 1, 4), new VertexPosition(0, 1, 4));
+            Assert.AreEqual((-1, -1, -1, -1), idx);
+
+            var scene = new SceneBuilder();
+
+            scene.AddMesh(mesh, Matrix4x4.Identity);
+
+            scene.AttachToCurrentTest("cube.glb");
+        }
+
         [Test]
         public void CreateAnimatedCubeScene()
         {
@@ -215,15 +251,15 @@ namespace SharpGLTF.Scenes
             mesh.VertexPreprocessor.SetSanitizerPreprocessors();
             #endif
 
-            mesh.UsePrimitive(pink).AddConvexPolygon(v1, v2, v6, v5);
-            mesh.UsePrimitive(pink).AddConvexPolygon(v2, v3, v7, v6);
-            mesh.UsePrimitive(pink).AddConvexPolygon(v3, v4, v8, v7);
-            mesh.UsePrimitive(pink).AddConvexPolygon(v4, v1, v5, v8);
+            mesh.UsePrimitive(pink).AddQuadrangle(v1, v2, v6, v5);
+            mesh.UsePrimitive(pink).AddQuadrangle(v2, v3, v7, v6);
+            mesh.UsePrimitive(pink).AddQuadrangle(v3, v4, v8, v7);
+            mesh.UsePrimitive(pink).AddQuadrangle(v4, v1, v5, v8);
 
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v5, v6, v10, v9);
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v6, v7, v11, v10);
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v7, v8, v12, v11);
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v8, v5, v9, v12);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v5, v6, v10, v9);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v6, v7, v11, v10);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v7, v8, v12, v11);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v8, v5, v9, v12);
 
             mesh.Validate();
             
@@ -302,15 +338,15 @@ namespace SharpGLTF.Scenes
             mesh.VertexPreprocessor.SetSanitizerPreprocessors();
             #endif
 
-            mesh.UsePrimitive(pink).AddConvexPolygon(v1, v2, v6, v5);
-            mesh.UsePrimitive(pink).AddConvexPolygon(v2, v3, v7, v6);
-            mesh.UsePrimitive(pink).AddConvexPolygon(v3, v4, v8, v7);
-            mesh.UsePrimitive(pink).AddConvexPolygon(v4, v1, v5, v8);
+            mesh.UsePrimitive(pink).AddQuadrangle(v1, v2, v6, v5);
+            mesh.UsePrimitive(pink).AddQuadrangle(v2, v3, v7, v6);
+            mesh.UsePrimitive(pink).AddQuadrangle(v3, v4, v8, v7);
+            mesh.UsePrimitive(pink).AddQuadrangle(v4, v1, v5, v8);
 
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v5, v6, v10, v9);
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v6, v7, v11, v10);
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v7, v8, v12, v11);
-            mesh.UsePrimitive(yellow).AddConvexPolygon(v8, v5, v9, v12);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v5, v6, v10, v9);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v6, v7, v11, v10);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v7, v8, v12, v11);
+            mesh.UsePrimitive(yellow).AddQuadrangle(v8, v5, v9, v12);
 
             mesh.Validate();
 

tests/SharpGLTF.Tests/Schema2/Authoring/ExtensionsCreationTests.cs

@@ -71,7 +71,7 @@ namespace SharpGLTF.Schema2.Authoring
                 .WithChannelImage(Materials.KnownChannels.SpecularGlossiness, System.IO.Path.Combine(basePath, "WaterBottle_specularGlossiness.png"));
 
             var mesh = new Geometry.MeshBuilder<VPOS, VTEX>("mesh1");
-            mesh.UsePrimitive(material).AddConvexPolygon
+            mesh.UsePrimitive(material).AddQuadrangle
                 ((new Vector3(-10, 10, 0), new Vector2(1, 0))
                 , (new Vector3(10, 10, 0), new Vector2(0, 0))
                 , (new Vector3(10, -10, 0), new Vector2(0, 1))
@@ -109,7 +109,7 @@ namespace SharpGLTF.Schema2.Authoring
 
             mesh
                 .UsePrimitive(material)
-                .AddConvexPolygon
+                .AddQuadrangle
                 ((new Vector3(-10, 10, 0), new Vector2(1, 0))
                 , (new Vector3(10, 10, 0), new Vector2(0, 0))
                 , (new Vector3(10, -10, 0), new Vector2(0, 1))
@@ -149,7 +149,7 @@ namespace SharpGLTF.Schema2.Authoring
 
             mesh
                 .UsePrimitive(material)
-                .AddConvexPolygon
+                .AddQuadrangle
                 ((new Vector3(-10, 10, 0), new Vector2(1, 0))
                 , (new Vector3(10, 10, 0), new Vector2(0, 0))
                 , (new Vector3(10, -10, 0), new Vector2(0, 1))

tests/SharpGLTF.Tests/Schema2/Authoring/MeshBuilderCreationTests.cs

@@ -40,7 +40,7 @@ namespace SharpGLTF.Schema2.Authoring
             meshBuilder.VertexPreprocessor.SetDebugPreprocessors();
 
             // add a polygon to the primitive that uses material1 as key.
-            meshBuilder.UsePrimitive(material1).AddConvexPolygon(v1, v2, v3, v4);
+            meshBuilder.UsePrimitive(material1).AddQuadrangle(v1, v2, v3, v4);
 
             // create a gltf scene
             var model = ModelRoot.CreateModel();
@@ -201,15 +201,15 @@ namespace SharpGLTF.Schema2.Authoring
             var v11 = (new VPOS(+5, 80, -5), new VSKIN4(jointIdx2));
             var v12 = (new VPOS(-5, 80, -5), new VSKIN4(jointIdx2));
 
-            meshBuilder.UsePrimitive(pink).AddConvexPolygon(v1, v2, v6, v5);
-            meshBuilder.UsePrimitive(pink).AddConvexPolygon(v2, v3, v7, v6);
-            meshBuilder.UsePrimitive(pink).AddConvexPolygon(v3, v4, v8, v7);
-            meshBuilder.UsePrimitive(pink).AddConvexPolygon(v4, v1, v5, v8);
+            meshBuilder.UsePrimitive(pink).AddQuadrangle(v1, v2, v6, v5);
+            meshBuilder.UsePrimitive(pink).AddQuadrangle(v2, v3, v7, v6);
+            meshBuilder.UsePrimitive(pink).AddQuadrangle(v3, v4, v8, v7);
+            meshBuilder.UsePrimitive(pink).AddQuadrangle(v4, v1, v5, v8);
 
-            meshBuilder.UsePrimitive(yellow).AddConvexPolygon(v5, v6, v10, v9);
-            meshBuilder.UsePrimitive(yellow).AddConvexPolygon(v6, v7, v11, v10);
-            meshBuilder.UsePrimitive(yellow).AddConvexPolygon(v7, v8, v12, v11);
-            meshBuilder.UsePrimitive(yellow).AddConvexPolygon(v8, v5, v9, v12);
+            meshBuilder.UsePrimitive(yellow).AddQuadrangle(v5, v6, v10, v9);
+            meshBuilder.UsePrimitive(yellow).AddQuadrangle(v6, v7, v11, v10);
+            meshBuilder.UsePrimitive(yellow).AddQuadrangle(v7, v8, v12, v11);
+            meshBuilder.UsePrimitive(yellow).AddQuadrangle(v8, v5, v9, v12);
 
             meshBuilder.Validate();
 

tests/SharpGLTF.Tests/ToolkitUtils.cs

@@ -1,40 +0,0 @@
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using SharpGLTF.Geometry;
-using SharpGLTF.Geometry.VertexTypes;
-
-namespace SharpGLTF
-{
-    static class ToolkitUtils
-    {
-        public static void AddConvexPolygon<TMaterial, TvG, TvM, TvS>(this PrimitiveBuilder<TMaterial, TvG, TvM, TvS> primitive, params VertexBuilder<TvG, TvM, TvS>[] vertices)
-        where TvG : struct, IVertexGeometry
-        where TvM : struct, IVertexMaterial
-        where TvS : struct, IVertexSkinning
-        {
-            for (int i = 2; i < vertices.Length; ++i)
-            {
-                var a = vertices[0];
-                var b = vertices[i - 1];
-                var c = vertices[i];
-
-                primitive.AddTriangle(a, b, c);
-            }
-        }
-
-        public static void AddConvexPolygon(this IPrimitiveBuilder primitive, params IVertexBuilder[] vertices)
-        {
-            for (int i = 2; i < vertices.Length; ++i)
-            {
-                var a = vertices[0];
-                var b = vertices[i - 1];
-                var c = vertices[i];
-
-                primitive.AddTriangle(a, b, c);
-            }
-        }
-    }
-}