예제 #1
0
 public ChunkAttach(byte[] file, int address, uint imageBase, Dictionary<int, string> labels)
     : this()
 {
     if (labels.ContainsKey(address))
         Name = labels[address];
     else
         Name = "attach_" + address.ToString("X8");
     ChunkType ctype;
     int tmpaddr = ByteConverter.ToInt32(file, address);
     if (tmpaddr != 0)
     {
         tmpaddr = (int)unchecked((uint)tmpaddr - imageBase);
         Vertex = new List<VertexChunk>();
         if (labels.ContainsKey(tmpaddr))
             VertexName = labels[tmpaddr];
         else
             VertexName = "vertex_" + tmpaddr.ToString("X8");
         ctype = (ChunkType)(ByteConverter.ToUInt32(file, tmpaddr) & 0xFF);
         while (ctype != ChunkType.End)
         {
             VertexChunk chunk = new VertexChunk(file, tmpaddr);
             Vertex.Add(chunk);
             tmpaddr += (chunk.Size * 4) + 4;
             ctype = (ChunkType)(ByteConverter.ToUInt32(file, tmpaddr) & 0xFF);
         }
     }
     tmpaddr = ByteConverter.ToInt32(file, address + 4);
     if (tmpaddr != 0)
     {
         tmpaddr = (int)unchecked((uint)tmpaddr - imageBase);
         Poly = new List<PolyChunk>();
         if (labels.ContainsKey(tmpaddr))
             PolyName = labels[tmpaddr];
         else
             PolyName = "poly_" + tmpaddr.ToString("X8");
         PolyChunk chunk = PolyChunk.Load(file, tmpaddr);
         while (chunk.Type != ChunkType.End)
         {
             if (chunk.Type != ChunkType.Null)
                 Poly.Add(chunk);
             tmpaddr += chunk.ByteSize;
             chunk = PolyChunk.Load(file, tmpaddr);
         }
     }
     Bounds = new BoundingSphere(file, address + 8);
 }
예제 #2
0
        public VertexChunk Clone()
        {
            VertexChunk result = (VertexChunk)MemberwiseClone();

            result.Vertices = new List <Vertex>(Vertices.Count);
            foreach (Vertex item in Vertices)
            {
                result.Vertices.Add(item.Clone());
            }
            result.Normals = new List <Vertex>(Normals.Count);
            foreach (Vertex item in Normals)
            {
                result.Normals.Add(item.Clone());
            }
            result.Diffuse    = new List <Color>(Diffuse);
            result.Specular   = new List <Color>(Specular);
            result.UserFlags  = new List <uint>(UserFlags);
            result.NinjaFlags = new List <uint>(NinjaFlags);
            return(result);
        }
예제 #3
0
        public ChunkAttach(byte[] file, int address, uint imageBase, Dictionary <int, string> labels)
            : this()
        {
            if (labels.ContainsKey(address))
            {
                Name = labels[address];
            }
            else
            {
                Name = "attach_" + address.ToString("X8");
            }
            ChunkType ctype;
            int       tmpaddr = ByteConverter.ToInt32(file, address);

            if (tmpaddr != 0)
            {
                tmpaddr = (int)unchecked ((uint)tmpaddr - imageBase);
                Vertex  = new List <VertexChunk>();
                if (labels.ContainsKey(tmpaddr))
                {
                    VertexName = labels[tmpaddr];
                }
                else
                {
                    VertexName = "vertex_" + tmpaddr.ToString("X8");
                }
                ctype = (ChunkType)(ByteConverter.ToUInt32(file, tmpaddr) & 0xFF);
                while (ctype != ChunkType.End)
                {
                    VertexChunk chunk = new VertexChunk(file, tmpaddr);
                    Vertex.Add(chunk);
                    tmpaddr += (chunk.Size * 4) + 4;
                    ctype    = (ChunkType)(ByteConverter.ToUInt32(file, tmpaddr) & 0xFF);
                }
            }
            tmpaddr = ByteConverter.ToInt32(file, address + 4);
            if (tmpaddr != 0)
            {
                tmpaddr = (int)unchecked ((uint)tmpaddr - imageBase);
                Poly    = new List <PolyChunk>();
                if (labels.ContainsKey(tmpaddr))
                {
                    PolyName = labels[tmpaddr];
                }
                else
                {
                    PolyName = "poly_" + tmpaddr.ToString("X8");
                }
                PolyChunk chunk = PolyChunk.Load(file, tmpaddr);
                while (chunk.Type != ChunkType.End)
                {
                    if (chunk.Type != ChunkType.Null)
                    {
                        Poly.Add(chunk);
                    }
                    tmpaddr += chunk.ByteSize;
                    chunk    = PolyChunk.Load(file, tmpaddr);
                }
            }
            Bounds = new BoundingSphere(file, address + 8);
        }
