private static void _AddSphereFace(IPrimitiveBuilder primitiveBuilder, Matrix4x4 xform, Vector3 a, Vector3 b, Vector3 c, int iterations = 0)
        {
            if (iterations <= 0)
            {
                var tt = (a + b + c) / 3.0f;

                var aa = _CreateVertex(a, xform);
                var bb = _CreateVertex(b, xform);
                var cc = _CreateVertex(c, xform);
                primitiveBuilder.AddTriangle(aa, bb, cc);
                return;
            }

            --iterations;

            var ab = Vector3.Normalize(a + b) * a.Length();
            var bc = Vector3.Normalize(b + c) * b.Length();
            var ca = Vector3.Normalize(c + a) * c.Length();

            // central triangle
            _AddSphereFace(primitiveBuilder, xform, ab, bc, ca, iterations);

            // vertex triangles
            _AddSphereFace(primitiveBuilder, xform, a, ab, ca, iterations);
            _AddSphereFace(primitiveBuilder, xform, b, bc, ab, iterations);
            _AddSphereFace(primitiveBuilder, xform, c, ca, bc, iterations);
        }
        private static void _AddCubeFace(IPrimitiveBuilder primitiveBuilder, Vector3 origin, Vector3 axisX, Vector3 axisY, Matrix4x4 xform)
        {
            var p1 = Vector3.Transform(origin - axisX - axisY, xform);
            var p2 = Vector3.Transform(origin + axisX - axisY, xform);
            var p3 = Vector3.Transform(origin + axisX + axisY, xform);
            var p4 = Vector3.Transform(origin - axisX + axisY, xform);
            var n  = Vector3.Normalize(Vector3.TransformNormal(origin, xform));

            primitiveBuilder.AddQuadrangle
            (
                new VERTEX((p1, n), (Vector4.One, Vector2.Zero)),
                new VERTEX((p2, n), (Vector4.One, Vector2.UnitX)),
                new VERTEX((p3, n), (Vector4.One, Vector2.One)),
                new VERTEX((p4, n), (Vector4.One, Vector2.UnitY))
            );
        }
Exemple #3
0
        public static IMeshBuilder <Materials.MaterialBuilder> ToMeshBuilder(this Mesh srcMesh)
        {
            if (srcMesh == null)
            {
                return(null);
            }

            var vertexAttributes = srcMesh.Primitives
                                   .SelectMany(item => item.VertexAccessors.Keys)
                                   .Distinct()
                                   .ToArray();

            var dstMesh = MeshBuilderToolkit.CreateMeshBuilderFromVertexAttributes <Materials.MaterialBuilder>(vertexAttributes);

            dstMesh.Name   = srcMesh.Name;
            dstMesh.Extras = srcMesh.Extras.DeepClone();

            Materials.MaterialBuilder defMat = null;

            var dstMaterials = new Dictionary <Material, Materials.MaterialBuilder>();

            IPrimitiveBuilder GetPrimitive(Material srcMaterial, int vcount)
            {
                IPrimitiveBuilder dstPrim = null;

                if (srcMaterial == null)
                {
                    if (defMat == null)
                    {
                        defMat = Materials.MaterialBuilder.CreateDefault();
                    }
                    dstPrim = dstMesh.UsePrimitive(defMat, vcount);
                }
                else
                {
                    if (!dstMaterials.TryGetValue(srcMaterial, out Materials.MaterialBuilder dstMat))
                    {
                        dstMat = new Materials.MaterialBuilder();
                        srcMaterial.CopyTo(dstMat);
                        dstMaterials[srcMaterial] = dstMat;
                    }

                    dstPrim = dstMesh.UsePrimitive(dstMat, vcount);
                }

                return(dstPrim);
            }

            foreach (var srcPrim in srcMesh.Primitives)
            {
                int vcount = 0;
                if (srcPrim.GetPointIndices().Any())
                {
                    vcount = 1;
                }
                if (srcPrim.GetLineIndices().Any())
                {
                    vcount = 2;
                }
                if (srcPrim.GetTriangleIndices().Any())
                {
                    vcount = 3;
                }

                var dstPrim = GetPrimitive(srcPrim.Material, vcount);

                dstPrim.AddPrimitiveGeometry(srcPrim);
            }

            return(dstMesh);
        }