Example #1
0
        private static Mesh MergeMeshes(List <Mesh> meshes, List <Material> materials, List <Matrix4f> transforms)
        {
            Mesh resMesh = new Mesh();

            if (meshes.Count > 0)
            {
                List <Vertex> finalVertices = new List <Vertex>();
                for (int m = 0; m < meshes.Count; m++)
                {
                    for (int i = 0; i < meshes[m].indices.Count; i++)
                    {
                        Vertex vertex  = meshes[m].vertices[meshes[m].indices[i]];
                        Vertex newVert = new Vertex(vertex);
                        newVert.SetPosition(vertex.GetPosition().Multiply(transforms[m]));
                        if (vertex.GetNormal() != null)
                        {
                            newVert.SetNormal(vertex.GetNormal().Multiply(transforms[m].Invert().TransposeStore()));
                        }
                        finalVertices.Add(newVert);
                    }
                }
                resMesh.SetVertices(finalVertices);
                resMesh.Material      = materials[0];
                resMesh.PrimitiveType = meshes[0].PrimitiveType;
            }
            return(resMesh);
        }
Example #2
0
        public SKNFile(WGTFile Weights, SCOFile Model)
        {
            this.Submeshes.Add(new SKNSubmesh(Model.Name, 0, (uint)Model.Vertices.Count, 0, (uint)Model.Faces.Count * 3));
            foreach (Vector3 Vertex in Model.Vertices)
            {
                this.Vertices.Add(new SKNVertex(Vertex));
            }
            for (int i = 0; i < this.Vertices.Count; i++)
            {
                this.Vertices[i].SetWeight(Weights.Weights[i].Indices, Weights.Weights[i].Weights);
            }
            for (int i = 0; i < Model.Faces.Count; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    this.Vertices[Model.Faces[i].Indices[j]].SetUV(Model.Faces[i].UV[j]);
                }
                for (int j = 0; j < 3; j++)
                {
                    this.Indices.Add(Model.Faces[i].Indices[j]);
                }
            }
            for (int i = 0; i < Indices.Count; i += 3)
            {
                Vector3 cp = Vector3.Cross(
                    Vertices[Indices[i + 1]].Position - Vertices[Indices[i]].Position,
                    Vertices[Indices[i + 2]].Position - Vertices[Indices[i]].Position);

                Vertices[Indices[i]].SetNormal(Vertices[Indices[i]].Normal + cp);
                Vertices[Indices[i + 1]].SetNormal(Vertices[Indices[i + 1]].Normal + cp);
                Vertices[Indices[i + 2]].SetNormal(Vertices[Indices[i + 2]].Normal + cp);
            }
            foreach (SKNVertex Vertex in Vertices)
            {
                float s = Vertex.Normal.X + Vertex.Normal.Y + Vertex.Normal.Z;
                Vertex.SetNormal(new Vector3(
                                     Vertex.Normal.X / s,
                                     Vertex.Normal.Y / s,
                                     Vertex.Normal.Z / s
                                     )
                                 );
            }
        }
Example #3
0
        // Checks if three clipping planes intersect and if so, returns an intersection point.
        public static bool FindIntersection(Plane a, Plane b, Plane c, out Vertex intersection)
        {
            // Calculates the possible intersection point using the Cramer's rule.
            double det = Determinant(a.A, a.B, a.C, b.A, b.B, b.C, c.A, c.B, c.C);

            if (det >= -1e-6 && det <= 1e-6)
            {
                intersection = null;
                return(false);
            }

            double x = Determinant(a.D, a.B, a.C, b.D, b.B, b.C, c.D, c.B, c.C) / det;
            double y = Determinant(a.A, a.D, a.C, b.A, b.D, b.C, c.A, c.D, c.C) / det;
            double z = Determinant(a.A, a.B, a.D, b.A, b.B, b.D, c.A, c.B, c.D) / det;

            intersection = new Vertex(x, y, z);
            intersection.SetNormal((a.Normal + b.Normal + c.Normal).Unit());

            return(true);
        }