예제 #4
0
 static void Main(string[] args)
 {
     string filename;
     if (args.Length > 0)
     {
         filename = args[0];
         Console.WriteLine("File: {0}", filename);
     }
     else
     {
         Console.Write("File: ");
         filename = Console.ReadLine();
     }
     LandTable level = LandTable.LoadFromFile(filename);
     switch (level.Format)
     {
         case LandTableFormat.SA1:
             {
                 List<COL> newcollist = new List<COL>();
                 foreach (COL col in level.COL.Where((col) => col.Model != null && col.Model.Attach != null))
                 {
                     if ((col.SurfaceFlags & SurfaceFlags.Visible) == SurfaceFlags.Visible)
                     {
                         COL newcol = new COL() { Bounds = col.Bounds };
                         newcol.SurfaceFlags = SurfaceFlags.Visible;
                         newcol.Model = new SonicRetro.SAModel.NJS_OBJECT() { Name = col.Model.Name + "_cnk" };
                         newcol.Model.Position = col.Model.Position;
                         newcol.Model.Rotation = col.Model.Rotation;
                         newcol.Model.Scale = col.Model.Scale;
                         BasicAttach basatt = (BasicAttach)col.Model.Attach;
                         ChunkAttach cnkatt = new ChunkAttach(true, true) { Name = basatt.Name + "_cnk", Bounds = basatt.Bounds };
                         newcol.Model.Attach = cnkatt;
                         VertexChunk vcnk;
                         if (basatt.Normal != null && basatt.Normal.Length > 0)
                             vcnk = new VertexChunk(ChunkType.Vertex_VertexNormal);
                         else
                             vcnk = new VertexChunk(ChunkType.Vertex_Vertex);
                         vcnk.Vertices = new List<Vertex>(basatt.Vertex);
                         if (basatt.Normal != null)
                             vcnk.Normals = new List<Vertex>(basatt.Normal);
                         vcnk.VertexCount = (ushort)basatt.Vertex.Length;
                         vcnk.Size = (ushort)((vcnk.Type == ChunkType.Vertex_VertexNormal ? vcnk.VertexCount * 6 : vcnk.VertexCount * 3) + 1);
                         cnkatt.Vertex.Add(vcnk);
                         foreach (NJS_MESHSET mesh in basatt.Mesh)
                         {
                             if (mesh.PolyType != Basic_PolyType.Strips)
                             {
                                 Console.WriteLine("Warning: Skipping non-strip mesh in {0} ({1}).", basatt.MeshName, mesh.PolyType);
                                 continue;
                             }
                             NJS_MATERIAL mat = null;
                             if (basatt.Material != null && mesh.MaterialID < basatt.Material.Count)
                             {
                                 mat = basatt.Material[mesh.MaterialID];
                                 cnkatt.Poly.Add(new PolyChunkBitsBlendAlpha()
                                 {
                                     SourceAlpha = mat.SourceAlpha,
                                     DestinationAlpha = mat.DestinationAlpha
                                 });
                                 cnkatt.Poly.Add(new PolyChunkTinyTextureID()
                                 {
                                     ClampU = mat.ClampU,
                                     ClampV = mat.ClampV,
                                     FilterMode = mat.FilterMode,
                                     FlipU = mat.FlipU,
                                     FlipV = mat.FlipV,
                                     SuperSample = mat.SuperSample,
                                     TextureID = (ushort)mat.TextureID
                                 });
                                 cnkatt.Poly.Add(new PolyChunkMaterial()
                                 {
                                     Diffuse = mat.DiffuseColor,
                                     Specular = mat.SpecularColor,
                                     SpecularExponent = (byte)mat.Exponent
                                 });
                             }
                             PolyChunkStrip strip;
                             if (mesh.UV != null & mesh.VColor != null)
                                 strip = new PolyChunkStrip(ChunkType.Strip_StripUVNColor);
                             else if (mesh.UV != null)
                                 strip = new PolyChunkStrip(ChunkType.Strip_StripUVN);
                             else if (mesh.VColor != null)
                                 strip = new PolyChunkStrip(ChunkType.Strip_StripColor);
                             else
                                 strip = new PolyChunkStrip(ChunkType.Strip_Strip);
                             if (mat != null)
                             {
                                 strip.IgnoreLight = mat.IgnoreLighting;
                                 strip.IgnoreSpecular = mat.IgnoreSpecular;
                                 strip.UseAlpha = mat.UseAlpha;
                                 strip.DoubleSide = mat.DoubleSided;
                                 strip.FlatShading = mat.FlatShading;
                                 strip.EnvironmentMapping = mat.EnvironmentMap;
                             }
                             int striptotal = 0;
                             foreach (Strip item in mesh.Poly.Cast<Strip>())
                             {
                                 UV[] uvs = null;
                                 if (mesh.UV != null)
                                 {
                                     uvs = new UV[item.Indexes.Length];
                                     Array.Copy(mesh.UV, striptotal, uvs, 0, item.Indexes.Length);
                                 }
                                 Color[] vcolors = null;
                                 if (mesh.VColor != null)
                                 {
                                     vcolors = new Color[item.Indexes.Length];
                                     Array.Copy(mesh.VColor, striptotal, vcolors, 0, item.Indexes.Length);
                                 }
                                 strip.Strips.Add(new PolyChunkStrip.Strip(item.Reversed, item.Indexes, uvs, vcolors));
                                 striptotal += item.Indexes.Length;
                             }
                             cnkatt.Poly.Add(strip);
                         }
                         newcollist.Add(newcol);
                     }
                     if ((col.SurfaceFlags & ~SurfaceFlags.Visible) != 0)
                     {
                         col.SurfaceFlags &= ~SurfaceFlags.Visible;
                         newcollist.Add(col);
                     }
                 }
                 level.COL = newcollist;
             }
             level.Anim = new List<GeoAnimData>();
             level.Tool = "SA Tools Level Converter";
             level.SaveToFile(System.IO.Path.ChangeExtension(filename, "sa2lvl"), LandTableFormat.SA2);
             break;
         case LandTableFormat.SA2:
             Vertex[] VertexBuffer = new Vertex[0];
             Vertex[] NormalBuffer = new Vertex[0];
             foreach (COL col in level.COL.Where((col) => col.Model != null && col.Model.Attach is ChunkAttach))
             {
                 ChunkAttach cnkatt = (ChunkAttach)col.Model.Attach;
                 BasicAttach basatt = new BasicAttach() { Name = cnkatt.Name, Bounds = cnkatt.Bounds };
                 if (cnkatt.Vertex != null)
                     foreach (VertexChunk chunk in cnkatt.Vertex)
                     {
                         if (VertexBuffer.Length < chunk.IndexOffset + chunk.VertexCount)
                         {
                             Array.Resize(ref VertexBuffer, chunk.IndexOffset + chunk.VertexCount);
                             Array.Resize(ref NormalBuffer, chunk.IndexOffset + chunk.VertexCount);
                         }
                         Array.Copy(chunk.Vertices.ToArray(), 0, VertexBuffer, chunk.IndexOffset, chunk.Vertices.Count);
                         Array.Copy(chunk.Normals.ToArray(), 0, NormalBuffer, chunk.IndexOffset, chunk.Normals.Count);
                     }
                 NJS_MATERIAL material = new NJS_MATERIAL() { UseTexture = true };
                 int minVtx = int.MaxValue;
                 int maxVtx = int.MinValue;
                 foreach (PolyChunk chunk in cnkatt.Poly)
                     switch (chunk.Type)
                     {
                         case ChunkType.Bits_BlendAlpha:
                             {
                                 PolyChunkBitsBlendAlpha c2 = (PolyChunkBitsBlendAlpha)chunk;
                                 material.SourceAlpha = c2.SourceAlpha;
                                 material.DestinationAlpha = c2.DestinationAlpha;
                             }
                             break;
                         case ChunkType.Bits_MipmapDAdjust:
                             break;
                         case ChunkType.Bits_SpecularExponent:
                             material.Exponent = ((PolyChunkBitsSpecularExponent)chunk).SpecularExponent;
                             break;
                         case ChunkType.Tiny_TextureID:
                         case ChunkType.Tiny_TextureID2:
                             {
                                 PolyChunkTinyTextureID c2 = (PolyChunkTinyTextureID)chunk;
                                 material.ClampU = c2.ClampU;
                                 material.ClampV = c2.ClampV;
                                 material.FilterMode = c2.FilterMode;
                                 material.FlipU = c2.FlipU;
                                 material.FlipV = c2.FlipV;
                                 material.SuperSample = c2.SuperSample;
                                 material.TextureID = c2.TextureID;
                             }
                             break;
                         case ChunkType.Material_Diffuse:
                         case ChunkType.Material_Ambient:
                         case ChunkType.Material_DiffuseAmbient:
                         case ChunkType.Material_Specular:
                         case ChunkType.Material_DiffuseSpecular:
                         case ChunkType.Material_AmbientSpecular:
                         case ChunkType.Material_DiffuseAmbientSpecular:
                         case ChunkType.Material_Diffuse2:
                         case ChunkType.Material_Ambient2:
                         case ChunkType.Material_DiffuseAmbient2:
                         case ChunkType.Material_Specular2:
                         case ChunkType.Material_DiffuseSpecular2:
                         case ChunkType.Material_AmbientSpecular2:
                         case ChunkType.Material_DiffuseAmbientSpecular2:
                             {
                                 PolyChunkMaterial c2 = (PolyChunkMaterial)chunk;
                                 if (c2.Diffuse.HasValue)
                                     material.DiffuseColor = c2.Diffuse.Value;
                                 if (c2.Specular.HasValue)
                                 {
                                     material.SpecularColor = c2.Specular.Value;
                                     material.Exponent = c2.SpecularExponent;
                                 }
                             }
                             break;
                         case ChunkType.Strip_Strip:
                         case ChunkType.Strip_StripUVN:
                         case ChunkType.Strip_StripUVH:
                         case ChunkType.Strip_StripNormal:
                         case ChunkType.Strip_StripUVNNormal:
                         case ChunkType.Strip_StripUVHNormal:
                         case ChunkType.Strip_StripColor:
                         case ChunkType.Strip_StripUVNColor:
                         case ChunkType.Strip_StripUVHColor:
                         case ChunkType.Strip_Strip2:
                         case ChunkType.Strip_StripUVN2:
                         case ChunkType.Strip_StripUVH2:
                             {
                                 PolyChunkStrip c2 = (PolyChunkStrip)chunk;
                                 material.DoubleSided = c2.DoubleSide;
                                 material.EnvironmentMap = c2.EnvironmentMapping;
                                 material.FlatShading = c2.FlatShading;
                                 material.IgnoreLighting = c2.IgnoreLight;
                                 material.IgnoreSpecular = c2.IgnoreSpecular;
                                 material.UseAlpha = c2.UseAlpha;
                                 bool hasVColor = false;
                                 switch (chunk.Type)
                                 {
                                     case ChunkType.Strip_StripColor:
                                     case ChunkType.Strip_StripUVNColor:
                                     case ChunkType.Strip_StripUVHColor:
                                         hasVColor = true;
                                         break;
                                 }
                                 bool hasUV = false;
                                 switch (chunk.Type)
                                 {
                                     case ChunkType.Strip_StripUVN:
                                     case ChunkType.Strip_StripUVH:
                                     case ChunkType.Strip_StripUVNColor:
                                     case ChunkType.Strip_StripUVHColor:
                                     case ChunkType.Strip_StripUVN2:
                                     case ChunkType.Strip_StripUVH2:
                                         hasUV = true;
                                         break;
                                 }
                                 List<Strip> strips = new List<Strip>(c2.StripCount);
                                 List<UV> uvs = hasUV ? new List<UV>() : null;
                                 List<Color> vcolors = hasVColor ? new List<Color>() : null;
                                 foreach (PolyChunkStrip.Strip strip in c2.Strips)
                                 {
                                     minVtx = Math.Min(minVtx, strip.Indexes.Min());
                                     maxVtx = Math.Max(maxVtx, strip.Indexes.Max());
                                     strips.Add(new Strip(strip.Indexes, strip.Reversed));
                                     if (hasUV)
                                         uvs.AddRange(strip.UVs);
                                     if (hasVColor)
                                         vcolors.AddRange(strip.VColors);
                                 }
                                 NJS_MESHSET mesh = new NJS_MESHSET(strips.ToArray(), false, hasUV, hasVColor);
                                 if (hasUV)
                                     uvs.CopyTo(mesh.UV);
                                 if (hasVColor)
                                     vcolors.CopyTo(mesh.VColor);
                                 mesh.MaterialID = (ushort)basatt.Material.Count;
                                 basatt.Mesh.Add(mesh);
                                 basatt.Material.Add(material);
                                 material = new NJS_MATERIAL(material.GetBytes(), 0);
                             }
                             break;
                     }
                 int numVtx = maxVtx - minVtx + 1;
                 basatt.ResizeVertexes(numVtx);
                 Array.Copy(VertexBuffer, minVtx, basatt.Vertex, 0, numVtx);
                 Array.Copy(NormalBuffer, minVtx, basatt.Normal, 0, numVtx);
                 foreach (NJS_MESHSET mesh in basatt.Mesh)
                     foreach (Poly poly in mesh.Poly)
                         for (int i = 0; i < poly.Indexes.Length; i++)
                             poly.Indexes[i] = (ushort)(poly.Indexes[i] - minVtx);
                 col.Model.Attach = basatt;
             }
             level.Anim = new List<GeoAnimData>();
             level.Tool = "SA Tools Level Converter";
             level.SaveToFile(System.IO.Path.ChangeExtension(filename, "sa1lvl"), LandTableFormat.SA1);
             break;
     }
 }
