Beispiel #1
0
        private Color SetMaterialColor(KCLModel.Face f)
        {
            if (GameMaterialSet == GameSet.MarioKart8D)
            {
                switch (f.MaterialFlag)
                {
                case (ushort)CollisionType_MK8D.Road_Default:
                    return(Color.DarkGray);

                case (ushort)CollisionType_MK8D.Glider:
                    return(Color.Orange);

                case (ushort)CollisionType_MK8D.Road_Sand:
                    return(Color.LightYellow);

                case (ushort)CollisionType_MK8D.Offroad_Sand:
                    return(Color.SandyBrown);

                case (ushort)CollisionType_MK8D.Water:
                    return(Color.Blue);

                case (ushort)CollisionType_MK8D.Wall1:
                    return(Color.LightSlateGray);

                case (ushort)CollisionType_MK8D.Wall2:
                    return(Color.OrangeRed);

                case (ushort)CollisionType_MK8D.Wall3:
                    return(Color.IndianRed);

                case (ushort)CollisionType_MK8D.Unsolid:
                    return(Color.Beige);

                case (ushort)CollisionType_MK8D.Road_3DS_MP_Piano:
                    return(Color.RosyBrown);

                case (ushort)CollisionType_MK8D.Road_3DS_MP_Vibraphone:
                    return(Color.BurlyWood);

                case (ushort)CollisionType_MK8D.Road_3DS_MP_Xylophone:
                    return(Color.DarkSalmon);

                case (ushort)CollisionType_MK8D.Latiku:
                    return(Color.GhostWhite);

                case (ushort)CollisionType_MK8D.Road_Bumpy:
                    return(Color.GreenYellow);

                case (ushort)CollisionType_MK8D.Road_RoyalR_Grass:
                    return(Color.Green);

                case (ushort)CollisionType_MK8D.YoshiCuiruit_Grass:
                    return(Color.Green);

                case (ushort)CollisionType_MK8D.Wall:
                    return(Color.LightCyan);

                case (ushort)CollisionType_MK8D.Wall4:
                    return(Color.LightSlateGray);

                case (ushort)CollisionType_MK8D.Wall5:
                    return(Color.DarkSlateGray);

                case (ushort)CollisionType_MK8D.AntiGravityPanel:
                    return(Color.Purple);

                case (ushort)CollisionType_MK8D.SidewalkSlope:
                    return(Color.FromArgb(153, 153, 102));

                case (ushort)CollisionType_MK8D.BoostTrick:
                    return(Color.DarkOrange);

                case (ushort)CollisionType_MK8D.Offroad_Mud:
                    return(Color.FromArgb(77, 26, 0));

                case (ushort)CollisionType_MK8D.Road_Metal:
                    return(Color.FromArgb(80, 80, 80));

                case (ushort)CollisionType_MK8D.Road_MetalGating:
                    return(Color.FromArgb(64, 64, 64));

                case (ushort)CollisionType_MK8D.Road_Dirt:
                    return(Color.Sienna);

                case (ushort)CollisionType_MK8D.Road_Stone:
                    return(Color.FromArgb(50, 50, 50));

                case (ushort)CollisionType_MK8D.Latiku2:
                    return(Color.WhiteSmoke);

                case (ushort)CollisionType_MK8D.RedFlowerEffect:
                    return(Color.MediumVioletRed);

                case (ushort)CollisionType_MK8D.WhiteFlowerEffect:
                    return(Color.FloralWhite);

                case (ushort)CollisionType_MK8D.YellowFlowerEffect:
                    return(Color.Yellow);

                case (ushort)CollisionType_MK8D.TopPillar:
                    return(Color.Gray);

                default:
                    return(Color.FromArgb(20, 20, 20));
                }
            }
            else if (GameMaterialSet == GameSet.MarioOdyssey)
            {
                return(Color.Gray);
            }
            else if (GameMaterialSet == GameSet.Splatoon2)
            {
                return(Color.Gray);
            }
            else
            {
                return(Color.Gray);
            }
        }
