/**
|
* @author mrdoob / http://mrdoob.com/
|
* @author supereggbert / http://www.paulbrunt.co.uk/
|
* @author julianwa / https://github.com/julianwa
|
*/
|
|
THREE.RenderableObject = function () {
|
|
this.id = 0;
|
|
this.object = null;
|
this.z = 0;
|
this.renderOrder = 0;
|
|
};
|
|
//
|
|
THREE.RenderableFace = function () {
|
|
this.id = 0;
|
|
this.v1 = new THREE.RenderableVertex();
|
this.v2 = new THREE.RenderableVertex();
|
this.v3 = new THREE.RenderableVertex();
|
|
this.normalModel = new THREE.Vector3();
|
|
this.vertexNormalsModel = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
|
this.vertexNormalsLength = 0;
|
|
this.color = new THREE.Color();
|
this.material = null;
|
this.uvs = [new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2()];
|
|
this.z = 0;
|
this.renderOrder = 0;
|
|
};
|
|
//
|
|
THREE.RenderableVertex = function () {
|
|
this.position = new THREE.Vector3();
|
this.positionWorld = new THREE.Vector3();
|
this.positionScreen = new THREE.Vector4();
|
|
this.visible = true;
|
|
};
|
|
THREE.RenderableVertex.prototype.copy = function (vertex) {
|
|
this.positionWorld.copy(vertex.positionWorld);
|
this.positionScreen.copy(vertex.positionScreen);
|
|
};
|
|
//
|
|
THREE.RenderableLine = function () {
|
|
this.id = 0;
|
|
this.v1 = new THREE.RenderableVertex();
|
this.v2 = new THREE.RenderableVertex();
|
|
this.vertexColors = [new THREE.Color(), new THREE.Color()];
|
this.material = null;
|
|
this.z = 0;
|
this.renderOrder = 0;
|
|
};
|
|
//
|
|
THREE.RenderableSprite = function () {
|
|
this.id = 0;
|
|
this.object = null;
|
|
this.x = 0;
|
this.y = 0;
|
this.z = 0;
|
|
this.rotation = 0;
|
this.scale = new THREE.Vector2();
|
|
this.material = null;
|
this.renderOrder = 0;
|
|
};
|
|
//
|
|
THREE.Projector = function () {
|
|
var _object, _objectCount, _objectPool = [], _objectPoolLength = 0,
|
_vertex, _vertexCount, _vertexPool = [], _vertexPoolLength = 0,
|
_face, _faceCount, _facePool = [], _facePoolLength = 0,
|
_line, _lineCount, _linePool = [], _linePoolLength = 0,
|
_sprite, _spriteCount, _spritePool = [], _spritePoolLength = 0,
|
|
_renderData = { objects: [], lights: [], elements: [] },
|
|
_vector3 = new THREE.Vector3(),
|
_vector4 = new THREE.Vector4(),
|
|
_clipBox = new THREE.Box3(new THREE.Vector3(-1, -1, -1), new THREE.Vector3(1, 1, 1)),
|
_boundingBox = new THREE.Box3(),
|
_points3 = new Array(3),
|
|
_viewMatrix = new THREE.Matrix4(),
|
_viewProjectionMatrix = new THREE.Matrix4(),
|
|
_modelMatrix,
|
_modelViewProjectionMatrix = new THREE.Matrix4(),
|
|
_normalMatrix = new THREE.Matrix3(),
|
|
_frustum = new THREE.Frustum(),
|
|
_clippedVertex1PositionScreen = new THREE.Vector4(),
|
_clippedVertex2PositionScreen = new THREE.Vector4();
|
|
//
|
|
this.projectVector = function (vector, camera) {
|
|
console.warn('THREE.Projector: .projectVector() is now vector.project().');
|
vector.project(camera);
|
|
};
|
|
this.unprojectVector = function (vector, camera) {
|
|
console.warn('THREE.Projector: .unprojectVector() is now vector.unproject().');
|
vector.unproject(camera);
|
|
};
|
|
this.pickingRay = function () {
|
|
console.error('THREE.Projector: .pickingRay() is now raycaster.setFromCamera().');
|
|
};
|
|
//
|
|
var RenderList = function () {
|
|
var normals = [];
|
var colors = [];
|
var uvs = [];
|
|
var object = null;
|
var material = null;
|
|
var normalMatrix = new THREE.Matrix3();
|
|
function setObject(value) {
|
|
object = value;
|
material = object.material;
|
|
normalMatrix.getNormalMatrix(object.matrixWorld);
|
|
normals.length = 0;
|
colors.length = 0;
|
uvs.length = 0;
|
|
}
|
|
function projectVertex(vertex) {
|
|
var position = vertex.position;
|
var positionWorld = vertex.positionWorld;
|
var positionScreen = vertex.positionScreen;
|
|
positionWorld.copy(position).applyMatrix4(_modelMatrix);
|
positionScreen.copy(positionWorld).applyMatrix4(_viewProjectionMatrix);
|
|
var invW = 1 / positionScreen.w;
|
|
positionScreen.x *= invW;
|
positionScreen.y *= invW;
|
positionScreen.z *= invW;
|
|
vertex.visible = positionScreen.x >= -1 && positionScreen.x <= 1 &&
|
positionScreen.y >= -1 && positionScreen.y <= 1 &&
|
positionScreen.z >= -1 && positionScreen.z <= 1;
|
|
}
|
|
function pushVertex(x, y, z) {
|
|
_vertex = getNextVertexInPool();
|
_vertex.position.set(x, y, z);
|
|
projectVertex(_vertex);
|
|
}
|
|
function pushNormal(x, y, z) {
|
|
normals.push(x, y, z);
|
|
}
|
|
function pushColor(r, g, b) {
|
|
colors.push(r, g, b);
|
|
}
|
|
function pushUv(x, y) {
|
|
uvs.push(x, y);
|
|
}
|
|
function checkTriangleVisibility(v1, v2, v3) {
|
|
if (v1.visible === true || v2.visible === true || v3.visible === true) return true;
|
|
_points3[0] = v1.positionScreen;
|
_points3[1] = v2.positionScreen;
|
_points3[2] = v3.positionScreen;
|
|
return _clipBox.intersectsBox(_boundingBox.setFromPoints(_points3));
|
|
}
|
|
function checkBackfaceCulling(v1, v2, v3) {
|
|
return ((v3.positionScreen.x - v1.positionScreen.x) *
|
(v2.positionScreen.y - v1.positionScreen.y) -
|
(v3.positionScreen.y - v1.positionScreen.y) *
|
(v2.positionScreen.x - v1.positionScreen.x)) < 0;
|
|
}
|
|
function pushLine(a, b) {
|
|
var v1 = _vertexPool[a];
|
var v2 = _vertexPool[b];
|
|
// Clip
|
|
v1.positionScreen.copy(v1.position).applyMatrix4(_modelViewProjectionMatrix);
|
v2.positionScreen.copy(v2.position).applyMatrix4(_modelViewProjectionMatrix);
|
|
if (clipLine(v1.positionScreen, v2.positionScreen) === true) {
|
|
// Perform the perspective divide
|
v1.positionScreen.multiplyScalar(1 / v1.positionScreen.w);
|
v2.positionScreen.multiplyScalar(1 / v2.positionScreen.w);
|
|
_line = getNextLineInPool();
|
_line.id = object.id;
|
_line.v1.copy(v1);
|
_line.v2.copy(v2);
|
_line.z = Math.max(v1.positionScreen.z, v2.positionScreen.z);
|
_line.renderOrder = object.renderOrder;
|
|
_line.material = object.material;
|
|
if (object.material.vertexColors === THREE.VertexColors) {
|
|
_line.vertexColors[0].fromArray(colors, a * 3);
|
_line.vertexColors[1].fromArray(colors, b * 3);
|
|
}
|
|
_renderData.elements.push(_line);
|
|
}
|
|
}
|
|
function pushTriangle(a, b, c) {
|
|
var v1 = _vertexPool[a];
|
var v2 = _vertexPool[b];
|
var v3 = _vertexPool[c];
|
|
if (checkTriangleVisibility(v1, v2, v3) === false) return;
|
|
if (material.side === THREE.DoubleSide || checkBackfaceCulling(v1, v2, v3) === true) {
|
|
_face = getNextFaceInPool();
|
|
_face.id = object.id;
|
_face.v1.copy(v1);
|
_face.v2.copy(v2);
|
_face.v3.copy(v3);
|
_face.z = (v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z) / 3;
|
_face.renderOrder = object.renderOrder;
|
|
// use first vertex normal as face normal
|
|
_face.normalModel.fromArray(normals, a * 3);
|
_face.normalModel.applyMatrix3(normalMatrix).normalize();
|
|
for (var i = 0; i < 3; i++) {
|
|
var normal = _face.vertexNormalsModel[i];
|
normal.fromArray(normals, arguments[i] * 3);
|
normal.applyMatrix3(normalMatrix).normalize();
|
|
var uv = _face.uvs[i];
|
uv.fromArray(uvs, arguments[i] * 2);
|
|
}
|
|
_face.vertexNormalsLength = 3;
|
|
_face.material = object.material;
|
|
_renderData.elements.push(_face);
|
|
}
|
|
}
|
|
return {
|
setObject: setObject,
|
projectVertex: projectVertex,
|
checkTriangleVisibility: checkTriangleVisibility,
|
checkBackfaceCulling: checkBackfaceCulling,
|
pushVertex: pushVertex,
|
pushNormal: pushNormal,
|
pushColor: pushColor,
|
pushUv: pushUv,
|
pushLine: pushLine,
|
pushTriangle: pushTriangle
|
};
|
|
};
|
|
var renderList = new RenderList();
|
|
function projectObject(object) {
|
|
if (object.visible === false) return;
|
|
if (object instanceof THREE.Light) {
|
|
_renderData.lights.push(object);
|
|
} else if (object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points) {
|
|
if (object.material.visible === false) return;
|
if (object.frustumCulled === true && _frustum.intersectsObject(object) === false) return;
|
|
addObject(object);
|
|
} else if (object instanceof THREE.Sprite) {
|
|
if (object.material.visible === false) return;
|
if (object.frustumCulled === true && _frustum.intersectsSprite(object) === false) return;
|
|
addObject(object);
|
|
}
|
|
var children = object.children;
|
|
for (var i = 0, l = children.length; i < l; i++) {
|
|
projectObject(children[i]);
|
|
}
|
|
}
|
|
function addObject(object) {
|
|
_object = getNextObjectInPool();
|
_object.id = object.id;
|
_object.object = object;
|
|
_vector3.setFromMatrixPosition(object.matrixWorld);
|
_vector3.applyMatrix4(_viewProjectionMatrix);
|
_object.z = _vector3.z;
|
_object.renderOrder = object.renderOrder;
|
|
_renderData.objects.push(_object);
|
|
}
|
|
this.projectScene = function (scene, camera, sortObjects, sortElements) {
|
|
_faceCount = 0;
|
_lineCount = 0;
|
_spriteCount = 0;
|
|
_renderData.elements.length = 0;
|
|
if (scene.autoUpdate === true) scene.updateMatrixWorld();
|
if (camera.parent === null) camera.updateMatrixWorld();
|
|
_viewMatrix.copy(camera.matrixWorldInverse);
|
_viewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, _viewMatrix);
|
|
_frustum.setFromMatrix(_viewProjectionMatrix);
|
|
//
|
|
_objectCount = 0;
|
|
_renderData.objects.length = 0;
|
_renderData.lights.length = 0;
|
|
projectObject(scene);
|
|
if (sortObjects === true) {
|
|
_renderData.objects.sort(painterSort);
|
|
}
|
|
//
|
|
var objects = _renderData.objects;
|
|
for (var o = 0, ol = objects.length; o < ol; o++) {
|
|
var object = objects[o].object;
|
var geometry = object.geometry;
|
|
renderList.setObject(object);
|
|
_modelMatrix = object.matrixWorld;
|
|
_vertexCount = 0;
|
|
if (object instanceof THREE.Mesh) {
|
|
if (geometry instanceof THREE.BufferGeometry) {
|
|
var attributes = geometry.attributes;
|
var groups = geometry.groups;
|
|
if (attributes.position === undefined) continue;
|
|
var positions = attributes.position.array;
|
|
for (var i = 0, l = positions.length; i < l; i += 3) {
|
|
renderList.pushVertex(positions[i], positions[i + 1], positions[i + 2]);
|
|
}
|
|
if (attributes.normal !== undefined) {
|
|
var normals = attributes.normal.array;
|
|
for (var i = 0, l = normals.length; i < l; i += 3) {
|
|
renderList.pushNormal(normals[i], normals[i + 1], normals[i + 2]);
|
|
}
|
|
}
|
|
if (attributes.uv !== undefined) {
|
|
var uvs = attributes.uv.array;
|
|
for (var i = 0, l = uvs.length; i < l; i += 2) {
|
|
renderList.pushUv(uvs[i], uvs[i + 1]);
|
|
}
|
|
}
|
|
if (geometry.index !== null) {
|
|
var indices = geometry.index.array;
|
|
if (groups.length > 0) {
|
|
for (var g = 0; g < groups.length; g++) {
|
|
var group = groups[g];
|
|
for (var i = group.start, l = group.start + group.count; i < l; i += 3) {
|
|
renderList.pushTriangle(indices[i], indices[i + 1], indices[i + 2]);
|
|
}
|
|
}
|
|
} else {
|
|
for (var i = 0, l = indices.length; i < l; i += 3) {
|
|
renderList.pushTriangle(indices[i], indices[i + 1], indices[i + 2]);
|
|
}
|
|
}
|
|
} else {
|
|
for (var i = 0, l = positions.length / 3; i < l; i += 3) {
|
|
renderList.pushTriangle(i, i + 1, i + 2);
|
|
}
|
|
}
|
|
} else if (geometry instanceof THREE.Geometry) {
|
|
var vertices = geometry.vertices;
|
var faces = geometry.faces;
|
var faceVertexUvs = geometry.faceVertexUvs[0];
|
|
_normalMatrix.getNormalMatrix(_modelMatrix);
|
|
var material = object.material;
|
|
var isMultiMaterial = Array.isArray(material);
|
|
for (var v = 0, vl = vertices.length; v < vl; v++) {
|
|
var vertex = vertices[v];
|
|
_vector3.copy(vertex);
|
|
if (material.morphTargets === true) {
|
|
var morphTargets = geometry.morphTargets;
|
var morphInfluences = object.morphTargetInfluences;
|
|
for (var t = 0, tl = morphTargets.length; t < tl; t++) {
|
|
var influence = morphInfluences[t];
|
|
if (influence === 0) continue;
|
|
var target = morphTargets[t];
|
var targetVertex = target.vertices[v];
|
|
_vector3.x += (targetVertex.x - vertex.x) * influence;
|
_vector3.y += (targetVertex.y - vertex.y) * influence;
|
_vector3.z += (targetVertex.z - vertex.z) * influence;
|
|
}
|
|
}
|
|
renderList.pushVertex(_vector3.x, _vector3.y, _vector3.z);
|
|
}
|
|
for (var f = 0, fl = faces.length; f < fl; f++) {
|
|
var face = faces[f];
|
|
material = isMultiMaterial === true
|
? object.material[face.materialIndex]
|
: object.material;
|
|
if (material === undefined) continue;
|
|
var side = material.side;
|
|
var v1 = _vertexPool[face.a];
|
var v2 = _vertexPool[face.b];
|
var v3 = _vertexPool[face.c];
|
|
if (renderList.checkTriangleVisibility(v1, v2, v3) === false) continue;
|
|
var visible = renderList.checkBackfaceCulling(v1, v2, v3);
|
|
if (side !== THREE.DoubleSide) {
|
|
if (side === THREE.FrontSide && visible === false) continue;
|
if (side === THREE.BackSide && visible === true) continue;
|
|
}
|
|
_face = getNextFaceInPool();
|
|
_face.id = object.id;
|
_face.v1.copy(v1);
|
_face.v2.copy(v2);
|
_face.v3.copy(v3);
|
|
_face.normalModel.copy(face.normal);
|
|
if (visible === false && (side === THREE.BackSide || side === THREE.DoubleSide)) {
|
|
_face.normalModel.negate();
|
|
}
|
|
_face.normalModel.applyMatrix3(_normalMatrix).normalize();
|
|
var faceVertexNormals = face.vertexNormals;
|
|
for (var n = 0, nl = Math.min(faceVertexNormals.length, 3) ; n < nl; n++) {
|
|
var normalModel = _face.vertexNormalsModel[n];
|
normalModel.copy(faceVertexNormals[n]);
|
|
if (visible === false && (side === THREE.BackSide || side === THREE.DoubleSide)) {
|
|
normalModel.negate();
|
|
}
|
|
normalModel.applyMatrix3(_normalMatrix).normalize();
|
|
}
|
|
_face.vertexNormalsLength = faceVertexNormals.length;
|
|
var vertexUvs = faceVertexUvs[f];
|
|
if (vertexUvs !== undefined) {
|
|
for (var u = 0; u < 3; u++) {
|
|
_face.uvs[u].copy(vertexUvs[u]);
|
|
}
|
|
}
|
|
_face.color = face.color;
|
_face.material = material;
|
|
_face.z = (v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z) / 3;
|
_face.renderOrder = object.renderOrder;
|
|
_renderData.elements.push(_face);
|
|
}
|
|
}
|
|
} else if (object instanceof THREE.Line) {
|
|
_modelViewProjectionMatrix.multiplyMatrices(_viewProjectionMatrix, _modelMatrix);
|
|
if (geometry instanceof THREE.BufferGeometry) {
|
|
var attributes = geometry.attributes;
|
|
if (attributes.position !== undefined) {
|
|
var positions = attributes.position.array;
|
|
for (var i = 0, l = positions.length; i < l; i += 3) {
|
|
renderList.pushVertex(positions[i], positions[i + 1], positions[i + 2]);
|
|
}
|
|
if (attributes.color !== undefined) {
|
|
var colors = attributes.color.array;
|
|
for (var i = 0, l = colors.length; i < l; i += 3) {
|
|
renderList.pushColor(colors[i], colors[i + 1], colors[i + 2]);
|
|
}
|
|
}
|
|
if (geometry.index !== null) {
|
|
var indices = geometry.index.array;
|
|
for (var i = 0, l = indices.length; i < l; i += 2) {
|
|
renderList.pushLine(indices[i], indices[i + 1]);
|
|
}
|
|
} else {
|
|
var step = object instanceof THREE.LineSegments ? 2 : 1;
|
|
for (var i = 0, l = (positions.length / 3) - 1; i < l; i += step) {
|
|
renderList.pushLine(i, i + 1);
|
|
}
|
|
}
|
|
}
|
|
} else if (geometry instanceof THREE.Geometry) {
|
|
var vertices = object.geometry.vertices;
|
|
if (vertices.length === 0) continue;
|
|
v1 = getNextVertexInPool();
|
v1.positionScreen.copy(vertices[0]).applyMatrix4(_modelViewProjectionMatrix);
|
|
var step = object instanceof THREE.LineSegments ? 2 : 1;
|
|
for (var v = 1, vl = vertices.length; v < vl; v++) {
|
|
v1 = getNextVertexInPool();
|
v1.positionScreen.copy(vertices[v]).applyMatrix4(_modelViewProjectionMatrix);
|
|
if ((v + 1) % step > 0) continue;
|
|
v2 = _vertexPool[_vertexCount - 2];
|
|
_clippedVertex1PositionScreen.copy(v1.positionScreen);
|
_clippedVertex2PositionScreen.copy(v2.positionScreen);
|
|
if (clipLine(_clippedVertex1PositionScreen, _clippedVertex2PositionScreen) === true) {
|
|
// Perform the perspective divide
|
_clippedVertex1PositionScreen.multiplyScalar(1 / _clippedVertex1PositionScreen.w);
|
_clippedVertex2PositionScreen.multiplyScalar(1 / _clippedVertex2PositionScreen.w);
|
|
_line = getNextLineInPool();
|
|
_line.id = object.id;
|
_line.v1.positionScreen.copy(_clippedVertex1PositionScreen);
|
_line.v2.positionScreen.copy(_clippedVertex2PositionScreen);
|
|
_line.z = Math.max(_clippedVertex1PositionScreen.z, _clippedVertex2PositionScreen.z);
|
_line.renderOrder = object.renderOrder;
|
|
_line.material = object.material;
|
|
if (object.material.vertexColors === THREE.VertexColors) {
|
|
_line.vertexColors[0].copy(object.geometry.colors[v]);
|
_line.vertexColors[1].copy(object.geometry.colors[v - 1]);
|
|
}
|
|
_renderData.elements.push(_line);
|
|
}
|
|
}
|
|
}
|
|
} else if (object instanceof THREE.Points) {
|
|
_modelViewProjectionMatrix.multiplyMatrices(_viewProjectionMatrix, _modelMatrix);
|
|
if (geometry instanceof THREE.Geometry) {
|
|
var vertices = object.geometry.vertices;
|
|
for (var v = 0, vl = vertices.length; v < vl; v++) {
|
|
var vertex = vertices[v];
|
|
_vector4.set(vertex.x, vertex.y, vertex.z, 1);
|
_vector4.applyMatrix4(_modelViewProjectionMatrix);
|
|
pushPoint(_vector4, object, camera);
|
|
}
|
|
} else if (geometry instanceof THREE.BufferGeometry) {
|
|
var attributes = geometry.attributes;
|
|
if (attributes.position !== undefined) {
|
|
var positions = attributes.position.array;
|
|
for (var i = 0, l = positions.length; i < l; i += 3) {
|
|
_vector4.set(positions[i], positions[i + 1], positions[i + 2], 1);
|
_vector4.applyMatrix4(_modelViewProjectionMatrix);
|
|
pushPoint(_vector4, object, camera);
|
|
}
|
|
}
|
|
}
|
|
} else if (object instanceof THREE.Sprite) {
|
|
_vector4.set(_modelMatrix.elements[12], _modelMatrix.elements[13], _modelMatrix.elements[14], 1);
|
_vector4.applyMatrix4(_viewProjectionMatrix);
|
|
pushPoint(_vector4, object, camera);
|
|
}
|
|
}
|
|
if (sortElements === true) {
|
|
_renderData.elements.sort(painterSort);
|
|
}
|
|
return _renderData;
|
|
};
|
|
function pushPoint(_vector4, object, camera) {
|
|
var invW = 1 / _vector4.w;
|
|
_vector4.z *= invW;
|
|
if (_vector4.z >= -1 && _vector4.z <= 1) {
|
|
_sprite = getNextSpriteInPool();
|
_sprite.id = object.id;
|
_sprite.x = _vector4.x * invW;
|
_sprite.y = _vector4.y * invW;
|
_sprite.z = _vector4.z;
|
_sprite.renderOrder = object.renderOrder;
|
_sprite.object = object;
|
|
_sprite.rotation = object.rotation;
|
|
_sprite.scale.x = object.scale.x * Math.abs(_sprite.x - (_vector4.x + camera.projectionMatrix.elements[0]) / (_vector4.w + camera.projectionMatrix.elements[12]));
|
_sprite.scale.y = object.scale.y * Math.abs(_sprite.y - (_vector4.y + camera.projectionMatrix.elements[5]) / (_vector4.w + camera.projectionMatrix.elements[13]));
|
|
_sprite.material = object.material;
|
|
_renderData.elements.push(_sprite);
|
|
}
|
|
}
|
|
// Pools
|
|
function getNextObjectInPool() {
|
|
if (_objectCount === _objectPoolLength) {
|
|
var object = new THREE.RenderableObject();
|
_objectPool.push(object);
|
_objectPoolLength++;
|
_objectCount++;
|
return object;
|
|
}
|
|
return _objectPool[_objectCount++];
|
|
}
|
|
function getNextVertexInPool() {
|
|
if (_vertexCount === _vertexPoolLength) {
|
|
var vertex = new THREE.RenderableVertex();
|
_vertexPool.push(vertex);
|
_vertexPoolLength++;
|
_vertexCount++;
|
return vertex;
|
|
}
|
|
return _vertexPool[_vertexCount++];
|
|
}
|
|
function getNextFaceInPool() {
|
|
if (_faceCount === _facePoolLength) {
|
|
var face = new THREE.RenderableFace();
|
_facePool.push(face);
|
_facePoolLength++;
|
_faceCount++;
|
return face;
|
|
}
|
|
return _facePool[_faceCount++];
|
|
|
}
|
|
function getNextLineInPool() {
|
|
if (_lineCount === _linePoolLength) {
|
|
var line = new THREE.RenderableLine();
|
_linePool.push(line);
|
_linePoolLength++;
|
_lineCount++;
|
return line;
|
|
}
|
|
return _linePool[_lineCount++];
|
|
}
|
|
function getNextSpriteInPool() {
|
|
if (_spriteCount === _spritePoolLength) {
|
|
var sprite = new THREE.RenderableSprite();
|
_spritePool.push(sprite);
|
_spritePoolLength++;
|
_spriteCount++;
|
return sprite;
|
|
}
|
|
return _spritePool[_spriteCount++];
|
|
}
|
|
//
|
|
function painterSort(a, b) {
|
|
if (a.renderOrder !== b.renderOrder) {
|
|
return a.renderOrder - b.renderOrder;
|
|
} else if (a.z !== b.z) {
|
|
return b.z - a.z;
|
|
} else if (a.id !== b.id) {
|
|
return a.id - b.id;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
function clipLine(s1, s2) {
|
|
var alpha1 = 0, alpha2 = 1,
|
|
// Calculate the boundary coordinate of each vertex for the near and far clip planes,
|
// Z = -1 and Z = +1, respectively.
|
|
bc1near = s1.z + s1.w,
|
bc2near = s2.z + s2.w,
|
bc1far = -s1.z + s1.w,
|
bc2far = -s2.z + s2.w;
|
|
if (bc1near >= 0 && bc2near >= 0 && bc1far >= 0 && bc2far >= 0) {
|
|
// Both vertices lie entirely within all clip planes.
|
return true;
|
|
} else if ((bc1near < 0 && bc2near < 0) || (bc1far < 0 && bc2far < 0)) {
|
|
// Both vertices lie entirely outside one of the clip planes.
|
return false;
|
|
} else {
|
|
// The line segment spans at least one clip plane.
|
|
if (bc1near < 0) {
|
|
// v1 lies outside the near plane, v2 inside
|
alpha1 = Math.max(alpha1, bc1near / (bc1near - bc2near));
|
|
} else if (bc2near < 0) {
|
|
// v2 lies outside the near plane, v1 inside
|
alpha2 = Math.min(alpha2, bc1near / (bc1near - bc2near));
|
|
}
|
|
if (bc1far < 0) {
|
|
// v1 lies outside the far plane, v2 inside
|
alpha1 = Math.max(alpha1, bc1far / (bc1far - bc2far));
|
|
} else if (bc2far < 0) {
|
|
// v2 lies outside the far plane, v2 inside
|
alpha2 = Math.min(alpha2, bc1far / (bc1far - bc2far));
|
|
}
|
|
if (alpha2 < alpha1) {
|
|
// The line segment spans two boundaries, but is outside both of them.
|
// (This can't happen when we're only clipping against just near/far but good
|
// to leave the check here for future usage if other clip planes are added.)
|
return false;
|
|
} else {
|
|
// Update the s1 and s2 vertices to match the clipped line segment.
|
s1.lerp(s2, alpha1);
|
s2.lerp(s1, 1 - alpha2);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
};
|