예제 #5
0
        public static List <VertexChunk> Merge(List <VertexChunk> source)
        {
            if (source == null)
            {
                return(null);
            }
            if (source.Count < 2)
            {
                return(source);
            }
            var chunks = new Dictionary <ChunkType, List <VertexChunk> >();

            foreach (var c in source)
            {
                if (!chunks.ContainsKey(c.Type))
                {
                    chunks[c.Type] = new List <VertexChunk>();
                }
                chunks[c.Type].Add(c);
            }
            var result = new List <VertexChunk>();

            foreach (var list in chunks.Values)
            {
                var t = list[0].Type;
                switch (t)
                {
                case ChunkType.Vertex_VertexNinjaFlags:
                case ChunkType.Vertex_VertexNormalNinjaFlags:
                    var weights = new Dictionary <WeightStatus, List <VertexChunk> >();
                    foreach (var c in list)
                    {
                        if (!weights.ContainsKey(c.WeightStatus))
                        {
                            weights[c.WeightStatus] = new List <VertexChunk>();
                        }
                        weights[c.WeightStatus].Add(c);
                    }
                    foreach (var(s, l2) in weights.OrderBy(a => a.Key))
                    {
                        var r = new VertexChunk(t)
                        {
                            WeightStatus = s, IndexOffset = l2.Min(a => a.IndexOffset)
                        };
                        foreach (var c in l2)
                        {
                            r.Vertices.AddRange(c.Vertices);
                            if (c.Normals?.Count > 0)
                            {
                                r.Normals.AddRange(c.Normals);
                            }
                            if (c.IndexOffset == r.IndexOffset)
                            {
                                r.NinjaFlags.AddRange(c.NinjaFlags);
                            }
                            else
                            {
                                for (int i = 0; i < c.Vertices.Count; i++)
                                {
                                    int ind = (int)c.NinjaFlags[i] & 0xFFFF;
                                    ind += c.IndexOffset - r.IndexOffset;
                                    r.NinjaFlags.Add((c.NinjaFlags[i] & 0xFFFF0000) | (uint)ind);
                                }
                            }
                        }
                        result.Add(r);
                    }
                    break;

                default:
                    list.Sort((a, b) => a.IndexOffset.CompareTo(b.IndexOffset));
                    var r2 = new VertexChunk(t)
                    {
                        IndexOffset = list[0].IndexOffset
                    };
                    foreach (var c in list)
                    {
                        if (c.IndexOffset != r2.IndexOffset + r2.VertexCount)
                        {
                            result.Add(r2);
                            r2 = c;
                        }
                        else
                        {
                            r2.Vertices.AddRange(c.Vertices);
                            if (c.Normals?.Count > 0)
                            {
                                r2.Normals.AddRange(c.Normals);
                            }
                            if (c.Diffuse?.Count > 0)
                            {
                                r2.Diffuse.AddRange(c.Diffuse);
                            }
                            if (c.Specular?.Count > 0)
                            {
                                r2.Specular.AddRange(c.Specular);
                            }
                            if (c.UserFlags?.Count > 0)
                            {
                                r2.UserFlags.AddRange(c.UserFlags);
                            }
                        }
                    }
                    result.Add(r2);
                    break;
                }
            }
            return(result);
        }