Beispiel #2
0
        public void Read(MarioKart.MK7.KCL kcl)
        {
            Nodes.Clear();
            Renderer.models.Clear();

            int CurModelIndx = 0;

            foreach (MarioKart.MK7.KCL.KCLModel mdl in kcl.Models)
            {
                KCLModel kclmodel = new KCLModel();

                kclmodel.Text = "Model " + CurModelIndx;

                int ft = 0;
                foreach (var plane in mdl.Planes)
                {
                    var triangle = mdl.GetTriangle(plane);
                    var normal   = triangle.Normal;
                    var pointA   = triangle.PointA;
                    var pointB   = triangle.PointB;
                    var pointC   = triangle.PointC;

                    Vertex vtx  = new Vertex();
                    Vertex vtx2 = new Vertex();
                    Vertex vtx3 = new Vertex();

                    vtx.pos  = new Vector3(Vec3D_To_Vec3(pointA));
                    vtx2.pos = new Vector3(Vec3D_To_Vec3(pointB));
                    vtx3.pos = new Vector3(Vec3D_To_Vec3(pointC));
                    vtx.nrm  = new Vector3(Vec3D_To_Vec3(normal));
                    vtx2.nrm = new Vector3(Vec3D_To_Vec3(normal));
                    vtx3.nrm = new Vector3(Vec3D_To_Vec3(normal));

                    KCLModel.Face face = new KCLModel.Face();
                    face.Text         = triangle.Collision.ToString();
                    face.MaterialFlag = triangle.Collision;

                    var     col      = MarioKart.MK7.KCLColors.GetMaterialColor(plane.CollisionType);
                    Vector3 ColorSet = new Vector3(col.R, col.G, col.B);

                    vtx.col  = new Vector4(ColorSet, 1);
                    vtx2.col = new Vector4(ColorSet, 1);
                    vtx3.col = new Vector4(ColorSet, 1);

                    kclmodel.faces.Add(ft);
                    kclmodel.faces.Add(ft + 1);
                    kclmodel.faces.Add(ft + 2);

                    ft += 3;

                    kclmodel.vertices.Add(vtx);
                    kclmodel.vertices.Add(vtx2);
                    kclmodel.vertices.Add(vtx3);
                }

                Renderer.models.Add(kclmodel);
                Nodes.Add(kclmodel);

                CurModelIndx++;
            }
        }
