Ejemplo n.º 1
0
        public List <byte> GetBytes(VTX_FLAGS flags)
        {
            List <byte> bytes = new List <byte>();
            int         size  = 0;

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_POS))
            {
                bytes.AddRange(BitConverter.GetBytes(PositionX));
                bytes.AddRange(BitConverter.GetBytes(PositionY));
                bytes.AddRange(BitConverter.GetBytes(PositionZ));
                size += 12;
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_NORM))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    bytes.AddRange(Half.GetBytes((Half)NormalX));
                    bytes.AddRange(Half.GetBytes((Half)NormalY));
                    bytes.AddRange(Half.GetBytes((Half)NormalZ));
                    bytes.AddRange(new byte[2]);
                    size += 8;
                }
                else
                {
                    bytes.AddRange(BitConverter.GetBytes(NormalX));
                    bytes.AddRange(BitConverter.GetBytes(NormalY));
                    bytes.AddRange(BitConverter.GetBytes(NormalZ));
                    size += 12;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TANGENT))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    bytes.AddRange(Half.GetBytes((Half)TangentX));
                    bytes.AddRange(Half.GetBytes((Half)TangentY));
                    bytes.AddRange(Half.GetBytes((Half)TangentZ));
                    bytes.AddRange(new byte[2]);
                    size += 8;
                }
                else
                {
                    bytes.AddRange(BitConverter.GetBytes(TangentX));
                    bytes.AddRange(BitConverter.GetBytes(TangentY));
                    bytes.AddRange(BitConverter.GetBytes(TangentZ));
                    size += 12;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TEX))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    bytes.AddRange(Half.GetBytes((Half)TextureU));
                    bytes.AddRange(Half.GetBytes((Half)TextureV));
                    size += 4;
                }
                else
                {
                    bytes.AddRange(BitConverter.GetBytes(TextureU));
                    bytes.AddRange(BitConverter.GetBytes(TextureV));
                    size += 8;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TEX2))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    bytes.AddRange(Half.GetBytes((Half)Texture2U));
                    bytes.AddRange(Half.GetBytes((Half)Texture2V));
                    size += 4;
                }
                else
                {
                    bytes.AddRange(BitConverter.GetBytes(Texture2U));
                    bytes.AddRange(BitConverter.GetBytes(Texture2V));
                    size += 8;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COLOR))
            {
                bytes.Add(ColorR);
                bytes.Add(ColorG);
                bytes.Add(ColorB);
                bytes.Add(ColorA);
                size += 4;
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_BLEND_WEIGHT))
            {
                bytes.Add(BlendIndexes[0]);
                bytes.Add(BlendIndexes[1]);
                bytes.Add(BlendIndexes[2]);
                bytes.Add(BlendIndexes[3]);
                size += 4;

                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    bytes.AddRange(Half.GetBytes((Half)BlendWeights[0]));
                    bytes.AddRange(Half.GetBytes((Half)BlendWeights[1]));
                    bytes.AddRange(Half.GetBytes((Half)BlendWeights[2]));
                    bytes.AddRange(Half.GetBytes((Half)0f));
                    size += 8; //An additional 2 bytes of padding added at the end
                }
                else
                {
                    bytes.AddRange(BitConverter.GetBytes(BlendWeights[0]));
                    bytes.AddRange(BitConverter.GetBytes(BlendWeights[1]));
                    bytes.AddRange(BitConverter.GetBytes(BlendWeights[2]));
                    bytes.AddRange(BitConverter.GetBytes(0f));
                    size += 16;
                }
            }

            if (size != bytes.Count)
            {
                throw new Exception(String.Format("EMD_Vertex size mismatch. Expected a size of {0}, but it was {1}. (Flags: {2})", size, bytes.Count, flags));
            }

            return(bytes);
        }
Ejemplo n.º 2
0
        }                                         //Size 3 (if float16, then 2 bytes of padding after)

        public static int GetVertexSize(VTX_FLAGS flags)
        {
            int size = 0;

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_POS))
            {
                size += 12;
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_NORM))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    size += 8;
                }
                else
                {
                    size += 12;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TANGENT))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    size += 8;
                }
                else
                {
                    size += 12;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TEX))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    size += 4;
                }
                else
                {
                    size += 8;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_TEX2))
            {
                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    size += 4;
                }
                else
                {
                    size += 8;
                }
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COLOR))
            {
                size += 4;
            }

            if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_BLEND_WEIGHT))
            {
                size += 4;

                if (flags.HasFlag(VTX_FLAGS.EMD_VTX_FLAG_COMPRESSED_FORMAT))
                {
                    size += 8;
                }
                else
                {
                    size += 16;
                }
            }

            return(size);
        }