예제 #6
0
        public byte[] GetBytes()
        {
            VertexChunk next = null;
            int         vertlimit;
            int         vertcount = Vertices.Count;

            switch (Type)
            {
            case ChunkType.Vertex_VertexSH:
                vertlimit = 65535 / 4;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexNormalSH:
                vertlimit = 65535 / 8;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(), Normals = Normals.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_Vertex:
                vertlimit = 65535 / 3;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexDiffuse8:
                vertlimit = 65535 / 4;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(), Diffuse = Diffuse.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexUserFlags:
                vertlimit = 65535 / 4;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(), UserFlags = UserFlags.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexNinjaFlags:
                vertlimit = 65535 / 4;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(), NinjaFlags = NinjaFlags.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexDiffuseSpecular5:
            case ChunkType.Vertex_VertexDiffuseSpecular4:
                vertlimit = 65535 / 4;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(),
                        Diffuse  = Diffuse.Skip(vertlimit).ToList(),
                        Specular = Specular.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexNormal:
                vertlimit = 65535 / 6;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(), Normals = Normals.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexNormalDiffuse8:
                vertlimit = 65535 / 7;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(),
                        Normals  = Normals.Skip(vertlimit).ToList(),
                        Diffuse  = Diffuse.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexNormalUserFlags:
                vertlimit = 65535 / 7;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices  = Vertices.Skip(vertlimit).ToList(),
                        Normals   = Normals.Skip(vertlimit).ToList(),
                        UserFlags = UserFlags.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexNormalNinjaFlags:
                vertlimit = 65535 / 7;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices   = Vertices.Skip(vertlimit).ToList(),
                        Normals    = Normals.Skip(vertlimit).ToList(),
                        NinjaFlags = NinjaFlags.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.Vertex_VertexNormalDiffuseSpecular5:
            case ChunkType.Vertex_VertexNormalDiffuseSpecular4:
                vertlimit = 65535 / 7;
                if (Vertices.Count > vertlimit)
                {
                    next = new VertexChunk(Type)
                    {
                        Vertices = Vertices.Skip(vertlimit).ToList(),
                        Normals  = Normals.Skip(vertlimit).ToList(),
                        Diffuse  = Diffuse.Skip(vertlimit).ToList(),
                        Specular = Specular.Skip(vertlimit).ToList()
                    };
                    vertcount = vertlimit;
                }
                break;

            case ChunkType.End:
                break;

            default:
                throw new NotSupportedException("Unsupported chunk type " + Type + ".");
            }
            SetVertCount(vertcount);
            switch (Type)
            {
            case ChunkType.Vertex_Vertex:
                Size = (ushort)(vertcount * 3 + 1);
                break;

            case ChunkType.Vertex_VertexSH:
            case ChunkType.Vertex_VertexDiffuse8:
            case ChunkType.Vertex_VertexUserFlags:
            case ChunkType.Vertex_VertexNinjaFlags:
            case ChunkType.Vertex_VertexDiffuseSpecular5:
            case ChunkType.Vertex_VertexDiffuseSpecular4:
                Size = (ushort)(vertcount * 4 + 1);
                break;

            case ChunkType.Vertex_VertexNormal:
                Size = (ushort)(vertcount * 6 + 1);
                break;

            case ChunkType.Vertex_VertexNormalDiffuse8:
            case ChunkType.Vertex_VertexNormalUserFlags:
            case ChunkType.Vertex_VertexNormalNinjaFlags:
            case ChunkType.Vertex_VertexNormalDiffuseSpecular5:
            case ChunkType.Vertex_VertexNormalDiffuseSpecular4:
                Size = (ushort)(vertcount * 7 + 1);
                break;

            case ChunkType.Vertex_VertexNormalSH:
                Size = (ushort)(vertcount * 8 + 1);
                break;
            }
            List <byte> result = new List <byte>((Size * 4) + 4);

            result.AddRange(ByteConverter.GetBytes(Header1));
            result.AddRange(ByteConverter.GetBytes(Header2));
            for (int i = 0; i < vertcount; i++)
            {
                switch (Type)
                {
                case ChunkType.Vertex_VertexSH:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(1.0f));
                    break;

                case ChunkType.Vertex_VertexNormalSH:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(1.0f));
                    result.AddRange(Normals[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(1.0f));
                    break;

                case ChunkType.Vertex_Vertex:
                    result.AddRange(Vertices[i].GetBytes());
                    break;

                case ChunkType.Vertex_VertexDiffuse8:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(VColor.GetBytes(Diffuse[i], ColorType.ARGB8888_32));
                    break;

                case ChunkType.Vertex_VertexUserFlags:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(UserFlags[i]));
                    break;

                case ChunkType.Vertex_VertexNinjaFlags:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(NinjaFlags[i]));
                    break;

                case ChunkType.Vertex_VertexDiffuseSpecular5:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(
                                        ByteConverter.ToUInt16(VColor.GetBytes(Diffuse[i], ColorType.RGB565), 0)
                                        | (ByteConverter.ToUInt16(VColor.GetBytes(Specular[i], ColorType.RGB565), 0) << 16)));
                    break;

                case ChunkType.Vertex_VertexDiffuseSpecular4:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(
                                        ByteConverter.ToUInt16(VColor.GetBytes(Diffuse[i], ColorType.ARGB4444), 0)
                                        | (ByteConverter.ToUInt16(VColor.GetBytes(Specular[i], ColorType.RGB565), 0) << 16)));
                    break;

                case ChunkType.Vertex_VertexNormal:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(Normals[i].GetBytes());
                    break;

                case ChunkType.Vertex_VertexNormalDiffuse8:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(Normals[i].GetBytes());
                    result.AddRange(VColor.GetBytes(Diffuse[i], ColorType.ARGB8888_32));
                    break;

                case ChunkType.Vertex_VertexNormalUserFlags:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(Normals[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(UserFlags[i]));
                    break;

                case ChunkType.Vertex_VertexNormalNinjaFlags:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(Normals[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(NinjaFlags[i]));
                    break;

                case ChunkType.Vertex_VertexNormalDiffuseSpecular5:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(Normals[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(
                                        ByteConverter.ToUInt16(VColor.GetBytes(Diffuse[i], ColorType.RGB565), 0)
                                        | (ByteConverter.ToUInt16(VColor.GetBytes(Specular[i], ColorType.RGB565), 0) << 16)));
                    break;

                case ChunkType.Vertex_VertexNormalDiffuseSpecular4:
                    result.AddRange(Vertices[i].GetBytes());
                    result.AddRange(Normals[i].GetBytes());
                    result.AddRange(ByteConverter.GetBytes(
                                        ByteConverter.ToUInt16(VColor.GetBytes(Diffuse[i], ColorType.ARGB4444), 0)
                                        | (ByteConverter.ToUInt16(VColor.GetBytes(Specular[i], ColorType.RGB565), 0) << 16)));
                    break;
                }
            }
            if (next != null)
            {
                result.AddRange(next.GetBytes());
            }
            return(result.ToArray());
        }