Beispiel #3
0
        public void Read(byte[] file_data)
        {
            try
            {
                kcl = new KclFile(new MemoryStream(file_data), true, false, Syroot.BinaryData.ByteOrder.LittleEndian);
            }
            catch
            {
                kcl = new KclFile(new MemoryStream(file_data), true, false, Syroot.BinaryData.ByteOrder.BigEndian);
            }

            AllFlags.Clear();

            int CurModelIndx = 0;

            foreach (KclModel mdl in kcl.Models)
            {
                KCLModel kclmodel = new KCLModel();

                kclmodel.Text = "Model " + CurModelIndx;


                KclFace[] indicesArray = mdl.Faces;

                int ft = 0;
                foreach (KclFace f in mdl.Faces)
                {
                    Vertex vtx  = new Vertex();
                    Vertex vtx2 = new Vertex();
                    Vertex vtx3 = new Vertex();


                    Vector3 CrossA   = Vector3.Cross(Vec3F_To_Vec3(mdl.Normals[f.Normal1Index]), Vec3F_To_Vec3(mdl.Normals[f.DirectionIndex]));
                    Vector3 CrossB   = Vector3.Cross(Vec3F_To_Vec3(mdl.Normals[f.Normal2Index]), Vec3F_To_Vec3(mdl.Normals[f.DirectionIndex]));
                    Vector3 CrossC   = Vector3.Cross(Vec3F_To_Vec3(mdl.Normals[f.Normal3Index]), Vec3F_To_Vec3(mdl.Normals[f.DirectionIndex]));
                    Vector3 normal_a = Vec3F_To_Vec3(mdl.Normals[f.Normal1Index]);
                    Vector3 normal_b = Vec3F_To_Vec3(mdl.Normals[f.Normal2Index]);
                    Vector3 normal_c = Vec3F_To_Vec3(mdl.Normals[f.Normal3Index]);


                    float result1 = Vector3.Dot(new Vector3(CrossB.X, CrossB.Y, CrossB.Z), (new Vector3(normal_c.X, normal_c.Y, normal_c.Z)));
                    float result2 = Vector3.Dot(new Vector3(CrossA.X, CrossA.Y, CrossA.Z), (new Vector3(normal_c.X, normal_c.Y, normal_c.Z)));

                    Vector3 pos = Vec3F_To_Vec3(mdl.Positions[f.PositionIndex]);
                    Vector3 nrm = Vec3F_To_Vec3(mdl.Normals[f.Normal1Index]);

                    Vector3 Vertex1 = pos;
                    Vector3 Vertex2 = pos + CrossB * (f.Length / result1);
                    Vector3 Vertex3 = pos + CrossA * (f.Length / result2);

                    vtx.pos  = new Vector3(Vertex1.X, Vertex1.Y, Vertex1.Z);
                    vtx2.pos = new Vector3(Vertex2.X, Vertex2.Y, Vertex2.Z);
                    vtx3.pos = new Vector3(Vertex3.X, Vertex3.Y, Vertex3.Z);

                    var dir  = Vector3.Cross(Vertex2 - Vertex1, Vertex3 - Vertex1);
                    var norm = Vector3.Normalize(dir);

                    vtx.nrm  = norm;
                    vtx2.nrm = norm;
                    vtx3.nrm = norm;

                    KCLModel.Face face = new KCLModel.Face();

                    face.Text = f.CollisionFlags.ToString();

                    face.MaterialFlag = f.CollisionFlags;

                    Color color = SetMaterialColor(face);


                    AllFlags.Add(face.MaterialFlag);

                    Vector3 ColorSet = new Vector3(color.R / 255.0f, color.G / 255.0f, color.B / 255.0f);

                    vtx.col  = new Vector3(ColorSet);
                    vtx2.col = new Vector3(ColorSet);
                    vtx3.col = new Vector3(ColorSet);

                    kclmodel.faces.Add(ft);
                    kclmodel.faces.Add(ft + 1);
                    kclmodel.faces.Add(ft + 2);

                    ft += 3;

                    kclmodel.vertices.Add(vtx);
                    kclmodel.vertices.Add(vtx2);
                    kclmodel.vertices.Add(vtx3);
                }


                models.Add(kclmodel);



                Nodes.Add(kclmodel);

                CurModelIndx++;
            }

            List <int> noDupes = AllFlags.Distinct().ToList();

            Console.WriteLine("List of all material flags (Not duped)");
            foreach (int mat in noDupes)
            {
                Console.WriteLine("Mat flag " + (CollisionType_MK8D)mat);
            }
        }
