Skip to content

Instantly share code, notes, and snippets.

@gonchar
Created December 25, 2013 13:51
Show Gist options
  • Save gonchar/8123359 to your computer and use it in GitHub Desktop.
Save gonchar/8123359 to your computer and use it in GitHub Desktop.
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.
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;
}
}
}
}
@gonchar
Copy link
Author

gonchar commented Dec 25, 2013

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.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment