threejs 使用ThreeBSP库进行Three.js网格组合 (源码)

[code]import * as THREE from 'three';
let BACK;
let COPLANAR;
let EPSILON;
let FRONT;
let SPANNING;
let Timelimit;
let returning;
let bind = function(fn, me) {
return function() {
return fn.apply(me, arguments);
};
};
let slice = [].slice;
let extend = function(child, parent) {
for (let key in parent) {
if (hasProp.call(parent, key)) {
child[key] = parent[key];
}
}
function Ctor() {
this.constructor = child;
}
Ctor.prototype = parent.prototype;
child.prototype = new Ctor();
child.__super__ = parent.prototype;
return child;
};
let hasProp = {}.hasOwnProperty;
EPSILON = 1e-5;
COPLANAR = 0;
FRONT = 1;
BACK = 2;
SPANNING = 3;
returning = function(value, fn) {
fn();
return value;
};
Timelimit = (function() {
function Timelimit(timeout, progress) {
this.timeout = timeout;
this.progress = progress;
this.doTask = bind(this.doTask, this);
this.finish = bind(this.finish, this);
this.start = bind(this.start, this);
this.check = bind(this.check, this);
}
Timelimit.prototype.check = function() {
let elapsed;
if (this.started == null) {
return;
}
return returning((elapsed = Date.now() - this.started), (function(_this) {
return function() {
let ref, ref1, ref2;
if ((ref = elapsed >= _this.timeout) != null ? ref : 2e308) {
throw new Error('Timeout reached: ' + elapsed + '/' + _this.timeout + ', ' + ((ref1 = _this.tasks) != null ? ref1 : 0) + ' tasks unfinished ' + ((ref2 = _this.done) != null ? ref2 : 0) + ' finished.');
}
};
})(this));
};
Timelimit.prototype.start = function() {
if (this.started == null) {
this.started = Date.now();
}
if (this.tasks == null) {
this.tasks = 0;
}
if (this.total == null) {
this.total = 0;
}
this.total += 1;
this.tasks += 1;
return this.check();
};
Timelimit.prototype.finish = function() {
let elapsed;
if ((this.tasks != null) && this.tasks < 1) {
throw new Error('Finished more tasks than started');
}
this.tasks -= 1;
elapsed = this.check();
if (this.done == null) {
this.done = 0;
}
this.done += 1;
if (this.progress != null) {
this.progress(this.done, this.total);
}
if (this.tasks === 0) {
// 'Finished ' + this.done + ' tasks in ' + elapsed + '/' + this.timeout + ' ms';
let result = this.started = this.done = this.total = void 0;
return result;
}
};
Timelimit.prototype.doTask = function(block) {
let result;
this.start();
result = block();
this.finish();
return result;
};
return Timelimit;
})();
function ThreeBSP(treeIsh, matrix1, options) {
let base;
let ref;
let ref1;
let ref2;
let ref3;
this.matrix = matrix1;
this.options = options != null ? options : {};
this.intersect = bind(this.intersect, this);
this.union = bind(this.union, this);
this.subtract = bind(this.subtract, this);
this.toGeometry = bind(this.toGeometry, this);
this.toMesh = bind(this.toMesh, this);
this.toTree = bind(this.toTree, this);
this.withTimer = bind(this.withTimer, this);
if ((this.matrix != null) && !(this.matrix instanceof THREE.Matrix4)) {
this.options = this.matrix;
this.matrix = void 0;
}
if (this.options == null) {
this.options = {};
}
if (this.matrix == null) {
this.matrix = new THREE.Matrix4();
}
if ((base = this.options).timer == null) {
base.timer = new Timelimit((ref = (ref1 = this.options.timer) != null ? ref1.timeout : void 0) != null ? ref : this.options.timeout, (ref2 = (ref3 = this.options.timer) != null ? ref3.progress : void 0) != null ? ref2 : this.options.progress);
}
if (treeIsh !== undefined) {
this.tree = this.toTree(treeIsh);
}
}
ThreeBSP.prototype.withTimer = function(newTimer, block) {
let oldTimer;
oldTimer = this.options.timer;
try {
this.options.timer = newTimer;
return block();
} finally {
this.options.timer = oldTimer;
}
};
ThreeBSP.prototype.toTree = function(treeIsh) {
let face, fn1, geometry, i, k, len, polygons, ref;
if (treeIsh instanceof ThreeBSP.Node) {
return treeIsh;
}
polygons = [];
geometry = treeIsh instanceof THREE.Geometry ? treeIsh : treeIsh instanceof THREE.Mesh ? (treeIsh.updateMatrix(), this.matrix = treeIsh.matrix.clone(), treeIsh.geometry) : void 0;
ref = geometry.faces;
fn1 = (function(_this) {
return function(face, i) {
let faceVertexUvs, idx, l, len1, polygon, ref1, ref2, vIndex, vName, vertex;
faceVertexUvs = (ref1 = geometry.faceVertexUvs) != null ? ref1[0][i] : void 0;
if (faceVertexUvs == null) {
faceVertexUvs = [new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2()];
}
polygon = new ThreeBSP.Polygon();
ref2 = ['a', 'b', 'c', 'd'];
for (vIndex = l = 0, len1 = ref2.length; l < len1; vIndex = ++l) {
vName = ref2[vIndex];
if ((idx = face[vName]) != null) {
vertex = geometry.vertices[idx];
vertex = new ThreeBSP.Vertex(vertex.x, vertex.y, vertex.z, face.vertexNormals[0], new THREE.Vector2(faceVertexUvs[vIndex].x, faceVertexUvs[vIndex].y));
vertex.applyMatrix4(_this.matrix);
polygon.vertices.push(vertex);
}
}
return polygons.push(polygon.calculateProperties());
};
})(this);
for (i = k = 0, len = ref.length; k < len; i = ++k) {
face = ref[i];
fn1(face, i);
}
return new ThreeBSP.Node(polygons, this.options);
};
ThreeBSP.prototype.toMesh = function(material) {
if (material == null) {
material = new THREE.MeshNormalMaterial();
}
return this.options.timer.doTask((function(_this) {
return function() {
let geometry;
let mesh;
geometry = _this.toGeometry();
return returning((mesh = new THREE.Mesh(geometry, material)), function() {
// mesh.position.getPositionFromMatrix(_this.matrix);
mesh.position.setFromMatrixPosition(_this.matrix);
return mesh.rotation.setFromRotationMatrix(_this.matrix);
});
};
})(this));
};
ThreeBSP.prototype.toGeometry = function() {
return this.options.timer.doTask((function(_this) {
return function() {
let geometry, matrix;
matrix = new THREE.Matrix4().getInverse(_this.matrix);
return returning((geometry = new THREE.Geometry()), function() {
let k, len, polygon, ref, results;
ref = _this.tree.allPolygons();
results = [];
for (k = 0, len = ref.length; k < len; k++) {
polygon = ref[k];
results.push(_this.options.timer.doTask(function() {
let face, idx, l, polyVerts, ref1, results1, v, vertUvs, verts;
polyVerts = (function() {
let l, len1, ref1, results1;
ref1 = polygon.vertices;
results1 = [];
for (l = 0, len1 = ref1.length; l < len1; l++) {
v = ref1[l];
results1.push(v.clone().applyMatrix4(matrix));
}
return results1;
})();
results1 = [];
for (idx = l = 2, ref1 = polyVerts.length; 2 <= ref1 ? l < ref1 : l > ref1; idx = 2 <= ref1 ? ++l : --l) {
verts = [polyVerts[0], polyVerts[idx - 1], polyVerts[idx]];
vertUvs = (function() {
let len1, m, ref2, ref3, results2;
results2 = [];
for (m = 0, len1 = verts.length; m < len1; m++) {
v = verts[m];
results2.push(new THREE.Vector2((ref2 = v.uv) != null ? ref2.x : void 0, (ref3 = v.uv) != null ? ref3.y : void 0));
}
return results2;
})();
face = (function(func, args, Ctor) {
Ctor.prototype = func.prototype;
let child = new Ctor;
let result = func.apply(child, args);
return Object(result) === result ? result : child;
})(THREE.Face3, slice.call((function() {
let len1, m, results2;
results2 = [];
for (m = 0, len1 = verts.length; m < len1; m++) {
v = verts[m];
results2.push(geometry.vertices.push(v) - 1);
}
return results2;
})()).concat([polygon.normal.clone()]), function(){});
geometry.faces.push(face);
results1.push(geometry.faceVertexUvs[0].push(vertUvs));
}
return results1;
}));
}
return results;
});
};
})(this));
};
ThreeBSP.prototype.subtract = function(other) {
return this.options.timer.doTask((function(_this) {
return function() {
return other.withTimer(_this.options.timer, function() {
let ref;
let them;
let us;
ref = [_this.tree.clone(), other.tree.clone()];
us = ref[0];
them = ref[1];
us.invert().clipTo(them);
them.clipTo(us).invert().clipTo(us).invert();
return new ThreeBSP(us.build(them.allPolygons()).invert(), _this.matrix, _this.options);
});
};
})(this));
};
ThreeBSP.prototype.union = function(other) {
return this.options.timer.doTask((function(_this) {
return function() {
return other.withTimer(_this.options.timer, function() {
let ref;
let them;
let us;
ref = [_this.tree.clone(), other.tree.clone()];
us = ref[0];
them = ref[1];
us.clipTo(them);
them.clipTo(us).invert().clipTo(us).invert();
return new ThreeBSP(us.build(them.allPolygons()), _this.matrix, _this.options);
});
};
})(this));
};
ThreeBSP.prototype.intersect = function(other) {
return this.options.timer.doTask((function(_this) {
return function() {
return other.withTimer(_this.options.timer, function() {
let ref;
let them;
let us;
ref = [_this.tree.clone(), other.tree.clone()];
us = ref[0];
them = ref[1];
them.clipTo(us.invert()).invert().clipTo(us.clipTo(them));
return new ThreeBSP(us.build(them.allPolygons()).invert(), _this.matrix, _this.options);
});
};
})(this));
};
ThreeBSP.Vertex = (function(superClass) {
extend(Vertex, superClass);
function Vertex(x, y, z, normal, uv) {
this.normal = normal != null ? normal : new THREE.Vector3();
this.uv = uv != null ? uv : new THREE.Vector2();
this.interpolate = bind(this.interpolate, this);
this.lerp = bind(this.lerp, this);
Vertex.__super__.constructor.call(this, x, y, z);
}
Vertex.prototype.clone = function() {
return new ThreeBSP.Vertex(this.x, this.y, this.z, this.normal.clone(), this.uv.clone());
};
Vertex.prototype.lerp = function(v, alpha) {
return returning(Vertex.__super__.lerp.apply(this, arguments), (function(_this) {
return function() {
_this.uv.add(v.uv.clone().sub(_this.uv).multiplyScalar(alpha));
return _this.normal.lerp(v, alpha);
};
})(this));
};
Vertex.prototype.interpolate = function() {
let args;
let ref;
args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
return (ref = this.clone()).lerp.apply(ref, args);
};
return Vertex;
})(THREE.Vector3);
ThreeBSP.Polygon = (function() {
function Polygon(vertices, normal, w) {
this.vertices = vertices != null ? vertices : [];
this.normal = normal;
this.w = w;
this.subdivide = bind(this.subdivide, this);
this.tessellate = bind(this.tessellate, this);
this.classifySide = bind(this.classifySide, this);
this.classifyVertex = bind(this.classifyVertex, this);
this.invert = bind(this.invert, this);
this.clone = bind(this.clone, this);
this.calculateProperties = bind(this.calculateProperties, this);
if (this.vertices.length) {
this.calculateProperties();
}
}
Polygon.prototype.calculateProperties = function() {
return returning(this, (function(_this) {
return function() {
let a;
let b;
let c;
let ref;
ref = _this.vertices;
a = ref[0];
b = ref[1];
c = ref[2];
_this.normal = b.clone().sub(a).cross(c.clone().sub(a)).normalize();
_this.w = _this.normal.clone().dot(a);
return _this.w;
};
})(this));
};
Polygon.prototype.clone = function() {
let v;
return new ThreeBSP.Polygon((function() {
let k;
let len;
let ref;
let results;
ref = this.vertices;
results = [];
for (k = 0, len = ref.length; k < len; k++) {
v = ref[k];
results.push(v.clone());
}
return results;
}).call(this), this.normal.clone(), this.w);
};
Polygon.prototype.invert = function() {
return returning(this, (function(_this) {
return function() {
_this.normal.multiplyScalar(-1);
_this.w *= -1;
return _this.vertices.reverse();
};
})(this));
};
Polygon.prototype.classifyVertex = function(vertex) {
let side;
side = this.normal.dot(vertex) - this.w;
switch (false) {
case !(side < -EPSILON):
return BACK;
case !(side > EPSILON):
return FRONT;
default:
return COPLANAR;
}
};
Polygon.prototype.classifySide = function(polygon) {
let back;
let front;
let k;
let len;
let ref;
let ref1;
let tally;
let v;
ref = [0, 0];
front = ref[0];
back = ref[1];
tally = (function(_this) {
return function(v) {
switch (_this.classifyVertex(v)) {
case FRONT:
let dataFront = front += 1;
return dataFront;
case BACK:
let dataBack = back += 1;
return dataBack;
}
};
})(this);
ref1 = polygon.vertices;
for (k = 0, len = ref1.length; k < len; k++) {
v = ref1[k];
tally(v);
}
if (front > 0 && back === 0) {
return FRONT;
}
if (front === 0 && back > 0) {
return BACK;
}
if ((front === back && back === 0)) {
return COPLANAR;
}
return SPANNING;
};
Polygon.prototype.tessellate = function(poly) {
let b;
let count;
let f;
let i;
let j;
let k;
let len;
let polys;
let ref;
let ref1;
let ref2;
let t;
let ti;
let tj;
let v;
let vi;
let vj;
ref = {
f: [],
b: [],
count: poly.vertices.length
};
f = ref.f;
b = ref.b;
count = ref.count;
if (this.classifySide(poly) !== SPANNING) {
return [poly];
}
ref1 = poly.vertices;
for (i = k = 0, len = ref1.length; k < len; i = ++k) {
vi = ref1[i];
vj = poly.vertices[(j = (i + 1) % count)];
ref2 = (function() {
let l;
let len1;
let ref2;
let results;
ref2 = [vi, vj];
results = [];
for (l = 0, len1 = ref2.length; l < len1; l++) {
v = ref2[l];
results.push(this.classifyVertex(v));
}
return results;
}).call(this);
ti = ref2[0];
tj = ref2[1];
if (ti !== BACK) {
f.push(vi);
}
if (ti !== FRONT) {
b.push(vi);
}
if ((ti | tj) === SPANNING) {
t = (this.w - this.normal.dot(vi)) / this.normal.dot(vj.clone().sub(vi));
v = vi.interpolate(vj, t);
f.push(v);
b.push(v);
}
}
return returning((polys = []), (function(_this) {
return function() {
if (f.length >= 3) {
polys.push(new ThreeBSP.Polygon(f));
}
if (b.length >= 3) {
return polys.push(new ThreeBSP.Polygon(b));
}
};
})(this));
};
Polygon.prototype.subdivide = function(polygon, coplanarFront, coplanarBack, front, back) {
let k;
let len;
let poly;
let ref;
let results;
let side;
ref = this.tessellate(polygon);
results = [];
for (k = 0, len = ref.length; k < len; k++) {
poly = ref[k];
side = this.classifySide(poly);
switch (side) {
case FRONT:
results.push(front.push(poly));
break;
case BACK:
results.push(back.push(poly));
break;
case COPLANAR:
if (this.normal.dot(poly.normal) > 0) {
results.push(coplanarFront.push(poly));
} else {
results.push(coplanarBack.push(poly));
}
break;
default:
throw new Error('BUG: Polygon of classification ' + side + ' in subdivision"');
}
}
return results;
};
return Polygon;
})();
ThreeBSP.Node = (function() {
Node.prototype.clone = function() {
let node;
return returning((node = new ThreeBSP.Node(this.options)), (function(_this) {
return function() {
let ref;
node.divider = (ref = _this.divider) != null ? ref.clone() : void 0;
node.polygons = _this.options.timer.doTask(function() {
let k, len, p, ref1, results;
ref1 = _this.polygons;
results = [];
for (k = 0, len = ref1.length; k < len; k++) {
p = ref1[k];
results.push(p.clone());
}
return results;
});
node.front = _this.options.timer.doTask(function() {
let ref1;
return (ref1 = _this.front) != null ? ref1.clone() : void 0;
});
node.back = _this.options.timer.doTask(function() {
let ref1;
return (ref1 = _this.back) != null ? ref1.clone() : void 0;
});
return node.back;
};
})(this));
};
function Node(polygons, options) {
this.options = options != null ? options : {};
this.clipTo = bind(this.clipTo, this);
this.clipPolygons = bind(this.clipPolygons, this);
this.invert = bind(this.invert, this);
this.allPolygons = bind(this.allPolygons, this);
this.isConvex = bind(this.isConvex, this);
this.build = bind(this.build, this);
this.clone = bind(this.clone, this);
if ((polygons != null) && !(polygons instanceof Array)) {
this.options = polygons;
polygons = void 0;
}
this.polygons = [];
this.options.timer.doTask((function(_this) {
return function() {
if ((polygons != null) && polygons.length) {
return _this.build(polygons);
}
};
})(this));
}
Node.prototype.build = function(polygons) {
return returning(this, (function(_this) {
return function() {
let polys, results, side, sides;
sides = {
front: [],
back: []
};
if (_this.divider == null) {
_this.divider = polygons[0].clone();
}
_this.options.timer.doTask(function() {
let k, len, poly, results;
results = [];
for (k = 0, len = polygons.length; k < len; k++) {
poly = polygons[k];
results.push(_this.options.timer.doTask(function() {
return _this.divider.subdivide(poly, _this.polygons, _this.polygons, sides.front, sides.back);
}));
}
return results;
});
results = [];
for (side in sides) {
if (!hasProp.call(sides, side)) continue;
polys = sides[side];
if (polys.length) {
if (_this[side] == null) {
_this[side] = new ThreeBSP.Node(_this.options);
}
results.push(_this[side].build(polys));
} else {
results.push(void 0);
}
}
return results;
};
})(this));
};
Node.prototype.isConvex = function(polys) {
let inner, k, l, len, len1, outer;
for (k = 0, len = polys.length; k < len; k++) {
inner = polys[k];
for (l = 0, len1 = polys.length; l < len1; l++) {
outer = polys[l];
if (inner !== outer && outer.classifySide(inner) !== BACK) {
return false;
}
}
}
return true;
};
Node.prototype.allPolygons = function() {
return this.options.timer.doTask((function(_this) {
return function() {
var ref, ref1;
return _this.polygons.slice().concat(((ref1 = _this.front) != null ? ref1.allPolygons() : void 0) || []).concat(((ref = _this.back) != null ? ref.allPolygons() : void 0) || []);
};
})(this));
};
Node.prototype.invert = function() {
return returning(this, (function(_this) {
return function() {
return _this.options.timer.doTask(function() {
let flipper, k, l, len, len1, poly, ref, ref1, ref2;
ref = _this.polygons;
for (k = 0, len = ref.length; k < len; k++) {
poly = ref[k];
_this.options.timer.doTask(function() {
return poly.invert();
});
}
ref1 = [_this.divider, _this.front, _this.back];
for (l = 0, len1 = ref1.length; l < len1; l++) {
flipper = ref1[l];
_this.options.timer.doTask(function() {
return flipper != null ? flipper.invert() : void 0;
});
}
return ref2 = [_this.back, _this.front], _this.front = ref2[0], _this.back = ref2[1], ref2;
});
};
})(this));
};
Node.prototype.clipPolygons = function(polygons) {
return this.options.timer.doTask((function(_this) {
return function() {
let back, front, k, len, poly;
if (!_this.divider) {
return polygons.slice();
}
front = [];
back = [];
for (k = 0, len = polygons.length; k < len; k++) {
poly = polygons[k];
_this.options.timer.doTask(function() {
return _this.divider.subdivide(poly, front, back, front, back);
});
}
if (_this.front) {
front = _this.front.clipPolygons(front);
}
if (_this.back) {
back = _this.back.clipPolygons(back);
}
if (_this.back) {
return front.concat(back);
} else {
return front;
}
};
})(this));
};
Node.prototype.clipTo = function(node) {
return returning(this, (function(_this) {
return function() {
return _this.options.timer.doTask(function() {
let ref, ref1;
_this.polygons = node.clipPolygons(_this.polygons);
if ((ref = _this.front) != null) {
ref.clipTo(node);
}
return (ref1 = _this.back) != null ? ref1.clipTo(node) : void 0;
});
};
})(this));
};
return Node;
})();

export default ThreeBSP;