Beispiel #4
0
        private void Read(MarioKart.MK7.KCL kcl)
        {
            Vector3 min = new Vector3();
            Vector3 max = new Vector3();

            Nodes.Clear();
            Renderer.OctreeNodes.Clear();
            Renderer.models.Clear();
            Renderer.KclFile = kcl;

            TreeNode modelTree = new TreeNode("Model Octree");

            LoadModelTree(modelTree, kcl.GlobalHeader.ModelOctrees);
            foreach (var node in modelTree.Nodes)
            {
                Renderer.OctreeNodes.Add((OctreeNode)node);
            }
            Nodes.Add(modelTree);

            int CurModelIndx = 0;

            foreach (MarioKart.MK7.KCL.KCLModel mdl in kcl.Models)
            {
                KCLModel kclmodel = new KCLModel();

                kclmodel.Text = "Model " + CurModelIndx;

                int ft = 0;
                foreach (var plane in mdl.Planes)
                {
                    var triangle = mdl.GetTriangle(plane);
                    var normal   = triangle.Normal;
                    var pointA   = triangle.PointA;
                    var pointB   = triangle.PointB;
                    var pointC   = triangle.PointC;

                    Vertex vtx  = new Vertex();
                    Vertex vtx2 = new Vertex();
                    Vertex vtx3 = new Vertex();

                    vtx.pos  = new Vector3(Vec3D_To_Vec3(pointA));
                    vtx2.pos = new Vector3(Vec3D_To_Vec3(pointB));
                    vtx3.pos = new Vector3(Vec3D_To_Vec3(pointC));
                    vtx.nrm  = new Vector3(Vec3D_To_Vec3(normal));
                    vtx2.nrm = new Vector3(Vec3D_To_Vec3(normal));
                    vtx3.nrm = new Vector3(Vec3D_To_Vec3(normal));

                    KCLModel.Face face = new KCLModel.Face();
                    face.Text         = triangle.Collision.ToString();
                    face.MaterialFlag = triangle.Collision;

                    var     col      = MarioKart.MK7.KCLColors.GetMaterialColor(plane.CollisionType);
                    Vector3 ColorSet = new Vector3(col.R, col.G, col.B);

                    vtx.col  = new Vector4(ColorSet, 1);
                    vtx2.col = new Vector4(ColorSet, 1);
                    vtx3.col = new Vector4(ColorSet, 1);

                    kclmodel.faces.Add(ft);
                    kclmodel.faces.Add(ft + 1);
                    kclmodel.faces.Add(ft + 2);

                    ft += 3;

                    kclmodel.vertices.Add(vtx);
                    kclmodel.vertices.Add(vtx2);
                    kclmodel.vertices.Add(vtx3);

                    #region FindMaxMin
                    if (triangle.PointA.X < min.X)
                    {
                        min.X = (float)triangle.PointA.X;
                    }
                    if (triangle.PointA.Y < min.Y)
                    {
                        min.Y = (float)triangle.PointA.Y;
                    }
                    if (triangle.PointA.Z < min.Z)
                    {
                        min.Z = (float)triangle.PointA.Z;
                    }
                    if (triangle.PointA.X > max.X)
                    {
                        max.X = (float)triangle.PointA.X;
                    }
                    if (triangle.PointA.Y > max.Y)
                    {
                        max.Y = (float)triangle.PointA.Y;
                    }
                    if (triangle.PointA.Z > max.Z)
                    {
                        max.Z = (float)triangle.PointA.Z;
                    }

                    if (triangle.PointB.X < min.X)
                    {
                        min.X = (float)triangle.PointB.X;
                    }
                    if (triangle.PointB.Y < min.Y)
                    {
                        min.Y = (float)triangle.PointB.Y;
                    }
                    if (triangle.PointB.Z < min.Z)
                    {
                        min.Z = (float)triangle.PointB.Z;
                    }
                    if (triangle.PointB.X > max.X)
                    {
                        max.X = (float)triangle.PointB.X;
                    }
                    if (triangle.PointB.Y > max.Y)
                    {
                        max.Y = (float)triangle.PointB.Y;
                    }
                    if (triangle.PointB.Z > max.Z)
                    {
                        max.Z = (float)triangle.PointB.Z;
                    }

                    if (triangle.PointC.X < min.X)
                    {
                        min.X = (float)triangle.PointC.X;
                    }
                    if (triangle.PointC.Y < min.Y)
                    {
                        min.Y = (float)triangle.PointC.Y;
                    }
                    if (triangle.PointC.Z < min.Z)
                    {
                        min.Z = (float)triangle.PointC.Z;
                    }
                    if (triangle.PointC.X > max.X)
                    {
                        max.X = (float)triangle.PointC.X;
                    }
                    if (triangle.PointC.Y > max.Y)
                    {
                        max.Y = (float)triangle.PointC.Y;
                    }
                    if (triangle.PointC.Z > max.Z)
                    {
                        max.Z = (float)triangle.PointC.Z;
                    }
                    #endregion
                }

                Renderer.Max = max;
                Renderer.Min = min;
                Renderer.models.Add(kclmodel);
                Nodes.Add(kclmodel);

                CurModelIndx++;
            }
        }