Example #4
0
        private static Mesh MergeMeshes(List<Mesh> meshes, List<Material> materials, List<Matrix4f> transforms)
        {
            Mesh resMesh = new Mesh();

            if (meshes.Count > 0)
            {
                List<Vertex> finalVertices = new List<Vertex>();
                for (int m = 0; m < meshes.Count; m++)
                {
                    for (int i = 0; i < meshes[m].indices.Count; i++)
                    {
                        Vertex vertex = meshes[m].vertices[meshes[m].indices[i]];
                        Vertex newVert = new Vertex(vertex);
                        newVert.SetPosition(vertex.GetPosition().Multiply(transforms[m]));
                        if (vertex.GetNormal() != null)
                            newVert.SetNormal(vertex.GetNormal().Multiply(transforms[m].Invert().TransposeStore()));
                        finalVertices.Add(newVert);
                    }
                }
                resMesh.SetVertices(finalVertices);
                resMesh.Material = materials[0];
                resMesh.PrimitiveType = meshes[0].PrimitiveType;
            }
            return resMesh;
        }
Example #5
0
        private void EndModel()
        {
            if (skeletons.Count > 0)
            {
                Skeleton skeleton = skeletons[skeletons.Count - 1];
                if (skeleton.GetNumBones() > 0)
                {
                    for (int i = 0; i < skeleton.GetNumBones(); i++)
                    {
                        skeleton.GetBone(i).SetToBindingPose();
                    }
                    skeleton.GetBone(0).CalculateBindingRotation();
                    skeleton.GetBone(0).CalculateBindingTranslation();
                    for (int i = 0; i < skeleton.GetNumBones(); i++)
                    {
                        skeleton.GetBone(i).StoreBindingPose();
                        skeleton.GetBone(i).ClearPose();
                    }
                    skeleton.GetBone(0).UpdateTransform();
                }
                if (hasAnimations)
                {
                    for (int j = 0; j < animations.Count; j++)
                    {
                        skeletons[0].AddAnimation(animations[j]);
                    }
                    nodes[0].AddController(new AnimationController(skeletons[0]));
                }
            }
            for (int i = 0; i < meshes.Count; i++)
            {
                List <Vertex> cVerts = vertices[i];
                List <int>    cFaces = faces[i];

                List <Vector3f>   cPos  = positions[i];
                List <Vector3f>   cNorm = normals[i];
                List <Vector2f>   tc0   = texcoords0[i];
                List <Vector2f>   tc1   = texcoords1[i];
                List <BoneAssign> ba    = null;

                Mesh mesh = meshes[i];
                if (boneAssigns.Count > 0)
                {
                    ba = boneAssigns[i];
                }
                int stride = 3;

                if (tc1.Count > 0)
                {
                    stride++;
                }
                for (int j = 0; j < cFaces.Count; j += stride)
                {
                    Vertex v = new Vertex(cPos[cFaces[j]]);
                    if (cNorm.Count > 0)
                    {
                        mesh.GetAttributes().SetAttribute(VertexAttributes.NORMALS);
                        v.SetNormal(cNorm[cFaces[j + 1]]);
                    }
                    if (tc0.Count > 0)
                    {
                        mesh.GetAttributes().SetAttribute(VertexAttributes.TEXCOORDS0);
                        v.SetTexCoord1(tc0[cFaces[j + 2]]);
                    }
                    if (tc1.Count > 0)
                    {
                        mesh.GetAttributes().SetAttribute(VertexAttributes.TEXCOORDS1);
                        v.SetTexCoord1(tc1[cFaces[j + 3]]);
                    }
                    cVerts.Add(v);
                }
                List <int> indexData = new List <int>();
                if (skeletons.Count > 0)
                {
                    mesh.SetSkeleton(skeletons[0]);
                    if (boneAssigns.Count > 0)
                    {
                        for (int j = 0; j < ba.Count; j++)
                        {
                            Vertex v = cVerts[ba[j].GetVertexIndex()];
                            v.AddBoneIndex(ba[j].GetBoneIndex());
                            v.AddBoneWeight(ba[j].GetBoneWeight());
                        }
                    }
                }
                mesh.SetVertices(cVerts);
                if (geoms.Count > 0)
                {
                    Geometry parent   = geoms[i];
                    Material material = null;
                    if (geomMats.ContainsKey(parent))
                    {
                        material = geomMats[parent];
                    }
                    else
                    {
                        material = new Material();
                    }
                    parent.Mesh     = mesh;
                    parent.Material = material;
                }
            }
        }