@loaders.gl/tiles 3.1.0-alpha.5 → 3.1.0-beta.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (84) hide show
  1. package/dist/bundle.d.ts +1 -0
  2. package/dist/bundle.d.ts.map +1 -0
  3. package/dist/bundle.js +8136 -0
  4. package/dist/constants.d.ts +1 -0
  5. package/dist/constants.d.ts.map +1 -0
  6. package/dist/constants.js +35 -0
  7. package/dist/es5/tileset/helpers/i3s-lod.js.map +1 -1
  8. package/dist/es5/tileset/tileset-cache.js.map +1 -1
  9. package/dist/es5/utils/doubly-linked-list-node.js +7 -0
  10. package/dist/es5/utils/doubly-linked-list-node.js.map +1 -1
  11. package/dist/es5/utils/doubly-linked-list.js +5 -3
  12. package/dist/es5/utils/doubly-linked-list.js.map +1 -1
  13. package/dist/es5/utils/managed-array.js +7 -1
  14. package/dist/es5/utils/managed-array.js.map +1 -1
  15. package/dist/esm/tileset/helpers/i3s-lod.js.map +1 -1
  16. package/dist/esm/tileset/tileset-cache.js.map +1 -1
  17. package/dist/esm/utils/doubly-linked-list-node.js +7 -0
  18. package/dist/esm/utils/doubly-linked-list-node.js.map +1 -1
  19. package/dist/esm/utils/doubly-linked-list.js +6 -3
  20. package/dist/esm/utils/doubly-linked-list.js.map +1 -1
  21. package/dist/esm/utils/managed-array.js +7 -1
  22. package/dist/esm/utils/managed-array.js.map +1 -1
  23. package/dist/index.d.ts +1 -0
  24. package/dist/index.d.ts.map +1 -0
  25. package/dist/index.js +28 -0
  26. package/dist/tileset/helpers/3d-tiles-options.d.ts +1 -0
  27. package/dist/tileset/helpers/3d-tiles-options.d.ts.map +1 -0
  28. package/dist/tileset/helpers/3d-tiles-options.js +9 -0
  29. package/dist/tileset/helpers/bounding-volume.d.ts +1 -0
  30. package/dist/tileset/helpers/bounding-volume.d.ts.map +1 -0
  31. package/dist/tileset/helpers/bounding-volume.js +177 -0
  32. package/dist/tileset/helpers/frame-state.d.ts +1 -0
  33. package/dist/tileset/helpers/frame-state.d.ts.map +1 -0
  34. package/dist/tileset/helpers/frame-state.js +70 -0
  35. package/dist/tileset/helpers/i3s-lod.d.ts +2 -1
  36. package/dist/tileset/helpers/i3s-lod.d.ts.map +1 -0
  37. package/dist/tileset/helpers/i3s-lod.js +83 -0
  38. package/dist/tileset/helpers/tiles-3d-lod.d.ts +1 -0
  39. package/dist/tileset/helpers/tiles-3d-lod.d.ts.map +1 -0
  40. package/dist/tileset/helpers/tiles-3d-lod.js +116 -0
  41. package/dist/tileset/helpers/transform-utils.d.ts +1 -0
  42. package/dist/tileset/helpers/transform-utils.d.ts.map +1 -0
  43. package/dist/tileset/helpers/transform-utils.js +52 -0
  44. package/dist/tileset/helpers/zoom.d.ts +1 -0
  45. package/dist/tileset/helpers/zoom.d.ts.map +1 -0
  46. package/dist/tileset/helpers/zoom.js +42 -0
  47. package/dist/tileset/tile-3d.d.ts +1 -0
  48. package/dist/tileset/tile-3d.d.ts.map +1 -0
  49. package/dist/tileset/tile-3d.js +554 -0
  50. package/dist/tileset/tileset-3d.d.ts +1 -0
  51. package/dist/tileset/tileset-3d.d.ts.map +1 -0
  52. package/dist/tileset/tileset-3d.js +601 -0
  53. package/dist/tileset/tileset-cache.d.ts +1 -0
  54. package/dist/tileset/tileset-cache.d.ts.map +1 -0
  55. package/dist/tileset/tileset-cache.js +79 -0
  56. package/dist/tileset/traversers/i3s-tile-manager.d.ts +1 -0
  57. package/dist/tileset/traversers/i3s-tile-manager.d.ts.map +1 -0
  58. package/dist/tileset/traversers/i3s-tile-manager.js +36 -0
  59. package/dist/tileset/traversers/i3s-tileset-traverser.d.ts +1 -0
  60. package/dist/tileset/traversers/i3s-tileset-traverser.d.ts.map +1 -0
  61. package/dist/tileset/traversers/i3s-tileset-traverser.js +85 -0
  62. package/dist/tileset/traversers/tileset-3d-traverser.d.ts +1 -0
  63. package/dist/tileset/traversers/tileset-3d-traverser.d.ts.map +1 -0
  64. package/dist/tileset/traversers/tileset-3d-traverser.js +55 -0
  65. package/dist/tileset/traversers/tileset-traverser.d.ts +1 -0
  66. package/dist/tileset/traversers/tileset-traverser.d.ts.map +1 -0
  67. package/dist/tileset/traversers/tileset-traverser.js +294 -0
  68. package/dist/utils/doubly-linked-list-node.d.ts +2 -1
  69. package/dist/utils/doubly-linked-list-node.d.ts.map +1 -0
  70. package/dist/utils/doubly-linked-list-node.js +17 -0
  71. package/dist/utils/doubly-linked-list.d.ts +7 -6
  72. package/dist/utils/doubly-linked-list.d.ts.map +1 -0
  73. package/dist/utils/doubly-linked-list.js +100 -0
  74. package/dist/utils/managed-array.d.ts +10 -9
  75. package/dist/utils/managed-array.d.ts.map +1 -0
  76. package/dist/utils/managed-array.js +151 -0
  77. package/package.json +6 -7
  78. package/src/tileset/helpers/i3s-lod.ts +1 -1
  79. package/src/tileset/tileset-cache.ts +2 -0
  80. package/src/utils/{doubly-linked-list-node.js → doubly-linked-list-node.ts} +4 -0
  81. package/src/utils/{doubly-linked-list.js → doubly-linked-list.ts} +3 -5
  82. package/src/utils/{managed-array.js → managed-array.ts} +4 -1
  83. package/dist/dist.min.js +0 -2
  84. package/dist/dist.min.js.map +0 -1
package/dist/dist.min.js.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js","webpack:///external \"loaders\"","webpack:///./src/bundle.ts","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/process/browser.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/lib/assert.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/lib/common.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/lib/validators.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/classes/base/math-array.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/classes/base/matrix.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/gl-matrix/esm/common.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/gl-matrix/esm/mat4.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/gl-matrix/esm/vec2.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/gl-matrix/esm/vec3.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/gl-matrix/esm/vec4.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/classes/matrix4.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/classes/base/vector.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/classes/vector3.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/lib/math-utils.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/geospatial/dist/esm/constants.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/geospatial/dist/esm/type-utils.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/scale-to-geodetic-surface.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/ellipsoid-transform.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/ellipsoid.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@probe.gl/stats/dist/esm/lib/stat.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@probe.gl/stats/dist/esm/lib/stats.js","webpack:///../loader-utils/src/lib/env-utils/assert.ts","webpack:///../loader-utils/src/lib/path-utils/path.ts","webpack:///../loader-utils/src/lib/request-utils/request-scheduler.ts","webpack:///./src/utils/doubly-linked-list-node.js","webpack:///./src/utils/doubly-linked-list.js","webpack:///./src/tileset/tileset-cache.ts","webpack:///./src/tileset/helpers/transform-utils.ts","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/constants.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/axis-aligned-bounding-box.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/bounding-sphere.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/gl-matrix/esm/mat3.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/classes/matrix3.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/gl-matrix/esm/quat.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/core/dist/esm/classes/quaternion.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/oriented-bounding-box.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/plane.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/culling-volume.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/perspective-off-center-frustum.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-sphere-from-points.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/algorithms/compute-eigen-decomposition.js","webpack:////home/user/apps/loaders.gl_duplicate/node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-box-from-points.js","webpack:///./src/tileset/helpers/frame-state.ts","webpack:///./src/tileset/helpers/zoom.ts","webpack:///./src/constants.ts","webpack:///./src/tileset/helpers/bounding-volume.ts","webpack:///./src/tileset/helpers/tiles-3d-lod.ts","webpack:///./src/tileset/helpers/i3s-lod.ts","webpack:///./src/utils/managed-array.js","webpack:///./src/tileset/traversers/tileset-traverser.ts","webpack:///./src/tileset/tile-3d.ts","webpack:///./src/tileset/helpers/3d-tiles-options.ts","webpack:///./src/tileset/traversers/tileset-3d-traverser.ts","webpack:///./src/tileset/traversers/i3s-tile-manager.ts","webpack:///./src/tileset/traversers/i3s-tileset-traverser.ts","webpack:///./src/tileset/tileset-3d.ts"],"names":["root","factory","exports","module","require","define","amd","a","i","window","__WEBPACK_EXTERNAL_MODULE__7__","installedModules","__webpack_require__","moduleId","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","getHiResTimestamp","timestamp","performance","now","process","hrtime","timeParts","Date","moduleExports","globalThis","loaders","assign","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","e","this","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","length","concat","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","Array","arguments","push","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","assert","condition","message","RADIANS_TO_DEGREES","Math","PI","DEGREES_TO_RADIANS","config","formatValue","precision","round","EPSILON","parseFloat","toPrecision","isArray","ArrayBuffer","isView","DataView","func","result","clone","toRadians","degrees","toDegrees","radians","equals","b","epsilon","oldEpsilon","Number","isFinite","abs","max","checkNumber","checkVector","v","callerName","debug","validateVector","printTypes","printDegrees","printRowMajor","deprecated","method","console","warn","cls","ExtendableBuiltin","instance","Reflect","construct","from","setPrototypeOf","getPrototypeOf","constructor","writable","configurable","__proto__","_extendableBuiltin","copy","arrayOrObject","fromObject","offset","ELEMENTS","check","toArray","toObject","target","to","Float32Array","formatString","opts","string","undefined","ai","vector","min","minVector","maxVector","vectors","scale","multiply","subtract","addScalar","scalar","validate","valid","row","RANK","col","columnIndex","fill","firstIndex","columnVector","vec3_transformMat4AsVector","out","x","y","z","w","ARRAY_TYPE","random","a00","a01","a02","a03","a10","a11","a12","a13","a20","a21","a22","a23","a30","a31","a32","a33","b0","b1","b2","b3","getScaling","mat","m11","m12","m13","m21","m22","m23","m31","m32","m33","hypot","sqrt","vec","ax","ay","az","bx","by","bz","IDENTITY","freeze","ZERO","INDICES","COL0ROW0","COL0ROW1","COL0ROW2","COL0ROW3","COL1ROW0","COL1ROW1","COL1ROW2","COL1ROW3","COL2ROW0","COL2ROW1","COL2ROW2","COL2ROW3","COL3ROW0","COL3ROW1","COL3ROW2","COL3ROW3","constants","super","identity","m00","m10","m20","m30","m01","m02","m03","q","x2","y2","z2","xx","yx","yy","zx","zy","zz","wx","wy","wz","left","right","bottom","top","near","far","Infinity","_computeInfinitePerspectiveOffCenter","rl","tb","nf","column0Row0","column1Row1","column2Row0","column2Row1","column3Row2","eye","center","up","x0","x1","y0","y1","z0","z1","eyex","eyey","eyez","upx","upy","upz","centerx","centery","centerz","lr","bt","fovy","aspect","focalDistance","halfY","tan","ortho","fov","f","scaleResult","getScale","inverseScale0","inverseScale1","inverseScale2","b00","b01","b02","b03","b04","b05","b06","b07","b08","b09","b10","b11","det","rad","sin","cos","rx","ry","rz","rotateX","rotateY","rotateZ","axis","b12","b20","b21","b22","factor","transformAsPoint","vec2_transformMat4AsVector","translate","transformAsVector","lengthSquared","mathArray","distanceSquared","dist","product","magnitude","distance","add","multiplyScalar","ORIGIN","mag","cosine","acos","origin","matrix4","matrix3","matrix2","vec3_transformMat2","quaternion","qx","qy","qz","qw","uvx","uvy","uvz","uuvx","uuvy","uuvz","w2","scratchVector","fromCartographic","cartographic","map","longitude","latitude","height","toCartographic","scaleToGeodeticSurfaceIntersection","scaleToGeodeticSurfaceGradient","scratchOrigin","VECTOR_PRODUCT_LOCAL_FRAME","south","north","west","east","down","degeneratePositionLocalFrame","scratchAxisVectors","scratchVector1","scratchVector2","scratchVector3","localFrameToFixedFrame","ellipsoid","firstAxis","secondAxis","thirdAxis","cartesianOrigin","thirdAxisInferred","firstAxisVector","secondAxisVector","thirdAxisVector","sign","fromArray","set","normalize","geodeticSurfaceNormal","cross","scratchNormal","scratchK","scratchPosition","scratchHeight","scratchCartesian","wgs84","radii","radiiSquared","radiiToTheFourth","oneOverRadii","oneOverRadiiSquared","minimumRadius","maximumRadius","centerToleranceSquared","squaredXOverSquaredZ","Boolean","toString","normal","k","geodeticSurfaceNormalCartographic","gamma","dot","cartesian","point","scaleToGeodeticSurface","h","atan2","asin","_cartographicRadians","cartographicVectorRadians","fromCartographicToRadians","cosLatitude","positionX","positionY","positionZ","oneOverRadiiX","oneOverRadiiY","oneOverRadiiZ","squaredNorm","ratio","intersection","oneOverRadiiSquaredX","oneOverRadiiSquaredY","oneOverRadiiSquaredZ","gradient","xMultiplier","yMultiplier","zMultiplier","lambda","correction","xMultiplier2","yMultiplier2","zMultiplier2","beta","position","buffer","type","sampleSize","reset","samples","addCount","subtractCount","_count","_samples","_checkSampling","time","_time","lastTiming","_startTime","_timerPending","addTime","lastSampleCount","lastSampleTime","count","id","stats","_initializeStats","seal","_getOrCreate","keys","fn","table","forEach","stat","average","getAverageTime","hz","getHz","filename","url","slashIndex","lastIndexOf","substr","dirname","join","parts","part","index","replace","RegExp","DEFAULT_PROPS","throttleRequests","maxRequests","RequestScheduler","props","Map","Stats","scheduleRequest","handle","getPriority","Promise","resolve","done","requestMap","has","request","priority","promise","requestQueue","_issueNewRequests","_issueRequest","isDone","delete","activeRequestCount","deferredUpdate","_issueNewRequestsAsync","freeSlots","_updateAllRequests","shift","_updateRequest","splice","sort","DoublyLinkedListNode","item","previous","next","DoublyLinkedList","head","tail","_length","node","remove","nextNode","_insert","oldNodeNext","defined","TilesetCache","_list","_sentinel","_trimTiles","touch","tile","_cacheNode","tileset","addCallback","unloadTile","unloadCallback","unloadTiles","trimTiles","list","maximumMemoryUsageInBytes","maximumMemoryUsage","sentinel","gpuMemoryUsageInBytes","trim","calculateTransformProps","tileHeader","rtcCenter","gltfUpAxis","computedTransform","boundingVolume","modelMatrix","Matrix4","rotationY","multiplyRight","rotationX","isQuantized","quantizedVolumeOffset","quantizedVolumeScale","Vector3","cartesianModelMatrix","cartographicOrigin","Ellipsoid","WGS84","cartesianToCartographic","toFixedFrameMatrix","eastNorthUpToFixedFrame","invert","cartographicModelMatrix","coordinateSystem","INTERSECTION","OUTSIDE","INTERSECTING","INSIDE","radius","fromCenterRadius","corner","oppositeCorner","boundingSphere","leftCenter","leftRadius","rightCenter","rightRadius","toRightCenter","centerSeparation","halfDistanceBetweenTangentPoints","transform","distanceSquaredTo","plane","distanceToPlane","vec4_transformMat3","setAxisAngle","aw","bw","slerp","omega","cosom","sinom","scale0","scale1","fromMat3","fRoot","fTrace","j","tmpvec3","xUnitVec3","yUnitVec3","temp1","temp2","matr","rotationTo","IDENTITY_QUATERNION","fromAxisRotation","vectorA","vectorB","a0","a1","a2","a3","invDot","start","ix","iy","iz","iw","multiplyLeft","scratchOffset","scratchVectorU","scratchVectorV","scratchVectorW","scratchCorner","scratchToCenter","MATRIX3","halfAxes","xAxis","getColumn","yAxis","zAxis","normXAxis","normYAxis","normZAxis","fromMatrix3","halfSize","quaternionObject","directionsMatrix","fromQuaternion","u","cornerVector","normalX","normalY","normalZ","radEffective","uHalf","vHalf","wHalf","direction","minDist","POSITIVE_INFINITY","maxDist","NEGATIVE_INFINITY","toCenter","transformation","fromNormalDistance","fromPointNormal","pointDistance","getPointDistance","scaledNormal","faces","scratchPlaneCenter","scratchPlaneNormal","planes","every","planeIndex","faceNormal","plane0","plane1","plane0Center","plane1Center","negatedFaceNormal","negate","intersect","intersectPlane","parentPlaneMask","MASK_OUTSIDE","MASK_INSIDE","mask","flag","cullingVolume","CullingVolume","Plane","getFrameState","viewport","frameNumber","cameraDirection","cameraUp","metersPerUnit","distanceScales","viewportCenterCartographic","viewportCenterCartesian","cartographicToCartesian","enuToFixedTransform","cameraPositionCartographic","unprojectPosition","cameraPosition","cameraPositionCartesian","cameraDirectionCartesian","cameraUpCartesian","frustumPlanes","getFrustumPlanes","distanceToCenter","cartographicPos","cartesianPos","commonSpacePlanesToWGS84","camera","sseDenominator","getZoomFromBoundingVolume","width","obbSize","axeY","axeZ","farthestVertex","getObbSize","log2","TILE_CONTENT_STATE","UNLOADED","LOADING","PROCESSING","READY","EXPIRED","FAILED","TILE_REFINEMENT","ADD","REPLACE","TILE_TYPE","EMPTY","SCENEGRAPH","POINTCLOUD","MESH","TILESET_TYPE","I3S","TILES3D","LOD_METRIC_TYPE","GEOMETRIC_ERROR","MAX_SCREEN_THRESHOLD","TILE3D_OPTIMIZATION_HINT","scratchScale","scratchNorthWest","scratchSouthEast","createBoundingVolume","boundingVolumeHeader","box","slice","Quaternion","transformByQuaternion","Matrix3","OrientedBoundingBox","createBox","region","minHeight","maxHeight","northWest","southEast","centerInCartesian","addVectors","subVectors","createSphere","sphere","uniformScale","BoundingSphere","getDynamicScreenSpaceError","distanceToCamera","dynamicScreenSpaceError","dynamicScreenSpaceErrorComputedDensity","density","dynamicScreenSpaceErrorFactor","exp","fog","getLodStatus","frameState","lodMetricValue","isNaN","screenSize","getProjectedRadius","header","children","originalViewport","ViewportClass","bearing","zoom","pitch","mbsLat","mbs","mbsLon","mbsZ","mbsR","mbsCenterCartesian","toEye","enuToCartesianMatrix","cartesianToEnuMatrix","cameraPositionEnu","projection","extraZ","extraVertexCartesian","extraVectorCartesian","radiusVector","sphereMbsBorderVertexCartesian","sphereMbsBorderVertexCartographic","projectedOrigin","project","projectedMbsBorderVertex","ManagedArray","_array","_map","element","peek","pop","reserve","resize","find","loadSiblings","skipLevelOfDetail","maximumScreenSpaceError","updateTransforms","onTraversalEnd","viewportTraversersMap","basePath","TilesetTraverser","options","_traversalStack","_emptyTraversalStack","_frameNumber","selectedTiles","requestedTiles","emptyTiles","traverse","updateTile","executeTraversal","stack","_selectionDepth","shouldRefine","canTraverse","updateChildTiles","updateAndPushChildren","hasRenderContent","parent","parentRefines","_shouldRefine","stoppedRefining","refine","loadTile","selectTile","touchTile","child","depth","compareDistanceToCamera","checkRefines","hasVisibleChild","refines","isVisibleAndInRequestVolume","childRefines","_inRequestVolume","contentAvailable","executeEmptyTraversal","updateTileVisibility","shouldSelectTile","_selectedFrame","shouldLoadTile","_requestedFrame","_priority","_getPriority","_cache","_touchedFrame","useParentMetric","ignoreVisibility","hasChildren","hasTilesetContent","contentExpired","hasUnloadedContent","screenSpaceError","_screenSpaceError","getScreenSpaceError","viewportIds","updateVisibility","_distanceToCamera","anyChildrenVisible","anyVisible","allDescendantsLoaded","TileHeader","parentHeader","extendedId","_getRefine","contentUrl","lodMetricType","content","contentState","hasEmptyContent","userData","_visitedFrame","traverser","_centerZDepth","_visible","_stackLength","_initialTransform","_initializeLodMetric","_initializeTransforms","_initializeBoundingVolumes","_initializeContent","_initializeRenderingState","_lodJudge","_expireDate","_expiredContent","destroy","isDestroyed","contentReady","contentFailed","contentUnloaded","useParentLodMetric","parentLodMetricValue","viewDistanceScale","error","getTiles3DScreenSpaceError","_traverser","maySkipTile","isVisible","rootScreenSpaceError","requestToken","_requestScheduler","getTileUrl","loader","loadOptions","isTileset","_getLoaderSpecificOptions","load","contentLoader","_isTileset","_initializeTileHeaders","_onContentLoaded","unloadContent","parentVisibilityPlaneMask","_visibilityPlaneMask","MASK_INDETERMINATE","parentTransform","_updateTransform","distanceToTile","visibility","insideViewerRequestVolume","computeVisibilityWithPlaneMask","contentVisibility","cameraSpaceZDepth","viewerRequestVolume","_viewerRequestVolume","updateExpiration","lessThan","extras","parentInitialTransform","_contentBoundingVolume","_updateBoundingVolume","_tileset","_tile","level","indexOf","disableSkipLevelOfDetail","loaderId","i3s","isTileHeader","assetGltfUpAxis","asset","Tileset3DTraverser","firstChild","meetsScreenSpaceErrorEarly","useOptimization","_optimChildrenWithinParent","STATUS","I3STileManager","_statusMap","callback","status","then","data","catch","update","I3STilesetTraverser","_tileManager","childTiles","childTile","_loadTile","nodePages","nodePagesTile","formTileFromNodePages","_onTileLoad","nodeId","nodeUrl","loadContent","description","onTileLoad","onTileUnload","onTileError","onTraversalComplete","loadTiles","fetch","attributions","Tileset3D","json","path","roots","cartographicCenter","cartesianCenter","traverseCounter","geometricError","_initializeTraverser","_pendingCount","_tiles","_emptyTiles","_requestedTiles","frameStateData","lastUpdatedVieports","_queryParams","_queryParamsString","_extensionsUsed","credits","_initializeTileSet","_destroy","isLoaded","values","queryParams","queryParamStrings","getQueryParamString","setProps","setOptions","tilePath","startsWith","hasExtension","extensionName","viewports","viewportsToTraverse","_needTraverse","includes","viewportId","traverserId","_onTraversalEnd","currentFrameStateData","_updateTiles","frameStateKey","frameStateDataValue","_loadTiles","_unloadTiles","_updateStats","_tilesChanged","oldSelectedTiles","set1","Set","set2","changed","filter","_unloadTile","tilesRenderable","pointsRenderable","pointCount","tilesetJson","_initializeCesiumTileset","_initializeI3STileset","_calculateViewProps","parentTileHeader","rootTile","Tile3D","incrementCount","childHeader","TraverserClass","I3SetTraverser","_destroyTileHeaders","parentTile","_destroySubtree","loaded","_onStartTileLoading","_onTileLoadError","_onEndTileLoading","_addTileToCache","decrementCount","_updateCacheStats","byteLength","_destroyTile","tilesetVersion","properties","extensionsUsed","token"],"mappings":"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","file":"dist.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"loaders\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"loaders\"], factory);\n\telse {\n\t\tvar a = typeof exports === 'object' ? factory(require(\"loaders\")) : factory(root[\"loaders\"]);\n\t\tfor(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n\t}\n})(window, function(__WEBPACK_EXTERNAL_MODULE__7__) {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 20);\n","export default function getHiResTimestamp() {\n let timestamp;\n\n if (typeof window !== 'undefined' && window.performance) {\n timestamp = window.performance.now();\n } else if (typeof process !== 'undefined' && process.hrtime) {\n const timeParts = process.hrtime();\n timestamp = timeParts[0] * 1000 + timeParts[1] / 1e6;\n } else {\n timestamp = Date.now();\n }\n\n return timestamp;\n}\n//# sourceMappingURL=hi-res-timestamp.js.map","module.exports = __WEBPACK_EXTERNAL_MODULE__7__;","// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","export default function assert(condition, message) {\n if (!condition) {\n throw new Error(\"math.gl assertion \".concat(message));\n }\n}\n//# sourceMappingURL=assert.js.map","import assert from './assert';\nconst RADIANS_TO_DEGREES = 1 / Math.PI * 180;\nconst DEGREES_TO_RADIANS = 1 / 180 * Math.PI;\nconst config = {};\nconfig.EPSILON = 1e-12;\nconfig.debug = false;\nconfig.precision = 4;\nconfig.printTypes = false;\nconfig.printDegrees = false;\nconfig.printRowMajor = true;\nexport { config };\nexport function configure(options = {}) {\n for (const key in options) {\n assert(key in config);\n config[key] = options[key];\n }\n\n return config;\n}\n\nfunction round(value) {\n return Math.round(value / config.EPSILON) * config.EPSILON;\n}\n\nexport function formatValue(value, {\n precision = config.precision || 4\n} = {}) {\n value = round(value);\n return \"\".concat(parseFloat(value.toPrecision(precision)));\n}\nexport function isArray(value) {\n return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);\n}\n\nfunction duplicateArray(array) {\n return array.clone ? array.clone() : new Array(array.length);\n}\n\nexport function clone(array) {\n return array.clone ? array.clone() : new Array(...array);\n}\n\nfunction map(value, func, result) {\n if (isArray(value)) {\n result = result || duplicateArray(value);\n\n for (let i = 0; i < result.length && i < value.length; ++i) {\n result[i] = func(value[i], i, result);\n }\n\n return result;\n }\n\n return func(value);\n}\n\nexport function toRadians(degrees) {\n return radians(degrees);\n}\nexport function toDegrees(radians) {\n return degrees(radians);\n}\nexport function radians(degrees, result) {\n return map(degrees, degrees => degrees * DEGREES_TO_RADIANS, result);\n}\nexport function degrees(radians, result) {\n return map(radians, radians => radians * RADIANS_TO_DEGREES, result);\n}\nexport function sin(radians) {\n return map(radians, angle => Math.sin(angle));\n}\nexport function cos(radians) {\n return map(radians, angle => Math.cos(angle));\n}\nexport function tan(radians) {\n return map(radians, angle => Math.tan(angle));\n}\nexport function asin(radians) {\n return map(radians, angle => Math.asin(angle));\n}\nexport function acos(radians) {\n return map(radians, angle => Math.acos(angle));\n}\nexport function atan(radians) {\n return map(radians, angle => Math.atan(angle));\n}\nexport function clamp(value, min, max) {\n return map(value, value => Math.max(min, Math.min(max, value)));\n}\nexport function lerp(a, b, t) {\n if (isArray(a)) {\n return a.map((ai, i) => lerp(ai, b[i], t));\n }\n\n return t * b + (1 - t) * a;\n}\nexport function equals(a, b, epsilon) {\n const oldEpsilon = config.EPSILON;\n\n if (epsilon) {\n config.EPSILON = epsilon;\n }\n\n try {\n if (a === b) {\n return true;\n }\n\n if (isArray(a) && isArray(b)) {\n if (a.length !== b.length) {\n return false;\n }\n\n for (let i = 0; i < a.length; ++i) {\n if (!equals(a[i], b[i])) {\n return false;\n }\n }\n\n return true;\n }\n\n if (a && a.equals) {\n return a.equals(b);\n }\n\n if (b && b.equals) {\n return b.equals(a);\n }\n\n if (Number.isFinite(a) && Number.isFinite(b)) {\n return Math.abs(a - b) <= config.EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));\n }\n\n return false;\n } finally {\n config.EPSILON = oldEpsilon;\n }\n}\nexport function exactEquals(a, b) {\n if (a === b) {\n return true;\n }\n\n if (a && typeof a === 'object' && b && typeof b === 'object') {\n if (a.constructor !== b.constructor) {\n return false;\n }\n\n if (a.exactEquals) {\n return a.exactEquals(b);\n }\n }\n\n if (isArray(a) && isArray(b)) {\n if (a.length !== b.length) {\n return false;\n }\n\n for (let i = 0; i < a.length; ++i) {\n if (!exactEquals(a[i], b[i])) {\n return false;\n }\n }\n\n return true;\n }\n\n return false;\n}\nexport function withEpsilon(EPSILON, func) {\n const oldPrecision = config.EPSILON;\n config.EPSILON = EPSILON;\n let value;\n\n try {\n value = func();\n } finally {\n config.EPSILON = oldPrecision;\n }\n\n return value;\n}\n//# sourceMappingURL=common.js.map","import { config } from './common';\nexport function validateVector(v, length) {\n if (v.length !== length) {\n return false;\n }\n\n for (let i = 0; i < v.length; ++i) {\n if (!Number.isFinite(v[i])) {\n return false;\n }\n }\n\n return true;\n}\nexport function checkNumber(value) {\n if (!Number.isFinite(value)) {\n throw new Error(\"Invalid number \".concat(value));\n }\n\n return value;\n}\nexport function checkVector(v, length, callerName = '') {\n if (config.debug && !validateVector(v, length)) {\n throw new Error(\"math.gl: \".concat(callerName, \" some fields set to invalid numbers'\"));\n }\n\n return v;\n}\nconst map = {};\nexport function deprecated(method, version) {\n if (!map[method]) {\n map[method] = true;\n console.warn(\"\".concat(method, \" has been removed in version \").concat(version, \", see upgrade guide for more information\"));\n }\n}\n//# sourceMappingURL=validators.js.map","function _extendableBuiltin(cls) {\n function ExtendableBuiltin() {\n var instance = Reflect.construct(cls, Array.from(arguments));\n Object.setPrototypeOf(instance, Object.getPrototypeOf(this));\n return instance;\n }\n\n ExtendableBuiltin.prototype = Object.create(cls.prototype, {\n constructor: {\n value: cls,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(ExtendableBuiltin, cls);\n } else {\n ExtendableBuiltin.__proto__ = cls;\n }\n\n return ExtendableBuiltin;\n}\n\nimport { config, formatValue, equals, isArray } from '../../lib/common';\nimport assert from '../../lib/assert';\nexport default class MathArray extends _extendableBuiltin(Array) {\n get ELEMENTS() {\n assert(false);\n return 0;\n }\n\n clone() {\n return new this.constructor().copy(this);\n }\n\n from(arrayOrObject) {\n return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);\n }\n\n fromArray(array, offset = 0) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = array[i + offset];\n }\n\n return this.check();\n }\n\n to(arrayOrObject) {\n if (arrayOrObject === this) {\n return this;\n }\n\n return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);\n }\n\n toTarget(target) {\n return target ? this.to(target) : this;\n }\n\n toArray(array = [], offset = 0) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n array[offset + i] = this[i];\n }\n\n return array;\n }\n\n toFloat32Array() {\n return new Float32Array(this);\n }\n\n toString() {\n return this.formatString(config);\n }\n\n formatString(opts) {\n let string = '';\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);\n }\n\n return \"\".concat(opts.printTypes ? this.constructor.name : '', \"[\").concat(string, \"]\");\n }\n\n equals(array) {\n if (!array || this.length !== array.length) {\n return false;\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n if (!equals(this[i], array[i])) {\n return false;\n }\n }\n\n return true;\n }\n\n exactEquals(array) {\n if (!array || this.length !== array.length) {\n return false;\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n if (this[i] !== array[i]) {\n return false;\n }\n }\n\n return true;\n }\n\n negate() {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = -this[i];\n }\n\n return this.check();\n }\n\n lerp(a, b, t) {\n if (t === undefined) {\n t = b;\n b = a;\n a = this;\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n const ai = a[i];\n this[i] = ai + t * (b[i] - ai);\n }\n\n return this.check();\n }\n\n min(vector) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.min(vector[i], this[i]);\n }\n\n return this.check();\n }\n\n max(vector) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.max(vector[i], this[i]);\n }\n\n return this.check();\n }\n\n clamp(minVector, maxVector) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);\n }\n\n return this.check();\n }\n\n add(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] += vector[i];\n }\n }\n\n return this.check();\n }\n\n subtract(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] -= vector[i];\n }\n }\n\n return this.check();\n }\n\n scale(scale) {\n if (Array.isArray(scale)) {\n return this.multiply(scale);\n }\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] *= scale;\n }\n\n return this.check();\n }\n\n sub(a) {\n return this.subtract(a);\n }\n\n setScalar(a) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = a;\n }\n\n return this.check();\n }\n\n addScalar(a) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] += a;\n }\n\n return this.check();\n }\n\n subScalar(a) {\n return this.addScalar(-a);\n }\n\n multiplyScalar(scalar) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] *= scalar;\n }\n\n return this.check();\n }\n\n divideScalar(a) {\n return this.scale(1 / a);\n }\n\n clampScalar(min, max) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] = Math.min(Math.max(this[i], min), max);\n }\n\n return this.check();\n }\n\n multiplyByScalar(scalar) {\n return this.scale(scalar);\n }\n\n get elements() {\n return this;\n }\n\n check() {\n if (config.debug && !this.validate()) {\n throw new Error(\"math.gl: \".concat(this.constructor.name, \" some fields set to invalid numbers'\"));\n }\n\n return this;\n }\n\n validate() {\n let valid = this.length === this.ELEMENTS;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n valid = valid && Number.isFinite(this[i]);\n }\n\n return valid;\n }\n\n}\n//# sourceMappingURL=math-array.js.map","import MathArray from './math-array';\nimport { checkNumber } from '../../lib/validators';\nimport { config } from '../../lib/common';\nimport assert from '../../lib/assert';\nexport default class Matrix extends MathArray {\n get ELEMENTS() {\n assert(false);\n return 0;\n }\n\n get RANK() {\n assert(false);\n return 0;\n }\n\n toString() {\n let string = '[';\n\n if (config.printRowMajor) {\n string += 'row-major:';\n\n for (let row = 0; row < this.RANK; ++row) {\n for (let col = 0; col < this.RANK; ++col) {\n string += \" \".concat(this[col * this.RANK + row]);\n }\n }\n } else {\n string += 'column-major:';\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n string += \" \".concat(this[i]);\n }\n }\n\n string += ']';\n return string;\n }\n\n getElementIndex(row, col) {\n return col * this.RANK + row;\n }\n\n getElement(row, col) {\n return this[col * this.RANK + row];\n }\n\n setElement(row, col, value) {\n this[col * this.RANK + row] = checkNumber(value);\n return this;\n }\n\n getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {\n const firstIndex = columnIndex * this.RANK;\n\n for (let i = 0; i < this.RANK; ++i) {\n result[i] = this[firstIndex + i];\n }\n\n return result;\n }\n\n setColumn(columnIndex, columnVector) {\n const firstIndex = columnIndex * this.RANK;\n\n for (let i = 0; i < this.RANK; ++i) {\n this[firstIndex + i] = columnVector[i];\n }\n\n return this;\n }\n\n}\n//# sourceMappingURL=matrix.js.map","export function vec2_transformMat4AsVector(out, a, m) {\n const x = a[0];\n const y = a[1];\n const w = m[3] * x + m[7] * y || 1.0;\n out[0] = (m[0] * x + m[4] * y) / w;\n out[1] = (m[1] * x + m[5] * y) / w;\n return out;\n}\nexport function vec3_transformMat4AsVector(out, a, m) {\n const x = a[0];\n const y = a[1];\n const z = a[2];\n const w = m[3] * x + m[7] * y + m[11] * z || 1.0;\n out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;\n out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;\n out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;\n return out;\n}\nexport function vec3_transformMat2(out, a, m) {\n const x = a[0];\n const y = a[1];\n out[0] = m[0] * x + m[2] * y;\n out[1] = m[1] * x + m[3] * y;\n out[2] = a[2];\n return out;\n}\nexport function vec4_transformMat2(out, a, m) {\n const x = a[0];\n const y = a[1];\n out[0] = m[0] * x + m[2] * y;\n out[1] = m[1] * x + m[3] * y;\n out[2] = a[2];\n out[3] = a[3];\n return out;\n}\nexport function vec4_transformMat3(out, a, m) {\n const x = a[0];\n const y = a[1];\n const z = a[2];\n out[0] = m[0] * x + m[3] * y + m[6] * z;\n out[1] = m[1] * x + m[4] * y + m[7] * z;\n out[2] = m[2] * x + m[5] * y + m[8] * z;\n out[3] = a[3];\n return out;\n}\n//# sourceMappingURL=gl-matrix-extras.js.map","/**\r\n * Common utilities\r\n * @module glMatrix\r\n */\n// Configuration Constants\nexport var EPSILON = 0.000001;\nexport var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;\nexport var RANDOM = Math.random;\n/**\r\n * Sets the type of array used when creating new vectors and matrices\r\n *\r\n * @param {Float32ArrayConstructor | ArrayConstructor} type Array type, such as Float32Array or Array\r\n */\n\nexport function setMatrixArrayType(type) {\n ARRAY_TYPE = type;\n}\nvar degree = Math.PI / 180;\n/**\r\n * Convert Degree To Radian\r\n *\r\n * @param {Number} a Angle in Degrees\r\n */\n\nexport function toRadian(a) {\n return a * degree;\n}\n/**\r\n * Tests whether or not the arguments have approximately the same value, within an absolute\r\n * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less\r\n * than or equal to 1.0, and a relative tolerance is used for larger values)\r\n *\r\n * @param {Number} a The first number to test.\r\n * @param {Number} b The second number to test.\r\n * @returns {Boolean} True if the numbers are approximately equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));\n}\nif (!Math.hypot) Math.hypot = function () {\n var y = 0,\n i = arguments.length;\n\n while (i--) {\n y += arguments[i] * arguments[i];\n }\n\n return Math.sqrt(y);\n};","import * as glMatrix from \"./common.js\";\n/**\r\n * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.\r\n * @module mat4\r\n */\n\n/**\r\n * Creates a new identity mat4\r\n *\r\n * @returns {mat4} a new 4x4 matrix\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(16);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n }\n\n out[0] = 1;\n out[5] = 1;\n out[10] = 1;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a new mat4 initialized with values from an existing matrix\r\n *\r\n * @param {ReadonlyMat4} a matrix to clone\r\n * @returns {mat4} a new 4x4 matrix\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(16);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n out[9] = a[9];\n out[10] = a[10];\n out[11] = a[11];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n return out;\n}\n/**\r\n * Copy the values from one mat4 to another\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n out[9] = a[9];\n out[10] = a[10];\n out[11] = a[11];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n return out;\n}\n/**\r\n * Create a new mat4 with the given values\r\n *\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\r\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\r\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\r\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\r\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\r\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\r\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\r\n * @returns {mat4} A new mat4\r\n */\n\nexport function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n var out = new glMatrix.ARRAY_TYPE(16);\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m03;\n out[4] = m10;\n out[5] = m11;\n out[6] = m12;\n out[7] = m13;\n out[8] = m20;\n out[9] = m21;\n out[10] = m22;\n out[11] = m23;\n out[12] = m30;\n out[13] = m31;\n out[14] = m32;\n out[15] = m33;\n return out;\n}\n/**\r\n * Set the components of a mat4 to the given values\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\r\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\r\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\r\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\r\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\r\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\r\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\r\n * @returns {mat4} out\r\n */\n\nexport function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m03;\n out[4] = m10;\n out[5] = m11;\n out[6] = m12;\n out[7] = m13;\n out[8] = m20;\n out[9] = m21;\n out[10] = m22;\n out[11] = m23;\n out[12] = m30;\n out[13] = m31;\n out[14] = m32;\n out[15] = m33;\n return out;\n}\n/**\r\n * Set a mat4 to the identity matrix\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @returns {mat4} out\r\n */\n\nexport function identity(out) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = 1;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 1;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Transpose the values of a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function transpose(out, a) {\n // If we are transposing ourselves we can skip a few steps but have to cache some values\n if (out === a) {\n var a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a12 = a[6],\n a13 = a[7];\n var a23 = a[11];\n out[1] = a[4];\n out[2] = a[8];\n out[3] = a[12];\n out[4] = a01;\n out[6] = a[9];\n out[7] = a[13];\n out[8] = a02;\n out[9] = a12;\n out[11] = a[14];\n out[12] = a03;\n out[13] = a13;\n out[14] = a23;\n } else {\n out[0] = a[0];\n out[1] = a[4];\n out[2] = a[8];\n out[3] = a[12];\n out[4] = a[1];\n out[5] = a[5];\n out[6] = a[9];\n out[7] = a[13];\n out[8] = a[2];\n out[9] = a[6];\n out[10] = a[10];\n out[11] = a[14];\n out[12] = a[3];\n out[13] = a[7];\n out[14] = a[11];\n out[15] = a[15];\n }\n\n return out;\n}\n/**\r\n * Inverts a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function invert(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n var b00 = a00 * a11 - a01 * a10;\n var b01 = a00 * a12 - a02 * a10;\n var b02 = a00 * a13 - a03 * a10;\n var b03 = a01 * a12 - a02 * a11;\n var b04 = a01 * a13 - a03 * a11;\n var b05 = a02 * a13 - a03 * a12;\n var b06 = a20 * a31 - a21 * a30;\n var b07 = a20 * a32 - a22 * a30;\n var b08 = a20 * a33 - a23 * a30;\n var b09 = a21 * a32 - a22 * a31;\n var b10 = a21 * a33 - a23 * a31;\n var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n if (!det) {\n return null;\n }\n\n det = 1.0 / det;\n out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\n out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\n out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\n out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;\n out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\n out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\n out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\n out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;\n out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\n out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\n out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\n out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;\n out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;\n out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;\n out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;\n out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;\n return out;\n}\n/**\r\n * Calculates the adjugate of a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {mat4} out\r\n */\n\nexport function adjoint(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);\n out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));\n out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);\n out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));\n out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));\n out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);\n out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));\n out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);\n out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);\n out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));\n out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);\n out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));\n out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));\n out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);\n out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));\n out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);\n return out;\n}\n/**\r\n * Calculates the determinant of a mat4\r\n *\r\n * @param {ReadonlyMat4} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\n\nexport function determinant(a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n var b00 = a00 * a11 - a01 * a10;\n var b01 = a00 * a12 - a02 * a10;\n var b02 = a00 * a13 - a03 * a10;\n var b03 = a01 * a12 - a02 * a11;\n var b04 = a01 * a13 - a03 * a11;\n var b05 = a02 * a13 - a03 * a12;\n var b06 = a20 * a31 - a21 * a30;\n var b07 = a20 * a32 - a22 * a30;\n var b08 = a20 * a33 - a23 * a30;\n var b09 = a21 * a32 - a22 * a31;\n var b10 = a21 * a33 - a23 * a31;\n var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n}\n/**\r\n * Multiplies two mat4s\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @returns {mat4} out\r\n */\n\nexport function multiply(out, a, b) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15]; // Cache only the current line of the second matrix\n\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3];\n out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n b0 = b[4];\n b1 = b[5];\n b2 = b[6];\n b3 = b[7];\n out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n b0 = b[8];\n b1 = b[9];\n b2 = b[10];\n b3 = b[11];\n out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n b0 = b[12];\n b1 = b[13];\n b2 = b[14];\n b3 = b[15];\n out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n return out;\n}\n/**\r\n * Translate a mat4 by the given vector\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to translate\r\n * @param {ReadonlyVec3} v vector to translate by\r\n * @returns {mat4} out\r\n */\n\nexport function translate(out, a, v) {\n var x = v[0],\n y = v[1],\n z = v[2];\n var a00, a01, a02, a03;\n var a10, a11, a12, a13;\n var a20, a21, a22, a23;\n\n if (a === out) {\n out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];\n out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];\n out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];\n out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];\n } else {\n a00 = a[0];\n a01 = a[1];\n a02 = a[2];\n a03 = a[3];\n a10 = a[4];\n a11 = a[5];\n a12 = a[6];\n a13 = a[7];\n a20 = a[8];\n a21 = a[9];\n a22 = a[10];\n a23 = a[11];\n out[0] = a00;\n out[1] = a01;\n out[2] = a02;\n out[3] = a03;\n out[4] = a10;\n out[5] = a11;\n out[6] = a12;\n out[7] = a13;\n out[8] = a20;\n out[9] = a21;\n out[10] = a22;\n out[11] = a23;\n out[12] = a00 * x + a10 * y + a20 * z + a[12];\n out[13] = a01 * x + a11 * y + a21 * z + a[13];\n out[14] = a02 * x + a12 * y + a22 * z + a[14];\n out[15] = a03 * x + a13 * y + a23 * z + a[15];\n }\n\n return out;\n}\n/**\r\n * Scales the mat4 by the dimensions in the given vec3 not using vectorization\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to scale\r\n * @param {ReadonlyVec3} v the vec3 to scale the matrix by\r\n * @returns {mat4} out\r\n **/\n\nexport function scale(out, a, v) {\n var x = v[0],\n y = v[1],\n z = v[2];\n out[0] = a[0] * x;\n out[1] = a[1] * x;\n out[2] = a[2] * x;\n out[3] = a[3] * x;\n out[4] = a[4] * y;\n out[5] = a[5] * y;\n out[6] = a[6] * y;\n out[7] = a[7] * y;\n out[8] = a[8] * z;\n out[9] = a[9] * z;\n out[10] = a[10] * z;\n out[11] = a[11] * z;\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n return out;\n}\n/**\r\n * Rotates a mat4 by the given angle around the given axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @param {ReadonlyVec3} axis the axis to rotate around\r\n * @returns {mat4} out\r\n */\n\nexport function rotate(out, a, rad, axis) {\n var x = axis[0],\n y = axis[1],\n z = axis[2];\n var len = Math.hypot(x, y, z);\n var s, c, t;\n var a00, a01, a02, a03;\n var a10, a11, a12, a13;\n var a20, a21, a22, a23;\n var b00, b01, b02;\n var b10, b11, b12;\n var b20, b21, b22;\n\n if (len < glMatrix.EPSILON) {\n return null;\n }\n\n len = 1 / len;\n x *= len;\n y *= len;\n z *= len;\n s = Math.sin(rad);\n c = Math.cos(rad);\n t = 1 - c;\n a00 = a[0];\n a01 = a[1];\n a02 = a[2];\n a03 = a[3];\n a10 = a[4];\n a11 = a[5];\n a12 = a[6];\n a13 = a[7];\n a20 = a[8];\n a21 = a[9];\n a22 = a[10];\n a23 = a[11]; // Construct the elements of the rotation matrix\n\n b00 = x * x * t + c;\n b01 = y * x * t + z * s;\n b02 = z * x * t - y * s;\n b10 = x * y * t - z * s;\n b11 = y * y * t + c;\n b12 = z * y * t + x * s;\n b20 = x * z * t + y * s;\n b21 = y * z * t - x * s;\n b22 = z * z * t + c; // Perform rotation-specific matrix multiplication\n\n out[0] = a00 * b00 + a10 * b01 + a20 * b02;\n out[1] = a01 * b00 + a11 * b01 + a21 * b02;\n out[2] = a02 * b00 + a12 * b01 + a22 * b02;\n out[3] = a03 * b00 + a13 * b01 + a23 * b02;\n out[4] = a00 * b10 + a10 * b11 + a20 * b12;\n out[5] = a01 * b10 + a11 * b11 + a21 * b12;\n out[6] = a02 * b10 + a12 * b11 + a22 * b12;\n out[7] = a03 * b10 + a13 * b11 + a23 * b12;\n out[8] = a00 * b20 + a10 * b21 + a20 * b22;\n out[9] = a01 * b20 + a11 * b21 + a21 * b22;\n out[10] = a02 * b20 + a12 * b21 + a22 * b22;\n out[11] = a03 * b20 + a13 * b21 + a23 * b22;\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged last row\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n }\n\n return out;\n}\n/**\r\n * Rotates a matrix by the given angle around the X axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function rotateX(out, a, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad);\n var a10 = a[4];\n var a11 = a[5];\n var a12 = a[6];\n var a13 = a[7];\n var a20 = a[8];\n var a21 = a[9];\n var a22 = a[10];\n var a23 = a[11];\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged rows\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n } // Perform axis-specific matrix multiplication\n\n\n out[4] = a10 * c + a20 * s;\n out[5] = a11 * c + a21 * s;\n out[6] = a12 * c + a22 * s;\n out[7] = a13 * c + a23 * s;\n out[8] = a20 * c - a10 * s;\n out[9] = a21 * c - a11 * s;\n out[10] = a22 * c - a12 * s;\n out[11] = a23 * c - a13 * s;\n return out;\n}\n/**\r\n * Rotates a matrix by the given angle around the Y axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function rotateY(out, a, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad);\n var a00 = a[0];\n var a01 = a[1];\n var a02 = a[2];\n var a03 = a[3];\n var a20 = a[8];\n var a21 = a[9];\n var a22 = a[10];\n var a23 = a[11];\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged rows\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n } // Perform axis-specific matrix multiplication\n\n\n out[0] = a00 * c - a20 * s;\n out[1] = a01 * c - a21 * s;\n out[2] = a02 * c - a22 * s;\n out[3] = a03 * c - a23 * s;\n out[8] = a00 * s + a20 * c;\n out[9] = a01 * s + a21 * c;\n out[10] = a02 * s + a22 * c;\n out[11] = a03 * s + a23 * c;\n return out;\n}\n/**\r\n * Rotates a matrix by the given angle around the Z axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function rotateZ(out, a, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad);\n var a00 = a[0];\n var a01 = a[1];\n var a02 = a[2];\n var a03 = a[3];\n var a10 = a[4];\n var a11 = a[5];\n var a12 = a[6];\n var a13 = a[7];\n\n if (a !== out) {\n // If the source and destination differ, copy the unchanged last row\n out[8] = a[8];\n out[9] = a[9];\n out[10] = a[10];\n out[11] = a[11];\n out[12] = a[12];\n out[13] = a[13];\n out[14] = a[14];\n out[15] = a[15];\n } // Perform axis-specific matrix multiplication\n\n\n out[0] = a00 * c + a10 * s;\n out[1] = a01 * c + a11 * s;\n out[2] = a02 * c + a12 * s;\n out[3] = a03 * c + a13 * s;\n out[4] = a10 * c - a00 * s;\n out[5] = a11 * c - a01 * s;\n out[6] = a12 * c - a02 * s;\n out[7] = a13 * c - a03 * s;\n return out;\n}\n/**\r\n * Creates a matrix from a vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, dest, vec);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromTranslation(out, v) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = 1;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 1;\n out[11] = 0;\n out[12] = v[0];\n out[13] = v[1];\n out[14] = v[2];\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.scale(dest, dest, vec);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {ReadonlyVec3} v Scaling vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromScaling(out, v) {\n out[0] = v[0];\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = v[1];\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = v[2];\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a given angle around a given axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotate(dest, dest, rad, axis);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @param {ReadonlyVec3} axis the axis to rotate around\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotation(out, rad, axis) {\n var x = axis[0],\n y = axis[1],\n z = axis[2];\n var len = Math.hypot(x, y, z);\n var s, c, t;\n\n if (len < glMatrix.EPSILON) {\n return null;\n }\n\n len = 1 / len;\n x *= len;\n y *= len;\n z *= len;\n s = Math.sin(rad);\n c = Math.cos(rad);\n t = 1 - c; // Perform rotation-specific matrix multiplication\n\n out[0] = x * x * t + c;\n out[1] = y * x * t + z * s;\n out[2] = z * x * t - y * s;\n out[3] = 0;\n out[4] = x * y * t - z * s;\n out[5] = y * y * t + c;\n out[6] = z * y * t + x * s;\n out[7] = 0;\n out[8] = x * z * t + y * s;\n out[9] = y * z * t - x * s;\n out[10] = z * z * t + c;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from the given angle around the X axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateX(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function fromXRotation(out, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = c;\n out[6] = s;\n out[7] = 0;\n out[8] = 0;\n out[9] = -s;\n out[10] = c;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from the given angle around the Y axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateY(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function fromYRotation(out, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n out[0] = c;\n out[1] = 0;\n out[2] = -s;\n out[3] = 0;\n out[4] = 0;\n out[5] = 1;\n out[6] = 0;\n out[7] = 0;\n out[8] = s;\n out[9] = 0;\n out[10] = c;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from the given angle around the Z axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateZ(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\n\nexport function fromZRotation(out, rad) {\n var s = Math.sin(rad);\n var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n out[0] = c;\n out[1] = s;\n out[2] = 0;\n out[3] = 0;\n out[4] = -s;\n out[5] = c;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 1;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a quaternion rotation and vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotationTranslation(out, q, v) {\n // Quaternion math\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var xy = x * y2;\n var xz = x * z2;\n var yy = y * y2;\n var yz = y * z2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n out[0] = 1 - (yy + zz);\n out[1] = xy + wz;\n out[2] = xz - wy;\n out[3] = 0;\n out[4] = xy - wz;\n out[5] = 1 - (xx + zz);\n out[6] = yz + wx;\n out[7] = 0;\n out[8] = xz + wy;\n out[9] = yz - wx;\n out[10] = 1 - (xx + yy);\n out[11] = 0;\n out[12] = v[0];\n out[13] = v[1];\n out[14] = v[2];\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a new mat4 from a dual quat.\r\n *\r\n * @param {mat4} out Matrix\r\n * @param {ReadonlyQuat2} a Dual Quaternion\r\n * @returns {mat4} mat4 receiving operation result\r\n */\n\nexport function fromQuat2(out, a) {\n var translation = new glMatrix.ARRAY_TYPE(3);\n var bx = -a[0],\n by = -a[1],\n bz = -a[2],\n bw = a[3],\n ax = a[4],\n ay = a[5],\n az = a[6],\n aw = a[7];\n var magnitude = bx * bx + by * by + bz * bz + bw * bw; //Only scale if it makes sense\n\n if (magnitude > 0) {\n translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;\n translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;\n translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;\n } else {\n translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;\n translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;\n translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;\n }\n\n fromRotationTranslation(out, a, translation);\n return out;\n}\n/**\r\n * Returns the translation vector component of a transformation\r\n * matrix. If a matrix is built with fromRotationTranslation,\r\n * the returned vector will be the same as the translation vector\r\n * originally supplied.\r\n * @param {vec3} out Vector to receive translation component\r\n * @param {ReadonlyMat4} mat Matrix to be decomposed (input)\r\n * @return {vec3} out\r\n */\n\nexport function getTranslation(out, mat) {\n out[0] = mat[12];\n out[1] = mat[13];\n out[2] = mat[14];\n return out;\n}\n/**\r\n * Returns the scaling factor component of a transformation\r\n * matrix. If a matrix is built with fromRotationTranslationScale\r\n * with a normalized Quaternion paramter, the returned vector will be\r\n * the same as the scaling vector\r\n * originally supplied.\r\n * @param {vec3} out Vector to receive scaling factor component\r\n * @param {ReadonlyMat4} mat Matrix to be decomposed (input)\r\n * @return {vec3} out\r\n */\n\nexport function getScaling(out, mat) {\n var m11 = mat[0];\n var m12 = mat[1];\n var m13 = mat[2];\n var m21 = mat[4];\n var m22 = mat[5];\n var m23 = mat[6];\n var m31 = mat[8];\n var m32 = mat[9];\n var m33 = mat[10];\n out[0] = Math.hypot(m11, m12, m13);\n out[1] = Math.hypot(m21, m22, m23);\n out[2] = Math.hypot(m31, m32, m33);\n return out;\n}\n/**\r\n * Returns a quaternion representing the rotational component\r\n * of a transformation matrix. If a matrix is built with\r\n * fromRotationTranslation, the returned quaternion will be the\r\n * same as the quaternion originally supplied.\r\n * @param {quat} out Quaternion to receive the rotation component\r\n * @param {ReadonlyMat4} mat Matrix to be decomposed (input)\r\n * @return {quat} out\r\n */\n\nexport function getRotation(out, mat) {\n var scaling = new glMatrix.ARRAY_TYPE(3);\n getScaling(scaling, mat);\n var is1 = 1 / scaling[0];\n var is2 = 1 / scaling[1];\n var is3 = 1 / scaling[2];\n var sm11 = mat[0] * is1;\n var sm12 = mat[1] * is2;\n var sm13 = mat[2] * is3;\n var sm21 = mat[4] * is1;\n var sm22 = mat[5] * is2;\n var sm23 = mat[6] * is3;\n var sm31 = mat[8] * is1;\n var sm32 = mat[9] * is2;\n var sm33 = mat[10] * is3;\n var trace = sm11 + sm22 + sm33;\n var S = 0;\n\n if (trace > 0) {\n S = Math.sqrt(trace + 1.0) * 2;\n out[3] = 0.25 * S;\n out[0] = (sm23 - sm32) / S;\n out[1] = (sm31 - sm13) / S;\n out[2] = (sm12 - sm21) / S;\n } else if (sm11 > sm22 && sm11 > sm33) {\n S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;\n out[3] = (sm23 - sm32) / S;\n out[0] = 0.25 * S;\n out[1] = (sm12 + sm21) / S;\n out[2] = (sm31 + sm13) / S;\n } else if (sm22 > sm33) {\n S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;\n out[3] = (sm31 - sm13) / S;\n out[0] = (sm12 + sm21) / S;\n out[1] = 0.25 * S;\n out[2] = (sm23 + sm32) / S;\n } else {\n S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;\n out[3] = (sm12 - sm21) / S;\n out[0] = (sm31 + sm13) / S;\n out[1] = (sm23 + sm32) / S;\n out[2] = 0.25 * S;\n }\n\n return out;\n}\n/**\r\n * Creates a matrix from a quaternion rotation, vector translation and vector scale\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n * mat4.scale(dest, scale)\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @param {ReadonlyVec3} s Scaling vector\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotationTranslationScale(out, q, v, s) {\n // Quaternion math\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var xy = x * y2;\n var xz = x * z2;\n var yy = y * y2;\n var yz = y * z2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n var sx = s[0];\n var sy = s[1];\n var sz = s[2];\n out[0] = (1 - (yy + zz)) * sx;\n out[1] = (xy + wz) * sx;\n out[2] = (xz - wy) * sx;\n out[3] = 0;\n out[4] = (xy - wz) * sy;\n out[5] = (1 - (xx + zz)) * sy;\n out[6] = (yz + wx) * sy;\n out[7] = 0;\n out[8] = (xz + wy) * sz;\n out[9] = (yz - wx) * sz;\n out[10] = (1 - (xx + yy)) * sz;\n out[11] = 0;\n out[12] = v[0];\n out[13] = v[1];\n out[14] = v[2];\n out[15] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * mat4.translate(dest, origin);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n * mat4.scale(dest, scale)\r\n * mat4.translate(dest, negativeOrigin);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {ReadonlyVec3} v Translation vector\r\n * @param {ReadonlyVec3} s Scaling vector\r\n * @param {ReadonlyVec3} o The origin vector around which to scale and rotate\r\n * @returns {mat4} out\r\n */\n\nexport function fromRotationTranslationScaleOrigin(out, q, v, s, o) {\n // Quaternion math\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var xy = x * y2;\n var xz = x * z2;\n var yy = y * y2;\n var yz = y * z2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n var sx = s[0];\n var sy = s[1];\n var sz = s[2];\n var ox = o[0];\n var oy = o[1];\n var oz = o[2];\n var out0 = (1 - (yy + zz)) * sx;\n var out1 = (xy + wz) * sx;\n var out2 = (xz - wy) * sx;\n var out4 = (xy - wz) * sy;\n var out5 = (1 - (xx + zz)) * sy;\n var out6 = (yz + wx) * sy;\n var out8 = (xz + wy) * sz;\n var out9 = (yz - wx) * sz;\n var out10 = (1 - (xx + yy)) * sz;\n out[0] = out0;\n out[1] = out1;\n out[2] = out2;\n out[3] = 0;\n out[4] = out4;\n out[5] = out5;\n out[6] = out6;\n out[7] = 0;\n out[8] = out8;\n out[9] = out9;\n out[10] = out10;\n out[11] = 0;\n out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);\n out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);\n out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);\n out[15] = 1;\n return out;\n}\n/**\r\n * Calculates a 4x4 matrix from the given quaternion\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {ReadonlyQuat} q Quaternion to create matrix from\r\n *\r\n * @returns {mat4} out\r\n */\n\nexport function fromQuat(out, q) {\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var yx = y * x2;\n var yy = y * y2;\n var zx = z * x2;\n var zy = z * y2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n out[0] = 1 - yy - zz;\n out[1] = yx + wz;\n out[2] = zx - wy;\n out[3] = 0;\n out[4] = yx - wz;\n out[5] = 1 - xx - zz;\n out[6] = zy + wx;\n out[7] = 0;\n out[8] = zx + wy;\n out[9] = zy - wx;\n out[10] = 1 - xx - yy;\n out[11] = 0;\n out[12] = 0;\n out[13] = 0;\n out[14] = 0;\n out[15] = 1;\n return out;\n}\n/**\r\n * Generates a frustum matrix with the given bounds\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {Number} left Left bound of the frustum\r\n * @param {Number} right Right bound of the frustum\r\n * @param {Number} bottom Bottom bound of the frustum\r\n * @param {Number} top Top bound of the frustum\r\n * @param {Number} near Near bound of the frustum\r\n * @param {Number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\n\nexport function frustum(out, left, right, bottom, top, near, far) {\n var rl = 1 / (right - left);\n var tb = 1 / (top - bottom);\n var nf = 1 / (near - far);\n out[0] = near * 2 * rl;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = near * 2 * tb;\n out[6] = 0;\n out[7] = 0;\n out[8] = (right + left) * rl;\n out[9] = (top + bottom) * tb;\n out[10] = (far + near) * nf;\n out[11] = -1;\n out[12] = 0;\n out[13] = 0;\n out[14] = far * near * 2 * nf;\n out[15] = 0;\n return out;\n}\n/**\r\n * Generates a perspective projection matrix with the given bounds.\r\n * Passing null/undefined/no value for far will generate infinite projection matrix.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {number} fovy Vertical field of view in radians\r\n * @param {number} aspect Aspect ratio. typically viewport width/height\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum, can be null or Infinity\r\n * @returns {mat4} out\r\n */\n\nexport function perspective(out, fovy, aspect, near, far) {\n var f = 1.0 / Math.tan(fovy / 2),\n nf;\n out[0] = f / aspect;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = f;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[11] = -1;\n out[12] = 0;\n out[13] = 0;\n out[15] = 0;\n\n if (far != null && far !== Infinity) {\n nf = 1 / (near - far);\n out[10] = (far + near) * nf;\n out[14] = 2 * far * near * nf;\n } else {\n out[10] = -1;\n out[14] = -2 * near;\n }\n\n return out;\n}\n/**\r\n * Generates a perspective projection matrix with the given field of view.\r\n * This is primarily useful for generating projection matrices to be used\r\n * with the still experiemental WebVR API.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\n\nexport function perspectiveFromFieldOfView(out, fov, near, far) {\n var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0);\n var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0);\n var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0);\n var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0);\n var xScale = 2.0 / (leftTan + rightTan);\n var yScale = 2.0 / (upTan + downTan);\n out[0] = xScale;\n out[1] = 0.0;\n out[2] = 0.0;\n out[3] = 0.0;\n out[4] = 0.0;\n out[5] = yScale;\n out[6] = 0.0;\n out[7] = 0.0;\n out[8] = -((leftTan - rightTan) * xScale * 0.5);\n out[9] = (upTan - downTan) * yScale * 0.5;\n out[10] = far / (near - far);\n out[11] = -1.0;\n out[12] = 0.0;\n out[13] = 0.0;\n out[14] = far * near / (near - far);\n out[15] = 0.0;\n return out;\n}\n/**\r\n * Generates a orthogonal projection matrix with the given bounds\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {number} left Left bound of the frustum\r\n * @param {number} right Right bound of the frustum\r\n * @param {number} bottom Bottom bound of the frustum\r\n * @param {number} top Top bound of the frustum\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\n\nexport function ortho(out, left, right, bottom, top, near, far) {\n var lr = 1 / (left - right);\n var bt = 1 / (bottom - top);\n var nf = 1 / (near - far);\n out[0] = -2 * lr;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 0;\n out[5] = -2 * bt;\n out[6] = 0;\n out[7] = 0;\n out[8] = 0;\n out[9] = 0;\n out[10] = 2 * nf;\n out[11] = 0;\n out[12] = (left + right) * lr;\n out[13] = (top + bottom) * bt;\n out[14] = (far + near) * nf;\n out[15] = 1;\n return out;\n}\n/**\r\n * Generates a look-at matrix with the given eye position, focal point, and up axis.\r\n * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {ReadonlyVec3} eye Position of the viewer\r\n * @param {ReadonlyVec3} center Point the viewer is looking at\r\n * @param {ReadonlyVec3} up vec3 pointing up\r\n * @returns {mat4} out\r\n */\n\nexport function lookAt(out, eye, center, up) {\n var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;\n var eyex = eye[0];\n var eyey = eye[1];\n var eyez = eye[2];\n var upx = up[0];\n var upy = up[1];\n var upz = up[2];\n var centerx = center[0];\n var centery = center[1];\n var centerz = center[2];\n\n if (Math.abs(eyex - centerx) < glMatrix.EPSILON && Math.abs(eyey - centery) < glMatrix.EPSILON && Math.abs(eyez - centerz) < glMatrix.EPSILON) {\n return identity(out);\n }\n\n z0 = eyex - centerx;\n z1 = eyey - centery;\n z2 = eyez - centerz;\n len = 1 / Math.hypot(z0, z1, z2);\n z0 *= len;\n z1 *= len;\n z2 *= len;\n x0 = upy * z2 - upz * z1;\n x1 = upz * z0 - upx * z2;\n x2 = upx * z1 - upy * z0;\n len = Math.hypot(x0, x1, x2);\n\n if (!len) {\n x0 = 0;\n x1 = 0;\n x2 = 0;\n } else {\n len = 1 / len;\n x0 *= len;\n x1 *= len;\n x2 *= len;\n }\n\n y0 = z1 * x2 - z2 * x1;\n y1 = z2 * x0 - z0 * x2;\n y2 = z0 * x1 - z1 * x0;\n len = Math.hypot(y0, y1, y2);\n\n if (!len) {\n y0 = 0;\n y1 = 0;\n y2 = 0;\n } else {\n len = 1 / len;\n y0 *= len;\n y1 *= len;\n y2 *= len;\n }\n\n out[0] = x0;\n out[1] = y0;\n out[2] = z0;\n out[3] = 0;\n out[4] = x1;\n out[5] = y1;\n out[6] = z1;\n out[7] = 0;\n out[8] = x2;\n out[9] = y2;\n out[10] = z2;\n out[11] = 0;\n out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);\n out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);\n out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);\n out[15] = 1;\n return out;\n}\n/**\r\n * Generates a matrix that makes something look at something else.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {ReadonlyVec3} eye Position of the viewer\r\n * @param {ReadonlyVec3} center Point the viewer is looking at\r\n * @param {ReadonlyVec3} up vec3 pointing up\r\n * @returns {mat4} out\r\n */\n\nexport function targetTo(out, eye, target, up) {\n var eyex = eye[0],\n eyey = eye[1],\n eyez = eye[2],\n upx = up[0],\n upy = up[1],\n upz = up[2];\n var z0 = eyex - target[0],\n z1 = eyey - target[1],\n z2 = eyez - target[2];\n var len = z0 * z0 + z1 * z1 + z2 * z2;\n\n if (len > 0) {\n len = 1 / Math.sqrt(len);\n z0 *= len;\n z1 *= len;\n z2 *= len;\n }\n\n var x0 = upy * z2 - upz * z1,\n x1 = upz * z0 - upx * z2,\n x2 = upx * z1 - upy * z0;\n len = x0 * x0 + x1 * x1 + x2 * x2;\n\n if (len > 0) {\n len = 1 / Math.sqrt(len);\n x0 *= len;\n x1 *= len;\n x2 *= len;\n }\n\n out[0] = x0;\n out[1] = x1;\n out[2] = x2;\n out[3] = 0;\n out[4] = z1 * x2 - z2 * x1;\n out[5] = z2 * x0 - z0 * x2;\n out[6] = z0 * x1 - z1 * x0;\n out[7] = 0;\n out[8] = z0;\n out[9] = z1;\n out[10] = z2;\n out[11] = 0;\n out[12] = eyex;\n out[13] = eyey;\n out[14] = eyez;\n out[15] = 1;\n return out;\n}\n/**\r\n * Returns a string representation of a mat4\r\n *\r\n * @param {ReadonlyMat4} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\n\nexport function str(a) {\n return \"mat4(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \", \" + a[4] + \", \" + a[5] + \", \" + a[6] + \", \" + a[7] + \", \" + a[8] + \", \" + a[9] + \", \" + a[10] + \", \" + a[11] + \", \" + a[12] + \", \" + a[13] + \", \" + a[14] + \", \" + a[15] + \")\";\n}\n/**\r\n * Returns Frobenius norm of a mat4\r\n *\r\n * @param {ReadonlyMat4} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\n\nexport function frob(a) {\n return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);\n}\n/**\r\n * Adds two mat4's\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @returns {mat4} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n out[3] = a[3] + b[3];\n out[4] = a[4] + b[4];\n out[5] = a[5] + b[5];\n out[6] = a[6] + b[6];\n out[7] = a[7] + b[7];\n out[8] = a[8] + b[8];\n out[9] = a[9] + b[9];\n out[10] = a[10] + b[10];\n out[11] = a[11] + b[11];\n out[12] = a[12] + b[12];\n out[13] = a[13] + b[13];\n out[14] = a[14] + b[14];\n out[15] = a[15] + b[15];\n return out;\n}\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @returns {mat4} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n out[3] = a[3] - b[3];\n out[4] = a[4] - b[4];\n out[5] = a[5] - b[5];\n out[6] = a[6] - b[6];\n out[7] = a[7] - b[7];\n out[8] = a[8] - b[8];\n out[9] = a[9] - b[9];\n out[10] = a[10] - b[10];\n out[11] = a[11] - b[11];\n out[12] = a[12] - b[12];\n out[13] = a[13] - b[13];\n out[14] = a[14] - b[14];\n out[15] = a[15] - b[15];\n return out;\n}\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {ReadonlyMat4} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat4} out\r\n */\n\nexport function multiplyScalar(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n out[3] = a[3] * b;\n out[4] = a[4] * b;\n out[5] = a[5] * b;\n out[6] = a[6] * b;\n out[7] = a[7] * b;\n out[8] = a[8] * b;\n out[9] = a[9] * b;\n out[10] = a[10] * b;\n out[11] = a[11] * b;\n out[12] = a[12] * b;\n out[13] = a[13] * b;\n out[14] = a[14] * b;\n out[15] = a[15] * b;\n return out;\n}\n/**\r\n * Adds two mat4's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat4} out the receiving vector\r\n * @param {ReadonlyMat4} a the first operand\r\n * @param {ReadonlyMat4} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat4} out\r\n */\n\nexport function multiplyScalarAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n out[3] = a[3] + b[3] * scale;\n out[4] = a[4] + b[4] * scale;\n out[5] = a[5] + b[5] * scale;\n out[6] = a[6] + b[6] * scale;\n out[7] = a[7] + b[7] * scale;\n out[8] = a[8] + b[8] * scale;\n out[9] = a[9] + b[9] * scale;\n out[10] = a[10] + b[10] * scale;\n out[11] = a[11] + b[11] * scale;\n out[12] = a[12] + b[12] * scale;\n out[13] = a[13] + b[13] * scale;\n out[14] = a[14] + b[14] * scale;\n out[15] = a[15] + b[15] * scale;\n return out;\n}\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyMat4} a The first matrix.\r\n * @param {ReadonlyMat4} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];\n}\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyMat4} a The first matrix.\r\n * @param {ReadonlyMat4} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3];\n var a4 = a[4],\n a5 = a[5],\n a6 = a[6],\n a7 = a[7];\n var a8 = a[8],\n a9 = a[9],\n a10 = a[10],\n a11 = a[11];\n var a12 = a[12],\n a13 = a[13],\n a14 = a[14],\n a15 = a[15];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3];\n var b4 = b[4],\n b5 = b[5],\n b6 = b[6],\n b7 = b[7];\n var b8 = b[8],\n b9 = b[9],\n b10 = b[10],\n b11 = b[11];\n var b12 = b[12],\n b13 = b[13],\n b14 = b[14],\n b15 = b[15];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15));\n}\n/**\r\n * Alias for {@link mat4.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link mat4.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\n/**\r\n * 2 Dimensional Vector\r\n * @module vec2\r\n */\n\n/**\r\n * Creates a new, empty vec2\r\n *\r\n * @returns {vec2} a new 2D vector\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(2);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n }\n\n return out;\n}\n/**\r\n * Creates a new vec2 initialized with values from an existing vector\r\n *\r\n * @param {ReadonlyVec2} a vector to clone\r\n * @returns {vec2} a new 2D vector\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(2);\n out[0] = a[0];\n out[1] = a[1];\n return out;\n}\n/**\r\n * Creates a new vec2 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @returns {vec2} a new 2D vector\r\n */\n\nexport function fromValues(x, y) {\n var out = new glMatrix.ARRAY_TYPE(2);\n out[0] = x;\n out[1] = y;\n return out;\n}\n/**\r\n * Copy the values from one vec2 to another\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the source vector\r\n * @returns {vec2} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n return out;\n}\n/**\r\n * Set the components of a vec2 to the given values\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @returns {vec2} out\r\n */\n\nexport function set(out, x, y) {\n out[0] = x;\n out[1] = y;\n return out;\n}\n/**\r\n * Adds two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n return out;\n}\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n return out;\n}\n/**\r\n * Multiplies two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function multiply(out, a, b) {\n out[0] = a[0] * b[0];\n out[1] = a[1] * b[1];\n return out;\n}\n/**\r\n * Divides two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function divide(out, a, b) {\n out[0] = a[0] / b[0];\n out[1] = a[1] / b[1];\n return out;\n}\n/**\r\n * Math.ceil the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to ceil\r\n * @returns {vec2} out\r\n */\n\nexport function ceil(out, a) {\n out[0] = Math.ceil(a[0]);\n out[1] = Math.ceil(a[1]);\n return out;\n}\n/**\r\n * Math.floor the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to floor\r\n * @returns {vec2} out\r\n */\n\nexport function floor(out, a) {\n out[0] = Math.floor(a[0]);\n out[1] = Math.floor(a[1]);\n return out;\n}\n/**\r\n * Returns the minimum of two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function min(out, a, b) {\n out[0] = Math.min(a[0], b[0]);\n out[1] = Math.min(a[1], b[1]);\n return out;\n}\n/**\r\n * Returns the maximum of two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec2} out\r\n */\n\nexport function max(out, a, b) {\n out[0] = Math.max(a[0], b[0]);\n out[1] = Math.max(a[1], b[1]);\n return out;\n}\n/**\r\n * Math.round the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to round\r\n * @returns {vec2} out\r\n */\n\nexport function round(out, a) {\n out[0] = Math.round(a[0]);\n out[1] = Math.round(a[1]);\n return out;\n}\n/**\r\n * Scales a vec2 by a scalar number\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec2} out\r\n */\n\nexport function scale(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n return out;\n}\n/**\r\n * Adds two vec2's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec2} out\r\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n return out;\n}\n/**\r\n * Calculates the euclidian distance between two vec2's\r\n *\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\n\nexport function distance(a, b) {\n var x = b[0] - a[0],\n y = b[1] - a[1];\n return Math.hypot(x, y);\n}\n/**\r\n * Calculates the squared euclidian distance between two vec2's\r\n *\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\n\nexport function squaredDistance(a, b) {\n var x = b[0] - a[0],\n y = b[1] - a[1];\n return x * x + y * y;\n}\n/**\r\n * Calculates the length of a vec2\r\n *\r\n * @param {ReadonlyVec2} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport function length(a) {\n var x = a[0],\n y = a[1];\n return Math.hypot(x, y);\n}\n/**\r\n * Calculates the squared length of a vec2\r\n *\r\n * @param {ReadonlyVec2} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\n\nexport function squaredLength(a) {\n var x = a[0],\n y = a[1];\n return x * x + y * y;\n}\n/**\r\n * Negates the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to negate\r\n * @returns {vec2} out\r\n */\n\nexport function negate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n return out;\n}\n/**\r\n * Returns the inverse of the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to invert\r\n * @returns {vec2} out\r\n */\n\nexport function inverse(out, a) {\n out[0] = 1.0 / a[0];\n out[1] = 1.0 / a[1];\n return out;\n}\n/**\r\n * Normalize a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a vector to normalize\r\n * @returns {vec2} out\r\n */\n\nexport function normalize(out, a) {\n var x = a[0],\n y = a[1];\n var len = x * x + y * y;\n\n if (len > 0) {\n //TODO: evaluate use of glm_invsqrt here?\n len = 1 / Math.sqrt(len);\n }\n\n out[0] = a[0] * len;\n out[1] = a[1] * len;\n return out;\n}\n/**\r\n * Calculates the dot product of two vec2's\r\n *\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\n\nexport function dot(a, b) {\n return a[0] * b[0] + a[1] * b[1];\n}\n/**\r\n * Computes the cross product of two vec2's\r\n * Note that the cross product must by definition produce a 3D vector\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function cross(out, a, b) {\n var z = a[0] * b[1] - a[1] * b[0];\n out[0] = out[1] = 0;\n out[2] = z;\n return out;\n}\n/**\r\n * Performs a linear interpolation between two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the first operand\r\n * @param {ReadonlyVec2} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec2} out\r\n */\n\nexport function lerp(out, a, b, t) {\n var ax = a[0],\n ay = a[1];\n out[0] = ax + t * (b[0] - ax);\n out[1] = ay + t * (b[1] - ay);\n return out;\n}\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec2} out\r\n */\n\nexport function random(out, scale) {\n scale = scale || 1.0;\n var r = glMatrix.RANDOM() * 2.0 * Math.PI;\n out[0] = Math.cos(r) * scale;\n out[1] = Math.sin(r) * scale;\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat2} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat2(out, a, m) {\n var x = a[0],\n y = a[1];\n out[0] = m[0] * x + m[2] * y;\n out[1] = m[1] * x + m[3] * y;\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat2d\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat2d} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat2d(out, a, m) {\n var x = a[0],\n y = a[1];\n out[0] = m[0] * x + m[2] * y + m[4];\n out[1] = m[1] * x + m[3] * y + m[5];\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat3\r\n * 3rd vector component is implicitly '1'\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat3} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat3(out, a, m) {\n var x = a[0],\n y = a[1];\n out[0] = m[0] * x + m[3] * y + m[6];\n out[1] = m[1] * x + m[4] * y + m[7];\n return out;\n}\n/**\r\n * Transforms the vec2 with a mat4\r\n * 3rd vector component is implicitly '0'\r\n * 4th vector component is implicitly '1'\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {ReadonlyVec2} a the vector to transform\r\n * @param {ReadonlyMat4} m matrix to transform with\r\n * @returns {vec2} out\r\n */\n\nexport function transformMat4(out, a, m) {\n var x = a[0];\n var y = a[1];\n out[0] = m[0] * x + m[4] * y + m[12];\n out[1] = m[1] * x + m[5] * y + m[13];\n return out;\n}\n/**\r\n * Rotate a 2D vector\r\n * @param {vec2} out The receiving vec2\r\n * @param {ReadonlyVec2} a The vec2 point to rotate\r\n * @param {ReadonlyVec2} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec2} out\r\n */\n\nexport function rotate(out, a, b, rad) {\n //Translate point to the origin\n var p0 = a[0] - b[0],\n p1 = a[1] - b[1],\n sinC = Math.sin(rad),\n cosC = Math.cos(rad); //perform rotation and translate to correct position\n\n out[0] = p0 * cosC - p1 * sinC + b[0];\n out[1] = p0 * sinC + p1 * cosC + b[1];\n return out;\n}\n/**\r\n * Get the angle between two 2D vectors\r\n * @param {ReadonlyVec2} a The first operand\r\n * @param {ReadonlyVec2} b The second operand\r\n * @returns {Number} The angle in radians\r\n */\n\nexport function angle(a, b) {\n var x1 = a[0],\n y1 = a[1],\n x2 = b[0],\n y2 = b[1],\n // mag is the product of the magnitudes of a and b\n mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2),\n // mag &&.. short circuits if mag == 0\n cosine = mag && (x1 * x2 + y1 * y2) / mag; // Math.min(Math.max(cosine, -1), 1) clamps the cosine between -1 and 1\n\n return Math.acos(Math.min(Math.max(cosine, -1), 1));\n}\n/**\r\n * Set the components of a vec2 to zero\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @returns {vec2} out\r\n */\n\nexport function zero(out) {\n out[0] = 0.0;\n out[1] = 0.0;\n return out;\n}\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {ReadonlyVec2} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"vec2(\" + a[0] + \", \" + a[1] + \")\";\n}\n/**\r\n * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyVec2} a The first vector.\r\n * @param {ReadonlyVec2} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1];\n}\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyVec2} a The first vector.\r\n * @param {ReadonlyVec2} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1];\n var b0 = b[0],\n b1 = b[1];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1));\n}\n/**\r\n * Alias for {@link vec2.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Alias for {@link vec2.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;\n/**\r\n * Alias for {@link vec2.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link vec2.divide}\r\n * @function\r\n */\n\nexport var div = divide;\n/**\r\n * Alias for {@link vec2.distance}\r\n * @function\r\n */\n\nexport var dist = distance;\n/**\r\n * Alias for {@link vec2.squaredDistance}\r\n * @function\r\n */\n\nexport var sqrDist = squaredDistance;\n/**\r\n * Alias for {@link vec2.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Perform some operation over an array of vec2s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\n\nexport var forEach = function () {\n var vec = create();\n return function (a, stride, offset, count, fn, arg) {\n var i, l;\n\n if (!stride) {\n stride = 2;\n }\n\n if (!offset) {\n offset = 0;\n }\n\n if (count) {\n l = Math.min(count * stride + offset, a.length);\n } else {\n l = a.length;\n }\n\n for (i = offset; i < l; i += stride) {\n vec[0] = a[i];\n vec[1] = a[i + 1];\n fn(vec, vec, arg);\n a[i] = vec[0];\n a[i + 1] = vec[1];\n }\n\n return a;\n };\n}();","import * as glMatrix from \"./common.js\";\n/**\r\n * 3 Dimensional Vector\r\n * @module vec3\r\n */\n\n/**\r\n * Creates a new, empty vec3\r\n *\r\n * @returns {vec3} a new 3D vector\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(3);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n }\n\n return out;\n}\n/**\r\n * Creates a new vec3 initialized with values from an existing vector\r\n *\r\n * @param {ReadonlyVec3} a vector to clone\r\n * @returns {vec3} a new 3D vector\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(3);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n return out;\n}\n/**\r\n * Calculates the length of a vec3\r\n *\r\n * @param {ReadonlyVec3} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport function length(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n return Math.hypot(x, y, z);\n}\n/**\r\n * Creates a new vec3 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @returns {vec3} a new 3D vector\r\n */\n\nexport function fromValues(x, y, z) {\n var out = new glMatrix.ARRAY_TYPE(3);\n out[0] = x;\n out[1] = y;\n out[2] = z;\n return out;\n}\n/**\r\n * Copy the values from one vec3 to another\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the source vector\r\n * @returns {vec3} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n return out;\n}\n/**\r\n * Set the components of a vec3 to the given values\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @returns {vec3} out\r\n */\n\nexport function set(out, x, y, z) {\n out[0] = x;\n out[1] = y;\n out[2] = z;\n return out;\n}\n/**\r\n * Adds two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n return out;\n}\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n return out;\n}\n/**\r\n * Multiplies two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function multiply(out, a, b) {\n out[0] = a[0] * b[0];\n out[1] = a[1] * b[1];\n out[2] = a[2] * b[2];\n return out;\n}\n/**\r\n * Divides two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function divide(out, a, b) {\n out[0] = a[0] / b[0];\n out[1] = a[1] / b[1];\n out[2] = a[2] / b[2];\n return out;\n}\n/**\r\n * Math.ceil the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to ceil\r\n * @returns {vec3} out\r\n */\n\nexport function ceil(out, a) {\n out[0] = Math.ceil(a[0]);\n out[1] = Math.ceil(a[1]);\n out[2] = Math.ceil(a[2]);\n return out;\n}\n/**\r\n * Math.floor the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to floor\r\n * @returns {vec3} out\r\n */\n\nexport function floor(out, a) {\n out[0] = Math.floor(a[0]);\n out[1] = Math.floor(a[1]);\n out[2] = Math.floor(a[2]);\n return out;\n}\n/**\r\n * Returns the minimum of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function min(out, a, b) {\n out[0] = Math.min(a[0], b[0]);\n out[1] = Math.min(a[1], b[1]);\n out[2] = Math.min(a[2], b[2]);\n return out;\n}\n/**\r\n * Returns the maximum of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function max(out, a, b) {\n out[0] = Math.max(a[0], b[0]);\n out[1] = Math.max(a[1], b[1]);\n out[2] = Math.max(a[2], b[2]);\n return out;\n}\n/**\r\n * Math.round the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to round\r\n * @returns {vec3} out\r\n */\n\nexport function round(out, a) {\n out[0] = Math.round(a[0]);\n out[1] = Math.round(a[1]);\n out[2] = Math.round(a[2]);\n return out;\n}\n/**\r\n * Scales a vec3 by a scalar number\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec3} out\r\n */\n\nexport function scale(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n return out;\n}\n/**\r\n * Adds two vec3's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec3} out\r\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n return out;\n}\n/**\r\n * Calculates the euclidian distance between two vec3's\r\n *\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\n\nexport function distance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n return Math.hypot(x, y, z);\n}\n/**\r\n * Calculates the squared euclidian distance between two vec3's\r\n *\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\n\nexport function squaredDistance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n return x * x + y * y + z * z;\n}\n/**\r\n * Calculates the squared length of a vec3\r\n *\r\n * @param {ReadonlyVec3} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\n\nexport function squaredLength(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n return x * x + y * y + z * z;\n}\n/**\r\n * Negates the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to negate\r\n * @returns {vec3} out\r\n */\n\nexport function negate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n out[2] = -a[2];\n return out;\n}\n/**\r\n * Returns the inverse of the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to invert\r\n * @returns {vec3} out\r\n */\n\nexport function inverse(out, a) {\n out[0] = 1.0 / a[0];\n out[1] = 1.0 / a[1];\n out[2] = 1.0 / a[2];\n return out;\n}\n/**\r\n * Normalize a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a vector to normalize\r\n * @returns {vec3} out\r\n */\n\nexport function normalize(out, a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var len = x * x + y * y + z * z;\n\n if (len > 0) {\n //TODO: evaluate use of glm_invsqrt here?\n len = 1 / Math.sqrt(len);\n }\n\n out[0] = a[0] * len;\n out[1] = a[1] * len;\n out[2] = a[2] * len;\n return out;\n}\n/**\r\n * Calculates the dot product of two vec3's\r\n *\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\n\nexport function dot(a, b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n/**\r\n * Computes the cross product of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @returns {vec3} out\r\n */\n\nexport function cross(out, a, b) {\n var ax = a[0],\n ay = a[1],\n az = a[2];\n var bx = b[0],\n by = b[1],\n bz = b[2];\n out[0] = ay * bz - az * by;\n out[1] = az * bx - ax * bz;\n out[2] = ax * by - ay * bx;\n return out;\n}\n/**\r\n * Performs a linear interpolation between two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\n\nexport function lerp(out, a, b, t) {\n var ax = a[0];\n var ay = a[1];\n var az = a[2];\n out[0] = ax + t * (b[0] - ax);\n out[1] = ay + t * (b[1] - ay);\n out[2] = az + t * (b[2] - az);\n return out;\n}\n/**\r\n * Performs a hermite interpolation with two control points\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {ReadonlyVec3} c the third operand\r\n * @param {ReadonlyVec3} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\n\nexport function hermite(out, a, b, c, d, t) {\n var factorTimes2 = t * t;\n var factor1 = factorTimes2 * (2 * t - 3) + 1;\n var factor2 = factorTimes2 * (t - 2) + t;\n var factor3 = factorTimes2 * (t - 1);\n var factor4 = factorTimes2 * (3 - 2 * t);\n out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\n out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\n out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\n return out;\n}\n/**\r\n * Performs a bezier interpolation with two control points\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the first operand\r\n * @param {ReadonlyVec3} b the second operand\r\n * @param {ReadonlyVec3} c the third operand\r\n * @param {ReadonlyVec3} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\n\nexport function bezier(out, a, b, c, d, t) {\n var inverseFactor = 1 - t;\n var inverseFactorTimesTwo = inverseFactor * inverseFactor;\n var factorTimes2 = t * t;\n var factor1 = inverseFactorTimesTwo * inverseFactor;\n var factor2 = 3 * t * inverseFactorTimesTwo;\n var factor3 = 3 * factorTimes2 * inverseFactor;\n var factor4 = factorTimes2 * t;\n out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\n out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\n out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\n return out;\n}\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec3} out\r\n */\n\nexport function random(out, scale) {\n scale = scale || 1.0;\n var r = glMatrix.RANDOM() * 2.0 * Math.PI;\n var z = glMatrix.RANDOM() * 2.0 - 1.0;\n var zScale = Math.sqrt(1.0 - z * z) * scale;\n out[0] = Math.cos(r) * zScale;\n out[1] = Math.sin(r) * zScale;\n out[2] = z * scale;\n return out;\n}\n/**\r\n * Transforms the vec3 with a mat4.\r\n * 4th vector component is implicitly '1'\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to transform\r\n * @param {ReadonlyMat4} m matrix to transform with\r\n * @returns {vec3} out\r\n */\n\nexport function transformMat4(out, a, m) {\n var x = a[0],\n y = a[1],\n z = a[2];\n var w = m[3] * x + m[7] * y + m[11] * z + m[15];\n w = w || 1.0;\n out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;\n out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;\n out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;\n return out;\n}\n/**\r\n * Transforms the vec3 with a mat3.\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to transform\r\n * @param {ReadonlyMat3} m the 3x3 matrix to transform with\r\n * @returns {vec3} out\r\n */\n\nexport function transformMat3(out, a, m) {\n var x = a[0],\n y = a[1],\n z = a[2];\n out[0] = x * m[0] + y * m[3] + z * m[6];\n out[1] = x * m[1] + y * m[4] + z * m[7];\n out[2] = x * m[2] + y * m[5] + z * m[8];\n return out;\n}\n/**\r\n * Transforms the vec3 with a quat\r\n * Can also be used for dual quaternions. (Multiply it with the real part)\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {ReadonlyVec3} a the vector to transform\r\n * @param {ReadonlyQuat} q quaternion to transform with\r\n * @returns {vec3} out\r\n */\n\nexport function transformQuat(out, a, q) {\n // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed\n var qx = q[0],\n qy = q[1],\n qz = q[2],\n qw = q[3];\n var x = a[0],\n y = a[1],\n z = a[2]; // var qvec = [qx, qy, qz];\n // var uv = vec3.cross([], qvec, a);\n\n var uvx = qy * z - qz * y,\n uvy = qz * x - qx * z,\n uvz = qx * y - qy * x; // var uuv = vec3.cross([], qvec, uv);\n\n var uuvx = qy * uvz - qz * uvy,\n uuvy = qz * uvx - qx * uvz,\n uuvz = qx * uvy - qy * uvx; // vec3.scale(uv, uv, 2 * w);\n\n var w2 = qw * 2;\n uvx *= w2;\n uvy *= w2;\n uvz *= w2; // vec3.scale(uuv, uuv, 2);\n\n uuvx *= 2;\n uuvy *= 2;\n uuvz *= 2; // return vec3.add(out, a, vec3.add(out, uv, uuv));\n\n out[0] = x + uvx + uuvx;\n out[1] = y + uvy + uuvy;\n out[2] = z + uvz + uuvz;\n return out;\n}\n/**\r\n * Rotate a 3D vector around the x-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {ReadonlyVec3} a The vec3 point to rotate\r\n * @param {ReadonlyVec3} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec3} out\r\n */\n\nexport function rotateX(out, a, b, rad) {\n var p = [],\n r = []; //Translate point to the origin\n\n p[0] = a[0] - b[0];\n p[1] = a[1] - b[1];\n p[2] = a[2] - b[2]; //perform rotation\n\n r[0] = p[0];\n r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);\n r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); //translate to correct position\n\n out[0] = r[0] + b[0];\n out[1] = r[1] + b[1];\n out[2] = r[2] + b[2];\n return out;\n}\n/**\r\n * Rotate a 3D vector around the y-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {ReadonlyVec3} a The vec3 point to rotate\r\n * @param {ReadonlyVec3} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec3} out\r\n */\n\nexport function rotateY(out, a, b, rad) {\n var p = [],\n r = []; //Translate point to the origin\n\n p[0] = a[0] - b[0];\n p[1] = a[1] - b[1];\n p[2] = a[2] - b[2]; //perform rotation\n\n r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);\n r[1] = p[1];\n r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); //translate to correct position\n\n out[0] = r[0] + b[0];\n out[1] = r[1] + b[1];\n out[2] = r[2] + b[2];\n return out;\n}\n/**\r\n * Rotate a 3D vector around the z-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {ReadonlyVec3} a The vec3 point to rotate\r\n * @param {ReadonlyVec3} b The origin of the rotation\r\n * @param {Number} rad The angle of rotation in radians\r\n * @returns {vec3} out\r\n */\n\nexport function rotateZ(out, a, b, rad) {\n var p = [],\n r = []; //Translate point to the origin\n\n p[0] = a[0] - b[0];\n p[1] = a[1] - b[1];\n p[2] = a[2] - b[2]; //perform rotation\n\n r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);\n r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);\n r[2] = p[2]; //translate to correct position\n\n out[0] = r[0] + b[0];\n out[1] = r[1] + b[1];\n out[2] = r[2] + b[2];\n return out;\n}\n/**\r\n * Get the angle between two 3D vectors\r\n * @param {ReadonlyVec3} a The first operand\r\n * @param {ReadonlyVec3} b The second operand\r\n * @returns {Number} The angle in radians\r\n */\n\nexport function angle(a, b) {\n var ax = a[0],\n ay = a[1],\n az = a[2],\n bx = b[0],\n by = b[1],\n bz = b[2],\n mag1 = Math.sqrt(ax * ax + ay * ay + az * az),\n mag2 = Math.sqrt(bx * bx + by * by + bz * bz),\n mag = mag1 * mag2,\n cosine = mag && dot(a, b) / mag;\n return Math.acos(Math.min(Math.max(cosine, -1), 1));\n}\n/**\r\n * Set the components of a vec3 to zero\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @returns {vec3} out\r\n */\n\nexport function zero(out) {\n out[0] = 0.0;\n out[1] = 0.0;\n out[2] = 0.0;\n return out;\n}\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {ReadonlyVec3} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"vec3(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \")\";\n}\n/**\r\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyVec3} a The first vector.\r\n * @param {ReadonlyVec3} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];\n}\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyVec3} a The first vector.\r\n * @param {ReadonlyVec3} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2));\n}\n/**\r\n * Alias for {@link vec3.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;\n/**\r\n * Alias for {@link vec3.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link vec3.divide}\r\n * @function\r\n */\n\nexport var div = divide;\n/**\r\n * Alias for {@link vec3.distance}\r\n * @function\r\n */\n\nexport var dist = distance;\n/**\r\n * Alias for {@link vec3.squaredDistance}\r\n * @function\r\n */\n\nexport var sqrDist = squaredDistance;\n/**\r\n * Alias for {@link vec3.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Alias for {@link vec3.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Perform some operation over an array of vec3s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\n\nexport var forEach = function () {\n var vec = create();\n return function (a, stride, offset, count, fn, arg) {\n var i, l;\n\n if (!stride) {\n stride = 3;\n }\n\n if (!offset) {\n offset = 0;\n }\n\n if (count) {\n l = Math.min(count * stride + offset, a.length);\n } else {\n l = a.length;\n }\n\n for (i = offset; i < l; i += stride) {\n vec[0] = a[i];\n vec[1] = a[i + 1];\n vec[2] = a[i + 2];\n fn(vec, vec, arg);\n a[i] = vec[0];\n a[i + 1] = vec[1];\n a[i + 2] = vec[2];\n }\n\n return a;\n };\n}();","import * as glMatrix from \"./common.js\";\n/**\r\n * 4 Dimensional Vector\r\n * @module vec4\r\n */\n\n/**\r\n * Creates a new, empty vec4\r\n *\r\n * @returns {vec4} a new 4D vector\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(4);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n }\n\n return out;\n}\n/**\r\n * Creates a new vec4 initialized with values from an existing vector\r\n *\r\n * @param {ReadonlyVec4} a vector to clone\r\n * @returns {vec4} a new 4D vector\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(4);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n return out;\n}\n/**\r\n * Creates a new vec4 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {vec4} a new 4D vector\r\n */\n\nexport function fromValues(x, y, z, w) {\n var out = new glMatrix.ARRAY_TYPE(4);\n out[0] = x;\n out[1] = y;\n out[2] = z;\n out[3] = w;\n return out;\n}\n/**\r\n * Copy the values from one vec4 to another\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the source vector\r\n * @returns {vec4} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n return out;\n}\n/**\r\n * Set the components of a vec4 to the given values\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {vec4} out\r\n */\n\nexport function set(out, x, y, z, w) {\n out[0] = x;\n out[1] = y;\n out[2] = z;\n out[3] = w;\n return out;\n}\n/**\r\n * Adds two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n out[3] = a[3] + b[3];\n return out;\n}\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n out[3] = a[3] - b[3];\n return out;\n}\n/**\r\n * Multiplies two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function multiply(out, a, b) {\n out[0] = a[0] * b[0];\n out[1] = a[1] * b[1];\n out[2] = a[2] * b[2];\n out[3] = a[3] * b[3];\n return out;\n}\n/**\r\n * Divides two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function divide(out, a, b) {\n out[0] = a[0] / b[0];\n out[1] = a[1] / b[1];\n out[2] = a[2] / b[2];\n out[3] = a[3] / b[3];\n return out;\n}\n/**\r\n * Math.ceil the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to ceil\r\n * @returns {vec4} out\r\n */\n\nexport function ceil(out, a) {\n out[0] = Math.ceil(a[0]);\n out[1] = Math.ceil(a[1]);\n out[2] = Math.ceil(a[2]);\n out[3] = Math.ceil(a[3]);\n return out;\n}\n/**\r\n * Math.floor the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to floor\r\n * @returns {vec4} out\r\n */\n\nexport function floor(out, a) {\n out[0] = Math.floor(a[0]);\n out[1] = Math.floor(a[1]);\n out[2] = Math.floor(a[2]);\n out[3] = Math.floor(a[3]);\n return out;\n}\n/**\r\n * Returns the minimum of two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function min(out, a, b) {\n out[0] = Math.min(a[0], b[0]);\n out[1] = Math.min(a[1], b[1]);\n out[2] = Math.min(a[2], b[2]);\n out[3] = Math.min(a[3], b[3]);\n return out;\n}\n/**\r\n * Returns the maximum of two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {vec4} out\r\n */\n\nexport function max(out, a, b) {\n out[0] = Math.max(a[0], b[0]);\n out[1] = Math.max(a[1], b[1]);\n out[2] = Math.max(a[2], b[2]);\n out[3] = Math.max(a[3], b[3]);\n return out;\n}\n/**\r\n * Math.round the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to round\r\n * @returns {vec4} out\r\n */\n\nexport function round(out, a) {\n out[0] = Math.round(a[0]);\n out[1] = Math.round(a[1]);\n out[2] = Math.round(a[2]);\n out[3] = Math.round(a[3]);\n return out;\n}\n/**\r\n * Scales a vec4 by a scalar number\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec4} out\r\n */\n\nexport function scale(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n out[3] = a[3] * b;\n return out;\n}\n/**\r\n * Adds two vec4's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec4} out\r\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n out[3] = a[3] + b[3] * scale;\n return out;\n}\n/**\r\n * Calculates the euclidian distance between two vec4's\r\n *\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\n\nexport function distance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n var w = b[3] - a[3];\n return Math.hypot(x, y, z, w);\n}\n/**\r\n * Calculates the squared euclidian distance between two vec4's\r\n *\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\n\nexport function squaredDistance(a, b) {\n var x = b[0] - a[0];\n var y = b[1] - a[1];\n var z = b[2] - a[2];\n var w = b[3] - a[3];\n return x * x + y * y + z * z + w * w;\n}\n/**\r\n * Calculates the length of a vec4\r\n *\r\n * @param {ReadonlyVec4} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport function length(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var w = a[3];\n return Math.hypot(x, y, z, w);\n}\n/**\r\n * Calculates the squared length of a vec4\r\n *\r\n * @param {ReadonlyVec4} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\n\nexport function squaredLength(a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var w = a[3];\n return x * x + y * y + z * z + w * w;\n}\n/**\r\n * Negates the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to negate\r\n * @returns {vec4} out\r\n */\n\nexport function negate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n out[2] = -a[2];\n out[3] = -a[3];\n return out;\n}\n/**\r\n * Returns the inverse of the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to invert\r\n * @returns {vec4} out\r\n */\n\nexport function inverse(out, a) {\n out[0] = 1.0 / a[0];\n out[1] = 1.0 / a[1];\n out[2] = 1.0 / a[2];\n out[3] = 1.0 / a[3];\n return out;\n}\n/**\r\n * Normalize a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a vector to normalize\r\n * @returns {vec4} out\r\n */\n\nexport function normalize(out, a) {\n var x = a[0];\n var y = a[1];\n var z = a[2];\n var w = a[3];\n var len = x * x + y * y + z * z + w * w;\n\n if (len > 0) {\n len = 1 / Math.sqrt(len);\n }\n\n out[0] = x * len;\n out[1] = y * len;\n out[2] = z * len;\n out[3] = w * len;\n return out;\n}\n/**\r\n * Calculates the dot product of two vec4's\r\n *\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\n\nexport function dot(a, b) {\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];\n}\n/**\r\n * Returns the cross-product of three vectors in a 4-dimensional space\r\n *\r\n * @param {ReadonlyVec4} result the receiving vector\r\n * @param {ReadonlyVec4} U the first vector\r\n * @param {ReadonlyVec4} V the second vector\r\n * @param {ReadonlyVec4} W the third vector\r\n * @returns {vec4} result\r\n */\n\nexport function cross(out, u, v, w) {\n var A = v[0] * w[1] - v[1] * w[0],\n B = v[0] * w[2] - v[2] * w[0],\n C = v[0] * w[3] - v[3] * w[0],\n D = v[1] * w[2] - v[2] * w[1],\n E = v[1] * w[3] - v[3] * w[1],\n F = v[2] * w[3] - v[3] * w[2];\n var G = u[0];\n var H = u[1];\n var I = u[2];\n var J = u[3];\n out[0] = H * F - I * E + J * D;\n out[1] = -(G * F) + I * C - J * B;\n out[2] = G * E - H * C + J * A;\n out[3] = -(G * D) + H * B - I * A;\n return out;\n}\n/**\r\n * Performs a linear interpolation between two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the first operand\r\n * @param {ReadonlyVec4} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec4} out\r\n */\n\nexport function lerp(out, a, b, t) {\n var ax = a[0];\n var ay = a[1];\n var az = a[2];\n var aw = a[3];\n out[0] = ax + t * (b[0] - ax);\n out[1] = ay + t * (b[1] - ay);\n out[2] = az + t * (b[2] - az);\n out[3] = aw + t * (b[3] - aw);\n return out;\n}\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec4} out\r\n */\n\nexport function random(out, scale) {\n scale = scale || 1.0; // Marsaglia, George. Choosing a Point from the Surface of a\n // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646.\n // http://projecteuclid.org/euclid.aoms/1177692644;\n\n var v1, v2, v3, v4;\n var s1, s2;\n\n do {\n v1 = glMatrix.RANDOM() * 2 - 1;\n v2 = glMatrix.RANDOM() * 2 - 1;\n s1 = v1 * v1 + v2 * v2;\n } while (s1 >= 1);\n\n do {\n v3 = glMatrix.RANDOM() * 2 - 1;\n v4 = glMatrix.RANDOM() * 2 - 1;\n s2 = v3 * v3 + v4 * v4;\n } while (s2 >= 1);\n\n var d = Math.sqrt((1 - s1) / s2);\n out[0] = scale * v1;\n out[1] = scale * v2;\n out[2] = scale * v3 * d;\n out[3] = scale * v4 * d;\n return out;\n}\n/**\r\n * Transforms the vec4 with a mat4.\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the vector to transform\r\n * @param {ReadonlyMat4} m matrix to transform with\r\n * @returns {vec4} out\r\n */\n\nexport function transformMat4(out, a, m) {\n var x = a[0],\n y = a[1],\n z = a[2],\n w = a[3];\n out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;\n out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;\n out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;\n out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;\n return out;\n}\n/**\r\n * Transforms the vec4 with a quat\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {ReadonlyVec4} a the vector to transform\r\n * @param {ReadonlyQuat} q quaternion to transform with\r\n * @returns {vec4} out\r\n */\n\nexport function transformQuat(out, a, q) {\n var x = a[0],\n y = a[1],\n z = a[2];\n var qx = q[0],\n qy = q[1],\n qz = q[2],\n qw = q[3]; // calculate quat * vec\n\n var ix = qw * x + qy * z - qz * y;\n var iy = qw * y + qz * x - qx * z;\n var iz = qw * z + qx * y - qy * x;\n var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat\n\n out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;\n out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;\n out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;\n out[3] = a[3];\n return out;\n}\n/**\r\n * Set the components of a vec4 to zero\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @returns {vec4} out\r\n */\n\nexport function zero(out) {\n out[0] = 0.0;\n out[1] = 0.0;\n out[2] = 0.0;\n out[3] = 0.0;\n return out;\n}\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {ReadonlyVec4} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"vec4(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \")\";\n}\n/**\r\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyVec4} a The first vector.\r\n * @param {ReadonlyVec4} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];\n}\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyVec4} a The first vector.\r\n * @param {ReadonlyVec4} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));\n}\n/**\r\n * Alias for {@link vec4.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;\n/**\r\n * Alias for {@link vec4.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link vec4.divide}\r\n * @function\r\n */\n\nexport var div = divide;\n/**\r\n * Alias for {@link vec4.distance}\r\n * @function\r\n */\n\nexport var dist = distance;\n/**\r\n * Alias for {@link vec4.squaredDistance}\r\n * @function\r\n */\n\nexport var sqrDist = squaredDistance;\n/**\r\n * Alias for {@link vec4.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Alias for {@link vec4.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Perform some operation over an array of vec4s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\n\nexport var forEach = function () {\n var vec = create();\n return function (a, stride, offset, count, fn, arg) {\n var i, l;\n\n if (!stride) {\n stride = 4;\n }\n\n if (!offset) {\n offset = 0;\n }\n\n if (count) {\n l = Math.min(count * stride + offset, a.length);\n } else {\n l = a.length;\n }\n\n for (i = offset; i < l; i += stride) {\n vec[0] = a[i];\n vec[1] = a[i + 1];\n vec[2] = a[i + 2];\n vec[3] = a[i + 3];\n fn(vec, vec, arg);\n a[i] = vec[0];\n a[i + 1] = vec[1];\n a[i + 2] = vec[2];\n a[i + 3] = vec[3];\n }\n\n return a;\n };\n}();","import { checkVector, deprecated } from '../lib/validators';\nimport Matrix from './base/matrix';\nimport { vec2_transformMat4AsVector, vec3_transformMat4AsVector } from '../lib/gl-matrix-extras';\nimport * as mat4 from 'gl-matrix/mat4';\nimport * as vec2 from 'gl-matrix/vec2';\nimport * as vec3 from 'gl-matrix/vec3';\nimport * as vec4 from 'gl-matrix/vec4';\nconst IDENTITY = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);\nconst ZERO = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);\nconst INDICES = Object.freeze({\n COL0ROW0: 0,\n COL0ROW1: 1,\n COL0ROW2: 2,\n COL0ROW3: 3,\n COL1ROW0: 4,\n COL1ROW1: 5,\n COL1ROW2: 6,\n COL1ROW3: 7,\n COL2ROW0: 8,\n COL2ROW1: 9,\n COL2ROW2: 10,\n COL2ROW3: 11,\n COL3ROW0: 12,\n COL3ROW1: 13,\n COL3ROW2: 14,\n COL3ROW3: 15\n});\nconst constants = {};\nexport default class Matrix4 extends Matrix {\n static get IDENTITY() {\n constants.IDENTITY = constants.IDENTITY || Object.freeze(new Matrix4(IDENTITY));\n return constants.IDENTITY;\n }\n\n static get ZERO() {\n constants.ZERO = constants.ZERO || Object.freeze(new Matrix4(ZERO));\n return constants.ZERO;\n }\n\n get INDICES() {\n return INDICES;\n }\n\n get ELEMENTS() {\n return 16;\n }\n\n get RANK() {\n return 4;\n }\n\n constructor(array) {\n super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);\n\n if (arguments.length === 1 && Array.isArray(array)) {\n this.copy(array);\n } else {\n this.identity();\n }\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n this[3] = array[3];\n this[4] = array[4];\n this[5] = array[5];\n this[6] = array[6];\n this[7] = array[7];\n this[8] = array[8];\n this[9] = array[9];\n this[10] = array[10];\n this[11] = array[11];\n this[12] = array[12];\n this[13] = array[13];\n this[14] = array[14];\n this[15] = array[15];\n return this.check();\n }\n\n set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m30;\n this[4] = m01;\n this[5] = m11;\n this[6] = m21;\n this[7] = m31;\n this[8] = m02;\n this[9] = m12;\n this[10] = m22;\n this[11] = m32;\n this[12] = m03;\n this[13] = m13;\n this[14] = m23;\n this[15] = m33;\n return this.check();\n }\n\n setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m30;\n this[4] = m01;\n this[5] = m11;\n this[6] = m21;\n this[7] = m31;\n this[8] = m02;\n this[9] = m12;\n this[10] = m22;\n this[11] = m32;\n this[12] = m03;\n this[13] = m13;\n this[14] = m23;\n this[15] = m33;\n return this.check();\n }\n\n toRowMajor(result) {\n result[0] = this[0];\n result[1] = this[4];\n result[2] = this[8];\n result[3] = this[12];\n result[4] = this[1];\n result[5] = this[5];\n result[6] = this[9];\n result[7] = this[13];\n result[8] = this[2];\n result[9] = this[6];\n result[10] = this[10];\n result[11] = this[14];\n result[12] = this[3];\n result[13] = this[7];\n result[14] = this[11];\n result[15] = this[15];\n return result;\n }\n\n identity() {\n return this.copy(IDENTITY);\n }\n\n fromQuaternion(q) {\n mat4.fromQuat(this, q);\n return this.check();\n }\n\n frustum({\n left,\n right,\n bottom,\n top,\n near,\n far\n }) {\n if (far === Infinity) {\n Matrix4._computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);\n } else {\n mat4.frustum(this, left, right, bottom, top, near, far);\n }\n\n return this.check();\n }\n\n static _computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {\n const column0Row0 = 2.0 * near / (right - left);\n const column1Row1 = 2.0 * near / (top - bottom);\n const column2Row0 = (right + left) / (right - left);\n const column2Row1 = (top + bottom) / (top - bottom);\n const column2Row2 = -1.0;\n const column2Row3 = -1.0;\n const column3Row2 = -2.0 * near;\n result[0] = column0Row0;\n result[1] = 0.0;\n result[2] = 0.0;\n result[3] = 0.0;\n result[4] = 0.0;\n result[5] = column1Row1;\n result[6] = 0.0;\n result[7] = 0.0;\n result[8] = column2Row0;\n result[9] = column2Row1;\n result[10] = column2Row2;\n result[11] = column2Row3;\n result[12] = 0.0;\n result[13] = 0.0;\n result[14] = column3Row2;\n result[15] = 0.0;\n return result;\n }\n\n lookAt(eye, center, up) {\n if (arguments.length === 1) {\n ({\n eye,\n center,\n up\n } = eye);\n }\n\n center = center || [0, 0, 0];\n up = up || [0, 1, 0];\n mat4.lookAt(this, eye, center, up);\n return this.check();\n }\n\n ortho({\n left,\n right,\n bottom,\n top,\n near = 0.1,\n far = 500\n }) {\n mat4.ortho(this, left, right, bottom, top, near, far);\n return this.check();\n }\n\n orthographic({\n fovy = 45 * Math.PI / 180,\n aspect = 1,\n focalDistance = 1,\n near = 0.1,\n far = 500\n }) {\n if (fovy > Math.PI * 2) {\n throw Error('radians');\n }\n\n const halfY = fovy / 2;\n const top = focalDistance * Math.tan(halfY);\n const right = top * aspect;\n return new Matrix4().ortho({\n left: -right,\n right,\n bottom: -top,\n top,\n near,\n far\n });\n }\n\n perspective({\n fovy = undefined,\n fov = 45 * Math.PI / 180,\n aspect = 1,\n near = 0.1,\n far = 500\n } = {}) {\n fovy = fovy || fov;\n\n if (fovy > Math.PI * 2) {\n throw Error('radians');\n }\n\n mat4.perspective(this, fovy, aspect, near, far);\n return this.check();\n }\n\n determinant() {\n return mat4.determinant(this);\n }\n\n getScale(result = [-0, -0, -0]) {\n result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);\n result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);\n result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);\n return result;\n }\n\n getTranslation(result = [-0, -0, -0]) {\n result[0] = this[12];\n result[1] = this[13];\n result[2] = this[14];\n return result;\n }\n\n getRotation(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {\n const scale = this.getScale(scaleResult || [-0, -0, -0]);\n const inverseScale0 = 1 / scale[0];\n const inverseScale1 = 1 / scale[1];\n const inverseScale2 = 1 / scale[2];\n result[0] = this[0] * inverseScale0;\n result[1] = this[1] * inverseScale1;\n result[2] = this[2] * inverseScale2;\n result[3] = 0;\n result[4] = this[4] * inverseScale0;\n result[5] = this[5] * inverseScale1;\n result[6] = this[6] * inverseScale2;\n result[7] = 0;\n result[8] = this[8] * inverseScale0;\n result[9] = this[9] * inverseScale1;\n result[10] = this[10] * inverseScale2;\n result[11] = 0;\n result[12] = 0;\n result[13] = 0;\n result[14] = 0;\n result[15] = 1;\n return result;\n }\n\n getRotationMatrix3(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {\n const scale = this.getScale(scaleResult || [-0, -0, -0]);\n const inverseScale0 = 1 / scale[0];\n const inverseScale1 = 1 / scale[1];\n const inverseScale2 = 1 / scale[2];\n result[0] = this[0] * inverseScale0;\n result[1] = this[1] * inverseScale1;\n result[2] = this[2] * inverseScale2;\n result[3] = this[4] * inverseScale0;\n result[4] = this[5] * inverseScale1;\n result[5] = this[6] * inverseScale2;\n result[6] = this[8] * inverseScale0;\n result[7] = this[9] * inverseScale1;\n result[8] = this[10] * inverseScale2;\n return result;\n }\n\n transpose() {\n mat4.transpose(this, this);\n return this.check();\n }\n\n invert() {\n mat4.invert(this, this);\n return this.check();\n }\n\n multiplyLeft(a) {\n mat4.multiply(this, a, this);\n return this.check();\n }\n\n multiplyRight(a) {\n mat4.multiply(this, this, a);\n return this.check();\n }\n\n rotateX(radians) {\n mat4.rotateX(this, this, radians);\n return this.check();\n }\n\n rotateY(radians) {\n mat4.rotateY(this, this, radians);\n return this.check();\n }\n\n rotateZ(radians) {\n mat4.rotateZ(this, this, radians);\n return this.check();\n }\n\n rotateXYZ([rx, ry, rz]) {\n return this.rotateX(rx).rotateY(ry).rotateZ(rz);\n }\n\n rotateAxis(radians, axis) {\n mat4.rotate(this, this, radians, axis);\n return this.check();\n }\n\n scale(factor) {\n if (Array.isArray(factor)) {\n mat4.scale(this, this, factor);\n } else {\n mat4.scale(this, this, [factor, factor, factor]);\n }\n\n return this.check();\n }\n\n translate(vec) {\n mat4.translate(this, this, vec);\n return this.check();\n }\n\n transform(vector, result) {\n if (vector.length === 4) {\n result = vec4.transformMat4(result || [-0, -0, -0, -0], vector, this);\n checkVector(result, 4);\n return result;\n }\n\n return this.transformAsPoint(vector, result);\n }\n\n transformAsPoint(vector, result) {\n const {\n length\n } = vector;\n\n switch (length) {\n case 2:\n result = vec2.transformMat4(result || [-0, -0], vector, this);\n break;\n\n case 3:\n result = vec3.transformMat4(result || [-0, -0, -0], vector, this);\n break;\n\n default:\n throw new Error('Illegal vector');\n }\n\n checkVector(result, vector.length);\n return result;\n }\n\n transformAsVector(vector, result) {\n switch (vector.length) {\n case 2:\n result = vec2_transformMat4AsVector(result || [-0, -0], vector, this);\n break;\n\n case 3:\n result = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);\n break;\n\n default:\n throw new Error('Illegal vector');\n }\n\n checkVector(result, vector.length);\n return result;\n }\n\n makeRotationX(radians) {\n return this.identity().rotateX(radians);\n }\n\n makeTranslation(x, y, z) {\n return this.identity().translate([x, y, z]);\n }\n\n transformPoint(vector, result) {\n deprecated('Matrix4.transformPoint', '3.0');\n return this.transformAsPoint(vector, result);\n }\n\n transformVector(vector, result) {\n deprecated('Matrix4.transformVector', '3.0');\n return this.transformAsPoint(vector, result);\n }\n\n transformDirection(vector, result) {\n deprecated('Matrix4.transformDirection', '3.0');\n return this.transformAsVector(vector, result);\n }\n\n}\n//# sourceMappingURL=matrix4.js.map","import MathArray from './math-array';\nimport { checkNumber } from '../../lib/validators';\nimport assert from '../../lib/assert';\nexport default class Vector extends MathArray {\n get ELEMENTS() {\n assert(false);\n return 0;\n }\n\n copy(vector) {\n assert(false);\n return this;\n }\n\n get x() {\n return this[0];\n }\n\n set x(value) {\n this[0] = checkNumber(value);\n }\n\n get y() {\n return this[1];\n }\n\n set y(value) {\n this[1] = checkNumber(value);\n }\n\n len() {\n return Math.sqrt(this.lengthSquared());\n }\n\n magnitude() {\n return this.len();\n }\n\n lengthSquared() {\n let length = 0;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n length += this[i] * this[i];\n }\n\n return length;\n }\n\n magnitudeSquared() {\n return this.lengthSquared();\n }\n\n distance(mathArray) {\n return Math.sqrt(this.distanceSquared(mathArray));\n }\n\n distanceSquared(mathArray) {\n let length = 0;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n const dist = this[i] - mathArray[i];\n length += dist * dist;\n }\n\n return checkNumber(length);\n }\n\n dot(mathArray) {\n let product = 0;\n\n for (let i = 0; i < this.ELEMENTS; ++i) {\n product += this[i] * mathArray[i];\n }\n\n return checkNumber(product);\n }\n\n normalize() {\n const length = this.magnitude();\n\n if (length !== 0) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] /= length;\n }\n }\n\n return this.check();\n }\n\n multiply(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] *= vector[i];\n }\n }\n\n return this.check();\n }\n\n divide(...vectors) {\n for (const vector of vectors) {\n for (let i = 0; i < this.ELEMENTS; ++i) {\n this[i] /= vector[i];\n }\n }\n\n return this.check();\n }\n\n lengthSq() {\n return this.lengthSquared();\n }\n\n distanceTo(vector) {\n return this.distance(vector);\n }\n\n distanceToSquared(vector) {\n return this.distanceSquared(vector);\n }\n\n getComponent(i) {\n assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');\n return checkNumber(this[i]);\n }\n\n setComponent(i, value) {\n assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');\n this[i] = value;\n return this.check();\n }\n\n addVectors(a, b) {\n return this.copy(a).add(b);\n }\n\n subVectors(a, b) {\n return this.copy(a).subtract(b);\n }\n\n multiplyVectors(a, b) {\n return this.copy(a).multiply(b);\n }\n\n addScaledVector(a, b) {\n return this.add(new this.constructor(a).multiplyScalar(b));\n }\n\n}\n//# sourceMappingURL=vector.js.map","import Vector from './base/vector';\nimport { config, isArray } from '../lib/common';\nimport { checkNumber } from '../lib/validators';\nimport * as vec3 from 'gl-matrix/vec3';\nimport { vec3_transformMat2, vec3_transformMat4AsVector } from '../lib/gl-matrix-extras';\nconst ORIGIN = [0, 0, 0];\nconst constants = {};\nexport default class Vector3 extends Vector {\n static get ZERO() {\n return constants.ZERO = constants.ZERO || Object.freeze(new Vector3(0, 0, 0, 0));\n }\n\n constructor(x = 0, y = 0, z = 0) {\n super(-0, -0, -0);\n\n if (arguments.length === 1 && isArray(x)) {\n this.copy(x);\n } else {\n if (config.debug) {\n checkNumber(x);\n checkNumber(y);\n checkNumber(z);\n }\n\n this[0] = x;\n this[1] = y;\n this[2] = z;\n }\n }\n\n set(x, y, z) {\n this[0] = x;\n this[1] = y;\n this[2] = z;\n return this.check();\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n return this.check();\n }\n\n fromObject(object) {\n if (config.debug) {\n checkNumber(object.x);\n checkNumber(object.y);\n checkNumber(object.z);\n }\n\n this[0] = object.x;\n this[1] = object.y;\n this[2] = object.z;\n return this.check();\n }\n\n toObject(object) {\n object.x = this[0];\n object.y = this[1];\n object.z = this[2];\n return object;\n }\n\n get ELEMENTS() {\n return 3;\n }\n\n get z() {\n return this[2];\n }\n\n set z(value) {\n this[2] = checkNumber(value);\n }\n\n angle(vector) {\n return vec3.angle(this, vector);\n }\n\n cross(vector) {\n vec3.cross(this, this, vector);\n return this.check();\n }\n\n rotateX({\n radians,\n origin = ORIGIN\n }) {\n vec3.rotateX(this, this, origin, radians);\n return this.check();\n }\n\n rotateY({\n radians,\n origin = ORIGIN\n }) {\n vec3.rotateY(this, this, origin, radians);\n return this.check();\n }\n\n rotateZ({\n radians,\n origin = ORIGIN\n }) {\n vec3.rotateZ(this, this, origin, radians);\n return this.check();\n }\n\n transform(matrix4) {\n return this.transformAsPoint(matrix4);\n }\n\n transformAsPoint(matrix4) {\n vec3.transformMat4(this, this, matrix4);\n return this.check();\n }\n\n transformAsVector(matrix4) {\n vec3_transformMat4AsVector(this, this, matrix4);\n return this.check();\n }\n\n transformByMatrix3(matrix3) {\n vec3.transformMat3(this, this, matrix3);\n return this.check();\n }\n\n transformByMatrix2(matrix2) {\n vec3_transformMat2(this, this, matrix2);\n return this.check();\n }\n\n transformByQuaternion(quaternion) {\n vec3.transformQuat(this, this, quaternion);\n return this.check();\n }\n\n}\n//# sourceMappingURL=vector3.js.map","export default {\n EPSILON1: 1e-1,\n EPSILON2: 1e-2,\n EPSILON3: 1e-3,\n EPSILON4: 1e-4,\n EPSILON5: 1e-5,\n EPSILON6: 1e-6,\n EPSILON7: 1e-7,\n EPSILON8: 1e-8,\n EPSILON9: 1e-9,\n EPSILON10: 1e-10,\n EPSILON11: 1e-11,\n EPSILON12: 1e-12,\n EPSILON13: 1e-13,\n EPSILON14: 1e-14,\n EPSILON15: 1e-15,\n EPSILON16: 1e-16,\n EPSILON17: 1e-17,\n EPSILON18: 1e-18,\n EPSILON19: 1e-19,\n EPSILON20: 1e-20,\n PI_OVER_TWO: Math.PI / 2,\n PI_OVER_FOUR: Math.PI / 4,\n PI_OVER_SIX: Math.PI / 6,\n TWO_PI: Math.PI * 2\n};\n//# sourceMappingURL=math-utils.js.map","export const WGS84_RADIUS_X = 6378137.0;\nexport const WGS84_RADIUS_Y = 6378137.0;\nexport const WGS84_RADIUS_Z = 6356752.3142451793;\nexport const WGS84_CONSTANTS = {\n radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],\n radiiSquared: [WGS84_RADIUS_X * WGS84_RADIUS_X, WGS84_RADIUS_Y * WGS84_RADIUS_Y, WGS84_RADIUS_Z * WGS84_RADIUS_Z],\n oneOverRadii: [1.0 / WGS84_RADIUS_X, 1.0 / WGS84_RADIUS_Y, 1.0 / WGS84_RADIUS_Z],\n oneOverRadiiSquared: [1.0 / (WGS84_RADIUS_X * WGS84_RADIUS_X), 1.0 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y), 1.0 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)],\n maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),\n centerToleranceSquared: 1e-1\n};\n//# sourceMappingURL=constants.js.map","import { Vector3, isArray, toRadians, toDegrees, config } from '@math.gl/core';\nimport { WGS84_CONSTANTS } from './constants';\n\nconst noop = x => x;\n\nconst scratchVector = new Vector3();\nexport function fromCartographic(cartographic, result, map = noop) {\n if (isArray(cartographic)) {\n result[0] = map(cartographic[0]);\n result[1] = map(cartographic[1]);\n result[2] = cartographic[2];\n } else if ('longitude' in cartographic) {\n result[0] = map(cartographic.longitude);\n result[1] = map(cartographic.latitude);\n result[2] = cartographic.height;\n } else {\n result[0] = map(cartographic.x);\n result[1] = map(cartographic.y);\n result[2] = cartographic.z;\n }\n\n return result;\n}\nexport function fromCartographicToRadians(cartographic, vector = scratchVector) {\n return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);\n}\nexport function fromCartographicToDegrees(cartographic, vector = scratchVector) {\n return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : noop);\n}\nexport function toCartographic(vector, cartographic, map = noop) {\n if (isArray(cartographic)) {\n cartographic[0] = map(vector[0]);\n cartographic[1] = map(vector[1]);\n cartographic[2] = vector[2];\n } else if ('longitude' in cartographic) {\n cartographic.longitude = map(vector[0]);\n cartographic.latitude = map(vector[1]);\n cartographic.height = vector[2];\n } else {\n cartographic.x = map(vector[0]);\n cartographic.y = map(vector[1]);\n cartographic.z = vector[2];\n }\n\n return cartographic;\n}\nexport function toCartographicFromRadians(vector, cartographic) {\n return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);\n}\nexport function toCartographicFromDegrees(vector, cartographic) {\n return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : noop);\n}\nexport function isWGS84(vector) {\n if (!vector) {\n return false;\n }\n\n scratchVector.from(vector);\n const {\n oneOverRadiiSquared,\n centerToleranceSquared\n } = WGS84_CONSTANTS;\n const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];\n const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];\n const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];\n return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;\n}\n//# sourceMappingURL=type-utils.js.map","import { Vector3, assert, _MathUtils } from '@math.gl/core';\nimport * as vec3 from 'gl-matrix/vec3';\nconst scratchVector = new Vector3();\nconst scaleToGeodeticSurfaceIntersection = new Vector3();\nconst scaleToGeodeticSurfaceGradient = new Vector3();\nexport default function scaleToGeodeticSurface(cartesian, ellipsoid, result = new Vector3()) {\n const {\n oneOverRadii,\n oneOverRadiiSquared,\n centerToleranceSquared\n } = ellipsoid;\n scratchVector.from(cartesian);\n const positionX = cartesian.x;\n const positionY = cartesian.y;\n const positionZ = cartesian.z;\n const oneOverRadiiX = oneOverRadii.x;\n const oneOverRadiiY = oneOverRadii.y;\n const oneOverRadiiZ = oneOverRadii.z;\n const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;\n const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;\n const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;\n const squaredNorm = x2 + y2 + z2;\n const ratio = Math.sqrt(1.0 / squaredNorm);\n\n if (!Number.isFinite(ratio)) {\n return undefined;\n }\n\n const intersection = scaleToGeodeticSurfaceIntersection;\n intersection.copy(cartesian).scale(ratio);\n\n if (squaredNorm < centerToleranceSquared) {\n return intersection.to(result);\n }\n\n const oneOverRadiiSquaredX = oneOverRadiiSquared.x;\n const oneOverRadiiSquaredY = oneOverRadiiSquared.y;\n const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;\n const gradient = scaleToGeodeticSurfaceGradient;\n gradient.set(intersection.x * oneOverRadiiSquaredX * 2.0, intersection.y * oneOverRadiiSquaredY * 2.0, intersection.z * oneOverRadiiSquaredZ * 2.0);\n let lambda = (1.0 - ratio) * cartesian.len() / (0.5 * gradient.len());\n let correction = 0.0;\n let xMultiplier;\n let yMultiplier;\n let zMultiplier;\n let func;\n\n do {\n lambda -= correction;\n xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);\n yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);\n zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);\n const xMultiplier2 = xMultiplier * xMultiplier;\n const yMultiplier2 = yMultiplier * yMultiplier;\n const zMultiplier2 = zMultiplier * zMultiplier;\n const xMultiplier3 = xMultiplier2 * xMultiplier;\n const yMultiplier3 = yMultiplier2 * yMultiplier;\n const zMultiplier3 = zMultiplier2 * zMultiplier;\n func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;\n const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;\n const derivative = -2.0 * denominator;\n correction = func / derivative;\n } while (Math.abs(func) > _MathUtils.EPSILON12);\n\n return scratchVector.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);\n}\n//# sourceMappingURL=scale-to-geodetic-surface.js.map","import { Vector3, assert, equals as equalsEpsilon } from '@math.gl/core';\nconst EPSILON14 = 1e-14;\nconst scratchOrigin = new Vector3();\nconst VECTOR_PRODUCT_LOCAL_FRAME = {\n up: {\n south: 'east',\n north: 'west',\n west: 'south',\n east: 'north'\n },\n down: {\n south: 'west',\n north: 'east',\n west: 'north',\n east: 'south'\n },\n south: {\n up: 'west',\n down: 'east',\n west: 'down',\n east: 'up'\n },\n north: {\n up: 'east',\n down: 'west',\n west: 'up',\n east: 'down'\n },\n west: {\n up: 'north',\n down: 'south',\n north: 'down',\n south: 'up'\n },\n east: {\n up: 'south',\n down: 'north',\n north: 'up',\n south: 'down'\n }\n};\nconst degeneratePositionLocalFrame = {\n north: [-1, 0, 0],\n east: [0, 1, 0],\n up: [0, 0, 1],\n south: [1, 0, 0],\n west: [0, -1, 0],\n down: [0, 0, -1]\n};\nconst scratchAxisVectors = {\n east: new Vector3(),\n north: new Vector3(),\n up: new Vector3(),\n west: new Vector3(),\n south: new Vector3(),\n down: new Vector3()\n};\nconst scratchVector1 = new Vector3();\nconst scratchVector2 = new Vector3();\nconst scratchVector3 = new Vector3();\nexport default function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {\n const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];\n assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));\n let firstAxisVector;\n let secondAxisVector;\n let thirdAxisVector;\n const origin = scratchOrigin.copy(cartesianOrigin);\n const atPole = equalsEpsilon(origin.x, 0.0, EPSILON14) && equalsEpsilon(origin.y, 0.0, EPSILON14);\n\n if (atPole) {\n const sign = Math.sign(origin.z);\n firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);\n\n if (firstAxis !== 'east' && firstAxis !== 'west') {\n firstAxisVector.scale(sign);\n }\n\n secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);\n\n if (secondAxis !== 'east' && secondAxis !== 'west') {\n secondAxisVector.scale(sign);\n }\n\n thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);\n\n if (thirdAxis !== 'east' && thirdAxis !== 'west') {\n thirdAxisVector.scale(sign);\n }\n } else {\n const {\n up,\n east,\n north\n } = scratchAxisVectors;\n east.set(-origin.y, origin.x, 0.0).normalize();\n ellipsoid.geodeticSurfaceNormal(origin, up);\n north.copy(up).cross(east);\n const {\n down,\n west,\n south\n } = scratchAxisVectors;\n down.copy(up).scale(-1);\n west.copy(east).scale(-1);\n south.copy(north).scale(-1);\n firstAxisVector = scratchAxisVectors[firstAxis];\n secondAxisVector = scratchAxisVectors[secondAxis];\n thirdAxisVector = scratchAxisVectors[thirdAxis];\n }\n\n result[0] = firstAxisVector.x;\n result[1] = firstAxisVector.y;\n result[2] = firstAxisVector.z;\n result[3] = 0.0;\n result[4] = secondAxisVector.x;\n result[5] = secondAxisVector.y;\n result[6] = secondAxisVector.z;\n result[7] = 0.0;\n result[8] = thirdAxisVector.x;\n result[9] = thirdAxisVector.y;\n result[10] = thirdAxisVector.z;\n result[11] = 0.0;\n result[12] = origin.x;\n result[13] = origin.y;\n result[14] = origin.z;\n result[15] = 1.0;\n return result;\n}\n//# sourceMappingURL=ellipsoid-transform.js.map","import { Vector3, Matrix4, toRadians, toDegrees, assert, equals, _MathUtils } from '@math.gl/core';\nimport * as vec3 from 'gl-matrix/vec3';\nimport { WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z } from '../constants';\nimport { fromCartographicToRadians, toCartographicFromRadians } from '../type-utils';\nimport scaleToGeodeticSurface from './helpers/scale-to-geodetic-surface';\nimport localFrameToFixedFrame from './helpers/ellipsoid-transform';\nconst scratchVector = new Vector3();\nconst scratchNormal = new Vector3();\nconst scratchK = new Vector3();\nconst scratchPosition = new Vector3();\nconst scratchHeight = new Vector3();\nconst scratchCartesian = new Vector3();\nlet wgs84;\nexport default class Ellipsoid {\n static get WGS84() {\n wgs84 = wgs84 || new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);\n return wgs84;\n }\n\n constructor(x = 0.0, y = 0.0, z = 0.0) {\n assert(x >= 0.0);\n assert(y >= 0.0);\n assert(z >= 0.0);\n this.radii = new Vector3(x, y, z);\n this.radiiSquared = new Vector3(x * x, y * y, z * z);\n this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);\n this.oneOverRadii = new Vector3(x === 0.0 ? 0.0 : 1.0 / x, y === 0.0 ? 0.0 : 1.0 / y, z === 0.0 ? 0.0 : 1.0 / z);\n this.oneOverRadiiSquared = new Vector3(x === 0.0 ? 0.0 : 1.0 / (x * x), y === 0.0 ? 0.0 : 1.0 / (y * y), z === 0.0 ? 0.0 : 1.0 / (z * z));\n this.minimumRadius = Math.min(x, y, z);\n this.maximumRadius = Math.max(x, y, z);\n this.centerToleranceSquared = _MathUtils.EPSILON1;\n\n if (this.radiiSquared.z !== 0) {\n this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;\n }\n\n Object.freeze(this);\n }\n\n equals(right) {\n return this === right || Boolean(right && this.radii.equals(right.radii));\n }\n\n toString() {\n return this.radii.toString();\n }\n\n cartographicToCartesian(cartographic, result = [0, 0, 0]) {\n const normal = scratchNormal;\n const k = scratchK;\n const [,, height] = cartographic;\n this.geodeticSurfaceNormalCartographic(cartographic, normal);\n k.copy(this.radiiSquared).scale(normal);\n const gamma = Math.sqrt(normal.dot(k));\n k.scale(1 / gamma);\n normal.scale(height);\n k.add(normal);\n return k.to(result);\n }\n\n cartesianToCartographic(cartesian, result = [0, 0, 0]) {\n scratchCartesian.from(cartesian);\n const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);\n\n if (!point) {\n return undefined;\n }\n\n const normal = this.geodeticSurfaceNormal(point, scratchNormal);\n const h = scratchHeight;\n h.copy(scratchCartesian).subtract(point);\n const longitude = Math.atan2(normal.y, normal.x);\n const latitude = Math.asin(normal.z);\n const height = Math.sign(vec3.dot(h, scratchCartesian)) * vec3.length(h);\n return toCartographicFromRadians([longitude, latitude, height], result);\n }\n\n eastNorthUpToFixedFrame(origin, result = new Matrix4()) {\n return localFrameToFixedFrame(this, 'east', 'north', 'up', origin, result);\n }\n\n localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {\n return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);\n }\n\n geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {\n return scratchVector.from(cartesian).normalize().to(result);\n }\n\n geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {\n const cartographicVectorRadians = fromCartographicToRadians(cartographic);\n const longitude = cartographicVectorRadians[0];\n const latitude = cartographicVectorRadians[1];\n const cosLatitude = Math.cos(latitude);\n scratchVector.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();\n return scratchVector.to(result);\n }\n\n geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {\n return scratchVector.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);\n }\n\n scaleToGeodeticSurface(cartesian, result) {\n return scaleToGeodeticSurface(cartesian, this, result);\n }\n\n scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {\n scratchPosition.from(cartesian);\n const positionX = scratchPosition.x;\n const positionY = scratchPosition.y;\n const positionZ = scratchPosition.z;\n const oneOverRadiiSquared = this.oneOverRadiiSquared;\n const beta = 1.0 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);\n return scratchPosition.multiplyScalar(beta).to(result);\n }\n\n transformPositionToScaledSpace(position, result = [0, 0, 0]) {\n return scratchPosition.from(position).scale(this.oneOverRadii).to(result);\n }\n\n transformPositionFromScaledSpace(position, result = [0, 0, 0]) {\n return scratchPosition.from(position).scale(this.radii).to(result);\n }\n\n getSurfaceNormalIntersectionWithZAxis(position, buffer = 0.0, result = [0, 0, 0]) {\n assert(equals(this.radii.x, this.radii.y, _MathUtils.EPSILON15));\n assert(this.radii.z > 0);\n scratchPosition.from(position);\n const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);\n\n if (Math.abs(z) >= this.radii.z - buffer) {\n return undefined;\n }\n\n return scratchPosition.set(0.0, 0.0, z).to(result);\n }\n\n}\n//# sourceMappingURL=ellipsoid.js.map","import getHiResTimestamp from '../utils/hi-res-timestamp';\nexport default class Stat {\n constructor(name, type) {\n this.name = name;\n this.type = type;\n this.sampleSize = 1;\n this.reset();\n }\n\n setSampleSize(samples) {\n this.sampleSize = samples;\n return this;\n }\n\n incrementCount() {\n this.addCount(1);\n return this;\n }\n\n decrementCount() {\n this.subtractCount(1);\n return this;\n }\n\n addCount(value) {\n this._count += value;\n this._samples++;\n\n this._checkSampling();\n\n return this;\n }\n\n subtractCount(value) {\n this._count -= value;\n this._samples++;\n\n this._checkSampling();\n\n return this;\n }\n\n addTime(time) {\n this._time += time;\n this.lastTiming = time;\n this._samples++;\n\n this._checkSampling();\n\n return this;\n }\n\n timeStart() {\n this._startTime = getHiResTimestamp();\n this._timerPending = true;\n return this;\n }\n\n timeEnd() {\n if (!this._timerPending) {\n return this;\n }\n\n this.addTime(getHiResTimestamp() - this._startTime);\n this._timerPending = false;\n\n this._checkSampling();\n\n return this;\n }\n\n getSampleAverageCount() {\n return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;\n }\n\n getSampleAverageTime() {\n return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;\n }\n\n getSampleHz() {\n return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1000) : 0;\n }\n\n getAverageCount() {\n return this.samples > 0 ? this.count / this.samples : 0;\n }\n\n getAverageTime() {\n return this.samples > 0 ? this.time / this.samples : 0;\n }\n\n getHz() {\n return this.time > 0 ? this.samples / (this.time / 1000) : 0;\n }\n\n reset() {\n this.time = 0;\n this.count = 0;\n this.samples = 0;\n this.lastTiming = 0;\n this.lastSampleTime = 0;\n this.lastSampleCount = 0;\n this._count = 0;\n this._time = 0;\n this._samples = 0;\n this._startTime = 0;\n this._timerPending = false;\n return this;\n }\n\n _checkSampling() {\n if (this._samples === this.sampleSize) {\n this.lastSampleTime = this._time;\n this.lastSampleCount = this._count;\n this.count += this._count;\n this.time += this._time;\n this.samples += this._samples;\n this._time = 0;\n this._count = 0;\n this._samples = 0;\n }\n }\n\n}\n//# sourceMappingURL=stat.js.map","import Stat from './stat';\nexport default class Stats {\n constructor({\n id,\n stats\n }) {\n this.id = id;\n this.stats = {};\n\n this._initializeStats(stats);\n\n Object.seal(this);\n }\n\n get(name, type = 'count') {\n return this._getOrCreate({\n name,\n type\n });\n }\n\n get size() {\n return Object.keys(this.stats).length;\n }\n\n reset() {\n for (const key in this.stats) {\n this.stats[key].reset();\n }\n\n return this;\n }\n\n forEach(fn) {\n for (const key in this.stats) {\n fn(this.stats[key]);\n }\n }\n\n getTable() {\n const table = {};\n this.forEach(stat => {\n table[stat.name] = {\n time: stat.time || 0,\n count: stat.count || 0,\n average: stat.getAverageTime() || 0,\n hz: stat.getHz() || 0\n };\n });\n return table;\n }\n\n _initializeStats(stats = []) {\n stats.forEach(stat => this._getOrCreate(stat));\n }\n\n _getOrCreate(stat) {\n if (!stat || !stat.name) {\n return null;\n }\n\n const {\n name,\n type\n } = stat;\n\n if (!this.stats[name]) {\n if (stat instanceof Stat) {\n this.stats[name] = stat;\n } else {\n this.stats[name] = new Stat(name, type);\n }\n }\n\n return this.stats[name];\n }\n\n}\n//# sourceMappingURL=stats.js.map","/**\n * Throws an `Error` with the optional `message` if `condition` is falsy\n * @note Replacement for the external assert method to reduce bundle size\n */\nexport function assert(condition: any, message?: string): void {\n if (!condition) {\n throw new Error(message || 'loader assertion failed.');\n }\n}\n","// Beginning of a minimal implementation of the Node.js path API, that doesn't pull in big polyfills.\n\n/**\n * Replacement for Node.js path.filename\n * @param url\n */\nexport function filename(url: string): string {\n const slashIndex = url && url.lastIndexOf('/');\n return slashIndex >= 0 ? url.substr((slashIndex as number) + 1) : '';\n}\n\n/**\n * Replacement for Node.js path.dirname\n * @param url\n */\nexport function dirname(url: string): string {\n const slashIndex = url && url.lastIndexOf('/');\n return slashIndex >= 0 ? url.substr(0, slashIndex as number) : '';\n}\n\n/**\n * Replacement for Node.js path.join\n * @param parts\n */\nexport function join(...parts: string[]): string {\n const separator = '/';\n parts = parts.map((part, index) => {\n if (index) {\n part = part.replace(new RegExp(`^${separator}`), '');\n }\n if (index !== parts.length - 1) {\n part = part.replace(new RegExp(`${separator}$`), '');\n }\n return part;\n });\n return parts.join(separator);\n}\n","import {Stats} from '@probe.gl/stats';\n\ntype Handle = any;\ntype DoneFunction = () => any;\ntype GetPriorityFunction = () => number;\ntype RequestResult = {\n done: DoneFunction;\n} | null;\n\n/** RequestScheduler Options */\nexport type RequestSchedulerProps = {\n id?: string;\n throttleRequests?: boolean;\n maxRequests?: number;\n};\n\nconst STAT_QUEUED_REQUESTS = 'Queued Requests';\nconst STAT_ACTIVE_REQUESTS = 'Active Requests';\nconst STAT_CANCELLED_REQUESTS = 'Cancelled Requests';\nconst STAT_QUEUED_REQUESTS_EVER = 'Queued Requests Ever';\nconst STAT_ACTIVE_REQUESTS_EVER = 'Active Requests Ever';\n\nconst DEFAULT_PROPS: Required<RequestSchedulerProps> = {\n id: 'request-scheduler',\n // Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing\n throttleRequests: true,\n // The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit.\n maxRequests: 6\n};\n\n/** Tracks one request */\ntype Request = {\n handle: Handle;\n priority: number;\n getPriority: GetPriorityFunction;\n resolve?: (value: any) => any;\n};\n\n/**\n * Used to issue a request, without having them \"deeply queued\" by the browser.\n * @todo - Track requests globally, across multiple servers\n */\nexport default class RequestScheduler {\n readonly props: Required<RequestSchedulerProps>;\n readonly stats: Stats;\n activeRequestCount: number = 0;\n\n /** Tracks the number of active requests and prioritizes/cancels queued requests. */\n private requestQueue: Request[] = [];\n private requestMap: Map<Handle, Promise<RequestResult>> = new Map();\n private deferredUpdate: any = null;\n\n constructor(props: RequestSchedulerProps = {}) {\n this.props = {...DEFAULT_PROPS, ...props};\n\n // Returns the statistics used by the request scheduler.\n this.stats = new Stats({id: this.props.id});\n this.stats.get(STAT_QUEUED_REQUESTS);\n this.stats.get(STAT_ACTIVE_REQUESTS);\n this.stats.get(STAT_CANCELLED_REQUESTS);\n this.stats.get(STAT_QUEUED_REQUESTS_EVER);\n this.stats.get(STAT_ACTIVE_REQUESTS_EVER);\n }\n\n /**\n * Called by an application that wants to issue a request, without having it deeply queued by the browser\n *\n * When the returned promise resolved, it is OK for the application to issue a request.\n * The promise resolves to an object that contains a `done` method.\n * When the application's request has completed (or failed), the application must call the `done` function\n *\n * @param handle\n * @param getPriority will be called when request \"slots\" open up,\n * allowing the caller to update priority or cancel the request\n * Highest priority executes first, priority < 0 cancels the request\n * @returns a promise\n * - resolves to a object (with a `done` field) when the request can be issued without queueing,\n * - resolves to `null` if the request has been cancelled (by the callback return < 0).\n * In this case the application should not issue the request\n */\n scheduleRequest(\n handle: Handle,\n getPriority: GetPriorityFunction = () => 0\n ): Promise<RequestResult> {\n // Allows throttling to be disabled\n if (!this.props.throttleRequests) {\n return Promise.resolve({done: () => {}});\n }\n\n // dedupe\n if (this.requestMap.has(handle)) {\n return this.requestMap.get(handle) as Promise<any>;\n }\n\n const request: Request = {handle, priority: 0, getPriority};\n const promise = new Promise<RequestResult>((resolve) => {\n // @ts-ignore\n request.resolve = resolve;\n return request;\n });\n\n this.requestQueue.push(request);\n this.requestMap.set(handle, promise);\n this._issueNewRequests();\n return promise;\n }\n\n // PRIVATE\n\n _issueRequest(request: Request): Promise<any> {\n const {handle, resolve} = request;\n let isDone = false;\n\n const done = () => {\n // can only be called once\n if (!isDone) {\n isDone = true;\n\n // Stop tracking a request - it has completed, failed, cancelled etc\n this.requestMap.delete(handle);\n this.activeRequestCount--;\n // A slot just freed up, see if any queued requests are waiting\n this._issueNewRequests();\n }\n };\n\n // Track this request\n this.activeRequestCount++;\n\n return resolve ? resolve({done}) : Promise.resolve({done});\n }\n\n /** We check requests asynchronously, to prevent multiple updates */\n _issueNewRequests(): void {\n if (!this.deferredUpdate) {\n this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);\n }\n }\n\n /** Refresh all requests */\n _issueNewRequestsAsync() {\n // TODO - shouldn't we clear the timeout?\n this.deferredUpdate = null;\n\n const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);\n\n if (freeSlots === 0) {\n return;\n }\n\n this._updateAllRequests();\n\n // Resolve pending promises for the top-priority requests\n for (let i = 0; i < freeSlots; ++i) {\n const request = this.requestQueue.shift();\n if (request) {\n this._issueRequest(request); // eslint-disable-line @typescript-eslint/no-floating-promises\n }\n }\n\n // Uncomment to debug\n // console.log(`${freeSlots} free slots, ${this.requestQueue.length} queued requests`);\n }\n\n /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */\n _updateAllRequests() {\n const requestQueue = this.requestQueue;\n for (let i = 0; i < requestQueue.length; ++i) {\n const request = requestQueue[i];\n if (!this._updateRequest(request)) {\n // Remove the element and make sure to adjust the counter to account for shortened array\n requestQueue.splice(i, 1);\n this.requestMap.delete(request.handle);\n i--;\n }\n }\n\n // Sort the remaining requests based on priority\n requestQueue.sort((a, b) => a.priority - b.priority);\n }\n\n /** Update a single request by calling the callback */\n _updateRequest(request) {\n request.priority = request.getPriority(request.handle); // eslint-disable-line callback-return\n\n // by returning a negative priority, the callback cancels the request\n if (request.priority < 0) {\n request.resolve(null);\n return false;\n }\n return true;\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n/**\n * Doubly linked list node\n *\n * @private\n */\nexport default class DoublyLinkedListNode {\n constructor(item, previous, next) {\n this.item = item;\n this.previous = previous;\n this.next = next;\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport DoublyLinkedListNode from '../utils/doubly-linked-list-node';\n\n/**\n * Doubly linked list\n *\n * @private\n */\nexport default class DoublyLinkedList {\n constructor() {\n this.head = null;\n this.tail = null;\n this._length = 0;\n }\n\n get length() {\n return this._length;\n }\n\n /**\n * Adds the item to the end of the list\n * @param {*} [item]\n * @return {DoublyLinkedListNode}\n */\n add(item) {\n const node = new DoublyLinkedListNode(item, this.tail, null);\n\n if (this.tail) {\n this.tail.next = node;\n this.tail = node;\n } else {\n this.head = node;\n this.tail = node;\n }\n\n ++this._length;\n\n return node;\n }\n\n /**\n * Removes the given node from the list\n * @param {DoublyLinkedListNode} node\n */\n remove(node) {\n if (!node) {\n return;\n }\n\n if (node.previous && node.next) {\n node.previous.next = node.next;\n node.next.previous = node.previous;\n } else if (node.previous) {\n // Remove last node\n node.previous.next = null;\n this.tail = node.previous;\n } else if (node.next) {\n // Remove first node\n node.next.previous = null;\n this.head = node.next;\n } else {\n // Remove last node in the linked list\n this.head = null;\n this.tail = null;\n }\n\n node.next = null;\n node.previous = null;\n\n --this._length;\n }\n\n /**\n * Moves nextNode after node\n * @param {DoublyLinkedListNode} node\n * @param {DoublyLinkedListNode} nextNode\n */\n splice(node, nextNode) {\n if (node === nextNode) {\n return;\n }\n\n // Remove nextNode, then insert after node\n this.remove(nextNode);\n this._insert(node, nextNode);\n }\n\n _insert(node, nextNode) {\n const oldNodeNext = node.next;\n node.next = nextNode;\n\n // nextNode is the new tail\n if (this.tail === node) {\n this.tail = nextNode;\n } else {\n oldNodeNext.previous = nextNode;\n }\n\n nextNode.next = oldNodeNext;\n nextNode.previous = node;\n\n ++this._length;\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport DoublyLinkedList from '../utils/doubly-linked-list';\n\nfunction defined(x) {\n return x !== undefined && x !== null;\n}\n\n/**\n * Stores tiles with content loaded.\n *\n * @private\n */\nexport default class TilesetCache {\n private _list: DoublyLinkedList;\n private _sentinel: any;\n private _trimTiles: boolean;\n\n constructor() {\n // [head, sentinel) -> tiles that weren't selected this frame and may be removed from the cache\n // (sentinel, tail] -> tiles that were selected this frame\n this._list = new DoublyLinkedList();\n this._sentinel = this._list.add('sentinel');\n this._trimTiles = false;\n }\n\n reset() {\n // Move sentinel node to the tail so, at the start of the frame, all tiles\n // may be potentially replaced. Tiles are moved to the right of the sentinel\n // when they are selected so they will not be replaced.\n this._list.splice(this._list.tail, this._sentinel);\n }\n\n touch(tile) {\n const node = tile._cacheNode;\n if (defined(node)) {\n this._list.splice(this._sentinel, node);\n }\n }\n\n add(tileset, tile, addCallback) {\n if (!defined(tile._cacheNode)) {\n tile._cacheNode = this._list.add(tile);\n\n if (addCallback) {\n addCallback(tileset, tile);\n }\n }\n }\n\n unloadTile(tileset, tile, unloadCallback?) {\n const node = tile._cacheNode;\n if (!defined(node)) {\n return;\n }\n\n this._list.remove(node);\n tile._cacheNode = undefined;\n if (unloadCallback) {\n unloadCallback(tileset, tile);\n }\n }\n\n unloadTiles(tileset, unloadCallback) {\n const trimTiles = this._trimTiles;\n this._trimTiles = false;\n\n const list = this._list;\n\n const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;\n\n // Traverse the list only to the sentinel since tiles/nodes to the\n // right of the sentinel were used this frame.\n // The sub-list to the left of the sentinel is ordered from LRU to MRU.\n const sentinel = this._sentinel;\n let node = list.head;\n\n while (\n node !== sentinel &&\n (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)\n ) {\n const tile = node.item;\n node = node.next;\n this.unloadTile(tileset, tile, unloadCallback);\n }\n }\n\n trim() {\n this._trimTiles = true;\n }\n}\n","import {Ellipsoid} from '@math.gl/geospatial';\nimport {Matrix4, Vector3} from '@math.gl/core';\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function calculateTransformProps(tileHeader, tile) {\n assert(tileHeader);\n assert(tile);\n\n const {rtcCenter, gltfUpAxis} = tile;\n const {\n computedTransform,\n boundingVolume: {center}\n } = tileHeader;\n\n let modelMatrix = new Matrix4(computedTransform);\n\n // Translate if appropriate\n if (rtcCenter) {\n modelMatrix.translate(rtcCenter);\n }\n\n // glTF models need to be rotated from Y to Z up\n // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up\n switch (gltfUpAxis) {\n case 'Z':\n break;\n case 'Y':\n const rotationY = new Matrix4().rotateX(Math.PI / 2);\n modelMatrix = modelMatrix.multiplyRight(rotationY);\n break;\n case 'X':\n const rotationX = new Matrix4().rotateY(-Math.PI / 2);\n modelMatrix = modelMatrix.multiplyRight(rotationX);\n break;\n default:\n break;\n }\n\n // Scale/offset positions if normalized integers\n if (tile.isQuantized) {\n modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);\n }\n\n // Option 1: Cartesian matrix and origin\n const cartesianOrigin = new Vector3(center);\n\n tile.cartesianModelMatrix = modelMatrix;\n tile.cartesianOrigin = cartesianOrigin;\n\n // Option 2: Cartographic matrix and origin\n const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(\n cartesianOrigin,\n new Vector3()\n );\n const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);\n const toFixedFrameMatrix = fromFixedFrameMatrix.invert();\n\n tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);\n tile.cartographicOrigin = cartographicOrigin;\n\n // Deprecated, drop\n if (!tile.coordinateSystem) {\n tile.modelMatrix = tile.cartographicModelMatrix;\n }\n}\n","export const INTERSECTION = Object.freeze({\n OUTSIDE: -1,\n INTERSECTING: 0,\n INSIDE: 1\n});\n//# sourceMappingURL=constants.js.map","import { Vector3 } from '@math.gl/core';\nimport { INTERSECTION } from '../../constants';\nconst scratchVector = new Vector3();\nconst scratchNormal = new Vector3();\nexport default class AxisAlignedBoundingBox {\n constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center = null) {\n center = center || scratchVector.copy(minimum).add(maximum).scale(0.5);\n this.center = new Vector3(center);\n this.halfDiagonal = new Vector3(maximum).subtract(this.center);\n this.minimum = new Vector3(minimum);\n this.maximum = new Vector3(maximum);\n }\n\n clone() {\n return new AxisAlignedBoundingBox(this.minimum, this.maximum, this.center);\n }\n\n equals(right) {\n return this === right || Boolean(right) && this.minimum.equals(right.minimum) && this.maximum.equals(right.maximum);\n }\n\n transform(transformation) {\n this.center.transformAsPoint(transformation);\n this.halfDiagonal.transform(transformation);\n this.minimum.transform(transformation);\n this.maximum.transform(transformation);\n return this;\n }\n\n intersectPlane(plane) {\n const {\n halfDiagonal\n } = this;\n const normal = scratchNormal.from(plane.normal);\n const e = halfDiagonal.x * Math.abs(normal.x) + halfDiagonal.y * Math.abs(normal.y) + halfDiagonal.z * Math.abs(normal.z);\n const s = this.center.dot(normal) + plane.distance;\n\n if (s - e > 0) {\n return INTERSECTION.INSIDE;\n }\n\n if (s + e < 0) {\n return INTERSECTION.OUTSIDE;\n }\n\n return INTERSECTION.INTERSECTING;\n }\n\n distanceTo(point) {\n return Math.sqrt(this.distanceSquaredTo(point));\n }\n\n distanceSquaredTo(point) {\n const offset = scratchVector.from(point).subtract(this.center);\n const {\n halfDiagonal\n } = this;\n let distanceSquared = 0.0;\n let d;\n d = Math.abs(offset.x) - halfDiagonal.x;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.y) - halfDiagonal.y;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.z) - halfDiagonal.z;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n return distanceSquared;\n }\n\n}\n//# sourceMappingURL=axis-aligned-bounding-box.js.map","import { Vector3 } from '@math.gl/core';\nimport * as mat4 from 'gl-matrix/mat4';\nimport { INTERSECTION } from '../../constants';\nconst scratchVector = new Vector3();\nconst scratchVector2 = new Vector3();\nexport default class BoundingSphere {\n constructor(center = [0, 0, 0], radius = 0.0) {\n this.radius = -0;\n this.center = new Vector3();\n this.fromCenterRadius(center, radius);\n }\n\n fromCenterRadius(center, radius) {\n this.center.from(center);\n this.radius = radius;\n return this;\n }\n\n fromCornerPoints(corner, oppositeCorner) {\n oppositeCorner = scratchVector.from(oppositeCorner);\n this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);\n this.radius = this.center.distance(oppositeCorner);\n return this;\n }\n\n equals(right) {\n return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius;\n }\n\n clone() {\n return new BoundingSphere(this.center, this.radius);\n }\n\n union(boundingSphere) {\n const leftCenter = this.center;\n const leftRadius = this.radius;\n const rightCenter = boundingSphere.center;\n const rightRadius = boundingSphere.radius;\n const toRightCenter = scratchVector.copy(rightCenter).subtract(leftCenter);\n const centerSeparation = toRightCenter.magnitude();\n\n if (leftRadius >= centerSeparation + rightRadius) {\n return this.clone();\n }\n\n if (rightRadius >= centerSeparation + leftRadius) {\n return boundingSphere.clone();\n }\n\n const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;\n scratchVector2.copy(toRightCenter).scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation).add(leftCenter);\n this.center.copy(scratchVector2);\n this.radius = halfDistanceBetweenTangentPoints;\n return this;\n }\n\n expand(point) {\n point = scratchVector.from(point);\n const radius = point.subtract(this.center).magnitude();\n\n if (radius > this.radius) {\n this.radius = radius;\n }\n\n return this;\n }\n\n transform(transform) {\n this.center.transform(transform);\n const scale = mat4.getScaling(scratchVector, transform);\n this.radius = Math.max(scale[0], Math.max(scale[1], scale[2])) * this.radius;\n return this;\n }\n\n distanceSquaredTo(point) {\n point = scratchVector.from(point);\n const delta = point.subtract(this.center);\n return delta.lengthSquared() - this.radius * this.radius;\n }\n\n distanceTo(point) {\n return Math.sqrt(this.distanceSquaredTo(point));\n }\n\n intersectPlane(plane) {\n const center = this.center;\n const radius = this.radius;\n const normal = plane.normal;\n const distanceToPlane = normal.dot(center) + plane.distance;\n\n if (distanceToPlane < -radius) {\n return INTERSECTION.OUTSIDE;\n }\n\n if (distanceToPlane < radius) {\n return INTERSECTION.INTERSECTING;\n }\n\n return INTERSECTION.INSIDE;\n }\n\n}\n//# sourceMappingURL=bounding-sphere.js.map","import * as glMatrix from \"./common.js\";\n/**\r\n * 3x3 Matrix\r\n * @module mat3\r\n */\n\n/**\r\n * Creates a new identity mat3\r\n *\r\n * @returns {mat3} a new 3x3 matrix\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(9);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n }\n\n out[0] = 1;\n out[4] = 1;\n out[8] = 1;\n return out;\n}\n/**\r\n * Copies the upper-left 3x3 values into the given mat3.\r\n *\r\n * @param {mat3} out the receiving 3x3 matrix\r\n * @param {ReadonlyMat4} a the source 4x4 matrix\r\n * @returns {mat3} out\r\n */\n\nexport function fromMat4(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[4];\n out[4] = a[5];\n out[5] = a[6];\n out[6] = a[8];\n out[7] = a[9];\n out[8] = a[10];\n return out;\n}\n/**\r\n * Creates a new mat3 initialized with values from an existing matrix\r\n *\r\n * @param {ReadonlyMat3} a matrix to clone\r\n * @returns {mat3} a new 3x3 matrix\r\n */\n\nexport function clone(a) {\n var out = new glMatrix.ARRAY_TYPE(9);\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n return out;\n}\n/**\r\n * Copy the values from one mat3 to another\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function copy(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = a[2];\n out[3] = a[3];\n out[4] = a[4];\n out[5] = a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n return out;\n}\n/**\r\n * Create a new mat3 with the given values\r\n *\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\r\n * @returns {mat3} A new mat3\r\n */\n\nexport function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n var out = new glMatrix.ARRAY_TYPE(9);\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m10;\n out[4] = m11;\n out[5] = m12;\n out[6] = m20;\n out[7] = m21;\n out[8] = m22;\n return out;\n}\n/**\r\n * Set the components of a mat3 to the given values\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\r\n * @returns {mat3} out\r\n */\n\nexport function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n out[0] = m00;\n out[1] = m01;\n out[2] = m02;\n out[3] = m10;\n out[4] = m11;\n out[5] = m12;\n out[6] = m20;\n out[7] = m21;\n out[8] = m22;\n return out;\n}\n/**\r\n * Set a mat3 to the identity matrix\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @returns {mat3} out\r\n */\n\nexport function identity(out) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 1;\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 1;\n return out;\n}\n/**\r\n * Transpose the values of a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function transpose(out, a) {\n // If we are transposing ourselves we can skip a few steps but have to cache some values\n if (out === a) {\n var a01 = a[1],\n a02 = a[2],\n a12 = a[5];\n out[1] = a[3];\n out[2] = a[6];\n out[3] = a01;\n out[5] = a[7];\n out[6] = a02;\n out[7] = a12;\n } else {\n out[0] = a[0];\n out[1] = a[3];\n out[2] = a[6];\n out[3] = a[1];\n out[4] = a[4];\n out[5] = a[7];\n out[6] = a[2];\n out[7] = a[5];\n out[8] = a[8];\n }\n\n return out;\n}\n/**\r\n * Inverts a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function invert(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n var b01 = a22 * a11 - a12 * a21;\n var b11 = -a22 * a10 + a12 * a20;\n var b21 = a21 * a10 - a11 * a20; // Calculate the determinant\n\n var det = a00 * b01 + a01 * b11 + a02 * b21;\n\n if (!det) {\n return null;\n }\n\n det = 1.0 / det;\n out[0] = b01 * det;\n out[1] = (-a22 * a01 + a02 * a21) * det;\n out[2] = (a12 * a01 - a02 * a11) * det;\n out[3] = b11 * det;\n out[4] = (a22 * a00 - a02 * a20) * det;\n out[5] = (-a12 * a00 + a02 * a10) * det;\n out[6] = b21 * det;\n out[7] = (-a21 * a00 + a01 * a20) * det;\n out[8] = (a11 * a00 - a01 * a10) * det;\n return out;\n}\n/**\r\n * Calculates the adjugate of a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {mat3} out\r\n */\n\nexport function adjoint(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n out[0] = a11 * a22 - a12 * a21;\n out[1] = a02 * a21 - a01 * a22;\n out[2] = a01 * a12 - a02 * a11;\n out[3] = a12 * a20 - a10 * a22;\n out[4] = a00 * a22 - a02 * a20;\n out[5] = a02 * a10 - a00 * a12;\n out[6] = a10 * a21 - a11 * a20;\n out[7] = a01 * a20 - a00 * a21;\n out[8] = a00 * a11 - a01 * a10;\n return out;\n}\n/**\r\n * Calculates the determinant of a mat3\r\n *\r\n * @param {ReadonlyMat3} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\n\nexport function determinant(a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);\n}\n/**\r\n * Multiplies two mat3's\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @returns {mat3} out\r\n */\n\nexport function multiply(out, a, b) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2];\n var a10 = a[3],\n a11 = a[4],\n a12 = a[5];\n var a20 = a[6],\n a21 = a[7],\n a22 = a[8];\n var b00 = b[0],\n b01 = b[1],\n b02 = b[2];\n var b10 = b[3],\n b11 = b[4],\n b12 = b[5];\n var b20 = b[6],\n b21 = b[7],\n b22 = b[8];\n out[0] = b00 * a00 + b01 * a10 + b02 * a20;\n out[1] = b00 * a01 + b01 * a11 + b02 * a21;\n out[2] = b00 * a02 + b01 * a12 + b02 * a22;\n out[3] = b10 * a00 + b11 * a10 + b12 * a20;\n out[4] = b10 * a01 + b11 * a11 + b12 * a21;\n out[5] = b10 * a02 + b11 * a12 + b12 * a22;\n out[6] = b20 * a00 + b21 * a10 + b22 * a20;\n out[7] = b20 * a01 + b21 * a11 + b22 * a21;\n out[8] = b20 * a02 + b21 * a12 + b22 * a22;\n return out;\n}\n/**\r\n * Translate a mat3 by the given vector\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to translate\r\n * @param {ReadonlyVec2} v vector to translate by\r\n * @returns {mat3} out\r\n */\n\nexport function translate(out, a, v) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a10 = a[3],\n a11 = a[4],\n a12 = a[5],\n a20 = a[6],\n a21 = a[7],\n a22 = a[8],\n x = v[0],\n y = v[1];\n out[0] = a00;\n out[1] = a01;\n out[2] = a02;\n out[3] = a10;\n out[4] = a11;\n out[5] = a12;\n out[6] = x * a00 + y * a10 + a20;\n out[7] = x * a01 + y * a11 + a21;\n out[8] = x * a02 + y * a12 + a22;\n return out;\n}\n/**\r\n * Rotates a mat3 by the given angle\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat3} out\r\n */\n\nexport function rotate(out, a, rad) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a10 = a[3],\n a11 = a[4],\n a12 = a[5],\n a20 = a[6],\n a21 = a[7],\n a22 = a[8],\n s = Math.sin(rad),\n c = Math.cos(rad);\n out[0] = c * a00 + s * a10;\n out[1] = c * a01 + s * a11;\n out[2] = c * a02 + s * a12;\n out[3] = c * a10 - s * a00;\n out[4] = c * a11 - s * a01;\n out[5] = c * a12 - s * a02;\n out[6] = a20;\n out[7] = a21;\n out[8] = a22;\n return out;\n}\n/**\r\n * Scales the mat3 by the dimensions in the given vec2\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to rotate\r\n * @param {ReadonlyVec2} v the vec2 to scale the matrix by\r\n * @returns {mat3} out\r\n **/\n\nexport function scale(out, a, v) {\n var x = v[0],\n y = v[1];\n out[0] = x * a[0];\n out[1] = x * a[1];\n out[2] = x * a[2];\n out[3] = y * a[3];\n out[4] = y * a[4];\n out[5] = y * a[5];\n out[6] = a[6];\n out[7] = a[7];\n out[8] = a[8];\n return out;\n}\n/**\r\n * Creates a matrix from a vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.translate(dest, dest, vec);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyVec2} v Translation vector\r\n * @returns {mat3} out\r\n */\n\nexport function fromTranslation(out, v) {\n out[0] = 1;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = 1;\n out[5] = 0;\n out[6] = v[0];\n out[7] = v[1];\n out[8] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a given angle\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.rotate(dest, dest, rad);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat3} out\r\n */\n\nexport function fromRotation(out, rad) {\n var s = Math.sin(rad),\n c = Math.cos(rad);\n out[0] = c;\n out[1] = s;\n out[2] = 0;\n out[3] = -s;\n out[4] = c;\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 1;\n return out;\n}\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.scale(dest, dest, vec);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyVec2} v Scaling vector\r\n * @returns {mat3} out\r\n */\n\nexport function fromScaling(out, v) {\n out[0] = v[0];\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = v[1];\n out[5] = 0;\n out[6] = 0;\n out[7] = 0;\n out[8] = 1;\n return out;\n}\n/**\r\n * Copies the values from a mat2d into a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat2d} a the matrix to copy\r\n * @returns {mat3} out\r\n **/\n\nexport function fromMat2d(out, a) {\n out[0] = a[0];\n out[1] = a[1];\n out[2] = 0;\n out[3] = a[2];\n out[4] = a[3];\n out[5] = 0;\n out[6] = a[4];\n out[7] = a[5];\n out[8] = 1;\n return out;\n}\n/**\r\n * Calculates a 3x3 matrix from the given quaternion\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyQuat} q Quaternion to create matrix from\r\n *\r\n * @returns {mat3} out\r\n */\n\nexport function fromQuat(out, q) {\n var x = q[0],\n y = q[1],\n z = q[2],\n w = q[3];\n var x2 = x + x;\n var y2 = y + y;\n var z2 = z + z;\n var xx = x * x2;\n var yx = y * x2;\n var yy = y * y2;\n var zx = z * x2;\n var zy = z * y2;\n var zz = z * z2;\n var wx = w * x2;\n var wy = w * y2;\n var wz = w * z2;\n out[0] = 1 - yy - zz;\n out[3] = yx - wz;\n out[6] = zx + wy;\n out[1] = yx + wz;\n out[4] = 1 - xx - zz;\n out[7] = zy - wx;\n out[2] = zx - wy;\n out[5] = zy + wx;\n out[8] = 1 - xx - yy;\n return out;\n}\n/**\r\n * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {ReadonlyMat4} a Mat4 to derive the normal matrix from\r\n *\r\n * @returns {mat3} out\r\n */\n\nexport function normalFromMat4(out, a) {\n var a00 = a[0],\n a01 = a[1],\n a02 = a[2],\n a03 = a[3];\n var a10 = a[4],\n a11 = a[5],\n a12 = a[6],\n a13 = a[7];\n var a20 = a[8],\n a21 = a[9],\n a22 = a[10],\n a23 = a[11];\n var a30 = a[12],\n a31 = a[13],\n a32 = a[14],\n a33 = a[15];\n var b00 = a00 * a11 - a01 * a10;\n var b01 = a00 * a12 - a02 * a10;\n var b02 = a00 * a13 - a03 * a10;\n var b03 = a01 * a12 - a02 * a11;\n var b04 = a01 * a13 - a03 * a11;\n var b05 = a02 * a13 - a03 * a12;\n var b06 = a20 * a31 - a21 * a30;\n var b07 = a20 * a32 - a22 * a30;\n var b08 = a20 * a33 - a23 * a30;\n var b09 = a21 * a32 - a22 * a31;\n var b10 = a21 * a33 - a23 * a31;\n var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n if (!det) {\n return null;\n }\n\n det = 1.0 / det;\n out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\n out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\n out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\n out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\n out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\n out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\n out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\n out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\n out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\n return out;\n}\n/**\r\n * Generates a 2D projection matrix with the given bounds\r\n *\r\n * @param {mat3} out mat3 frustum matrix will be written into\r\n * @param {number} width Width of your gl context\r\n * @param {number} height Height of gl context\r\n * @returns {mat3} out\r\n */\n\nexport function projection(out, width, height) {\n out[0] = 2 / width;\n out[1] = 0;\n out[2] = 0;\n out[3] = 0;\n out[4] = -2 / height;\n out[5] = 0;\n out[6] = -1;\n out[7] = 1;\n out[8] = 1;\n return out;\n}\n/**\r\n * Returns a string representation of a mat3\r\n *\r\n * @param {ReadonlyMat3} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\n\nexport function str(a) {\n return \"mat3(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \", \" + a[4] + \", \" + a[5] + \", \" + a[6] + \", \" + a[7] + \", \" + a[8] + \")\";\n}\n/**\r\n * Returns Frobenius norm of a mat3\r\n *\r\n * @param {ReadonlyMat3} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\n\nexport function frob(a) {\n return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);\n}\n/**\r\n * Adds two mat3's\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @returns {mat3} out\r\n */\n\nexport function add(out, a, b) {\n out[0] = a[0] + b[0];\n out[1] = a[1] + b[1];\n out[2] = a[2] + b[2];\n out[3] = a[3] + b[3];\n out[4] = a[4] + b[4];\n out[5] = a[5] + b[5];\n out[6] = a[6] + b[6];\n out[7] = a[7] + b[7];\n out[8] = a[8] + b[8];\n return out;\n}\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @returns {mat3} out\r\n */\n\nexport function subtract(out, a, b) {\n out[0] = a[0] - b[0];\n out[1] = a[1] - b[1];\n out[2] = a[2] - b[2];\n out[3] = a[3] - b[3];\n out[4] = a[4] - b[4];\n out[5] = a[5] - b[5];\n out[6] = a[6] - b[6];\n out[7] = a[7] - b[7];\n out[8] = a[8] - b[8];\n return out;\n}\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {ReadonlyMat3} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat3} out\r\n */\n\nexport function multiplyScalar(out, a, b) {\n out[0] = a[0] * b;\n out[1] = a[1] * b;\n out[2] = a[2] * b;\n out[3] = a[3] * b;\n out[4] = a[4] * b;\n out[5] = a[5] * b;\n out[6] = a[6] * b;\n out[7] = a[7] * b;\n out[8] = a[8] * b;\n return out;\n}\n/**\r\n * Adds two mat3's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat3} out the receiving vector\r\n * @param {ReadonlyMat3} a the first operand\r\n * @param {ReadonlyMat3} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat3} out\r\n */\n\nexport function multiplyScalarAndAdd(out, a, b, scale) {\n out[0] = a[0] + b[0] * scale;\n out[1] = a[1] + b[1] * scale;\n out[2] = a[2] + b[2] * scale;\n out[3] = a[3] + b[3] * scale;\n out[4] = a[4] + b[4] * scale;\n out[5] = a[5] + b[5] * scale;\n out[6] = a[6] + b[6] * scale;\n out[7] = a[7] + b[7] * scale;\n out[8] = a[8] + b[8] * scale;\n return out;\n}\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyMat3} a The first matrix.\r\n * @param {ReadonlyMat3} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function exactEquals(a, b) {\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8];\n}\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyMat3} a The first matrix.\r\n * @param {ReadonlyMat3} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\n\nexport function equals(a, b) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3],\n a4 = a[4],\n a5 = a[5],\n a6 = a[6],\n a7 = a[7],\n a8 = a[8];\n var b0 = b[0],\n b1 = b[1],\n b2 = b[2],\n b3 = b[3],\n b4 = b[4],\n b5 = b[5],\n b6 = b[6],\n b7 = b[7],\n b8 = b[8];\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8));\n}\n/**\r\n * Alias for {@link mat3.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Alias for {@link mat3.subtract}\r\n * @function\r\n */\n\nexport var sub = subtract;","import Matrix from './base/matrix';\nimport { checkVector, deprecated } from '../lib/validators';\nimport { vec4_transformMat3 } from '../lib/gl-matrix-extras';\nimport * as mat3 from 'gl-matrix/mat3';\nimport * as vec2 from 'gl-matrix/vec2';\nimport * as vec3 from 'gl-matrix/vec3';\nconst IDENTITY = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);\nconst ZERO = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0]);\nconst INDICES = Object.freeze({\n COL0ROW0: 0,\n COL0ROW1: 1,\n COL0ROW2: 2,\n COL1ROW0: 3,\n COL1ROW1: 4,\n COL1ROW2: 5,\n COL2ROW0: 6,\n COL2ROW1: 7,\n COL2ROW2: 8\n});\nconst constants = {};\nexport default class Matrix3 extends Matrix {\n static get IDENTITY() {\n constants.IDENTITY = constants.IDENTITY || Object.freeze(new Matrix3(IDENTITY));\n return constants.IDENTITY;\n }\n\n static get ZERO() {\n constants.ZERO = constants.ZERO || Object.freeze(new Matrix3(ZERO));\n return constants.ZERO;\n }\n\n get ELEMENTS() {\n return 9;\n }\n\n get RANK() {\n return 3;\n }\n\n get INDICES() {\n return INDICES;\n }\n\n constructor(array) {\n super(-0, -0, -0, -0, -0, -0, -0, -0, -0);\n\n if (arguments.length === 1 && Array.isArray(array)) {\n this.copy(array);\n } else {\n this.identity();\n }\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n this[3] = array[3];\n this[4] = array[4];\n this[5] = array[5];\n this[6] = array[6];\n this[7] = array[7];\n this[8] = array[8];\n return this.check();\n }\n\n set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m01;\n this[4] = m11;\n this[5] = m21;\n this[6] = m02;\n this[7] = m12;\n this[8] = m22;\n return this.check();\n }\n\n setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n this[0] = m00;\n this[1] = m10;\n this[2] = m20;\n this[3] = m01;\n this[4] = m11;\n this[5] = m21;\n this[6] = m02;\n this[7] = m12;\n this[8] = m22;\n return this.check();\n }\n\n determinant() {\n return mat3.determinant(this);\n }\n\n identity() {\n return this.copy(IDENTITY);\n }\n\n fromQuaternion(q) {\n mat3.fromQuat(this, q);\n return this.check();\n }\n\n transpose() {\n mat3.transpose(this, this);\n return this.check();\n }\n\n invert() {\n mat3.invert(this, this);\n return this.check();\n }\n\n multiplyLeft(a) {\n mat3.multiply(this, a, this);\n return this.check();\n }\n\n multiplyRight(a) {\n mat3.multiply(this, this, a);\n return this.check();\n }\n\n rotate(radians) {\n mat3.rotate(this, this, radians);\n return this.check();\n }\n\n scale(factor) {\n if (Array.isArray(factor)) {\n mat3.scale(this, this, factor);\n } else {\n mat3.scale(this, this, [factor, factor, factor]);\n }\n\n return this.check();\n }\n\n translate(vec) {\n mat3.translate(this, this, vec);\n return this.check();\n }\n\n transform(vector, result) {\n switch (vector.length) {\n case 2:\n result = vec2.transformMat3(result || [-0, -0], vector, this);\n break;\n\n case 3:\n result = vec3.transformMat3(result || [-0, -0, -0], vector, this);\n break;\n\n case 4:\n result = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);\n break;\n\n default:\n throw new Error('Illegal vector');\n }\n\n checkVector(result, vector.length);\n return result;\n }\n\n transformVector(vector, result) {\n deprecated('Matrix3.transformVector');\n return this.transform(vector, result);\n }\n\n transformVector2(vector, result) {\n deprecated('Matrix3.transformVector');\n return this.transform(vector, result);\n }\n\n transformVector3(vector, result) {\n deprecated('Matrix3.transformVector');\n return this.transform(vector, result);\n }\n\n}\n//# sourceMappingURL=matrix3.js.map","import * as glMatrix from \"./common.js\";\nimport * as mat3 from \"./mat3.js\";\nimport * as vec3 from \"./vec3.js\";\nimport * as vec4 from \"./vec4.js\";\n/**\r\n * Quaternion\r\n * @module quat\r\n */\n\n/**\r\n * Creates a new identity quat\r\n *\r\n * @returns {quat} a new quaternion\r\n */\n\nexport function create() {\n var out = new glMatrix.ARRAY_TYPE(4);\n\n if (glMatrix.ARRAY_TYPE != Float32Array) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n }\n\n out[3] = 1;\n return out;\n}\n/**\r\n * Set a quat to the identity quaternion\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @returns {quat} out\r\n */\n\nexport function identity(out) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n out[3] = 1;\n return out;\n}\n/**\r\n * Sets a quat from the given angle and rotation axis,\r\n * then returns it.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyVec3} axis the axis around which to rotate\r\n * @param {Number} rad the angle in radians\r\n * @returns {quat} out\r\n **/\n\nexport function setAxisAngle(out, axis, rad) {\n rad = rad * 0.5;\n var s = Math.sin(rad);\n out[0] = s * axis[0];\n out[1] = s * axis[1];\n out[2] = s * axis[2];\n out[3] = Math.cos(rad);\n return out;\n}\n/**\r\n * Gets the rotation axis and angle for a given\r\n * quaternion. If a quaternion is created with\r\n * setAxisAngle, this method will return the same\r\n * values as providied in the original parameter list\r\n * OR functionally equivalent values.\r\n * Example: The quaternion formed by axis [0, 0, 1] and\r\n * angle -90 is the same as the quaternion formed by\r\n * [0, 0, 1] and 270. This method favors the latter.\r\n * @param {vec3} out_axis Vector receiving the axis of rotation\r\n * @param {ReadonlyQuat} q Quaternion to be decomposed\r\n * @return {Number} Angle, in radians, of the rotation\r\n */\n\nexport function getAxisAngle(out_axis, q) {\n var rad = Math.acos(q[3]) * 2.0;\n var s = Math.sin(rad / 2.0);\n\n if (s > glMatrix.EPSILON) {\n out_axis[0] = q[0] / s;\n out_axis[1] = q[1] / s;\n out_axis[2] = q[2] / s;\n } else {\n // If s is zero, return any axis (no rotation - axis does not matter)\n out_axis[0] = 1;\n out_axis[1] = 0;\n out_axis[2] = 0;\n }\n\n return rad;\n}\n/**\r\n * Gets the angular distance between two unit quaternions\r\n *\r\n * @param {ReadonlyQuat} a Origin unit quaternion\r\n * @param {ReadonlyQuat} b Destination unit quaternion\r\n * @return {Number} Angle, in radians, between the two quaternions\r\n */\n\nexport function getAngle(a, b) {\n var dotproduct = dot(a, b);\n return Math.acos(2 * dotproduct * dotproduct - 1);\n}\n/**\r\n * Multiplies two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @returns {quat} out\r\n */\n\nexport function multiply(out, a, b) {\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bx = b[0],\n by = b[1],\n bz = b[2],\n bw = b[3];\n out[0] = ax * bw + aw * bx + ay * bz - az * by;\n out[1] = ay * bw + aw * by + az * bx - ax * bz;\n out[2] = az * bw + aw * bz + ax * by - ay * bx;\n out[3] = aw * bw - ax * bx - ay * by - az * bz;\n return out;\n}\n/**\r\n * Rotates a quaternion by the given angle about the X axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {ReadonlyQuat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\n\nexport function rotateX(out, a, rad) {\n rad *= 0.5;\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bx = Math.sin(rad),\n bw = Math.cos(rad);\n out[0] = ax * bw + aw * bx;\n out[1] = ay * bw + az * bx;\n out[2] = az * bw - ay * bx;\n out[3] = aw * bw - ax * bx;\n return out;\n}\n/**\r\n * Rotates a quaternion by the given angle about the Y axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {ReadonlyQuat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\n\nexport function rotateY(out, a, rad) {\n rad *= 0.5;\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var by = Math.sin(rad),\n bw = Math.cos(rad);\n out[0] = ax * bw - az * by;\n out[1] = ay * bw + aw * by;\n out[2] = az * bw + ax * by;\n out[3] = aw * bw - ay * by;\n return out;\n}\n/**\r\n * Rotates a quaternion by the given angle about the Z axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {ReadonlyQuat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\n\nexport function rotateZ(out, a, rad) {\n rad *= 0.5;\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bz = Math.sin(rad),\n bw = Math.cos(rad);\n out[0] = ax * bw + ay * bz;\n out[1] = ay * bw - ax * bz;\n out[2] = az * bw + aw * bz;\n out[3] = aw * bw - az * bz;\n return out;\n}\n/**\r\n * Calculates the W component of a quat from the X, Y, and Z components.\r\n * Assumes that quaternion is 1 unit in length.\r\n * Any existing W component will be ignored.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate W component of\r\n * @returns {quat} out\r\n */\n\nexport function calculateW(out, a) {\n var x = a[0],\n y = a[1],\n z = a[2];\n out[0] = x;\n out[1] = y;\n out[2] = z;\n out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));\n return out;\n}\n/**\r\n * Calculate the exponential of a unit quaternion.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate the exponential of\r\n * @returns {quat} out\r\n */\n\nexport function exp(out, a) {\n var x = a[0],\n y = a[1],\n z = a[2],\n w = a[3];\n var r = Math.sqrt(x * x + y * y + z * z);\n var et = Math.exp(w);\n var s = r > 0 ? et * Math.sin(r) / r : 0;\n out[0] = x * s;\n out[1] = y * s;\n out[2] = z * s;\n out[3] = et * Math.cos(r);\n return out;\n}\n/**\r\n * Calculate the natural logarithm of a unit quaternion.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate the exponential of\r\n * @returns {quat} out\r\n */\n\nexport function ln(out, a) {\n var x = a[0],\n y = a[1],\n z = a[2],\n w = a[3];\n var r = Math.sqrt(x * x + y * y + z * z);\n var t = r > 0 ? Math.atan2(r, w) / r : 0;\n out[0] = x * t;\n out[1] = y * t;\n out[2] = z * t;\n out[3] = 0.5 * Math.log(x * x + y * y + z * z + w * w);\n return out;\n}\n/**\r\n * Calculate the scalar power of a unit quaternion.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate the exponential of\r\n * @param {Number} b amount to scale the quaternion by\r\n * @returns {quat} out\r\n */\n\nexport function pow(out, a, b) {\n ln(out, a);\n scale(out, out, b);\n exp(out, out);\n return out;\n}\n/**\r\n * Performs a spherical linear interpolation between two quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n */\n\nexport function slerp(out, a, b, t) {\n // benchmarks:\n // http://jsperf.com/quaternion-slerp-implementations\n var ax = a[0],\n ay = a[1],\n az = a[2],\n aw = a[3];\n var bx = b[0],\n by = b[1],\n bz = b[2],\n bw = b[3];\n var omega, cosom, sinom, scale0, scale1; // calc cosine\n\n cosom = ax * bx + ay * by + az * bz + aw * bw; // adjust signs (if necessary)\n\n if (cosom < 0.0) {\n cosom = -cosom;\n bx = -bx;\n by = -by;\n bz = -bz;\n bw = -bw;\n } // calculate coefficients\n\n\n if (1.0 - cosom > glMatrix.EPSILON) {\n // standard case (slerp)\n omega = Math.acos(cosom);\n sinom = Math.sin(omega);\n scale0 = Math.sin((1.0 - t) * omega) / sinom;\n scale1 = Math.sin(t * omega) / sinom;\n } else {\n // \"from\" and \"to\" quaternions are very close\n // ... so we can do a linear interpolation\n scale0 = 1.0 - t;\n scale1 = t;\n } // calculate final values\n\n\n out[0] = scale0 * ax + scale1 * bx;\n out[1] = scale0 * ay + scale1 * by;\n out[2] = scale0 * az + scale1 * bz;\n out[3] = scale0 * aw + scale1 * bw;\n return out;\n}\n/**\r\n * Generates a random unit quaternion\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @returns {quat} out\r\n */\n\nexport function random(out) {\n // Implementation of http://planning.cs.uiuc.edu/node198.html\n // TODO: Calling random 3 times is probably not the fastest solution\n var u1 = glMatrix.RANDOM();\n var u2 = glMatrix.RANDOM();\n var u3 = glMatrix.RANDOM();\n var sqrt1MinusU1 = Math.sqrt(1 - u1);\n var sqrtU1 = Math.sqrt(u1);\n out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);\n out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);\n out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);\n out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);\n return out;\n}\n/**\r\n * Calculates the inverse of a quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate inverse of\r\n * @returns {quat} out\r\n */\n\nexport function invert(out, a) {\n var a0 = a[0],\n a1 = a[1],\n a2 = a[2],\n a3 = a[3];\n var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;\n var invDot = dot ? 1.0 / dot : 0; // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0\n\n out[0] = -a0 * invDot;\n out[1] = -a1 * invDot;\n out[2] = -a2 * invDot;\n out[3] = a3 * invDot;\n return out;\n}\n/**\r\n * Calculates the conjugate of a quat\r\n * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quat to calculate conjugate of\r\n * @returns {quat} out\r\n */\n\nexport function conjugate(out, a) {\n out[0] = -a[0];\n out[1] = -a[1];\n out[2] = -a[2];\n out[3] = a[3];\n return out;\n}\n/**\r\n * Creates a quaternion from the given 3x3 rotation matrix.\r\n *\r\n * NOTE: The resultant quaternion is not normalized, so you should be sure\r\n * to renormalize the quaternion yourself where necessary.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyMat3} m rotation matrix\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport function fromMat3(out, m) {\n // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes\n // article \"Quaternion Calculus and Fast Animation\".\n var fTrace = m[0] + m[4] + m[8];\n var fRoot;\n\n if (fTrace > 0.0) {\n // |w| > 1/2, may as well choose w > 1/2\n fRoot = Math.sqrt(fTrace + 1.0); // 2w\n\n out[3] = 0.5 * fRoot;\n fRoot = 0.5 / fRoot; // 1/(4w)\n\n out[0] = (m[5] - m[7]) * fRoot;\n out[1] = (m[6] - m[2]) * fRoot;\n out[2] = (m[1] - m[3]) * fRoot;\n } else {\n // |w| <= 1/2\n var i = 0;\n if (m[4] > m[0]) i = 1;\n if (m[8] > m[i * 3 + i]) i = 2;\n var j = (i + 1) % 3;\n var k = (i + 2) % 3;\n fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);\n out[i] = 0.5 * fRoot;\n fRoot = 0.5 / fRoot;\n out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;\n out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;\n out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;\n }\n\n return out;\n}\n/**\r\n * Creates a quaternion from the given euler angle x, y, z.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {x} Angle to rotate around X axis in degrees.\r\n * @param {y} Angle to rotate around Y axis in degrees.\r\n * @param {z} Angle to rotate around Z axis in degrees.\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport function fromEuler(out, x, y, z) {\n var halfToRad = 0.5 * Math.PI / 180.0;\n x *= halfToRad;\n y *= halfToRad;\n z *= halfToRad;\n var sx = Math.sin(x);\n var cx = Math.cos(x);\n var sy = Math.sin(y);\n var cy = Math.cos(y);\n var sz = Math.sin(z);\n var cz = Math.cos(z);\n out[0] = sx * cy * cz - cx * sy * sz;\n out[1] = cx * sy * cz + sx * cy * sz;\n out[2] = cx * cy * sz - sx * sy * cz;\n out[3] = cx * cy * cz + sx * sy * sz;\n return out;\n}\n/**\r\n * Returns a string representation of a quatenion\r\n *\r\n * @param {ReadonlyQuat} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\n\nexport function str(a) {\n return \"quat(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \")\";\n}\n/**\r\n * Creates a new quat initialized with values from an existing quaternion\r\n *\r\n * @param {ReadonlyQuat} a quaternion to clone\r\n * @returns {quat} a new quaternion\r\n * @function\r\n */\n\nexport var clone = vec4.clone;\n/**\r\n * Creates a new quat initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {quat} a new quaternion\r\n * @function\r\n */\n\nexport var fromValues = vec4.fromValues;\n/**\r\n * Copy the values from one quat to another\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the source quaternion\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var copy = vec4.copy;\n/**\r\n * Set the components of a quat to the given values\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var set = vec4.set;\n/**\r\n * Adds two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var add = vec4.add;\n/**\r\n * Alias for {@link quat.multiply}\r\n * @function\r\n */\n\nexport var mul = multiply;\n/**\r\n * Scales a quat by a scalar number\r\n *\r\n * @param {quat} out the receiving vector\r\n * @param {ReadonlyQuat} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var scale = vec4.scale;\n/**\r\n * Calculates the dot product of two quat's\r\n *\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @returns {Number} dot product of a and b\r\n * @function\r\n */\n\nexport var dot = vec4.dot;\n/**\r\n * Performs a linear interpolation between two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var lerp = vec4.lerp;\n/**\r\n * Calculates the length of a quat\r\n *\r\n * @param {ReadonlyQuat} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\n\nexport var length = vec4.length;\n/**\r\n * Alias for {@link quat.length}\r\n * @function\r\n */\n\nexport var len = length;\n/**\r\n * Calculates the squared length of a quat\r\n *\r\n * @param {ReadonlyQuat} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n * @function\r\n */\n\nexport var squaredLength = vec4.squaredLength;\n/**\r\n * Alias for {@link quat.squaredLength}\r\n * @function\r\n */\n\nexport var sqrLen = squaredLength;\n/**\r\n * Normalize a quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a quaternion to normalize\r\n * @returns {quat} out\r\n * @function\r\n */\n\nexport var normalize = vec4.normalize;\n/**\r\n * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {ReadonlyQuat} a The first quaternion.\r\n * @param {ReadonlyQuat} b The second quaternion.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport var exactEquals = vec4.exactEquals;\n/**\r\n * Returns whether or not the quaternions have approximately the same elements in the same position.\r\n *\r\n * @param {ReadonlyQuat} a The first vector.\r\n * @param {ReadonlyQuat} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\n\nexport var equals = vec4.equals;\n/**\r\n * Sets a quaternion to represent the shortest rotation from one\r\n * vector to another.\r\n *\r\n * Both vectors are assumed to be unit length.\r\n *\r\n * @param {quat} out the receiving quaternion.\r\n * @param {ReadonlyVec3} a the initial vector\r\n * @param {ReadonlyVec3} b the destination vector\r\n * @returns {quat} out\r\n */\n\nexport var rotationTo = function () {\n var tmpvec3 = vec3.create();\n var xUnitVec3 = vec3.fromValues(1, 0, 0);\n var yUnitVec3 = vec3.fromValues(0, 1, 0);\n return function (out, a, b) {\n var dot = vec3.dot(a, b);\n\n if (dot < -0.999999) {\n vec3.cross(tmpvec3, xUnitVec3, a);\n if (vec3.len(tmpvec3) < 0.000001) vec3.cross(tmpvec3, yUnitVec3, a);\n vec3.normalize(tmpvec3, tmpvec3);\n setAxisAngle(out, tmpvec3, Math.PI);\n return out;\n } else if (dot > 0.999999) {\n out[0] = 0;\n out[1] = 0;\n out[2] = 0;\n out[3] = 1;\n return out;\n } else {\n vec3.cross(tmpvec3, a, b);\n out[0] = tmpvec3[0];\n out[1] = tmpvec3[1];\n out[2] = tmpvec3[2];\n out[3] = 1 + dot;\n return normalize(out, out);\n }\n };\n}();\n/**\r\n * Performs a spherical linear interpolation with two control points\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {ReadonlyQuat} a the first operand\r\n * @param {ReadonlyQuat} b the second operand\r\n * @param {ReadonlyQuat} c the third operand\r\n * @param {ReadonlyQuat} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n */\n\nexport var sqlerp = function () {\n var temp1 = create();\n var temp2 = create();\n return function (out, a, b, c, d, t) {\n slerp(temp1, a, d, t);\n slerp(temp2, b, c, t);\n slerp(out, temp1, temp2, 2 * t * (1 - t));\n return out;\n };\n}();\n/**\r\n * Sets the specified quaternion with values corresponding to the given\r\n * axes. Each axis is a vec3 and is expected to be unit length and\r\n * perpendicular to all other specified axes.\r\n *\r\n * @param {ReadonlyVec3} view the vector representing the viewing direction\r\n * @param {ReadonlyVec3} right the vector representing the local \"right\" direction\r\n * @param {ReadonlyVec3} up the vector representing the local \"up\" direction\r\n * @returns {quat} out\r\n */\n\nexport var setAxes = function () {\n var matr = mat3.create();\n return function (out, view, right, up) {\n matr[0] = right[0];\n matr[3] = right[1];\n matr[6] = right[2];\n matr[1] = up[0];\n matr[4] = up[1];\n matr[7] = up[2];\n matr[2] = -view[0];\n matr[5] = -view[1];\n matr[8] = -view[2];\n return normalize(out, fromMat3(out, matr));\n };\n}();","import MathArray from './base/math-array';\nimport { checkNumber, checkVector } from '../lib/validators';\nimport assert from '../lib/assert';\nimport * as quat from 'gl-matrix/quat';\nimport * as vec4 from 'gl-matrix/vec4';\nconst IDENTITY_QUATERNION = [0, 0, 0, 1];\nexport default class Quaternion extends MathArray {\n constructor(x = 0, y = 0, z = 0, w = 1) {\n super(-0, -0, -0, -0);\n\n if (Array.isArray(x) && arguments.length === 1) {\n this.copy(x);\n } else {\n this.set(x, y, z, w);\n }\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n this[2] = array[2];\n this[3] = array[3];\n return this.check();\n }\n\n set(x, y, z, w) {\n this[0] = x;\n this[1] = y;\n this[2] = z;\n this[3] = w;\n return this.check();\n }\n\n fromMatrix3(m) {\n quat.fromMat3(this, m);\n return this.check();\n }\n\n identity() {\n quat.identity(this);\n return this.check();\n }\n\n fromAxisRotation(axis, rad) {\n quat.setAxisAngle(this, axis, rad);\n return this.check();\n }\n\n setAxisAngle(axis, rad) {\n return this.fromAxisRotation(axis, rad);\n }\n\n get ELEMENTS() {\n return 4;\n }\n\n get x() {\n return this[0];\n }\n\n set x(value) {\n this[0] = checkNumber(value);\n }\n\n get y() {\n return this[1];\n }\n\n set y(value) {\n this[1] = checkNumber(value);\n }\n\n get z() {\n return this[2];\n }\n\n set z(value) {\n this[2] = checkNumber(value);\n }\n\n get w() {\n return this[3];\n }\n\n set w(value) {\n this[3] = checkNumber(value);\n }\n\n len() {\n return quat.length(this);\n }\n\n lengthSquared() {\n return quat.squaredLength(this);\n }\n\n dot(a, b) {\n if (b !== undefined) {\n throw new Error('Quaternion.dot only takes one argument');\n }\n\n return quat.dot(this, a);\n }\n\n rotationTo(vectorA, vectorB) {\n quat.rotationTo(this, vectorA, vectorB);\n return this.check();\n }\n\n add(a, b) {\n if (b !== undefined) {\n throw new Error('Quaternion.add only takes one argument');\n }\n\n quat.add(this, this, a);\n return this.check();\n }\n\n calculateW() {\n quat.calculateW(this, this);\n return this.check();\n }\n\n conjugate() {\n quat.conjugate(this, this);\n return this.check();\n }\n\n invert() {\n quat.invert(this, this);\n return this.check();\n }\n\n lerp(a, b, t) {\n quat.lerp(this, a, b, t);\n return this.check();\n }\n\n multiplyRight(a, b) {\n assert(!b);\n quat.multiply(this, this, a);\n return this.check();\n }\n\n multiplyLeft(a, b) {\n assert(!b);\n quat.multiply(this, a, this);\n return this.check();\n }\n\n normalize() {\n const length = this.len();\n const l = length > 0 ? 1 / length : 0;\n this[0] = this[0] * l;\n this[1] = this[1] * l;\n this[2] = this[2] * l;\n this[3] = this[3] * l;\n\n if (length === 0) {\n this[3] = 1;\n }\n\n return this.check();\n }\n\n rotateX(rad) {\n quat.rotateX(this, this, rad);\n return this.check();\n }\n\n rotateY(rad) {\n quat.rotateY(this, this, rad);\n return this.check();\n }\n\n rotateZ(rad) {\n quat.rotateZ(this, this, rad);\n return this.check();\n }\n\n scale(b) {\n quat.scale(this, this, b);\n return this.check();\n }\n\n slerp(start, target, ratio) {\n switch (arguments.length) {\n case 1:\n ({\n start = IDENTITY_QUATERNION,\n target,\n ratio\n } = arguments[0]);\n break;\n\n case 2:\n [target, ratio] = arguments;\n start = this;\n break;\n\n default:\n }\n\n quat.slerp(this, start, target, ratio);\n return this.check();\n }\n\n transformVector4(vector, result = vector) {\n vec4.transformQuat(result, vector, this);\n return checkVector(result, 4);\n }\n\n lengthSq() {\n return this.lengthSquared();\n }\n\n setFromAxisAngle(axis, rad) {\n return this.setAxisAngle(axis, rad);\n }\n\n premultiply(a, b) {\n return this.multiplyLeft(a, b);\n }\n\n multiply(a, b) {\n return this.multiplyRight(a, b);\n }\n\n}\n//# sourceMappingURL=quaternion.js.map","import { Vector3, Matrix3, Quaternion } from '@math.gl/core';\nimport BoundingSphere from './bounding-sphere';\nimport { INTERSECTION } from '../../constants';\nconst scratchVector3 = new Vector3();\nconst scratchOffset = new Vector3();\nconst scratchVectorU = new Vector3();\nconst scratchVectorV = new Vector3();\nconst scratchVectorW = new Vector3();\nconst scratchCorner = new Vector3();\nconst scratchToCenter = new Vector3();\nconst MATRIX3 = {\n COLUMN0ROW0: 0,\n COLUMN0ROW1: 1,\n COLUMN0ROW2: 2,\n COLUMN1ROW0: 3,\n COLUMN1ROW1: 4,\n COLUMN1ROW2: 5,\n COLUMN2ROW0: 6,\n COLUMN2ROW1: 7,\n COLUMN2ROW2: 8\n};\nexport default class OrientedBoundingBox {\n constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {\n this.center = new Vector3().from(center);\n this.halfAxes = new Matrix3(halfAxes);\n }\n\n get halfSize() {\n const xAxis = this.halfAxes.getColumn(0);\n const yAxis = this.halfAxes.getColumn(1);\n const zAxis = this.halfAxes.getColumn(2);\n return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()];\n }\n\n get quaternion() {\n const xAxis = this.halfAxes.getColumn(0);\n const yAxis = this.halfAxes.getColumn(1);\n const zAxis = this.halfAxes.getColumn(2);\n const normXAxis = new Vector3(xAxis).normalize();\n const normYAxis = new Vector3(yAxis).normalize();\n const normZAxis = new Vector3(zAxis).normalize();\n return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));\n }\n\n fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {\n const quaternionObject = new Quaternion(quaternion);\n const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);\n directionsMatrix[0] = directionsMatrix[0] * halfSize[0];\n directionsMatrix[1] = directionsMatrix[1] * halfSize[0];\n directionsMatrix[2] = directionsMatrix[2] * halfSize[0];\n directionsMatrix[3] = directionsMatrix[3] * halfSize[1];\n directionsMatrix[4] = directionsMatrix[4] * halfSize[1];\n directionsMatrix[5] = directionsMatrix[5] * halfSize[1];\n directionsMatrix[6] = directionsMatrix[6] * halfSize[2];\n directionsMatrix[7] = directionsMatrix[7] * halfSize[2];\n directionsMatrix[8] = directionsMatrix[8] * halfSize[2];\n this.center = new Vector3().from(center);\n this.halfAxes = directionsMatrix;\n return this;\n }\n\n clone() {\n return new OrientedBoundingBox(this.center, this.halfAxes);\n }\n\n equals(right) {\n return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes);\n }\n\n getBoundingSphere(result = new BoundingSphere()) {\n const halfAxes = this.halfAxes;\n const u = halfAxes.getColumn(0, scratchVectorU);\n const v = halfAxes.getColumn(1, scratchVectorV);\n const w = halfAxes.getColumn(2, scratchVectorW);\n const cornerVector = scratchVector3.copy(u).add(v).add(w);\n result.center.copy(this.center);\n result.radius = cornerVector.magnitude();\n return result;\n }\n\n intersectPlane(plane) {\n const center = this.center;\n const normal = plane.normal;\n const halfAxes = this.halfAxes;\n const normalX = normal.x;\n const normalY = normal.y;\n const normalZ = normal.z;\n const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] + normalY * halfAxes[MATRIX3.COLUMN0ROW1] + normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] + normalY * halfAxes[MATRIX3.COLUMN1ROW1] + normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] + normalY * halfAxes[MATRIX3.COLUMN2ROW1] + normalZ * halfAxes[MATRIX3.COLUMN2ROW2]);\n const distanceToPlane = normal.dot(center) + plane.distance;\n\n if (distanceToPlane <= -radEffective) {\n return INTERSECTION.OUTSIDE;\n } else if (distanceToPlane >= radEffective) {\n return INTERSECTION.INSIDE;\n }\n\n return INTERSECTION.INTERSECTING;\n }\n\n distanceTo(point) {\n return Math.sqrt(this.distanceSquaredTo(point));\n }\n\n distanceSquaredTo(point) {\n const offset = scratchOffset.from(point).subtract(this.center);\n const halfAxes = this.halfAxes;\n const u = halfAxes.getColumn(0, scratchVectorU);\n const v = halfAxes.getColumn(1, scratchVectorV);\n const w = halfAxes.getColumn(2, scratchVectorW);\n const uHalf = u.magnitude();\n const vHalf = v.magnitude();\n const wHalf = w.magnitude();\n u.normalize();\n v.normalize();\n w.normalize();\n let distanceSquared = 0.0;\n let d;\n d = Math.abs(offset.dot(u)) - uHalf;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.dot(v)) - vHalf;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n d = Math.abs(offset.dot(w)) - wHalf;\n\n if (d > 0) {\n distanceSquared += d * d;\n }\n\n return distanceSquared;\n }\n\n computePlaneDistances(position, direction, result = [-0, -0]) {\n let minDist = Number.POSITIVE_INFINITY;\n let maxDist = Number.NEGATIVE_INFINITY;\n const center = this.center;\n const halfAxes = this.halfAxes;\n const u = halfAxes.getColumn(0, scratchVectorU);\n const v = halfAxes.getColumn(1, scratchVectorV);\n const w = halfAxes.getColumn(2, scratchVectorW);\n const corner = scratchCorner.copy(u).add(v).add(w).add(center);\n const toCenter = scratchToCenter.copy(corner).subtract(position);\n let mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n corner.copy(center).add(u).add(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n corner.copy(center).add(u).subtract(v).add(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n corner.copy(center).add(u).subtract(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).add(v).add(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).add(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).subtract(v).add(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n center.copy(corner).subtract(u).subtract(v).subtract(w);\n toCenter.copy(corner).subtract(position);\n mag = direction.dot(toCenter);\n minDist = Math.min(mag, minDist);\n maxDist = Math.max(mag, maxDist);\n result[0] = minDist;\n result[1] = maxDist;\n return result;\n }\n\n transform(transformation) {\n this.center.transformAsPoint(transformation);\n const xAxis = this.halfAxes.getColumn(0, scratchVectorU);\n xAxis.transformAsPoint(transformation);\n const yAxis = this.halfAxes.getColumn(1, scratchVectorV);\n yAxis.transformAsPoint(transformation);\n const zAxis = this.halfAxes.getColumn(2, scratchVectorW);\n zAxis.transformAsPoint(transformation);\n this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]);\n return this;\n }\n\n getTransform() {\n throw new Error('not implemented');\n }\n\n}\n//# sourceMappingURL=oriented-bounding-box.js.map","import { Vector3, equals, assert } from '@math.gl/core';\nconst scratchPosition = new Vector3();\nconst scratchNormal = new Vector3();\nexport default class Plane {\n constructor(normal = [0, 0, 1], distance = 0) {\n this.normal = new Vector3();\n this.distance = -0;\n this.fromNormalDistance(normal, distance);\n }\n\n fromNormalDistance(normal, distance) {\n assert(Number.isFinite(distance));\n this.normal.from(normal).normalize();\n this.distance = distance;\n return this;\n }\n\n fromPointNormal(point, normal) {\n point = scratchPosition.from(point);\n this.normal.from(normal).normalize();\n const distance = -this.normal.dot(point);\n this.distance = distance;\n return this;\n }\n\n fromCoefficients(a, b, c, d) {\n this.normal.set(a, b, c);\n assert(equals(this.normal.len(), 1));\n this.distance = d;\n return this;\n }\n\n clone(plane) {\n return new Plane(this.normal, this.distance);\n }\n\n equals(right) {\n return equals(this.distance, right.distance) && equals(this.normal, right.normal);\n }\n\n getPointDistance(point) {\n return this.normal.dot(point) + this.distance;\n }\n\n transform(matrix4) {\n const normal = scratchNormal.copy(this.normal).transformAsVector(matrix4).normalize();\n const point = this.normal.scale(-this.distance).transform(matrix4);\n return this.fromPointNormal(point, normal);\n }\n\n projectPointOntoPlane(point, result = [0, 0, 0]) {\n point = scratchPosition.from(point);\n const pointDistance = this.getPointDistance(point);\n const scaledNormal = scratchNormal.copy(this.normal).scale(pointDistance);\n return point.subtract(scaledNormal).to(result);\n }\n\n}\n//# sourceMappingURL=plane.js.map","import { Vector3, Vector4, assert } from '@math.gl/core';\nimport { INTERSECTION } from '../constants';\nimport Plane from './plane';\nconst faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];\nconst scratchPlaneCenter = new Vector3();\nconst scratchPlaneNormal = new Vector3();\nconst scratchPlane = new Plane(new Vector3(1.0, 0.0, 0.0), 0.0);\nexport default class CullingVolume {\n static get MASK_OUTSIDE() {\n return 0xffffffff;\n }\n\n static get MASK_INSIDE() {\n return 0x00000000;\n }\n\n static get MASK_INDETERMINATE() {\n return 0x7fffffff;\n }\n\n constructor(planes = []) {\n this.planes = planes;\n assert(this.planes.every(plane => plane instanceof Plane));\n }\n\n fromBoundingSphere(boundingSphere) {\n this.planes.length = 2 * faces.length;\n const center = boundingSphere.center;\n const radius = boundingSphere.radius;\n let planeIndex = 0;\n\n for (const faceNormal of faces) {\n let plane0 = this.planes[planeIndex];\n let plane1 = this.planes[planeIndex + 1];\n\n if (!plane0) {\n plane0 = this.planes[planeIndex] = new Plane();\n }\n\n if (!plane1) {\n plane1 = this.planes[planeIndex + 1] = new Plane();\n }\n\n const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);\n const plane0Distance = -faceNormal.dot(plane0Center);\n plane0.fromPointNormal(plane0Center, faceNormal);\n const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center);\n const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();\n const plane1Distance = -negatedFaceNormal.dot(plane1Center);\n plane1.fromPointNormal(plane1Center, negatedFaceNormal);\n planeIndex += 2;\n }\n\n return this;\n }\n\n computeVisibility(boundingVolume) {\n assert(boundingVolume);\n let intersect = INTERSECTION.INSIDE;\n\n for (const plane of this.planes) {\n const result = boundingVolume.intersectPlane(plane);\n\n switch (result) {\n case INTERSECTION.OUTSIDE:\n return INTERSECTION.OUTSIDE;\n\n case INTERSECTION.INTERSECTING:\n intersect = INTERSECTION.INTERSECTING;\n break;\n\n default:\n }\n }\n\n return intersect;\n }\n\n computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {\n assert(boundingVolume, 'boundingVolume is required.');\n assert(Number.isFinite(parentPlaneMask), 'parentPlaneMask is required.');\n\n if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {\n return parentPlaneMask;\n }\n\n let mask = CullingVolume.MASK_INSIDE;\n const planes = this.planes;\n\n for (let k = 0; k < this.planes.length; ++k) {\n const flag = k < 31 ? 1 << k : 0;\n\n if (k < 31 && (parentPlaneMask & flag) === 0) {\n continue;\n }\n\n const plane = planes[k];\n const result = boundingVolume.intersectPlane(plane);\n\n if (result === INTERSECTION.OUTSIDE) {\n return CullingVolume.MASK_OUTSIDE;\n } else if (result === INTERSECTION.INTERSECTING) {\n mask |= flag;\n }\n }\n\n return mask;\n }\n\n}\n//# sourceMappingURL=culling-volume.js.map","import { Vector3, Matrix4, assert } from '@math.gl/core';\nimport CullingVolume from './culling-volume';\nimport Plane from './plane';\nconst scratchPlaneUpVector = new Vector3();\nconst scratchPlaneRightVector = new Vector3();\nconst scratchPlaneNearCenter = new Vector3();\nconst scratchPlaneFarCenter = new Vector3();\nconst scratchPlaneNormal = new Vector3();\nexport default class PerspectiveOffCenterFrustum {\n constructor(options = {}) {\n options = {\n near: 1.0,\n far: 500000000.0,\n ...options\n };\n this.left = options.left;\n this._left = undefined;\n this.right = options.right;\n this._right = undefined;\n this.top = options.top;\n this._top = undefined;\n this.bottom = options.bottom;\n this._bottom = undefined;\n this.near = options.near;\n this._near = this.near;\n this.far = options.far;\n this._far = this.far;\n this._cullingVolume = new CullingVolume([new Plane(), new Plane(), new Plane(), new Plane(), new Plane(), new Plane()]);\n this._perspectiveMatrix = new Matrix4();\n this._infinitePerspective = new Matrix4();\n }\n\n clone() {\n return new PerspectiveOffCenterFrustum({\n right: this.right,\n left: this.left,\n top: this.top,\n bottom: this.bottom,\n near: this.near,\n far: this.far\n });\n }\n\n equals(other) {\n return other && other instanceof PerspectiveOffCenterFrustum && this.right === other.right && this.left === other.left && this.top === other.top && this.bottom === other.bottom && this.near === other.near && this.far === other.far;\n }\n\n get projectionMatrix() {\n update(this);\n return this._perspectiveMatrix;\n }\n\n get infiniteProjectionMatrix() {\n update(this);\n return this._infinitePerspective;\n }\n\n computeCullingVolume(position, direction, up) {\n assert(position, 'position is required.');\n assert(direction, 'direction is required.');\n assert(up, 'up is required.');\n const planes = this._cullingVolume.planes;\n up = scratchPlaneUpVector.copy(up).normalize();\n const right = scratchPlaneRightVector.copy(direction).cross(up).normalize();\n const nearCenter = scratchPlaneNearCenter.copy(direction).multiplyByScalar(this.near).add(position);\n const farCenter = scratchPlaneFarCenter.copy(direction).multiplyByScalar(this.far).add(position);\n let normal = scratchPlaneNormal;\n normal.copy(right).multiplyByScalar(this.left).add(nearCenter).subtract(position).cross(up);\n planes[0].fromPointNormal(position, normal);\n normal.copy(right).multiplyByScalar(this.right).add(nearCenter).subtract(position).cross(up).negate();\n planes[1].fromPointNormal(position, normal);\n normal.copy(up).multiplyByScalar(this.bottom).add(nearCenter).subtract(position).cross(right).negate();\n planes[2].fromPointNormal(position, normal);\n normal.copy(up).multiplyByScalar(this.top).add(nearCenter).subtract(position).cross(right);\n planes[3].fromPointNormal(position, normal);\n normal = new Vector3().copy(direction);\n planes[4].fromPointNormal(nearCenter, normal);\n normal.negate();\n planes[5].fromPointNormal(farCenter, normal);\n return this._cullingVolume;\n }\n\n getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, result) {\n update(this);\n assert(Number.isFinite(drawingBufferWidth) && Number.isFinite(drawingBufferHeight));\n assert(drawingBufferWidth > 0);\n assert(drawingBufferHeight > 0);\n assert(distance > 0);\n assert(result);\n const inverseNear = 1.0 / this.near;\n let tanTheta = this.top * inverseNear;\n const pixelHeight = 2.0 * distance * tanTheta / drawingBufferHeight;\n tanTheta = this.right * inverseNear;\n const pixelWidth = 2.0 * distance * tanTheta / drawingBufferWidth;\n result.x = pixelWidth;\n result.y = pixelHeight;\n return result;\n }\n\n}\n\nfunction update(frustum) {\n assert(Number.isFinite(frustum.right) && Number.isFinite(frustum.left) && Number.isFinite(frustum.top) && Number.isFinite(frustum.bottom) && Number.isFinite(frustum.near) && Number.isFinite(frustum.far));\n const {\n top,\n bottom,\n right,\n left,\n near,\n far\n } = frustum;\n\n if (top !== frustum._top || bottom !== frustum._bottom || left !== frustum._left || right !== frustum._right || near !== frustum._near || far !== frustum._far) {\n assert(frustum.near > 0 && frustum.near < frustum.far, 'near must be greater than zero and less than far.');\n frustum._left = left;\n frustum._right = right;\n frustum._top = top;\n frustum._bottom = bottom;\n frustum._near = near;\n frustum._far = far;\n frustum._perspectiveMatrix = new Matrix4().frustum({\n left,\n right,\n bottom,\n top,\n near,\n far\n });\n frustum._infinitePerspective = new Matrix4().frustum({\n left,\n right,\n bottom,\n top,\n near,\n far: Infinity\n });\n }\n}\n//# sourceMappingURL=perspective-off-center-frustum.js.map","import { Vector3 } from '@math.gl/core';\nimport BoundingSphere from '../bounding-volumes/bounding-sphere';\nconst fromPointsXMin = new Vector3();\nconst fromPointsYMin = new Vector3();\nconst fromPointsZMin = new Vector3();\nconst fromPointsXMax = new Vector3();\nconst fromPointsYMax = new Vector3();\nconst fromPointsZMax = new Vector3();\nconst fromPointsCurrentPos = new Vector3();\nconst fromPointsScratch = new Vector3();\nconst fromPointsRitterCenter = new Vector3();\nconst fromPointsMinBoxPt = new Vector3();\nconst fromPointsMaxBoxPt = new Vector3();\nconst fromPointsNaiveCenterScratch = new Vector3();\nconst volumeConstant = 4.0 / 3.0 * Math.PI;\nexport default function makeBoundingSphereFromPoints(positions, result = new BoundingSphere()) {\n if (!positions || positions.length === 0) {\n return result.fromCenterRadius([0, 0, 0], 0);\n }\n\n const currentPos = fromPointsCurrentPos.copy(positions[0]);\n const xMin = fromPointsXMin.copy(currentPos);\n const yMin = fromPointsYMin.copy(currentPos);\n const zMin = fromPointsZMin.copy(currentPos);\n const xMax = fromPointsXMax.copy(currentPos);\n const yMax = fromPointsYMax.copy(currentPos);\n const zMax = fromPointsZMax.copy(currentPos);\n\n for (const position of positions) {\n currentPos.copy(position);\n const x = currentPos.x;\n const y = currentPos.y;\n const z = currentPos.z;\n\n if (x < xMin.x) {\n currentPos.copy(xMin);\n }\n\n if (x > xMax.x) {\n currentPos.copy(xMax);\n }\n\n if (y < yMin.y) {\n currentPos.copy(yMin);\n }\n\n if (y > yMax.y) {\n currentPos.copy(yMax);\n }\n\n if (z < zMin.z) {\n currentPos.copy(zMin);\n }\n\n if (z > zMax.z) {\n currentPos.copy(zMax);\n }\n }\n\n const xSpan = fromPointsScratch.copy(xMax).subtract(xMin).magnitudeSquared();\n const ySpan = fromPointsScratch.copy(yMax).subtract(yMin).magnitudeSquared();\n const zSpan = fromPointsScratch.copy(zMax).subtract(zMin).magnitudeSquared();\n let diameter1 = xMin;\n let diameter2 = xMax;\n let maxSpan = xSpan;\n\n if (ySpan > maxSpan) {\n maxSpan = ySpan;\n diameter1 = yMin;\n diameter2 = yMax;\n }\n\n if (zSpan > maxSpan) {\n maxSpan = zSpan;\n diameter1 = zMin;\n diameter2 = zMax;\n }\n\n const ritterCenter = fromPointsRitterCenter;\n ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;\n ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;\n ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;\n let radiusSquared = fromPointsScratch.copy(diameter2).subtract(ritterCenter).magnitudeSquared();\n let ritterRadius = Math.sqrt(radiusSquared);\n const minBoxPt = fromPointsMinBoxPt;\n minBoxPt.x = xMin.x;\n minBoxPt.y = yMin.y;\n minBoxPt.z = zMin.z;\n const maxBoxPt = fromPointsMaxBoxPt;\n maxBoxPt.x = xMax.x;\n maxBoxPt.y = yMax.y;\n maxBoxPt.z = zMax.z;\n const naiveCenter = fromPointsNaiveCenterScratch.copy(minBoxPt).add(maxBoxPt).multiplyByScalar(0.5);\n let naiveRadius = 0;\n\n for (const position of positions) {\n currentPos.copy(position);\n const r = fromPointsScratch.copy(currentPos).subtract(naiveCenter).magnitude();\n\n if (r > naiveRadius) {\n naiveRadius = r;\n }\n\n const oldCenterToPointSquared = fromPointsScratch.copy(currentPos).subtract(ritterCenter).magnitudeSquared();\n\n if (oldCenterToPointSquared > radiusSquared) {\n const oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);\n ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;\n radiusSquared = ritterRadius * ritterRadius;\n const oldToNew = oldCenterToPoint - ritterRadius;\n ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;\n ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;\n ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;\n }\n }\n\n if (ritterRadius < naiveRadius) {\n ritterCenter.to(result.center);\n result.radius = ritterRadius;\n } else {\n naiveCenter.to(result.center);\n result.radius = naiveRadius;\n }\n\n return result;\n}\n//# sourceMappingURL=bounding-sphere-from-points.js.map","import { Matrix3, _MathUtils } from '@math.gl/core';\nconst scratchMatrix = new Matrix3();\nconst scratchUnitary = new Matrix3();\nconst scratchDiagonal = new Matrix3();\nconst jMatrix = new Matrix3();\nconst jMatrixTranspose = new Matrix3();\nexport default function computeEigenDecomposition(matrix, result = {}) {\n const EIGEN_TOLERANCE = _MathUtils.EPSILON20;\n const EIGEN_MAX_SWEEPS = 10;\n let count = 0;\n let sweep = 0;\n const unitaryMatrix = scratchUnitary;\n const diagonalMatrix = scratchDiagonal;\n unitaryMatrix.identity();\n diagonalMatrix.copy(matrix);\n const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix);\n\n while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) {\n shurDecomposition(diagonalMatrix, jMatrix);\n jMatrixTranspose.copy(jMatrix).transpose();\n diagonalMatrix.multiplyRight(jMatrix);\n diagonalMatrix.multiplyLeft(jMatrixTranspose);\n unitaryMatrix.multiplyRight(jMatrix);\n\n if (++count > 2) {\n ++sweep;\n count = 0;\n }\n }\n\n result.unitary = unitaryMatrix.toTarget(result.unitary);\n result.diagonal = diagonalMatrix.toTarget(result.diagonal);\n return result;\n}\n\nfunction computeFrobeniusNorm(matrix) {\n let norm = 0.0;\n\n for (let i = 0; i < 9; ++i) {\n const temp = matrix[i];\n norm += temp * temp;\n }\n\n return Math.sqrt(norm);\n}\n\nconst rowVal = [1, 0, 0];\nconst colVal = [2, 2, 1];\n\nfunction offDiagonalFrobeniusNorm(matrix) {\n let norm = 0.0;\n\n for (let i = 0; i < 3; ++i) {\n const temp = matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])];\n norm += 2.0 * temp * temp;\n }\n\n return Math.sqrt(norm);\n}\n\nfunction shurDecomposition(matrix, result) {\n const tolerance = _MathUtils.EPSILON15;\n let maxDiagonal = 0.0;\n let rotAxis = 1;\n\n for (let i = 0; i < 3; ++i) {\n const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i], rowVal[i])]);\n\n if (temp > maxDiagonal) {\n rotAxis = i;\n maxDiagonal = temp;\n }\n }\n\n const p = rowVal[rotAxis];\n const q = colVal[rotAxis];\n let c = 1.0;\n let s = 0.0;\n\n if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p)]) > tolerance) {\n const qq = matrix[scratchMatrix.getElementIndex(q, q)];\n const pp = matrix[scratchMatrix.getElementIndex(p, p)];\n const qp = matrix[scratchMatrix.getElementIndex(q, p)];\n const tau = (qq - pp) / 2.0 / qp;\n let t;\n\n if (tau < 0.0) {\n t = -1.0 / (-tau + Math.sqrt(1.0 + tau * tau));\n } else {\n t = 1.0 / (tau + Math.sqrt(1.0 + tau * tau));\n }\n\n c = 1.0 / Math.sqrt(1.0 + t * t);\n s = t * c;\n }\n\n Matrix3.IDENTITY.to(result);\n result[scratchMatrix.getElementIndex(p, p)] = result[scratchMatrix.getElementIndex(q, q)] = c;\n result[scratchMatrix.getElementIndex(q, p)] = s;\n result[scratchMatrix.getElementIndex(p, q)] = -s;\n return result;\n}\n//# sourceMappingURL=compute-eigen-decomposition.js.map","import { Vector3, Matrix3 } from '@math.gl/core';\nimport computeEigenDecomposition from './compute-eigen-decomposition';\nimport OrientedBoundingBox from '../bounding-volumes/oriented-bounding-box';\nimport AxisAlignedBoundingBox from '../bounding-volumes/axis-aligned-bounding-box';\nconst scratchVector2 = new Vector3();\nconst scratchVector3 = new Vector3();\nconst scratchVector4 = new Vector3();\nconst scratchVector5 = new Vector3();\nconst scratchVector6 = new Vector3();\nconst scratchCovarianceResult = new Matrix3();\nconst scratchEigenResult = {\n diagonal: new Matrix3(),\n unitary: new Matrix3()\n};\nexport function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) {\n if (!positions || positions.length === 0) {\n result.halfAxes = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);\n result.center = new Vector3();\n return result;\n }\n\n const length = positions.length;\n const meanPoint = new Vector3(0, 0, 0);\n\n for (const position of positions) {\n meanPoint.add(position);\n }\n\n const invLength = 1.0 / length;\n meanPoint.multiplyByScalar(invLength);\n let exx = 0.0;\n let exy = 0.0;\n let exz = 0.0;\n let eyy = 0.0;\n let eyz = 0.0;\n let ezz = 0.0;\n\n for (const position of positions) {\n const p = scratchVector2.copy(position).subtract(meanPoint);\n exx += p.x * p.x;\n exy += p.x * p.y;\n exz += p.x * p.z;\n eyy += p.y * p.y;\n eyz += p.y * p.z;\n ezz += p.z * p.z;\n }\n\n exx *= invLength;\n exy *= invLength;\n exz *= invLength;\n eyy *= invLength;\n eyz *= invLength;\n ezz *= invLength;\n const covarianceMatrix = scratchCovarianceResult;\n covarianceMatrix[0] = exx;\n covarianceMatrix[1] = exy;\n covarianceMatrix[2] = exz;\n covarianceMatrix[3] = exy;\n covarianceMatrix[4] = eyy;\n covarianceMatrix[5] = eyz;\n covarianceMatrix[6] = exz;\n covarianceMatrix[7] = eyz;\n covarianceMatrix[8] = ezz;\n const {\n unitary\n } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult);\n const rotation = result.halfAxes.copy(unitary);\n let v1 = rotation.getColumn(0, scratchVector4);\n let v2 = rotation.getColumn(1, scratchVector5);\n let v3 = rotation.getColumn(2, scratchVector6);\n let u1 = -Number.MAX_VALUE;\n let u2 = -Number.MAX_VALUE;\n let u3 = -Number.MAX_VALUE;\n let l1 = Number.MAX_VALUE;\n let l2 = Number.MAX_VALUE;\n let l3 = Number.MAX_VALUE;\n\n for (const position of positions) {\n u1 = Math.max(position.dot(v1), u1);\n u2 = Math.max(position.dot(v2), u2);\n u3 = Math.max(position.dot(v3), u3);\n l1 = Math.min(position.dot(v1), l1);\n l2 = Math.min(position.dot(v2), l2);\n l3 = Math.min(position.dot(v3), l3);\n }\n\n v1 = v1.multiplyByScalar(0.5 * (l1 + u1));\n v2 = v2.multiplyByScalar(0.5 * (l2 + u2));\n v3 = v3.multiplyByScalar(0.5 * (l3 + u3));\n result.center.copy(v1).add(v2).add(v3);\n const scale = scratchVector3.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5);\n const scaleMatrix = new Matrix3([scale[0], 0, 0, 0, scale[1], 0, 0, 0, scale[2]]);\n result.halfAxes.multiplyRight(scaleMatrix);\n return result;\n}\nexport function makeAxisAlignedBoundingBoxFromPoints(positions, result = new AxisAlignedBoundingBox()) {\n if (!positions || positions.length === 0) {\n result.minimum.set(0, 0, 0);\n result.maximum.set(0, 0, 0);\n result.center.set(0, 0, 0);\n result.halfDiagonal.set(0, 0, 0);\n return result;\n }\n\n let minimumX = positions[0][0];\n let minimumY = positions[0][1];\n let minimumZ = positions[0][2];\n let maximumX = positions[0][0];\n let maximumY = positions[0][1];\n let maximumZ = positions[0][2];\n\n for (const p of positions) {\n const x = p[0];\n const y = p[1];\n const z = p[2];\n minimumX = Math.min(x, minimumX);\n maximumX = Math.max(x, maximumX);\n minimumY = Math.min(y, minimumY);\n maximumY = Math.max(y, maximumY);\n minimumZ = Math.min(z, minimumZ);\n maximumZ = Math.max(z, maximumZ);\n }\n\n result.minimum.set(minimumX, minimumY, minimumZ);\n result.maximum.set(maximumX, maximumY, maximumZ);\n result.center.copy(result.minimum).add(result.maximum).scale(0.5);\n result.halfDiagonal.copy(result.maximum).subtract(result.center);\n return result;\n}\n//# sourceMappingURL=bounding-box-from-points.js.map","import {Vector3} from '@math.gl/core';\nimport {CullingVolume, Plane} from '@math.gl/culling';\nimport {Ellipsoid} from '@math.gl/geospatial';\n\nexport type FrameState = {\n camera: {\n position: number[];\n direction: number[];\n up: number[];\n };\n viewport: {[key: string]: any};\n height: number;\n cullingVolume: CullingVolume;\n frameNumber: number; // TODO: This can be the same between updates, what number is unique for between updates?\n sseDenominator: number; // Assumes fovy = 60 degrees\n};\n\nconst scratchVector = new Vector3();\nconst scratchPosition = new Vector3();\nconst cullingVolume = new CullingVolume([\n new Plane(),\n new Plane(),\n new Plane(),\n new Plane(),\n new Plane(),\n new Plane()\n]);\n\n// Extracts a frame state appropriate for tile culling from a deck.gl viewport\n// TODO - this could likely be generalized and merged back into deck.gl for other culling scenarios\nexport function getFrameState(viewport, frameNumber: number): FrameState {\n // Traverse and and request. Update _selectedTiles so that we know what to render.\n const {cameraDirection, cameraUp, height} = viewport;\n const {metersPerUnit} = viewport.distanceScales;\n\n const viewportCenterCartographic = [viewport.longitude, viewport.latitude, 0];\n // TODO - Ellipsoid.eastNorthUpToFixedFrame() breaks on raw array, create a Vector.\n // TODO - Ellipsoid.eastNorthUpToFixedFrame() takes a cartesian, is that intuitive?\n const viewportCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n viewportCenterCartographic,\n new Vector3()\n );\n const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);\n\n const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);\n const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n cameraPositionCartographic,\n new Vector3()\n );\n\n // These should still be normalized as the transform has scale 1 (goes from meters to meters)\n const cameraDirectionCartesian = new Vector3(\n // @ts-ignore\n enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))\n ).normalize();\n const cameraUpCartesian = new Vector3(\n // @ts-ignore\n enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))\n ).normalize();\n\n commonSpacePlanesToWGS84(viewport, viewportCenterCartesian);\n\n // TODO: make a file/class for frameState and document what needs to be attached to this so that traversal can function\n return {\n camera: {\n position: cameraPositionCartesian,\n direction: cameraDirectionCartesian,\n up: cameraUpCartesian\n },\n viewport,\n height,\n cullingVolume,\n frameNumber, // TODO: This can be the same between updates, what number is unique for between updates?\n sseDenominator: 1.15 // Assumes fovy = 60 degrees\n };\n}\n\nfunction commonSpacePlanesToWGS84(viewport, viewportCenterCartesian) {\n // Extract frustum planes based on current view.\n const frustumPlanes = viewport.getFrustumPlanes();\n let i = 0;\n for (const dir in frustumPlanes) {\n const plane = frustumPlanes[dir];\n const distanceToCenter = plane.normal.dot(viewport.center);\n scratchPosition\n .copy(plane.normal)\n .scale(plane.distance - distanceToCenter)\n .add(viewport.center);\n const cartographicPos = viewport.unprojectPosition(scratchPosition);\n\n const cartesianPos = Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new Vector3());\n\n cullingVolume.planes[i++].fromPointNormal(\n cartesianPos,\n // Want the normal to point into the frustum since that's what culling expects\n scratchVector.copy(viewportCenterCartesian).subtract(cartesianPos)\n );\n }\n}\n","import {Vector3} from '@math.gl/core';\n\nconst WGS84_RADIUS_X = 6378137.0;\nconst WGS84_RADIUS_Y = 6378137.0;\nconst WGS84_RADIUS_Z = 6356752.3142451793;\n\nconst scratchVector = new Vector3();\n\n/**\n * Calculate appropriate zoom value for a particular boundingVolume\n * @param {BoundingSphere, OrientedBoundingBox} boundingVolume - the instance of bounding volume\n * @returns {number} - zoom value\n */\nexport function getZoomFromBoundingVolume(boundingVolume) {\n const {halfAxes, radius, width, height} = boundingVolume;\n\n if (halfAxes) {\n // OrientedBoundingBox\n const obbSize = getObbSize(halfAxes);\n // Use WGS84_RADIUS_Z to allign with BoundingSphere algorithm\n return Math.log2(WGS84_RADIUS_Z / obbSize);\n } else if (radius) {\n // BoundingSphere\n return Math.log2(WGS84_RADIUS_Z / radius);\n } else if (height && width) {\n // BoundingRectangle\n const zoomX = Math.log2(WGS84_RADIUS_X / width);\n const zoomY = Math.log2(WGS84_RADIUS_Y / height);\n\n return (zoomX + zoomY) / 2;\n }\n\n return 1;\n}\n\nfunction getObbSize(halfAxes) {\n halfAxes.getColumn(0, scratchVector);\n const axeY = halfAxes.getColumn(1);\n const axeZ = halfAxes.getColumn(2);\n const farthestVertex = scratchVector.add(axeY).add(axeZ);\n const size = farthestVertex.len();\n return size;\n}\n","export const TILE_CONTENT_STATE = {\n UNLOADED: 0, // Has never been requested\n LOADING: 1, // Is waiting on a pending request\n PROCESSING: 2, // Request received. Contents are being processed for rendering. Depending on the content, it might make its own requests for external data.\n READY: 3, // Ready to render.\n EXPIRED: 4, // Is expired and will be unloaded once new content is loaded.\n FAILED: 5 // Request failed.\n};\n\nexport const TILE_REFINEMENT = {\n ADD: 1, // Render tile and, if screen space error exceeded, also refine to its children.\n REPLACE: 2 // Render tile or, if screen space error exceeded, refine to its descendants instead.\n};\n\nexport const TILE_TYPE = {\n EMPTY: 'empty',\n SCENEGRAPH: 'scenegraph',\n POINTCLOUD: 'pointcloud',\n MESH: 'mesh'\n};\n\nexport const TILESET_TYPE = {\n I3S: 'I3S',\n TILES3D: 'TILES3D'\n};\n\nexport const LOD_METRIC_TYPE = {\n GEOMETRIC_ERROR: 'geometricError',\n MAX_SCREEN_THRESHOLD: 'maxScreenThreshold'\n};\n\n// Cesium 3D Tiles Specific\nexport const TILE3D_OPTIMIZATION_HINT = {\n NOT_COMPUTED: -1,\n USE_OPTIMIZATION: 1,\n SKIP_OPTIMIZATION: 0\n};\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n/* eslint-disable */\nimport {Quaternion, Vector3, Matrix3, Matrix4, degrees} from '@math.gl/core';\nimport {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport {assert} from '@loaders.gl/loader-utils';\n\n// const scratchProjectedBoundingSphere = new BoundingSphere();\n\nfunction defined(x) {\n return x !== undefined && x !== null;\n}\n\n// const scratchMatrix = new Matrix3();\nconst scratchScale = new Vector3();\nconst scratchNorthWest = new Vector3();\nconst scratchSouthEast = new Vector3();\n// const scratchRectangle = new Rectangle();\n// const scratchOrientedBoundingBox = new OrientedBoundingBox();\n// const scratchTransform = new Matrix4();\n\n/**\n * Create a bounding volume from the tile's bounding volume header.\n * @param {Object} boundingVolumeHeader The tile's bounding volume header.\n * @param {Matrix4} transform The transform to apply to the bounding volume.\n * @param [result] The object onto which to store the result.\n * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.\n */\nexport function createBoundingVolume(boundingVolumeHeader, transform, result) {\n assert(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');\n\n // boundingVolume schema:\n // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json\n if (boundingVolumeHeader.box) {\n return createBox(boundingVolumeHeader.box, transform, result);\n }\n if (boundingVolumeHeader.region) {\n // [west, south, east, north, minimum height, maximum height]\n // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.\n // Heights are in meters above (or below) the WGS 84 ellipsoid.\n const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;\n\n const northWest = Ellipsoid.WGS84.cartographicToCartesian(\n [degrees(west), degrees(north), minHeight],\n scratchNorthWest\n );\n const southEast = Ellipsoid.WGS84.cartographicToCartesian(\n [degrees(east), degrees(south), maxHeight],\n scratchSouthEast\n );\n const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyScalar(0.5);\n const radius = new Vector3().subVectors(northWest, southEast).len() / 2.0;\n\n // TODO improve region boundingVolume\n // for now, create a sphere as the boundingVolume instead of box\n return createSphere(\n [centerInCartesian[0], centerInCartesian[1], centerInCartesian[2], radius],\n new Matrix4()\n );\n }\n\n if (boundingVolumeHeader.sphere) {\n return createSphere(boundingVolumeHeader.sphere, transform, result);\n }\n\n throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');\n}\n\nfunction createBox(box, transform, result) {\n // https://math.gl/modules/culling/docs/api-reference/oriented-bounding-box\n // 1. A half-axes based representation.\n // box: An array of 12 numbers that define an oriented bounding box.\n // The first three elements define the x, y, and z values for the center of the box.\n // The next three elements (with indices 3, 4, and 5) define the x axis direction and half-length.\n // The next three elements (indices 6, 7, and 8) define the y axis direction and half-length.\n // The last three elements (indices 9, 10, and 11) define the z axis direction and half-length.\n // 2. A half-size-quaternion based representation.\n // box: An array of 10 numbers that define an oriented bounding box.\n // The first three elements define the x, y, and z values for the center of the box in a right-handed 3-axis (x, y, z) Cartesian coordinate system where the z-axis is up.\n // The next three elements (with indices 3, 4, and 5) define the halfSize.\n // The last four elements (indices 6, 7, 8 and 10) define the quaternion.\n const center = new Vector3(box[0], box[1], box[2]);\n transform.transform(center, center);\n let origin: number[] = [];\n if (box.length === 10) {\n const halfSize = box.slice(3, 6);\n const quaternion = new Quaternion();\n quaternion.fromArray(box, 6);\n const x = new Vector3([1, 0, 0]);\n const y = new Vector3([0, 1, 0]);\n const z = new Vector3([0, 0, 1]);\n x.transformByQuaternion(quaternion);\n x.scale(halfSize[0]);\n y.transformByQuaternion(quaternion);\n y.scale(halfSize[1]);\n z.transformByQuaternion(quaternion);\n z.scale(halfSize[2]);\n origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];\n } else {\n origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];\n }\n const xAxis = transform.transformAsVector(origin.slice(0, 3));\n const yAxis = transform.transformAsVector(origin.slice(3, 6));\n const zAxis = transform.transformAsVector(origin.slice(6, 9));\n const halfAxes = new Matrix3([\n xAxis[0],\n xAxis[1],\n xAxis[2],\n yAxis[0],\n yAxis[1],\n yAxis[2],\n zAxis[0],\n zAxis[1],\n zAxis[2]\n ]);\n\n if (defined(result)) {\n result.center = center;\n result.halfAxes = halfAxes;\n return result;\n }\n\n return new OrientedBoundingBox(center, halfAxes);\n}\n\n/*\nfunction createBoxFromTransformedRegion(region, transform, initialTransform, result) {\n const rectangle = Rectangle.unpack(region, 0, scratchRectangle);\n const minimumHeight = region[4];\n const maximumHeight = region[5];\n\n const orientedBoundingBox = OrientedBoundingBox.fromRectangle(\n rectangle,\n minimumHeight,\n maximumHeight,\n Ellipsoid.WGS84,\n scratchOrientedBoundingBox\n );\n const center = orientedBoundingBox.center;\n const halfAxes = orientedBoundingBox.halfAxes;\n\n // A region bounding volume is not transformed by the transform in the tileset JSON,\n // but may be transformed by additional transforms applied in Cesium.\n // This is why the transform is calculated as the difference between the initial transform and the current transform.\n transform = Matrix4.multiplyTransformation(\n transform,\n Matrix4.inverseTransformation(initialTransform, scratchTransform),\n scratchTransform\n );\n center = Matrix4.multiplyByPoint(transform, center, center);\n const rotationScale = Matrix4.getRotation(transform, scratchMatrix);\n halfAxes = Matrix3.multiply(rotationScale, halfAxes, halfAxes);\n\n if (defined(result) && result instanceof TileOrientedBoundingBox) {\n result.update(center, halfAxes);\n return result;\n }\n\n return new TileOrientedBoundingBox(center, halfAxes);\n}\n\nfunction createRegion(region, transform, initialTransform, result) {\n if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {\n return createBoxFromTransformedRegion(region, transform, initialTransform, result);\n }\n\n if (defined(result)) {\n return result;\n }\n\n const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);\n\n return new TileBoundingRegion({\n rectangle: rectangleRegion,\n minimumHeight: region[4],\n maximumHeight: region[5]\n });\n}\n*/\n\nfunction createSphere(sphere, transform, result?) {\n // Find the transformed center\n const center = new Vector3(sphere[0], sphere[1], sphere[2]);\n transform.transform(center, center);\n const scale = transform.getScale(scratchScale);\n\n const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);\n const radius = sphere[3] * uniformScale;\n\n if (defined(result)) {\n result.center = center;\n result.radius = radius;\n return result;\n }\n\n return new BoundingSphere(center, radius);\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n// TODO - Dynamic screen space error provides an optimization when looking at\n// tilesets from above\n\n/* eslint-disable */\n// @ts-nocheck\nimport {Matrix4, Vector3, clamp} from '@math.gl/core';\n\nconst scratchPositionNormal = new Vector3();\nconst scratchCartographic = new Vector3();\nconst scratchMatrix = new Matrix4();\nconst scratchCenter = new Vector3();\nconst scratchPosition = new Vector3();\nconst scratchDirection = new Vector3();\n\n// eslint-disable-next-line max-statements, complexity\nexport function calculateDynamicScreenSpaceError(root, {camera, mapProjection}, options = {}) {\n const {dynamicScreenSpaceErrorHeightFalloff = 0.25, dynamicScreenSpaceErrorDensity = 0.00278} =\n options;\n\n let up;\n let direction;\n let height;\n let minimumHeight;\n let maximumHeight;\n\n const tileBoundingVolume = root.contentBoundingVolume;\n\n if (tileBoundingVolume instanceof TileBoundingRegion) {\n up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);\n direction = camera.directionWC;\n height = camera.positionCartographic.height;\n minimumHeight = tileBoundingVolume.minimumHeight;\n maximumHeight = tileBoundingVolume.maximumHeight;\n } else {\n // Transform camera position and direction into the local coordinate system of the tileset\n const transformLocal = Matrix4.inverseTransformation(root.computedTransform, scratchMatrix);\n const ellipsoid = mapProjection.ellipsoid;\n const boundingVolume = tileBoundingVolume.boundingVolume;\n const centerLocal = Matrix4.multiplyByPoint(\n transformLocal,\n boundingVolume.center,\n scratchCenter\n );\n if (Cartesian3.magnitude(centerLocal) > ellipsoid.minimumRadius) {\n // The tileset is defined in WGS84. Approximate the minimum and maximum height.\n const centerCartographic = Cartographic.fromCartesian(\n centerLocal,\n ellipsoid,\n scratchCartographic\n );\n up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);\n direction = camera.directionWC;\n height = camera.positionCartographic.height;\n minimumHeight = 0.0;\n maximumHeight = centerCartographic.height * 2.0;\n } else {\n // The tileset is defined in local coordinates (z-up)\n const positionLocal = Matrix4.multiplyByPoint(\n transformLocal,\n camera.positionWC,\n scratchPosition\n );\n up = Cartesian3.UNIT_Z;\n direction = Matrix4.multiplyByPointAsVector(\n transformLocal,\n camera.directionWC,\n scratchDirection\n );\n direction = Cartesian3.normalize(direction, direction);\n height = positionLocal.z;\n if (tileBoundingVolume instanceof TileOrientedBoundingBox) {\n // Assuming z-up, the last component stores the half-height of the box\n const boxHeight = root._header.boundingVolume.box[11];\n minimumHeight = centerLocal.z - boxHeight;\n maximumHeight = centerLocal.z + boxHeight;\n } else if (tileBoundingVolume instanceof TileBoundingSphere) {\n const radius = boundingVolume.radius;\n minimumHeight = centerLocal.z - radius;\n maximumHeight = centerLocal.z + radius;\n }\n }\n }\n\n // The range where the density starts to lessen. Start at the quarter height of the tileset.\n const heightFalloff = dynamicScreenSpaceErrorHeightFalloff;\n const heightClose = minimumHeight + (maximumHeight - minimumHeight) * heightFalloff;\n const heightFar = maximumHeight;\n\n const t = clamp((height - heightClose) / (heightFar - heightClose), 0.0, 1.0);\n\n // Increase density as the camera tilts towards the horizon\n const dot = Math.abs(Cartesian3.dot(direction, up));\n\n let horizonFactor = 1.0 - dot;\n\n // Weaken the horizon factor as the camera height increases, implying the camera is further away from the tileset.\n // The goal is to increase density for the \"street view\", not when viewing the tileset from a distance.\n horizonFactor = horizonFactor * (1.0 - t);\n\n return dynamicScreenSpaceErrorDensity * horizonFactor;\n}\n\nexport function fog(distanceToCamera, density) {\n const scalar = distanceToCamera * density;\n return 1.0 - Math.exp(-(scalar * scalar));\n}\n\nexport function getDynamicScreenSpaceError(tileset, distanceToCamera) {\n if (tileset.dynamicScreenSpaceError && tileset.dynamicScreenSpaceErrorComputedDensity) {\n const density = tileset.dynamicScreenSpaceErrorComputedDensity;\n const factor = tileset.dynamicScreenSpaceErrorFactor;\n // TODO: Refined screen space error that minimizes tiles in non-first-person\n const dynamicError = fog(distanceToCamera, density) * factor;\n return dynamicError;\n }\n\n return 0;\n}\n\nexport function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {\n const tileset = tile.tileset;\n const parentLodMetricValue = (tile.parent && tile.parent.lodMetricValue) || tile.lodMetricValue;\n const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;\n\n // Leaf tiles do not have any error so save the computation\n if (lodMetricValue === 0.0) {\n return 0.0;\n }\n\n // TODO: Orthographic Frustum needs special treatment?\n // this._getOrthograhicScreenSpaceError();\n\n // Avoid divide by zero when viewer is inside the tile\n const distance = Math.max(tile._distanceToCamera, 1e-7);\n const {height, sseDenominator} = frameState;\n const {viewDistanceScale} = tileset.options;\n let error = (lodMetricValue * height * (viewDistanceScale || 1.0)) / (distance * sseDenominator);\n\n error -= getDynamicScreenSpaceError(tileset, distance);\n\n return error;\n}\n","import {Matrix4, Vector3} from '@math.gl/core';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport {Tile3D} from '../..';\nimport {FrameState} from './frame-state';\n\n/**\n * For the maxScreenThreshold error metric, maxError means that you should replace the node with it's children\n as soon as the nodes bounding sphere has a screen radius larger than maxError pixels.\n In this sense a value of 0 means you should always load it's children,\n or if it's a leaf node, you should always display it.\n * @param tile \n * @param frameState \n * @returns \n */\nexport function getLodStatus(tile: Tile3D, frameState: FrameState): 'DIG' | 'OUT' | 'DRAW' {\n if (tile.lodMetricValue === 0 || isNaN(tile.lodMetricValue)) {\n return 'DIG';\n }\n const screenSize = 2 * getProjectedRadius(tile, frameState);\n if (screenSize < 2) {\n return 'OUT';\n }\n if (!tile.header.children || screenSize <= tile.lodMetricValue) {\n return 'DRAW';\n } else if (tile.header.children) {\n return 'DIG';\n }\n return 'OUT';\n}\n\n/**\n * Calculate size of MBS radius projected on the screen plane\n * @param tile\n * @param frameState\n * @returns\n */\n// eslint-disable-next-line max-statements\nexport function getProjectedRadius(tile: Tile3D, frameState: FrameState): number {\n const originalViewport = frameState.viewport;\n const ViewportClass = originalViewport.constructor;\n const {longitude, latitude, height, width, bearing, zoom} = originalViewport;\n // @ts-ignore\n const viewport = new ViewportClass({longitude, latitude, height, width, bearing, zoom, pitch: 0});\n const mbsLat = tile.header.mbs[1];\n const mbsLon = tile.header.mbs[0];\n const mbsZ = tile.header.mbs[2];\n const mbsR = tile.header.mbs[3];\n const mbsCenterCartesian = [...tile.boundingVolume.center];\n const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);\n const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(\n cameraPositionCartographic,\n new Vector3()\n );\n\n // ---------------------------\n // Calculate mbs border vertex\n // ---------------------------\n const toEye = new Vector3(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();\n // Add extra vector to form plane\n const enuToCartesianMatrix = new Matrix4();\n Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);\n const cartesianToEnuMatrix = new Matrix4(enuToCartesianMatrix).invert();\n const cameraPositionEnu = new Vector3(cameraPositionCartesian).transform(cartesianToEnuMatrix);\n // Mean Proportionals in Right Triangles - Altitude rule\n // https://mathbitsnotebook.com/Geometry/RightTriangles/RTmeanRight.html\n const projection = Math.sqrt(\n cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]\n );\n const extraZ = (projection * projection) / cameraPositionEnu[2];\n const extraVertexEnu = new Vector3([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);\n const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);\n const extraVectorCartesian = new Vector3(extraVertexCartesian)\n .subtract(mbsCenterCartesian)\n .normalize();\n // We need radius vector orthogonal to toEye vector\n const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);\n const sphereMbsBorderVertexCartesian = new Vector3(mbsCenterCartesian).add(radiusVector);\n const sphereMbsBorderVertexCartographic = Ellipsoid.WGS84.cartesianToCartographic(\n sphereMbsBorderVertexCartesian\n );\n // ---------------------------\n\n // Project center vertex and border vertex and calculate projected radius of MBS\n const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);\n const projectedMbsBorderVertex = viewport.project(sphereMbsBorderVertexCartographic);\n const projectedRadius = new Vector3(projectedOrigin)\n .subtract(projectedMbsBorderVertex)\n .magnitude();\n return projectedRadius;\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {assert} from '@loaders.gl/loader-utils';\n\n/**\n * A wrapper around arrays so that the internal length of the array can be manually managed.\n *\n * @alias ManagedArray\n * @constructor\n * @private\n *\n * @param {Number} [length=0] The initial length of the array.\n */\nexport default class ManagedArray {\n constructor(length = 0) {\n this._array = new Array(length);\n this._map = new Map();\n this._length = length;\n }\n\n /**\n * Gets or sets the length of the array.\n * If the set length is greater than the length of the internal array, the internal array is resized.\n *\n * @memberof ManagedArray.prototype\n * @type Number\n */\n get length() {\n return this._length;\n }\n\n set length(length) {\n this._length = length;\n if (length > this._array.length) {\n this._array.length = length;\n }\n }\n\n /**\n * Gets the internal array.\n *\n * @memberof ManagedArray.prototype\n * @type Array\n * @readonly\n */\n get values() {\n return this._array;\n }\n\n /**\n * Gets the element at an index.\n *\n * @param {Number} index The index to get.\n */\n get(index) {\n assert(index < this._array.length);\n return this._array[index];\n }\n\n /**\n * Sets the element at an index. Resizes the array if index is greater than the length of the array.\n *\n * @param {Number} index The index to set.\n * @param {*} element The element to set at index.\n */\n set(index, element) {\n assert(index >= 0);\n\n if (index >= this.length) {\n this.length = index + 1;\n }\n\n if (this._map.has(this._array[index])) {\n this._map.delete(this._array[index]);\n }\n\n this._array[index] = element;\n this._map.set(element, index);\n }\n\n delete(element) {\n const index = this._map.get(element);\n if (index >= 0) {\n this._array.splice(index, 1);\n this._map.delete(element);\n this.length--;\n }\n }\n\n /**\n * Returns the last element in the array without modifying the array.\n *\n * @returns {*} The last element in the array.\n */\n peek() {\n return this._array[this._length - 1];\n }\n\n /**\n * Push an element into the array.\n *\n * @param {*} element The element to push.\n */\n push(element) {\n if (!this._map.has(element)) {\n const index = this.length++;\n this._array[index] = element;\n this._map.set(element, index);\n }\n }\n\n /**\n * Pop an element from the array.\n *\n * @returns {*} The last element in the array.\n */\n pop() {\n const element = this._array[--this.length];\n this._map.delete(element);\n return element;\n }\n\n /**\n * Resize the internal array if length > _array.length.\n *\n * @param {Number} length The length.\n */\n reserve(length) {\n assert(length >= 0);\n\n if (length > this._array.length) {\n this._array.length = length;\n }\n }\n\n /**\n * Resize the array.\n *\n * @param {Number} length The length.\n */\n resize(length) {\n assert(length >= 0);\n\n this.length = length;\n }\n\n /**\n * Trim the internal array to the specified length. Defaults to the current length.\n *\n * @param {Number} [length] The length.\n */\n trim(length) {\n if (length === null || length === undefined) {\n length = this.length;\n }\n this._array.length = length;\n }\n\n reset() {\n this._array = [];\n this._map = new Map();\n this._length = 0;\n }\n\n find(target) {\n return this._map.has(target);\n }\n}\n","import ManagedArray from '../../utils/managed-array';\nimport {TILE_REFINEMENT} from '../../constants';\n\nexport type TilesetTraverserProps = {\n loadSiblings?: boolean;\n skipLevelOfDetail?: boolean;\n maximumScreenSpaceError?: number;\n onTraversalEnd?: (frameState) => any;\n viewportTraversersMap?: {[key: string]: any};\n basePath?: string;\n};\n\nexport type Props = {\n loadSiblings: boolean;\n skipLevelOfDetail: boolean;\n updateTransforms: boolean;\n maximumScreenSpaceError: number;\n onTraversalEnd: (frameState) => any;\n viewportTraversersMap: {[key: string]: any};\n basePath: string;\n};\n\nexport const DEFAULT_PROPS: Props = {\n loadSiblings: false,\n skipLevelOfDetail: false,\n maximumScreenSpaceError: 2,\n updateTransforms: true,\n onTraversalEnd: () => {},\n viewportTraversersMap: {},\n basePath: ''\n};\n\nexport default class TilesetTraverser {\n options: Props;\n\n root: any;\n requestedTiles: object;\n selectedTiles: object;\n emptyTiles: object;\n\n protected _traversalStack: ManagedArray;\n protected _emptyTraversalStack: ManagedArray;\n protected _frameNumber: number | null;\n\n // TODO nested props\n constructor(options: TilesetTraverserProps) {\n this.options = {...DEFAULT_PROPS, ...options};\n // TRAVERSAL\n // temporary storage to hold the traversed tiles during a traversal\n this._traversalStack = new ManagedArray();\n this._emptyTraversalStack = new ManagedArray();\n\n // set in every traverse cycle\n this._frameNumber = null;\n\n // fulfill in traverse call\n this.root = null;\n\n // RESULT\n // tiles should be rendered\n this.selectedTiles = {};\n // tiles should be loaded from server\n this.requestedTiles = {};\n // tiles does not have render content\n this.emptyTiles = {};\n }\n\n // tiles should be visible\n traverse(root, frameState, options) {\n this.root = root; // for root screen space error\n this.options = {...this.options, ...options};\n\n // reset result\n this.reset();\n\n // update tile (visibility and expiration)\n this.updateTile(root, frameState);\n\n this._frameNumber = frameState.frameNumber;\n this.executeTraversal(root, frameState);\n }\n\n reset() {\n this.requestedTiles = {};\n this.selectedTiles = {};\n this.emptyTiles = {};\n this._traversalStack.reset();\n this._emptyTraversalStack.reset();\n }\n\n // execute traverse\n // Depth-first traversal that traverses all visible tiles and marks tiles for selection.\n // If skipLevelOfDetail is off then a tile does not refine until all children are loaded.\n // This is the traditional replacement refinement approach and is called the base traversal.\n // Tiles that have a greater screen space error than the base screen space error are part of the base traversal,\n // all other tiles are part of the skip traversal. The skip traversal allows for skipping levels of the tree\n // and rendering children and parent tiles simultaneously.\n /* eslint-disable-next-line complexity, max-statements */\n executeTraversal(root, frameState) {\n // stack to store traversed tiles, only visible tiles should be added to stack\n // visible: visible in the current view frustum\n const stack = this._traversalStack;\n root._selectionDepth = 1;\n\n stack.push(root);\n while (stack.length > 0) {\n // 1. pop tile\n const tile = stack.pop();\n\n // 2. check if tile needs to be refine, needs refine if a tile's LoD is not sufficient and tile has available children (available content)\n let shouldRefine = false;\n if (this.canTraverse(tile, frameState)) {\n this.updateChildTiles(tile, frameState);\n shouldRefine = this.updateAndPushChildren(\n tile,\n frameState,\n stack,\n tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth\n );\n }\n\n // 3. decide if should render (select) this tile\n // - tile does not have render content\n // - tile has render content and tile is `add` type (pointcloud)\n // - tile has render content and tile is `replace` type (photogrammetry) and can't refine any further\n const parent = tile.parent;\n const parentRefines = Boolean(!parent || parent._shouldRefine);\n const stoppedRefining = !shouldRefine;\n\n if (!tile.hasRenderContent) {\n this.emptyTiles[tile.id] = tile;\n this.loadTile(tile, frameState);\n if (stoppedRefining) {\n this.selectTile(tile, frameState);\n }\n // additive tiles\n } else if (tile.refine === TILE_REFINEMENT.ADD) {\n // Additive tiles are always loaded and selected\n this.loadTile(tile, frameState);\n this.selectTile(tile, frameState);\n\n // replace tiles\n } else if (tile.refine === TILE_REFINEMENT.REPLACE) {\n // Always load tiles in the base traversal\n // Select tiles that can't refine further\n this.loadTile(tile, frameState);\n if (stoppedRefining) {\n this.selectTile(tile, frameState);\n }\n }\n\n // 3. update cache, most recent touched tiles have higher priority to be fetched from server\n this.touchTile(tile, frameState);\n\n // 4. update tile refine prop and parent refinement status to trickle down to the descendants\n tile._shouldRefine = shouldRefine && parentRefines;\n }\n\n this.options.onTraversalEnd(frameState);\n }\n\n updateChildTiles(tile, frameState) {\n const children = tile.children;\n for (const child of children) {\n this.updateTile(child, frameState);\n }\n return true;\n }\n\n /* eslint-disable complexity, max-statements */\n updateAndPushChildren(tile, frameState, stack, depth) {\n const {loadSiblings, skipLevelOfDetail} = this.options;\n\n const children = tile.children;\n\n // sort children tiles\n children.sort(this.compareDistanceToCamera.bind(this));\n\n // For traditional replacement refinement only refine if all children are loaded.\n // Empty tiles are exempt since it looks better if children stream in as they are loaded to fill the empty space.\n const checkRefines =\n tile.refine === TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;\n\n let hasVisibleChild = false;\n let refines = true;\n\n for (const child of children) {\n child._selectionDepth = depth;\n if (child.isVisibleAndInRequestVolume) {\n if (stack.find(child)) {\n stack.delete(child);\n }\n stack.push(child);\n hasVisibleChild = true;\n } else if (checkRefines || loadSiblings) {\n // Keep non-visible children loaded since they are still needed before the parent can refine.\n // Or loadSiblings is true so always load tiles regardless of visibility.\n this.loadTile(child, frameState);\n this.touchTile(child, frameState);\n }\n\n if (checkRefines) {\n let childRefines;\n if (!child._inRequestVolume) {\n childRefines = false;\n } else if (!child.hasRenderContent) {\n childRefines = this.executeEmptyTraversal(child, frameState);\n } else {\n childRefines = child.contentAvailable;\n }\n refines = refines && childRefines;\n\n if (!refines) {\n return false;\n }\n }\n }\n\n if (!hasVisibleChild) {\n refines = false;\n }\n return refines;\n }\n /* eslint-enable complexity, max-statements */\n\n updateTile(tile, frameState) {\n this.updateTileVisibility(tile, frameState);\n }\n\n // tile to render in the browser\n selectTile(tile, frameState) {\n if (this.shouldSelectTile(tile)) {\n // The tile can be selected right away and does not require traverseAndSelect\n tile._selectedFrame = frameState.frameNumber;\n this.selectedTiles[tile.id] = tile;\n }\n }\n\n // tile to load from server\n loadTile(tile, frameState) {\n if (this.shouldLoadTile(tile)) {\n tile._requestedFrame = frameState.frameNumber;\n tile._priority = tile._getPriority();\n this.requestedTiles[tile.id] = tile;\n }\n }\n\n // cache tile\n touchTile(tile, frameState) {\n tile.tileset._cache.touch(tile);\n tile._touchedFrame = frameState.frameNumber;\n }\n\n // tile should be visible\n // tile should have children\n // tile LoD (level of detail) is not sufficient under current viewport\n canTraverse(tile, frameState, useParentMetric = false, ignoreVisibility = false) {\n if (!tile.hasChildren) {\n return false;\n }\n\n // cesium specific\n if (tile.hasTilesetContent) {\n // Traverse external this to visit its root tile\n // Don't traverse if the subtree is expired because it will be destroyed\n return !tile.contentExpired;\n }\n\n if (!ignoreVisibility && !tile.isVisibleAndInRequestVolume) {\n return false;\n }\n\n return this.shouldRefine(tile, frameState, useParentMetric);\n }\n\n shouldLoadTile(tile) {\n // if request tile is in current frame\n // and has unexpired render content\n return tile.hasUnloadedContent || tile.contentExpired;\n }\n\n shouldSelectTile(tile) {\n // if select tile is in current frame\n // and content available\n return tile.contentAvailable && !this.options.skipLevelOfDetail;\n }\n\n // Decide if tile LoD (level of detail) is not sufficient under current viewport\n shouldRefine(tile, frameState, useParentMetric) {\n let screenSpaceError = tile._screenSpaceError;\n if (useParentMetric) {\n screenSpaceError = tile.getScreenSpaceError(frameState, true);\n }\n\n return screenSpaceError > this.options.maximumScreenSpaceError;\n }\n\n updateTileVisibility(tile, frameState) {\n const viewportIds: string[] = [];\n if (this.options.viewportTraversersMap) {\n for (const key in this.options.viewportTraversersMap) {\n const value = this.options.viewportTraversersMap[key];\n if (value === frameState.viewport.id) {\n viewportIds.push(key);\n }\n }\n } else {\n viewportIds.push(frameState.viewport.id);\n }\n tile.updateVisibility(frameState, viewportIds);\n }\n\n // UTILITIES\n\n compareDistanceToCamera(b, a) {\n return b._distanceToCamera - a._distanceToCamera;\n }\n\n anyChildrenVisible(tile, frameState) {\n let anyVisible = false;\n for (const child of tile.children) {\n child.updateVisibility(frameState);\n anyVisible = anyVisible || child.isVisibleAndInRequestVolume;\n }\n return anyVisible;\n }\n\n // Depth-first traversal that checks if all nearest descendants with content are loaded.\n // Ignores visibility.\n executeEmptyTraversal(root, frameState) {\n let allDescendantsLoaded = true;\n const stack = this._emptyTraversalStack;\n\n stack.push(root);\n\n while (stack.length > 0 && allDescendantsLoaded) {\n const tile = stack.pop();\n\n this.updateTile(tile, frameState);\n\n if (!tile.isVisibleAndInRequestVolume) {\n // Load tiles that aren't visible since they are still needed for the parent to refine\n this.loadTile(tile, frameState);\n }\n\n this.touchTile(tile, frameState);\n\n // Only traverse if the tile is empty - traversal stop at descendants with content\n const traverse = !tile.hasRenderContent && this.canTraverse(tile, frameState, false, true);\n\n if (traverse) {\n const children = tile.children;\n for (const child of children) {\n // eslint-disable-next-line max-depth\n if (stack.find(child)) {\n stack.delete(child);\n }\n stack.push(child);\n }\n } else if (!tile.contentAvailable) {\n allDescendantsLoaded = false;\n }\n }\n\n return allDescendantsLoaded;\n }\n}\n\n// TODO\n// enable expiration\n// enable optimization hint\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\nimport {Vector3, Matrix4} from '@math.gl/core';\nimport {CullingVolume} from '@math.gl/culling';\n\nimport {load} from '@loaders.gl/core';\nimport {TILE_REFINEMENT, TILE_CONTENT_STATE, TILESET_TYPE} from '../constants';\n\nimport {FrameState} from './helpers/frame-state';\nimport {createBoundingVolume} from './helpers/bounding-volume';\nimport {getTiles3DScreenSpaceError} from './helpers/tiles-3d-lod';\nimport {getProjectedRadius} from './helpers/i3s-lod';\nimport {get3dTilesOptions} from './helpers/3d-tiles-options';\nimport TilesetTraverser from './traversers/tileset-traverser';\n\n// Note: circular dependency\nimport type Tileset3D from './tileset-3d';\n\nconst scratchVector = new Vector3();\n\nfunction defined(x) {\n return x !== undefined && x !== null;\n}\n\n/**\n * @param tileset - Tileset3D instance\n * @param header - tile header - JSON loaded from a dataset\n * @param parentHeader - parent TileHeader instance\n * @param extendedId - optional ID to separate copies of a tile for different viewports.\n * const extendedId = `${tile.id}-${frameState.viewport.id}`;\n */\nexport type TileHeaderProps = {\n tileset: Tileset3D;\n header: Object;\n parentHeader: TileHeader;\n extendedId: string;\n};\n\n/**\n * A Tile3DHeader represents a tile as Tileset3D. When a tile is first created, its content is not loaded;\n * the content is loaded on-demand when needed based on the view.\n * Do not construct this directly, instead access tiles through {@link Tileset3D#tileVisible}.\n */\nexport default class TileHeader {\n tileset: Tileset3D;\n header: any;\n id: string;\n url: string;\n parent: TileHeader;\n refine: number;\n type: string;\n contentUrl: string;\n lodMetricType: string;\n lodMetricValue: number;\n boundingVolume: any;\n content: any;\n contentState: any;\n gpuMemoryUsageInBytes: number;\n children: TileHeader[];\n depth: number;\n viewportIds: any[];\n transform: Matrix4;\n\n // Container to store application specific data\n userData: {[key: string]: any};\n computedTransform: any;\n hasEmptyContent: boolean;\n hasTilesetContent: boolean;\n\n traverser: object;\n\n // @ts-ignore\n private _cacheNode: any;\n private _frameNumber: any;\n // TODO i3s specific, needs to remove\n // @ts-ignore\n private _lodJudge: any;\n // TODO Cesium 3d tiles specific\n private _expireDate: any;\n private _expiredContent: any;\n // @ts-ignore\n private _shouldRefine: boolean;\n\n // Members this are updated every frame for tree traversal and rendering optimizations:\n // @ts-ignore\n private _distanceToCamera: number;\n // @ts-ignore\n private _centerZDepth: number;\n private _screenSpaceError: number;\n private _visibilityPlaneMask: any;\n private _visible?: boolean;\n private _inRequestVolume: boolean;\n\n // @ts-ignore\n private _stackLength: number;\n // @ts-ignore\n private _selectionDepth: number;\n\n // @ts-ignore\n private _touchedFrame: number;\n // @ts-ignore\n private _visitedFrame: number;\n private _selectedFrame: number;\n // @ts-ignore\n private _requestedFrame: number;\n\n // @ts-ignore\n private _priority: number;\n\n private _contentBoundingVolume: any;\n private _viewerRequestVolume: any;\n\n _initialTransform: Matrix4;\n\n /**\n * @constructs\n * Create a TileHeader instance\n * @param tileset - Tileset3D instance\n * @param header - tile header - JSON loaded from a dataset\n * @param parentHeader - parent TileHeader instance\n * @param extendedId - optional ID to separate copies of a tile for different viewports.\n * const extendedId = `${tile.id}-${frameState.viewport.id}`;\n */\n // eslint-disable-next-line max-statements\n constructor(\n tileset: Tileset3D,\n header: {[key: string]: any},\n parentHeader?: TileHeader,\n extendedId = ''\n ) {\n // PUBLIC MEMBERS\n // original tile data\n this.header = header;\n\n // The tileset containing this tile.\n this.tileset = tileset;\n this.id = extendedId || header.id;\n this.url = header.url;\n\n // This tile's parent or `undefined` if this tile is the root.\n // @ts-ignore\n this.parent = parentHeader;\n this.refine = this._getRefine(header.refine);\n this.type = header.type;\n this.contentUrl = header.contentUrl;\n\n // The error, in meters, introduced if this tile is rendered and its children are not.\n this.lodMetricType = 'geometricError';\n this.lodMetricValue = 0;\n\n // Specifies the type of refine that is used when traversing this tile for rendering.\n this.boundingVolume = null;\n\n // The tile's content. This represents the actual tile's payload,\n // not the content's metadata in the tileset JSON file.\n this.content = null;\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n this.gpuMemoryUsageInBytes = 0;\n\n // The tile's children - an array of Tile3D objects.\n this.children = [];\n\n this.hasEmptyContent = false;\n this.hasTilesetContent = false;\n\n this.depth = 0;\n this.viewportIds = [];\n\n // Container to store application specific data\n this.userData = {};\n\n // PRIVATE MEMBERS\n this._priority = 0;\n this._touchedFrame = 0;\n this._visitedFrame = 0;\n this._selectedFrame = 0;\n this._requestedFrame = 0;\n this._screenSpaceError = 0;\n\n this._cacheNode = null;\n this._frameNumber = null;\n this._cacheNode = null;\n\n this.traverser = new TilesetTraverser({});\n this._shouldRefine = false;\n this._distanceToCamera = 0;\n this._centerZDepth = 0;\n this._visible = undefined;\n this._inRequestVolume = false;\n this._stackLength = 0;\n this._selectionDepth = 0;\n this._initialTransform = new Matrix4();\n this.transform = new Matrix4();\n\n this._initializeLodMetric(header);\n this._initializeTransforms(header);\n this._initializeBoundingVolumes(header);\n this._initializeContent(header);\n this._initializeRenderingState(header);\n\n // TODO i3s specific, needs to remove\n this._lodJudge = null;\n\n // TODO Cesium 3d tiles specific\n this._expireDate = null;\n this._expiredContent = null;\n\n Object.seal(this);\n }\n\n destroy() {\n this.header = null;\n }\n\n isDestroyed() {\n return this.header === null;\n }\n\n get selected() {\n return this._selectedFrame === this.tileset._frameNumber;\n }\n\n get isVisible() {\n return this._visible;\n }\n\n get isVisibleAndInRequestVolume() {\n return this._visible && this._inRequestVolume;\n }\n\n /** Returns true if tile is not an empty tile and not an external tileset */\n get hasRenderContent() {\n return !this.hasEmptyContent && !this.hasTilesetContent;\n }\n\n /** Returns true if tile has children */\n get hasChildren() {\n return this.children.length > 0 || (this.header.children && this.header.children.length > 0);\n }\n\n /**\n * Determines if the tile's content is ready. This is automatically `true` for\n * tiles with empty content.\n */\n get contentReady() {\n return this.contentState === TILE_CONTENT_STATE.READY || this.hasEmptyContent;\n }\n\n /**\n * Determines if the tile has available content to render. `true` if the tile's\n * content is ready or if it has expired content this renders while new content loads; otherwise,\n */\n get contentAvailable() {\n return Boolean(\n (this.contentReady && this.hasRenderContent) || (this._expiredContent && !this.contentFailed)\n );\n }\n\n /** Returns true if tile has renderable content but it's unloaded */\n get hasUnloadedContent() {\n return this.hasRenderContent && this.contentUnloaded;\n }\n\n /**\n * Determines if the tile's content has not be requested. `true` if tile's\n * content has not be requested; otherwise, `false`.\n */\n get contentUnloaded() {\n return this.contentState === TILE_CONTENT_STATE.UNLOADED;\n }\n\n /**\n * Determines if the tile's content is expired. `true` if tile's\n * content is expired; otherwise, `false`.\n */\n get contentExpired() {\n return this.contentState === TILE_CONTENT_STATE.EXPIRED;\n }\n\n // Determines if the tile's content failed to load. `true` if the tile's\n // content failed to load; otherwise, `false`.\n get contentFailed() {\n return this.contentState === TILE_CONTENT_STATE.FAILED;\n }\n\n /** Get the tile's screen space error. */\n getScreenSpaceError(frameState, useParentLodMetric) {\n switch (this.tileset.type) {\n case TILESET_TYPE.I3S:\n return getProjectedRadius(this, frameState);\n case TILESET_TYPE.TILES3D:\n return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric);\n default:\n // eslint-disable-next-line\n throw new Error('Unsupported tileset type');\n }\n }\n\n /*\n * If skipLevelOfDetail is off try to load child tiles as soon as possible so that their parent can refine sooner.\n * Tiles are prioritized by screen space error.\n */\n // eslint-disable-next-line complexity\n _getPriority() {\n const traverser = this.tileset._traverser;\n const {skipLevelOfDetail} = traverser.options;\n\n /*\n * Tiles that are outside of the camera's frustum could be skipped if we are in 'ADD' mode\n * or if we are using 'Skip Traversal' in 'REPLACE' mode.\n * Otherewise, all 'touched' child tiles have to be loaded and displayed,\n * this may include tiles that are outide of the camera frustum (so that we can hide the parent tile).\n */\n const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;\n\n // Check if any reason to abort\n if (maySkipTile && !this.isVisible && this._visible !== undefined) {\n return -1;\n }\n // Condition used in `cancelOutOfViewRequests` function in CesiumJS/Cesium3DTileset.js\n if (this.tileset._frameNumber - this._touchedFrame >= 1) {\n return -1;\n }\n if (this.contentState === TILE_CONTENT_STATE.UNLOADED) {\n return -1;\n }\n\n // Based on the priority function `getPriorityReverseScreenSpaceError` in CesiumJS. Scheduling priority is based on the parent's screen space error when possible.\n const parent = this.parent;\n const useParentScreenSpaceError =\n parent && (!maySkipTile || this._screenSpaceError === 0.0 || parent.hasTilesetContent);\n const screenSpaceError = useParentScreenSpaceError\n ? parent._screenSpaceError\n : this._screenSpaceError;\n\n const rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0.0;\n\n // Map higher SSE to lower values (e.g. root tile is highest priority)\n return Math.max(rootScreenSpaceError - screenSpaceError, 0);\n }\n\n /**\n * Requests the tile's content.\n * The request may not be made if the Request Scheduler can't prioritize it.\n */\n // eslint-disable-next-line max-statements, complexity\n async loadContent(): Promise<boolean> {\n if (this.hasEmptyContent) {\n return false;\n }\n\n if (this.content) {\n return true;\n }\n\n const expired = this.contentExpired;\n\n if (expired) {\n this._expireDate = null;\n }\n\n this.contentState = TILE_CONTENT_STATE.LOADING;\n\n const requestToken = await this.tileset._requestScheduler.scheduleRequest(\n this.id,\n this._getPriority.bind(this)\n );\n\n if (!requestToken) {\n // cancelled\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n return false;\n }\n\n try {\n const contentUrl = this.tileset.getTileUrl(this.contentUrl);\n // The content can be a binary tile ot a JSON tileset\n const loader = this.tileset.loader;\n const options = {\n ...this.tileset.loadOptions,\n [loader.id]: {\n ...this.tileset.loadOptions[loader.id],\n isTileset: this.type === 'json',\n ...this._getLoaderSpecificOptions(loader.id)\n }\n };\n\n this.content = await load(contentUrl, loader, options);\n\n if (this.tileset.options.contentLoader) {\n await this.tileset.options.contentLoader(this);\n }\n\n if (this._isTileset()) {\n // Add tile headers for the nested tilset's subtree\n // Async update of the tree should be fine since there would never be edits to the same node\n // TODO - we need to capture the child tileset's URL\n this.tileset._initializeTileHeaders(this.content, this);\n }\n\n this.contentState = TILE_CONTENT_STATE.READY;\n this._onContentLoaded();\n return true;\n } catch (error) {\n // Tile is unloaded before the content finishes loading\n this.contentState = TILE_CONTENT_STATE.FAILED;\n throw error;\n } finally {\n requestToken.done();\n }\n }\n\n // Unloads the tile's content.\n unloadContent() {\n if (this.content && this.content.destroy) {\n this.content.destroy();\n }\n this.content = null;\n if (this.header.content && this.header.content.destroy) {\n this.header.content.destroy();\n }\n this.header.content = null;\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n return true;\n }\n\n /**\n * Update the tile's visibility\n * @param {Object} frameState - frame state for tile culling\n * @param {string[]} viewportIds - a list of viewport ids that show this tile\n * @return {void}\n */\n updateVisibility(frameState, viewportIds) {\n if (this._frameNumber === frameState.frameNumber) {\n // Return early if visibility has already been checked during the traversal.\n // The visibility may have already been checked if the cullWithChildrenBounds optimization is used.\n return;\n }\n\n const parent = this.parent;\n const parentVisibilityPlaneMask = parent\n ? parent._visibilityPlaneMask\n : CullingVolume.MASK_INDETERMINATE;\n\n if (this.tileset._traverser.options.updateTransforms) {\n const parentTransform = parent ? parent.computedTransform : this.tileset.modelMatrix;\n this._updateTransform(parentTransform);\n }\n\n this._distanceToCamera = this.distanceToTile(frameState);\n this._screenSpaceError = this.getScreenSpaceError(frameState, false);\n this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask); // Use parent's plane mask to speed up visibility test\n this._visible = this._visibilityPlaneMask !== CullingVolume.MASK_OUTSIDE;\n this._inRequestVolume = this.insideViewerRequestVolume(frameState);\n\n this._frameNumber = frameState.frameNumber;\n this.viewportIds = viewportIds;\n }\n\n // Determines whether the tile's bounding volume intersects the culling volume.\n // @param {FrameState} frameState The frame state.\n // @param {Number} parentVisibilityPlaneMask The parent's plane mask to speed up the visibility check.\n // @returns {Number} A plane mask as described above in {@link CullingVolume#computeVisibilityWithPlaneMask}.\n visibility(frameState, parentVisibilityPlaneMask) {\n const {cullingVolume} = frameState;\n const {boundingVolume} = this;\n\n // TODO Cesium specific - restore clippingPlanes\n // const {clippingPlanes, clippingPlanesOriginMatrix} = tileset;\n // if (clippingPlanes && clippingPlanes.enabled) {\n // const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(\n // boundingVolume,\n // clippingPlanesOriginMatrix\n // );\n // this._isClipped = intersection !== Intersect.INSIDE;\n // if (intersection === Intersect.OUTSIDE) {\n // return CullingVolume.MASK_OUTSIDE;\n // }\n // }\n\n // return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);\n return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);\n }\n\n // Assuming the tile's bounding volume intersects the culling volume, determines\n // whether the tile's content's bounding volume intersects the culling volume.\n // @param {FrameState} frameState The frame state.\n // @returns {Intersect} The result of the intersection: the tile's content is completely outside, completely inside, or intersecting the culling volume.\n contentVisibility() {\n return true;\n\n // TODO restore\n /*\n // Assumes the tile's bounding volume intersects the culling volume already, so\n // just return Intersect.INSIDE if there is no content bounding volume.\n if (!defined(this.contentBoundingVolume)) {\n return Intersect.INSIDE;\n }\n\n if (this._visibilityPlaneMask === CullingVolume.MASK_INSIDE) {\n // The tile's bounding volume is completely inside the culling volume so\n // the content bounding volume must also be inside.\n return Intersect.INSIDE;\n }\n\n // PERFORMANCE_IDEA: is it possible to burn less CPU on this test since we know the\n // tile's (not the content's) bounding volume intersects the culling volume?\n const cullingVolume = frameState.cullingVolume;\n const boundingVolume = tile.contentBoundingVolume;\n\n const tileset = this.tileset;\n const clippingPlanes = tileset.clippingPlanes;\n if (defined(clippingPlanes) && clippingPlanes.enabled) {\n const intersection = clippingPlanes.computeIntersectionWithBoundingVolume(\n boundingVolume,\n tileset.clippingPlanesOriginMatrix\n );\n this._isClipped = intersection !== Intersect.INSIDE;\n if (intersection === Intersect.OUTSIDE) {\n return Intersect.OUTSIDE;\n }\n }\n\n return cullingVolume.computeVisibility(boundingVolume);\n */\n }\n\n /**\n * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.\n * @param frameState The frame state.\n * @returns {Number} The distance, in meters, or zero if the camera is inside the bounding volume.\n */\n distanceToTile(frameState: FrameState): number {\n const boundingVolume = this.boundingVolume;\n return Math.sqrt(Math.max(boundingVolume.distanceSquaredTo(frameState.camera.position), 0));\n }\n\n /**\n * Computes the tile's camera-space z-depth.\n * @param frameState The frame state.\n * @returns The distance, in meters.\n */\n cameraSpaceZDepth({camera}): number {\n const boundingVolume = this.boundingVolume; // Gets the underlying OrientedBoundingBox or BoundingSphere\n scratchVector.subVectors(boundingVolume.center, camera.position);\n return camera.direction.dot(scratchVector);\n }\n\n /**\n * Checks if the camera is inside the viewer request volume.\n * @param {FrameState} frameState The frame state.\n * @returns {Boolean} Whether the camera is inside the volume.\n */\n insideViewerRequestVolume(frameState: FrameState) {\n const viewerRequestVolume = this._viewerRequestVolume;\n return (\n !viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0\n );\n }\n\n // TODO Cesium specific\n\n // Update whether the tile has expired.\n updateExpiration() {\n if (defined(this._expireDate) && this.contentReady && !this.hasEmptyContent) {\n const now = Date.now();\n // @ts-ignore Date.lessThan - replace with ms compare?\n if (Date.lessThan(this._expireDate, now)) {\n this.contentState = TILE_CONTENT_STATE.EXPIRED;\n this._expiredContent = this.content;\n }\n }\n }\n\n get extras() {\n return this.header.extras;\n }\n\n // INTERNAL METHODS\n\n _initializeLodMetric(header) {\n if ('lodMetricType' in header) {\n this.lodMetricType = header.lodMetricType;\n } else {\n this.lodMetricType = (this.parent && this.parent.lodMetricType) || this.tileset.lodMetricType;\n // eslint-disable-next-line\n console.warn(`3D Tile: Required prop lodMetricType is undefined. Using parent lodMetricType`);\n }\n\n // This is used to compute screen space error, i.e., the error measured in pixels.\n if ('lodMetricValue' in header) {\n this.lodMetricValue = header.lodMetricValue;\n } else {\n this.lodMetricValue =\n (this.parent && this.parent.lodMetricValue) || this.tileset.lodMetricValue;\n // eslint-disable-next-line\n console.warn(\n '3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue'\n );\n }\n }\n\n _initializeTransforms(tileHeader) {\n // The local transform of this tile.\n this.transform = tileHeader.transform ? new Matrix4(tileHeader.transform) : new Matrix4();\n\n const parent = this.parent;\n const tileset = this.tileset;\n\n const parentTransform =\n parent && parent.computedTransform\n ? parent.computedTransform.clone()\n : tileset.modelMatrix.clone();\n this.computedTransform = new Matrix4(parentTransform).multiplyRight(this.transform);\n\n const parentInitialTransform =\n parent && parent._initialTransform ? parent._initialTransform.clone() : new Matrix4();\n this._initialTransform = new Matrix4(parentInitialTransform).multiplyRight(this.transform);\n }\n\n _initializeBoundingVolumes(tileHeader) {\n this._contentBoundingVolume = null;\n this._viewerRequestVolume = null;\n\n this._updateBoundingVolume(tileHeader);\n }\n\n _initializeContent(tileHeader) {\n // Empty tile by default\n this.content = {_tileset: this.tileset, _tile: this};\n this.hasEmptyContent = true;\n this.contentState = TILE_CONTENT_STATE.UNLOADED;\n\n // When `true`, the tile's content points to an external tileset.\n // This is `false` until the tile's content is loaded.\n this.hasTilesetContent = false;\n\n if (tileHeader.contentUrl) {\n this.content = null;\n this.hasEmptyContent = false;\n }\n }\n\n // TODO - remove anything not related to basic visibility detection\n _initializeRenderingState(header) {\n this.depth = header.level || (this.parent ? this.parent.depth + 1 : 0);\n this._shouldRefine = false;\n\n // Members this are updated every frame for tree traversal and rendering optimizations:\n this._distanceToCamera = 0;\n this._centerZDepth = 0;\n this._screenSpaceError = 0;\n this._visibilityPlaneMask = CullingVolume.MASK_INDETERMINATE;\n this._visible = undefined;\n this._inRequestVolume = false;\n\n this._stackLength = 0;\n this._selectionDepth = 0;\n\n this._frameNumber = 0;\n this._touchedFrame = 0;\n this._visitedFrame = 0;\n this._selectedFrame = 0;\n this._requestedFrame = 0;\n\n this._priority = 0.0;\n }\n\n _getRefine(refine) {\n // Inherit from parent tile if omitted.\n return refine || (this.parent && this.parent.refine) || TILE_REFINEMENT.REPLACE;\n }\n\n _isTileset() {\n return this.contentUrl.indexOf('.json') !== -1;\n }\n\n _onContentLoaded() {\n // Vector and Geometry tile rendering do not support the skip LOD optimization.\n switch (this.content && this.content.type) {\n case 'vctr':\n case 'geom':\n // @ts-ignore\n this.tileset._traverser.disableSkipLevelOfDetail = true;\n break;\n default:\n }\n\n // The content may be tileset json\n if (this._isTileset()) {\n this.hasTilesetContent = true;\n }\n }\n\n _updateBoundingVolume(header) {\n // Update the bounding volumes\n this.boundingVolume = createBoundingVolume(\n header.boundingVolume,\n this.computedTransform,\n this.boundingVolume\n );\n\n const content = header.content;\n if (!content) {\n return;\n }\n\n // TODO Cesium specific\n // Non-leaf tiles may have a content bounding-volume, which is a tight-fit bounding volume\n // around only the features in the tile. This box is useful for culling for rendering,\n // but not for culling for traversing the tree since it does not guarantee spatial coherence, i.e.,\n // since it only bounds features in the tile, not the entire tile, children may be\n // outside of this box.\n if (content.boundingVolume) {\n this._contentBoundingVolume = createBoundingVolume(\n content.boundingVolume,\n this.computedTransform,\n this._contentBoundingVolume\n );\n }\n if (header.viewerRequestVolume) {\n this._viewerRequestVolume = createBoundingVolume(\n header.viewerRequestVolume,\n this.computedTransform,\n this._viewerRequestVolume\n );\n }\n }\n\n // Update the tile's transform. The transform is applied to the tile's bounding volumes.\n _updateTransform(parentTransform = new Matrix4()) {\n const computedTransform = parentTransform.clone().multiplyRight(this.transform);\n const didTransformChange = !computedTransform.equals(this.computedTransform);\n\n if (!didTransformChange) {\n return;\n }\n\n this.computedTransform = computedTransform;\n\n this._updateBoundingVolume(this.header);\n }\n\n // Get options which are applicable only for the particular loader\n _getLoaderSpecificOptions(loaderId) {\n switch (loaderId) {\n case 'i3s':\n return {\n ...this.tileset.options.i3s,\n tile: this.header,\n tileset: this.tileset.tileset,\n isTileHeader: false\n };\n case '3d-tiles':\n case 'cesium-ion':\n default:\n return get3dTilesOptions(this.tileset.tileset);\n }\n }\n}\n","export function get3dTilesOptions(tileset) {\n return {\n assetGltfUpAxis: (tileset.asset && tileset.asset.gltfUpAxis) || 'Y'\n };\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {TILE3D_OPTIMIZATION_HINT, TILE_REFINEMENT} from '../../constants';\nimport TilesetTraverser from './tileset-traverser';\n\nexport default class Tileset3DTraverser extends TilesetTraverser {\n compareDistanceToCamera(a, b) {\n // Sort by farthest child first since this is going on a stack\n return b._distanceToCamera === 0 && a._distanceToCamera === 0\n ? b._centerZDepth - a._centerZDepth\n : b._distanceToCamera - a._distanceToCamera;\n }\n\n updateTileVisibility(tile, frameState) {\n super.updateTileVisibility(tile, frameState);\n\n // Optimization - if none of the tile's children are visible then this tile isn't visible\n if (!tile.isVisibleAndInRequestVolume) {\n return;\n }\n\n const hasChildren = tile.children.length > 0;\n if (tile.hasTilesetContent && hasChildren) {\n // Use the root tile's visibility instead of this tile's visibility.\n // The root tile may be culled by the children bounds optimization in which\n // case this tile should also be culled.\n const firstChild = tile.children[0];\n this.updateTileVisibility(firstChild, frameState);\n tile._visible = firstChild._visible;\n return;\n }\n\n if (this.meetsScreenSpaceErrorEarly(tile, frameState)) {\n tile._visible = false;\n return;\n }\n\n const replace = tile.refine === TILE_REFINEMENT.REPLACE;\n const useOptimization =\n tile._optimChildrenWithinParent === TILE3D_OPTIMIZATION_HINT.USE_OPTIMIZATION;\n if (replace && useOptimization && hasChildren) {\n if (!this.anyChildrenVisible(tile, frameState)) {\n tile._visible = false;\n return;\n }\n }\n }\n\n meetsScreenSpaceErrorEarly(tile, frameState) {\n const {parent} = tile;\n if (!parent || parent.hasTilesetContent || parent.refine !== TILE_REFINEMENT.ADD) {\n return false;\n }\n\n // Use parent's geometric error with child's box to see if the tile already meet the SSE\n return !this.shouldRefine(tile, frameState, true);\n }\n}\n","const STATUS = {\n REQUESTED: 'REQUESTED',\n COMPLETED: 'COMPLETED',\n ERROR: 'ERROR'\n};\n\n// A helper class to manage tile metadata fetching\nexport default class I3STileManager {\n private _statusMap: object;\n\n constructor() {\n this._statusMap = {};\n }\n\n add(request, key, callback, frameState) {\n if (!this._statusMap[key]) {\n this._statusMap[key] = {request, callback, key, frameState, status: STATUS.REQUESTED};\n request()\n .then((data) => {\n this._statusMap[key].status = STATUS.COMPLETED;\n this._statusMap[key].callback(data, frameState);\n })\n .catch((error) => {\n this._statusMap[key].status = STATUS.ERROR;\n callback(error);\n });\n }\n }\n\n update(key, frameState) {\n if (this._statusMap[key]) {\n this._statusMap[key].frameState = frameState;\n }\n }\n\n find(key) {\n return this._statusMap[key];\n }\n}\n","import {load} from '@loaders.gl/core';\nimport TilesetTraverser from './tileset-traverser';\n\nimport {getLodStatus} from '../helpers/i3s-lod';\nimport TileHeader from '../tile-3d';\nimport I3STileManager from './i3s-tile-manager';\n\nexport default class I3STilesetTraverser extends TilesetTraverser {\n private _tileManager: I3STileManager;\n\n constructor(options) {\n super(options);\n this._tileManager = new I3STileManager();\n }\n\n shouldRefine(tile, frameState) {\n tile._lodJudge = getLodStatus(tile, frameState);\n return tile._lodJudge === 'DIG';\n }\n\n updateChildTiles(tile, frameState): boolean {\n const children = tile.header.children || [];\n // children which are already fetched and constructed as Tile3D instances\n const childTiles = tile.children;\n const tileset = tile.tileset;\n\n for (const child of children) {\n const extendedId = `${child.id}-${frameState.viewport.id}`;\n // if child tile is not fetched\n const childTile = childTiles && childTiles.find((t) => t.id === extendedId);\n if (!childTile) {\n let request = () => this._loadTile(child.id, tileset);\n const cachedRequest = this._tileManager.find(extendedId);\n if (!cachedRequest) {\n // eslint-disable-next-line max-depth\n if (tileset.tileset.nodePages) {\n request = () => tileset.tileset.nodePagesTile.formTileFromNodePages(child.id);\n }\n this._tileManager.add(\n request,\n extendedId,\n (header) => this._onTileLoad(header, tile, extendedId),\n frameState\n );\n } else {\n // update frameNumber since it is still needed in current frame\n this._tileManager.update(extendedId, frameState);\n }\n } else if (childTile) {\n // if child tile is fetched and available\n this.updateTile(childTile, frameState);\n }\n }\n return false;\n }\n\n async _loadTile(nodeId, tileset) {\n const {loader} = tileset;\n const nodeUrl = tileset.getTileUrl(`${tileset.url}/nodes/${nodeId}`);\n // load metadata\n const options = {\n ...tileset.loadOptions,\n i3s: {\n ...tileset.loadOptions.i3s,\n isTileHeader: true,\n loadContent: false\n }\n };\n\n return await load(nodeUrl, loader, options);\n }\n\n /**\n * The callback to init TileHeader instance after loading the tile JSON\n * @param {Object} header - the tile JSON from a dataset\n * @param {TileHeader} tile - the parent TileHeader instance\n * @param {string} extendedId - optional ID to separate copies of a tile for different viewports.\n * const extendedId = `${tile.id}-${frameState.viewport.id}`;\n * @return {void}\n */\n _onTileLoad(header, tile, extendedId) {\n // after child tile is fetched\n const childTile = new TileHeader(tile.tileset, header, tile, extendedId);\n tile.children.push(childTile);\n const frameState = this._tileManager.find(childTile.id).frameState;\n this.updateTile(childTile, frameState);\n\n // after tile fetched, resume traversal if still in current update/traversal frame\n if (this._frameNumber === frameState.frameNumber) {\n this.executeTraversal(childTile, frameState);\n }\n }\n}\n","// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\n/*\n\n The Tileset loading and rendering flow is as below,\n A rendered (i.e. deck.gl `Tile3DLayer`) triggers `tileset.update()` after a `tileset` is loaded\n `tileset` starts traversing the tile tree and update `requestTiles` (tiles of which content need\n to be fetched) and `selectedTiles` (tiles ready for rendering under the current viewport).\n `Tile3DLayer` will update rendering based on `selectedTiles`.\n `Tile3DLayer` also listens to `onTileLoad` callback and trigger another round of `update and then traversal`\n when new tiles are loaded.\n\n As I3S tileset have stored `tileHeader` file (metadata) and tile content files (geometry, texture, ...) separately.\n During each traversal, it issues `tilHeader` requests if that `tileHeader` is not yet fetched,\n after the tile header is fulfilled, it will resume the traversal starting from the tile just fetched (not root).\n\n Tile3DLayer\n |\n await load(tileset)\n |\n tileset.update()\n | async load tileHeader\n tileset.traverse() -------------------------- Queued\n | resume traversal after fetched |\n |----------------------------------------|\n |\n | async load tile content\n tilset.requestedTiles ----------------------------- RequestScheduler\n |\n tilset.selectedTiles (ready for rendering) |\n | Listen to |\n Tile3DLayer ----------- onTileLoad ----------------------|\n | | notify new tile is available\n updateLayers |\n tileset.update // trigger another round of update\n*/\n\nimport {Matrix4, Vector3} from '@math.gl/core';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport {Stats} from '@probe.gl/stats';\nimport {\n RequestScheduler,\n assert,\n path,\n LoaderWithParser,\n LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport TilesetCache from './tileset-cache';\nimport {calculateTransformProps} from './helpers/transform-utils';\nimport {FrameState, getFrameState} from './helpers/frame-state';\nimport {getZoomFromBoundingVolume} from './helpers/zoom';\nimport Tile3D from './tile-3d';\nimport Tileset3DTraverser from './traversers/tileset-3d-traverser';\nimport TilesetTraverser from './traversers/tileset-traverser';\nimport I3SetTraverser from './traversers/i3s-tileset-traverser';\nimport {TILESET_TYPE} from '../constants';\n\nexport type Tileset3DProps = {\n // loading\n throttleRequests?: boolean;\n maxRequests?: number;\n loadOptions?: LoaderOptions;\n loadTiles?: boolean;\n basePath?: string;\n maximumMemoryUsage?: number;\n\n // Metadata\n description?: string;\n attributions?: string[];\n\n // Transforms\n ellipsoid?: object;\n modelMatrix?: Matrix4;\n\n // Traversal\n maximumScreenSpaceError?: number;\n viewportTraversersMap?: any;\n updateTransforms?: boolean;\n viewDistanceScale?: number;\n\n // Callbacks\n onTileLoad?: (tile: Tile3D) => any;\n onTileUnload?: (tile: Tile3D) => any;\n onTileError?: (tile: Tile3D, message: string, url: string) => any;\n contentLoader?: (tile: Tile3D) => Promise<void>;\n onTraversalComplete?: (selectedTiles: Tile3D[]) => Tile3D[];\n};\n\ntype Props = {\n description: string;\n ellipsoid: object;\n modelMatrix: Matrix4;\n throttleRequests: boolean;\n maximumMemoryUsage: number;\n onTileLoad: (tile: Tile3D) => any;\n onTileUnload: (tile: Tile3D) => any;\n onTileError: (tile: Tile3D, message: string, url: string) => any;\n onTraversalComplete: (selectedTiles: Tile3D[]) => Tile3D[];\n maximumScreenSpaceError: number;\n viewportTraversersMap: any;\n attributions: string[];\n maxRequests: number;\n loadTiles: boolean;\n loadOptions: LoaderOptions;\n updateTransforms: boolean;\n viewDistanceScale: number;\n basePath: string;\n contentLoader?: (tile: Tile3D) => Promise<void>;\n i3s: {[key: string]: any};\n};\n\nconst DEFAULT_PROPS: Props = {\n description: '',\n\n ellipsoid: Ellipsoid.WGS84,\n // A 4x4 transformation matrix this transforms the entire tileset.\n modelMatrix: new Matrix4(),\n\n // Set to false to disable network request throttling\n throttleRequests: true,\n\n // Number of simultaneous requsts, if throttleRequests is true\n maxRequests: 64,\n\n maximumMemoryUsage: 32,\n\n /**\n * Callback. Indicates this a tile's content was loaded\n * @param tile {TileHeader}\n */\n onTileLoad: () => {},\n /**\n * Callback. Indicates this a tile's content was unloaded\n * @param tile {TileHeader}\n */\n onTileUnload: () => {},\n onTileError: () => {},\n /**\n * Callback. Allows post-process selectedTiles right after traversal.\n * @param selectedTiles {TileHeader[]}\n * @returns TileHeader[] - output array of tiles to return to deck.gl\n */\n onTraversalComplete: (selectedTiles: Tile3D[]) => selectedTiles,\n\n // Optional async tile content loader\n contentLoader: undefined,\n\n // View distance scale modifier\n viewDistanceScale: 1.0,\n\n // TODO CESIUM\n // The maximum screen space error used to drive level of detail refinement.\n maximumScreenSpaceError: 8,\n\n loadTiles: true,\n updateTransforms: true,\n viewportTraversersMap: null,\n\n loadOptions: {fetch: {}},\n\n attributions: [],\n basePath: '',\n\n i3s: {}\n};\n\n// Tracked Stats\nconst TILES_TOTAL = 'Tiles In Tileset(s)';\nconst TILES_IN_MEMORY = 'Tiles In Memory';\nconst TILES_IN_VIEW = 'Tiles In View';\nconst TILES_RENDERABLE = 'Tiles To Render';\nconst TILES_LOADED = 'Tiles Loaded';\nconst TILES_LOADING = 'Tiles Loading';\nconst TILES_UNLOADED = 'Tiles Unloaded';\nconst TILES_LOAD_FAILED = 'Failed Tile Loads';\nconst POINTS_COUNT = 'Points';\nconst TILES_GPU_MEMORY = 'Tile Memory Use';\n\nexport default class Tileset3D {\n // props: Tileset3DProps;\n options: Props;\n loadOptions: {[key: string]: any};\n\n type: string;\n tileset: {[key: string]: any};\n loader: LoaderWithParser;\n url: string;\n basePath: string;\n modelMatrix: Matrix4;\n ellipsoid: any;\n lodMetricType: string;\n lodMetricValue: number;\n refine: string;\n root: Tile3D | null;\n roots: {[key: string]: Tile3D};\n asset: {[key: string]: any};\n\n description: string;\n properties: any;\n extras: any;\n attributions: any;\n credits: any;\n\n stats: Stats;\n\n traverseCounter: number;\n geometricError: number;\n selectedTiles: Tile3D[];\n\n cartographicCenter: Vector3 | null;\n cartesianCenter: Vector3 | null;\n zoom: number;\n boundingVolume: any;\n\n // METRICS\n // The maximum amount of GPU memory (in MB) that may be used to cache tiles.\n // Tiles not in view are unloaded to enforce private\n // The total amount of GPU memory in bytes used by the tileset.\n gpuMemoryUsageInBytes: any;\n dynamicScreenSpaceErrorComputedDensity: any;\n\n // TRAVERSAL\n _traverser: TilesetTraverser;\n private _cache: TilesetCache;\n _requestScheduler: RequestScheduler;\n\n _frameNumber: number;\n private _queryParamsString: string;\n private _queryParams: any;\n private _extensionsUsed: any;\n private _tiles: {[id: string]: Tile3D};\n\n // counter for tracking tiles requests\n private _pendingCount: any;\n\n // HOLD TRAVERSAL RESULTS\n private lastUpdatedVieports: any[] | null;\n private _requestedTiles: any;\n private _emptyTiles: any;\n private frameStateData: any;\n\n maximumMemoryUsage: number;\n\n /**\n * Create a new Tileset3D\n * @param json\n * @param props\n */\n // eslint-disable-next-line max-statements\n constructor(json: any, options?: Tileset3DProps) {\n assert(json);\n\n // PUBLIC MEMBERS\n this.options = {...DEFAULT_PROPS, ...options};\n // raw data\n this.tileset = json;\n this.loader = json.loader;\n // could be 3d tiles, i3s\n this.type = json.type;\n // The url to a tileset JSON file.\n this.url = json.url;\n this.basePath = json.basePath || path.dirname(this.url);\n this.modelMatrix = this.options.modelMatrix;\n this.ellipsoid = this.options.ellipsoid;\n\n // Geometric error when the tree is not rendered at all\n this.lodMetricType = json.lodMetricType;\n this.lodMetricValue = json.lodMetricValue;\n this.refine = json.root.refine;\n\n this.loadOptions = this.options.loadOptions || {};\n\n this.root = null;\n this.roots = {};\n // view props\n this.cartographicCenter = null;\n this.cartesianCenter = null;\n this.zoom = 1;\n this.boundingVolume = null;\n\n // TRAVERSAL\n this.traverseCounter = 0;\n this.geometricError = 0;\n this._traverser = this._initializeTraverser();\n this._cache = new TilesetCache();\n this._requestScheduler = new RequestScheduler({\n throttleRequests: this.options.throttleRequests,\n maxRequests: this.options.maxRequests\n });\n // update tracker\n // increase in each update cycle\n this._frameNumber = 0;\n\n // counter for tracking tiles requests\n this._pendingCount = 0;\n\n // HOLD TRAVERSAL RESULTS\n this._tiles = {};\n this.selectedTiles = [];\n this._emptyTiles = [];\n this._requestedTiles = [];\n this.frameStateData = {};\n this.lastUpdatedVieports = null;\n\n this._queryParams = {};\n this._queryParamsString = '';\n\n // METRICS\n // The maximum amount of GPU memory (in MB) that may be used to cache tiles.\n // Tiles not in view are unloaded to enforce this.\n this.maximumMemoryUsage = this.options.maximumMemoryUsage || 32;\n // The total amount of GPU memory in bytes used by the tileset.\n this.gpuMemoryUsageInBytes = 0;\n this.stats = new Stats({id: this.url});\n this._initializeStats();\n\n // EXTRACTED FROM TILESET\n this._extensionsUsed = undefined;\n this.dynamicScreenSpaceErrorComputedDensity = 0.0; // Updated based on the camera position and direction\n // Metadata for the entire tileset\n this.extras = null;\n this.asset = {};\n this.credits = {};\n this.description = this.options.description || '';\n\n this._initializeTileSet(json);\n }\n\n /** Release resources */\n destroy(): void {\n this._destroy();\n }\n\n /** Is the tileset loaded (update needs to have been called at least once) */\n isLoaded(): boolean {\n // Check that `_frameNumber !== 0` which means that update was called at least once\n return this._pendingCount === 0 && this._frameNumber !== 0;\n }\n\n get tiles(): object[] {\n return Object.values(this._tiles);\n }\n\n get frameNumber(): number {\n return this._frameNumber;\n }\n\n get queryParams(): string {\n if (!this._queryParamsString) {\n this._queryParamsString = getQueryParamString(this._queryParams);\n }\n return this._queryParamsString;\n }\n\n setProps(props: Tileset3DProps): void {\n this.options = {...this.options, ...props};\n }\n\n /** @deprecated */\n setOptions(options: Tileset3DProps): void {\n this.options = {...this.options, ...options};\n }\n\n /**\n * Return a loadable tile url for a specific tile subpath\n * @param tilePath a tile subpath\n */\n getTileUrl(tilePath: string): string {\n const isDataUrl = tilePath.startsWith('data:');\n if (isDataUrl) {\n return tilePath;\n }\n return `${tilePath}${this.queryParams}`;\n }\n\n // TODO CESIUM specific\n hasExtension(extensionName: string): boolean {\n return Boolean(this._extensionsUsed && this._extensionsUsed.indexOf(extensionName) > -1);\n }\n\n /**\n * Update visible tiles relying on a list of viewports\n * @param viewports - list of viewports\n */\n // eslint-disable-next-line max-statements, complexity\n update(viewports: any[]): void {\n if ('loadTiles' in this.options && !this.options.loadTiles) {\n return;\n }\n if (this.traverseCounter > 0) {\n return;\n }\n if (!viewports && this.lastUpdatedVieports) {\n viewports = this.lastUpdatedVieports;\n } else {\n this.lastUpdatedVieports = viewports;\n }\n if (!(viewports instanceof Array)) {\n viewports = [viewports];\n }\n\n this._cache.reset();\n this._frameNumber++;\n this.traverseCounter = viewports.length;\n const viewportsToTraverse: string[] = [];\n // First loop to decrement traverseCounter\n for (const viewport of viewports) {\n const id = viewport.id as string;\n if (this._needTraverse(id)) {\n viewportsToTraverse.push(id);\n } else {\n this.traverseCounter--;\n }\n }\n\n // Second loop to traverse\n for (const viewport of viewports) {\n const id = viewport.id as string;\n if (!this.roots[id]) {\n this.roots[id] = this._initializeTileHeaders(this.tileset, null);\n }\n\n if (!viewportsToTraverse.includes(id)) {\n continue; // eslint-disable-line no-continue\n }\n const frameState = getFrameState(viewport, this._frameNumber);\n this._traverser.traverse(this.roots[id], frameState, this.options);\n }\n }\n\n /**\n * Check if traversal is needed for particular viewport\n * @param {string} viewportId - id of a viewport\n * @return {boolean}\n */\n _needTraverse(viewportId: string): boolean {\n let traverserId = viewportId;\n if (this.options.viewportTraversersMap) {\n traverserId = this.options.viewportTraversersMap[viewportId];\n }\n if (traverserId !== viewportId) {\n return false;\n }\n\n return true;\n }\n\n /**\n * The callback to post-process tiles after traversal procedure\n * @param frameState - frame state for tile culling\n */\n _onTraversalEnd(frameState: FrameState): void {\n const id = frameState.viewport.id;\n if (!this.frameStateData[id]) {\n this.frameStateData[id] = {selectedTiles: [], _requestedTiles: [], _emptyTiles: []};\n }\n const currentFrameStateData = this.frameStateData[id];\n const selectedTiles = Object.values(this._traverser.selectedTiles);\n currentFrameStateData.selectedTiles = selectedTiles;\n currentFrameStateData._requestedTiles = Object.values(this._traverser.requestedTiles);\n currentFrameStateData._emptyTiles = Object.values(this._traverser.emptyTiles);\n\n this.traverseCounter--;\n if (this.traverseCounter > 0) {\n return;\n }\n\n this._updateTiles();\n }\n\n /**\n * Update tiles relying on data from all traversers\n */\n _updateTiles(): void {\n this.selectedTiles = [];\n this._requestedTiles = [];\n this._emptyTiles = [];\n\n for (const frameStateKey in this.frameStateData) {\n const frameStateDataValue = this.frameStateData[frameStateKey];\n this.selectedTiles = this.selectedTiles.concat(frameStateDataValue.selectedTiles);\n this._requestedTiles = this._requestedTiles.concat(frameStateDataValue._requestedTiles);\n this._emptyTiles = this._emptyTiles.concat(frameStateDataValue._emptyTiles);\n }\n\n this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);\n\n for (const tile of this.selectedTiles) {\n this._tiles[tile.id] = tile;\n }\n\n this._loadTiles();\n this._unloadTiles();\n this._updateStats();\n }\n\n _tilesChanged(oldSelectedTiles, selectedTiles) {\n if (oldSelectedTiles.length !== selectedTiles.length) {\n return true;\n }\n const set1 = new Set(oldSelectedTiles.map((t) => t.id));\n const set2 = new Set(selectedTiles.map((t) => t.id));\n let changed = oldSelectedTiles.filter((x) => !set2.has(x.id)).length > 0;\n changed = changed || selectedTiles.filter((x) => !set1.has(x.id)).length > 0;\n return changed;\n }\n\n _loadTiles() {\n // Sort requests by priority before making any requests.\n // This makes it less likely this requests will be cancelled after being issued.\n // requestedTiles.sort((a, b) => a._priority - b._priority);\n for (const tile of this._requestedTiles) {\n if (tile.contentUnloaded) {\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this._loadTile(tile);\n }\n }\n }\n\n _unloadTiles() {\n // unload tiles from cache when hit maximumMemoryUsage\n this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));\n }\n\n _updateStats() {\n let tilesRenderable = 0;\n let pointsRenderable = 0;\n for (const tile of this.selectedTiles) {\n if (tile.contentAvailable && tile.content) {\n tilesRenderable++;\n if (tile.content.pointCount) {\n pointsRenderable += tile.content.pointCount;\n }\n }\n }\n\n this.stats.get(TILES_IN_VIEW).count = this.selectedTiles.length;\n this.stats.get(TILES_RENDERABLE).count = tilesRenderable;\n this.stats.get(POINTS_COUNT).count = pointsRenderable;\n }\n\n _initializeTileSet(tilesetJson) {\n this.root = this._initializeTileHeaders(tilesetJson, null);\n\n // TODO CESIUM Specific\n if (this.type === TILESET_TYPE.TILES3D) {\n this._initializeCesiumTileset(tilesetJson);\n }\n\n if (this.type === TILESET_TYPE.I3S) {\n this._initializeI3STileset();\n }\n // Calculate cartographicCenter & zoom props to help apps center view on tileset\n this._calculateViewProps();\n }\n\n // Called during initialize Tileset to initialize the tileset's cartographic center (longitude, latitude) and zoom.\n _calculateViewProps() {\n const root = this.root as Tile3D;\n assert(root);\n const {center} = root.boundingVolume;\n // TODO - handle all cases\n if (!center) {\n // eslint-disable-next-line\n console.warn('center was not pre-calculated for the root tile');\n this.cartographicCenter = new Vector3();\n this.zoom = 1;\n return;\n }\n this.cartographicCenter = Ellipsoid.WGS84.cartesianToCartographic(center, new Vector3());\n this.cartesianCenter = center;\n this.zoom = getZoomFromBoundingVolume(root.boundingVolume);\n }\n\n _initializeStats() {\n this.stats.get(TILES_TOTAL);\n this.stats.get(TILES_LOADING);\n this.stats.get(TILES_IN_MEMORY);\n this.stats.get(TILES_IN_VIEW);\n this.stats.get(TILES_RENDERABLE);\n this.stats.get(TILES_LOADED);\n this.stats.get(TILES_UNLOADED);\n this.stats.get(TILES_LOAD_FAILED);\n this.stats.get(POINTS_COUNT, 'memory');\n this.stats.get(TILES_GPU_MEMORY, 'memory');\n }\n\n // Installs the main tileset JSON file or a tileset JSON file referenced from a tile.\n // eslint-disable-next-line max-statements\n _initializeTileHeaders(tilesetJson, parentTileHeader) {\n // A tileset JSON file referenced from a tile may exist in a different directory than the root tileset.\n // Get the basePath relative to the external tileset.\n const rootTile = new Tile3D(this, tilesetJson.root, parentTileHeader); // resource\n\n // If there is a parentTileHeader, add the root of the currently loading tileset\n // to parentTileHeader's children, and update its depth.\n if (parentTileHeader) {\n parentTileHeader.children.push(rootTile);\n rootTile.depth = parentTileHeader.depth + 1;\n }\n\n // Cesium 3d tiles knows the hierarchy beforehand\n if (this.type === TILESET_TYPE.TILES3D) {\n const stack: Tile3D[] = [];\n stack.push(rootTile);\n\n while (stack.length > 0) {\n const tile = stack.pop() as Tile3D;\n this.stats.get(TILES_TOTAL).incrementCount();\n const children = tile.header.children || [];\n for (const childHeader of children) {\n const childTile = new Tile3D(this, childHeader, tile);\n tile.children.push(childTile);\n childTile.depth = tile.depth + 1;\n stack.push(childTile);\n }\n }\n }\n\n return rootTile;\n }\n\n _initializeTraverser() {\n let TraverserClass;\n const type = this.type;\n switch (type) {\n case TILESET_TYPE.TILES3D:\n TraverserClass = Tileset3DTraverser;\n break;\n case TILESET_TYPE.I3S:\n TraverserClass = I3SetTraverser;\n break;\n default:\n TraverserClass = TilesetTraverser;\n }\n\n return new TraverserClass({\n basePath: this.basePath,\n onTraversalEnd: this._onTraversalEnd.bind(this)\n });\n }\n\n _destroyTileHeaders(parentTile) {\n this._destroySubtree(parentTile);\n }\n\n async _loadTile(tile) {\n let loaded;\n try {\n this._onStartTileLoading();\n loaded = await tile.loadContent();\n } catch (error) {\n this._onTileLoadError(tile, error);\n } finally {\n this._onEndTileLoading();\n this._onTileLoad(tile, loaded);\n }\n }\n\n _onTileLoadError(tile, error) {\n this.stats.get(TILES_LOAD_FAILED).incrementCount();\n\n const message = error.message || error.toString();\n const url = tile.url;\n // TODO - Allow for probe log to be injected instead of console?\n console.error(`A 3D tile failed to load: ${tile.url} ${message}`); // eslint-disable-line\n this.options.onTileError(tile, message, url);\n }\n\n _onTileLoad(tile, loaded) {\n if (!loaded) {\n return;\n }\n\n // add coordinateOrigin and modelMatrix to tile\n if (tile && tile.content) {\n calculateTransformProps(tile, tile.content);\n }\n\n this._addTileToCache(tile);\n this.options.onTileLoad(tile);\n }\n\n _onStartTileLoading() {\n this._pendingCount++;\n this.stats.get(TILES_LOADING).incrementCount();\n }\n\n _onEndTileLoading() {\n this._pendingCount--;\n this.stats.get(TILES_LOADING).decrementCount();\n }\n\n _addTileToCache(tile) {\n this._cache.add(this, tile, (tileset) => tileset._updateCacheStats(tile));\n }\n\n _updateCacheStats(tile) {\n this.stats.get(TILES_LOADED).incrementCount();\n this.stats.get(TILES_IN_MEMORY).incrementCount();\n\n // Good enough? Just use the raw binary ArrayBuffer's byte length.\n this.gpuMemoryUsageInBytes += tile.content.byteLength || 0;\n this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;\n }\n\n _unloadTile(tile) {\n this.gpuMemoryUsageInBytes -= (tile.content && tile.content.byteLength) || 0;\n\n this.stats.get(TILES_IN_MEMORY).decrementCount();\n this.stats.get(TILES_UNLOADED).incrementCount();\n this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;\n\n this.options.onTileUnload(tile);\n tile.unloadContent();\n }\n\n // Traverse the tree and destroy all tiles\n _destroy() {\n const stack: Tile3D[] = [];\n\n if (this.root) {\n stack.push(this.root);\n }\n\n while (stack.length > 0) {\n const tile: Tile3D = stack.pop() as Tile3D;\n\n for (const child of tile.children) {\n stack.push(child);\n }\n\n this._destroyTile(tile);\n }\n this.root = null;\n }\n\n // Traverse the tree and destroy all sub tiles\n _destroySubtree(tile) {\n const root = tile;\n const stack: Tile3D[] = [];\n stack.push(root);\n while (stack.length > 0) {\n tile = stack.pop();\n for (const child of tile.children) {\n stack.push(child);\n }\n if (tile !== root) {\n this._destroyTile(tile);\n }\n }\n root.children = [];\n }\n\n _destroyTile(tile) {\n this._cache.unloadTile(this, tile);\n this._unloadTile(tile);\n tile.destroy();\n }\n\n _initializeCesiumTileset(tilesetJson) {\n this.asset = tilesetJson.asset;\n if (!this.asset) {\n throw new Error('Tileset must have an asset property.');\n }\n if (this.asset.version !== '0.0' && this.asset.version !== '1.0') {\n throw new Error('The tileset must be 3D Tiles version 0.0 or 1.0.');\n }\n\n // Note: `asset.tilesetVersion` is version of the tileset itself (not the version of the 3D TILES standard)\n // We add this version as a `v=1.0` query param to fetch the right version and not get an older cached version\n if ('tilesetVersion' in this.asset) {\n this._queryParams.v = this.asset.tilesetVersion;\n }\n\n // TODO - ion resources have a credits property we can use for additional attribution.\n this.credits = {\n attributions: this.options.attributions || []\n };\n this.description = this.options.description || '';\n\n // Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.\n this.properties = tilesetJson.properties;\n this.geometricError = tilesetJson.geometricError;\n this._extensionsUsed = tilesetJson.extensionsUsed;\n // Returns the extras property at the top of the tileset JSON (application specific metadata).\n this.extras = tilesetJson.extras;\n }\n\n _initializeI3STileset() {\n if (this.loadOptions.i3s && 'token' in this.loadOptions.i3s) {\n this._queryParams.token = this.loadOptions.i3s.token;\n }\n }\n}\n\nfunction getQueryParamString(queryParams): string {\n const queryParamStrings: string[] = [];\n for (const key of Object.keys(queryParams)) {\n queryParamStrings.push(`${key}=${queryParams[key]}`);\n }\n switch (queryParamStrings.length) {\n case 0:\n return '';\n case 1:\n return `?${queryParamStrings[0]}`;\n default:\n return `?${queryParamStrings.join('&')}`;\n }\n}\n"],"sourceRoot":""}