Created
April 19, 2023 23:22
-
-
Save pwillia7/f4c6bf43c97d57f6e0a7cb183f451386 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
var _____WB$wombat$assign$function_____ = function(name) {return (self._wb_wombat && self._wb_wombat.local_init && self._wb_wombat.local_init(name)) || self[name]; }; | |
if (!self.__WB_pmw) { self.__WB_pmw = function(obj) { this.__WB_source = obj; return this; } } | |
{ | |
let window = _____WB$wombat$assign$function_____("window"); | |
let self = _____WB$wombat$assign$function_____("self"); | |
let document = _____WB$wombat$assign$function_____("document"); | |
let location = _____WB$wombat$assign$function_____("location"); | |
let top = _____WB$wombat$assign$function_____("top"); | |
let parent = _____WB$wombat$assign$function_____("parent"); | |
let frames = _____WB$wombat$assign$function_____("frames"); | |
let opener = _____WB$wombat$assign$function_____("opener"); | |
/** | |
* @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; | |
} | |
} | |
} | |
}; | |
} | |
/* | |
FILE ARCHIVED ON 02:26:44 Jul 11, 2018 AND RETRIEVED FROM THE | |
INTERNET ARCHIVE ON 23:21:59 Apr 19, 2023. | |
JAVASCRIPT APPENDED BY WAYBACK MACHINE, COPYRIGHT INTERNET ARCHIVE. | |
ALL OTHER CONTENT MAY ALSO BE PROTECTED BY COPYRIGHT (17 U.S.C. | |
SECTION 108(a)(3)). | |
*/ | |
/* | |
playback timings (ms): | |
captures_list: 138.609 | |
exclusion.robots: 0.075 | |
exclusion.robots.policy: 0.065 | |
RedisCDXSource: 13.188 | |
esindex: 0.011 | |
LoadShardBlock: 107.184 (3) | |
PetaboxLoader3.datanode: 87.929 (4) | |
load_resource: 123.321 | |
PetaboxLoader3.resolve: 72.755 | |
*/ |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment