dcbe2fc245
Currently, it's only possible to create modules at the leafs of the namespace structure. This CL lifts that restriction. Get rid of "use strict" in many cases.
100 lines
2.9 KiB
JavaScript
100 lines
2.9 KiB
JavaScript
|
|
Elm.Native.Transform2D = {};
|
|
Elm.Native.Transform2D.make = function(elm) {
|
|
|
|
elm.Native = elm.Native || {};
|
|
if (elm.Native.Transform2D) return elm.Native.Transform2D;
|
|
|
|
var A;
|
|
if (typeof Float32Array === 'undefined') {
|
|
A = function(arr) {
|
|
this.length = arr.length;
|
|
this[0] = arr[0];
|
|
this[1] = arr[1];
|
|
this[2] = arr[2];
|
|
this[3] = arr[3];
|
|
this[4] = arr[4];
|
|
this[5] = arr[5];
|
|
};
|
|
} else {
|
|
A = Float32Array;
|
|
}
|
|
|
|
// layout of matrix in an array is
|
|
//
|
|
// | m11 m12 dx |
|
|
// | m21 m22 dy |
|
|
// | 0 0 1 |
|
|
//
|
|
// new A([ m11, m12, dx, m21, m22, dy ])
|
|
|
|
var identity = new A([1,0,0,0,1,0]);
|
|
function matrix(m11, m12, m21, m22, dx, dy) {
|
|
return new A([m11, m12, dx, m21, m22, dy]);
|
|
}
|
|
function rotation(t) {
|
|
var c = Math.cos(t);
|
|
var s = Math.sin(t);
|
|
return new A([c, -s, 0, s, c, 0]);
|
|
}
|
|
|
|
function rotate(t,m) {
|
|
var c = Math.cos(t);
|
|
var s = Math.sin(t);
|
|
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
|
|
return new A([m11*c + m12*s, -m11*s + m12*c, m[2],
|
|
m21*c + m22*s, -m21*s + m22*c, m[5]]);
|
|
}
|
|
/*
|
|
function move(xy,m) {
|
|
var x = xy._0;
|
|
var y = xy._1;
|
|
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];
|
|
return new A([m11, m12, m11*x + m12*y + m[2],
|
|
m21, m22, m21*x + m22*y + m[5]]);
|
|
}
|
|
function scale(s,m) { return new A([m[0]*s, m[1]*s, m[2], m[3]*s, m[4]*s, m[5]]); }
|
|
function scaleX(x,m) { return new A([m[0]*x, m[1], m[2], m[3]*x, m[4], m[5]]); }
|
|
function scaleY(y,m) { return new A([m[0], m[1]*y, m[2], m[3], m[4]*y, m[5]]); }
|
|
function reflectX(m) { return new A([-m[0], m[1], m[2], -m[3], m[4], m[5]]); }
|
|
function reflectY(m) { return new A([m[0], -m[1], m[2], m[3], -m[4], m[5]]); }
|
|
|
|
function transform(m11, m21, m12, m22, mdx, mdy, n) {
|
|
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
|
|
return new A([m11*n11 + m12*n21,
|
|
m11*n12 + m12*n22,
|
|
m11*ndx + m12*ndy + mdx,
|
|
m21*n11 + m22*n21,
|
|
m21*n12 + m22*n22,
|
|
m21*ndx + m22*ndy + mdy]);
|
|
}
|
|
*/
|
|
function multiply(m, n) {
|
|
var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4], mdx = m[2], mdy = m[5];
|
|
var n11 = n[0], n12 = n[1], n21 = n[3], n22 = n[4], ndx = n[2], ndy = n[5];
|
|
return new A([m11*n11 + m12*n21,
|
|
m11*n12 + m12*n22,
|
|
m11*ndx + m12*ndy + mdx,
|
|
m21*n11 + m22*n21,
|
|
m21*n12 + m22*n22,
|
|
m21*ndx + m22*ndy + mdy]);
|
|
}
|
|
|
|
return elm.Native.Transform2D = {
|
|
identity:identity,
|
|
matrix:F6(matrix),
|
|
rotation:rotation,
|
|
multiply:F2(multiply)
|
|
/*
|
|
transform:F7(transform),
|
|
rotate:F2(rotate),
|
|
move:F2(move),
|
|
scale:F2(scale),
|
|
scaleX:F2(scaleX),
|
|
scaleY:F2(scaleY),
|
|
reflectX:reflectX,
|
|
reflectY:reflectY
|
|
*/
|
|
};
|
|
|
|
};
|