//////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// 返回一个菱形Texture2D
        /// </summary>
        public static Texture2D GetDiamond(int width, int height, Color color, Game game)
        {
            Texture2D ttDmd = new Texture2D(game.GraphicsDevice, width, height);
            Byte4[] btDmd = new Byte4[width * height];
            Vector2 vtO = new Vector2(width / 2f, height / 2f);
            // Point ptPos = new Point(i / ttRound.Width, i % ttRound.Width);
            // ptPos.X = Row number, ptPos.Y = Col number
            for (int x = 0; x <= width / 2; x++)
            {
                for (int y = 0; y <= height / 2; y++)
                {
                    if (width / 2f * y + height / 2f * x >= width * height / 4f)
                    {
                        uint packed = (uint)(
                                (color.A << 24) +
                                (color.B << 16) +
                                (color.G << 8) +
                                color.R
                                );
                        btDmd[Vector2ToIndex(new Vector2(x, y), width)].PackedValue = packed;
                        if (x != 0)
                            btDmd[Vector2ToIndex(new Vector2(width - x, y), width)].PackedValue = packed;
                        if (y != 0)
                            btDmd[Vector2ToIndex(new Vector2(x, height - y), width)].PackedValue = packed;
                        if (x != 0 && y != 0)
                            btDmd[Vector2ToIndex(new Vector2(width - x, height - y), width)].PackedValue = packed;
                    }
                }
            }
            ttDmd.SetData<Byte4>(btDmd);

            return ttDmd;
        }

        private Texture2D processTexture(Texture2D texture)
        {
            //Some programs such as Photoshop save PNG and other RGBA images without premultiplied alpha
            if (!Constants.Instance.PremultipliedAlpha)
            {

                //XNA 4.0+ assumes that all RGBA images have premultiplied alpha channels.
                //Code snippet borrowed from http://xboxforums.create.msdn.com/forums/p/62320/383015.aspx#485897

                Byte4[] data = new Byte4[texture.Width * texture.Height];
                texture.GetData<Byte4>(data);
                for (int i = 0; i < data.Length; i++)
                {
                    Vector4 vec = data[i].ToVector4();
                    float alpha = vec.W / 255.0f;
                    int a = (int)(vec.W);
                    int r = (int)(alpha * vec.X);
                    int g = (int)(alpha * vec.Y);
                    int b = (int)(alpha * vec.Z);
                    uint packed = (uint)(
                        (a << 24) +
                        (b << 16) +
                        (g << 8) +
                        r
                        );

                    data[i].PackedValue = packed;
                }

                texture.SetData<Byte4>(data);
            }

            return texture;
        }

 static public Byte4 PackNormalB4(ref Vector3 normal)
 {
     uint packedValue = PackNormal(ref normal);
     Byte4 b4 = new Byte4();
     b4.PackedValue = packedValue;
     return b4;
 }

 internal void AddSprite(Vector2 clipOffset, Vector2 clipScale, Vector2 texOffset, Vector2 texScale, Byte4 color)
 {
     MySpritesRenderer.m_spriteInstanceList.Add(new MyVertexFormatSpritePositionTextureColor(
         new HalfVector4(clipOffset.X, clipOffset.Y, clipScale.X, clipScale.Y),
         new HalfVector4(texOffset.X, texOffset.Y, texScale.X, texScale.Y),
         color));
 }

 internal void AddSprite(Vector2 clipOffset, Vector2 clipScale, Vector2 texOffset, Vector2 texScale, 
     Vector2 origin, Vector2 tangent, Byte4 color)
 {
     MySpritesRenderer.StackTop().m_instances.Add(new MyVertexFormatSpritePositionTextureRotationColor(
         new HalfVector4(clipOffset.X, clipOffset.Y, clipScale.X, clipScale.Y),
         new HalfVector4(texOffset.X, texOffset.Y, texScale.X, texScale.Y),
         new HalfVector4(origin.X, origin.Y, tangent.X, tangent.Y),
         color));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="VertexPositionNormalBlendable"/> struct.
 /// </summary>
 /// <param name="position">
 /// The position of the vertex.
 /// </param>
 /// <param name="normal">
 /// The normal of the vertex.
 /// </param>
 /// <param name="boneWeight">
 /// The bone weightings that apply to the vertex.
 /// </param>
 /// <param name="boneIndices">
 /// The bone IDs that apply to the vertex.
 /// </param>
 public VertexPositionNormalBlendable(
     Vector3 position, 
     Vector3 normal,
     Vector4 boneWeight, 
     Byte4 boneIndices)
 {
     this.Position = position;
     this.Normal = normal;
     this.BoneWeights = boneWeight;
     this.BoneIndices = boneIndices;
 }

        public InstancedVertexPositionNormalTextureBumpSkin(VertexPositionNormalTextureBumpSkin source, Matrix meshToObject, byte index)
        {
            Position = source.Position;
            Normal = source.Normal;
            TextureCoordinate1 = source.TextureCoordinate;
            TextureCoordinate2 = source.TextureCoordinate;
            Tangent = source.Tangent;
            Binormal = source.Binormal;

            BoneIndices = new Byte4(source.BoneIndex0, source.BoneIndex1, source.BoneIndex2, source.BoneIndex3);
            BoneWeights = source.BoneWeights;     
        }

        internal void AddQuad(Vector3 v0, Vector3 v1, Vector3 v2, Vector3 v3, Color color)
        {
            var bcolor = new Byte4(color.R, color.G, color.B, color.A);

            Add(new MyVertexFormatPositionColor(v0, bcolor));
            Add(new MyVertexFormatPositionColor(v1, bcolor));

            Add(new MyVertexFormatPositionColor(v1, bcolor));
            Add(new MyVertexFormatPositionColor(v2, bcolor));

            Add(new MyVertexFormatPositionColor(v2, bcolor));
            Add(new MyVertexFormatPositionColor(v3, bcolor));

            Add(new MyVertexFormatPositionColor(v3, bcolor));
            Add(new MyVertexFormatPositionColor(v0, bcolor));
        }

        private static void MultiplyAlpha(Texture2D ret)
        {
            var data = new Byte4[ret.Width*ret.Height];

            ret.GetData(data);
            for (int i = 0; i < data.Length; i++)
            {
                Vector4 vec = data[i].ToVector4();
                float alpha = vec.W/255.0f;
                var a = (int) (vec.W);
                var r = (int) (alpha*vec.X);
                var g = (int) (alpha*vec.Y);
                var b = (int) (alpha*vec.Z);
                var packed = (uint) ((a << 24) + (b << 16) + (g << 8) + r);

                data[i].PackedValue = packed;
            }

            ret.SetData(data);
        }

        internal void AddBoundingBox(BoundingBox bb, Color color)
        {
            var v0 = bb.Center - bb.HalfExtents;
            var v1 = v0 + new Vector3(bb.HalfExtents.X * 2, 0, 0);
            var v2 = v0 + new Vector3(bb.HalfExtents.X * 2, bb.HalfExtents.Y * 2, 0);
            var v3 = v0 + new Vector3(0, bb.HalfExtents.Y * 2, 0);

            var v4 = v0 + new Vector3(0, 0, bb.HalfExtents.Z * 2);
            var v5 = v4 + new Vector3(bb.HalfExtents.X * 2, 0, 0);
            var v6 = v4 + new Vector3(bb.HalfExtents.X * 2, bb.HalfExtents.Y * 2, 0);
            var v7 = v4 + new Vector3(0, bb.HalfExtents.Y * 2, 0);

            var bcolor = new Byte4(color.R, color.G, color.B, color.A);

            Add(new MyVertexFormatPositionColor(v0, bcolor));
            Add(new MyVertexFormatPositionColor(v1, bcolor));
            Add(new MyVertexFormatPositionColor(v1, bcolor));
            Add(new MyVertexFormatPositionColor(v2, bcolor));
            Add(new MyVertexFormatPositionColor(v2, bcolor));
            Add(new MyVertexFormatPositionColor(v3, bcolor));
            Add(new MyVertexFormatPositionColor(v0, bcolor));
            Add(new MyVertexFormatPositionColor(v3, bcolor));

            Add(new MyVertexFormatPositionColor(v4, bcolor));
            Add(new MyVertexFormatPositionColor(v5, bcolor));
            Add(new MyVertexFormatPositionColor(v5, bcolor));
            Add(new MyVertexFormatPositionColor(v6, bcolor));
            Add(new MyVertexFormatPositionColor(v6, bcolor));
            Add(new MyVertexFormatPositionColor(v7, bcolor));
            Add(new MyVertexFormatPositionColor(v4, bcolor));
            Add(new MyVertexFormatPositionColor(v7, bcolor));

            Add(new MyVertexFormatPositionColor(v0, bcolor));
            Add(new MyVertexFormatPositionColor(v4, bcolor));
            Add(new MyVertexFormatPositionColor(v1, bcolor));
            Add(new MyVertexFormatPositionColor(v5, bcolor));
            Add(new MyVertexFormatPositionColor(v2, bcolor));
            Add(new MyVertexFormatPositionColor(v6, bcolor));
            Add(new MyVertexFormatPositionColor(v3, bcolor));
            Add(new MyVertexFormatPositionColor(v7, bcolor));
        }

 public ModelVertex(
     Vector3? position,
     Vector3? normal,
     Vector3? tangent,
     Vector3? bitangent,
     Color[] colors,
     Vector2[] texCoordsUV,
     Vector3[] texCoordsUVW,
     Byte4? boneIndicies,
     Vector4? boneWeights)
 {
     Position = position;
     Normal = normal;
     Tangent = tangent;
     BiTangent = bitangent;
     Colors = colors;
     TexCoordsUV = texCoordsUV;
     TexCoordsUVW = texCoordsUVW;
     BoneIndices = boneIndicies;
     BoneWeights = boneWeights;
 }

 // by 火必烈
 public static void PreMultiplyAlphas(Texture2D ret)
 {
     Byte4[] data = new Byte4[ret.Width * ret.Height];
     ret.GetData<Byte4>(data);
     for (int i = 0; i < data.Length; i++)
     {
         Vector4 vec = data[i].ToVector4();
         float alpha = vec.W / 255.0f;
         int a = (int)(vec.W);
         int r = (int)(alpha * vec.X);
         int g = (int)(alpha * vec.Y);
         int b = (int)(alpha * vec.Z);
         uint packed = (uint)(
             (a << 24) +
             (b << 16) +
             (g << 8) +
             r
             );
         data[i].PackedValue = packed;
     }
     ret.SetData<Byte4>(data);
 }

 internal MyVertexFormatNormal(Byte4 normal, Byte4 normalMorph)
 {
     Normal = normal;
     NormalMorph = normalMorph;
 }

 internal MyVertexFormatTexcoordNormalTangentTexindices(Vector2 texcoord, Vector3 normal, Vector3 tangent, Byte4 texIndices)
 {
     Texcoord = new HalfVector2(texcoord.X, texcoord.Y);
     Normal = VF_Packer.PackNormalB4(ref normal);
     Vector4 T = new Vector4(tangent, 1);
     Tangent = VF_Packer.PackTangentSignB4(ref T);
     TexIndices = texIndices;
 }

 internal MyVertexFormatTexcoordNormalTangent(HalfVector2 texcoord, Byte4 normal, Byte4 tangent)
 {
     Texcoord = texcoord;
     Normal = normal;
     Tangent = tangent;
 }

 public void TestMemberFn_GetHashCode_i ()
 {
     HashSet<Int32> hs = new HashSet<Int32>();
     var rand = new System.Random();
     var buff = new Byte[4];
     UInt32 collisions = 0;
     for(Int32 i = 0; i < Settings.NumTests; ++i)
     {
         rand.NextBytes(buff);
         BitConverter.ToUInt32(buff, 0);
         UInt32 packed = BitConverter.ToUInt32(buff, 0);
         var packedObj = new Byte4();
         packedObj.PackedValue = packed;
         Int32 hc = packedObj.GetHashCode ();
         if(hs.Contains(hc)) ++collisions;
         hs.Add(hc);
     }
     Assert.That(collisions, Is.LessThan(10));
 }

 internal MyVertexFormatPositionColor(Vector3 position, Color color)
 {
     Position = position;
     Color = new Byte4(color.PackedValue);
 }

 internal MyVertexFormatPositionPackedColor(Vector3 position, Color color)
 {
     Position = new HalfVector4(position.X, position.Y, position.Z, 1);
     Color = new Byte4(color.PackedValue);
 }

 internal MyVertexFormatPositionSkinning(HalfVector4 position, Byte4 indices, Vector4 weights)
 {
     Position = position;
     BoneIndices = indices;
     BoneWeights = new HalfVector4(weights);
 }

        public bool ExportDataPackedAsB4(string tagName, Vector3[] vctArr)
        {
            WriteTag(tagName);

            if (vctArr == null)
            {
                m_writer.Write(0);
                return true;
            }

            m_writer.Write(vctArr.Length);
            foreach (Vector3 vctVal in vctArr)
            {
                Vector3 v = vctVal;
                Byte4 vct = new Byte4();
                vct.PackedValue = VF_Packer.PackNormal(ref v);
                WriteByte4(vct);
            }

            return true;
        }