コード例 #1
0
        public static IEnumerable <(IVertexBuilder A, IVertexBuilder B, IVertexBuilder C, Material Material)> EvaluateTriangles(this MeshPrimitive prim, MESHXFORM xform = null)
        {
            if (prim == null)
            {
                yield break;
            }
            if (xform != null && !xform.Visible)
            {
                yield break;
            }

            var triangles = prim.GetTriangleIndices();

            if (!triangles.Any())
            {
                yield break;
            }

            var vertices = prim.GetVertexColumns(xform);
            var vtype    = vertices.GetCompatibleVertexType();

            foreach (var t in triangles)
            {
                var a = vertices.GetVertex(vtype, t.A);
                var b = vertices.GetVertex(vtype, t.B);
                var c = vertices.GetVertex(vtype, t.C);

                yield return(a, b, c, prim.Material);
            }
        }
コード例 #2
0
 public static MeshPrimitive WithVertexAccessors <TvP, TvM, TvS>(this MeshPrimitive primitive, IReadOnlyList <(TvP Geo, TvM Mat, TvS Skin)> vertices)
コード例 #3
0
        public static IEnumerable <(IVertexBuilder A, Material Material)> EvaluatePoints(this MeshPrimitive prim, MESHXFORM xform = null)
        {
            if (prim == null)
            {
                yield break;
            }
            if (xform != null && !xform.Visible)
            {
                yield break;
            }

            var points = prim.GetPointIndices();

            if (!points.Any())
            {
                yield break;
            }

            var vertices = prim.GetVertexColumns(xform);
            var vtype    = vertices.GetCompatibleVertexType();

            foreach (var t in points)
            {
                var a = vertices.GetVertex(vtype, t);

                yield return(a, prim.Material);
            }
        }
コード例 #4
0
        public static IEnumerable <(IVertexBuilder A, IVertexBuilder B, Material Material)> EvaluateLines(this MeshPrimitive prim, MESHXFORM xform = null)
        {
            if (prim == null)
            {
                yield break;
            }
            if (xform != null && !xform.Visible)
            {
                yield break;
            }

            var lines = prim.GetLineIndices();

            if (!lines.Any())
            {
                yield break;
            }

            var vertices = prim.GetVertexColumns(xform);
            var vtype    = vertices.GetCompatibleVertexType();

            foreach (var(la, lb) in lines)
            {
                var va = vertices.GetVertex(vtype, la);
                var vb = vertices.GetVertex(vtype, lb);

                yield return(va, vb, prim.Material);
            }
        }
コード例 #5
0
 public static MeshPrimitive WithVertexAccessors <TVertex, TValues>(this MeshPrimitive primitive, IReadOnlyList <(TVertex, TValues)> vertices)
コード例 #6
0
 public static MeshPrimitive WithVertexAccessors <TvP, TvM>(this MeshPrimitive primitive, IReadOnlyList <(TvP, TvM)> vertices)
コード例 #7
0
            static IEnumerable <Vertex> GetVerticesFromPrimitive(GLTF.MeshPrimitive prim)
            {
                var pos = prim.VertexAccessors["POSITION"];
                //pos = prim.GetVertexAccessor("POSITON");
                var result = pos.AsVector3Array().Select((p, idx) => {
                    return(new Vertex {
                        pos = p
                    });
                });

                prim.VertexAccessors.TryGetValue("NORMAL", out var normal);
                if (normal != null && normal.Count > 0)
                {
                    var na = normal.AsVector3Array();
                    result = result.Select((vtx, idx) => { vtx.normal = na[idx]; return(vtx); });
                }

                prim.VertexAccessors.TryGetValue("TANGENT", out var tangent);
                if (tangent != null && tangent.Count > 0)
                {
                    var ta = tangent.AsVector4Array();
                    result = result.Select((vtx, idx) =>
                    {
                        var et             = ta[idx];
                        var tangent_vector = new Vector3(et.X, et.Y, et.Z);
                        var binormal       = Vector3.Cross(tangent_vector, vtx.normal.Value) * et.W;
                        vtx.tangent        = tangent_vector;
                        vtx.binormal       = binormal;

                        return(vtx);
                    });
                }

                prim.VertexAccessors.TryGetValue("COLOR_0", out var vcols);
                if (vcols != null && vcols.Count > 0)
                {
                    if (vcols.Dimensions == GLTF.DimensionType.VEC4)
                    {
                        var vca = vcols.AsVector4Array();
                        result = result.Select((vtx, idx) => { vtx.vtx_col = vca[idx]; return(vtx); });
                    }
                    else
                    {
                        var vca = vcols.AsVector3Array();
                        // TODO: Does Diesel have opaque be 1, 0, or 255?
                        result = result.Select((vtx, idx) => { vtx.vtx_col = new Vector4(vca[idx], 1.0f); return(vtx); });
                    }
                }

                for (int i = 0; i < 8; i++)
                {
                    var ii = i; // Closures capture by reference, and i is declared outside the loop body in for.
                    prim.VertexAccessors.TryGetValue($"TEXCOORD_{ii}", out var uvs);
                    if (uvs != null && uvs.Count > 0)
                    {
                        var uva = uvs.AsVector2Array();
                        result = result.Select((vtx, idx) => { vtx.uv[ii] = new Vector2(uva[idx].X, 1 - uva[idx].Y); return(vtx); });
                    }
                }

                prim.VertexAccessors.TryGetValue("JOINTS_0", out var joints);
                prim.VertexAccessors.TryGetValue("WEIGHTS_0", out var weights);
                if (joints != null && joints.Count > 0)
                {
                    var ja = joints.AsVector4Array();
                    var wa = joints.AsVector4Array();
                    result = result.Select((vtx, idx) =>
                    {
                        var gltfWeight = ja[idx];
                        vtx.weight     = new Vector3(gltfWeight.X, gltfWeight.Y, gltfWeight.Z);
                        if (gltfWeight.W > 0)
                        {
                            Log.Default.Warn($"{prim.LogicalParent.Name} has a vertex with >3 weights at {vtx.pos}!");
                        }
                        vtx.weightGroups = new DM.GeometryWeightGroups(
                            (ushort)wa[idx].X,
                            (ushort)wa[idx].Y,
                            (ushort)wa[idx].Z,
                            (ushort)wa[idx].W
                            );

                        return(vtx);
                    });
                }

                return(result);
            }
コード例 #8
0
        public static IEnumerable <(IVertexBuilder A, IVertexBuilder B, IVertexBuilder C, Material Material)> EvaluateTriangles(this MeshPrimitive prim, MESHXFORM xform = null)
        {
            if (prim == null)
            {
                yield break;
            }
            if (xform != null && !xform.Visible)
            {
                yield break;
            }

            var vertices  = prim.GetVertexColumns();
            var triangles = prim.GetTriangleIndices();

            if (!triangles.Any())
            {
                yield break;
            }

            foreach (var xinst in Transforms.InstancingTransform.Evaluate(xform))
            {
                var xvertices = xinst != null?vertices.WithTransform(xinst) : vertices;

                var vtype = vertices.GetCompatibleVertexType();

                foreach (var(ta, tb, tc) in triangles)
                {
                    var va = xvertices.GetVertex(vtype, ta);
                    var vb = xvertices.GetVertex(vtype, tb);
                    var vc = xvertices.GetVertex(vtype, tc);

                    yield return(va, vb, vc, prim.Material);
                }
            }
        }