C# XNA 自定义写了一个：MMatrix33的类（3 * 3矩阵类）
写这个的目的是为了，加深对MMatrix33作用，有什么用的理解；
当然，里面的运算，为什么这写法，算法，我都是抄了别的语言过来的；
以下部份运算，是参考了：AS3 Starling ，与网络上其它相关矩阵信息的运算方式；
最终我的目的是，为了能先加深对矩阵运算理解；再看看Cocos2d-xna（WP7）版的源码（虽然官方是因为Win8已出，而已停止扩展）；
然后最终再自己写一个轻量级的：3D渲染，的2D简单框架；
源码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
namespace Base.MyMath
{
///
/// 3 * 3 矩阵
/// Author : Jave.Lin
/// Date : 2013-08-30
///
public struct MMatrix33
{
/*
* [m11, m12, m13]
* [m21, m22, m23]
* [m31, m32, m33]
* */
public float m11, m12, m13;
public float m21, m22, m23;
public float m31, m32, m33;
/**
* ================>
* （1）、缩放：s
* [m11 * s, m12 * s, 0]
* [m21 * s, m22 * s, 0]
* [0, 0, 1]
*
* ================>
* （2）、位移：x, y
* [1, 0, 0]
* [0, 1, 0] == tm
* [x, y, 1]
* sm = sm * tm//sm：源矩阵；tm：位移矩阵
*
* ================>
* （3）、旋转：r
* [cos(r), sin(r), 0]
* [-sin(r), cos(r), 0] == rm
* [0, 0, 1]
* sm = sm * tm//sm：源矩阵；rm：旋转矩阵
*
* ================>
* （4）、扭曲：skewX, skewY
* [m11, m12, m13] [a, b, 0]
* [m21, m22, m23] ==> [c, d, 0]
* [m31, m32, m33] [tx,ty,1]
* float sinX = (float)Math.Sin(skewX);
* float cosX = (float)Math.Cos(skewX);
* float sinY = (float)Math.Sin(skewY);
* float cosY = (float)Math.Cos(skewY);
* a = a * cosY - b * sinX;//a
* b = a * sinY + b * cosX;//b
* c = c * cosY - d * sinX;//c
* d = c * sinY + d * cosX;//d
* tx = tx * cosY - ty * sinX;//tx
* ty = tx * sinY + ty * cosX;//ty
* */
public MMatrix33()
{
m11 = m22 = m33 = 1;
m12 = m13 = m21 = m23 = m31 = m32 = 0;
}
//临时矩阵池
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);
}
///
/// 单位化
///
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 mul(MMatrix33 m)
{
MMatrix33.mul(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);
}
///
/// 根据指定的Vector2向量缩放
///
///
public void scaleByV(Vector2 v)
{
MMatrix33.scaleByV(ref this, v);
}
///
/// 扭曲
///
///
///
public void skew(float skewX, float skewY)
{
MMatrix33.skew(ref this, skewX, skewY);
}
///
/// 复制
///
///
/// 将所有指定的Vecotr2向量都应用指定的matrix坐标转换
///
///
///
public static void transformVector2Arr(MMatrix33 matrix, ref Vector2[] vecArr)
{
for (int i = 0; i < vecArr.Length; 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.mul(ref matrix, m);
MMatrix33.pushM(m);
}
///
/// 根据指定的相前的向量fwd，指定的法向量side，旋转矩阵
///
///
///
///
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.mul(ref matrix, m);
MMatrix33.pushM(m);
}
///
/// 矩阵相乘
///
///
///
public static void mul(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.mul(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);
//MMatrix33
/*
* [a, b, 0]
* [c, d, 0]
* [tx, ty, 1]
* */
//相当于flash的a,c,b,d,tx,ty
/*
* [a, b, tx]
* [c, d, ty]
* [0, 0, 1]
* */
matrix.m11 = matrix.m11 * cosY - matrix.m12 * sinX;//a
matrix.m12 = matrix.m11 * sinY + matrix.m12 * cosX;//b
matrix.m21 = matrix.m21 * cosY - matrix.m22 * sinX;//c
matrix.m22 = matrix.m21 * sinY + matrix.m22 * cosX;//d
matrix.m31 = matrix.m31 * cosY - matrix.m32 * sinX;//tx
matrix.m32 = matrix.m31 * sinY + matrix.m32 * cosX;//ty
}
///
/// 复制对象
///
///
///