A Disturbing Strangeness

Pour faire mon petit Mario kart j’ai utilisé une matrice 2D pour la camera. J’ai eu quelque difficulté à trouver des sources sur le net alors je vous livre ci-dessous celle que j’ai codée. J’y pensais depuis un certain temps. En fait l’enjeu du débat est que se passer d’une matrice pour faire les calculs est plutôt simple; La rotation se fait avec x = distance * cos(delta) et y = distance * sin(delta) et la rotation inverse nécessaire pour les calculs de camera se fait tout simplement par delta = – delta. Alors pourquoi utiliser une matrice qui sera de toute façon moins performante car multipliant les opérations arithmétiques ? Et bien tout simplement parce qu’en combinant plusieurs calculs de rotations et de déplacements de suite on peut vite s’y perdre et c’est donc bien mieux de les contenir dans un objet. Imaginons un objet 2D contenu dans un objet 2D lui même contenu dans un autre objet 2D; il est plus simple de combiner les matrices 2D de chaque objet pour trouver leur positionnement plutôt que de faire le calcul d’un bloque. (Et pourquoi pas utiliser la matrice 2D de flash ? Parce que je ne sais pas ce qu’il y a dedans alors j’aime pas ça .. je me souviens d’avoir bien galéré sur un code avec la matrice3D de flash avant de comprende qu’il y a vait un bug ! )

package math {
	/**
	 * @author orbito
	 */
	public class Matrix2D {
		public var 	a : Number,
		b : Number,
		c : Number,
		d : Number,
		tx : Number,
		ty : Number;

		public function Matrix2D() : void {
			this.a = 1;
			this.b = 0;
			this.c = 0;
			this.d = 1;

			this.tx = 1;
			this.ty = 0;
		}

		public function get determinant() : Number {
			return (a * d - b * c);
		}

		public function get position() : Vector2D {
			return new Vector2D(tx, ty);
		}

		public function set position(a : Vector2D) : void {
			tx = a.x;
			ty = a.y;
		}

		public function translate(dx : Number = 0, dy : Number = 0) : void {
			tx += dx;
			ty += dy;
		}

		public function scale(sx : Number = 1, sy : Number = 1) : void {
			a = a * sx;
			b = b * sx;
			c = c * sx;
			d = d * sy;

			tx = tx * sy;
			ty = ty * sy;
		}

		public function rot(radians : Number) : void {
			var m : Matrix2D = new Matrix2D;

			m.a = m.d = Math.cos(radians);
			m.c = Math.sin(radians);
			m.b = -m.c;

			deltaCombine(m);
		}

		public function deltaCombine(lhs : Matrix2D) : void {
			var mat : Matrix2D = new Matrix2D;

			mat.a = lhs.a * a + lhs.b * c;
			mat.b = lhs.a * b + lhs.b * d;

			mat.c = lhs.c * a + lhs.d * c;
			mat.d = lhs.c * b + lhs.d * d;

			deltaCopy(mat);
		}

		public function clone() : Matrix2D {
			var mat : Matrix2D = new Matrix2D;
			mat.copy(this);
			return mat;
		}

		public function deltaCopy(mat : Matrix2D) : void {
			a = mat.a;
			b = mat.b;
			c = mat.c;
			d = mat.d;
		}

		public function copy(mat : Matrix2D) : void {
			a = mat.a;
			b = mat.b;
			c = mat.c;
			d = mat.d;
			tx = mat.tx;
			ty = mat.ty;
		}

		public function invert() : Boolean {
			var mat : Matrix2D = new Matrix2D;

			var det : Number = determinant;

			if (det == 0) return false;

			det = 1 / det;

			mat.a = d * det;
			mat.b = b * -det;
			mat.c = c * -det;
			mat.d = a * det;

			mat.tx = (b * ty - d * tx) * det;
			mat.ty = (c * tx - a * ty) * det;

			copy(mat);

			return true;
		}

		public function transformVector(v : Vector2D) : Vector2D {
			return new Vector2D(v.x * a + v.y * b + tx, v.x * c + v.y * d + ty);
		}
	}
}