Matrix3D class with clear API, direct access to the components, without unnecessary instance creation inside methods. But, it works a little bit slower than native Matrix3D methods.

AwayTransform.as

package away3d.core.math {
	import flash.geom.Matrix3D;
	import flash.geom.Orientation3D;
	import flash.geom.Vector3D;

	public class AwayTransform {

		public var a:Number = 1;
		public var b:Number = 0;
		public var c:Number = 0;
		public var d:Number = 0;
		public var e:Number = 0;
		public var f:Number = 1;
		public var g:Number = 0;
		public var h:Number = 0;
		public var i:Number = 0;
		public var j:Number = 0;
		public var k:Number = 1;
		public var l:Number = 0;
		public var m:Number = 0;
		public var n:Number = 0;
		public var o:Number = 0;
		public var p:Number = 1;

		public function AwayTransform(rawData:Vector.<Number> = null) {
			if (rawData) {
				a = rawData[0];
				e = rawData[1];
				i = rawData[2];
				m = rawData[3];
				b = rawData[4];
				f = rawData[5];
				j = rawData[6];
				n = rawData[7];
				c = rawData[8];
				g = rawData[9];
				k = rawData[10];
				o = rawData[11];
				d = rawData[12];
				h = rawData[13];
				l = rawData[14];
				p = rawData[15];
			}
		}

		public function recompose(x:Number, y:Number, z:Number, rotationX:Number, rotationY:Number, rotationZ:Number, scaleX:Number, scaleY:Number, scaleZ:Number):void {
			var cosX:Number = Math.cos(rotationX);
			var sinX:Number = Math.sin(rotationX);
			var cosY:Number = Math.cos(rotationY);
			var sinY:Number = Math.sin(rotationY);
			var cosZ:Number = Math.cos(rotationZ);
			var sinZ:Number = Math.sin(rotationZ);
			var cosZsinY:Number = cosZ * sinY;
			var sinZsinY:Number = sinZ * sinY;
			var cosYscaleX:Number = cosY * scaleX;
			var sinXscaleY:Number = sinX * scaleY;
			var cosXscaleY:Number = cosX * scaleY;
			var cosXscaleZ:Number = cosX * scaleZ;
			var sinXscaleZ:Number = sinX * scaleZ;
			a = cosZ * cosYscaleX;
			b = cosZsinY * sinXscaleY - sinZ * cosXscaleY;
			c = cosZsinY * cosXscaleZ + sinZ * sinXscaleZ;
			d = x;
			e = sinZ * cosYscaleX;
			f = sinZsinY * sinXscaleY + cosZ * cosXscaleY;
			g = sinZsinY * cosXscaleZ - cosZ * sinXscaleZ;
			h = y;
			i = -sinY * scaleX;
			j = cosY * sinXscaleY;
			k = cosY * cosXscaleZ;
			l = z;

			m = 0;
			n = 0;
			o = 0;
			p = 1;
		}

		public function decompose(orientationStyle:String = "eulerAngles"):Vector.<Vector3D> {
			var x:Number;
			var y:Number;
			var z:Number;
			var scaleX:Number;
			var scaleY:Number;
			var scaleZ:Number;
			var rotationX:Number;
			var rotationY:Number;
			var rotationZ:Number;
			var rotationW:Number;

			x = d;
			y = h;
			z = l;

			var tx:Number = Math.sqrt(a * a + e * e + i * i);
			var ty:Number = Math.sqrt(b * b + f * f + j * j);
			var tz:Number = Math.sqrt(c * c + g * g + k * k);
			var tw:Number = 0;

			scaleX = tx;
			scaleY = ty;
			scaleZ = tz;

			var ta:Number = a / scaleX;
			var te:Number = e / scaleX;
			var ti:Number = i / scaleX;
			var tb:Number = b / scaleY;
			var tf:Number = f / scaleY;
			var tj:Number = j / scaleY;
			var tc:Number = c / scaleZ;
			var tg:Number = g / scaleZ;
			var tk:Number = k / scaleZ;

			if (orientationStyle == Orientation3D.EULER_ANGLES) {
				tx = Math.atan2(tj, tk);
				ty = Math.atan2(-ti, Math.sqrt(ta * ta + te * te));
				tz = Math.atan2(te, ta);
			} else if (orientationStyle == Orientation3D.AXIS_ANGLE) {
				tw = Math.acos((ta + tf + tk - 1) / 2);
				var len:Number = Math.sqrt((tj - tg) * (tj - tg) + (tc - ti) * (tc - ti) + (te - tb) * (te - tb));
				tx = (tj - tg) / len;
				ty = (tc - ti) / len;
				tz = (te - tb) / len;
			} else {//Orientation3D.QUATERNION
				var tr:Number = ta + tf + tk;
				if (tr > 0) {
					tw = Math.sqrt(1 + tr) / 2;

					tx = (tj - tg) / (4 * tw);
					ty = (tc - ti) / (4 * tw);
					tz = (te - tb) / (4 * tw);
				} else if ((ta > tf) && (ta > tk)) {
					tx = Math.sqrt(1 + ta - tf - tk) / 2;

					tw = (tj - tg) / (4 * tx);
					ty = (te + tb) / (4 * tx);
					tz = (tc + ti) / (4 * tx);
				} else if (tf > tk) {
					ty = Math.sqrt(1 + tf - ta - tk) / 2;

					tx = (te + tb) / (4 * ty);
					tw = (tc - ti) / (4 * ty);
					tz = (tj + tg) / (4 * ty);
				} else {
					tz = Math.sqrt(1 + tk - ta - tf) / 2;

					tx = (tc + ti) / (4 * tz);
					ty = (tj + tg) / (4 * tz);
					tw = (te - tb) / (4 * tz);
				}
			}

			rotationX = tx;
			rotationY = ty;
			rotationZ = tz;
			rotationW = tw;

			decomposeResult[0].x = x;
			decomposeResult[0].y = y;
			decomposeResult[0].z = z;
			decomposeResult[1].x = rotationX;
			decomposeResult[1].y = rotationY;
			decomposeResult[1].z = rotationZ;
			decomposeResult[1].w = rotationW;
			decomposeResult[2].x = scaleX;
			decomposeResult[2].y = scaleY;
			decomposeResult[2].z = scaleZ;
			return decomposeResult;
		}

		private static const decomposeResult:Vector.<Vector3D> = Vector.<Vector3D>([new Vector3D(), new Vector3D(), new Vector3D()]);

		public function invert():void {
			var ta:Number = a;
			var tb:Number = b;
			var tc:Number = c;
			var td:Number = d;
			var te:Number = e;
			var tf:Number = f;
			var tg:Number = g;
			var th:Number = h;
			var ti:Number = i;
			var tj:Number = j;
			var tk:Number = k;
			var tl:Number = l;
			var tm:Number = m;
			var tn:Number = n;
			var to:Number = o;
			var tp:Number = p;

			var det:Number;

			if (m != 0 || n != 0 || o != 0 || p != 1) {
				det = 1 / determinant;
				a = det * (tf * (tk * tp - tl * to) - tg * (tj * tp - tl * tn) + th * (tj * to - tk * tn));
				e = -det * (te * (tk * tp - tl * to) - tg * (ti * tp - tl * tm) + th * (ti * to - tk * tm));
				i = det * (te * (tj * tp - tl * tn) - tf * (ti * tp - tl * tm) + th * (ti * tn - tj * tm));
				m = -det * (te * (tj * to - tk * tn) - tf * (ti * to - tk * tm) + tg * (ti * tn - tj * tm));
				b = -det * (tb * (tk * tp - tl * to) - tc * (tj * tp - tl * tn) + td * (tj * to - tk * tn));
				f = det * (ta * (tk * tp - tl * to) - tc * (ti * tp - tl * tm) + td * (ti * to - tk * tm));
				j = -det * (ta * (tj * tp - tl * tn) - tb * (ti * tp - tl * tm) + td * (ti * tn - tj * tm));
				n = det * (ta * (tj * to - tk * tn) - tb * (ti * to - tk * tm) + tc * (ti * tn - tj * tm));
				c = det * (tb * (tg * tp - th * to) - tc * (tf * tp - th * tn) + td * (tf * to - tg * tn));
				g = -det * (ta * (tg * tp - th * to) - tc * (te * tp - th * tm) + td * (te * to - tg * tm));
				k = det * (ta * (tf * tp - th * tn) - tb * (te * tp - th * tm) + td * (te * tn - tf * tm));
				o = -det * (ta * (tf * to - tg * tn) - tb * (te * to - tg * tm) + tc * (te * tn - tf * tm));
				d = -det * (tb * (tg * tl - th * tk) - tc * (tf * tl - th * tj) + td * (tf * tk - tg * tj));
				h = det * (ta * (tg * tl - th * tk) - tc * (te * tl - th * ti) + td * (te * tk - tg * ti));
				l = -det * (ta * (tf * tl - th * tj) - tb * (te * tl - th * ti) + td * (te * tj - tf * ti));
				p = det * (ta * (tf * tk - tg * tj) - tb * (te * tk - tg * ti) + tc * (te * tj - tf * ti));
				return;
			}

			det = 1 / (-tc * tf * ti + tb * tg * ti + tc * te * tj - ta * tg * tj - tb * te * tk + ta * tf * tk);
			a = (-tg * tj + tf * tk) * det;
			b = (tc * tj - tb * tk) * det;
			c = (-tc * tf + tb * tg) * det;
			d = (td * tg * tj - tc * th * tj - td * tf * tk + tb * th * tk + tc * tf * tl - tb * tg * tl) * det;
			e = (tg * ti - te * tk) * det;
			f = (-tc * ti + ta * tk) * det;
			g = (tc * te - ta * tg) * det;
			h = (tc * th * ti - td * tg * ti + td * te * tk - ta * th * tk - tc * te * tl + ta * tg * tl) * det;
			i = (-tf * ti + te * tj) * det;
			j = (tb * ti - ta * tj) * det;
			k = (-tb * te + ta * tf) * det;
			l = (td * tf * ti - tb * th * ti - td * te * tj + ta * th * tj + tb * te * tl - ta * tf * tl) * det;
		}

		public function transpose():void {
			var te:Number = e;
			var ti:Number = i;
			var tm:Number = m;
			var tb:Number = b;
			var tj:Number = j;
			var tn:Number = n;
			var tc:Number = c;
			var tg:Number = g;
			var to:Number = o;
			var td:Number = d;
			var th:Number = h;
			var tl:Number = l;
			e = tb;
			i = tc;
			m = td;
			j = tg;
			n = th;
			o = tl;
			b = te;
			c = ti;
			d = tm;
			g = tj;
			h = tn;
			l = to;
		}

		public function append(transform:AwayTransform):void {
			var ta:Number = a;
			var tb:Number = b;
			var tc:Number = c;
			var td:Number = d;
			var te:Number = e;
			var tf:Number = f;
			var tg:Number = g;
			var th:Number = h;
			var ti:Number = i;
			var tj:Number = j;
			var tk:Number = k;
			var tl:Number = l;
			var tm:Number = m;
			var tn:Number = n;
			var to:Number = o;
			var tp:Number = p;

			a = ta * transform.a + te * transform.b + ti * transform.c + tm * transform.d;
			e = ta * transform.e + te * transform.f + ti * transform.g + tm * transform.h;
			i = ta * transform.i + te * transform.j + ti * transform.k + tm * transform.l;
			m = ta * transform.m + te * transform.n + ti * transform.o + tm * transform.p;

			b = tb * transform.a + tf * transform.b + tj * transform.c + tn * transform.d;
			f = tb * transform.e + tf * transform.f + tj * transform.g + tn * transform.h;
			j = tb * transform.i + tf * transform.j + tj * transform.k + tn * transform.l;
			n = tb * transform.m + tf * transform.n + tj * transform.o + tn * transform.p;

			c = tc * transform.a + tg * transform.b + tk * transform.c + to * transform.d;
			g = tc * transform.e + tg * transform.f + tk * transform.g + to * transform.h;
			k = tc * transform.i + tg * transform.j + tk * transform.k + to * transform.l;
			o = tc * transform.m + tg * transform.n + tk * transform.o + to * transform.p;

			d = td * transform.a + th * transform.b + tl * transform.c + tp * transform.d;
			h = td * transform.e + th * transform.f + tl * transform.g + tp * transform.h;
			l = td * transform.i + th * transform.j + tl * transform.k + tp * transform.l;
			p = td * transform.m + th * transform.n + tl * transform.o + tp * transform.p;
		}

		public function prepend(transform:AwayTransform):void {
			var ta:Number = a;
			var tb:Number = b;
			var tc:Number = c;
			var td:Number = d;
			var te:Number = e;
			var tf:Number = f;
			var tg:Number = g;
			var th:Number = h;
			var ti:Number = i;
			var tj:Number = j;
			var tk:Number = k;
			var tl:Number = l;
			var tm:Number = m;
			var tn:Number = n;
			var to:Number = o;
			var tp:Number = p;

			a = transform.a * ta + transform.e * tb + transform.i * tc + transform.m * td;
			e = transform.a * te + transform.e * tf + transform.i * tg + transform.m * th;
			i = transform.a * ti + transform.e * tj + transform.i * tk + transform.m * tl;
			m = transform.a * tm + transform.e * tn + transform.i * to + transform.m * tp;

			b = transform.b * ta + transform.f * tb + transform.j * tc + transform.n * td;
			f = transform.b * te + transform.f * tf + transform.j * tg + transform.n * th;
			j = transform.b * ti + transform.f * tj + transform.j * tk + transform.n * tl;
			n = transform.b * tm + transform.f * tn + transform.j * to + transform.n * tp;

			c = transform.c * ta + transform.g * tb + transform.k * tc + transform.o * td;
			g = transform.c * te + transform.g * tf + transform.k * tg + transform.o * th;
			k = transform.c * ti + transform.g * tj + transform.k * tk + transform.o * tl;
			o = transform.c * tm + transform.g * tn + transform.k * to + transform.o * tp;

			d = transform.d * ta + transform.h * tb + transform.l * tc + transform.p * td;
			h = transform.d * te + transform.h * tf + transform.l * tg + transform.p * th;
			l = transform.d * ti + transform.h * tj + transform.l * tk + transform.p * tl;
			p = transform.d * tm + transform.h * tn + transform.l * to + transform.p * tp;
		}

		public function appendTranslation(x:Number, y:Number, z:Number):void {
			d += x;
			h += y;
			l += z;
		}

		public function prependTranslation(x:Number, y:Number, z:Number):void {
			d += a * x + b * y + c * z;
			h += e * x + f * y + g * z;
			l += i * x + j * y + k * z;
		}

		public function prependScale(scaleX:Number, scaleY:Number, scaleZ:Number):void {
			a *= scaleX;
			b *= scaleY;
			c *= scaleZ;
			e *= scaleX;
			f *= scaleY;
			g *= scaleZ;
			i *= scaleX;
			j *= scaleY;
			k *= scaleZ;
		}

		public function appendScale(scaleX:Number, scaleY:Number, scaleZ:Number):void {
			a *= scaleX;
			b *= scaleX;
			c *= scaleX;
			d *= scaleX;
			e *= scaleY;
			f *= scaleY;
			g *= scaleY;
			h *= scaleY;
			i *= scaleZ;
			j *= scaleZ;
			k *= scaleZ;
			l *= scaleZ;
		}

		public function transformVector(vector:Vector3D, result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			var x:Number = vector.x;
			var y:Number = vector.y;
			var z:Number = vector.z;
			result.x = a * x + b * y + c * z + d;
			result.y = e * x + f * y + g * z + h;
			result.z = i * x + j * y + k * z + l;
			return result;
		}

		public function deltaTransformVector(vector:Vector3D, result:Vector3D = null):Vector3D {
			if (!vector) return null;
			if (!result) result = new Vector3D();
			var x:Number = vector.x;
			var y:Number = vector.y;
			var z:Number = vector.z;
			result.x = a * x + b * y + c * z;
			result.y = e * x + f * y + g * z;
			result.z = i * x + j * y + k * z;
			return result;
		}

		public function transformVectors(vectors:Vector.<Number>, result:Vector.<Number> = null):Vector.<Number> {
			if (!vectors) return null;
			if (!result) result = new Vector.<Number>();

			var length:uint = vectors.length;
			var x:Number;
			var y:Number;
			var z:Number;
			for (var index:uint = 0; i < length; i++) {
				x = vectors[index];
				y = vectors[index + 1];
				z = vectors[index + 2];
				result[index] = a * x + b * y + c * z + d;
				result[index + 1] = e * x + f * y + g * z + h;
				result[index + 2] = i * x + j * y + k * z + l;
			}

			return result;
		}

		public function appendRotation(radians:Number, axisX:Number = 0, axisY:Number = 1, axisZ:Number = 0, pivotX:Number = 0, pivotY:Number = 0, pivotZ:Number = 0):void {
			var hasPivot:Boolean = (pivotX != 0) || (pivotY != 0) || (pivotZ != 0);
			if (hasPivot) {
				appendTranslation(-pivotX, -pivotY, -pivotZ);
			}

			append(getAxisRotation(axisX, axisY, axisZ, radians));

			if (hasPivot) {
				appendTranslation(pivotX, pivotY, pivotZ);
			}
		}

		public function prependRotation(radians:Number, axisX:Number = 0, axisY:Number = 1, axisZ:Number = 0, pivotX:Number = 0, pivotY:Number = 0, pivotZ:Number = 0):void {
			var hasPivot:Boolean = (pivotX != 0) || (pivotY != 0) || (pivotZ != 0);
			if (hasPivot) {
				prependTranslation(-pivotX, -pivotY, -pivotZ);
			}

			prepend(getAxisRotation(axisX, axisY, axisZ, radians));

			if (hasPivot) {
				prependTranslation(pivotX, pivotY, pivotZ);
			}
		}

		private static var tempTransform:AwayTransform;

		private static function getAxisRotation(x:Number, y:Number, z:Number, rad:Number):AwayTransform {
			if (!tempTransform) tempTransform = new AwayTransform();
			tempTransform.identity();

			var cosA:Number = Math.cos(rad);
			var sinA:Number = Math.sin(rad);
			var t:Number = 1 - cosA;

			var tmp1:Number;
			var tmp2:Number;

			tempTransform.a = cosA + x * x * t;
			tempTransform.f = cosA + y * y * t;
			tempTransform.k = cosA + z * z * t;
			tmp1 = x * y * t;
			tmp2 = z * sinA;
			tempTransform.b = tmp1 + tmp2;
			tempTransform.e = tmp1 - tmp2;
			tmp1 = x * z * t;
			tmp2 = y * sinA;
			tempTransform.i = tmp1 + tmp2;
			tempTransform.c = tmp1 - tmp2;
			tmp1 = y * z * t;
			tmp2 = x * sinA;
			tempTransform.j = tmp1 - tmp2;
			tempTransform.g = tmp1 + tmp2;
			return tempTransform;
		}

		public function get determinant():Number {
			return a * f * k * p - a * f * l * o - a * g * j * p + a * g * l * n + a * h * j * o - a * h * k * n - b * e * k * p + b * e * l * o + b * g * i * p - b * g * l * m - b * h * i * o + b * h * k * m + c * e * j * p - c * e * l * n - c * f * i * p + c * f * l * m + c * h * i * n - c * h * j * m - d * e * j * o + d * e * k * n + d * f * i * o - d * f * k * m - d * g * i * n + d * g * j * m;
		}

		public function copyFrom(source:AwayTransform):void {
			a = source.a;
			b = source.b;
			c = source.c;
			d = source.d;
			e = source.e;
			f = source.f;
			g = source.g;
			h = source.h;
			i = source.i;
			j = source.j;
			k = source.k;
			l = source.l;
			m = source.m;
			n = source.n;
			o = source.o;
			p = source.p;
		}

		/**
		 * Converts the current matrix to an identity or unit matrix.
		 */
		public function identity():void {
			a = 1;
			b = 0;
			c = 0;
			d = 0;
			e = 0;
			f = 1;
			g = 0;
			h = 0;
			i = 0;
			j = 0;
			k = 1;
			l = 0;
			m = 0;
			n = 0;
			o = 0;
			p = 1;
		}

		public function toString():String {
			return  a + " " + b + " " + c + " " + d + "\n" +
					e + " " + f + " " + g + " " + h + "\n" +
					i + " " + j + " " + k + " " + l + "\n" +
					m + " " + n + " " + o + " " + p;
		}

		public function getRightVector(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = a;
			result.y = b;
			result.z = c;
			return result;
		}

		public function getLeftVector(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = -a;
			result.y = -b;
			result.z = -c;
			return result;
		}

		public function getUpVector(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = e;
			result.y = f;
			result.z = g;
			return result;
		}

		public function getDownVector(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = -e;
			result.y = -f;
			result.z = -g;
			return result;
		}

		public function getForwardVector(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = i;
			result.y = j;
			result.z = k;
			return result;
		}

		public function getBackVector(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = -i;
			result.y = -j;
			result.z = -k;
			return result;
		}

		public function getTranslateVector(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = d;
			result.y = h;
			result.z = l;
			return result;
		}

		public function copyToMatrix(target:Matrix3D = null):Matrix3D {
			if (!target) target = new Matrix3D();
			var raw:Vector.<Number> = Matrix3DUtils.RAW_DATA_CONTAINER;
			raw[0] = a;
			raw[1] = e;
			raw[2] = i;
			raw[3] = m;
			raw[4] = b;
			raw[5] = f;
			raw[6] = j;
			raw[7] = n;
			raw[8] = c;
			raw[9] = g;
			raw[10] = k;
			raw[11] = o;
			raw[12] = d;
			raw[13] = h;
			raw[14] = l;
			raw[15] = p;
			target.copyRawDataFrom(raw);
			return target;
		}

		public function copyFromMatrix(source:Matrix3D):void {
			if (!source) return;
			var raw:Vector.<Number> = Matrix3DUtils.RAW_DATA_CONTAINER;
			source.copyRawDataTo(raw);
			a = raw[0];
			e = raw[1];
			i = raw[2];
			m = raw[3];
			b = raw[4];
			f = raw[5];
			j = raw[6];
			n = raw[7];
			c = raw[8];
			g = raw[9];
			k = raw[10];
			o = raw[11];
			d = raw[12];
			h = raw[13];
			l = raw[14];
			p = raw[15];
		}

		public function getRawData(result:Vector.<Number> = null):Vector.<Number> {
			if (!result) result = new Vector.<Number>();
			result[0] = a;
			result[1] = e;
			result[2] = i;
			result[3] = m;
			result[4] = b;
			result[5] = f;
			result[6] = j;
			result[7] = n;
			result[8] = c;
			result[9] = g;
			result[10] = k;
			result[11] = o;
			result[12] = d;
			result[13] = h;
			result[14] = l;
			result[15] = p;
			return result;
		}

		public function setRawData(data:Vector.<Number> = null):void {
			a = data[0];
			e = data[1];
			i = data[2];
			m = data[3];
			b = data[4];
			f = data[5];
			j = data[6];
			n = data[7];
			c = data[8];
			g = data[9];
			k = data[10];
			o = data[11];
			d = data[12];
			h = data[13];
			l = data[14];
			p = data[15];
		}

		public function get scaleX():Number {
			return Math.sqrt(a * a + e * e + i * i);
		}

		public function get scaleY():Number {
			return Math.sqrt(b * b + f * f + j * j);
		}

		public function get scaleZ():Number {
			return Math.sqrt(c * c + g * g + k * k);
		}

		public function getScaleValues(result:Vector3D = null):Vector3D {
			if (!result) result = new Vector3D();
			result.x = Math.sqrt(a * a + e * e + i * i);
			result.y = Math.sqrt(b * b + f * f + j * j);
			result.z = Math.sqrt(c * c + g * g + k * k);
			return result;
		}

		public function clone():AwayTransform {
			var result:AwayTransform = new AwayTransform();
			result.copyFrom(this);
			return result;
		}

		private static const tempProgramConstants:Vector.<Number> = new Vector.<Number>();

		public function get programConstants():Vector.<Number> {
			tempProgramConstants[0] = a;
			tempProgramConstants[1] = b;
			tempProgramConstants[2] = c;
			tempProgramConstants[3] = d;
			tempProgramConstants[4] = e;
			tempProgramConstants[5] = f;
			tempProgramConstants[6] = g;
			tempProgramConstants[7] = h;
			tempProgramConstants[8] = i;
			tempProgramConstants[9] = j;
			tempProgramConstants[10] = k;
			tempProgramConstants[11] = l;
			tempProgramConstants[12] = m;
			tempProgramConstants[13] = n;
			tempProgramConstants[14] = o;
			tempProgramConstants[15] = p;
			return tempProgramConstants;
		}

		public function get transposedProgramConstants():Vector.<Number> {
			tempProgramConstants[0] = a;
			tempProgramConstants[1] = e;
			tempProgramConstants[2] = i;
			tempProgramConstants[3] = m;
			tempProgramConstants[4] = b;
			tempProgramConstants[5] = f;
			tempProgramConstants[6] = j;
			tempProgramConstants[7] = n;
			tempProgramConstants[8] = c;
			tempProgramConstants[9] = g;
			tempProgramConstants[10] = k;
			tempProgramConstants[11] = o;
			tempProgramConstants[12] = d;
			tempProgramConstants[13] = h;
			tempProgramConstants[14] = l;
			tempProgramConstants[15] = p;
			return tempProgramConstants;
		}

		public function copyRawDataTo(target:Vector.<Number>, targetStartIndex:int, transpose:Boolean):void {
			if (transpose) {
				target[targetStartIndex++] = a;
				target[targetStartIndex++] = b;
				target[targetStartIndex++] = c;
				target[targetStartIndex++] = d;
				target[targetStartIndex++] = e;
				target[targetStartIndex++] = f;
				target[targetStartIndex++] = g;
				target[targetStartIndex++] = h;
				target[targetStartIndex++] = i;
				target[targetStartIndex++] = j;
				target[targetStartIndex++] = k;
				target[targetStartIndex++] = l;
				target[targetStartIndex++] = m;
				target[targetStartIndex++] = n;
				target[targetStartIndex++] = o;
				target[targetStartIndex] = p;
			} else {
				target[targetStartIndex++] = a;
				target[targetStartIndex++] = e;
				target[targetStartIndex++] = i;
				target[targetStartIndex++] = m;
				target[targetStartIndex++] = b;
				target[targetStartIndex++] = f;
				target[targetStartIndex++] = j;
				target[targetStartIndex++] = n;
				target[targetStartIndex++] = c;
				target[targetStartIndex++] = g;
				target[targetStartIndex++] = k;
				target[targetStartIndex++] = o;
				target[targetStartIndex++] = d;
				target[targetStartIndex++] = h;
				target[targetStartIndex++] = l;
				target[targetStartIndex] = p;
			}
		}
	}
}

It was created special for Away3D engine, to fix memory issues. But after speed test, I saw that it works a little bit slower in runtime than native Matrix3D.