C#XNA中实现自定义3x3矩阵类：MMatrix33

为了更好地理解和应用 3x3 矩阵的运算，本文详细描述了 MMatrix33 类的实现过程。通过借鉴 AS3 Starling 和网络上的相关资源，我们实现了多种矩阵操作，如缩放、位移、旋转和扭曲等。

最终目标是通过深入研究矩阵运算，进一步探索 Cocos2d-xna（WP7）版源码，并最终构建一个轻量级的 2D 渲染框架。

以下是 MMatrix33 类的完整代码实现：

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;

namespace Base.MyMath
{
///

/// 3x3 矩阵类
/// Author: Jave.Lin
/// Date: 2013-08-30
///

public struct MMatrix33
{
// 矩阵元素
public float m11, m12, m13;
public float m21, m22, m23;
public float m31, m32, m33;

// 构造函数
public MMatrix33()
{
m11 = m22 = m33 = 1;
m12 = m13 = m21 = m23 = m31 = m32 = 0;
}

// 单位化矩阵
public void Identity()
{
MMatrix33.Identity(ref this);
}

// 旋转矩阵
public void Rotate(float rotation)
{
MMatrix33.Rotate(ref this, rotation);
}

// 根据方向旋转矩阵
public void RotateByV(Vector2 fwd, Vector2 side)
{
MMatrix33.RotateByV(ref this, fwd, side);
}

// 矩阵相乘
public void Multiply(MMatrix33 m)
{
MMatrix33.Multiply(ref this, m);
}

// 位移矩阵
public void Translate(Vector2 v)
{
MMatrix33.Translate(ref this, v);
}

// 缩放矩阵
public void Scale(float s)
{
MMatrix33.Scale(ref this, s);
}

// 根据水平、垂直缩放
public void ScaleXY(float scaleX, float scaleY)
{
MMatrix33.ScaleXY(ref this, scaleX, scaleY);
}

// 根据指定的向量缩放
public void ScaleByV(Vector2 v)
{
MMatrix33.ScaleByV(ref this, v);
}

// 扭曲矩阵
public void Skew(float skewX, float skewY)
{
MMatrix33.Skew(ref this, skewX, skewY);
}

// 复制矩阵
public MMatrix33 Copy()
{
return MMatrix33.Copy(this);
}

// 将所有指定的Vector2向量都应用指定的matrix坐标转换
public static void TransformVector2Arr(MMatrix33 matrix, ref Vector2[] vecArr)
{
for (int i = 0; i {
TransformVector2(matrix, ref vecArr[i]);
}
}

// 将指定的Vector2向量应用指定的matrix坐标转换
public static void TransformVector2(MMatrix33 matrix, ref Vector2 v)
{
v.X = matrix.m11 * v.X + matrix.m21 * v.Y + matrix.m31;
v.Y = matrix.m12 * v.X + matrix.m22 * v.Y + matrix.m32;
}

// 单位化矩阵
public static void Identity(ref MMatrix33 matrix)
{
matrix.m11 = 1; matrix.m12 = 0; matrix.m13 = 0;
matrix.m21 = 0; matrix.m22 = 1; matrix.m23 = 0;
matrix.m31 = 0; matrix.m32 = 0; matrix.m33 = 1;
}

// 旋转矩阵
public static void Rotate(ref MMatrix33 matrix, float rotation)
{
MMatrix33 m = getM();
float sin = (float)Math.Sin(rotation);
float cos = (float)Math.Cos(rotation);
m.m11 = cos; m.m12 = sin; m.m13 = 0;
m.m21 = -sin; m.m22 = cos; m.m23 = 0;
m.m32 = 0; m.m32 = 0; m.m33 = 1;
MMatrix33.Multiply(ref matrix, m);
MMatrix33.PushM(m);
}

// 根据指定的方向向量旋转矩阵
public static void RotateByV(ref MMatrix33 matrix, Vector2 fwd, Vector2 side)
{
MMatrix33 m = getM();
m.m11 = fwd.X; m.m12 = fwd.Y; m.m13 = 0;
m.m21 = side.X; m.m22 = side.Y; m.m23 = 0;
m.m32 = 0; m.m32 = 0; m.m33 = 1;
MMatrix33.Multiply(ref matrix, m);
MMatrix33.PushM(m);
}

// 矩阵相乘
public static void Multiply(ref MMatrix33 matrix, MMatrix33 m)
{
// 第一行
matrix.m11 = matrix.m11 * m.m11 + matrix.m12 * m.m21 + matrix.m13 * m.m31;
matrix.m12 = matrix.m11 * m.m12 + matrix.m12 * m.m22 + matrix.m13 * m.m32;
matrix.m13 = matrix.m11 * m.m13 + matrix.m12 * m.m23 + matrix.m13 * m.m33;
// 第二行
matrix.m21 = matrix.m21 * m.m11 + matrix.m22 * m.m21 + matrix.m23 * m.m31;
matrix.m22 = matrix.m21 * m.m12 + matrix.m22 * m.m22 + matrix.m23 * m.m32;
matrix.m23 = matrix.m21 * m.m13 + matrix.m22 * m.m23 + matrix.m23 * m.m33;
// 第三行
matrix.m31 = matrix.m31 * m.m11 + matrix.m32 * m.m21 + matrix.m33 * m.m31;
matrix.m32 = matrix.m31 * m.m12 + matrix.m32 * m.m22 + matrix.m33 * m.m32;
matrix.m33 = matrix.m31 * m.m13 + matrix.m32 * m.m23 + matrix.m33 * m.m33;
}

// 矩阵根据指定量的Vector2向量位移
public static void Translate(ref MMatrix33 matrix, Vector2 v)
{
MMatrix33 m = getM();
m.m11 = 1; m.m12 = 0; m.m13 = 0;
m.m21 = 0; m.m22 = 1; m.m23 = 0;
m.m32 = v.X; m.m32 = v.Y; m.m33 = 1;
MMatrix33.Multiply(ref matrix, m);
}

// 缩放矩阵
public static void Scale(ref MMatrix33 matrix, float scale)
{
MMatrix33.ScaleXY(ref matrix, scale, scale);
}

// 根据指定的水平、垂直缩放
public static void ScaleXY(ref MMatrix33 matrix, float scaleX, float scaleY)
{
matrix.m11 *= scaleX; matrix.m12 *= scaleX;
matrix.m21 *= scaleY; matrix.m22 *= scaleY;
}

// 根据指定的向量缩放
public static void ScaleByV(ref MMatrix33 matrix, Vector2 v)
{
MMatrix33.ScaleXY(ref matrix, v.X, v.Y);
}

// 扭曲矩阵
public static void Skew(ref MMatrix33 matrix, float skewX, float skewY)
{
float sinX = (float)Math.Sin(skewX);
float cosX = (float)Math.Cos(skewX);
float sinY = (float)Math.Sin(skewY);
float cosY = (float)Math.Cos(skewY);

matrix.m11 = matrix.m11 * cosY - matrix.m12 * sinX;
matrix.m12 = matrix.m11 * sinY + matrix.m12 * cosX;
matrix.m21 = matrix.m21 * cosY - matrix.m22 * sinX;
matrix.m22 = matrix.m21 * sinY + matrix.m22 * cosX;
matrix.m31 = matrix.m31 * cosY - matrix.m32 * sinX;
matrix.m32 = matrix.m31 * sinY + matrix.m32 * cosX;
}

// 复制对象
public static MMatrix33 Copy(MMatrix33 m)
{
return (MMatrix33)m.MemberwiseClone();
}

// 临时矩阵池
private static Queue mPool = new Queue();

// 获取临时矩阵（出队）
private static MMatrix33 getM()
{
return mPool.Count > 0 ? mPool.Dequeue() : new MMatrix33();
}

// 回收临时矩阵（入队）
private static void PushM(MMatrix33 m)
{
m.Identity();
mPool.Enqueue(m);
}
}
}
```