gs-json/dist2015/libs/threex/threex.js

gs-JSON is a domain agnostic unifying 3D file format for geometric and semantic modelling (hence the 'gs').

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.multVectorMatrix = multVectorMatrix;
exports.multXYZMatrix = multXYZMatrix;
exports.xformMatrix = xformMatrix;
exports.xformMatrixFromXYZs = xformMatrixFromXYZs;
exports.matrixInv = matrixInv;
exports.vectorsFromVertices = vectorsFromVertices;
exports.vectorsFromPoints = vectorsFromPoints;
exports.subVectors = subVectors;
exports.addVectors = addVectors;
exports.crossVectors = crossVectors;
exports.vectorFromPointsAtoB = vectorFromPointsAtoB;
exports.vectorFromVerticesAtoB = vectorFromVerticesAtoB;
exports.subXYZs = subXYZs;
exports.addXYZs = addXYZs;
exports.crossXYZs = crossXYZs;
exports.normalizeXYZ = normalizeXYZ;
exports.lengthXYZ = lengthXYZ;
exports.setLengthXYZ = setLengthXYZ;
exports.makeXYZOrthogonal = makeXYZOrthogonal;
exports.subPoints = subPoints;
exports.addPoints = addPoints;
exports.subVertices = subVertices;
exports.addVertices = addVertices;

var _three = require("three");

var three = _interopRequireWildcard(_three);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var EPS = 1e-6;
/**
 * Utility functions for threejs.
 */
// Matrices ======================================================================================================
function multVectorMatrix(v, m) {
    var v2 = v.clone();
    v2.applyMatrix4(m);
    return v2;
}
function multXYZMatrix(xyz, m) {
    var v2 = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz))))();
    v2.applyMatrix4(m);
    return v2.toArray().slice(0, 3);
}
function xformMatrix(o, x, y, z) {
    x.normalize();
    y.normalize();
    z.normalize();
    var m1 = new three.Matrix4();
    var o_neg = o.clone().negate();
    m1.setPosition(o_neg);
    var m2 = new three.Matrix4();
    m2.makeBasis(x, y, z);
    m2.getInverse(m2);
    var m3 = new three.Matrix4();
    m3.multiplyMatrices(m2, m1);
    return m3;
}
function xformMatrixFromXYZs(o, axes) {
    return xformMatrix(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(o))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(axes[0]))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(axes[1]))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(axes[2]))))());
}
function matrixInv(m) {
    var m2 = new three.Matrix4();
    return m2.getInverse(m);
}
//  Vectors =======================================================================================================
function vectorsFromVertices(vertices) {
    return vertices.map(function (v) {
        return new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(v.getPoint().getPosition()))))();
    });
}
function vectorsFromPoints(points) {
    return points.map(function (p) {
        return new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p.getPosition()))))();
    });
}
function subVectors(v1, v2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    var v3 = new three.Vector3();
    v3.subVectors(v1, v2);
    if (norm) {
        v3.normalize();
    }
    return v3;
}
function addVectors(v1, v2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    var v3 = new three.Vector3();
    v3.addVectors(v1, v2);
    if (norm) {
        v3.normalize();
    }
    return v3;
}
function crossVectors(v1, v2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    var v3 = new three.Vector3();
    v3.crossVectors(v1, v2);
    if (norm) {
        v3.normalize();
    }
    return v3;
}
function vectorFromPointsAtoB(a, b) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    var v = subVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(b.getPosition()))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(a.getPosition()))))());
    if (norm) {
        v.normalize();
    }
    return v;
}
function vectorFromVerticesAtoB(a, b) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    var v = subVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(b.getPoint().getPosition()))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(a.getPoint().getPosition()))))());
    if (norm) {
        v.normalize();
    }
    return v;
}
//  XYZ ===========================================================================================================
function subXYZs(xyz1, xyz2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    return subVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz1))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz2))))(), norm).toArray().slice(0, 3);
}
function addXYZs(xyz1, xyz2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    return addVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz1))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz2))))(), norm).toArray().slice(0, 3);
}
function crossXYZs(xyz1, xyz2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    return crossVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz1))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz2))))(), norm).toArray().slice(0, 3);
}
function normalizeXYZ(xyz) {
    return new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz))))().normalize().toArray().slice(0, 3);
}
function lengthXYZ(xyz) {
    return new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz))))().length();
}
function setLengthXYZ(xyz, length) {
    return new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz))))().setLength(length).toArray();
}
function makeXYZOrthogonal(xyz1, xyz2, normalize) {
    // create normalised vectors
    var vec_x = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz1))))();
    var len = vec_x.length();
    if (len < EPS) {
        return null;
    }
    vec_x.normalize();
    var vec2 = new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(xyz2))))().normalize();
    // check if vec1 and vec2 are parallel
    var abs_dot = Math.abs(vec_x.dot(vec2));
    if (1 - abs_dot < EPS) {
        return null;
    }
    // make vec_z
    var vec_z = new three.Vector3();
    vec_z.crossVectors(vec_x, vec2);
    // make vec_y
    var vec_y = new three.Vector3();
    vec_y.crossVectors(vec_z, vec_x);
    // return
    if (normalize) {
        return [vec_x.toArray(), vec_y.toArray(), vec_z.toArray()];
    } else {
        return [xyz1, vec_y.setLength(len).toArray(), vec_z.toArray()];
    }
}
//  Points ========================================================================================================
function subPoints(p1, p2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    return subVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p1.getPosition()))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p2.getPosition()))))(), norm).toArray().slice(0, 3);
}
function addPoints(p1, p2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    return addVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p1.getPosition()))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(p2.getPosition()))))(), norm).toArray().slice(0, 3);
}
//  Vertices ======================================================================================================
function subVertices(v1, v2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    return subVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(v1.getPoint().getPosition()))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(v2.getPoint().getPosition()))))(), norm).toArray().slice(0, 3);
}
function addVertices(v1, v2) {
    var norm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

    return addVectors(new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(v1.getPoint().getPosition()))))(), new (Function.prototype.bind.apply(three.Vector3, [null].concat(_toConsumableArray(v2.getPoint().getPosition()))))(), norm).toArray().slice(0, 3);
}
//# sourceMappingURL=threex.js.map