@loaders.gl/3d-tiles 3.1.0-alpha.2 → 4.0.0-alpha.3

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 (27) hide show
  1. package/dist/bundle.js +2 -4
  2. package/dist/bundle.js.map +1 -1
  3. package/dist/lib/classes/tile-3d-batch-table-hierarchy.js +1 -1
  4. package/dist/lib/classes/tile-3d-batch-table-hierarchy.js.map +1 -1
  5. package/dist/lib/classes/tile-3d-batch-table.js +4 -4
  6. package/dist/lib/classes/tile-3d-batch-table.js.map +1 -1
  7. package/dist/lib/ion/ion.js +6 -6
  8. package/dist/lib/ion/ion.js.map +1 -1
  9. package/dist/lib/parsers/helpers/parse-3d-tile-gltf-view.js +2 -2
  10. package/dist/lib/parsers/helpers/parse-3d-tile-gltf-view.js.map +1 -1
  11. package/dist/lib/parsers/helpers/parse-3d-tile-header.js +1 -1
  12. package/dist/lib/parsers/helpers/parse-3d-tile-header.js.map +1 -1
  13. package/dist/lib/parsers/helpers/parse-3d-tile-tables.js +1 -1
  14. package/dist/lib/parsers/helpers/parse-3d-tile-tables.js.map +1 -1
  15. package/dist/lib/parsers/helpers/parse-utils.js +1 -5
  16. package/dist/lib/parsers/helpers/parse-utils.js.map +1 -1
  17. package/dist/lib/parsers/parse-3d-tile-header.js +1 -1
  18. package/dist/lib/parsers/parse-3d-tile-header.js.map +1 -1
  19. package/dist/lib/parsers/parse-3d-tile-instanced-model.js +1 -1
  20. package/dist/lib/parsers/parse-3d-tile-instanced-model.js.map +1 -1
  21. package/dist/lib/parsers/parse-3d-tile.js +1 -1
  22. package/dist/lib/parsers/parse-3d-tile.js.map +1 -1
  23. package/dist/lib/utils/version.js +1 -1
  24. package/package.json +11 -9
  25. package/src/bundle.ts +2 -3
  26. package/dist/dist.min.js +0 -2
  27. 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/node_modules/gl-matrix/esm/common.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/validators.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/vec3.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/common.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/vec4.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/mat4.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/assert.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/mat3.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/vec2.js","webpack:///../worker-utils/src/lib/env-utils/globals.ts","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/base/math-array.js","webpack:///../images/src/lib/utils/globals.ts","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/base/vector.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/base/matrix.js","webpack:///(webpack)/buildin/global.js","webpack:////home/user/apps/loaders.gl/node_modules/process/browser.js","webpack:///./src/bundle.ts","webpack:///../loader-utils/src/lib/path-utils/path.ts","webpack:///../tiles/src/constants.ts","webpack:///./src/lib/constants.js","webpack:///../loader-utils/src/lib/env-utils/assert.ts","webpack:///./src/lib/parsers/helpers/parse-utils.js","webpack:///../draco/src/lib/utils/version.ts","webpack:///../draco/src/draco-loader.ts","webpack:///../schema/src/lib/schema/impl/schema.ts","webpack:///../schema/src/lib/utils/assert.ts","webpack:///../schema/src/lib/schema/impl/field.ts","webpack:///../schema/src/lib/schema/impl/enum.ts","webpack:///../schema/src/lib/schema/impl/type.ts","webpack:///../schema/src/category/mesh/deduce-mesh-schema.ts","webpack:///../schema/src/lib/arrow/arrow-like-type-utils.ts","webpack:///../draco/src/lib/utils/get-draco-schema.ts","webpack:///../draco/src/lib/draco-parser.ts","webpack:///../schema/src/category/mesh/mesh-utils.ts","webpack:///../worker-utils/src/lib/library-utils/library-utils.ts","webpack:///../worker-utils/src/lib/env-utils/assert.ts","webpack:///../draco/src/lib/draco-module-loader.ts","webpack:///../draco/src/index.ts","webpack:///../math/src/geometry/constants.ts","webpack:///../math/src/geometry/gl/gl-type.ts","webpack:///./src/lib/classes/tile-3d-feature-table.js","webpack:///./src/lib/classes/helpers/tile-3d-accessor-utils.js","webpack:///./src/lib/classes/tile-3d-batch-table-hierarchy.js","webpack:///./src/lib/classes/tile-3d-batch-table.js","webpack:///./src/lib/parsers/helpers/parse-3d-tile-header.js","webpack:///./src/lib/parsers/helpers/parse-3d-tile-tables.js","webpack:///../math/src/geometry/colors/rgb565.ts","webpack:///./src/lib/parsers/helpers/normalize-3d-tile-colors.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/vector2.js","webpack:///../math/src/geometry/utils/assert.ts","webpack:///../math/src/geometry/compression/attribute-compression.ts","webpack:///./src/lib/parsers/helpers/normalize-3d-tile-normals.js","webpack:///./src/lib/parsers/helpers/normalize-3d-tile-positions.js","webpack:///./src/lib/parsers/parse-3d-tile-point-cloud.js","webpack:///../images/src/lib/utils/assert.js","webpack:///../images/src/lib/category-api/image-type.ts","webpack:///../images/src/lib/category-api/parsed-image-api.ts","webpack:///../images/src/lib/parsers/svg-utils.ts","webpack:///../images/src/lib/parsers/parse-to-image.ts","webpack:///../images/src/lib/parsers/parse-to-image-bitmap.ts","webpack:///../images/src/lib/category-api/binary-image-api.ts","webpack:///../images/src/image-loader.ts","webpack:///../images/src/lib/utils/version.ts","webpack:///../images/src/lib/parsers/parse-image.ts","webpack:///../images/src/lib/parsers/parse-to-node-image.ts","webpack:///../loader-utils/src/lib/binary-utils/get-first-characters.ts","webpack:///../loader-utils/src/lib/parser-utils/parse-json.ts","webpack:///../loader-utils/src/lib/binary-utils/array-buffer-utils.ts","webpack:///../gltf/src/lib/utils/assert.js","webpack:///../gltf/src/lib/gltf-utils/resolve-url.ts","webpack:///../gltf/src/lib/gltf-utils/get-typed-array.ts","webpack:///../loader-utils/src/lib/binary-utils/memory-copy-utils.ts","webpack:///../gltf/src/lib/gltf-utils/gltf-utils.ts","webpack:///../gltf/src/lib/api/gltf-scenegraph.ts","webpack:///../gltf/src/lib/gltf-utils/gltf-attribute-utils.ts","webpack:///../gltf/src/lib/extensions/KHR_draco_mesh_compression.ts","webpack:///../gltf/src/lib/gltf-utils/gltf-constants.ts","webpack:///../gltf/src/lib/extensions/KHR_materials_unlit.ts","webpack:///../gltf/src/lib/extensions/KHR_lights_punctual.ts","webpack:///../gltf/src/lib/extensions/KHR_techniques_webgl.ts","webpack:///../gltf/src/lib/extensions/gltf-extensions.ts","webpack:///../gltf/src/lib/api/normalize-gltf-v1.js","webpack:///../gltf/src/lib/extensions/KHR_binary_gltf.ts","webpack:///../gltf/src/lib/api/post-process-gltf.js","webpack:///../gltf/src/lib/parsers/parse-glb.ts","webpack:///../gltf/src/lib/parsers/parse-gltf.ts","webpack:///../gltf/src/gltf-loader.ts","webpack:///../gltf/src/lib/utils/version.js","webpack:///./src/lib/parsers/helpers/parse-3d-tile-gltf-view.js","webpack:///./src/lib/parsers/parse-3d-tile-batched-model.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/constants.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/type-utils.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/scale-to-geodetic-surface.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/ellipsoid-transform.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/geospatial/dist/esm/ellipsoid/ellipsoid.js","webpack:///./src/lib/parsers/parse-3d-tile-instanced-model.js","webpack:///./src/lib/parsers/parse-3d-tile.js","webpack:///./src/lib/parsers/parse-3d-tile-composite.js","webpack:///./src/lib/parsers/parse-3d-tile-header.js","webpack:///./src/tiles-3d-loader.ts","webpack:///./src/lib/utils/version.js","webpack:///../loader-utils/src/lib/path-utils/file-aliases.ts","webpack:///../core/src/javascript-utils/is-type.ts","webpack:///../core/src/lib/utils/mime-type-utils.ts","webpack:///../core/src/lib/utils/resource-utils.ts","webpack:///../core/src/lib/utils/response-utils.ts","webpack:///../core/src/lib/fetch/fetch-file.ts","webpack:///./src/lib/ion/ion.js","webpack:///./src/cesium-ion-loader.ts","webpack:///./src/lib/encoders/helpers/encode-3d-tile-header.js","webpack:///../loader-utils/src/lib/binary-utils/binary-copy-utils.ts","webpack:///../loader-utils/src/lib/binary-utils/encode-utils.ts","webpack:///./src/lib/encoders/encode-3d-tile-point-cloud.js","webpack:///./src/lib/encoders/encode-3d-tile.js","webpack:///./src/lib/encoders/encode-3d-tile-composite.js","webpack:///./src/lib/encoders/encode-3d-tile-batched-model.js","webpack:///./src/lib/encoders/encode-3d-tile-instanced-model.js","webpack:///./src/tile-3d-writer.ts","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/vector3.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/lib/math-utils.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/matrix4.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/matrix3.js","webpack:////home/user/apps/loaders.gl/node_modules/gl-matrix/esm/quat.js","webpack:////home/user/apps/loaders.gl/node_modules/@math.gl/core/dist/esm/classes/quaternion.js"],"names":["root","factory","exports","module","define","amd","a","i","window","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","EPSILON","ARRAY_TYPE","Float32Array","Array","RANDOM","Math","random","PI","hypot","y","arguments","length","sqrt","checkNumber","Number","isFinite","Error","concat","checkVector","v","callerName","debug","validateVector","map","deprecated","method","version","console","warn","out","x","z","fromValues","normalize","len","dot","b","cross","ax","ay","az","bx","by","bz","transformMat4","w","transformMat3","transformQuat","q","qx","qy","qz","qw","uvx","uvy","uvz","uuvx","uuvy","uuvz","w2","rotateX","rad","cos","sin","rotateY","rotateZ","angle","mag","cosine","acos","min","max","vec","RADIANS_TO_DEGREES","DEGREES_TO_RADIANS","config","formatValue","precision","round","parseFloat","toPrecision","isArray","ArrayBuffer","isView","DataView","func","result","array","clone","toRadians","degrees","radians","toDegrees","clamp","equals","epsilon","oldEpsilon","abs","printTypes","printDegrees","printRowMajor","copy","set","add","scale","squaredLength","lerp","aw","ix","iy","iz","iw","exactEquals","a0","a1","a2","a3","b0","b1","b2","b3","transpose","a01","a02","a03","a12","a13","a23","invert","a00","a10","a11","a20","a21","a22","a30","a31","a32","a33","b00","b01","b02","b03","b04","b05","b06","b07","b08","b09","b10","b11","det","determinant","multiply","translate","rotate","axis","b12","b20","b21","b22","fromQuat","x2","y2","z2","xx","yx","yy","zx","zy","zz","wx","wy","wz","frustum","left","right","bottom","top","near","far","rl","tb","nf","perspective","fovy","aspect","f","tan","Infinity","ortho","lr","bt","lookAt","eye","center","up","x0","x1","y0","y1","z0","z1","eyex","eyey","eyez","upx","upy","upz","centerx","centery","centerz","identity","assert","condition","message","vec2_transformMat4AsVector","vec3_transformMat4AsVector","vec3_transformMat2","vec4_transformMat3","transformMat2","transformMat2d","globals","self","global","document","global_","isBrowser","process","String","browser","isWorker","importScripts","matches","orientation","exec","MathArray","cls","ExtendableBuiltin","instance","Reflect","construct","from","setPrototypeOf","getPrototypeOf","this","constructor","writable","configurable","__proto__","_extendableBuiltin","arrayOrObject","fromObject","offset","ELEMENTS","check","toArray","toObject","target","to","formatString","opts","string","undefined","ai","vector","minVector","maxVector","vectors","subtract","addScalar","scalar","validate","valid","Vector","lengthSquared","mathArray","distanceSquared","dist","product","magnitude","distance","multiplyScalar","Matrix","row","RANK","col","columnIndex","fill","firstIndex","columnVector","g","Function","e","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","nextTick","args","push","apply","title","env","argv","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","moduleExports","require","_global","loaders","assign","dirname","url","slashIndex","lastIndexOf","substr","join","parts","part","index","replace","RegExp","TILE_REFINEMENT","TILE_TYPE","TILESET_TYPE","LOD_METRIC_TYPE","TILE3D_TYPE","COMPOSITE","POINT_CLOUD","BATCHED_3D_MODEL","INSTANCED_3D_MODEL","GEOMETRY","VECTOR","MAGIC_ARRAY","keys","BATCHED_MODEL","INSTANCED_MODEL","getStringFromArrayBuffer","arrayBuffer","byteOffset","byteLength","textDecoder","TextDecoder","typedArray","Uint8Array","decode","DracoLoader","id","shapes","worker","extensions","mimeTypes","binary","tests","options","draco","decoderType","WebAssembly","libraryPath","extraAttributes","attributeNameEntry","Schema","fields","metadata","usedNames","field","checkNames","Map","compareTo","other","select","columnNames","nameMap","selectedFields","filter","selectAt","columnIndices","Boolean","schemaOrFields","otherSchema","mergeMaps","fieldMap","mergedFields","values","m1","m2","Field","type","nullable","typeId","toString","Type","DataType","Null","Int","Float","Binary","Utf8","Bool","Decimal","Date","Time","Timestamp","Interval","List","Struct","Union","FixedSizeBinary","FixedSizeList","Dictionary","NONE","isSigned","bitWidth","super","Int8","Int16","Int32","Uint8","Uint16","Uint32","Precision","Float32","Float64","listSize","child","children","valueType","deduceMeshField","attributeName","attribute","optionalMetadata","Int8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float64Array","getArrowTypeFromTypedArray","byteStride","normalized","makeMeshAttributeMetadata","size","getArrowFieldFromAttribute","loaderData","makeMetadata","metadataMap","JSON","stringify","DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP","POSITION","NORMAL","COLOR","TEX_COORD","DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP","1","2","3","4","5","6","9","DracoParser","decoder","Decoder","metadataQuerier","MetadataQuerier","destroy","parseSync","buffer","DecoderBuffer","Init","_disableAttributeTransforms","geometry_type","GetEncodedGeometryType","dracoGeometry","TRIANGULAR_MESH","Mesh","PointCloud","dracoStatus","DecodeBufferToMesh","DecodeBufferToPointCloud","ok","ptr","error_msg","_getDracoLoaderData","geometry","_getMeshData","boundingBox","attributes","minX","minY","minZ","maxX","maxY","maxZ","positions","getMeshBoundingBox","schema","indices","namedLoaderDataAttributes","dracoAttribute","transformAttributesLoaderData","indicesField","getDracoSchema","loader","header","vertexCount","num_points","_getTopLevelMetadata","_getDracoAttributes","num_attributes","num_faces","dracoAttributes","attributeId","GetAttribute","_getAttributeMetadata","unique_id","attribute_type","data_type","num_components","byte_offset","byte_stride","attribute_index","quantization","_getQuantizationTransform","quantization_transform","octahedron","_getOctahedronTransform","octahedron_transform","_getMeshAttributes","topology","_getTriangleStripIndices","_getTriangleListIndices","loaderAttribute","_deduceAttributeName","_getAttributeValues","numIndices","_malloc","GetTrianglesUInt32Array","HEAPF32","slice","_free","dracoArray","DracoInt32Array","GetTriangleStripsFromMesh","numValues","intArray","GetValue","getUint32Array","TypedArrayCtor","numComponents","BYTES_PER_ELEMENT","dataType","attributeType","DT_FLOAT32","DT_INT8","DT_INT16","DT_INT32","DT_UINT8","DT_UINT16","DT_UINT32","DT_INVALID","getDracoDataType","GetAttributeDataArrayForAllPoints","uniqueId","attributeUniqueId","entries","thisAttributeType","dracoAttributeConstant","entryName","dracoMetadata","GetMetadata","_getDracoMetadata","GetAttributeMetadata","numEntries","NumEntries","entryIndex","GetEntryName","_getDracoMetadataField","GetIntEntryArray","getInt32Array","int","GetIntEntry","GetStringEntry","double","GetDoubleEntry","quantizedAttributes","octahedronAttributes","skipAttributes","dracoAttributeName","SkipAttributeTransform","includes","transform","AttributeQuantizationTransform","InitFromAttribute","quantization_bits","range","min_values","min_value","loadLibraryPromises","async","loadLibrary","libraryUrl","moduleName","library","startsWith","CDN","getLibraryUrl","endsWith","response","fetch","node","scriptSource","eval","script","createElement","appendChild","createTextNode","text","body","loadLibraryFromString","loadLibraryFromFile","loadDecoderPromise","loadDracoDecoderModule","draco3d","createDecoderModule","then","DracoDecoderModule","wasmBinary","Promise","all","globalThis","resolve","onModuleLoaded","initializeDracoDecoder","loadDracoDecoder","DracoWorkerLoader","parse","dracoParser","GL_TYPE","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","DOUBLE","GL","POINTS","LINES","LINE_LOOP","LINE_STRIP","TRIANGLES","TRIANGLE_STRIP","TRIANGLE_FAN","GL_TYPE_TO_ARRAY_TYPE","NAME_TO_GL_TYPE","GLType","arrayOrType","glType","UNSIGNED_SHORT_5_6_5","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","ArrayType","getArrayType","getByteSize","Tile3DFeatureTable","featureTableJson","featureTableBinary","json","featuresLength","_cachedTypedArrays","getExtension","extensionName","hasProperty","propertyName","getGlobalProperty","componentType","componentLength","jsonValue","_getTypedArrayFromBinary","getPropertyArray","fromName","_getTypedArrayFromArray","getProperty","featureId","count","cachedTypedArrays","createTypedArray","COMPONENTS_PER_ATTRIBUTE","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","UNPACKER","PACKER","defined","initializeHierarchy","batchTable","jsonHeader","binaryBody","hierarchy","legacyHierarchy","HIERARCHY","hierarchyJson","classId","binaryAccessor","instancesLength","classes","parentIndexes","classIds","parentCounts","parentIds","parentIdsLength","defaultValue","AttributeType","getBinaryAccessor","createArrayBufferView","classesLength","classInstancesLength","properties","instances","binaryProperties","getBinaryProperties","combine","classCounts","classIndexes","validateInstance","stack","validateHierarchy","initializeHierarchyValues","traverseHierarchy","instanceIndex","endConditionCallback","visited","scratchVisited","visitedMarker","scratchStack","pop","parentCount","parentIndex","parentId","traverseHierarchyMultipleParents","hasParent","traverseHierarchySingleParent","indexOf","IGNORED_PROPERTY_FIELDS","extras","Tile3DBatchTableParser","featureCount","_extensions","_properties","_binaryProperties","_initializeBinaryProperties","_hierarchy","memorySizeInBytes","isClass","batchId","className","_checkBatchId","isExactClass","getExactClassName","_hasPropertyInHierarchy","getPropertyNames","results","propertyNames","_getPropertyNamesInHierarchy","binaryProperty","_getBinaryProperty","propertyValues","hierarchyProperty","_getHierarchyProperty","setProperty","_setBinaryProperty","_setHierarchyProperty","unpack","pack","_initializeBinaryProperty","tile3DAccessor","accessor","unpacker","packer","createTypedArrayFromAccessor","componentCount","instanceClass","indexInClass","parse3DTileHeaderSync","tile","view","magic","getUint32","parse3DTileTablesHeaderSync","batchLength","featureTableJsonByteLength","featureTableBinaryByteLength","batchTableJsonByteLength","batchTableBinaryByteLength","SIZEOF_UINT32","parse3DTileTablesSync","BATCH_LENGTH","featureTableString","parse3DTileFeatureTable","batchTableString","batchTableJson","batchTableBinary","parse3DTileBatchTable","decodeRGB565","rgb565","r5","g6","b5","normalize3DTileColorAttribute","colors","batchIds","isRGB565","pointCount","colorArray","Uint8ClampedArray","color","atan2","matrix4","transformAsPoint","vec2","matrix3","matrix2x3","matrix2","Vector2","Vector3","fromSNorm","rangeMaximum","signNotZero","octDecodeInRange","rangeMax","oldVX","octDecode","scratchNormal","normalize3DTilePositionAttribute","isQuantized","decodeQuantizedPositions","scratchPosition","decodedArray","quantizedRange","quantizedVolumeScale","quantizedVolumeOffset","parsePointCloud3DTile","context","normals","isTranslucent","isOctEncoded16P","initializeTile","featureTable","pointsLength","rtcCenter","batchFeatureLength","Tile3DBatchTable","parseBatchIds","parsePointCloudTables","dracoBuffer","dracoFeatureTableProperties","dracoBatchTableProperties","batchTableDraco","featureTableDraco","dracoByteOffset","dracoByteLength","hasPositions","hasColors","RGB","RGBA","hasNormals","hasBatchIds","BATCH_ID","dracoData","featureTableProperties","batchTableProperties","dequantizeInShader","dracoOptions","data","decodedPositions","decodedColors","COLOR_0","decodedNormals","decodedBatchIds","isQuantizedDraco","isOctEncodedDraco","minValues","quantizationBits","octEncodedRange","batchTableAttributes","toLowerCase","loadDraco","parseDraco","parsePositions","constantRGBA","parseColors","normalize3DTileNormalAttribute","parseNormals","_parseImageNode","IMAGE_SUPPORTED","Image","IMAGE_BITMAP_SUPPORTED","ImageBitmap","NODE_IMAGE_SUPPORTED","DATA_SUPPORTED","getImageType","image","format","getImageTypeOrNull","getImageData","canvas","getContext","width","height","drawImage","SVG_DATA_URL_PATTERN","SVG_URL_PATTERN","isSVG","test","getBlob","Blob","parseToImage","blobOrDataUrl","xmlText","unescape","encodeURIComponent","error","btoa","getBlobOrSVGDataUrl","URL","webkitURL","objectUrl","createObjectURL","src","reject","onload","onerror","err","loadToImage","revokeObjectURL","EMPTY_OBJECT","imagebitmapOptionsSupported","parseToImageBitmap","blob","imagebitmapOptions","imagebitmap","isEmptyObject","createImageBitmap","safeCreateImageBitmap","getBinaryImageMetadata","binaryData","dataView","toDataView","mimeType","getPngMetadata","getUint16","getUint8","tableMarkers","sofMarkers","Set","getJpegMarkers","has","getJpegMetadata","getGifMetadata","getBmpMetadata","ImageLoader","imageType","getDefaultImageType","isImageTypeSupported","getLoadableImageType","parseToNodeImage","getMagicString","fromCharCode","parseJSON","_","getFirstCharacters","sliceArrayBuffer","subArray","subarray","resolveUrl","baseUrl","baseUri","uri","getTypedArrayForBufferView","buffers","bufferViewIndex","bufferView","bufferViews","binChunk","padToNBytes","padding","copyToArray","source","targetOffset","sourceArray","srcByteOffset","srcByteLength","TYPES","ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT","ARRAY_TO_COMPONENT_TYPE","ATTRIBUTE_TYPE_TO_COMPONENTS","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","5120","5121","5122","5123","5125","5126","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","getAccessorTypeFromSize","getComponentTypeFromArray","getAccessorArrayTypeAndLength","components","bytesPerComponent","DEFAULT_GLTF_JSON","asset","generator","GLTFScenegraph","gltf","sourceBuffers","getApplicationData","getExtraData","isExtension","getUsedExtensions","find","getRequiredExtension","getRequiredExtensions","extensionsRequired","extensionsUsed","getObjectExtension","getScene","getObject","getNode","getSkin","getMesh","getMaterial","getAccessor","getTexture","getSampler","getImage","getBufferView","getBuffer","bufferIndex","getTypedArrayForAccessor","getTypedArrayForImageData","addApplicationData","addExtraData","addObjectExtension","registerUsedExtension","setObjectExtension","removeObjectExtension","extension","addExtension","extensionData","addRequiredExtension","registerRequiredExtension","ext","removeExtension","_removeStringFromArray","setDefaultScene","sceneIndex","scene","addScene","nodeIndices","scenes","nodes","addNode","meshIndex","matrix","nodeData","mesh","addMesh","material","glTFMesh","primitives","_addAttributes","indicesAccessor","_addIndices","meshes","addPointCloud","addImage","imageData","mimeTypeOpt","glTFImage","addBufferView","images","glTFBufferView","addAccessor","glTFAccessor","accessors","addBinaryBuffer","sourceBuffer","minMax","_getAccessorMinMax","accessorDefaults","addTexture","texture","imageIndex","glTFTexture","textures","addMaterial","pbrMaterialInfo","materials","createBinaryChunk","totalByteLength","targetArray","dstByteOffset","found","splice","attributeKey","attributeData","attrName","_getGltfAttributeName","initValues","componentIndex","getGLTFAccessor","convertTypedArrays","toTypedArray","getAccessorData","gltfData","decompressMeshes","scenegraph","Scenegraph","promises","primitive","makeMeshPrimitiveIterator","decompressPrimitive","encode","compressMesh","dracoExtension","bufferCopy","decodedData","decodedAttributes","getGLTFAccessors","decodedAttribute","accessorIndex","checkPrimitive","DracoWriter","compressedData","encodeSync","fauxAccessors","_addFauxAttributes","gltfScenegraph","KHR_materials_unlit","unlit","lights","nodeExtension","light","techniques","techniquesExtension","programs","shaders","forEach","shader","code","program","fragmentShader","vertexShader","technique","resolveTechniques","materialExtension","resolveValues","uniforms","uniform","EXTENSIONS","KHR_draco_mesh_compression","KHR_lights_punctual","KHR_techniques_webgl","GLTF_ARRAYS","animations","samplers","skins","GLTF_KEYS","sampler","skin","GLTFV1Normalizer","idToIndexMap","_addAsset","_convertTopLevelObjectsToArrays","KHR_binary_glTF","_convertObjectIdsToArrayIndices","_updateObjects","_updateMaterial","arrayName","_convertTopLevelObjectToArray","mapName","objectMap","_convertIdsToIndices","_convertIdToIndex","_convertTextureIds","_convertMeshIds","_convertNodeIds","_convertSceneIds","topLevelArrayName","pbrMetallicRoughness","baseColorFactor","metallicFactor","roughnessFactor","textureId","tex","textureIndex","findIndex","baseColorTexture","COMPONENTS","BYTES","GL_SAMPLER","TEXTURE_MAG_FILTER","TEXTURE_MIN_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","REPEAT","LINEAR","NEAREST_MIPMAP_LINEAR","SAMPLER_PARAMETER_GLTF_TO_GL","magFilter","minFilter","wrapS","wrapT","DEFAULT_SAMPLER","TEXTURE_WRAP_","GLTFPostProcessor","postProcess","_resolveTree","bufView","_resolveBufferView","_resolveImage","_resolveSampler","_resolveTexture","_resolveAccessor","_resolveMaterial","_resolveMesh","_resolveNode","_resolveSkin","_resolveScene","_get","getCamera","reduce","accum","camera","inverseBindMatrices","normalTexture","occlusionTexture","occlustionTexture","emissiveTexture","emmisiveTexture","emissiveFactor","mr","metallicRoughnessTexture","bytesPerElement","cutBufffer","parameters","glEnum","_enumSamplerParameter","preloadedImage","_resolveCamera","orthographic","MAGIC_glTF","isGLB","magic1","parseGLBSync","glb","hasBinChunk","binChunks","GLB_FILE_HEADER_SIZE","contentLength","contentFormat","parseJSONChunk","parseBINChunk","parseGLBV1","chunkLength","chunkFormat","strict","parseGLBChunksSync","parseGLBV2","jsonChunk","jsonText","parseGLTF","arrayBufferOrString","_glb","parseGLTFContainerSync","normalizeGLTFV1","loadBuffers","loadImages","promise","loadImage","excludes","excludeExtensions","decodeExtensions","postProcessGLTF","parsedImage","GLTFLoader","log","deprecatedOptions","fetchImages","createImages","decompress","GLTF_FORMAT","parse3DTileGLTFViewSync","rotateYtoZ","gltfByteLength","gltfUpAxis","assetGltfUpAxis","gltfArrayBuffer","gltfByteOffset","extractGLTF","gltfFormat","tile3DOptions","gltfUrlBytes","gltfUrl","extractGLTFBufferOrURL","loadGLTF","parseBatchedModel3DTile","parseBatchedModel","CESIUM_RTC","scratchVector","fromCartographic","cartographic","longitude","latitude","toCartographic","scaleToGeodeticSurfaceIntersection","scaleToGeodeticSurfaceGradient","scratchOrigin","VECTOR_PRODUCT_LOCAL_FRAME","south","north","west","east","down","degeneratePositionLocalFrame","scratchAxisVectors","localFrameToFixedFrame","ellipsoid","firstAxis","secondAxis","thirdAxis","cartesianOrigin","thirdAxisInferred","firstAxisVector","secondAxisVector","thirdAxisVector","origin","sign","fromArray","geodeticSurfaceNormal","scratchK","scratchHeight","scratchCartesian","wgs84","radii","radiiSquared","radiiToTheFourth","oneOverRadii","oneOverRadiiSquared","minimumRadius","maximumRadius","centerToleranceSquared","EPSILON1","squaredXOverSquaredZ","freeze","normal","k","geodeticSurfaceNormalCartographic","gamma","cartesian","point","scaleToGeodeticSurface","h","asin","vec3","_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","EPSILON12","beta","position","EPSILON15","parseInstancedModel3DTile","eastNorthUp","_batchTable","collectionOptions","instancePosition","instanceNormalRight","instanceNormalUp","instanceNormalForward","instanceRotation","Matrix3","instanceQuaternion","Quaternion","instanceScale","instanceTranslationRotationScale","instanceTransform","Matrix4","scratch1","scratch2","scratchVector1","scratchVector2","MAX_UNSIGNED_SHORT","j","translation","normalUp","normalRight","hasCustomOrientation","octNormalUp","octNormalRight","Ellipsoid","WGS84","eastNorthUpToFixedFrame","getRotationMatrix3","setColumn","fromMatrix3","rotation","multiplyByScalar","nonUniformScale","rotationMatrix","fromQuaternion","multiplyRight","modelMatrix","extractInstancedAttributes","parseInstancedModel","parse3DTile","tilesLength","tiles","subtile","parseComposite3DTile","normalizeTileData","content","contentUri","contentUrl","basePath","lodMetricType","lodMetricValue","geometricError","transformMatrix","fileExtension","split","getTileType","refine","getRefine","Tiles3DLoader","loaderOptions","isTileset","tilesetJson","tileset","path","getBaseUri","childHeader","normalizeTileHeaders","parseTileset","featureIds","parseTile","pathPrefix","fileAliases","isResponse","Response","isBlob","DATA_URL_PATTERN","MIME_TYPE_PATTERN","parseMIMEType","mimeString","parseMIMETypeFromURL","QUERY_STRING_PATTERN","stripQueryString","makeResponse","resource","headers","getResourceContentLength","getResourceUrlAndType","initialDataUrl","blobSlice","reader","FileReader","event","readAsDataURL","bytes","arrayBufferToBase64","getInitialDataUrl","TextEncoder","fetchFile","filename","alias","replacement","resolvePath","fetchOptions","getIonTilesetMetadata","accessToken","assetId","assets","Authorization","statusText","getIonAssets","item","items","ionAssetMetadata","tilesetInfo","getIonAssetMetadata","CesiumIonLoader","preload","matched","match","encode3DTileHeader","setUint8","setUint32","encode3DTileByteLength","byteOffsetTileStart","copyPaddedStringToDataView","paddedLength","padLength","copyPaddedArrayBufferToDataView","copyStringToDataView","charCodeAt","copyBinaryToDataView","DEFAULT_FEATURE_TABLE_JSON","POINTS_LENGTH","POSITIONS","encodePointCloud3DTile","featureTableJsonString","byteAlignment","ceil","whitespace","padStringToByteAlignment","byteOffsetStart","encode3DTileToDataView","encode3DTile","encodeComposite3DTile","batchTableJsonString","gltfEncoded","encodeBatchedModel3DTile","gltfUri","gltfUriByteLength","INSTANCES_LENGTH","encodeInstancedModel3DTile","Tile3DWriter","ORIGIN","constants","ZERO","quaternion","EPSILON2","EPSILON3","EPSILON4","EPSILON5","EPSILON6","EPSILON7","EPSILON8","EPSILON9","EPSILON10","EPSILON11","EPSILON13","EPSILON14","EPSILON16","EPSILON17","EPSILON18","EPSILON19","EPSILON20","PI_OVER_TWO","PI_OVER_FOUR","PI_OVER_SIX","TWO_PI","IDENTITY","INDICES","COL0ROW0","COL0ROW1","COL0ROW2","COL0ROW3","COL1ROW0","COL1ROW1","COL1ROW2","COL1ROW3","COL2ROW0","COL2ROW1","COL2ROW2","COL2ROW3","COL3ROW0","COL3ROW1","COL3ROW2","COL3ROW3","m00","m10","m20","m30","m01","m11","m21","m31","m02","m12","m22","m32","m03","m13","m23","m33","_computeInfinitePerspectiveOffCenter","column0Row0","column1Row1","column2Row0","column2Row1","column3Row2","focalDistance","halfY","fov","scaleResult","getScale","inverseScale0","inverseScale1","inverseScale2","rx","ry","rz","factor","transformAsVector","setAxisAngle","bw","slerp","omega","cosom","sinom","scale0","scale1","fromMat3","fRoot","fTrace","vec4","tmpvec3","xUnitVec3","yUnitVec3","temp1","temp2","matr","rotationTo","mat3","IDENTITY_QUATERNION","fromAxisRotation","vectorA","vectorB","invDot","start","multiplyLeft"],"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();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse {\n\t\tvar a = factory();\n\t\tfor(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n\t}\n})(window, function() {\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 = 27);\n","/**\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 { 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","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 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 * 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 * 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;","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 * 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;","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","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}();","// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n self: typeof self !== 'undefined' && self,\n window: typeof window !== 'undefined' && window,\n global: typeof global !== 'undefined' && global,\n document: typeof document !== 'undefined' && document\n};\n\nconst self_: {[key: string]: any} = globals.self || globals.window || globals.global || {};\nconst window_: {[key: string]: any} = globals.window || globals.self || globals.global || {};\nconst global_: {[key: string]: any} = globals.global || globals.self || globals.window || {};\nconst document_: {[key: string]: any} = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/** true if running in the browser, false if running in Node.js */\nexport const isBrowser: boolean =\n // @ts-ignore process.browser\n typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\n/** true if running on a worker thread */\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n/** true if running on a mobile device */\nexport const isMobile: boolean =\n typeof window !== 'undefined' && typeof window.orientation !== 'undefined';\n\n// Extract node major version\nconst matches =\n typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\n\n/** Version of Node.js if running under Node, otherwise 0 */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;\n","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","// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n self: typeof self !== 'undefined' && self,\n window: typeof window !== 'undefined' && window,\n global: typeof global !== 'undefined' && global,\n document: typeof document !== 'undefined' && document\n};\n\nconst self_ = globals.self || globals.window || globals.global;\nconst window_ = globals.window || globals.self || globals.global;\nconst global_ = globals.global || globals.self || globals.window;\nconst document_ = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\nexport const isBrowser =\n // @ts-ignore\n typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\nexport const isWorker = typeof importScripts === 'function';\n\n// Extract node major version\nconst matches =\n typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\nexport const nodeVersion = (matches && parseFloat(matches[1])) || 0;\n","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 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","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\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","// @ts-nocheck\nconst moduleExports = require('./index');\nconst _global = typeof window === 'undefined' ? global : window;\n_global.loaders = _global.loaders || {};\nmodule.exports = Object.assign(_global.loaders, moduleExports);\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.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","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","// TILE TYPES\n\nexport const TILE3D_TYPE = {\n COMPOSITE: 'cmpt',\n POINT_CLOUD: 'pnts',\n BATCHED_3D_MODEL: 'b3dm',\n INSTANCED_3D_MODEL: 'i3dm',\n GEOMETRY: 'geom',\n VECTOR: 'vect'\n};\n\nexport const TILE3D_TYPES = Object.keys(TILE3D_TYPE);\n\nexport const MAGIC_ARRAY = {\n BATCHED_MODEL: [98, 51, 100, 109],\n INSTANCED_MODEL: [105, 51, 100, 109],\n POINT_CLOUD: [112, 110, 116, 115],\n COMPOSITE: [99, 109, 112, 116]\n};\n\n// TILE CONSTANTS\nexport const TILE3D_OPTIMIZATION_HINT = {\n NOT_COMPUTED: -1,\n USE_OPTIMIZATION: 1,\n SKIP_OPTIMIZATION: 0\n};\n","/**\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","// 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// Decode the JSON binary array into clear text\nexport function getStringFromArrayBuffer(arrayBuffer, byteOffset, byteLength) {\n assert(arrayBuffer instanceof ArrayBuffer);\n const textDecoder = new TextDecoder('utf8');\n const typedArray = new Uint8Array(arrayBuffer, byteOffset, byteLength);\n const string = textDecoder.decode(typedArray);\n return string;\n}\n\n// Decode the JSON binary array into clear text\nexport function getStringFromTypedArray(typedArray) {\n assert(ArrayBuffer.isView(typedArray));\n const textDecoder = new TextDecoder('utf8');\n const string = textDecoder.decode(typedArray);\n return string;\n}\n\nexport function getMagicString(arrayBuffer, byteOffset = 0) {\n const dataView = new DataView(arrayBuffer);\n return `\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;\n}\n","// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n","import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {DracoParseOptions} from './lib/draco-parser';\n// import type {DracoMeshData} from './types';\nimport {VERSION} from './lib/utils/version';\n\nexport type DracoLoaderOptions = LoaderOptions & {\n draco?: DracoParseOptions & {\n decoderType?: 'wasm' | 'js';\n libraryPath?: string;\n extraAttributes?;\n attributeNameEntry?: string;\n };\n};\n\nconst DEFAULT_DRACO_OPTIONS: DracoLoaderOptions = {\n draco: {\n decoderType: typeof WebAssembly === 'object' ? 'wasm' : 'js', // 'js' for IE11\n libraryPath: 'libs/',\n extraAttributes: {},\n attributeNameEntry: undefined\n }\n};\n\n/**\n * Worker loader for Draco3D compressed geometries\n */\nexport const DracoLoader = {\n name: 'Draco',\n id: 'draco',\n module: 'draco',\n shapes: ['mesh'],\n version: VERSION,\n worker: true,\n extensions: ['drc'],\n mimeTypes: ['application/octet-stream'],\n binary: true,\n tests: ['DRACO'],\n options: DEFAULT_DRACO_OPTIONS\n};\n\nexport const _TypecheckDracoLoader: Loader = DracoLoader;\n","import {assert} from '../../utils/assert';\nimport Field from './field';\n\nexport type SchemaMetadata = Map<string, any>;\n\n/**\n * ArrowJS `Schema` API-compatible class for row-based tables (returned from `DataTable`)\n * https://loaders.gl/arrowjs/docs/api-reference/schema\n */\nexport default class Schema {\n fields: Field[];\n // TODO - Arrow just allows Map<string, string>\n metadata: SchemaMetadata;\n\n constructor(fields: Field[], metadata?: SchemaMetadata) {\n assert(Array.isArray(fields));\n checkNames(fields);\n // For kepler fields, create arrow compatible `Fields` that have kepler fields as `metadata`\n this.fields = fields;\n this.metadata = metadata || new Map();\n }\n\n // TODO - arrow only seems to compare fields, not metadata\n compareTo(other: Schema): boolean {\n if (this.metadata !== other.metadata) {\n return false;\n }\n if (this.fields.length !== other.fields.length) {\n return false;\n }\n for (let i = 0; i < this.fields.length; ++i) {\n if (!this.fields[i].compareTo(other.fields[i])) {\n return false;\n }\n }\n return true;\n }\n\n select(...columnNames: string[]): Schema {\n // Ensure column names reference valid fields\n const nameMap = Object.create(null);\n for (const name of columnNames) {\n nameMap[name] = true;\n }\n const selectedFields = this.fields.filter((field) => nameMap[field.name]);\n return new Schema(selectedFields, this.metadata);\n }\n\n selectAt(...columnIndices: number[]): Schema {\n // Ensure column indices reference valid fields\n const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);\n return new Schema(selectedFields, this.metadata);\n }\n\n assign(schemaOrFields: Schema | Field[]): Schema {\n let fields: Field[];\n let metadata: SchemaMetadata = this.metadata;\n\n if (schemaOrFields instanceof Schema) {\n const otherSchema = schemaOrFields;\n fields = otherSchema.fields;\n metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);\n } else {\n fields = schemaOrFields;\n }\n\n // Create a merged list of fields, overwrite fields in place, new fields at end\n const fieldMap: {[key: string]: Field} = Object.create(null);\n\n for (const field of this.fields) {\n fieldMap[field.name] = field;\n }\n\n for (const field of fields) {\n fieldMap[field.name] = field;\n }\n\n const mergedFields = Object.values(fieldMap);\n\n return new Schema(mergedFields, metadata);\n }\n}\n\n// Warn if any duplicated field names\nfunction checkNames(fields) {\n const usedNames = {};\n for (const field of fields) {\n if (usedNames[field.name]) {\n // eslint-disable-next-line\n console.warn('Schema: duplicated field name', field.name, field);\n }\n usedNames[field.name] = true;\n }\n}\n\nfunction mergeMaps<T>(m1: T, m2: T): T {\n // @ts-ignore\n return new Map([...(m1 || new Map()), ...(m2 || new Map())]);\n}\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition: boolean, message?: string) {\n if (!condition) {\n throw new Error(message || 'loader assertion failed.');\n }\n}\n","import {DataType} from './type';\n\n/**\n * ArrowJS `Field` API-compatible class for row-based tables\n * https://loaders.gl/arrowjs/docs/api-reference/field\n * A field holds name, nullable, and metadata information about a table \"column\"\n * A Schema is essentially a list of fields\n */\nexport default class Field {\n name: string;\n type: DataType;\n nullable: boolean;\n metadata: Map<string, string>;\n\n constructor(\n name: string,\n type: DataType,\n nullable = false,\n metadata: Map<string, string> = new Map()\n ) {\n this.name = name;\n this.type = type;\n this.nullable = nullable;\n this.metadata = metadata;\n }\n\n get typeId(): number {\n return this.type && this.type.typeId;\n }\n\n clone(): Field {\n return new Field(this.name, this.type, this.nullable, this.metadata);\n }\n\n compareTo(other: this): boolean {\n return (\n this.name === other.name &&\n this.type === other.type &&\n this.nullable === other.nullable &&\n this.metadata === other.metadata\n );\n }\n\n toString(): string {\n return `${this.type}${this.nullable ? ', nullable' : ''}${\n this.metadata ? `, metadata: ${this.metadata}` : ''\n }`;\n }\n}\n","// This code is adapted from ArrowJS https://github.com/apache/arrow\n// under Apache license http://www.apache.org/licenses/LICENSE-2.0\n\n/**\n * Main data type enumeration.\n *\n * Data types in this library are all *logical*. They can be expressed as\n * either a primitive physical type (bytes or bits of some fixed size), a\n * nested type consisting of other data types, or another data type (e.g. a\n * timestamp encoded as an int64).\n *\n * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow\n * IPC payload.\n *\n * The rest of the values are specified here so TypeScript can narrow the type\n * signatures further beyond the base Arrow Types. The Arrow DataTypes include\n * metadata like `bitWidth` that impact the type signatures of the values we\n * accept and return.\n *\n * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an\n * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`\n * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the\n * underlying `Int32Array`.\n *\n * Library consumers benefit by knowing the narrowest type, since we can ensure\n * the types across all public methods are propagated, and never bail to `any`.\n * These values are _never_ used at runtime, and they will _never_ be written\n * to the flatbuffers metadata of serialized Arrow IPC payloads.\n */\nexport enum Type {\n /** The default placeholder type */\n NONE = 0,\n /** A NULL type having no physical storage */\n Null = 1,\n /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */\n Int = 2,\n /** 2, 4, or 8-byte floating point value */\n Float = 3,\n /** Variable-length bytes (no guarantee of UTF8-ness) */\n Binary = 4,\n /** UTF8 variable-length string as List<Char> */\n Utf8 = 5,\n /** Boolean as 1 bit, LSB bit-packed ordering */\n Bool = 6,\n /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */\n Decimal = 7,\n /** int32_t days or int64_t milliseconds since the UNIX epoch */\n Date = 8,\n /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */\n Time = 9,\n /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */\n Timestamp = 10,\n /** YEAR_MONTH or DAY_TIME interval in SQL style */\n Interval = 11,\n /** A list of some logical data type */\n List = 12,\n /** Struct of logical types */\n Struct = 13,\n /** Union of logical types */\n Union = 14,\n /** Fixed-size binary. Each value occupies the same number of bytes */\n FixedSizeBinary = 15,\n /** Fixed-size list. Each value occupies the same number of bytes */\n FixedSizeList = 16,\n /** Map of named logical types */\n Map = 17,\n\n /** Dictionary aka Category type */\n Dictionary = -1,\n Int8 = -2,\n Int16 = -3,\n Int32 = -4,\n Int64 = -5,\n Uint8 = -6,\n Uint16 = -7,\n Uint32 = -8,\n Uint64 = -9,\n Float16 = -10,\n Float32 = -11,\n Float64 = -12,\n DateDay = -13,\n DateMillisecond = -14,\n TimestampSecond = -15,\n TimestampMillisecond = -16,\n TimestampMicrosecond = -17,\n TimestampNanosecond = -18,\n TimeSecond = -19,\n TimeMillisecond = -20,\n TimeMicrosecond = -21,\n TimeNanosecond = -22,\n DenseUnion = -23,\n SparseUnion = -24,\n IntervalDayTime = -25,\n IntervalYearMonth = -26\n}\n","// This code is adapted from ArrowJS https://github.com/apache/arrow\n// under Apache license http://www.apache.org/licenses/LICENSE-2.0\n\nimport {Type} from './enum';\n\nimport Field from './field';\n\nexport {Type} from './enum';\n\nexport type TypedIntArray =\n | Int8Array\n | Uint8Array\n | Int16Array\n | Uint16Array\n | Int32Array\n | Uint32Array\n | Int32Array\n | Uint32Array\n | Uint8ClampedArray;\n\nexport type TypedFloatArray = Float32Array | Float64Array;\n\nexport type TypedArray = TypedIntArray | TypedFloatArray;\n\nexport type AnyArrayType = Array<any> | TypedIntArray | TypedFloatArray;\n\nexport class DataType {\n static isNull(x: any): boolean {\n return x && x.typeId === Type.Null;\n }\n static isInt(x: any): boolean {\n return x && x.typeId === Type.Int;\n }\n static isFloat(x: any): boolean {\n return x && x.typeId === Type.Float;\n }\n static isBinary(x: any): boolean {\n return x && x.typeId === Type.Binary;\n }\n static isUtf8(x: any): boolean {\n return x && x.typeId === Type.Utf8;\n }\n static isBool(x: any): boolean {\n return x && x.typeId === Type.Bool;\n }\n static isDecimal(x: any): boolean {\n return x && x.typeId === Type.Decimal;\n }\n static isDate(x: any): boolean {\n return x && x.typeId === Type.Date;\n }\n static isTime(x: any): boolean {\n return x && x.typeId === Type.Time;\n }\n static isTimestamp(x: any): boolean {\n return x && x.typeId === Type.Timestamp;\n }\n static isInterval(x: any): boolean {\n return x && x.typeId === Type.Interval;\n }\n static isList(x: any): boolean {\n return x && x.typeId === Type.List;\n }\n static isStruct(x: any): boolean {\n return x && x.typeId === Type.Struct;\n }\n static isUnion(x: any): boolean {\n return x && x.typeId === Type.Union;\n }\n static isFixedSizeBinary(x: any): boolean {\n return x && x.typeId === Type.FixedSizeBinary;\n }\n static isFixedSizeList(x: any): boolean {\n return x && x.typeId === Type.FixedSizeList;\n }\n static isMap(x: any): boolean {\n return x && x.typeId === Type.Map;\n }\n static isDictionary(x: any): boolean {\n return x && x.typeId === Type.Dictionary;\n }\n\n get typeId(): Type {\n return Type.NONE;\n }\n\n // get ArrayType(): AnyArrayType {\n // return Int8Array;\n // }\n\n // get ArrayType() { return Array; }\n compareTo(other: DataType): boolean {\n // TODO\n return this === other; // comparer.visit(this, other);\n }\n}\n\n// NULL\n\nexport class Null extends DataType {\n get typeId(): Type {\n return Type.Null;\n }\n get [Symbol.toStringTag](): string {\n return 'Null';\n }\n toString(): string {\n return 'Null';\n }\n}\n\n// BOOLEANS\n\nexport class Bool extends DataType {\n get typeId(): Type {\n return Type.Bool;\n }\n // get ArrayType() {\n // return Uint8Array;\n // }\n get [Symbol.toStringTag](): string {\n return 'Bool';\n }\n toString(): string {\n return 'Bool';\n }\n}\n\n// INTS\n\nexport class Int extends DataType {\n readonly isSigned: boolean;\n readonly bitWidth: number;\n constructor(isSigned, bitWidth) {\n super();\n this.isSigned = isSigned;\n this.bitWidth = bitWidth;\n }\n get typeId(): Type {\n return Type.Int;\n }\n // get ArrayType() {\n // switch (this.bitWidth) {\n // case 8:\n // return this.isSigned ? Int8Array : Uint8Array;\n // case 16:\n // return this.isSigned ? Int16Array : Uint16Array;\n // case 32:\n // return this.isSigned ? Int32Array : Uint32Array;\n // case 64:\n // return this.isSigned ? Int32Array : Uint32Array;\n // default:\n // throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n // }\n // }\n get [Symbol.toStringTag](): string {\n return 'Int';\n }\n toString(): string {\n return `${this.isSigned ? 'I' : 'Ui'}nt${this.bitWidth}`;\n }\n}\n\nexport class Int8 extends Int {\n constructor() {\n super(true, 8);\n }\n}\nexport class Int16 extends Int {\n constructor() {\n super(true, 16);\n }\n}\nexport class Int32 extends Int {\n constructor() {\n super(true, 32);\n }\n}\nexport class Int64 extends Int {\n constructor() {\n super(true, 64);\n }\n}\nexport class Uint8 extends Int {\n constructor() {\n super(false, 8);\n }\n}\nexport class Uint16 extends Int {\n constructor() {\n super(false, 16);\n }\n}\nexport class Uint32 extends Int {\n constructor() {\n super(false, 32);\n }\n}\nexport class Uint64 extends Int {\n constructor() {\n super(false, 64);\n }\n}\n\n// FLOATS\n\nconst Precision = {\n HALF: 16,\n SINGLE: 32,\n DOUBLE: 64\n};\n\nexport class Float extends DataType {\n readonly precision: number;\n constructor(precision) {\n super();\n this.precision = precision;\n }\n get typeId(): Type {\n return Type.Float;\n }\n // get ArrayType() {\n // switch (this.precision) {\n // case Precision.HALF:\n // return Uint16Array;\n // case Precision.SINGLE:\n // return Float32Array;\n // case Precision.DOUBLE:\n // return Float64Array;\n // default:\n // throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n // }\n // }\n get [Symbol.toStringTag](): string {\n return 'Float';\n }\n toString(): string {\n return `Float${this.precision}`;\n }\n}\n\nexport class Float16 extends Float {\n constructor() {\n super(Precision.HALF);\n }\n}\nexport class Float32 extends Float {\n constructor() {\n super(Precision.SINGLE);\n }\n}\nexport class Float64 extends Float {\n constructor() {\n super(Precision.DOUBLE);\n }\n}\n\nexport class Binary extends DataType {\n constructor() {\n super();\n }\n get typeId() {\n return Type.Binary;\n }\n toString() {\n return 'Binary';\n }\n get [Symbol.toStringTag]() {\n return 'Binary';\n }\n}\n\n// STRINGS\n\nexport class Utf8 extends DataType {\n get typeId(): Type {\n return Type.Utf8;\n }\n // get ArrayType() {\n // return Uint8Array;\n // }\n get [Symbol.toStringTag](): string {\n return 'Utf8';\n }\n toString(): string {\n return 'Utf8';\n }\n}\n\n// DATES, TIMES AND INTERVALS\n\nconst DateUnit = {\n DAY: 0,\n MILLISECOND: 1\n};\n\nexport class Date extends DataType {\n readonly unit: number;\n constructor(unit) {\n super();\n this.unit = unit;\n }\n get typeId(): Type {\n return Type.Date;\n }\n // get ArrayType() {\n // return Int32Array;\n // }\n get [Symbol.toStringTag](): string {\n return 'Date';\n }\n toString(): string {\n return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;\n }\n}\n\nexport class DateDay extends Date {\n constructor() {\n super(DateUnit.DAY);\n }\n}\nexport class DateMillisecond extends Date {\n constructor() {\n super(DateUnit.MILLISECOND);\n }\n}\n\nconst TimeUnit = {\n SECOND: 1,\n MILLISECOND: 1e3,\n MICROSECOND: 1e6,\n NANOSECOND: 1e9\n};\n\nexport class Time extends DataType {\n readonly unit: number;\n readonly bitWidth: number;\n\n constructor(unit, bitWidth) {\n super();\n this.unit = unit;\n this.bitWidth = bitWidth;\n }\n get typeId(): Type {\n return Type.Time;\n }\n toString(): string {\n return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;\n }\n get [Symbol.toStringTag](): string {\n return 'Time';\n }\n // get ArrayType() {\n // return Int32Array;\n // }\n}\n\nexport class TimeSecond extends Time {\n constructor() {\n super(TimeUnit.SECOND, 32);\n }\n}\nexport class TimeMillisecond extends Time {\n constructor() {\n super(TimeUnit.MILLISECOND, 32);\n }\n}\n// export class TimeMicrosecond extends Time { constructor() { super(TimeUnit.MICROSECOND, 64); } }\n// export class TimeNanosecond extends Time { constructor() { super(TimeUnit.NANOSECOND, 64); } }\n\nexport class Timestamp extends DataType {\n readonly unit: any;\n readonly timezone: any;\n\n constructor(unit: any, timezone = null) {\n super();\n this.unit = unit;\n this.timezone = timezone;\n }\n get typeId(): Type {\n return Type.Timestamp;\n }\n // get ArrayType() {\n // return Int32Array;\n // }\n get [Symbol.toStringTag](): string {\n return 'Timestamp';\n }\n toString(): string {\n return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ''}>`;\n }\n}\n\nexport class TimestampSecond extends Timestamp {\n constructor(timezone = null) {\n super(TimeUnit.SECOND, timezone);\n }\n}\nexport class TimestampMillisecond extends Timestamp {\n constructor(timezone = null) {\n super(TimeUnit.MILLISECOND, timezone);\n }\n}\nexport class TimestampMicrosecond extends Timestamp {\n constructor(timezone = null) {\n super(TimeUnit.MICROSECOND, timezone);\n }\n}\nexport class TimestampNanosecond extends Timestamp {\n constructor(timezone = null) {\n super(TimeUnit.NANOSECOND, timezone);\n }\n}\n\nconst IntervalUnit = {\n DAY_TIME: 0,\n YEAR_MONTH: 1\n};\n\nexport class Interval extends DataType {\n readonly unit: number;\n constructor(unit: number) {\n super();\n this.unit = unit;\n }\n get typeId(): Type {\n return Type.Interval;\n }\n // get ArrayType() {\n // return Int32Array;\n // }\n get [Symbol.toStringTag](): string {\n return 'Interval';\n }\n toString(): string {\n return `Interval<${IntervalUnit[this.unit]}>`;\n }\n}\n\nexport class IntervalDayTime extends Interval {\n constructor() {\n super(IntervalUnit.DAY_TIME);\n }\n}\nexport class IntervalYearMonth extends Interval {\n constructor() {\n super(IntervalUnit.YEAR_MONTH);\n }\n}\n\nexport class FixedSizeList extends DataType {\n readonly listSize: number;\n readonly children: Field[];\n\n constructor(listSize: number, child: Field) {\n super();\n this.listSize = listSize;\n this.children = [child];\n }\n get typeId(): Type {\n return Type.FixedSizeList;\n }\n get valueType() {\n return this.children[0].type;\n }\n get valueField() {\n return this.children[0];\n }\n // get ArrayType() {\n // return this.valueType.ArrayType;\n // }\n get [Symbol.toStringTag](): string {\n return 'FixedSizeList';\n }\n toString(): string {\n return `FixedSizeList[${this.listSize}]<${this.valueType}>`;\n }\n}\n\nexport class Struct extends DataType {\n public readonly children: Field[];\n\n constructor(children: Field[]) {\n super();\n this.children = children;\n }\n\n public get typeId() {\n return Type.Struct;\n }\n public toString() {\n return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(', ')}}>`;\n }\n get [Symbol.toStringTag](): string {\n return 'Struct';\n }\n}\n","import {MeshAttribute, MeshAttributes} from './mesh-types';\nimport {Schema, Field, FixedSizeList} from '../../lib/schema';\nimport {getArrowTypeFromTypedArray} from '../../lib/arrow/arrow-like-type-utils';\n\n/**\n * Create a schema for mesh attributes data\n * @param attributes\n * @param metadata\n * @returns\n */\nexport function deduceMeshSchema(\n attributes: MeshAttributes,\n metadata?: Map<string, string>\n): Schema {\n const fields = deduceMeshFields(attributes);\n return new Schema(fields, metadata);\n}\n\n/**\n * Create arrow-like schema field for mesh attribute\n * @param attributeName\n * @param attribute\n * @param optionalMetadata\n * @returns\n */\nexport function deduceMeshField(\n attributeName: string,\n attribute: MeshAttribute,\n optionalMetadata?: Map<string, string>\n): Field {\n const type = getArrowTypeFromTypedArray(attribute.value);\n const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);\n const field = new Field(\n attributeName,\n new FixedSizeList(attribute.size, new Field('value', type)),\n false,\n metadata\n );\n return field;\n}\n\n/**\n * Create fields array for mesh attributes\n * @param attributes\n * @returns\n */\nfunction deduceMeshFields(attributes: MeshAttributes): Field[] {\n const fields: Field[] = [];\n for (const attributeName in attributes) {\n const attribute: MeshAttribute = attributes[attributeName];\n fields.push(deduceMeshField(attributeName, attribute));\n }\n return fields;\n}\n\n/**\n * Make metadata by mesh attribute properties\n * @param attribute\n * @returns\n */\nexport function makeMeshAttributeMetadata(attribute: MeshAttribute): Map<string, string> {\n const result = new Map();\n if ('byteOffset' in attribute) {\n result.set('byteOffset', attribute.byteOffset!.toString(10));\n }\n if ('byteStride' in attribute) {\n result.set('byteStride', attribute.byteStride!.toString(10));\n }\n if ('normalized' in attribute) {\n result.set('normalized', attribute.normalized!.toString());\n }\n return result;\n}\n","import type {TypedArray} from '../../types';\nimport {DataType, Float32, Float64, Int16, Int32, Int8, Uint16, Uint32, Uint8} from '../schema';\n\nexport function getArrowTypeFromTypedArray(array: TypedArray): DataType {\n switch (array.constructor) {\n case Int8Array:\n return new Int8();\n case Uint8Array:\n return new Uint8();\n case Int16Array:\n return new Int16();\n case Uint16Array:\n return new Uint16();\n case Int32Array:\n return new Int32();\n case Uint32Array:\n return new Uint32();\n case Float32Array:\n return new Float32();\n case Float64Array:\n return new Float64();\n default:\n throw new Error('array type not supported');\n }\n}\n","import {deduceMeshField, MeshAttribute} from '@loaders.gl/schema';\nimport {Schema, Field} from '@loaders.gl/schema';\nimport type {DracoAttribute, DracoLoaderData, DracoMetadataEntry} from '../draco-types';\n\n/** Extract an arrow-like schema from a Draco mesh */\nexport function getDracoSchema(\n attributes: {[attributeName: string]: MeshAttribute},\n loaderData: DracoLoaderData,\n indices?: MeshAttribute\n): Schema {\n const metadataMap = makeMetadata(loaderData.metadata);\n const fields: Field[] = [];\n const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);\n for (const attributeName in attributes) {\n const attribute = attributes[attributeName];\n const field = getArrowFieldFromAttribute(\n attributeName,\n attribute,\n namedLoaderDataAttributes[attributeName]\n );\n fields.push(field);\n }\n if (indices) {\n const indicesField = getArrowFieldFromAttribute('indices', indices);\n fields.push(indicesField);\n }\n return new Schema(fields, metadataMap);\n}\n\nfunction transformAttributesLoaderData(loaderData: {[key: number]: DracoAttribute}): {\n [attributeName: string]: DracoAttribute;\n} {\n const result: {[attributeName: string]: DracoAttribute} = {};\n for (const key in loaderData) {\n const dracoAttribute = loaderData[key];\n result[dracoAttribute.name || 'undefined'] = dracoAttribute;\n }\n return result;\n}\n\nfunction getArrowFieldFromAttribute(\n attributeName: string,\n attribute: MeshAttribute,\n loaderData?: DracoAttribute\n): Field {\n const metadataMap = loaderData ? makeMetadata(loaderData.metadata) : undefined;\n const field = deduceMeshField(attributeName, attribute, metadataMap);\n return field;\n}\n\nfunction makeMetadata(metadata: {[key: string]: DracoMetadataEntry}): Map<string, string> {\n const metadataMap = new Map();\n for (const key in metadata) {\n metadataMap.set(`${key}.string`, JSON.stringify(metadata[key]));\n }\n return metadataMap;\n}\n","/* eslint-disable camelcase */\n\nimport type {TypedArray, MeshAttribute, MeshGeometry} from '@loaders.gl/schema';\n\n// Draco types (input)\nimport type {\n Draco3D,\n Decoder,\n Mesh,\n PointCloud,\n PointAttribute,\n Metadata,\n MetadataQuerier,\n DracoInt32Array,\n draco_DataType\n} from '../draco3d/draco3d-types';\n\n// Parsed data types (output)\nimport type {\n DracoMesh,\n DracoLoaderData,\n DracoAttribute,\n DracoMetadataEntry,\n DracoQuantizationTransform,\n DracoOctahedronTransform\n} from './draco-types';\n\nimport {getMeshBoundingBox} from '@loaders.gl/schema';\nimport {getDracoSchema} from './utils/get-draco-schema';\n\n/**\n * @param topology - How triangle indices should be generated (mesh only)\n * @param attributeNameEntry\n * @param extraAttributes\n * @param quantizedAttributes\n * @param octahedronAttributes\n */\nexport type DracoParseOptions = {\n topology?: 'triangle-list' | 'triangle-strip';\n attributeNameEntry?: string;\n extraAttributes?: {[uniqueId: string]: number};\n quantizedAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];\n octahedronAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];\n};\n\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nconst GEOMETRY_TYPE = {\n TRIANGULAR_MESH: 0,\n POINT_CLOUD: 1\n};\n\n// Native Draco attribute names to GLTF attribute names.\nconst DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {\n POSITION: 'POSITION',\n NORMAL: 'NORMAL',\n COLOR: 'COLOR_0',\n TEX_COORD: 'TEXCOORD_0'\n};\n\nconst DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP = {\n 1: Int8Array,\n 2: Uint8Array,\n 3: Int16Array,\n 4: Uint16Array,\n 5: Int32Array,\n 6: Uint32Array,\n 9: Float32Array\n};\n\nconst INDEX_ITEM_SIZE = 4;\n\nexport default class DracoParser {\n draco: Draco3D;\n decoder: Decoder;\n metadataQuerier: MetadataQuerier;\n\n // draco - the draco decoder, either import `draco3d` or load dynamically\n constructor(draco: Draco3D) {\n this.draco = draco;\n this.decoder = new this.draco.Decoder();\n this.metadataQuerier = new this.draco.MetadataQuerier();\n }\n\n /**\n * Destroy draco resources\n */\n destroy(): void {\n this.draco.destroy(this.decoder);\n this.draco.destroy(this.metadataQuerier);\n }\n\n /**\n * NOTE: caller must call `destroyGeometry` on the return value after using it\n * @param arrayBuffer\n * @param options\n */\n parseSync(arrayBuffer: ArrayBuffer, options: DracoParseOptions = {}): DracoMesh {\n const buffer = new this.draco.DecoderBuffer();\n buffer.Init(new Int8Array(arrayBuffer), arrayBuffer.byteLength);\n\n this._disableAttributeTransforms(options);\n\n const geometry_type = this.decoder.GetEncodedGeometryType(buffer);\n const dracoGeometry =\n geometry_type === this.draco.TRIANGULAR_MESH\n ? new this.draco.Mesh()\n : new this.draco.PointCloud();\n\n try {\n let dracoStatus;\n switch (geometry_type) {\n case this.draco.TRIANGULAR_MESH:\n dracoStatus = this.decoder.DecodeBufferToMesh(buffer, dracoGeometry as Mesh);\n break;\n\n case this.draco.POINT_CLOUD:\n dracoStatus = this.decoder.DecodeBufferToPointCloud(buffer, dracoGeometry);\n break;\n\n default:\n throw new Error('DRACO: Unknown geometry type.');\n }\n\n if (!dracoStatus.ok() || !dracoGeometry.ptr) {\n const message = `DRACO decompression failed: ${dracoStatus.error_msg()}`;\n // console.error(message);\n throw new Error(message);\n }\n\n const loaderData = this._getDracoLoaderData(dracoGeometry, geometry_type, options);\n\n const geometry = this._getMeshData(dracoGeometry, loaderData, options);\n\n const boundingBox = getMeshBoundingBox(geometry.attributes);\n\n const schema = getDracoSchema(geometry.attributes, loaderData, geometry.indices);\n\n const data: DracoMesh = {\n loader: 'draco',\n loaderData,\n header: {\n vertexCount: dracoGeometry.num_points(),\n boundingBox\n },\n ...geometry,\n schema\n };\n return data;\n } finally {\n this.draco.destroy(buffer);\n if (dracoGeometry) {\n this.draco.destroy(dracoGeometry);\n }\n }\n }\n\n // Draco specific \"loader data\"\n\n /**\n * Extract\n * @param dracoGeometry\n * @param geometry_type\n * @param options\n * @returns\n */\n _getDracoLoaderData(\n dracoGeometry: Mesh | PointCloud,\n geometry_type,\n options: DracoParseOptions\n ): DracoLoaderData {\n const metadata = this._getTopLevelMetadata(dracoGeometry);\n const attributes = this._getDracoAttributes(dracoGeometry, options);\n\n return {\n geometry_type,\n num_attributes: dracoGeometry.num_attributes(),\n num_points: dracoGeometry.num_points(),\n num_faces: dracoGeometry instanceof this.draco.Mesh ? dracoGeometry.num_faces() : 0,\n metadata,\n attributes\n };\n }\n\n /**\n * Extract all draco provided information and metadata for each attribute\n * @param dracoGeometry\n * @param options\n * @returns\n */\n _getDracoAttributes(\n dracoGeometry: Mesh | PointCloud,\n options: DracoParseOptions\n ): {[unique_id: number]: DracoAttribute} {\n const dracoAttributes: {[unique_id: number]: DracoAttribute} = {};\n\n for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {\n // Note: Draco docs do not seem clear on `GetAttribute` ids just being a zero-based index,\n // but it does seems to work this way\n const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);\n\n const metadata = this._getAttributeMetadata(dracoGeometry, attributeId);\n\n dracoAttributes[dracoAttribute.unique_id()] = {\n unique_id: dracoAttribute.unique_id(),\n attribute_type: dracoAttribute.attribute_type(),\n data_type: dracoAttribute.data_type(),\n num_components: dracoAttribute.num_components(),\n\n byte_offset: dracoAttribute.byte_offset(),\n byte_stride: dracoAttribute.byte_stride(),\n normalized: dracoAttribute.normalized(),\n attribute_index: attributeId,\n\n metadata\n };\n\n // Add transformation parameters for any attributes app wants untransformed\n const quantization = this._getQuantizationTransform(dracoAttribute, options);\n if (quantization) {\n dracoAttributes[dracoAttribute.unique_id()].quantization_transform = quantization;\n }\n\n const octahedron = this._getOctahedronTransform(dracoAttribute, options);\n if (octahedron) {\n dracoAttributes[dracoAttribute.unique_id()].octahedron_transform = octahedron;\n }\n }\n\n return dracoAttributes;\n }\n\n /**\n * Get standard loaders.gl mesh category data\n * Extracts the geometry from draco\n * @param dracoGeometry\n * @param options\n */\n _getMeshData(\n dracoGeometry: Mesh | PointCloud,\n loaderData: DracoLoaderData,\n options: DracoParseOptions\n ): MeshGeometry {\n const attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);\n\n const positionAttribute = attributes.POSITION;\n if (!positionAttribute) {\n throw new Error('DRACO: No position attribute found.');\n }\n\n // For meshes, we need indices to define the faces.\n if (dracoGeometry instanceof this.draco.Mesh) {\n switch (options.topology) {\n case 'triangle-strip':\n return {\n topology: 'triangle-strip',\n mode: 4, // GL.TRIANGLES\n attributes,\n indices: {\n value: this._getTriangleStripIndices(dracoGeometry),\n size: 1\n }\n };\n case 'triangle-list':\n default:\n return {\n topology: 'triangle-list',\n mode: 5, // GL.TRIANGLE_STRIP\n attributes,\n indices: {\n value: this._getTriangleListIndices(dracoGeometry),\n size: 1\n }\n };\n }\n }\n\n // PointCloud - must come last as Mesh inherits from PointCloud\n return {\n topology: 'point-list',\n mode: 0, // GL.POINTS\n attributes\n };\n }\n\n _getMeshAttributes(\n loaderData: DracoLoaderData,\n dracoGeometry: Mesh | PointCloud,\n options: DracoParseOptions\n ): {[attributeName: string]: MeshAttribute} {\n const attributes: {[key: string]: MeshAttribute} = {};\n\n for (const loaderAttribute of Object.values(loaderData.attributes)) {\n const attributeName = this._deduceAttributeName(loaderAttribute, options);\n loaderAttribute.name = attributeName;\n const {value, size} = this._getAttributeValues(dracoGeometry, loaderAttribute);\n attributes[attributeName] = {\n value,\n size,\n byteOffset: loaderAttribute.byte_offset,\n byteStride: loaderAttribute.byte_stride,\n normalized: loaderAttribute.normalized\n };\n }\n\n return attributes;\n }\n\n // MESH INDICES EXTRACTION\n\n /**\n * For meshes, we need indices to define the faces.\n * @param dracoGeometry\n */\n _getTriangleListIndices(dracoGeometry: Mesh) {\n // Example on how to retrieve mesh and attributes.\n const numFaces = dracoGeometry.num_faces();\n const numIndices = numFaces * 3;\n const byteLength = numIndices * INDEX_ITEM_SIZE;\n\n const ptr = this.draco._malloc(byteLength);\n try {\n this.decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);\n return new Uint32Array(this.draco.HEAPF32.buffer, ptr, numIndices).slice();\n } finally {\n this.draco._free(ptr);\n }\n }\n\n /**\n * For meshes, we need indices to define the faces.\n * @param dracoGeometry\n */\n _getTriangleStripIndices(dracoGeometry: Mesh) {\n const dracoArray = new this.draco.DracoInt32Array();\n try {\n /* const numStrips = */ this.decoder.GetTriangleStripsFromMesh(dracoGeometry, dracoArray);\n return getUint32Array(dracoArray);\n } finally {\n this.draco.destroy(dracoArray);\n }\n }\n\n /**\n *\n * @param dracoGeometry\n * @param dracoAttribute\n * @param attributeName\n */\n _getAttributeValues(\n dracoGeometry: Mesh | PointCloud,\n attribute: DracoAttribute\n ): {value: TypedArray; size: number} {\n const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];\n const numComponents = attribute.num_components;\n const numPoints = dracoGeometry.num_points();\n const numValues = numPoints * numComponents;\n\n const byteLength = numValues * TypedArrayCtor.BYTES_PER_ELEMENT;\n const dataType = getDracoDataType(this.draco, TypedArrayCtor);\n\n let value: TypedArray;\n\n const ptr = this.draco._malloc(byteLength);\n try {\n const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attribute.attribute_index);\n this.decoder.GetAttributeDataArrayForAllPoints(\n dracoGeometry,\n dracoAttribute,\n dataType,\n byteLength,\n ptr\n );\n value = new TypedArrayCtor(this.draco.HEAPF32.buffer, ptr, numValues).slice();\n } finally {\n this.draco._free(ptr);\n }\n\n return {value, size: numComponents};\n }\n\n // Attribute names\n\n /** \n * DRACO does not store attribute names - We need to deduce an attribute name\n * for each attribute\n _getAttributeNames(\n dracoGeometry: Mesh | PointCloud,\n options: DracoParseOptions\n ): {[unique_id: number]: string} {\n const attributeNames: {[unique_id: number]: string} = {};\n for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {\n const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);\n const attributeName = this._deduceAttributeName(dracoAttribute, options);\n attributeNames[attributeName] = attributeName;\n }\n return attributeNames;\n }\n */\n\n /**\n * Deduce an attribute name.\n * @note DRACO does not save attribute names, just general type (POSITION, COLOR)\n * to help optimize compression. We generate GLTF compatible names for the Draco-recognized\n * types\n * @param attributeData\n */\n _deduceAttributeName(attribute: DracoAttribute, options: DracoParseOptions): string {\n // Deduce name based on application provided map\n const uniqueId = attribute.unique_id;\n for (const [attributeName, attributeUniqueId] of Object.entries(\n options.extraAttributes || {}\n )) {\n if (attributeUniqueId === uniqueId) {\n return attributeName;\n }\n }\n\n // Deduce name based on attribute type\n const thisAttributeType = attribute.attribute_type;\n for (const dracoAttributeConstant in DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP) {\n const attributeType = this.draco[dracoAttributeConstant];\n if (attributeType === thisAttributeType) {\n // TODO - Return unique names if there multiple attributes per type\n // (e.g. multiple TEX_COORDS or COLORS)\n return DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP[dracoAttributeConstant];\n }\n }\n\n // Look up in metadata\n // TODO - shouldn't this have priority?\n const entryName = options.attributeNameEntry || 'name';\n if (attribute.metadata[entryName]) {\n return attribute.metadata[entryName].string;\n }\n\n // Attribute of \"GENERIC\" type, we need to assign some name\n return `CUSTOM_ATTRIBUTE_${uniqueId}`;\n }\n\n // METADATA EXTRACTION\n\n /** Get top level metadata */\n _getTopLevelMetadata(dracoGeometry: Mesh | PointCloud) {\n const dracoMetadata = this.decoder.GetMetadata(dracoGeometry);\n return this._getDracoMetadata(dracoMetadata);\n }\n\n /** Get per attribute metadata */\n _getAttributeMetadata(dracoGeometry: Mesh | PointCloud, attributeId: number) {\n const dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);\n return this._getDracoMetadata(dracoMetadata);\n }\n\n /**\n * Extract metadata field values\n * @param dracoMetadata\n * @returns\n */\n _getDracoMetadata(dracoMetadata: Metadata): {[entry: string]: DracoMetadataEntry} {\n // The not so wonderful world of undocumented Draco APIs :(\n if (!dracoMetadata || !dracoMetadata.ptr) {\n return {};\n }\n const result = {};\n const numEntries = this.metadataQuerier.NumEntries(dracoMetadata);\n for (let entryIndex = 0; entryIndex < numEntries; entryIndex++) {\n const entryName = this.metadataQuerier.GetEntryName(dracoMetadata, entryIndex);\n result[entryName] = this._getDracoMetadataField(dracoMetadata, entryName);\n }\n return result;\n }\n\n /**\n * Extracts possible values for one metadata entry by name\n * @param dracoMetadata\n * @param entryName\n */\n _getDracoMetadataField(dracoMetadata: Metadata, entryName: string): DracoMetadataEntry {\n const dracoArray = new this.draco.DracoInt32Array();\n try {\n // Draco metadata fields can hold int32 arrays\n this.metadataQuerier.GetIntEntryArray(dracoMetadata, entryName, dracoArray);\n const intArray = getInt32Array(dracoArray);\n return {\n int: this.metadataQuerier.GetIntEntry(dracoMetadata, entryName),\n string: this.metadataQuerier.GetStringEntry(dracoMetadata, entryName),\n double: this.metadataQuerier.GetDoubleEntry(dracoMetadata, entryName),\n intArray\n };\n } finally {\n this.draco.destroy(dracoArray);\n }\n }\n\n // QUANTIZED ATTRIBUTE SUPPORT (NO DECOMPRESSION)\n\n /** Skip transforms for specific attribute types */\n _disableAttributeTransforms(options: DracoParseOptions) {\n const {quantizedAttributes = [], octahedronAttributes = []} = options;\n const skipAttributes = [...quantizedAttributes, ...octahedronAttributes];\n for (const dracoAttributeName of skipAttributes) {\n this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);\n }\n }\n\n /**\n * Extract (and apply?) Position Transform\n * @todo not used\n */\n _getQuantizationTransform(\n dracoAttribute: PointAttribute,\n options: DracoParseOptions\n ): DracoQuantizationTransform | null {\n const {quantizedAttributes = []} = options;\n const attribute_type = dracoAttribute.attribute_type();\n const skip = quantizedAttributes.map((type) => this.decoder[type]).includes(attribute_type);\n if (skip) {\n const transform = new this.draco.AttributeQuantizationTransform();\n try {\n if (transform.InitFromAttribute(dracoAttribute)) {\n return {\n quantization_bits: transform.quantization_bits(),\n range: transform.range(),\n min_values: new Float32Array([1, 2, 3]).map((i) => transform.min_value(i))\n };\n }\n } finally {\n this.draco.destroy(transform);\n }\n }\n return null;\n }\n\n _getOctahedronTransform(\n dracoAttribute: PointAttribute,\n options: DracoParseOptions\n ): DracoOctahedronTransform | null {\n const {octahedronAttributes = []} = options;\n const attribute_type = dracoAttribute.attribute_type();\n const octahedron = octahedronAttributes\n .map((type) => this.decoder[type])\n .includes(attribute_type);\n if (octahedron) {\n const transform = new this.draco.AttributeQuantizationTransform();\n try {\n if (transform.InitFromAttribute(dracoAttribute)) {\n return {\n quantization_bits: transform.quantization_bits()\n };\n }\n } finally {\n this.draco.destroy(transform);\n }\n }\n return null;\n }\n\n // HELPERS\n}\n\n/**\n * Get draco specific data type by TypedArray constructor type\n * @param attributeType\n * @returns draco specific data type\n */\nfunction getDracoDataType(draco: Draco3D, attributeType: any): draco_DataType {\n switch (attributeType) {\n case Float32Array:\n return draco.DT_FLOAT32;\n case Int8Array:\n return draco.DT_INT8;\n case Int16Array:\n return draco.DT_INT16;\n case Int32Array:\n return draco.DT_INT32;\n case Uint8Array:\n return draco.DT_UINT8;\n case Uint16Array:\n return draco.DT_UINT16;\n case Uint32Array:\n return draco.DT_UINT32;\n default:\n return draco.DT_INVALID;\n }\n}\n\n/**\n * Copy a Draco int32 array into a JS typed array\n */\nfunction getInt32Array(dracoArray: DracoInt32Array): Int32Array {\n const numValues = dracoArray.size();\n const intArray = new Int32Array(numValues);\n for (let i = 0; i < numValues; i++) {\n intArray[i] = dracoArray.GetValue(i);\n }\n return intArray;\n}\n\n/**\n * Copy a Draco int32 array into a JS typed array\n */\nfunction getUint32Array(dracoArray: DracoInt32Array): Int32Array {\n const numValues = dracoArray.size();\n const intArray = new Int32Array(numValues);\n for (let i = 0; i < numValues; i++) {\n intArray[i] = dracoArray.GetValue(i);\n }\n return intArray;\n}\n","// Mesh category utilities\n// TODO - move to mesh category module, or to math.gl/geometry module\nimport {TypedArray} from '../../types';\nimport {MeshAttributes} from './mesh-types';\n\ntype TypedArrays = {[key: string]: TypedArray};\n\n/**\n * Holds an axis aligned bounding box\n * TODO - make sure AxisAlignedBoundingBox in math.gl/culling understands this format (or change this format)\n */\ntype BoundingBox = [[number, number, number], [number, number, number]];\n\n/**\n * Get number of vertices in mesh\n * @param attributes\n */\nexport function getMeshSize(attributes: TypedArrays): number {\n let size = 0;\n for (const attributeName in attributes) {\n const attribute = attributes[attributeName];\n if (ArrayBuffer.isView(attribute)) {\n // @ts-ignore DataView doesn't have BYTES_PER_ELEMENT\n size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;\n }\n }\n return size;\n}\n\n/**\n * Get the (axis aligned) bounding box of a mesh\n * @param attributes\n * @returns array of two vectors representing the axis aligned bounding box\n */\n// eslint-disable-next-line complexity\nexport function getMeshBoundingBox(attributes: MeshAttributes): BoundingBox {\n let minX = Infinity;\n let minY = Infinity;\n let minZ = Infinity;\n let maxX = -Infinity;\n let maxY = -Infinity;\n let maxZ = -Infinity;\n\n const positions = attributes.POSITION ? attributes.POSITION.value : [];\n const len = positions && positions.length;\n\n for (let i = 0; i < len; i += 3) {\n const x = positions[i];\n const y = positions[i + 1];\n const z = positions[i + 2];\n\n minX = x < minX ? x : minX;\n minY = y < minY ? y : minY;\n minZ = z < minZ ? z : minZ;\n\n maxX = x > maxX ? x : maxX;\n maxY = y > maxY ? y : maxY;\n maxZ = z > maxZ ? z : maxZ;\n }\n return [\n [minX, minY, minZ],\n [maxX, maxY, maxZ]\n ];\n}\n","/* global importScripts */\nimport {global, isBrowser, isWorker} from '../env-utils/globals';\nimport * as node from '../node/require-utils.node';\nimport {assert} from '../env-utils/assert';\nimport {VERSION as __VERSION__} from '../env-utils/version';\n\n// TODO - unpkg.com doesn't seem to have a `latest` specifier for alpha releases...\nconst LATEST = 'beta';\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : LATEST;\n\nconst loadLibraryPromises = {}; // promises\n\n/**\n * Dynamically loads a library (\"module\")\n *\n * - wasm library: Array buffer is returned\n * - js library: Parse JS is returned\n *\n * Method depends on environment\n * - browser - script element is created and installed on document\n * - worker - eval is called on global context\n * - node - file is required\n *\n * @param libraryUrl\n * @param moduleName\n * @param options\n */\nexport async function loadLibrary(\n libraryUrl: string,\n moduleName: string | null = null,\n options: object = {}\n): Promise<any> {\n if (moduleName) {\n libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);\n }\n\n // Ensure libraries are only loaded once\n loadLibraryPromises[libraryUrl] =\n loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);\n return await loadLibraryPromises[libraryUrl];\n}\n\n// TODO - sort out how to resolve paths for main/worker and dev/prod\nexport function getLibraryUrl(library, moduleName?: string, options?): string {\n // Check if already a URL\n if (library.startsWith('http')) {\n return library;\n }\n\n // Allow application to import and supply libraries through `options.modules`\n const modules = options.modules || {};\n if (modules[library]) {\n return modules[library];\n }\n\n // Load from local files, not from CDN scripts in Node.js\n // TODO - needs to locate the modules directory when installed!\n if (!isBrowser) {\n return `modules/${moduleName}/dist/libs/${library}`;\n }\n\n // In browser, load from external scripts\n if (options.CDN) {\n assert(options.CDN.startsWith('http'));\n return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${library}`;\n }\n\n // TODO - loading inside workers requires paths relative to worker script location...\n if (isWorker) {\n return `../src/libs/${library}`;\n }\n\n return `modules/${moduleName}/src/libs/${library}`;\n}\n\nasync function loadLibraryFromFile(libraryUrl) {\n if (libraryUrl.endsWith('wasm')) {\n const response = await fetch(libraryUrl);\n return await response.arrayBuffer();\n }\n\n if (!isBrowser) {\n return node.requireFromFile && (await node.requireFromFile(libraryUrl));\n }\n if (isWorker) {\n return importScripts(libraryUrl);\n }\n // TODO - fix - should be more secure than string parsing since observes CORS\n // if (isBrowser) {\n // return await loadScriptFromFile(libraryUrl);\n // }\n\n const response = await fetch(libraryUrl);\n const scriptSource = await response.text();\n return loadLibraryFromString(scriptSource, libraryUrl);\n}\n\n/*\nasync function loadScriptFromFile(libraryUrl) {\n const script = document.createElement('script');\n script.src = libraryUrl;\n return await new Promise((resolve, reject) => {\n script.onload = data => {\n resolve(data);\n };\n script.onerror = reject;\n });\n}\n*/\n\n// TODO - Needs security audit...\n// - Raw eval call\n// - Potentially bypasses CORS\n// Upside is that this separates fetching and parsing\n// we could create a`LibraryLoader` or`ModuleLoader`\nfunction loadLibraryFromString(scriptSource, id) {\n if (!isBrowser) {\n return node.requireFromString && node.requireFromString(scriptSource, id);\n }\n\n if (isWorker) {\n // Use lvalue trick to make eval run in global scope\n eval.call(global, scriptSource); // eslint-disable-line no-eval\n // https://stackoverflow.com/questions/9107240/1-evalthis-vs-evalthis-in-javascript\n // http://perfectionkills.com/global-eval-what-are-the-options/\n return null;\n }\n\n const script = document.createElement('script');\n script.id = id;\n // most browsers like a separate text node but some throw an error. The second method covers those.\n try {\n script.appendChild(document.createTextNode(scriptSource));\n } catch (e) {\n script.text = scriptSource;\n }\n document.body.appendChild(script);\n return null;\n}\n\n// TODO - technique for module injection into worker, from THREE.DracoLoader...\n/*\nfunction combineWorkerWithLibrary(worker, jsContent) {\n var fn = wWorker.toString();\n var body = [\n '// injected',\n jsContent,\n '',\n '// worker',\n fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))\n ].join('\\n');\n this.workerSourceURL = URL.createObjectURL(new Blob([body]));\n}\n*/\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\n\n/** Throws an `Error` with the optional `message` if `condition` is falsy */\nexport function assert(condition: any, message?: string): void {\n if (!condition) {\n throw new Error(message || 'loaders.gl assertion failed.');\n }\n}\n","// Dynamic DRACO module loading inspired by THREE.DRACOLoader\n// https://github.com/mrdoob/three.js/blob/398c4f39ebdb8b23eefd4a7a5ec49ec0c96c7462/examples/jsm/loaders/DRACOLoader.js\n// by Don McCurdy / https://www.donmccurdy.com / MIT license\n\nimport {loadLibrary} from '@loaders.gl/worker-utils';\n\nconst DRACO_VERSION = '1.4.1';\nconst DRACO_JS_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.js`;\nconst DRACO_WASM_WRAPPER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_wasm_wrapper.js`;\nconst DRACO_WASM_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.wasm`;\n\nconst DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_VERSION}/javascript/draco_encoder.js`;\n\nlet loadDecoderPromise;\nlet loadEncoderPromise;\n\nexport async function loadDracoDecoderModule(options) {\n const modules = options.modules || {};\n\n // Check if a bundled draco3d library has been supplied by application\n if (modules.draco3d) {\n loadDecoderPromise =\n loadDecoderPromise ||\n modules.draco3d.createDecoderModule({}).then((draco) => {\n return {draco};\n });\n } else {\n // If not, dynamically load the WASM script from our CDN\n loadDecoderPromise = loadDecoderPromise || loadDracoDecoder(options);\n }\n return await loadDecoderPromise;\n}\n\nexport async function loadDracoEncoderModule(options) {\n const modules = options.modules || {};\n\n // Check if a bundled draco3d library has been supplied by application\n if (modules.draco3d) {\n loadEncoderPromise =\n loadEncoderPromise ||\n modules.draco3d.createEncoderModule({}).then((draco) => {\n return {draco};\n });\n } else {\n // If not, dynamically load the WASM script from our CDN\n loadEncoderPromise = loadEncoderPromise || loadDracoEncoder(options);\n }\n return await loadEncoderPromise;\n}\n\n// DRACO DECODER LOADING\n\nasync function loadDracoDecoder(options) {\n let DracoDecoderModule;\n let wasmBinary;\n switch (options.draco && options.draco.decoderType) {\n case 'js':\n DracoDecoderModule = await loadLibrary(DRACO_JS_DECODER_URL, 'draco', options);\n break;\n\n case 'wasm':\n default:\n [DracoDecoderModule, wasmBinary] = await Promise.all([\n await loadLibrary(DRACO_WASM_WRAPPER_URL, 'draco', options),\n await loadLibrary(DRACO_WASM_DECODER_URL, 'draco', options)\n ]);\n }\n // Depends on how import happened...\n // @ts-ignore\n DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;\n return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);\n}\n\nfunction initializeDracoDecoder(DracoDecoderModule, wasmBinary) {\n const options: {wasmBinary?: any} = {};\n if (wasmBinary) {\n options.wasmBinary = wasmBinary;\n }\n\n return new Promise((resolve) => {\n DracoDecoderModule({\n ...options,\n onModuleLoaded: (draco) => resolve({draco}) // Module is Promise-like. Wrap in object to avoid loop.\n });\n });\n}\n\n// ENCODER\n\nasync function loadDracoEncoder(options) {\n let DracoEncoderModule = await loadLibrary(DRACO_ENCODER_URL, 'draco', options);\n // @ts-ignore\n DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;\n\n return new Promise((resolve) => {\n DracoEncoderModule({\n onModuleLoaded: (draco) => resolve({draco}) // Module is Promise-like. Wrap in object to avoid loop.\n });\n });\n}\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {DracoMesh, DracoLoaderData} from './lib/draco-types';\nimport type {DracoLoaderOptions} from './draco-loader';\nimport {DracoLoader as DracoWorkerLoader} from './draco-loader';\nimport DracoParser from './lib/draco-parser';\nimport {loadDracoDecoderModule} from './lib/draco-module-loader';\n\n// Draco data types\n\nexport type {DracoMesh, DracoLoaderData};\n\n// Draco Writer\n\nexport type {DracoWriterOptions} from './draco-writer';\nexport {DracoWriter} from './draco-writer';\n\n// Draco Loader\n\nexport type {DracoLoaderOptions};\nexport {DracoWorkerLoader};\n\n/**\n * Loader for Draco3D compressed geometries\n */\nexport const DracoLoader = {\n ...DracoWorkerLoader,\n parse\n};\n\nasync function parse(arrayBuffer: ArrayBuffer, options?: DracoLoaderOptions): Promise<DracoMesh> {\n const {draco} = await loadDracoDecoderModule(options);\n const dracoParser = new DracoParser(draco);\n try {\n return dracoParser.parseSync(arrayBuffer, options?.draco);\n } finally {\n dracoParser.destroy();\n }\n}\n\n// TYPE TESTS - TODO find a better way than exporting junk\nexport const _TypecheckDracoLoader: LoaderWithParser = DracoLoader;\n","// Subset of WebGL constants\n\nexport const GL_PRIMITIVE = {\n POINTS: 0x0000, // Points. single points.\n LINES: 0x0001, // Lines. Each vertex connects to the one after it.\n TRIANGLES: 0x0004 // Triangles. Each set of three vertices creates a separate triangle.\n};\n\n// Primitive modes\nexport const GL_PRIMITIVE_MODE = {\n POINTS: 0x0000, // Points. single points.\n LINES: 0x0001, // Lines. Each vertex connects to the one after it.\n LINE_LOOP: 0x0002, // Lines. Each set of two vertices is treated as a separate line segment.\n LINE_STRIP: 0x0003, // Lines/ a connected group of line segments from the first vertex to the last\n TRIANGLES: 0x0004, // Triangles. Each set of three vertices creates a separate triangle.\n TRIANGLE_STRIP: 0x0005, // Triangles. A connected group of triangles.\n TRIANGLE_FAN: 0x0006 // Triangles. A connected group of triangles.\n // Each vertex connects to the previous and the first vertex in the fan.\n};\n\ntype glType = {\n BYTE: number;\n UNSIGNED_BYTE: number;\n SHORT: number;\n UNSIGNED_SHORT: number;\n INT: number;\n UNSIGNED_INT: number;\n FLOAT: number;\n DOUBLE: number;\n};\n\nexport const GL_TYPE: glType = {\n BYTE: 5120,\n UNSIGNED_BYTE: 5121,\n SHORT: 5122,\n UNSIGNED_SHORT: 5123,\n INT: 5124,\n UNSIGNED_INT: 5125,\n FLOAT: 5126,\n DOUBLE: 5130\n};\n\nexport const GL = {\n ...GL_PRIMITIVE_MODE,\n ...GL_TYPE\n};\n","import {TypedArray} from '../types';\nimport {GL_TYPE as GL} from '../constants';\n\nconst GL_TYPE_TO_ARRAY_TYPE = {\n [GL.DOUBLE]: Float64Array,\n [GL.FLOAT]: Float32Array,\n [GL.UNSIGNED_SHORT]: Uint16Array,\n [GL.UNSIGNED_INT]: Uint32Array,\n [GL.UNSIGNED_BYTE]: Uint8Array,\n [GL.BYTE]: Int8Array,\n [GL.SHORT]: Int16Array,\n [GL.INT]: Int32Array\n};\ntype GlTypeMap = {\n [index: string]: number;\n};\nconst NAME_TO_GL_TYPE: GlTypeMap = {\n DOUBLE: GL.DOUBLE,\n FLOAT: GL.FLOAT,\n UNSIGNED_SHORT: GL.UNSIGNED_SHORT,\n UNSIGNED_INT: GL.UNSIGNED_INT,\n UNSIGNED_BYTE: GL.UNSIGNED_BYTE,\n BYTE: GL.BYTE,\n SHORT: GL.SHORT,\n INT: GL.INT\n};\nconst ERR_TYPE_CONVERSION = 'Failed to convert GL type';\n// Converts TYPED ARRAYS to corresponding GL constant\n// Used to auto deduce gl parameter types\nexport default class GLType {\n // Signature: fromTypedArray(new Uint8Array())\n // Signature: fromTypedArray(Uint8Array)\n /**\n * Returns the size, in bytes, of the corresponding datatype\n * @param arrayOrType\n * @returns glType a a string\n */\n static fromTypedArray(arrayOrType: TypedArray | Function): string {\n // If typed array, look up constructor\n arrayOrType = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;\n for (const glType in GL_TYPE_TO_ARRAY_TYPE) {\n const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];\n if (ArrayType === arrayOrType) {\n return glType;\n }\n }\n throw new Error(ERR_TYPE_CONVERSION);\n }\n /**\n * Extracts name for glType from array NAME_TO_GL_TYPE\n * @param name\n * @returns glType as a number\n */\n static fromName(name: string): number {\n const glType = NAME_TO_GL_TYPE[name];\n if (!glType) {\n throw new Error(ERR_TYPE_CONVERSION);\n }\n return glType;\n }\n // Converts GL constant to corresponding typed array type\n // eslint-disable-next-line complexity\n static getArrayType(glType: number) {\n switch (glType) {\n /*eslint-disable*/\n // @ts-ignore\n case GL.UNSIGNED_SHORT_5_6_5:\n // @ts-ignore\n case GL.UNSIGNED_SHORT_4_4_4_4:\n // @ts-ignore\n case GL.UNSIGNED_SHORT_5_5_5_1:\n /* eslint-enable*/\n return Uint16Array;\n default:\n const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];\n if (!ArrayType) {\n throw new Error(ERR_TYPE_CONVERSION);\n }\n return ArrayType;\n }\n }\n /**\n * Returns the size in bytes of one element of the provided WebGL type\n * @param glType\n * @returns size of glType\n */\n static getByteSize(glType: number): number {\n const ArrayType = GLType.getArrayType(glType);\n return ArrayType.BYTES_PER_ELEMENT;\n }\n /**\n * Returns `true` if `glType` is a valid WebGL data type.\n * @param glType\n * @returns boolean\n */\n static validate(glType: number): boolean {\n return Boolean(GLType.getArrayType(glType));\n }\n /**\n * Creates a typed view of an array of bytes\n * @param glType The type of typed array (ArrayBuffer view) to create\n * @param buffer The buffer storage to use for the view.\n * @param byteOffset The offset, in bytes, to the first element in the view\n * @param length The number of elements in the view. Defaults to buffer length\n * @returns A typed array view of the buffer\n */\n static createTypedArray(\n glType: number,\n buffer: TypedArray,\n byteOffset: number = 0,\n length?: number\n ): TypedArray {\n if (length === undefined) {\n length = (buffer.byteLength - byteOffset) / GLType.getByteSize(glType);\n }\n const ArrayType = GLType.getArrayType(glType);\n return new ArrayType(buffer, byteOffset, 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 {GL, GLType} from '@loaders.gl/math';\n\n// Reference:\n// https://github.com/AnalyticalGraphicsInc/cesium/blob/1de96d087f0b17575eb1a3f736407b348c765d59/Source/Scene/Cesium3DTileFeatureTable.js\nexport default class Tile3DFeatureTable {\n constructor(featureTableJson, featureTableBinary) {\n this.json = featureTableJson;\n this.buffer = featureTableBinary;\n this.featuresLength = 0;\n this._cachedTypedArrays = {};\n }\n\n getExtension(extensionName) {\n return this.json.extensions && this.json.extensions[extensionName];\n }\n\n hasProperty(propertyName) {\n return Boolean(this.json[propertyName]);\n }\n\n getGlobalProperty(propertyName, componentType = GL.UNSIGNED_INT, componentLength = 1) {\n const jsonValue = this.json[propertyName];\n\n if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {\n return this._getTypedArrayFromBinary(\n propertyName,\n componentType,\n componentLength,\n 1,\n jsonValue.byteOffset\n );\n }\n\n return jsonValue;\n }\n\n getPropertyArray(propertyName, componentType, componentLength) {\n const jsonValue = this.json[propertyName];\n\n if (jsonValue && Number.isFinite(jsonValue.byteOffset)) {\n if ('componentType' in jsonValue) {\n componentType = GLType.fromName(jsonValue.componentType);\n }\n return this._getTypedArrayFromBinary(\n propertyName,\n componentType,\n componentLength,\n this.featuresLength,\n jsonValue.byteOffset\n );\n }\n\n return this._getTypedArrayFromArray(propertyName, componentType, jsonValue);\n }\n\n getProperty(propertyName, componentType, componentLength, featureId, result) {\n const jsonValue = this.json[propertyName];\n if (!jsonValue) {\n return jsonValue;\n }\n\n const typedArray = this.getPropertyArray(propertyName, componentType, componentLength);\n\n if (componentLength === 1) {\n return typedArray[featureId];\n }\n\n for (let i = 0; i < componentLength; ++i) {\n result[i] = typedArray[componentLength * featureId + i];\n }\n\n return result;\n }\n\n // HELPERS\n\n _getTypedArrayFromBinary(propertyName, componentType, componentLength, count, byteOffset) {\n const cachedTypedArrays = this._cachedTypedArrays;\n let typedArray = cachedTypedArrays[propertyName];\n if (!typedArray) {\n typedArray = GLType.createTypedArray(\n componentType,\n this.buffer.buffer,\n this.buffer.byteOffset + byteOffset,\n count * componentLength\n );\n cachedTypedArrays[propertyName] = typedArray;\n }\n return typedArray;\n }\n\n _getTypedArrayFromArray(propertyName, componentType, array) {\n const cachedTypedArrays = this._cachedTypedArrays;\n let typedArray = cachedTypedArrays[propertyName];\n if (!typedArray) {\n typedArray = GLType.createTypedArray(componentType, array);\n cachedTypedArrays[propertyName] = typedArray;\n }\n return typedArray;\n }\n}\n","import {GLType} from '@loaders.gl/math'; // '@math.gl/geometry';\nimport {assert} from '@loaders.gl/loader-utils';\n\nconst COMPONENTS_PER_ATTRIBUTE = {\n SCALAR: 1,\n VEC2: 2,\n VEC3: 3,\n VEC4: 4,\n MAT2: 4,\n MAT3: 9,\n MAT4: 16\n};\n\n// TODO - could just return typed array views...\n// prettier-ignore\nconst UNPACKER = {\n SCALAR: (values, i) => values[i],\n VEC2: (values, i) => [values[2 * i + 0], values[2 * i + 1]],\n VEC3: (values, i) => [values[3 * i + 0], values[3 * i + 1], values[3 * i + 2]],\n VEC4: (values, i) => [values[4 * i + 0], values[4 * i + 1], values[4 * i + 2], values[4 * i + 3]],\n // TODO: check column major\n MAT2: (values, i) => [\n values[4 * i + 0], values[4 * i + 1],\n values[4 * i + 2], values[4 * i + 3]\n ],\n MAT3: (values, i) => [\n values[9 * i + 0], values[9 * i + 1], values[9 * i + 2],\n values[9 * i + 3], values[9 * i + 4], values[9 * i + 5],\n values[9 * i + 6], values[9 * i + 7], values[9 * i + 8]\n ],\n MAT4: (values, i) => [\n values[16 * i + 0], values[16 * i + 1], values[16 * i + 2], values[16 * i + 3],\n values[16 * i + 4], values[16 * i + 5], values[16 * i + 6], values[16 * i + 7],\n values[16 * i + 8], values[16 * i + 9], values[16 * i + 10], values[16 * i + 11],\n values[16 * i + 12], values[16 * i + 13], values[16 * i + 14], values[16 * i + 15]\n ]\n};\n\nconst PACKER = {\n SCALAR: (x, values, i) => {\n values[i] = x;\n },\n VEC2: (x, values, i) => {\n values[2 * i + 0] = x[0];\n values[2 * i + 1] = x[1];\n },\n VEC3: (x, values, i) => {\n values[3 * i + 0] = x[0];\n values[3 * i + 1] = x[1];\n values[3 * i + 2] = x[2];\n },\n VEC4: (x, values, i) => {\n values[4 * i + 0] = x[0];\n values[4 * i + 1] = x[1];\n values[4 * i + 2] = x[2];\n values[4 * i + 3] = x[3];\n },\n // TODO: check column major correctness\n MAT2: (x, values, i) => {\n values[4 * i + 0] = x[0];\n values[4 * i + 1] = x[1];\n values[4 * i + 2] = x[2];\n values[4 * i + 3] = x[3];\n },\n MAT3: (x, values, i) => {\n values[9 * i + 0] = x[0];\n values[9 * i + 1] = x[1];\n values[9 * i + 2] = x[2];\n values[9 * i + 3] = x[3];\n values[9 * i + 4] = x[4];\n values[9 * i + 5] = x[5];\n values[9 * i + 6] = x[6];\n values[9 * i + 7] = x[7];\n values[9 * i + 8] = x[8];\n values[9 * i + 9] = x[9];\n },\n MAT4: (x, values, i) => {\n values[16 * i + 0] = x[0];\n values[16 * i + 1] = x[1];\n values[16 * i + 2] = x[2];\n values[16 * i + 3] = x[3];\n values[16 * i + 4] = x[4];\n values[16 * i + 5] = x[5];\n values[16 * i + 6] = x[6];\n values[16 * i + 7] = x[7];\n values[16 * i + 8] = x[8];\n values[16 * i + 9] = x[9];\n values[16 * i + 10] = x[10];\n values[16 * i + 11] = x[11];\n values[16 * i + 12] = x[12];\n values[16 * i + 13] = x[13];\n values[16 * i + 14] = x[14];\n values[16 * i + 15] = x[15];\n }\n};\n\nexport function createTypedArrayFromAccessor(tile3DAccessor, buffer, byteOffset, length) {\n const {componentType} = tile3DAccessor;\n assert(tile3DAccessor.componentType);\n const type = typeof componentType === 'string' ? GLType.fromName(componentType) : componentType;\n const size = COMPONENTS_PER_ATTRIBUTE[tile3DAccessor.type];\n const unpacker = UNPACKER[tile3DAccessor.type];\n const packer = PACKER[tile3DAccessor.type];\n\n byteOffset += tile3DAccessor.byteOffset;\n const values = GLType.createTypedArray(type, buffer, byteOffset, size * length);\n\n return {\n values,\n type,\n size,\n unpacker,\n packer\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// TODO - Finish hierarchy suypport: this file is only half ported\n/* eslint-disable */\n// @ts-nocheck\nconst defined = (x) => x !== undefined;\n\nexport function initializeHierarchy(batchTable, jsonHeader, binaryBody) {\n if (!jsonHeader) {\n return null;\n }\n\n let hierarchy = batchTable.getExtension('3DTILES_batch_table_hierarchy');\n\n const legacyHierarchy = jsonHeader.HIERARCHY;\n if (legacyHierarchy) {\n // eslint-disable-next-line\n console.warn('3D Tile Parser: HIERARCHY is deprecated. Use 3DTILES_batch_table_hierarchy.');\n jsonHeader.extensions = jsonHeader.extensions || {};\n jsonHeader.extensions['3DTILES_batch_table_hierarchy'] = legacyHierarchy;\n hierarchy = legacyHierarchy;\n }\n\n if (!hierarchy) {\n return null;\n }\n\n return initializeHierarchyValues(hierarchy, binaryBody);\n}\n\n// eslint-disable-next-line max-statements\nfunction initializeHierarchyValues(hierarchyJson, binaryBody) {\n let i;\n let classId;\n let binaryAccessor;\n\n const instancesLength = hierarchyJson.instancesLength;\n const classes = hierarchyJson.classes;\n let classIds = hierarchyJson.classIds;\n let parentCounts = hierarchyJson.parentCounts;\n let parentIds = hierarchyJson.parentIds;\n let parentIdsLength = instancesLength;\n\n if (defined(classIds.byteOffset)) {\n classIds.componentType = defaultValue(classIds.componentType, GL.UNSIGNED_SHORT);\n classIds.type = AttributeType.SCALAR;\n binaryAccessor = getBinaryAccessor(classIds);\n classIds = binaryAccessor.createArrayBufferView(\n binaryBody.buffer,\n binaryBody.byteOffset + classIds.byteOffset,\n instancesLength\n );\n }\n\n let parentIndexes;\n if (defined(parentCounts)) {\n if (defined(parentCounts.byteOffset)) {\n parentCounts.componentType = defaultValue(parentCounts.componentType, GL.UNSIGNED_SHORT);\n parentCounts.type = AttributeType.SCALAR;\n binaryAccessor = getBinaryAccessor(parentCounts);\n parentCounts = binaryAccessor.createArrayBufferView(\n binaryBody.buffer,\n binaryBody.byteOffset + parentCounts.byteOffset,\n instancesLength\n );\n }\n parentIndexes = new Uint16Array(instancesLength);\n parentIdsLength = 0;\n for (i = 0; i < instancesLength; ++i) {\n parentIndexes[i] = parentIdsLength;\n parentIdsLength += parentCounts[i];\n }\n }\n\n if (defined(parentIds) && defined(parentIds.byteOffset)) {\n parentIds.componentType = defaultValue(parentIds.componentType, GL.UNSIGNED_SHORT);\n parentIds.type = AttributeType.SCALAR;\n binaryAccessor = getBinaryAccessor(parentIds);\n parentIds = binaryAccessor.createArrayBufferView(\n binaryBody.buffer,\n binaryBody.byteOffset + parentIds.byteOffset,\n parentIdsLength\n );\n }\n\n const classesLength = classes.length;\n for (i = 0; i < classesLength; ++i) {\n const classInstancesLength = classes[i].length;\n const properties = classes[i].instances;\n const binaryProperties = getBinaryProperties(classInstancesLength, properties, binaryBody);\n classes[i].instances = combine(binaryProperties, properties);\n }\n\n const classCounts = new Array(classesLength).fill(0);\n const classIndexes = new Uint16Array(instancesLength);\n for (i = 0; i < instancesLength; ++i) {\n classId = classIds[i];\n classIndexes[i] = classCounts[classId];\n ++classCounts[classId];\n }\n\n const hierarchy = {\n classes,\n classIds,\n classIndexes,\n parentCounts,\n parentIndexes,\n parentIds\n };\n\n validateHierarchy(hierarchy);\n\n return hierarchy;\n}\n\n// HELPER CODE\n\n// Traverse over the hierarchy and process each instance with the endConditionCallback.\n// When the endConditionCallback returns a value, the traversal stops and that value is returned.\nexport function traverseHierarchy(hierarchy, instanceIndex, endConditionCallback) {\n if (!hierarchy) {\n return;\n }\n\n const parentCounts = hierarchy.parentCounts;\n const parentIds = hierarchy.parentIds;\n if (parentIds) {\n return endConditionCallback(hierarchy, instanceIndex);\n }\n if (parentCounts > 0) {\n return traverseHierarchyMultipleParents(hierarchy, instanceIndex, endConditionCallback);\n }\n return traverseHierarchySingleParent(hierarchy, instanceIndex, endConditionCallback);\n}\n\n// eslint-disable-next-line max-statements\nfunction traverseHierarchyMultipleParents(hierarchy, instanceIndex, endConditionCallback) {\n const classIds = hierarchy.classIds;\n const parentCounts = hierarchy.parentCounts;\n const parentIds = hierarchy.parentIds;\n const parentIndexes = hierarchy.parentIndexes;\n const instancesLength = classIds.length;\n\n // Ignore instances that have already been visited. This occurs in diamond inheritance situations.\n // Use a marker value to indicate that an instance has been visited, which increments with each run.\n // This is more efficient than clearing the visited array every time.\n const visited = scratchVisited;\n visited.length = Math.max(visited.length, instancesLength);\n const visitedMarker = ++marker;\n\n const stack = scratchStack;\n stack.length = 0;\n stack.push(instanceIndex);\n\n while (stack.length > 0) {\n instanceIndex = stack.pop();\n if (visited[instanceIndex] === visitedMarker) {\n // This instance has already been visited, stop traversal\n continue;\n }\n visited[instanceIndex] = visitedMarker;\n const result = endConditionCallback(hierarchy, instanceIndex);\n if (defined(result)) {\n // The end condition was met, stop the traversal and return the result\n return result;\n }\n const parentCount = parentCounts[instanceIndex];\n const parentIndex = parentIndexes[instanceIndex];\n for (let i = 0; i < parentCount; ++i) {\n const parentId = parentIds[parentIndex + i];\n // Stop the traversal when the instance has no parent (its parentId equals itself)\n // else add the parent to the stack to continue the traversal.\n if (parentId !== instanceIndex) {\n stack.push(parentId);\n }\n }\n }\n\n return null;\n}\n\nfunction traverseHierarchySingleParent(hierarchy, instanceIndex, endConditionCallback) {\n let hasParent = true;\n while (hasParent) {\n const result = endConditionCallback(hierarchy, instanceIndex);\n if (defined(result)) {\n // The end condition was met, stop the traversal and return the result\n return result;\n }\n const parentId = hierarchy.parentIds[instanceIndex];\n hasParent = parentId !== instanceIndex;\n instanceIndex = parentId;\n }\n throw new Error('traverseHierarchySingleParent');\n}\n\n// DEBUG CODE\n\nfunction validateHierarchy(hierarchy) {\n const scratchValidateStack = [];\n\n const classIds = hierarchy.classIds;\n const instancesLength = classIds.length;\n\n for (let i = 0; i < instancesLength; ++i) {\n validateInstance(hierarchy, i, stack);\n }\n}\n\nfunction validateInstance(hierarchy, instanceIndex, stack) {\n const parentCounts = hierarchy.parentCounts;\n const parentIds = hierarchy.parentIds;\n const parentIndexes = hierarchy.parentIndexes;\n const classIds = hierarchy.classIds;\n const instancesLength = classIds.length;\n\n if (!defined(parentIds)) {\n // No need to validate if there are no parents\n return;\n }\n\n assert(\n instanceIndex < instancesLength,\n `Parent index ${instanceIndex} exceeds the total number of instances: ${instancesLength}`\n );\n assert(\n stack.indexOf(instanceIndex) === -1,\n 'Circular dependency detected in the batch table hierarchy.'\n );\n\n stack.push(instanceIndex);\n const parentCount = defined(parentCounts) ? parentCounts[instanceIndex] : 1;\n const parentIndex = defined(parentCounts) ? parentIndexes[instanceIndex] : instanceIndex;\n for (let i = 0; i < parentCount; ++i) {\n const parentId = parentIds[parentIndex + i];\n // Stop the traversal when the instance has no parent (its parentId equals itself), else continue the traversal.\n if (parentId !== instanceIndex) {\n validateInstance(hierarchy, parentId, stack);\n }\n }\n stack.pop(instanceIndex);\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\nimport {createTypedArrayFromAccessor} from './helpers/tile-3d-accessor-utils';\nimport {initializeHierarchy, traverseHierarchy} from './tile-3d-batch-table-hierarchy';\n\nfunction defined(x) {\n return x !== undefined && x !== null;\n}\n\nconst clone = (x, y) => x;\n\n// These top level fields in the batch table json are not properties\nconst IGNORED_PROPERTY_FIELDS = {\n HIERARCHY: true, // Deprecated HIERARCHY property\n extensions: true,\n extras: true\n};\n\n// The size of this array equals the maximum instance count among all loaded tiles, which has the potential to be large.\nexport default class Tile3DBatchTableParser {\n constructor(json, binary, featureCount, options = {}) {\n assert(featureCount >= 0);\n this.json = json || {};\n this.binary = binary;\n this.featureCount = featureCount;\n\n this._extensions = this.json?.extensions || {};\n\n // Copy all top-level property fields from the json object, ignoring special fields\n this._properties = {};\n for (const propertyName in this.json) {\n if (!IGNORED_PROPERTY_FIELDS[propertyName]) {\n this._properties[propertyName] = this.json[propertyName];\n }\n }\n\n this._binaryProperties = this._initializeBinaryProperties();\n\n // TODO: hierarchy support is only partially implemented and not tested\n if (options['3DTILES_batch_table_hierarchy']) {\n this._hierarchy = initializeHierarchy(this, this.json, this.binary);\n }\n }\n\n getExtension(extensionName) {\n return this.json && this.json.extensions && this.json.extensions[extensionName];\n }\n\n memorySizeInBytes() {\n return 0;\n }\n\n isClass(batchId, className) {\n this._checkBatchId(batchId);\n assert(typeof className === 'string', className);\n\n // extension: 3DTILES_batch_table_hierarchy\n if (this._hierarchy) {\n // PERFORMANCE_IDEA : cache results in the ancestor classes\n // to speed up this check if this area becomes a hotspot\n // PERFORMANCE_IDEA : treat class names as integers for faster comparisons\n const result = traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {\n const classId = hierarchy.classIds[instanceIndex];\n const instanceClass = hierarchy.classes[classId];\n return instanceClass.name === className;\n });\n return defined(result);\n }\n\n return false;\n }\n\n isExactClass(batchId, className) {\n assert(typeof className === 'string', className);\n\n return this.getExactClassName(batchId) === className;\n }\n\n getExactClassName(batchId) {\n this._checkBatchId(batchId);\n\n // extension: 3DTILES_batch_table_hierarchy\n if (this._hierarchy) {\n const classId = this._hierarchy.classIds[batchId];\n const instanceClass = this._hierarchy.classes[classId];\n return instanceClass.name;\n }\n\n return undefined;\n }\n\n hasProperty(batchId, name) {\n this._checkBatchId(batchId);\n assert(typeof name === 'string', name);\n\n return defined(this._properties[name]) || this._hasPropertyInHierarchy(batchId, name);\n }\n\n getPropertyNames(batchId, results) {\n this._checkBatchId(batchId);\n\n results = defined(results) ? results : [];\n results.length = 0;\n\n const propertyNames = Object.keys(this._properties);\n results.push(...propertyNames);\n\n if (this._hierarchy) {\n this._getPropertyNamesInHierarchy(batchId, results);\n }\n\n return results;\n }\n\n getProperty(batchId, name) {\n this._checkBatchId(batchId);\n assert(typeof name === 'string', name);\n\n if (this._binaryProperties) {\n const binaryProperty = this._binaryProperties[name];\n if (defined(binaryProperty)) {\n return this._getBinaryProperty(binaryProperty, batchId);\n }\n }\n\n const propertyValues = this._properties[name];\n if (defined(propertyValues)) {\n return clone(propertyValues[batchId], true);\n }\n\n // EXTENSION: 3DTILES_batch_table_hierarchy\n if (this._hierarchy) {\n const hierarchyProperty = this._getHierarchyProperty(batchId, name);\n if (defined(hierarchyProperty)) {\n return hierarchyProperty;\n }\n }\n\n return undefined;\n }\n\n setProperty(batchId, name, value) {\n const featureCount = this.featureCount;\n\n this._checkBatchId(batchId);\n assert(typeof name === 'string', name);\n\n if (this._binaryProperties) {\n const binaryProperty = this._binaryProperties[name];\n if (binaryProperty) {\n this._setBinaryProperty(binaryProperty, batchId, value);\n return;\n }\n }\n\n // EXTENSION: 3DTILES_batch_table_hierarchy\n if (this._hierarchy) {\n if (this._setHierarchyProperty(this, batchId, name, value)) {\n return;\n }\n }\n\n let propertyValues = this._properties[name];\n if (!defined(propertyValues)) {\n // Property does not exist. Create it.\n this._properties[name] = new Array(featureCount);\n propertyValues = this._properties[name];\n }\n\n propertyValues[batchId] = clone(value, true);\n }\n\n // PRIVATE METHODS\n\n _checkBatchId(batchId) {\n const valid = batchId >= 0 && batchId < this.featureCount;\n if (!valid) {\n throw new Error(`batchId not in range [0, featureCount - 1].`);\n }\n }\n\n _getBinaryProperty(binaryProperty, index) {\n return binaryProperty.unpack(binaryProperty.typedArray, index);\n }\n\n _setBinaryProperty(binaryProperty, index, value) {\n binaryProperty.pack(value, binaryProperty.typedArray, index);\n }\n\n _initializeBinaryProperties() {\n let binaryProperties = null;\n for (const name in this._properties) {\n const property = this._properties[name];\n const binaryProperty = this._initializeBinaryProperty(name, property);\n // Store any information needed to access the binary data, including the typed array,\n // componentCount (e.g. a VEC4 would be 4), and the type used to pack and unpack (e.g. Cartesian4).\n if (binaryProperty) {\n binaryProperties = binaryProperties || {};\n binaryProperties[name] = binaryProperty;\n }\n }\n return binaryProperties;\n }\n\n _initializeBinaryProperty(name, property) {\n if ('byteOffset' in property) {\n // This is a binary property\n const tile3DAccessor = property;\n\n assert(this.binary, `Property ${name} requires a batch table binary.`);\n assert(tile3DAccessor.type, `Property ${name} requires a type.`);\n\n const accessor = createTypedArrayFromAccessor(\n tile3DAccessor,\n this.binary.buffer,\n this.binary.byteOffset | 0,\n this.featureCount\n );\n\n // Store any information needed to access the binary data, including the typed array,\n // componentCount (e.g. a VEC4 would be 4), and the type used to pack and unpack (e.g. Cartesian4).\n return {\n typedArray: accessor.values,\n componentCount: accessor.size,\n unpack: accessor.unpacker,\n pack: accessor.packer\n };\n }\n\n return null;\n }\n\n // EXTENSION SUPPORT: 3DTILES_batch_table_hierarchy\n\n _hasPropertyInHierarchy(batchId, name) {\n if (!this._hierarchy) {\n return false;\n }\n\n const result = traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {\n const classId = hierarchy.classIds[instanceIndex];\n const instances = hierarchy.classes[classId].instances;\n return defined(instances[name]);\n });\n\n return defined(result);\n }\n\n _getPropertyNamesInHierarchy(batchId, results) {\n traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {\n const classId = hierarchy.classIds[instanceIndex];\n const instances = hierarchy.classes[classId].instances;\n for (const name in instances) {\n if (instances.hasOwnProperty(name)) {\n if (results.indexOf(name) === -1) {\n results.push(name);\n }\n }\n }\n });\n }\n\n _getHierarchyProperty(batchId, name) {\n return traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {\n const classId = hierarchy.classIds[instanceIndex];\n const instanceClass = hierarchy.classes[classId];\n const indexInClass = hierarchy.classIndexes[instanceIndex];\n const propertyValues = instanceClass.instances[name];\n if (defined(propertyValues)) {\n if (defined(propertyValues.typedArray)) {\n return this._getBinaryProperty(propertyValues, indexInClass);\n }\n return clone(propertyValues[indexInClass], true);\n }\n return null;\n });\n }\n\n _setHierarchyProperty(batchTable, batchId, name, value) {\n const result = traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {\n const classId = hierarchy.classIds[instanceIndex];\n const instanceClass = hierarchy.classes[classId];\n const indexInClass = hierarchy.classIndexes[instanceIndex];\n const propertyValues = instanceClass.instances[name];\n if (defined(propertyValues)) {\n assert(instanceIndex === batchId, `Inherited property \"${name}\" is read-only.`);\n if (defined(propertyValues.typedArray)) {\n this._setBinaryProperty(propertyValues, indexInClass, value);\n } else {\n propertyValues[indexInClass] = clone(value, true);\n }\n return true;\n }\n return false;\n });\n return defined(result);\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\nconst SIZEOF_UINT32 = 4;\n\n/* PARSE FIXED HEADER:\nPopulates\n magic, // identifies type of tile\n type, // String version of magic\n version,\n byteLength\n */\nexport function parse3DTileHeaderSync(tile, arrayBuffer, byteOffset = 0) {\n const view = new DataView(arrayBuffer);\n\n tile.magic = view.getUint32(byteOffset, true);\n byteOffset += SIZEOF_UINT32;\n\n tile.version = view.getUint32(byteOffset, true);\n byteOffset += SIZEOF_UINT32;\n\n tile.byteLength = view.getUint32(byteOffset, true);\n byteOffset += SIZEOF_UINT32;\n\n // TODO - move version check into each tile parser?\n if (tile.version !== 1) {\n throw new Error(`3D Tile Version ${tile.version} not supported`);\n }\n\n return byteOffset; // Indicates where the parsing ended\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 {getStringFromArrayBuffer} from './parse-utils';\n\nconst SIZEOF_UINT32 = 4;\nconst DEPRECATION_WARNING = `b3dm tile in legacy format.`;\n\n// eslint-disable-next-line max-statements\nexport function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {\n const view = new DataView(arrayBuffer);\n let batchLength;\n\n tile.header = tile.header || {};\n\n let featureTableJsonByteLength = view.getUint32(byteOffset, true);\n byteOffset += SIZEOF_UINT32;\n\n let featureTableBinaryByteLength = view.getUint32(byteOffset, true);\n byteOffset += SIZEOF_UINT32;\n\n let batchTableJsonByteLength = view.getUint32(byteOffset, true);\n byteOffset += SIZEOF_UINT32;\n\n let batchTableBinaryByteLength = view.getUint32(byteOffset, true);\n byteOffset += SIZEOF_UINT32;\n\n // First legacy header format - [batchLength] [batchTableByteLength] ('batchTableJsonByteLength': JSON starts with a quotation mark or the glTF magic)\n // Second legacy format - [batchTableJsonByteLength] [batchTableBinaryByteLength] [batchLength] (Second legacy format is similar as first but here we check 'batchTableBinaryByteLength' instead)\n // Current header format - [featureTableJsonByteLength] [featureTableBinaryByteLength] [batchTableJsonByteLength] [batchTableBinaryByteLength]\n // First byte will be 0x22 or 0x67. The minimum uint32 expected is 0x22000000 = 570425344 = 570MB.\n if (batchTableJsonByteLength >= 570425344) {\n byteOffset -= SIZEOF_UINT32 * 2;\n batchLength = featureTableJsonByteLength;\n batchTableJsonByteLength = featureTableBinaryByteLength;\n batchTableBinaryByteLength = 0;\n featureTableJsonByteLength = 0;\n featureTableBinaryByteLength = 0;\n\n console.warn(DEPRECATION_WARNING); // eslint-disable-line\n } else if (batchTableBinaryByteLength >= 570425344) {\n byteOffset -= SIZEOF_UINT32;\n batchLength = batchTableJsonByteLength;\n batchTableJsonByteLength = featureTableJsonByteLength;\n batchTableBinaryByteLength = featureTableBinaryByteLength;\n featureTableJsonByteLength = 0;\n featureTableBinaryByteLength = 0;\n\n console.warn(DEPRECATION_WARNING); // eslint-disable-line\n }\n\n tile.header.featureTableJsonByteLength = featureTableJsonByteLength;\n tile.header.featureTableBinaryByteLength = featureTableBinaryByteLength;\n tile.header.batchTableJsonByteLength = batchTableJsonByteLength;\n tile.header.batchTableBinaryByteLength = batchTableBinaryByteLength;\n tile.header.batchLength = batchLength;\n\n return byteOffset;\n}\n\nexport function parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options) {\n byteOffset = parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options);\n byteOffset = parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options);\n return byteOffset;\n}\n\nfunction parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {\n const {featureTableJsonByteLength, featureTableBinaryByteLength, batchLength} = tile.header;\n\n tile.featureTableJson = {\n BATCH_LENGTH: batchLength || 0\n };\n\n if (featureTableJsonByteLength > 0) {\n const featureTableString = getStringFromArrayBuffer(\n arrayBuffer,\n byteOffset,\n featureTableJsonByteLength\n );\n tile.featureTableJson = JSON.parse(featureTableString);\n }\n byteOffset += featureTableJsonByteLength;\n\n tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);\n byteOffset += featureTableBinaryByteLength;\n\n /*\n const featureTable = parseFeatureTable(featureTableJson, featureTableBinary);\n\n const batchLength = featureTable.getGlobalProperty('BATCH_LENGTH');\n featureTable.featuresLength = batchLength;\n */\n\n return byteOffset;\n}\n\nfunction parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {\n const {batchTableJsonByteLength, batchTableBinaryByteLength} = tile.header;\n\n if (batchTableJsonByteLength > 0) {\n const batchTableString = getStringFromArrayBuffer(\n arrayBuffer,\n byteOffset,\n batchTableJsonByteLength\n );\n tile.batchTableJson = JSON.parse(batchTableString);\n byteOffset += batchTableJsonByteLength;\n\n if (batchTableBinaryByteLength > 0) {\n // Has a batch table binary\n tile.batchTableBinary = new Uint8Array(arrayBuffer, byteOffset, batchTableBinaryByteLength);\n // Copy the batchTableBinary section and let the underlying ArrayBuffer be freed\n tile.batchTableBinary = new Uint8Array(tile.batchTableBinary);\n\n byteOffset += batchTableBinaryByteLength;\n }\n }\n\n return byteOffset;\n}\n","/**\n * Decode color values\n * @param rgb565\n * @param target\n * @returns target\n */\nexport function decodeRGB565(rgb565: number, target: number[] = [0, 0, 0]): number[] {\n const r5 = (rgb565 >> 11) & 31;\n const g6 = (rgb565 >> 5) & 63;\n const b5 = rgb565 & 31;\n\n target[0] = r5 << 3;\n target[1] = g6 << 2;\n target[2] = b5 << 3;\n\n return target;\n}\n\n/**\n * Encode color values\n * @param rgb\n * @returns color\n */\nexport function encodeRGB565(rgb: number[]): number {\n const r5 = Math.floor(rgb[0] / 8) + 4;\n const g6 = Math.floor(rgb[1] / 4) + 2;\n const b5 = Math.floor(rgb[2] / 8) + 4;\n return r5 + (g6 << 5) + (b5 << 11);\n}\n","import {decodeRGB565, GL} from '@loaders.gl/math';\n\n/* eslint-disable complexity*/\nexport function normalize3DTileColorAttribute(tile, colors, batchTable) {\n // no colors defined\n if (!colors && (!tile || !tile.batchIds || !batchTable)) {\n return null;\n }\n\n const {batchIds, isRGB565, pointCount} = tile;\n // Batch table, look up colors in table\n if (batchIds && batchTable) {\n const colorArray = new Uint8ClampedArray(pointCount * 3);\n for (let i = 0; i < pointCount; i++) {\n const batchId = batchIds[i];\n // TODO figure out what is `dimensions` used for\n const dimensions = batchTable.getProperty(batchId, 'dimensions');\n const color = dimensions.map((d) => d * 255);\n colorArray[i * 3] = color[0];\n colorArray[i * 3 + 1] = color[1];\n colorArray[i * 3 + 2] = color[2];\n }\n return {\n type: GL.UNSIGNED_BYTE,\n value: colorArray,\n size: 3,\n normalized: true\n };\n }\n\n // RGB565 case, convert to RGB\n if (isRGB565) {\n const colorArray = new Uint8ClampedArray(pointCount * 3);\n for (let i = 0; i < pointCount; i++) {\n const color = decodeRGB565(colors[i]);\n colorArray[i * 3] = color[0];\n colorArray[i * 3 + 1] = color[1];\n colorArray[i * 3 + 2] = color[2];\n }\n return {\n type: GL.UNSIGNED_BYTE,\n value: colorArray,\n size: 3,\n normalized: true\n };\n }\n\n // RGB case (tile.isTranslucent)\n if (colors && colors.length === pointCount * 3) {\n return {\n type: GL.UNSIGNED_BYTE,\n value: colors,\n size: 3,\n normalized: true\n };\n }\n\n // DEFAULT: RGBA case\n return {\n type: GL.UNSIGNED_BYTE,\n value: colors,\n size: 4,\n normalized: true\n };\n}\n/* eslint-enable complexity*/\n","import Vector from './base/vector';\nimport { config, isArray } from '../lib/common';\nimport { checkNumber } from '../lib/validators';\nimport * as vec2 from 'gl-matrix/vec2';\nimport { vec2_transformMat4AsVector } from '../lib/gl-matrix-extras';\nexport default class Vector2 extends Vector {\n constructor(x = 0, y = 0) {\n super(2);\n\n if (isArray(x) && arguments.length === 1) {\n this.copy(x);\n } else {\n if (config.debug) {\n checkNumber(x);\n checkNumber(y);\n }\n\n this[0] = x;\n this[1] = y;\n }\n }\n\n set(x, y) {\n this[0] = x;\n this[1] = y;\n return this.check();\n }\n\n copy(array) {\n this[0] = array[0];\n this[1] = array[1];\n return this.check();\n }\n\n fromObject(object) {\n if (config.debug) {\n checkNumber(object.x);\n checkNumber(object.y);\n }\n\n this[0] = object.x;\n this[1] = object.y;\n return this.check();\n }\n\n toObject(object) {\n object.x = this[0];\n object.y = this[1];\n return object;\n }\n\n get ELEMENTS() {\n return 2;\n }\n\n horizontalAngle() {\n return Math.atan2(this.y, this.x);\n }\n\n verticalAngle() {\n return Math.atan2(this.x, this.y);\n }\n\n transform(matrix4) {\n return this.transformAsPoint(matrix4);\n }\n\n transformAsPoint(matrix4) {\n vec2.transformMat4(this, this, matrix4);\n return this.check();\n }\n\n transformAsVector(matrix4) {\n vec2_transformMat4AsVector(this, this, matrix4);\n return this.check();\n }\n\n transformByMatrix3(matrix3) {\n vec2.transformMat3(this, this, matrix3);\n return this.check();\n }\n\n transformByMatrix2x3(matrix2x3) {\n vec2.transformMat2d(this, this, matrix2x3);\n return this.check();\n }\n\n transformByMatrix2(matrix2) {\n vec2.transformMat2(this, this, matrix2);\n return this.check();\n }\n\n}\n//# sourceMappingURL=vector2.js.map","/**\n * Throws error message\n * @param condition checks if an attribute equal to condition\n * @param message error message\n */\nexport function assert(condition: any, message?: any): void {\n if (!condition) {\n throw new Error(`math.gl assertion failed. ${message}`);\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// Attribute compression and decompression functions.\n\nimport {Vector2, Vector3, clamp, _MathUtils} from '@math.gl/core';\nimport {Vector4} from '../types';\nimport {assert} from '../utils/assert';\n\nconst RIGHT_SHIFT = 1.0 / 256.0;\nconst LEFT_SHIFT = 256.0;\n\nconst scratchVector2 = new Vector2();\nconst scratchVector3 = new Vector3();\nconst scratchEncodeVector2 = new Vector2();\nconst octEncodeScratch = new Vector2();\n\nconst uint8ForceArray = new Uint8Array(1);\n\n/**\n * Force a value to Uint8\n *\n * @param value\n * @returns\n */\nfunction forceUint8(value: number): number {\n uint8ForceArray[0] = value;\n return uint8ForceArray[0];\n}\n\n/**\n * Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].\n *\n * @param value SNORM value in the range [0, rangeMaximum]\n * @param [rangeMaximum=255] The maximum value in the SNORM range, 255 by default.\n * @returns Scalar in the range [-1.0, 1.0].\n *\n * @see CesiumMath.toSNorm\n */\nfunction fromSNorm(value: number, rangeMaximum = 255): number {\n return (clamp(value, 0.0, rangeMaximum) / rangeMaximum) * 2.0 - 1.0;\n}\n\n/**\n * Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum].\n *\n * @param value The scalar value in the range [-1.0, 1.0]\n * @param [rangeMaximum=255] The maximum value in the mapped range, 255 by default.\n * @returns A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.\n *\n * @see CesiumMath.fromSNorm\n */\nfunction toSNorm(value: number, rangeMaximum = 255): number {\n return Math.round((clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);\n}\n\n/**\n * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.\n * This is similar to `Math.sign` except that returns 1.0 instead of\n * 0.0 when the input value is 0.0.\n *\n * @param value The value to return the sign of.\n * @returns The sign of value.\n */\nfunction signNotZero(value: number): number {\n return value < 0.0 ? -1.0 : 1.0;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-rangeMax] following the 'oct' encoding.\n *\n * Oct encoding is a compact representation of unit length vectors.\n * The 'oct' encoding is described in \"A Survey of Efficient Representations of Independent Unit Vectors\",\n * Cigolle et al 2014: {@link http://jcgt.org/published/0003/02/01/}\n *\n * @param vector The normalized vector to be compressed into 2 component 'oct' encoding.\n * @param result The 2 component oct-encoded unit length vector.\n * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.\n * @returns The 2 component oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octDecodeInRange\n */\nexport function octEncodeInRange(vector: Vector3, rangeMax: number, result: Vector2): Vector2 {\n assert(vector);\n assert(result);\n\n const vector3 = scratchVector3.from(vector);\n\n assert(Math.abs(vector3.magnitudeSquared() - 1.0) <= _MathUtils.EPSILON6);\n\n result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));\n result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));\n\n if (vector.z < 0) {\n const x = result.x;\n const y = result.y;\n result.x = (1.0 - Math.abs(y)) * signNotZero(x);\n result.y = (1.0 - Math.abs(x)) * signNotZero(y);\n }\n\n result.x = toSNorm(result.x, rangeMax);\n result.y = toSNorm(result.y, rangeMax);\n\n return result;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding.\n *\n * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.\n * @param result The 2 byte oct-encoded unit length vector.\n * @returns he 2 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octEncodeInRange\n * @see octDecode\n */\nexport function octEncode(vector: Vector3, result: Vector2): Vector2 {\n return octEncodeInRange(vector, 255, result);\n}\n\n/**\n * Encodes a normalized vector into 4-byte vector\n * @param vector The normalized vector to be compressed into 4 byte 'oct' encoding.\n * @param result The 4 byte oct-encoded unit length vector.\n * @returns The 4 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n *\n * @see octEncodeInRange\n * @see octDecodeFromVector4\n */\nexport function octEncodeToVector4(vector: Vector3, result: Vector4): Vector4 {\n octEncodeInRange(vector, 65535, octEncodeScratch);\n result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);\n result.y = forceUint8(octEncodeScratch.x);\n result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);\n result.w = forceUint8(octEncodeScratch.y);\n return result;\n}\n\n/**\n * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component vector.\n *\n * @param x The x component of the oct-encoded unit length vector.\n * @param y The y component of the oct-encoded unit length vector.\n * @param rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.\n * @param result The decoded and normalized vector\n * @returns The decoded and normalized vector.\n *\n * @exception x and y must be unsigned normalized integers between 0 and rangeMax.\n *\n * @see octEncodeInRange\n */\nexport function octDecodeInRange(x: number, y: number, rangeMax: number, result: Vector3): Vector3 {\n assert(result);\n if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {\n throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMax}`);\n }\n\n result.x = fromSNorm(x, rangeMax);\n result.y = fromSNorm(y, rangeMax);\n result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));\n\n if (result.z < 0.0) {\n const oldVX = result.x;\n result.x = (1.0 - Math.abs(result.y)) * signNotZero(oldVX);\n result.y = (1.0 - Math.abs(oldVX)) * signNotZero(result.y);\n }\n\n return result.normalize();\n}\n\n/**\n * Decodes a unit-length vector in 2 byte 'oct' encoding to a normalized 3-component vector.\n *\n * @param x The x component of the oct-encoded unit length vector.\n * @param y The y component of the oct-encoded unit length vector.\n * @param result The decoded and normalized vector.\n * @returns he decoded and normalized vector.\n *\n * @exception x and y must be an unsigned normalized integer between 0 and 255.\n *\n * @see octDecodeInRange\n */\nexport function octDecode(x: number, y: number, result: Vector3): Vector3 {\n return octDecodeInRange(x, y, 255, result);\n}\n\n/**\n * Decodes a unit-length vector in 4 byte 'oct' encoding to a normalized 3-component vector.\n *\n * @param encoded The oct-encoded unit length vector.\n * @param esult The decoded and normalized vector.\n * @returns The decoded and normalized vector.\n *\n * @exception x, y, z, and w must be unsigned normalized integers between 0 and 255.\n *\n * @see octDecodeInRange\n * @see octEncodeToVector4\n */\nexport function octDecodeFromVector4(encoded: Vector4, result: Vector3): Vector3 {\n assert(encoded);\n assert(result);\n const x = encoded.x;\n const y = encoded.y;\n const z = encoded.z;\n const w = encoded.w;\n\n if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {\n throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');\n }\n\n const xOct16 = x * LEFT_SHIFT + y;\n const yOct16 = z * LEFT_SHIFT + w;\n return octDecodeInRange(xOct16, yOct16, 65535, result);\n}\n\n/**\n * Packs an oct encoded vector into a single floating-point number.\n *\n * @param encoded The oct encoded vector.\n * @returns The oct encoded vector packed into a single float.\n *\n */\nexport function octPackFloat(encoded: Vector2): number {\n const vector2 = scratchVector2.from(encoded);\n return 256.0 * vector2.x + vector2.y;\n}\n\n/**\n * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding and\n * stores those values in a single float-point number.\n *\n * @param vector The normalized vector to be compressed into 2 byte 'oct' encoding.\n * @returns The 2 byte oct-encoded unit length vector.\n *\n * @exception vector must be normalized.\n */\nexport function octEncodeFloat(vector: Vector3): number {\n octEncode(vector, scratchEncodeVector2);\n return octPackFloat(scratchEncodeVector2);\n}\n\n/**\n * Decodes a unit-length vector in 'oct' encoding packed in a floating-point number to a normalized 3-component vector.\n *\n * @param value The oct-encoded unit length vector stored as a single floating-point number.\n * @param result The decoded and normalized vector\n * @returns The decoded and normalized vector.\n *\n */\nexport function octDecodeFloat(value: number, result: Vector3): Vector3 {\n assert(Number.isFinite(value));\n\n const temp = value / 256.0;\n const x = Math.floor(temp);\n const y = (temp - x) * 256.0;\n\n return octDecode(x, y, result);\n}\n\n/**\n * Encodes three normalized vectors into 6 SNORM values in the range of [0-255] following the 'oct' encoding and\n * packs those into two floating-point numbers.\n *\n * @param v1 A normalized vector to be compressed.\n * @param v2 A normalized vector to be compressed.\n * @param v3 A normalized vector to be compressed.\n * @param result The 'oct' encoded vectors packed into two floating-point numbers.\n * @returns The 'oct' encoded vectors packed into two floating-point numbers.\n *\n */\nexport function octPack(v1: Vector3, v2: Vector3, v3: Vector3, result: Vector2): Vector2 {\n assert(v1);\n assert(v2);\n assert(v3);\n assert(result);\n\n const encoded1 = octEncodeFloat(v1);\n const encoded2 = octEncodeFloat(v2);\n\n const encoded3 = octEncode(v3, scratchEncodeVector2);\n result.x = 65536.0 * encoded3.x + encoded1;\n result.y = 65536.0 * encoded3.y + encoded2;\n return result;\n}\n\n/**\n * Decodes three unit-length vectors in 'oct' encoding packed into a floating-point number to a normalized 3-component vector.\n *\n * @param packed The three oct-encoded unit length vectors stored as two floating-point number.\n * @param v1 One decoded and normalized vector.\n * @param v2 One decoded and normalized vector.\n * @param v3 One decoded and normalized vector.\n */\nexport function octUnpack(packed: Vector2, v1: Vector3, v2: Vector3, v3: Vector3): void {\n let temp = packed.x / 65536.0;\n const x = Math.floor(temp);\n const encodedFloat1 = (temp - x) * 65536.0;\n\n temp = packed.y / 65536.0;\n const y = Math.floor(temp);\n const encodedFloat2 = (temp - y) * 65536.0;\n\n octDecodeFloat(encodedFloat1, v1);\n octDecodeFloat(encodedFloat2, v2);\n octDecode(x, y, v3);\n}\n\n/**\n * Pack texture coordinates into a single float. The texture coordinates will only preserve 12 bits of precision.\n *\n * @param textureCoordinates The texture coordinates to compress. Both coordinates must be in the range 0.0-1.0.\n * @returns The packed texture coordinates.\n *\n */\nexport function compressTextureCoordinates(textureCoordinates: Vector2): number {\n // Move x and y to the range 0-4095;\n const x = (textureCoordinates.x * 4095.0) | 0;\n const y = (textureCoordinates.y * 4095.0) | 0;\n return 4096.0 * x + y;\n}\n\n/**\n * Decompresses texture coordinates that were packed into a single float.\n *\n * @param compressed The compressed texture coordinates.\n * @param result The decompressed texture coordinates.\n * @returns The modified result parameter.\n *\n */\nexport function decompressTextureCoordinates(compressed: number, result: Vector2): Vector2 {\n const temp = compressed / 4096.0;\n const xZeroTo4095 = Math.floor(temp);\n result.x = xZeroTo4095 / 4095.0;\n result.y = (compressed - xZeroTo4095 * 4096) / 4095;\n return result;\n}\n\n/**\n * Decodes delta and ZigZag encoded vertices. This modifies the buffers in place.\n *\n * @param uBuffer The buffer view of u values.\n * @param vBuffer The buffer view of v values.\n * @param [heightBuffer] The buffer view of height values.\n *\n * @link https://github.com/AnalyticalGraphicsInc/quantized-mesh|quantized-mesh-1.0 terrain format\n */\nexport function zigZagDeltaDecode(\n uBuffer: Uint16Array,\n vBuffer: Uint16Array,\n heightBuffer?: Uint16Array | number[]\n) {\n assert(uBuffer);\n assert(vBuffer);\n assert(uBuffer.length === vBuffer.length);\n if (heightBuffer) {\n assert(uBuffer.length === heightBuffer.length);\n }\n\n function zigZagDecode(value: number) {\n return (value >> 1) ^ -(value & 1);\n }\n\n let u = 0;\n let v = 0;\n let height = 0;\n\n for (let i = 0; i < uBuffer.length; ++i) {\n u += zigZagDecode(uBuffer[i]);\n v += zigZagDecode(vBuffer[i]);\n\n uBuffer[i] = u;\n vBuffer[i] = v;\n\n if (heightBuffer) {\n height += zigZagDecode(heightBuffer[i]);\n heightBuffer[i] = height;\n }\n }\n}\n","import {Vector3} from '@math.gl/core';\nimport {GL, octDecode} from '@loaders.gl/math';\n\nconst scratchNormal = new Vector3();\n\nexport function normalize3DTileNormalAttribute(tile, normals) {\n if (!normals) {\n return null;\n }\n\n if (tile.isOctEncoded16P) {\n const decodedArray = new Float32Array(tile.pointsLength * 3);\n for (let i = 0; i < tile.pointsLength; i++) {\n octDecode(normals[i * 2], normals[i * 2 + 1], scratchNormal);\n // @ts-ignore\n scratchNormal.toArray(decodedArray, i * 3);\n }\n\n return {\n type: GL.FLOAT,\n size: 2,\n value: decodedArray\n };\n }\n\n return {\n type: GL.FLOAT,\n size: 2,\n value: normals\n };\n}\n","import {Vector3} from '@math.gl/core';\nimport {GL} from '@loaders.gl/math';\n\n// Prepare attribute for positions\nexport function normalize3DTilePositionAttribute(tile, positions, options) {\n if (!tile.isQuantized) {\n return positions;\n }\n\n // For quantized posititions, either expand to Float32Array or return custom accessor\n // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions\n\n // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes\n if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {\n tile.isQuantized = false;\n return decodeQuantizedPositions(tile, positions);\n }\n\n // Default: Use normalized shorts directly, no copying/processing.\n // NOTE: The \"missing\" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`\n return {\n type: GL.UNSIGNED_SHORT,\n value: positions,\n size: 3,\n normalized: true\n };\n}\n\n// Pre-scale quantized positions on CPU\nfunction decodeQuantizedPositions(tile, positions) {\n const scratchPosition = new Vector3();\n const decodedArray = new Float32Array(tile.pointCount * 3);\n\n for (let i = 0; i < tile.pointCount; i++) {\n // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET\n scratchPosition\n .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])\n .scale(1 / tile.quantizedRange)\n .multiply(tile.quantizedVolumeScale)\n .add(tile.quantizedVolumeOffset)\n .toArray(decodedArray, i * 3);\n }\n\n return decodedArray;\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 {DracoLoader} from '@loaders.gl/draco';\nimport {GL} from '@loaders.gl/math';\nimport {Vector3} from '@math.gl/core';\n\nimport Tile3DFeatureTable from '../classes/tile-3d-feature-table';\nimport Tile3DBatchTable from '../classes/tile-3d-batch-table';\nimport {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';\nimport {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/parse-3d-tile-tables';\nimport {normalize3DTileColorAttribute} from './helpers/normalize-3d-tile-colors';\nimport {normalize3DTileNormalAttribute} from './helpers/normalize-3d-tile-normals';\nimport {normalize3DTilePositionAttribute} from './helpers/normalize-3d-tile-positions';\n\nexport async function parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, context) {\n byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);\n byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);\n byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);\n initializeTile(tile);\n\n const {featureTable, batchTable} = parsePointCloudTables(tile);\n\n await parseDraco(tile, featureTable, batchTable, options, context);\n\n parsePositions(tile, featureTable, options);\n parseColors(tile, featureTable, batchTable);\n parseNormals(tile, featureTable);\n\n return byteOffset;\n}\n\nfunction initializeTile(tile) {\n // Initialize point cloud tile defaults\n tile.attributes = {\n positions: null,\n colors: null,\n normals: null,\n batchIds: null\n };\n tile.isQuantized = false;\n tile.isTranslucent = false;\n tile.isRGB565 = false;\n tile.isOctEncoded16P = false;\n}\n\nfunction parsePointCloudTables(tile) {\n const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);\n\n const pointsLength = featureTable.getGlobalProperty('POINTS_LENGTH');\n if (!Number.isFinite(pointsLength)) {\n throw new Error('POINTS_LENGTH must be defined');\n }\n featureTable.featuresLength = pointsLength;\n\n tile.featuresLength = pointsLength;\n tile.pointsLength = pointsLength;\n tile.pointCount = pointsLength;\n\n tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', GL.FLOAT, 3);\n\n const batchTable = parseBatchIds(tile, featureTable);\n\n return {featureTable, batchTable};\n}\n\nfunction parsePositions(tile, featureTable, options) {\n if (!tile.attributes.positions) {\n if (featureTable.hasProperty('POSITION')) {\n tile.attributes.positions = featureTable.getPropertyArray('POSITION', GL.FLOAT, 3);\n } else if (featureTable.hasProperty('POSITION_QUANTIZED')) {\n const positions = featureTable.getPropertyArray('POSITION_QUANTIZED', GL.UNSIGNED_SHORT, 3);\n\n tile.isQuantized = true;\n tile.quantizedRange = (1 << 16) - 1;\n\n tile.quantizedVolumeScale = featureTable.getGlobalProperty(\n 'QUANTIZED_VOLUME_SCALE',\n GL.FLOAT,\n 3\n );\n if (!tile.quantizedVolumeScale) {\n throw new Error('QUANTIZED_VOLUME_SCALE must be defined for quantized positions.');\n }\n\n tile.quantizedVolumeOffset = featureTable.getGlobalProperty(\n 'QUANTIZED_VOLUME_OFFSET',\n GL.FLOAT,\n 3\n );\n if (!tile.quantizedVolumeOffset) {\n throw new Error('QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.');\n }\n\n tile.attributes.positions = normalize3DTilePositionAttribute(tile, positions, options);\n }\n }\n\n if (!tile.attributes.positions) {\n throw new Error('Either POSITION or POSITION_QUANTIZED must be defined.');\n }\n}\n\nfunction parseColors(tile, featureTable, batchTable) {\n if (!tile.attributes.colors) {\n let colors = null;\n if (featureTable.hasProperty('RGBA')) {\n colors = featureTable.getPropertyArray('RGBA', GL.UNSIGNED_BYTE, 4);\n tile.isTranslucent = true;\n } else if (featureTable.hasProperty('RGB')) {\n colors = featureTable.getPropertyArray('RGB', GL.UNSIGNED_BYTE, 3);\n } else if (featureTable.hasProperty('RGB565')) {\n colors = featureTable.getPropertyArray('RGB565', GL.UNSIGNED_SHORT, 1);\n tile.isRGB565 = true;\n }\n\n tile.attributes.colors = normalize3DTileColorAttribute(tile, colors, batchTable);\n }\n\n if (featureTable.hasProperty('CONSTANT_RGBA')) {\n tile.constantRGBA = featureTable.getGlobalProperty('CONSTANT_RGBA', GL.UNSIGNED_BYTE, 4);\n }\n}\n\nfunction parseNormals(tile, featureTable) {\n if (!tile.attributes.normals) {\n let normals = null;\n if (featureTable.hasProperty('NORMAL')) {\n normals = featureTable.getPropertyArray('NORMAL', GL.FLOAT, 3);\n } else if (featureTable.hasProperty('NORMAL_OCT16P')) {\n normals = featureTable.getPropertyArray('NORMAL_OCT16P', GL.UNSIGNED_BYTE, 2);\n tile.isOctEncoded16P = true;\n }\n\n tile.attributes.normals = normalize3DTileNormalAttribute(tile, normals);\n }\n}\n\nfunction parseBatchIds(tile, featureTable) {\n let batchTable = null;\n if (!tile.batchIds && featureTable.hasProperty('BATCH_ID')) {\n tile.batchIds = featureTable.getPropertyArray('BATCH_ID', GL.UNSIGNED_SHORT, 1);\n\n if (tile.batchIds) {\n const batchFeatureLength = featureTable.getGlobalProperty('BATCH_LENGTH');\n if (!batchFeatureLength) {\n throw new Error('Global property: BATCH_LENGTH must be defined when BATCH_ID is defined.');\n }\n const {batchTableJson, batchTableBinary} = tile;\n batchTable = new Tile3DBatchTable(batchTableJson, batchTableBinary, batchFeatureLength);\n }\n }\n return batchTable;\n}\n\n// eslint-disable-next-line complexity\nasync function parseDraco(tile, featureTable, batchTable, options, context) {\n let dracoBuffer;\n let dracoFeatureTableProperties;\n let dracoBatchTableProperties;\n const batchTableDraco =\n tile.batchTableJson &&\n tile.batchTableJson.extensions &&\n tile.batchTableJson.extensions['3DTILES_draco_point_compression'];\n if (batchTableDraco) {\n dracoBatchTableProperties = batchTableDraco.properties;\n }\n\n const featureTableDraco = featureTable.getExtension('3DTILES_draco_point_compression');\n if (featureTableDraco) {\n dracoFeatureTableProperties = featureTableDraco.properties;\n const dracoByteOffset = featureTableDraco.byteOffset;\n const dracoByteLength = featureTableDraco.byteLength;\n if (!dracoFeatureTableProperties || !Number.isFinite(dracoByteOffset) || !dracoByteLength) {\n throw new Error('Draco properties, byteOffset, and byteLength must be defined');\n }\n\n dracoBuffer = tile.featureTableBinary.slice(dracoByteOffset, dracoByteOffset + dracoByteLength);\n\n tile.hasPositions = Number.isFinite(dracoFeatureTableProperties.POSITION);\n tile.hasColors =\n Number.isFinite(dracoFeatureTableProperties.RGB) ||\n Number.isFinite(dracoFeatureTableProperties.RGBA);\n tile.hasNormals = Number.isFinite(dracoFeatureTableProperties.NORMAL);\n tile.hasBatchIds = Number.isFinite(dracoFeatureTableProperties.BATCH_ID);\n tile.isTranslucent = Number.isFinite(dracoFeatureTableProperties.RGBA);\n }\n\n if (!dracoBuffer) {\n return true;\n }\n\n const dracoData = {\n buffer: dracoBuffer,\n properties: {...dracoFeatureTableProperties, ...dracoBatchTableProperties},\n featureTableProperties: dracoFeatureTableProperties,\n batchTableProperties: dracoBatchTableProperties,\n dequantizeInShader: false\n };\n\n return await loadDraco(tile, dracoData, options, context);\n}\n\n// eslint-disable-next-line complexity, max-statements\nexport async function loadDraco(tile, dracoData, options, context) {\n const {parse} = context;\n const dracoOptions = {\n ...options,\n draco: {\n ...options.draco,\n extraAttributes: dracoData.batchTableProperties || {}\n }\n };\n\n // The entire tileset might be included, too expensive to serialize\n delete dracoOptions['3d-tiles'];\n\n const data = await parse(dracoData.buffer, DracoLoader, dracoOptions);\n\n const decodedPositions = data.attributes.POSITION && data.attributes.POSITION.value;\n const decodedColors = data.attributes.COLOR_0 && data.attributes.COLOR_0.value;\n const decodedNormals = data.attributes.NORMAL && data.attributes.NORMAL.value;\n const decodedBatchIds = data.attributes.BATCH_ID && data.attributes.BATCH_ID.value;\n const isQuantizedDraco = decodedPositions && data.attributes.POSITION.value.quantization;\n const isOctEncodedDraco = decodedNormals && data.attributes.NORMAL.value.quantization;\n if (isQuantizedDraco) {\n // Draco quantization range == quantized volume scale - size in meters of the quantized volume\n // Internal quantized range is the range of values of the quantized data, e.g. 255 for 8-bit, 1023 for 10-bit, etc\n const quantization = data.POSITION.data.quantization;\n const range = quantization.range;\n tile.quantizedVolumeScale = new Vector3(range, range, range);\n tile.quantizedVolumeOffset = new Vector3(quantization.minValues);\n tile.quantizedRange = (1 << quantization.quantizationBits) - 1.0;\n tile.isQuantizedDraco = true;\n }\n if (isOctEncodedDraco) {\n tile.octEncodedRange = (1 << data.NORMAL.data.quantization.quantizationBits) - 1.0;\n tile.isOctEncodedDraco = true;\n }\n\n // Extra batch table attributes\n const batchTableAttributes = {};\n if (dracoData.batchTableProperties) {\n for (const attributeName of Object.keys(dracoData.batchTableProperties)) {\n if (data.attributes[attributeName] && data.attributes[attributeName].value) {\n batchTableAttributes[attributeName.toLowerCase()] = data.attributes[attributeName].value;\n }\n }\n }\n\n tile.attributes = {\n positions: decodedPositions,\n colors: normalize3DTileColorAttribute(tile, decodedColors),\n normals: decodedNormals,\n batchIds: decodedBatchIds,\n ...batchTableAttributes\n };\n}\n\n// TODO - this is the remaining code from Cesium's parser\n/*\n const batchTable = new Tile3DBatchTable(tile);\n\n // parseDracoBuffer(tile, featureTable, batchTable);\n\n if (!tile.attributes.positions) {\n throw new Error('Either POSITION or POSITION_QUANTIZED must be defined.');\n }\n}\n/*\n\n if (!tile.attributes.positions) {\n if (featureTable.hasProperty('POSITION')) {\n tile.attributes.positions = featureTable.getPropertyArray('POSITION', GL.FLOAT, 3);\n } else if (featureTable.hasProperty('POSITION_QUANTIZED')) {\n tile.attributes.positions = featureTable.getPropertyArray('POSITION_QUANTIZED', GL.UNSIGNED_SHORT, 3);\n\n\n if (!tile.colors) {\n if (featureTable.hasProperty('RGBA')) {\n tile.colors = featureTable.getPropertyArray('RGBA', GL.UNSIGNED_BYTE, 4);\n tile.isTranslucent = true;\n } else if (featureTable.hasProperty('RGB')) {\n tile.colors = featureTable.getPropertyArray('RGB', GL.UNSIGNED_BYTE, 3);\n } else if (featureTable.hasPropertry('RGB565')) {\n tile.colors = featureTable.getPropertyArray('RGB565', GL.UNSIGNED_SHORT, 1);\n tile.isRGB565 = true;\n }\n }\n\n if (!tile.attributes.normals) {\n if (featureTable.getPropertry('NORMAL')) {\n tile.attributes.normals = featureTable.getPropertyArray('NORMAL', GL.FLOAT, 3);\n } else if (featureTable.getProperty('NORMAL_OCT16P')) {\n tile.attributes.normals = featureTable.getPropertyArray('NORMAL_OCT16P', GL.UNSIGNED_BYTE, 2);\n tile.isOctEncoded16P = true;\n }\n }\n\n if (!tile.batchIds) {\n if (featureTable.hasProperty('BATCH_ID')) {\n tile.batchIds = featureTable.getPropertyArray('BATCH_ID', GL.UNSIGNED_SHORT, 1);\n }\n }\n\n if (!tile.attributes.positions) {\n throw new Error('Either POSITION or POSITION_QUANTIZED must be defined.');\n }\n\n if (featureTable.getPropertry('CONSTANT_RGBA')) {\n tile.constantRGBA = featureTable.getGlobalProperty('CONSTANT_RGBA', GL.UNSIGNED_BYTE, 4);\n }\n\n if (tile.batchIds) {\n const batchLength = featureTable.getGlobalProperty('BATCH_LENGTH');\n if (!defined(batchLength)) {\n throw new Error('Global property: BATCH_LENGTH must be defined when BATCH_ID is defined.');\n }\n\n if (defined(batchTableBinary)) {\n // Copy the batchTableBinary section and let the underlying ArrayBuffer be freed\n batchTableBinary = new Uint8Array(batchTableBinary);\n }\n\n if (defined(pointCloud._batchTableLoaded)) {\n pointCloud._batchTableLoaded(batchLength, batchTableJson, batchTableBinary);\n }\n }\n\n // If points are not batched and there are per-point properties, use these properties for styling purposes\n var styleableProperties;\n if (!hasBatchIds && defined(batchTableBinary)) {\n tile.styleableProperties = Cesium3DTileBatchTable.getBinaryProperties(\n pointsLength,\n batchTableJson,\n batchTableBinary\n );\n }\n\n tile.draco = draco;\n}\n\n// Separate parsing and decoding of Draco\nexport function parseDracoBuffer(tile, featureTable, batchTable) {\n let dracoBuffer;\n let dracoFeatureTableProperties;\n let dracoBatchTableProperties;\n\n const batchTableDraco = batchTable.getExtension('3DTILES_draco_point_compression');\n if (batchTableDraco) {\n dracoBatchTableProperties = batchTableDraco.properties;\n }\n\n const featureTableDraco = featureTable.getExtension('3DTILES_draco_point_compression');\n if (featureTableDraco) {\n dracoFeatureTableProperties = featureTableDraco.properties;\n const dracoByteOffset = featureTableDraco.byteOffset;\n const dracoByteLength = featureTableDraco.byteLength;\n if (!dracoFeatureTableProperties || !dracoByteOffset || !dracoByteLength) {\n throw new Error('Draco properties, byteOffset, and byteLength must be defined');\n }\n\n dracoBuffer = arraySlice(\n featureTableBinary,\n dracoByteOffset,\n dracoByteOffset + dracoByteLength\n );\n tile.hasPositions = dracoFeatureTableProperties.POSITION;\n tile.hasColors = dracoFeatureTableProperties.RGB || dracoFeatureTableProperties.RGBA;\n tile.hasNormals = dracoFeatureTableProperties.NORMAL;\n tile.hasBatchIds = dracoFeatureTableProperties.BATCH_ID;\n tile.isTranslucent = dracoFeatureTableProperties.RGBA;\n }\n\n if (dracoBuffer) {\n tile.draco = {\n buffer: dracoBuffer,\n properties: {...dracoFeatureTableProperties, ...dracoBatchTableProperties},\n featureTableProperties: dracoFeatureTableProperties,\n batchTableProperties: dracoBatchTableProperties,\n dequantizeInShader: false\n };\n\n tile.decodingState = DECODING_STATE.NEEDS_DECODE;\n }\n}\n\n/*\nfunction decodeDraco(tile, context) {\n if (tile.decodingState === DECODING_STATE.READY) {\n return false;\n }\n if (tile.decodingState === DECODING_STATE.NEEDS_DECODE) {\n var parsedContent = tile._parsedContent;\n var draco = parsedContent.draco;\n var decodePromise = DracoLoader.decodePointCloud(draco, context);\n if (defined(decodePromise)) {\n tile.decodingState = DECODING_STATE.DECODING;\n decodePromise.then(function(result) {\n tile.decodingState = DECODING_STATE.READY;\n var decodedPositions = defined(result.POSITION) ? result.POSITION.array : undefined;\n var decodedRgb = defined(result.RGB) ? result.RGB.array : undefined;\n var decodedRgba = defined(result.RGBA) ? result.RGBA.array : undefined;\n var decodedNormals = defined(result.NORMAL) ? result.NORMAL.array : undefined;\n var decodedBatchIds = defined(result.BATCH_ID) ? result.BATCH_ID.array : undefined;\n var isQuantizedDraco = defined(decodedPositions) && defined(result.POSITION.data.quantization);\n var isOctEncodedDraco = defined(decodedNormals) && defined(result.NORMAL.data.quantization);\n if (isQuantizedDraco) {\n // Draco quantization range == quantized volume scale - size in meters of the quantized volume\n // Internal quantized range is the range of values of the quantized data, e.g. 255 for 8-bit, 1023 for 10-bit, etc\n var quantization = result.POSITION.data.quantization;\n var range = quantization.range;\n tile._quantizedVolumeScale = Cartesian3.fromElements(range, range, range);\n tile._quantizedVolumeOffset = Cartesian3.unpack(quantization.minValues);\n tile._quantizedRange = (1 << quantization.quantizationBits) - 1.0;\n tile._isQuantizedDraco = true;\n }\n if (isOctEncodedDraco) {\n tile._octEncodedRange = (1 << result.NORMAL.data.quantization.quantizationBits) - 1.0;\n tile._isOctEncodedDraco = true;\n }\n var styleableProperties = parsedContent.styleableProperties;\n var batchTableProperties = draco.batchTableProperties;\n for (var name in batchTableProperties) {\n if (batchTableProperties.hasOwnProperty(name)) {\n var property = result[name];\n if (!defined(styleableProperties)) {\n styleableProperties = {};\n }\n styleableProperties[name] = {\n typedArray : property.array,\n componentCount : property.data.componentsPerAttribute\n };\n }\n }\n parsedContent.positions = defaultValue(decodedPositions, parsedContent.positions);\n parsedContent.colors = defaultValue(defaultValue(decodedRgba, decodedRgb), parsedContent.colors);\n parsedContent.normals = defaultValue(decodedNormals, parsedContent.normals);\n parsedContent.batchIds = defaultValue(decodedBatchIds, parsedContent.batchIds);\n parsedContent.styleableProperties = styleableProperties;\n }).otherwise(function(error) {\n tile.decodingState = DECODING_STATE.FAILED;\n tile._readyPromise.reject(error);\n });\n }\n }\n return true;\n}\n*/\n","export function assert(condition, message) {\n if (!condition) {\n throw new Error(message);\n }\n}\n","import type {ImageTypeEnum} from '../../types';\nimport {global, isBrowser} from '../utils/globals';\n\n// @ts-ignore TS2339: Property does not exist on type\nconst {_parseImageNode} = global;\n\nconst IMAGE_SUPPORTED = typeof Image !== 'undefined'; // NOTE: \"false\" positives if jsdom is installed\nconst IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== 'undefined';\nconst NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);\nconst DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;\n\n/**\n * Checks if a loaders.gl image type is supported\n * @param type image type string\n */\nexport function isImageTypeSupported(type: string): boolean {\n switch (type) {\n case 'auto':\n // Should only ever be false in Node.js, if polyfills have not been installed...\n return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;\n\n case 'imagebitmap':\n return IMAGE_BITMAP_SUPPORTED;\n case 'image':\n return IMAGE_SUPPORTED;\n case 'data':\n return DATA_SUPPORTED;\n\n default:\n throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);\n }\n}\n\n/**\n * Returns the \"most performant\" supported image type on this platform\n * @returns image type string\n */\nexport function getDefaultImageType(): ImageTypeEnum {\n if (IMAGE_BITMAP_SUPPORTED) {\n return 'imagebitmap';\n }\n if (IMAGE_SUPPORTED) {\n return 'image';\n }\n if (DATA_SUPPORTED) {\n return 'data';\n }\n\n // This should only happen in Node.js\n throw new Error('Install \\'@loaders.gl/polyfills\\' to parse images under Node.js');\n}\n","import type {ImageType, ImageTypeEnum, ImageDataType} from '../../types';\n\nexport function isImage(image: ImageType): boolean {\n return Boolean(getImageTypeOrNull(image));\n}\n\nexport function deleteImage(image: ImageType): void {\n switch (getImageType(image)) {\n case 'imagebitmap':\n (image as ImageBitmap).close();\n break;\n default:\n // Nothing to do for images and image data objects\n }\n}\n\nexport function getImageType(image: ImageType): ImageTypeEnum {\n const format = getImageTypeOrNull(image);\n if (!format) {\n throw new Error('Not an image');\n }\n return format;\n}\n\nexport function getImageSize(image: ImageType): {width: number; height: number} {\n return getImageData(image);\n}\n\nexport function getImageData(image: ImageType): ImageDataType | ImageData {\n switch (getImageType(image)) {\n case 'data':\n return image as unknown as ImageData;\n\n case 'image':\n case 'imagebitmap':\n // Extract the image data from the image via a canvas\n const canvas = document.createElement('canvas');\n // TODO - reuse the canvas?\n const context = canvas.getContext('2d');\n if (!context) {\n throw new Error('getImageData');\n }\n // @ts-ignore\n canvas.width = image.width;\n // @ts-ignore\n canvas.height = image.height;\n // @ts-ignore\n context.drawImage(image, 0, 0);\n // @ts-ignore\n return context.getImageData(0, 0, image.width, image.height);\n\n default:\n throw new Error('getImageData');\n }\n}\n\n// PRIVATE\n\n// eslint-disable-next-line complexity\nfunction getImageTypeOrNull(image) {\n if (typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {\n return 'imagebitmap';\n }\n if (typeof Image !== 'undefined' && image instanceof Image) {\n return 'image';\n }\n if (image && typeof image === 'object' && image.data && image.width && image.height) {\n return 'data';\n }\n return null;\n}\n","// SVG parsing has limitations, e.g:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n\nconst SVG_DATA_URL_PATTERN = /^data:image\\/svg\\+xml/;\nconst SVG_URL_PATTERN = /\\.svg((\\?|#).*)?$/;\n\nexport function isSVG(url) {\n return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));\n}\n\nexport function getBlobOrSVGDataUrl(arrayBuffer, url) {\n if (isSVG(url)) {\n // Prepare a properly tagged data URL, and load using normal mechanism\n const textDecoder = new TextDecoder();\n let xmlText = textDecoder.decode(arrayBuffer);\n // TODO Escape in browser to support e.g. Chinese characters\n try {\n if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {\n xmlText = unescape(encodeURIComponent(xmlText));\n }\n } catch (error) {\n throw new Error((error as Error).message);\n }\n // base64 encoding is safer. utf-8 fails in some browsers\n const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;\n return src;\n }\n return getBlob(arrayBuffer, url);\n}\n\nexport function getBlob(arrayBuffer, url) {\n if (isSVG(url)) {\n // https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});\n throw new Error('SVG cannot be parsed directly to imagebitmap');\n }\n // TODO - how to determine mime type? Param? Sniff here?\n return new Blob([new Uint8Array(arrayBuffer)]); // MIME type not needed?\n}\n","import {getBlobOrSVGDataUrl} from './svg-utils';\n\n// Parses html image from array buffer\nexport default async function parseToImage(arrayBuffer, options, url) {\n // Note: image parsing requires conversion to Blob (for createObjectURL).\n // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...\n // But presumably not worth adding 'blob' flag to loader objects?\n\n const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);\n const URL = self.URL || self.webkitURL;\n const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);\n try {\n return await loadToImage(objectUrl || blobOrDataUrl, options);\n } finally {\n if (objectUrl) {\n URL.revokeObjectURL(objectUrl);\n }\n }\n}\n\nexport async function loadToImage(url, options) {\n const image = new Image();\n image.src = url;\n\n // The `image.onload()` callback does not guarantee that the image has been decoded\n // so a main thread \"freeze\" can be incurred when using the image for the first time.\n // `Image.decode()` returns a promise that completes when image is decoded.\n\n // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode\n // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`\n // Note: `HTMLImageElement.decode()` is not available in Edge and IE11\n if (options.image && options.image.decode && image.decode) {\n await image.decode();\n return image;\n }\n\n // Create a promise that tracks onload/onerror callbacks\n return await new Promise((resolve, reject) => {\n try {\n image.onload = () => resolve(image);\n image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));\n } catch (error) {\n reject(error);\n }\n });\n}\n","import {isSVG, getBlob} from './svg-utils';\nimport parseToImage from './parse-to-image';\n\nconst EMPTY_OBJECT = {};\n\nlet imagebitmapOptionsSupported = true;\n\n/**\n * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data\n * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari\n * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility\n *\n * TODO - createImageBitmap supports source rect (5 param overload), pass through?\n */\nexport default async function parseToImageBitmap(arrayBuffer, options, url) {\n let blob;\n\n // Cannot parse SVG directly to ImageBitmap, parse to Image first\n if (isSVG(url)) {\n // Note: this only works on main thread\n const image = await parseToImage(arrayBuffer, options, url);\n blob = image;\n } else {\n // Create blob from the array buffer\n blob = getBlob(arrayBuffer, url);\n }\n\n const imagebitmapOptions = options && options.imagebitmap;\n\n return await safeCreateImageBitmap(blob, imagebitmapOptions);\n}\n\n/**\n * Safely creates an imageBitmap with options\n * *\n * Firefox crashes if imagebitmapOptions is supplied\n * Avoid supplying if not provided or supported, remember if not supported\n */\nasync function safeCreateImageBitmap(blob, imagebitmapOptions = null) {\n if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {\n imagebitmapOptions = null;\n }\n\n if (imagebitmapOptions) {\n try {\n // @ts-ignore Options\n return await createImageBitmap(blob, imagebitmapOptions);\n } catch (error) {\n console.warn(error); // eslint-disable-line\n imagebitmapOptionsSupported = false;\n }\n }\n\n return await createImageBitmap(blob);\n}\n\nfunction isEmptyObject(object) {\n // @ts-ignore\n for (const key in object || EMPTY_OBJECT) {\n return false;\n }\n return true;\n}\n","// Attributions\n// * Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng\n\n// TODO: make these functions work for Node.js buffers?\n// Quarantine references to Buffer to prevent bundler from adding big polyfills\n// import {bufferToArrayBuffer} from '../node/buffer-to-array-buffer';\n// TODO - this should be handled in @loaders.gl/polyfills\n\n/** MIME type, width and height extracted from binary compressed image data */\nexport type BinaryImageMetadata = {\n mimeType: string;\n width: number;\n height: number;\n};\n\nconst BIG_ENDIAN = false;\nconst LITTLE_ENDIAN = true;\n\n/**\n * Extracts `{mimeType, width and height}` from a memory buffer containing a known image format\n * Currently supports `image/png`, `image/jpeg`, `image/bmp` and `image/gif`.\n * @param binaryData image file memory to parse\n * @returns metadata or null if memory is not a valid image file format layout.\n */\nexport function getBinaryImageMetadata(\n binaryData: DataView | ArrayBuffer\n): BinaryImageMetadata | null {\n const dataView = toDataView(binaryData);\n return (\n getPngMetadata(dataView) ||\n getJpegMetadata(dataView) ||\n getGifMetadata(dataView) ||\n getBmpMetadata(dataView)\n );\n}\n\n// PNG\n\nfunction getPngMetadata(binaryData) {\n const dataView = toDataView(binaryData);\n // Check file contains the first 4 bytes of the PNG signature.\n const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 0x89504e47;\n if (!isPng) {\n return null;\n }\n\n // Extract size from a binary PNG file\n return {\n mimeType: 'image/png',\n width: dataView.getUint32(16, BIG_ENDIAN),\n height: dataView.getUint32(20, BIG_ENDIAN)\n };\n}\n\n// GIF\n\n// Extract size from a binary GIF file\n// TODO: GIF is not this simple\nfunction getGifMetadata(binaryData) {\n const dataView = toDataView(binaryData);\n // Check first 4 bytes of the GIF signature (\"GIF8\").\n const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 0x47494638;\n if (!isGif) {\n return null;\n }\n\n // GIF is little endian.\n return {\n mimeType: 'image/gif',\n width: dataView.getUint16(6, LITTLE_ENDIAN),\n height: dataView.getUint16(8, LITTLE_ENDIAN)\n };\n}\n\n// BMP\n\n// TODO: BMP is not this simple\nexport function getBmpMetadata(binaryData) {\n const dataView = toDataView(binaryData);\n // Check magic number is valid (first 2 characters should be \"BM\").\n // The mandatory bitmap file header is 14 bytes long.\n const isBmp =\n dataView.byteLength >= 14 &&\n dataView.getUint16(0, BIG_ENDIAN) === 0x424d &&\n dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;\n\n if (!isBmp) {\n return null;\n }\n\n // BMP is little endian.\n return {\n mimeType: 'image/bmp',\n width: dataView.getUint32(18, LITTLE_ENDIAN),\n height: dataView.getUint32(22, LITTLE_ENDIAN)\n };\n}\n\n// JPEG\n\n// Extract width and height from a binary JPEG file\nfunction getJpegMetadata(binaryData) {\n const dataView = toDataView(binaryData);\n // Check file contains the JPEG \"start of image\" (SOI) marker\n // followed by another marker.\n const isJpeg =\n dataView.byteLength >= 3 &&\n dataView.getUint16(0, BIG_ENDIAN) === 0xffd8 &&\n dataView.getUint8(2) === 0xff;\n\n if (!isJpeg) {\n return null;\n }\n\n const {tableMarkers, sofMarkers} = getJpegMarkers();\n\n // Exclude the two byte SOI marker.\n let i = 2;\n while (i + 9 < dataView.byteLength) {\n const marker = dataView.getUint16(i, BIG_ENDIAN);\n\n // The frame that contains the width and height of the JPEG image.\n if (sofMarkers.has(marker)) {\n return {\n mimeType: 'image/jpeg',\n height: dataView.getUint16(i + 5, BIG_ENDIAN), // Number of lines\n width: dataView.getUint16(i + 7, BIG_ENDIAN) // Number of pixels per line\n };\n }\n\n // Miscellaneous tables/data preceding the frame header.\n if (!tableMarkers.has(marker)) {\n return null;\n }\n\n // Length includes size of length parameter but not the two byte header.\n i += 2;\n i += dataView.getUint16(i, BIG_ENDIAN);\n }\n\n return null;\n}\n\nfunction getJpegMarkers() {\n // Tables/misc header markers.\n // DQT, DHT, DAC, DRI, COM, APP_n\n const tableMarkers = new Set([0xffdb, 0xffc4, 0xffcc, 0xffdd, 0xfffe]);\n for (let i = 0xffe0; i < 0xfff0; ++i) {\n tableMarkers.add(i);\n }\n\n // SOF markers and DHP marker.\n // These markers are after tables/misc data.\n const sofMarkers = new Set([\n 0xffc0, 0xffc1, 0xffc2, 0xffc3, 0xffc5, 0xffc6, 0xffc7, 0xffc9, 0xffca, 0xffcb, 0xffcd, 0xffce,\n 0xffcf, 0xffde\n ]);\n\n return {tableMarkers, sofMarkers};\n}\n\n// TODO - move into image module?\nfunction toDataView(data) {\n if (data instanceof DataView) {\n return data;\n }\n if (ArrayBuffer.isView(data)) {\n return new DataView(data.buffer);\n }\n\n // TODO: make these functions work for Node.js buffers?\n // if (bufferToArrayBuffer) {\n // data = bufferToArrayBuffer(data);\n // }\n\n // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)\n if (data instanceof ArrayBuffer) {\n return new DataView(data);\n }\n throw new Error('toDataView');\n}\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\nimport parseImage from './lib/parsers/parse-image';\nimport {getBinaryImageMetadata} from './lib/category-api/binary-image-api';\n\nconst EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'svg'];\nconst MIME_TYPES = [\n 'image/png',\n 'image/jpeg',\n 'image/gif',\n 'image/webp',\n 'image/bmp',\n 'image/vnd.microsoft.icon',\n 'image/svg+xml'\n];\n\n/**\n * Loads a platform-specific image type\n * Note: This type can be used as input data to WebGL texture creation\n */\nexport const ImageLoader = {\n id: 'image',\n module: 'images',\n name: 'Images',\n version: VERSION,\n mimeTypes: MIME_TYPES,\n extensions: EXTENSIONS,\n parse: parseImage,\n // TODO: byteOffset, byteLength;\n tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],\n options: {\n image: {\n type: 'auto',\n decode: true // if format is HTML\n }\n // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor\n }\n};\n\nexport const _typecheckImageLoader: LoaderWithParser = ImageLoader;\n","// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n","import {assert} from '../utils/assert';\nimport {isImageTypeSupported, getDefaultImageType} from '../category-api/image-type';\nimport {getImageData} from '../category-api/parsed-image-api';\nimport parseToImage from './parse-to-image';\nimport parseToImageBitmap from './parse-to-image-bitmap';\nimport parseToNodeImage from './parse-to-node-image';\n\n// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)\n// eslint-disable-next-line complexity\nexport default async function parseImage(arrayBuffer, options, context) {\n options = options || {};\n const imageOptions = options.image || {};\n\n // The user can request a specific output format via `options.image.type`\n const imageType = imageOptions.type || 'auto';\n\n const {url} = context || {};\n\n // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`\n const loadType = getLoadableImageType(imageType);\n\n let image;\n switch (loadType) {\n case 'imagebitmap':\n image = await parseToImageBitmap(arrayBuffer, options, url);\n break;\n case 'image':\n image = await parseToImage(arrayBuffer, options, url);\n break;\n case 'data':\n // Node.js loads imagedata directly\n image = await parseToNodeImage(arrayBuffer, options);\n break;\n default:\n assert(false);\n }\n\n // Browser: if options.image.type === 'data', we can now extract data from the loaded image\n if (imageType === 'data') {\n image = getImageData(image);\n }\n\n return image;\n}\n\n// Get a loadable image type from image type\nfunction getLoadableImageType(type) {\n switch (type) {\n case 'auto':\n case 'data':\n // Browser: For image data we need still need to load using an image format\n // Node: the default image type is `data`.\n return getDefaultImageType();\n default:\n // Throw an error if not supported\n isImageTypeSupported(type);\n return type;\n }\n}\n","import {global} from '../utils/globals';\nimport {assert} from '../utils/assert';\nimport {getBinaryImageMetadata} from '../category-api/binary-image-api';\n\n// Use polyfills if installed to p[arsed image using get-pixels\nexport default function parseToNodeImage(arrayBuffer, options) {\n const {mimeType} = getBinaryImageMetadata(arrayBuffer) || {};\n\n // @ts-ignore\n const {_parseImageNode} = global;\n assert(_parseImageNode); // '@loaders.gl/polyfills not installed'\n\n return _parseImageNode(arrayBuffer, mimeType, options);\n}\n","export function getFirstCharacters(data, length = 5): string {\n if (typeof data === 'string') {\n return data.slice(0, length);\n } else if (ArrayBuffer.isView(data)) {\n // Typed Arrays can have offsets into underlying buffer\n return getMagicString(data.buffer, data.byteOffset, length);\n } else if (data instanceof ArrayBuffer) {\n const byteOffset = 0;\n return getMagicString(data, byteOffset, length);\n }\n return '';\n}\n\nexport function getMagicString(\n arrayBuffer: ArrayBuffer,\n byteOffset: number,\n length: number\n): string {\n if (arrayBuffer.byteLength <= byteOffset + length) {\n return '';\n }\n const dataView = new DataView(arrayBuffer);\n let magic = '';\n for (let i = 0; i < length; i++) {\n magic += String.fromCharCode(dataView.getUint8(byteOffset + i));\n }\n return magic;\n}\n","import {getFirstCharacters} from '../binary-utils/get-first-characters';\n\n/**\n * Minimal JSON parser that throws more meaningful error messages\n */\nexport function parseJSON(string: string): any {\n try {\n return JSON.parse(string);\n } catch (_) {\n throw new Error(`Failed to parse JSON from data starting with \"${getFirstCharacters(string)}\"`);\n }\n}\n","import {TypedArray} from '../../types';\nimport {isBuffer, bufferToArrayBuffer} from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n // Note: Should be called first, Buffers can trigger other detections below\n if (isBuffer(data)) {\n return bufferToArrayBuffer(data);\n }\n\n if (data instanceof ArrayBuffer) {\n return data;\n }\n\n // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n if (ArrayBuffer.isView(data)) {\n if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n return data.buffer;\n }\n return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n }\n\n if (typeof data === 'string') {\n const text = data;\n const uint8Array = new TextEncoder().encode(text);\n return uint8Array.buffer;\n }\n\n // HACK to support Blob polyfill\n if (data && typeof data === 'object' && data._toArrayBuffer) {\n return data._toArrayBuffer();\n }\n\n throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} byteLength\n */\nexport function compareArrayBuffers(\n arrayBuffer1: ArrayBuffer,\n arrayBuffer2: ArrayBuffer,\n byteLength?: number\n): boolean {\n byteLength = byteLength || arrayBuffer1.byteLength;\n if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {\n return false;\n }\n const array1 = new Uint8Array(arrayBuffer1);\n const array2 = new Uint8Array(arrayBuffer2);\n for (let i = 0; i < array1.length; ++i) {\n if (array1[i] !== array2[i]) {\n return false;\n }\n }\n return true;\n}\n\n/**\n * Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n */\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer {\n // Make sure all inputs are wrapped in typed arrays\n const sourceArrays = sources.map((source2) =>\n source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n );\n\n // Get length of all inputs\n const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n // Allocate array with space for all inputs\n const result = new Uint8Array(byteLength);\n\n // Copy the subarrays\n let offset = 0;\n for (const sourceArray of sourceArrays) {\n result.set(sourceArray, offset);\n offset += sourceArray.byteLength;\n }\n\n // We work with ArrayBuffers, discard the typed array wrapper\n return result.buffer;\n}\n\n/**\n * Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param {...*} arrays - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n */\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n // @ts-ignore\n const arrays = typedArrays as TypedArray[];\n // @ts-ignore\n const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) || null;\n if (!TypedArrayConstructor) {\n throw new Error(\n '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n );\n }\n\n const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n // @ts-ignore typescript does not like dynamic constructors\n const result = new TypedArrayConstructor(sumLength);\n let offset = 0;\n for (const array of arrays) {\n result.set(array, offset);\n offset += array.length;\n }\n return result;\n}\n\n/**\n * Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n arrayBuffer: ArrayBuffer,\n byteOffset: number,\n byteLength?: number\n): ArrayBuffer {\n const subArray =\n byteLength !== undefined\n ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n : new Uint8Array(arrayBuffer).subarray(byteOffset);\n const arrayCopy = new Uint8Array(subArray);\n return arrayCopy.buffer;\n}\n","// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition, message) {\n if (!condition) {\n throw new Error(message || 'assert failed: gltf');\n }\n}\n","// Resolves a relative url against a baseUrl\n// If url is absolute, return it unchanged\nexport function resolveUrl(url, options) {\n // TODO: Use better logic to handle all protocols plus not delay on data\n const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');\n if (absolute) {\n return url;\n }\n const baseUrl = options.baseUri || options.uri;\n if (!baseUrl) {\n throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);\n }\n return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;\n}\n","// TODO - GLTFScenegraph should use these\nimport {assert} from '../utils/assert';\n\n// accepts buffer view index or buffer view object\n// returns a `Uint8Array`\nexport function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {\n const bufferView = json.bufferViews[bufferViewIndex];\n assert(bufferView);\n\n // Get hold of the arrayBuffer\n const bufferIndex = bufferView.buffer;\n const binChunk = buffers[bufferIndex];\n assert(binChunk);\n\n const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;\n return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);\n}\n\n// accepts accessor index or accessor object\n// returns a `Uint8Array`\nexport function getTypedArrayForImageData(json, buffers, imageIndex) {\n const image = json.images[imageIndex];\n const bufferViewIndex = json.bufferViews[image.bufferView];\n return getTypedArrayForBufferView(json, buffers, bufferViewIndex);\n}\n\n/*\n// accepts accessor index or accessor object\n// returns a typed array with type that matches the types\nexport function getTypedArrayForAccessor(accessor) {\n accessor = this.getAccessor(accessor);\n const bufferView = this.getBufferView(accessor.bufferView);\n const buffer = this.getBuffer(bufferView.buffer);\n const arrayBuffer = buffer.data;\n\n // Create a new typed array as a view into the combined buffer\n const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n const byteOffset = bufferView.byteOffset + accessor.byteOffset;\n return new ArrayType(arrayBuffer, byteOffset, length);\n}\n*/\n","import {assert} from '../env-utils/assert';\n\n/**\n * Calculate new size of an arrayBuffer to be aligned to an n-byte boundary\n * This function increases `byteLength` by the minimum delta,\n * allowing the total length to be divided by `padding`\n * @param byteLength\n * @param padding\n */\nexport function padToNBytes(byteLength: number, padding: number): number {\n assert(byteLength >= 0); // `Incorrect 'byteLength' value: ${byteLength}`\n assert(padding > 0); // `Incorrect 'padding' value: ${padding}`\n return (byteLength + (padding - 1)) & ~(padding - 1);\n}\n\n/**\n * Creates a new Uint8Array based on two different ArrayBuffers\n * @param targetBuffer The first buffer.\n * @param sourceBuffer The second buffer.\n * @return The new ArrayBuffer created out of the two.\n */\nexport function copyArrayBuffer(\n targetBuffer: ArrayBuffer,\n sourceBuffer: ArrayBuffer,\n byteOffset: number,\n byteLength: number = sourceBuffer.byteLength\n): ArrayBuffer {\n const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);\n const sourceArray = new Uint8Array(sourceBuffer);\n targetArray.set(sourceArray);\n return targetBuffer;\n}\n\n/**\n * Copy from source to target at the targetOffset\n *\n * @param source - The data to copy\n * @param target - The destination to copy data into\n * @param targetOffset - The start offset into target to place the copied data\n * @returns the new offset taking into account proper padding\n */\nexport function copyToArray(source: ArrayBuffer | any, target: any, targetOffset: number): number {\n let sourceArray;\n\n if (source instanceof ArrayBuffer) {\n sourceArray = new Uint8Array(source);\n } else {\n // Pack buffer onto the big target array\n //\n // 'source.data.buffer' could be a view onto a larger buffer.\n // We MUST use this constructor to ensure the byteOffset and byteLength is\n // set to correct values from 'source.data' and not the underlying\n // buffer for target.set() to work properly.\n const srcByteOffset = source.byteOffset;\n const srcByteLength = source.byteLength;\n // In gltf parser it is set as \"arrayBuffer\" instead of \"buffer\"\n // https://github.com/visgl/loaders.gl/blob/1e3a82a0a65d7b6a67b1e60633453e5edda2960a/modules/gltf/src/lib/parse-gltf.js#L85\n sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);\n }\n\n // Pack buffer onto the big target array\n target.set(sourceArray, targetOffset);\n\n return targetOffset + padToNBytes(sourceArray.byteLength, 4);\n}\n","import {assert} from '../utils/assert';\n\nconst TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];\n\ntype TypedArrayConstructor =\n | Int8ArrayConstructor\n | Uint8ArrayConstructor\n | Int16ArrayConstructor\n | Uint16ArrayConstructor\n | Int32ArrayConstructor\n | Uint32ArrayConstructor\n | Int32ArrayConstructor\n | Uint32ArrayConstructor\n | Float32ArrayConstructor\n | Float64ArrayConstructor;\n\nconst ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [\n [Int8Array, 5120],\n [Uint8Array, 5121],\n [Int16Array, 5122],\n [Uint16Array, 5123],\n [Uint32Array, 5125],\n [Float32Array, 5126],\n [Float64Array, 5130]\n];\nconst ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(\n ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT\n);\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n SCALAR: 1,\n VEC2: 2,\n VEC3: 3,\n VEC4: 4,\n MAT2: 4,\n MAT3: 9,\n MAT4: 16\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n 5120: 1,\n 5121: 1,\n 5122: 2,\n 5123: 2,\n 5125: 4,\n 5126: 4\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n 5120: Int8Array,\n 5121: Uint8Array,\n 5122: Int16Array,\n 5123: Uint16Array,\n 5125: Uint32Array,\n 5126: Float32Array\n};\n\nexport function getAccessorTypeFromSize(size) {\n const type = TYPES[size - 1];\n return type || TYPES[0];\n}\n\nexport function getComponentTypeFromArray(typedArray) {\n const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);\n if (!componentType) {\n throw new Error('Illegal typed array');\n }\n return componentType;\n}\n\nexport function getAccessorArrayTypeAndLength(accessor, bufferView) {\n const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];\n const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];\n const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];\n const length = accessor.count * components;\n const byteLength = accessor.count * components * bytesPerComponent;\n assert(byteLength >= 0 && byteLength <= bufferView.byteLength);\n return {ArrayType, length, byteLength};\n}\n","import type {\n GLTF,\n GLTFScene,\n GLTFNode,\n GLTFMesh,\n GLTFSkin,\n GLTFMaterial,\n GLTFAccessor,\n GLTFSampler,\n GLTFTexture,\n GLTFImage,\n GLTFBuffer,\n GLTFBufferView\n} from '../types/gltf-types';\n\nimport {getBinaryImageMetadata} from '@loaders.gl/images';\nimport {padToNBytes, copyToArray} from '@loaders.gl/loader-utils';\nimport {assert} from '../utils/assert';\nimport {\n getAccessorArrayTypeAndLength,\n getAccessorTypeFromSize,\n getComponentTypeFromArray\n} from '../gltf-utils/gltf-utils';\n\ntype GLTFWithBuffers = {\n json: GLTF;\n buffers: any[];\n binary?: ArrayBuffer;\n};\n\nconst DEFAULT_GLTF_JSON: GLTF = {\n asset: {\n version: '2.0',\n generator: 'loaders.gl'\n },\n buffers: []\n};\n\n/**\n * Class for structured access to GLTF data\n */\nexport default class GLTFScenegraph {\n // internal\n gltf: GLTFWithBuffers;\n sourceBuffers: any[];\n byteLength: number;\n\n constructor(gltf?: {json: GLTF; buffers?: any[]}) {\n // @ts-ignore\n this.gltf = gltf || {\n json: {...DEFAULT_GLTF_JSON},\n buffers: []\n };\n this.sourceBuffers = [];\n this.byteLength = 0;\n\n // Initialize buffers\n if (this.gltf.buffers && this.gltf.buffers[0]) {\n this.byteLength = this.gltf.buffers[0].byteLength;\n this.sourceBuffers = [this.gltf.buffers[0]];\n }\n }\n\n // Accessors\n\n get json(): GLTF {\n return this.gltf.json;\n }\n\n getApplicationData(key: string): {[key: string]: any} {\n // TODO - Data is already unpacked by GLBParser\n const data = this.json[key];\n return data;\n }\n\n getExtraData(key: string): {[key: string]: any} {\n // TODO - Data is already unpacked by GLBParser\n const extras = this.json.extras || {};\n return extras[key];\n }\n\n getExtension(extensionName: string): {[key: string]: any} | null {\n const isExtension = this.getUsedExtensions().find((name) => name === extensionName);\n const extensions = this.json.extensions || {};\n return isExtension ? extensions[extensionName] || true : null;\n }\n\n getRequiredExtension(extensionName: string): {[key: string]: any} | null {\n const isRequired = this.getRequiredExtensions().find((name) => name === extensionName);\n return isRequired ? this.getExtension(extensionName) : null;\n }\n\n getRequiredExtensions(): string[] {\n return this.json.extensionsRequired || [];\n }\n\n getUsedExtensions(): string[] {\n return this.json.extensionsUsed || [];\n }\n\n getObjectExtension(\n object: {[key: string]: any},\n extensionName: string\n ): {[key: string]: any} | null {\n const extensions = object.extensions || {};\n return extensions[extensionName];\n }\n\n getScene(index: number): GLTFScene {\n return this.getObject('scenes', index) as GLTFScene;\n }\n\n getNode(index: number): GLTFNode {\n return this.getObject('nodes', index) as GLTFNode;\n }\n\n getSkin(index: number): GLTFSkin {\n return this.getObject('skins', index) as GLTFSkin;\n }\n\n getMesh(index: number): GLTFMesh {\n return this.getObject('meshes', index) as GLTFMesh;\n }\n\n getMaterial(index: number): GLTFMaterial {\n return this.getObject('materials', index) as GLTFMaterial;\n }\n\n getAccessor(index: number): GLTFAccessor {\n return this.getObject('accessors', index) as GLTFAccessor;\n }\n\n // getCamera(index: number): object | null {\n // return null; // TODO: fix thi: object as null;\n // }\n\n getTexture(index: number): GLTFTexture {\n return this.getObject('textures', index) as GLTFTexture;\n }\n\n getSampler(index: number): GLTFSampler {\n return this.getObject('samplers', index) as GLTFSampler;\n }\n\n getImage(index: number): GLTFImage {\n return this.getObject('images', index) as GLTFImage;\n }\n\n getBufferView(index: number | object): GLTFBufferView {\n return this.getObject('bufferViews', index) as GLTFBufferView;\n }\n\n getBuffer(index: number): GLTFBuffer {\n return this.getObject('buffers', index) as GLTFBuffer;\n }\n\n getObject(array: string, index: number | object): object {\n // check if already resolved\n if (typeof index === 'object') {\n return index;\n }\n const object = this.json[array] && this.json[array][index];\n if (!object) {\n throw new Error(`glTF file error: Could not find ${array}[${index}]`); // eslint-disable-line\n }\n return object;\n }\n\n /**\n * Accepts buffer view index or buffer view object\n * @returns a `Uint8Array`\n */\n getTypedArrayForBufferView(bufferView: number | object): Uint8Array {\n bufferView = this.getBufferView(bufferView);\n // @ts-ignore\n const bufferIndex = bufferView.buffer;\n\n // Get hold of the arrayBuffer\n // const buffer = this.getBuffer(bufferIndex);\n const binChunk = this.gltf.buffers[bufferIndex];\n assert(binChunk);\n\n // @ts-ignore\n const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;\n // @ts-ignore\n return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);\n }\n\n /** Accepts accessor index or accessor object\n * @returns a typed array with type that matches the types\n */\n getTypedArrayForAccessor(accessor: number | object): any {\n // @ts-ignore\n accessor = this.getAccessor(accessor);\n // @ts-ignore\n const bufferView = this.getBufferView(accessor.bufferView);\n const buffer = this.getBuffer(bufferView.buffer);\n // @ts-ignore\n const arrayBuffer = buffer.data;\n\n // Create a new typed array as a view into the combined buffer\n const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n // @ts-ignore\n const byteOffset = bufferView.byteOffset + accessor.byteOffset;\n return new ArrayType(arrayBuffer, byteOffset, length);\n }\n\n /** accepts accessor index or accessor object\n * returns a `Uint8Array`\n */\n getTypedArrayForImageData(image: number | object): Uint8Array {\n // @ts-ignore\n image = this.getAccessor(image);\n // @ts-ignore\n const bufferView = this.getBufferView(image.bufferView);\n const buffer = this.getBuffer(bufferView.buffer);\n // @ts-ignore\n const arrayBuffer = buffer.data;\n\n const byteOffset = bufferView.byteOffset || 0;\n return new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);\n }\n\n // MODIFERS\n\n /**\n * Add an extra application-defined key to the top-level data structure\n */\n addApplicationData(key: string, data: object): GLTFScenegraph {\n this.json[key] = data;\n return this;\n }\n\n /**\n * `extras` - Standard GLTF field for storing application specific data\n */\n addExtraData(key: string, data: object): GLTFScenegraph {\n this.json.extras = this.json.extras || {};\n this.json.extras[key] = data;\n return this;\n }\n\n addObjectExtension(object: object, extensionName: string, data: object): GLTFScenegraph {\n // @ts-ignore\n object.extensions = object.extensions || {};\n // TODO - clobber or merge?\n // @ts-ignore\n object.extensions[extensionName] = data;\n this.registerUsedExtension(extensionName);\n return this;\n }\n\n setObjectExtension(object: object, extensionName: string, data: object): void {\n // @ts-ignore\n const extensions = object.extensions || {};\n extensions[extensionName] = data;\n // TODO - add to usedExtensions...\n }\n\n removeObjectExtension(object: object, extensionName: string): object {\n // @ts-ignore\n const extensions = object.extensions || {};\n const extension = extensions[extensionName];\n delete extensions[extensionName];\n return extension;\n }\n\n /**\n * Add to standard GLTF top level extension object, mark as used\n */\n addExtension(extensionName: string, extensionData: object = {}): object {\n assert(extensionData);\n this.json.extensions = this.json.extensions || {};\n this.json.extensions[extensionName] = extensionData;\n this.registerUsedExtension(extensionName);\n return extensionData;\n }\n\n /**\n * Standard GLTF top level extension object, mark as used and required\n */\n addRequiredExtension(extensionName, extensionData: object = {}): object {\n assert(extensionData);\n this.addExtension(extensionName, extensionData);\n this.registerRequiredExtension(extensionName);\n return extensionData;\n }\n\n /**\n * Add extensionName to list of used extensions\n */\n registerUsedExtension(extensionName: string): void {\n this.json.extensionsUsed = this.json.extensionsUsed || [];\n if (!this.json.extensionsUsed.find((ext) => ext === extensionName)) {\n this.json.extensionsUsed.push(extensionName);\n }\n }\n\n /**\n * Add extensionName to list of required extensions\n */\n registerRequiredExtension(extensionName: string): void {\n this.registerUsedExtension(extensionName);\n this.json.extensionsRequired = this.json.extensionsRequired || [];\n if (!this.json.extensionsRequired.find((ext) => ext === extensionName)) {\n this.json.extensionsRequired.push(extensionName);\n }\n }\n\n /**\n * Removes an extension from the top-level list\n */\n removeExtension(extensionName: string): void {\n if (this.json.extensionsRequired) {\n this._removeStringFromArray(this.json.extensionsRequired, extensionName);\n }\n if (this.json.extensionsUsed) {\n this._removeStringFromArray(this.json.extensionsUsed, extensionName);\n }\n if (this.json.extensions) {\n delete this.json.extensions[extensionName];\n }\n }\n\n /**\n * Set default scene which is to be displayed at load time\n */\n setDefaultScene(sceneIndex: number): void {\n this.json.scene = sceneIndex;\n }\n\n /**\n * @todo: add more properties for scene initialization:\n * name`, `extensions`, `extras`\n * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-scene\n */\n addScene(scene: {nodeIndices: number[]}): number {\n const {nodeIndices} = scene;\n this.json.scenes = this.json.scenes || [];\n this.json.scenes.push({nodes: nodeIndices});\n return this.json.scenes.length - 1;\n }\n\n /**\n * @todo: add more properties for node initialization:\n * `name`, `extensions`, `extras`, `camera`, `children`, `skin`, `rotation`, `scale`, `translation`, `weights`\n * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#node\n */\n addNode(node: {meshIndex: number; matrix: number[]}): number {\n const {meshIndex, matrix} = node;\n this.json.nodes = this.json.nodes || [];\n const nodeData = {mesh: meshIndex};\n if (matrix) {\n // @ts-ignore\n nodeData.matrix = matrix;\n }\n this.json.nodes.push(nodeData);\n return this.json.nodes.length - 1;\n }\n\n /** Adds a mesh to the json part */\n addMesh(mesh: {attributes: object; indices: object; material: number; mode: number}): number {\n const {attributes, indices, material, mode = 4} = mesh;\n const accessors = this._addAttributes(attributes);\n\n const glTFMesh = {\n primitives: [\n {\n attributes: accessors,\n mode\n }\n ]\n };\n\n if (indices) {\n const indicesAccessor = this._addIndices(indices);\n // @ts-ignore\n glTFMesh.primitives[0].indices = indicesAccessor;\n }\n\n if (Number.isFinite(material)) {\n // @ts-ignore\n glTFMesh.primitives[0].material = material;\n }\n\n this.json.meshes = this.json.meshes || [];\n this.json.meshes.push(glTFMesh);\n return this.json.meshes.length - 1;\n }\n\n addPointCloud(attributes: object): number {\n // @ts-ignore\n const accessorIndices = this._addAttributes(attributes);\n\n const glTFMesh = {\n primitives: [\n {\n attributes: accessorIndices,\n mode: 0 // GL.POINTS\n }\n ]\n };\n\n this.json.meshes = this.json.meshes || [];\n this.json.meshes.push(glTFMesh);\n return this.json.meshes.length - 1;\n }\n\n /**\n * Adds a binary image. Builds glTF \"JSON metadata\" and saves buffer reference\n * Buffer will be copied into BIN chunk during \"pack\"\n * Currently encodes as glTF image\n * @param imageData\n * @param mimeType\n */\n addImage(imageData: any, mimeTypeOpt?: string): number {\n // If image is referencing a bufferView instead of URI, mimeType must be defined:\n // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#images\n // \"a reference to a bufferView; in that case mimeType must be defined.\"\n const metadata = getBinaryImageMetadata(imageData);\n const mimeType = mimeTypeOpt || metadata?.mimeType;\n\n const bufferViewIndex = this.addBufferView(imageData);\n\n const glTFImage = {\n bufferView: bufferViewIndex,\n mimeType\n };\n\n this.json.images = this.json.images || [];\n this.json.images.push(glTFImage);\n return this.json.images.length - 1;\n }\n\n /**\n * Add one untyped source buffer, create a matching glTF `bufferView`, and return its index\n * @param buffer\n */\n addBufferView(buffer: any): number {\n const byteLength = buffer.byteLength;\n assert(Number.isFinite(byteLength));\n\n // Add this buffer to the list of buffers to be written to the body.\n this.sourceBuffers = this.sourceBuffers || [];\n this.sourceBuffers.push(buffer);\n\n const glTFBufferView = {\n buffer: 0,\n // Write offset from the start of the binary body\n byteOffset: this.byteLength,\n byteLength\n };\n\n // We've now added the contents to the body, so update the total length\n // Every sub-chunk needs to be 4-byte align ed\n this.byteLength += padToNBytes(byteLength, 4);\n\n // Add a bufferView indicating start and length of this binary sub-chunk\n this.json.bufferViews = this.json.bufferViews || [];\n this.json.bufferViews.push(glTFBufferView);\n return this.json.bufferViews.length - 1;\n }\n\n /**\n * Adds an accessor to a bufferView\n * @param bufferViewIndex\n * @param accessor\n */\n addAccessor(bufferViewIndex: number, accessor: object): number {\n const glTFAccessor = {\n bufferView: bufferViewIndex,\n // @ts-ignore\n type: getAccessorTypeFromSize(accessor.size),\n // @ts-ignore\n componentType: accessor.componentType,\n // @ts-ignore\n count: accessor.count,\n // @ts-ignore\n max: accessor.max,\n // @ts-ignore\n min: accessor.min\n };\n\n this.json.accessors = this.json.accessors || [];\n this.json.accessors.push(glTFAccessor);\n return this.json.accessors.length - 1;\n }\n\n /**\n * Add a binary buffer. Builds glTF \"JSON metadata\" and saves buffer reference\n * Buffer will be copied into BIN chunk during \"pack\"\n * Currently encodes buffers as glTF accessors, but this could be optimized\n * @param sourceBuffer\n * @param accessor\n */\n addBinaryBuffer(sourceBuffer: any, accessor: object = {size: 3}): number {\n const bufferViewIndex = this.addBufferView(sourceBuffer);\n // @ts-ignore\n let minMax = {min: accessor.min, max: accessor.max};\n if (!minMax.min || !minMax.max) {\n // @ts-ignore\n minMax = this._getAccessorMinMax(sourceBuffer, accessor.size);\n }\n\n const accessorDefaults = {\n // @ts-ignore\n size: accessor.size,\n componentType: getComponentTypeFromArray(sourceBuffer),\n // @ts-ignore\n count: Math.round(sourceBuffer.length / accessor.size),\n min: minMax.min,\n max: minMax.max\n };\n\n return this.addAccessor(bufferViewIndex, Object.assign(accessorDefaults, accessor));\n }\n\n /**\n * Adds a texture to the json part\n * @todo: add more properties for texture initialization\n * `sampler`, `name`, `extensions`, `extras`\n * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texture\n */\n addTexture(texture: {imageIndex: number}): number {\n const {imageIndex} = texture;\n const glTFTexture = {\n source: imageIndex\n };\n\n this.json.textures = this.json.textures || [];\n this.json.textures.push(glTFTexture);\n return this.json.textures.length - 1;\n }\n\n /** Adds a material to the json part */\n addMaterial(pbrMaterialInfo: Object): number {\n this.json.materials = this.json.materials || [];\n this.json.materials.push(pbrMaterialInfo);\n return this.json.materials.length - 1;\n }\n\n /** Pack the binary chunk */\n createBinaryChunk(): void {\n // Encoder expects this array undefined or empty\n this.gltf.buffers = [];\n\n // Allocate total array\n const totalByteLength = this.byteLength;\n const arrayBuffer = new ArrayBuffer(totalByteLength);\n const targetArray = new Uint8Array(arrayBuffer);\n\n // Copy each array into\n let dstByteOffset = 0;\n for (const sourceBuffer of this.sourceBuffers || []) {\n dstByteOffset = copyToArray(sourceBuffer, targetArray, dstByteOffset);\n }\n\n // Update the glTF BIN CHUNK byte length\n if (this.json?.buffers?.[0]) {\n this.json.buffers[0].byteLength = totalByteLength;\n } else {\n this.json.buffers = [{byteLength: totalByteLength}];\n }\n\n // Save generated arrayBuffer\n this.gltf.binary = arrayBuffer;\n\n // Put arrayBuffer to sourceBuffers for possible additional writing data in the chunk\n this.sourceBuffers = [arrayBuffer];\n }\n\n // PRIVATE\n\n _removeStringFromArray(array, string) {\n let found = true;\n while (found) {\n const index = array.indexOf(string);\n if (index > -1) {\n array.splice(index, 1);\n } else {\n found = false;\n }\n }\n }\n\n /**\n * Add attributes to buffers and create `attributes` object which is part of `mesh`\n */\n _addAttributes(attributes = {}) {\n const result = {};\n for (const attributeKey in attributes) {\n const attributeData = attributes[attributeKey];\n const attrName = this._getGltfAttributeName(attributeKey);\n const accessor = this.addBinaryBuffer(attributeData.value, attributeData);\n result[attrName] = accessor;\n }\n return result;\n }\n\n /**\n * Add indices to buffers\n */\n _addIndices(indices) {\n return this.addBinaryBuffer(indices, {size: 1});\n }\n\n /**\n * Deduce gltf specific attribue name from input attribute name\n */\n _getGltfAttributeName(attributeName) {\n switch (attributeName.toLowerCase()) {\n case 'position':\n case 'positions':\n case 'vertices':\n return 'POSITION';\n case 'normal':\n case 'normals':\n return 'NORMAL';\n case 'color':\n case 'colors':\n return 'COLOR_0';\n case 'texcoord':\n case 'texcoords':\n return 'TEXCOORD_0';\n default:\n return attributeName;\n }\n }\n\n /**\n * Calculate `min` and `max` arrays of accessor according to spec:\n * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-accessor\n */\n _getAccessorMinMax(buffer, size) {\n const result = {min: null, max: null};\n if (buffer.length < size) {\n return result;\n }\n // @ts-ignore\n result.min = [];\n // @ts-ignore\n result.max = [];\n const initValues = buffer.subarray(0, size);\n for (const value of initValues) {\n // @ts-ignore\n result.min.push(value);\n // @ts-ignore\n result.max.push(value);\n }\n\n for (let index = size; index < buffer.length; index += size) {\n for (let componentIndex = 0; componentIndex < size; componentIndex++) {\n // @ts-ignore\n result.min[0 + componentIndex] = Math.min(\n // @ts-ignore\n result.min[0 + componentIndex],\n buffer[index + componentIndex]\n );\n // @ts-ignore\n result.max[0 + componentIndex] = Math.max(\n // @ts-ignore\n result.max[0 + componentIndex],\n buffer[index + componentIndex]\n );\n }\n }\n return result;\n }\n}\n","// import type {TypedArray} from '../types/loader-utils';\nimport type {GLTFAccessor} from '../types/gltf-types';\n// TODO - remove\nimport {getAccessorTypeFromSize, getComponentTypeFromArray} from './gltf-utils';\n\n// Returns a fresh attributes object with glTF-standardized attributes names\n// Attributes that cannot be identified will not be included\n// Removes `indices` if present, as it should be stored separately from the attributes\nexport function getGLTFAccessors(attributes): {[key: string]: GLTFAccessor} {\n const accessors = {};\n for (const name in attributes) {\n const attribute = attributes[name];\n if (name !== 'indices') {\n const glTFAccessor = getGLTFAccessor(attribute);\n accessors[name] = glTFAccessor;\n }\n }\n return accessors;\n}\n\n// Fix up a single accessor.\n// Input: typed array or a partial accessor object\n// Return: accessor object\nexport function getGLTFAccessor(attribute) {\n const {buffer, size, count} = getAccessorData(attribute);\n\n const glTFAccessor: GLTFAccessor = {\n // glTF Accessor values\n // TODO: Instead of a bufferView index we could have an actual buffer (typed array)\n // bufferView: null,\n // TODO: Deprecate `value` in favor of bufferView?\n // @ts-ignore\n value: buffer,\n size, // Decoded `type` (e.g. SCALAR)\n\n byteOffset: 0,\n count,\n type: getAccessorTypeFromSize(size),\n componentType: getComponentTypeFromArray(buffer)\n };\n\n return glTFAccessor;\n}\n\n// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {\n// return data.attributes[data.glTFAttributeMap[gltfAttributeName]];\n// }\n\nfunction getAccessorData(attribute) {\n let buffer = attribute;\n let size = 1;\n let count = 0;\n\n if (attribute && attribute.value) {\n buffer = attribute.value;\n size = attribute.size || 1;\n }\n\n if (buffer) {\n if (!ArrayBuffer.isView(buffer)) {\n buffer = toTypedArray(buffer, Float32Array);\n }\n count = buffer.length / size;\n }\n\n return {buffer, size, count};\n}\n\n// Convert non-typed arrays to arrays of specified format\nfunction toTypedArray(array, ArrayType, convertTypedArrays = false) {\n if (!array) {\n return null;\n }\n if (Array.isArray(array)) {\n return new ArrayType(array);\n }\n if (convertTypedArrays && !(array instanceof ArrayType)) {\n return new ArrayType(array);\n }\n return array;\n}\n","// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression\n// Only TRIANGLES: 0x0004 and TRIANGLE_STRIP: 0x0005 are supported\n\n/* eslint-disable camelcase */\nimport type {GLTF, GLTFAccessor, GLTFMeshPrimitive} from '../types/gltf-types';\nimport type {GLTFLoaderOptions} from '../../gltf-loader';\n\nimport type {LoaderContext} from '@loaders.gl/loader-utils';\nimport {DracoLoader} from '@loaders.gl/draco';\nimport {DracoLoaderOptions, DracoMesh} from '@loaders.gl/draco';\nimport {sliceArrayBuffer} from '@loaders.gl/loader-utils';\nimport {default as Scenegraph} from '../api/gltf-scenegraph';\nimport {KHR_DRACO_MESH_COMPRESSION} from '../gltf-utils/gltf-constants';\nimport {getGLTFAccessors, getGLTFAccessor} from '../gltf-utils/gltf-attribute-utils';\n\n// Note: We have a \"soft dependency\" on DracoWriter to avoid bundling it when not needed\nexport async function decode(\n gltfData: {json: GLTF},\n options: GLTFLoaderOptions,\n context: LoaderContext\n): Promise<void> {\n if (!options?.gltf?.decompressMeshes) {\n return;\n }\n\n const scenegraph = new Scenegraph(gltfData);\n const promises: Promise<void>[] = [];\n for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {\n if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {\n promises.push(decompressPrimitive(scenegraph, primitive, options, context));\n }\n }\n\n // Decompress meshes in parallel\n await Promise.all(promises);\n\n // We have now decompressed all primitives, so remove the top-level extensions\n scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);\n}\n\nexport function encode(gltfData, options: GLTFLoaderOptions = {}): void {\n const scenegraph = new Scenegraph(gltfData);\n\n for (const mesh of scenegraph.json.meshes || []) {\n // eslint-disable-next-line camelcase\n // @ts-ignore\n compressMesh(mesh, options);\n // NOTE: Only add the extension if something was actually compressed\n scenegraph.addRequiredExtension(KHR_DRACO_MESH_COMPRESSION);\n }\n}\n\n// DECODE\n\n// Unpacks one mesh primitive and removes the extension from the primitive\n// DracoDecoder needs to be imported and registered by app\n// Returns: Promise that resolves when all pending draco decoder jobs for this mesh complete\n\n// TODO - Implement fallback behavior per KHR_DRACO_MESH_COMPRESSION spec\n\nasync function decompressPrimitive(\n scenegraph: Scenegraph,\n primitive: GLTFMeshPrimitive,\n options: GLTFLoaderOptions,\n context: LoaderContext\n): Promise<void> {\n const dracoExtension = scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);\n if (!dracoExtension) {\n return;\n }\n\n const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);\n // TODO - parse does not yet deal well with byte offsets embedded in typed arrays. Copy buffer\n // TODO - remove when `parse` is fixed to handle `byteOffset`s\n const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset); // , buffer.byteLength);\n\n const {parse} = context;\n const dracoOptions: DracoLoaderOptions = {...options};\n\n // TODO - remove hack: The entire tileset might be included, too expensive to serialize\n delete dracoOptions['3d-tiles'];\n const decodedData = (await parse(bufferCopy, DracoLoader, dracoOptions, context)) as DracoMesh;\n\n const decodedAttributes: {[key: string]: GLTFAccessor} = getGLTFAccessors(decodedData.attributes);\n\n // Restore min/max values\n for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {\n if (attributeName in primitive.attributes) {\n const accessorIndex: number = primitive.attributes[attributeName];\n const accessor = scenegraph.getAccessor(accessorIndex);\n if (accessor?.min && accessor?.max) {\n decodedAttribute.min = accessor.min;\n decodedAttribute.max = accessor.max;\n }\n }\n }\n\n // @ts-ignore\n primitive.attributes = decodedAttributes;\n if (decodedData.indices) {\n // @ts-ignore\n primitive.indices = getGLTFAccessor(decodedData.indices);\n }\n\n // Extension has been processed, delete it\n // delete primitive.extensions[KHR_DRACO_MESH_COMPRESSION];\n\n checkPrimitive(primitive);\n}\n\n// ENCODE\n\n// eslint-disable-next-line max-len\n// Only TRIANGLES: 0x0004 and TRIANGLE_STRIP: 0x0005 are supported\nfunction compressMesh(attributes, indices, mode: number = 4, options, context: LoaderContext) {\n if (!options.DracoWriter) {\n throw new Error('options.gltf.DracoWriter not provided');\n }\n\n // TODO - use DracoWriter using encode w/ registered DracoWriter...\n const compressedData = options.DracoWriter.encodeSync({attributes});\n\n // Draco compression may change the order and number of vertices in a mesh.\n // To satisfy the requirement that accessors properties be correct for both\n // compressed and uncompressed data, generators should create uncompressed\n // attributes and indices using data that has been decompressed from the Draco buffer,\n // rather than the original source data.\n // @ts-ignore TODO this needs to be fixed\n const decodedData = context?.parseSync?.({attributes});\n const fauxAccessors = options._addFauxAttributes(decodedData.attributes);\n\n const bufferViewIndex = options.addBufferView(compressedData);\n\n const glTFMesh = {\n primitives: [\n {\n attributes: fauxAccessors, // TODO - verify with spec\n mode, // GL.POINTS\n extensions: {\n [KHR_DRACO_MESH_COMPRESSION]: {\n bufferView: bufferViewIndex,\n attributes: fauxAccessors // TODO - verify with spec\n }\n }\n }\n ]\n };\n\n return glTFMesh;\n}\n\n// UTILS\n\nfunction checkPrimitive(primitive: GLTFMeshPrimitive) {\n if (!primitive.attributes && Object.keys(primitive.attributes).length > 0) {\n throw new Error('glTF: Empty primitive detected: Draco decompression failure?');\n }\n}\n\nfunction* makeMeshPrimitiveIterator(scenegraph) {\n for (const mesh of scenegraph.json.meshes || []) {\n for (const primitive of mesh.primitives) {\n yield primitive;\n }\n }\n}\n","// GLTF 1.0 extensions\nexport const KHR_BINARY_GLTF = 'KHR_binary_glTF';\n\n// GLTF 2.0 extensions\nexport const KHR_DRACO_MESH_COMPRESSION = 'KHR_draco_mesh_compression';\nexport const KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';\nexport const KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';\nexport const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';\n\n// External extensions\nexport const EXT_MESHOPT_COMPRESSION = 'EXT_meshopt_compression';\n\nconst COMPONENTS = {\n SCALAR: 1,\n VEC2: 2,\n VEC3: 3,\n VEC4: 4,\n MAT2: 4,\n MAT3: 9,\n MAT4: 16\n};\n\nconst BYTES = {\n 5120: 1, // BYTE\n 5121: 1, // UNSIGNED_BYTE\n 5122: 2, // SHORT\n 5123: 2, // UNSIGNED_SHORT\n 5125: 4, // UNSIGNED_INT\n 5126: 4 // FLOAT\n};\n\n// ENUM LOOKUP\n\nexport function getBytesFromComponentType(componentType) {\n return BYTES[componentType];\n}\n\nexport function getSizeFromAccessorType(type) {\n return COMPONENTS[type];\n}\n\nexport function getGLEnumFromSamplerParameter(parameter) {\n const GL_TEXTURE_MAG_FILTER = 0x2800;\n const GL_TEXTURE_MIN_FILTER = 0x2801;\n const GL_TEXTURE_WRAP_S = 0x2802;\n const GL_TEXTURE_WRAP_T = 0x2803;\n\n const PARAMETER_MAP = {\n magFilter: GL_TEXTURE_MAG_FILTER,\n minFilter: GL_TEXTURE_MIN_FILTER,\n wrapS: GL_TEXTURE_WRAP_S,\n wrapT: GL_TEXTURE_WRAP_T\n };\n\n return PARAMETER_MAP[parameter];\n}\n","// GLTF EXTENSION: KHR_materials_unlit\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit\n\nimport type {GLTF} from '../types/gltf-types';\n\nimport GLTFScenegraph from '../api/gltf-scenegraph';\nimport {KHR_MATERIALS_UNLIT} from '../gltf-utils/gltf-constants';\n\nexport async function decode(gltfData: {json: GLTF}): Promise<void> {\n const gltfScenegraph = new GLTFScenegraph(gltfData);\n const {json} = gltfScenegraph;\n\n // Remove the top-level extension\n gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);\n\n // Any nodes that have the extension, add lights field pointing to light object\n // and remove the extension\n for (const material of json.materials || []) {\n const extension = material.extensions && material.extensions.KHR_materials_unlit;\n if (extension) {\n // @ts-ignore TODO\n material.unlit = true;\n }\n gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);\n }\n}\n\nexport function encode(gltfData) {\n const gltfScenegraph = new GLTFScenegraph(gltfData);\n const {json} = gltfScenegraph;\n\n // Any nodes that have lights field pointing to light object\n // add the extension\n // @ts-ignore\n if (gltfScenegraph.materials) {\n for (const material of json.materials || []) {\n // @ts-ignore\n if (material.unlit) {\n // @ts-ignore\n delete material.unlit;\n gltfScenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});\n gltfScenegraph.addExtension(KHR_MATERIALS_UNLIT);\n }\n }\n }\n}\n","// GLTF EXTENSION: KHR_lights_punctual\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual\n\nimport type {GLTF} from '../types/gltf-types';\n\nimport {assert} from '../utils/assert';\nimport GLTFScenegraph from '../api/gltf-scenegraph';\nimport {KHR_LIGHTS_PUNCTUAL} from '../gltf-utils/gltf-constants';\n\nexport async function decode(gltfData: {json: GLTF}): Promise<void> {\n const gltfScenegraph = new GLTFScenegraph(gltfData);\n const {json} = gltfScenegraph;\n\n // Move the light array out of the extension and remove the extension\n const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);\n if (extension) {\n // @ts-ignore\n gltfScenegraph.json.lights = extension.lights;\n gltfScenegraph.removeExtension(KHR_LIGHTS_PUNCTUAL);\n }\n\n // Any nodes that have the extension, add lights field pointing to light object\n // and remove the extension\n for (const node of json.nodes || []) {\n const nodeExtension = gltfScenegraph.getObjectExtension(node, KHR_LIGHTS_PUNCTUAL);\n if (nodeExtension) {\n // @ts-ignore\n node.light = nodeExtension.light;\n }\n gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);\n }\n}\n\n// Move the light ar ray out of the extension and remove the extension\nexport async function encode(gltfData): Promise<void> {\n const gltfScenegraph = new GLTFScenegraph(gltfData);\n const {json} = gltfScenegraph;\n\n // @ts-ignore\n if (json.lights) {\n const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);\n // @ts-ignore\n assert(!extension.lights);\n // @ts-ignore\n extension.lights = json.lights;\n // @ts-ignore\n delete json.lights;\n }\n\n // Any nodes that have lights field pointing to light object\n // add the extension\n // @ts-ignore\n if (gltfScenegraph.json.lights) {\n // @ts-ignore\n for (const light of gltfScenegraph.json.lights) {\n const node = light.node;\n gltfScenegraph.addObjectExtension(node, KHR_LIGHTS_PUNCTUAL, light);\n }\n // @ts-ignore\n delete gltfScenegraph.json.lights;\n }\n}\n","// GLTF EXTENSION: KHR_techniques_webgl\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl\n\nimport type {GLTF} from '../types/gltf-types';\n\nimport GLTFScenegraph from '../api/gltf-scenegraph';\nimport {KHR_TECHNIQUES_WEBGL} from '../gltf-utils/gltf-constants';\n\nexport async function decode(gltfData: {json: GLTF}): Promise<void> {\n const gltfScenegraph = new GLTFScenegraph(gltfData);\n const {json} = gltfScenegraph;\n\n const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);\n if (extension) {\n const techniques = resolveTechniques(extension, gltfScenegraph);\n\n for (const material of json.materials || []) {\n const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);\n if (materialExtension) {\n // @ts-ignore TODO\n material.technique = Object.assign(\n {},\n materialExtension,\n // @ts-ignore\n techniques[materialExtension.technique]\n );\n // @ts-ignore TODO\n material.technique.values = resolveValues(material.technique, gltfScenegraph);\n }\n gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);\n }\n\n gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);\n }\n}\n// eslint-disable-next-line\nexport async function encode(gltfData, options): Promise<void> {\n // TODO\n}\n\nfunction resolveTechniques(\n techniquesExtension: {[key: string]: any},\n // programs: {[key: string]: any}[],\n // shaders: {[key: string]: any}[],\n // techniques: {[key: string]: any}[]\n gltfScenegraph\n) {\n const {programs = [], shaders = [], techniques = []} = techniquesExtension;\n const textDecoder = new TextDecoder();\n\n shaders.forEach((shader) => {\n if (Number.isFinite(shader.bufferView)) {\n shader.code = textDecoder.decode(\n gltfScenegraph.getTypedArrayForBufferView(shader.bufferView)\n );\n } else {\n // TODO: handle URI shader\n throw new Error('KHR_techniques_webgl: no shader code');\n }\n });\n\n programs.forEach((program) => {\n program.fragmentShader = shaders[program.fragmentShader];\n program.vertexShader = shaders[program.vertexShader];\n });\n\n techniques.forEach((technique) => {\n technique.program = programs[technique.program];\n });\n\n return techniques;\n}\n\nfunction resolveValues(technique, gltfScenegraph) {\n const values = Object.assign({}, technique.values);\n\n // merge values from uniforms\n Object.keys(technique.uniforms || {}).forEach((uniform) => {\n if (technique.uniforms[uniform].value && !(uniform in values)) {\n values[uniform] = technique.uniforms[uniform].value;\n }\n });\n\n // resolve textures\n Object.keys(values).forEach((uniform) => {\n if (typeof values[uniform] === 'object' && values[uniform].index !== undefined) {\n // Assume this is a texture\n // TODO: find if there are any other types that can be referenced\n values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);\n }\n });\n\n return values;\n}\n","/* eslint-disable camelcase */\nimport {GLTF} from '../types/gltf-types';\nimport type {GLTFLoaderOptions} from '../../gltf-loader';\n\n// GLTF 1.0 extensions (read only)\n// import * as KHR_binary_gltf from './KHR_draco_mesh_compression';\n\n// GLTF 2.0 extensions (read/write)\nimport * as KHR_draco_mesh_compression from './KHR_draco_mesh_compression';\nimport * as KHR_materials_unlit from './KHR_materials_unlit';\nimport * as KHR_lights_punctual from './KHR_lights_punctual';\nimport * as KHR_techniques_webgl from './KHR_techniques_webgl';\n\ntype GLTFExtensionPlugin = {\n decode: (gltfData: {json: GLTF}, options: GLTFLoaderOptions, context) => Promise<void>;\n\n encode: (gltfData: {json: GLTF}, options: GLTFLoaderOptions) => void;\n};\n\n/**\n * List of extensions processed by the GLTFLoader\n * Note that may extensions can only be handled on the rendering stage and are left out here\n * These are just extensions that can be handled fully or partially during loading.\n */\nexport const EXTENSIONS: {[extensionName: string]: GLTFExtensionPlugin} = {\n // 1.0\n // KHR_binary_gltf is handled separately - must be processed before other parsing starts\n // KHR_binary_gltf,\n\n // 2.0\n KHR_draco_mesh_compression,\n KHR_materials_unlit,\n KHR_lights_punctual,\n KHR_techniques_webgl\n};\n\nexport async function decodeExtensions(gltf, options: GLTFLoaderOptions = {}, context?) {\n for (const extensionName in EXTENSIONS) {\n const excludes = options?.gltf?.excludeExtensions || {};\n const exclude = extensionName in excludes && !excludes[extensionName];\n if (!exclude) {\n const extension = EXTENSIONS[extensionName];\n // Note: We decode async extensions sequentially, this might not be necessary\n // Currently we only have Draco, but when we add Basis we may revisit\n await extension.decode(gltf, options, context);\n }\n }\n}\n","/* eslint-disable camelcase */\nimport * as KHR_binary_glTF from '../extensions/KHR_binary_gltf';\n\n// Binary format changes (mainly implemented by GLBLoader)\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/1.0/Khronos/KHR_binary_glTF\n\n// JSON format changes:\n// https://github.com/khronosgroup/gltf/issues/605\n\n// - [x] Top-level JSON objects are arrays now\n// - [ ] Removed indirection from animation: sampler now refers directly to accessors, #712\n// - [ ] material.parameter.value and technique.parameter.value must be an array, #690\n// - [ ] Node can have only one mesh #821\n// - [ ] Added reqs on JSON encoding\n// - [ ] Added reqs on binary data alignment #802 (comment)\n\n// Additions:\n// - [ ] Added accessor.normalized, #691, #706\n// - [ ] Added glExtensionsUsed property and 5125 (UNSIGNED_INT) accessor.componentType value, #619\n// - [ ] Added extensionsRequired property, #720, #721\n// - [ ] Added \"STEP\" as valid animation.sampler.interpolation value, #712\n\n// Removals:\n// - [x] Removed buffer.type, #786, #629\n// - [ ] Removed revision number from profile.version, #709\n// - [ ] Removed technique.functions.scissor and removed 3089 (SCISSOR_TEST) as a valid value for technique.states.enable, #681\n// - [ ] Techniques, programs, and shaders were moved out to KHR_technique_webgl extension.\n\n// Other edits:\n// - [x] asset is now required, #642\n// - [ ] buffer.byteLength and bufferView.byteLength are now required, #560.\n// - [ ] accessor.min and accessor.max are now required, #593, and clarified that the JSON value and binary data must be the same, #628.\n// - [ ] Clarified animation.sampler and animation.channel restrictions, #712\n// - [ ] skin.inverseBindMatrices is now optional, #461.\n// - [ ] Attribute parameters can't have a value defined in the technique or parameter, #563 (comment).\n// - [ ] Only TEXCOORD and COLOR attribute semantics can be written in the form [semantic]_[set_index], #563 (comment).\n// - [ ] TEXCOORD and COLOR attribute semantics must be written in the form [semantic]_[set_index], e.g., just TEXCOORD should be TEXCOORD_0, and just COLOR should be COLOR_0, #649\n// - [ ] camera.perspective.aspectRatio and camera.perspective.yfov must now be > 0, not >= 0, #563 (comment).\n// - [ ] Application-specific parameter semantics must start with an underscore, e.g., _TEMPERATURE and _SIMULATION_TIME, #563 (comment).\n// - [ ] Properties in technique.parameters must be defined in technique.uniforms or technique.attributes,\n\n// #563 (comment).\n// - [ ] technique.parameter.count can only be defined when the semantic is JOINTMATRIX or an application-specific semantic is used. It can never be defined for attribute parameters; only uniforms, d2f6945\n// - [ ] technique.parameter.semantic is required when the parameter is an attribute, 28e113d\n// - [ ] Mesh-only models are allowed, e.g., without materials, #642\n// - [ ] Skeleton hierarchies (nodes containing jointName) must be separated from non-skeleton hierarchies., #647\n// - [ ] technique.states.functions.blendColor and technique.states.functions.depthRange parameters now must match WebGL function min/max, #707\n\nconst GLTF_ARRAYS = {\n accessors: 'accessor',\n animations: 'animation',\n buffers: 'buffer',\n bufferViews: 'bufferView',\n images: 'image',\n materials: 'material',\n meshes: 'mesh',\n nodes: 'node',\n samplers: 'sampler',\n scenes: 'scene',\n skins: 'skin',\n textures: 'texture'\n};\n\nconst GLTF_KEYS = {\n accessor: 'accessors',\n animations: 'animation',\n buffer: 'buffers',\n bufferView: 'bufferViews',\n image: 'images',\n material: 'materials',\n mesh: 'meshes',\n node: 'nodes',\n sampler: 'samplers',\n scene: 'scenes',\n skin: 'skins',\n texture: 'textures'\n};\n\n/**\n * Converts (normalizes) glTF v1 to v2\n */\nclass GLTFV1Normalizer {\n constructor(gltf) {\n this.idToIndexMap = {\n animations: {},\n accessors: {},\n buffers: {},\n bufferViews: {},\n images: {},\n materials: {},\n meshes: {},\n nodes: {},\n samplers: {},\n scenes: {},\n skins: {},\n textures: {}\n };\n }\n\n /**\n * Convert (normalize) glTF < 2.0 to glTF 2.0\n * @param gltf - object with json and binChunks\n * @param options\n * @param options normalize Whether to actually normalize\n */\n normalize(gltf, options) {\n this.json = gltf.json;\n const json = gltf.json;\n\n // Check version\n switch (json.asset && json.asset.version) {\n // We are converting to v2 format. Return if there is nothing to do\n case '2.0':\n return;\n\n // This class is written to convert 1.0\n case undefined:\n case '1.0':\n break;\n\n default:\n // eslint-disable-next-line no-undef, no-console\n console.warn(`glTF: Unknown version ${json.asset.version}`);\n return;\n }\n\n if (!options.normalize) {\n // We are still missing a few conversion tricks, remove once addressed\n throw new Error('glTF v1 is not supported.');\n }\n\n // eslint-disable-next-line no-undef, no-console\n console.warn('Converting glTF v1 to glTF v2 format. This is experimental and may fail.');\n\n this._addAsset(json);\n\n // In glTF2 top-level fields are Arrays not Object maps\n this._convertTopLevelObjectsToArrays(json);\n\n // Extract bufferView indices for images\n // (this extension needs to be invoked early in the normalization process)\n KHR_binary_glTF.decode(gltf);\n\n // Convert object references from ids to indices\n this._convertObjectIdsToArrayIndices(json);\n\n this._updateObjects(json);\n\n this._updateMaterial(json);\n }\n\n // asset is now required, #642 https://github.com/KhronosGroup/glTF/issues/639\n _addAsset(json) {\n json.asset = json.asset || {};\n // We are normalizing to glTF v2, so change version to \"2.0\"\n json.asset.version = '2.0';\n json.asset.generator = json.asset.generator || 'Normalized to glTF 2.0 by loaders.gl';\n }\n\n _convertTopLevelObjectsToArrays(json) {\n // TODO check that all arrays are covered\n for (const arrayName in GLTF_ARRAYS) {\n this._convertTopLevelObjectToArray(json, arrayName);\n }\n }\n\n /** Convert one top level object to array */\n _convertTopLevelObjectToArray(json, mapName) {\n const objectMap = json[mapName];\n if (!objectMap || Array.isArray(objectMap)) {\n return;\n }\n\n // Rewrite the top-level field as an array\n json[mapName] = [];\n // Copy the map key into object.id\n for (const id in objectMap) {\n const object = objectMap[id];\n object.id = object.id || id; // Mutates the loaded object\n const index = json[mapName].length;\n json[mapName].push(object);\n this.idToIndexMap[mapName][id] = index;\n }\n }\n\n /** Go through all objects in all top-level arrays and replace ids with indices */\n _convertObjectIdsToArrayIndices(json) {\n for (const arrayName in GLTF_ARRAYS) {\n this._convertIdsToIndices(json, arrayName);\n }\n if ('scene' in json) {\n json.scene = this._convertIdToIndex(json.scene, 'scene');\n }\n\n // Convert any index references that are not using array names\n\n // texture.source (image)\n for (const texture of json.textures) {\n this._convertTextureIds(texture);\n }\n for (const mesh of json.meshes) {\n this._convertMeshIds(mesh);\n }\n for (const node of json.nodes) {\n this._convertNodeIds(node);\n }\n for (const node of json.scenes) {\n this._convertSceneIds(node);\n }\n }\n\n _convertTextureIds(texture) {\n if (texture.source) {\n texture.source = this._convertIdToIndex(texture.source, 'image');\n }\n }\n\n _convertMeshIds(mesh) {\n for (const primitive of mesh.primitives) {\n const {attributes, indices, material} = primitive;\n for (const attributeName in attributes) {\n attributes[attributeName] = this._convertIdToIndex(attributes[attributeName], 'accessor');\n }\n if (indices) {\n primitive.indices = this._convertIdToIndex(indices, 'accessor');\n }\n if (material) {\n primitive.material = this._convertIdToIndex(material, 'material');\n }\n }\n }\n\n _convertNodeIds(node) {\n if (node.children) {\n node.children = node.children.map((child) => this._convertIdToIndex(child, 'node'));\n }\n if (node.meshes) {\n node.meshes = node.meshes.map((mesh) => this._convertIdToIndex(mesh, 'mesh'));\n }\n }\n\n _convertSceneIds(scene) {\n if (scene.nodes) {\n scene.nodes = scene.nodes.map((node) => this._convertIdToIndex(node, 'node'));\n }\n }\n\n /** Go through all objects in a top-level array and replace ids with indices */\n _convertIdsToIndices(json, topLevelArrayName) {\n if (!json[topLevelArrayName]) {\n console.warn(`gltf v1: json doesn't contain attribute ${topLevelArrayName}`); // eslint-disable-line no-console, no-undef\n json[topLevelArrayName] = [];\n }\n for (const object of json[topLevelArrayName]) {\n for (const key in object) {\n const id = object[key];\n const index = this._convertIdToIndex(id, key);\n object[key] = index;\n }\n }\n }\n\n _convertIdToIndex(id, key) {\n const arrayName = GLTF_KEYS[key];\n if (arrayName in this.idToIndexMap) {\n const index = this.idToIndexMap[arrayName][id];\n if (!Number.isFinite(index)) {\n throw new Error(`gltf v1: failed to resolve ${key} with id ${id}`);\n }\n return index;\n }\n return id;\n }\n\n /**\n *\n * @param {*} json\n */\n _updateObjects(json) {\n for (const buffer of this.json.buffers) {\n // - [x] Removed buffer.type, #786, #629\n delete buffer.type;\n }\n }\n\n /**\n * Update material (set pbrMetallicRoughness)\n * @param {*} json\n */\n _updateMaterial(json) {\n for (const material of json.materials) {\n material.pbrMetallicRoughness = {\n baseColorFactor: [1, 1, 1, 1],\n metallicFactor: 1,\n roughnessFactor: 1\n };\n\n const textureId = material.values && material.values.tex;\n const textureIndex = json.textures.findIndex((texture) => texture.id === textureId);\n if (textureIndex !== -1) {\n material.pbrMetallicRoughness.baseColorTexture = {index: textureIndex};\n }\n }\n }\n}\n\nexport function normalizeGLTFV1(gltf, options = {}) {\n return new GLTFV1Normalizer().normalize(gltf, options);\n}\n","// GLTF 1.0 EXTENSION: KHR_binary_glTF\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/1.0/Khronos/KHR_binary_glTF\n\nimport type {GLTF} from '../types/gltf-types';\n\nimport GLTFScenegraph from '../api/gltf-scenegraph';\nimport {KHR_BINARY_GLTF} from '../gltf-utils/gltf-constants';\n\nexport function decode(gltfData: {json: GLTF}): void {\n const gltfScenegraph = new GLTFScenegraph(gltfData);\n const {json} = gltfScenegraph;\n\n // Note: json.buffers.binary_glTF also needs to be replaced\n // This is currently done during gltf normalization\n\n // Image and shader nodes can have the extension\n // https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_binary_glTF/schema/image.KHR_binary_glTF.schema.json\n for (const node of json.images || []) {\n const extension = gltfScenegraph.removeObjectExtension(node, KHR_BINARY_GLTF);\n // The data in the extension is valid as glTF 2.0 data inside the object, so just copy it in\n if (extension) {\n Object.assign(node, extension);\n }\n }\n\n // TODO shaders\n // https://github.com/KhronosGroup/glTF/blob/master/extensions/1.0/Khronos/KHR_binary_glTF/schema/shader.KHR_binary_glTF.schema.json\n\n // glTF v1 one files have a partially formed URI field that is not expected in (and causes problems in) 2.0\n if (json.buffers && json.buffers[0]) {\n delete json.buffers[0].uri;\n }\n\n // Remove the top-level extension as it has now been removed from all nodes\n gltfScenegraph.removeExtension(KHR_BINARY_GLTF);\n}\n\n// KHR_binary_gltf is a 1.0 extension that is supported natively by 2.0\nexport function encode() {\n throw new Error(KHR_BINARY_GLTF);\n}\n","import {assert} from '../utils/assert';\nimport {getAccessorArrayTypeAndLength} from '../gltf-utils/gltf-utils';\n\n// This is a post processor for loaded glTF files\n// The goal is to make the loaded data easier to use in WebGL applications\n//\n// Functions:\n// * Resolve indexed arrays structure of glTF into a linked tree.\n// * Translate stringified enum keys and values into WebGL constants.\n// * Load images (optional)\n\n// ENUM LOOKUP\n\nconst COMPONENTS = {\n SCALAR: 1,\n VEC2: 2,\n VEC3: 3,\n VEC4: 4,\n MAT2: 4,\n MAT3: 9,\n MAT4: 16\n};\n\nconst BYTES = {\n 5120: 1, // BYTE\n 5121: 1, // UNSIGNED_BYTE\n 5122: 2, // SHORT\n 5123: 2, // UNSIGNED_SHORT\n 5125: 4, // UNSIGNED_INT\n 5126: 4 // FLOAT\n};\n\nconst GL_SAMPLER = {\n // Sampler parameters\n TEXTURE_MAG_FILTER: 0x2800,\n TEXTURE_MIN_FILTER: 0x2801,\n TEXTURE_WRAP_S: 0x2802,\n TEXTURE_WRAP_T: 0x2803,\n\n // Sampler default values\n REPEAT: 0x2901,\n LINEAR: 0x2601,\n NEAREST_MIPMAP_LINEAR: 0x2702\n};\n\nconst SAMPLER_PARAMETER_GLTF_TO_GL = {\n magFilter: GL_SAMPLER.TEXTURE_MAG_FILTER,\n minFilter: GL_SAMPLER.TEXTURE_MIN_FILTER,\n wrapS: GL_SAMPLER.TEXTURE_WRAP_S,\n wrapT: GL_SAMPLER.TEXTURE_WRAP_T\n};\n\n// When undefined, a sampler with repeat wrapping and auto filtering should be used.\n// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texture\nconst DEFAULT_SAMPLER = {\n [GL_SAMPLER.TEXTURE_MAG_FILTER]: GL_SAMPLER.LINEAR,\n [GL_SAMPLER.TEXTURE_MIN_FILTER]: GL_SAMPLER.NEAREST_MIPMAP_LINEAR,\n [GL_SAMPLER.TEXTURE_WRAP_S]: GL_SAMPLER.REPEAT,\n [GL_SAMPLER.TEXTURE_WRAP_]: GL_SAMPLER.REPEAT\n};\n\nfunction getBytesFromComponentType(componentType) {\n return BYTES[componentType];\n}\n\nfunction getSizeFromAccessorType(type) {\n return COMPONENTS[type];\n}\n\nclass GLTFPostProcessor {\n postProcess(gltf, options = {}) {\n const {json, buffers = [], images = [], baseUri = ''} = gltf;\n assert(json);\n\n this.baseUri = baseUri;\n this.json = json;\n this.buffers = buffers;\n this.images = images;\n\n this._resolveTree(this.json, options);\n\n return this.json;\n }\n\n // Convert indexed glTF structure into tree structure\n // cross-link index resolution, enum lookup, convenience calculations\n // eslint-disable-next-line complexity\n _resolveTree(json, options = {}) {\n if (json.bufferViews) {\n json.bufferViews = json.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));\n }\n if (json.images) {\n json.images = json.images.map((image, i) => this._resolveImage(image, i));\n }\n if (json.samplers) {\n json.samplers = json.samplers.map((sampler, i) => this._resolveSampler(sampler, i));\n }\n if (json.textures) {\n json.textures = json.textures.map((texture, i) => this._resolveTexture(texture, i));\n }\n if (json.accessors) {\n json.accessors = json.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));\n }\n if (json.materials) {\n json.materials = json.materials.map((material, i) => this._resolveMaterial(material, i));\n }\n if (json.meshes) {\n json.meshes = json.meshes.map((mesh, i) => this._resolveMesh(mesh, i));\n }\n if (json.nodes) {\n json.nodes = json.nodes.map((node, i) => this._resolveNode(node, i));\n }\n if (json.skins) {\n json.skins = json.skins.map((skin, i) => this._resolveSkin(skin, i));\n }\n if (json.scenes) {\n json.scenes = json.scenes.map((scene, i) => this._resolveScene(scene, i));\n }\n if (json.scene !== undefined) {\n json.scene = json.scenes[this.json.scene];\n }\n }\n\n getScene(index) {\n return this._get('scenes', index);\n }\n\n getNode(index) {\n return this._get('nodes', index);\n }\n\n getSkin(index) {\n return this._get('skins', index);\n }\n\n getMesh(index) {\n return this._get('meshes', index);\n }\n\n getMaterial(index) {\n return this._get('materials', index);\n }\n\n getAccessor(index) {\n return this._get('accessors', index);\n }\n\n getCamera(index) {\n return null; // TODO: fix this\n }\n\n getTexture(index) {\n return this._get('textures', index);\n }\n\n getSampler(index) {\n return this._get('samplers', index);\n }\n\n getImage(index) {\n return this._get('images', index);\n }\n\n getBufferView(index) {\n return this._get('bufferViews', index);\n }\n\n getBuffer(index) {\n return this._get('buffers', index);\n }\n\n _get(array, index) {\n // check if already resolved\n if (typeof index === 'object') {\n return index;\n }\n const object = this.json[array] && this.json[array][index];\n if (!object) {\n console.warn(`glTF file error: Could not find ${array}[${index}]`); // eslint-disable-line\n }\n return object;\n }\n\n // PARSING HELPERS\n\n _resolveScene(scene, index) {\n // scene = {...scene};\n scene.id = scene.id || `scene-${index}`;\n scene.nodes = (scene.nodes || []).map((node) => this.getNode(node));\n return scene;\n }\n\n _resolveNode(node, index) {\n // node = {...node};\n node.id = node.id || `node-${index}`;\n if (node.children) {\n node.children = node.children.map((child) => this.getNode(child));\n }\n if (node.mesh !== undefined) {\n node.mesh = this.getMesh(node.mesh);\n } else if (node.meshes !== undefined && node.meshes.length) {\n node.mesh = node.meshes.reduce(\n (accum, meshIndex) => {\n const mesh = this.getMesh(meshIndex);\n accum.id = mesh.id;\n accum.primitives = accum.primitives.concat(mesh.primitives);\n return accum;\n },\n {primitives: []}\n );\n }\n if (node.camera !== undefined) {\n node.camera = this.getCamera(node.camera);\n }\n if (node.skin !== undefined) {\n node.skin = this.getSkin(node.skin);\n }\n return node;\n }\n\n _resolveSkin(skin, index) {\n // skin = {...skin};\n skin.id = skin.id || `skin-${index}`;\n skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);\n return skin;\n }\n\n _resolveMesh(mesh, index) {\n // mesh = {...mesh};\n mesh.id = mesh.id || `mesh-${index}`;\n if (mesh.primitives) {\n mesh.primitives = mesh.primitives.map((primitive) => {\n primitive = {...primitive};\n const attributes = primitive.attributes;\n primitive.attributes = {};\n for (const attribute in attributes) {\n primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);\n }\n if (primitive.indices !== undefined) {\n primitive.indices = this.getAccessor(primitive.indices);\n }\n if (primitive.material !== undefined) {\n primitive.material = this.getMaterial(primitive.material);\n }\n return primitive;\n });\n }\n return mesh;\n }\n\n _resolveMaterial(material, index) {\n // material = {...material};\n material.id = material.id || `material-${index}`;\n if (material.normalTexture) {\n material.normalTexture = {...material.normalTexture};\n material.normalTexture.texture = this.getTexture(material.normalTexture.index);\n }\n if (material.occlusionTexture) {\n material.occlustionTexture = {...material.occlustionTexture};\n material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);\n }\n if (material.emissiveTexture) {\n material.emmisiveTexture = {...material.emmisiveTexture};\n material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);\n }\n if (!material.emissiveFactor) {\n material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];\n }\n\n if (material.pbrMetallicRoughness) {\n material.pbrMetallicRoughness = {...material.pbrMetallicRoughness};\n const mr = material.pbrMetallicRoughness;\n if (mr.baseColorTexture) {\n mr.baseColorTexture = {...mr.baseColorTexture};\n mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);\n }\n if (mr.metallicRoughnessTexture) {\n mr.metallicRoughnessTexture = {...mr.metallicRoughnessTexture};\n mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);\n }\n }\n return material;\n }\n\n _resolveAccessor(accessor, index) {\n // accessor = {...accessor};\n accessor.id = accessor.id || `accessor-${index}`;\n if (accessor.bufferView !== undefined) {\n // Draco encoded meshes don't have bufferView\n accessor.bufferView = this.getBufferView(accessor.bufferView);\n }\n\n // Look up enums\n accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);\n accessor.components = getSizeFromAccessorType(accessor.type);\n accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;\n\n // Create TypedArray for the accessor\n // Note: The canonical way to instantiate is to ignore this array and create\n // WebGLBuffer's using the bufferViews.\n if (accessor.bufferView) {\n const buffer = accessor.bufferView.buffer;\n const {ArrayType, byteLength} = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);\n const byteOffset =\n (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;\n const cutBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);\n accessor.value = new ArrayType(cutBufffer);\n }\n\n return accessor;\n }\n\n _resolveTexture(texture, index) {\n // texture = {...texture};\n texture.id = texture.id || `texture-${index}`;\n texture.sampler = 'sampler' in texture ? this.getSampler(texture.sampler) : DEFAULT_SAMPLER;\n texture.source = this.getImage(texture.source);\n return texture;\n }\n\n _resolveSampler(sampler, index) {\n // sampler = {...sampler};\n sampler.id = sampler.id || `sampler-${index}`;\n // Map textual parameters to GL parameter values\n sampler.parameters = {};\n for (const key in sampler) {\n const glEnum = this._enumSamplerParameter(key);\n if (glEnum !== undefined) {\n sampler.parameters[glEnum] = sampler[key];\n }\n }\n return sampler;\n }\n\n _enumSamplerParameter(key) {\n return SAMPLER_PARAMETER_GLTF_TO_GL[key];\n }\n\n _resolveImage(image, index) {\n // image = {...image};\n image.id = image.id || `image-${index}`;\n if (image.bufferView !== undefined) {\n image.bufferView = this.getBufferView(image.bufferView);\n }\n\n // Check if image has been preloaded by the GLTFLoader\n // If so, link it into the JSON and drop the URI\n const preloadedImage = this.images[index];\n if (preloadedImage) {\n image.image = preloadedImage;\n }\n\n return image;\n }\n\n _resolveBufferView(bufferView, index) {\n // bufferView = {...bufferView};\n bufferView.id = bufferView.id || `bufferView-${index}`;\n const bufferIndex = bufferView.buffer;\n bufferView.buffer = this.buffers[bufferIndex];\n\n const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;\n let byteOffset = this.buffers[bufferIndex].byteOffset || 0;\n\n if ('byteOffset' in bufferView) {\n byteOffset += bufferView.byteOffset;\n }\n\n bufferView.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);\n return bufferView;\n }\n\n _resolveCamera(camera, index) {\n camera.id = camera.id || `camera-${index}`;\n // TODO - create 4x4 matrices\n if (camera.perspective) {\n // camera.matrix = createPerspectiveMatrix(camera.perspective);\n }\n if (camera.orthographic) {\n // camera.matrix = createOrthographicMatrix(camera.orthographic);\n }\n return camera;\n }\n}\n\nexport function postProcessGLTF(gltf, options) {\n return new GLTFPostProcessor().postProcess(gltf, options);\n}\n","/* eslint-disable camelcase, max-statements */\n// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#glb-file-format-specification\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/1.0/Khronos/KHR_binary_glTF\nimport type {GLB} from '../types/glb-types';\nimport {padToNBytes, assert} from '@loaders.gl/loader-utils';\n\nexport type GLBParseOptions = {\n magic?: number;\n strict?: boolean;\n};\n\nconst MAGIC_glTF = 0x676c5446; // glTF in Big-Endian ASCII\n\nconst GLB_FILE_HEADER_SIZE = 12;\nconst GLB_CHUNK_HEADER_SIZE = 8;\n\nconst GLB_CHUNK_TYPE_JSON = 0x4e4f534a;\nconst GLB_CHUNK_TYPE_BIN = 0x004e4942;\nconst GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0; // DEPRECATED - Backward compatibility for old xviz files\nconst GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1; // DEPRECATED - Backward compatibility for old xviz files\n\nconst GLB_V1_CONTENT_FORMAT_JSON = 0x0;\n\nconst LE = true; // Binary GLTF is little endian.\n\nfunction getMagicString(dataView, byteOffset = 0) {\n return `\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;\n}\n\n// Check if a data view is a GLB\nexport function isGLB(\n arrayBuffer: ArrayBuffer,\n byteOffset: number = 0,\n options: GLBParseOptions = {}\n): boolean {\n const dataView = new DataView(arrayBuffer);\n // Check that GLB Header starts with the magic number\n const {magic = MAGIC_glTF} = options;\n const magic1 = dataView.getUint32(byteOffset, false);\n return magic1 === magic || magic1 === MAGIC_glTF;\n}\n\nexport default function parseGLBSync(\n glb: GLB,\n arrayBuffer: ArrayBuffer,\n byteOffset: number = 0,\n options: GLBParseOptions = {}\n) {\n // Check that GLB Header starts with the magic number\n const dataView = new DataView(arrayBuffer);\n\n // Compare format with GLBLoader documentation\n const type = getMagicString(dataView, byteOffset + 0);\n const version = dataView.getUint32(byteOffset + 4, LE); // Version 2 of binary glTF container format\n const byteLength = dataView.getUint32(byteOffset + 8, LE); // Total byte length of binary file\n\n Object.assign(glb, {\n // Put less important stuff in a header, to avoid clutter\n header: {\n byteOffset, // Byte offset into the initial arrayBuffer\n byteLength,\n hasBinChunk: false\n },\n\n type,\n version,\n\n json: {},\n binChunks: []\n } as GLB);\n\n byteOffset += GLB_FILE_HEADER_SIZE;\n\n switch (glb.version) {\n case 1:\n // eslint-disable-next-line\n return parseGLBV1(glb, dataView, byteOffset);\n case 2:\n // eslint-disable-next-line\n return parseGLBV2(glb, dataView, byteOffset, (options = {}));\n default:\n throw new Error(`Invalid GLB version ${glb.version}. Only supports v1 and v2.`);\n }\n}\n\nfunction parseGLBV1(glb: GLB, dataView: DataView, byteOffset: number): number {\n // Sanity: ensure file is big enough to hold at least the headers\n assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n // Explanation of GLB structure:\n // https://cloud.githubusercontent.com/assets/3479527/22600725/36b87122-ea55-11e6-9d40-6fd42819fcab.png\n const contentLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk\n const contentFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32\n byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n // GLB v1 only supports a single chunk type\n assert(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);\n\n parseJSONChunk(glb, dataView, byteOffset, contentLength);\n // No need to call the function padToBytes() from parseJSONChunk()\n byteOffset += contentLength;\n byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);\n\n return byteOffset;\n}\n\nfunction parseGLBV2(\n glb: GLB,\n dataView: DataView,\n byteOffset: number,\n options: GLBParseOptions\n): number {\n // Sanity: ensure file is big enough to hold at least the first chunk header\n assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n parseGLBChunksSync(glb, dataView, byteOffset, options);\n\n return byteOffset + glb.header.byteLength;\n}\n\nfunction parseGLBChunksSync(\n glb: GLB,\n dataView: DataView,\n byteOffset: number,\n options: GLBParseOptions\n) {\n // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n // Iterate as long as there is space left for another chunk header\n while (byteOffset + 8 <= glb.header.byteLength) {\n const chunkLength = dataView.getUint32(byteOffset + 0, LE); // Byte length of chunk\n const chunkFormat = dataView.getUint32(byteOffset + 4, LE); // Chunk format as uint32\n byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n switch (chunkFormat) {\n case GLB_CHUNK_TYPE_JSON:\n parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n break;\n case GLB_CHUNK_TYPE_BIN:\n parseBINChunk(glb, dataView, byteOffset, chunkLength);\n break;\n\n // Backward compatibility for very old xviz files\n case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:\n if (!options.strict) {\n parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n }\n break;\n case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:\n if (!options.strict) {\n parseBINChunk(glb, dataView, byteOffset, chunkLength);\n }\n break;\n\n default:\n // Ignore, per spec\n // console.warn(`Unknown GLB chunk type`); // eslint-disable-line\n break;\n }\n\n byteOffset += padToNBytes(chunkLength, 4);\n }\n\n return byteOffset;\n}\n\n// Parse a GLB JSON chunk\nfunction parseJSONChunk(glb: GLB, dataView: DataView, byteOffset: number, chunkLength: number) {\n // 1. Create a \"view\" of the binary encoded JSON data inside the GLB\n const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);\n\n // 2. Decode the JSON binary array into clear text\n const textDecoder = new TextDecoder('utf8');\n const jsonText = textDecoder.decode(jsonChunk);\n\n // 3. Parse the JSON text into a JavaScript data structure\n glb.json = JSON.parse(jsonText);\n\n return padToNBytes(chunkLength, 4);\n}\n\n// Parse a GLB BIN chunk\nfunction parseBINChunk(glb: GLB, dataView, byteOffset, chunkLength) {\n // Note: BIN chunk can be optional\n glb.header.hasBinChunk = true;\n glb.binChunks.push({\n byteOffset,\n byteLength: chunkLength,\n arrayBuffer: dataView.buffer\n // TODO - copy, or create typed array view?\n });\n\n return padToNBytes(chunkLength, 4);\n}\n","/* eslint-disable camelcase, max-statements, no-restricted-globals */\nimport type {LoaderContext} from '@loaders.gl/loader-utils';\nimport type {GLB} from '../types/glb-types';\nimport type {GLBParseOptions} from './parse-glb';\n\nimport {ImageLoader} from '@loaders.gl/images';\nimport {parseJSON, sliceArrayBuffer} from '@loaders.gl/loader-utils';\nimport {assert} from '../utils/assert';\nimport {resolveUrl} from '../gltf-utils/resolve-url';\nimport {getTypedArrayForBufferView} from '../gltf-utils/get-typed-array';\nimport {decodeExtensions} from '../extensions/gltf-extensions';\nimport {normalizeGLTFV1} from '../api/normalize-gltf-v1';\nimport {postProcessGLTF} from '../api/post-process-gltf';\nimport parseGLBSync, {isGLB} from './parse-glb';\n\nexport type GLTFParseOptions = {\n excludeExtensions?: string[];\n decompressMeshes?: boolean;\n normalize?: boolean;\n loadBuffers?: boolean;\n loadImages?: boolean;\n postProcess?: boolean;\n};\n\n// export type GLTFOptions = {\n// gltf?: GLTFParseOptions;\n// };\n\nexport function isGLTF(arrayBuffer, options?): boolean {\n const byteOffset = 0;\n return isGLB(arrayBuffer, byteOffset, options);\n}\n\nexport async function parseGLTF(\n gltf,\n arrayBufferOrString,\n byteOffset = 0,\n options: {\n gltf?: GLTFParseOptions;\n glb?: GLBParseOptions;\n },\n context: LoaderContext\n) {\n parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);\n\n normalizeGLTFV1(gltf, {normalize: options?.gltf?.normalize});\n\n const promises: Promise<any>[] = [];\n\n // Load linked buffers asynchronously and decodes base64 buffers in parallel\n if (options?.gltf?.loadBuffers && gltf.json.buffers) {\n await loadBuffers(gltf, options, context);\n }\n\n if (options?.gltf?.loadImages) {\n const promise = loadImages(gltf, options, context);\n promises.push(promise);\n }\n\n const promise = decodeExtensions(gltf, options, context);\n promises.push(promise);\n\n // Parallelize image loading and buffer loading/extension decoding\n await Promise.all(promises);\n\n // Post processing resolves indices to objects, buffers\n return options?.gltf?.postProcess ? postProcessGLTF(gltf, options) : gltf;\n}\n\n// `data` - can be ArrayBuffer (GLB), ArrayBuffer (Binary JSON), String (JSON), or Object (parsed JSON)\nfunction parseGLTFContainerSync(gltf, data, byteOffset, options) {\n // Initialize gltf container\n if (options.uri) {\n gltf.baseUri = options.uri;\n }\n\n // If data is binary and starting with magic bytes, assume binary JSON text, convert to string\n if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {\n const textDecoder = new TextDecoder();\n data = textDecoder.decode(data);\n }\n\n if (typeof data === 'string') {\n // If string, try to parse as JSON\n gltf.json = parseJSON(data);\n } else if (data instanceof ArrayBuffer) {\n // If still ArrayBuffer, parse as GLB container\n const glb: GLB = {} as GLB;\n byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);\n\n assert(glb.type === 'glTF', `Invalid GLB magic string ${glb.type}`);\n\n gltf._glb = glb;\n gltf.json = glb.json;\n } else {\n assert(false, 'GLTF: must be ArrayBuffer or string');\n }\n\n // Populate buffers\n // Create an external buffers array to hold binary data\n const buffers = gltf.json.buffers || [];\n gltf.buffers = new Array(buffers.length).fill(null);\n\n // Populates JSON and some bin chunk info\n if (gltf._glb && gltf._glb.header.hasBinChunk) {\n const {binChunks} = gltf._glb;\n gltf.buffers[0] = {\n arrayBuffer: binChunks[0].arrayBuffer,\n byteOffset: binChunks[0].byteOffset,\n byteLength: binChunks[0].byteLength\n };\n\n // TODO - this modifies JSON and is a post processing thing\n // gltf.json.buffers[0].data = gltf.buffers[0].arrayBuffer;\n // gltf.json.buffers[0].byteOffset = gltf.buffers[0].byteOffset;\n }\n\n // Populate images\n const images = gltf.json.images || [];\n gltf.images = new Array(images.length).fill({});\n}\n\n// Asynchronously fetch and parse buffers, store in buffers array outside of json\nasync function loadBuffers(gltf, options, context: LoaderContext) {\n for (let i = 0; i < gltf.json.buffers.length; ++i) {\n const buffer = gltf.json.buffers[i];\n if (buffer.uri) {\n const {fetch} = context;\n assert(fetch);\n\n const uri = resolveUrl(buffer.uri, options);\n const response = await context?.fetch?.(uri);\n const arrayBuffer = await response?.arrayBuffer?.();\n\n gltf.buffers[i] = {\n arrayBuffer,\n byteOffset: 0,\n byteLength: arrayBuffer.byteLength\n };\n\n delete buffer.uri;\n }\n }\n}\n\nasync function loadImages(gltf, options, context: LoaderContext) {\n const images = gltf.json.images || [];\n\n const promises: Promise<any>[] = [];\n for (let i = 0; i < images.length; ++i) {\n promises.push(loadImage(gltf, images[i], i, options, context));\n }\n\n return await Promise.all(promises);\n}\n\n// Asynchronously fetches and parses one image, store in images array outside of json\nasync function loadImage(gltf, image, index: number, options, context: LoaderContext) {\n const {fetch, parse} = context;\n\n let arrayBuffer;\n\n if (image.uri) {\n const uri = resolveUrl(image.uri, options);\n const response = await fetch(uri);\n arrayBuffer = await response.arrayBuffer();\n }\n\n if (Number.isFinite(image.bufferView)) {\n const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);\n arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);\n }\n\n assert(arrayBuffer, 'glTF image has no data');\n\n // Call `parse`\n const parsedImage = await parse(arrayBuffer, ImageLoader, {}, context);\n // TODO making sure ImageLoader is overridable by using array of loaders\n // const parsedImage = await parse(arrayBuffer, [ImageLoader]);\n\n gltf.images[index] = parsedImage;\n}\n","import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {DracoLoaderOptions} from '@loaders.gl/draco';\n// import type {ImageLoaderOptions} from '@loaders.gl/images';\n// import type {TextureLoaderOptions} from '@loaders.gl/textures';\nimport type {GLTFParseOptions} from './lib/parsers/parse-gltf';\nimport {VERSION} from './lib/utils/version';\nimport {parseGLTF} from './lib/parsers/parse-gltf';\nimport {GLBLoaderOptions} from './glb-loader';\n\n/**\n * GLTF loader options\n */\nexport type GLTFLoaderOptions = LoaderOptions &\n GLBLoaderOptions &\n DracoLoaderOptions & {\n gltf?: GLTFParseOptions;\n };\n\n/**\n * GLTF loader\n */\nexport const GLTFLoader: LoaderWithParser = {\n name: 'glTF',\n id: 'gltf',\n module: 'gltf',\n version: VERSION,\n extensions: ['gltf', 'glb'],\n mimeTypes: ['model/gltf+json', 'model/gltf-binary'],\n\n text: true,\n binary: true,\n tests: ['glTF'],\n parse,\n\n options: {\n gltf: {\n normalize: true, // Normalize glTF v1 to glTF v2 format (not yet stable)\n loadBuffers: true, // Fetch any linked .BIN buffers, decode base64\n loadImages: true, // Create image objects\n decompressMeshes: true, // Decompress Draco encoded meshes\n postProcess: true // Postprocess glTF and return json structure directly\n },\n\n // common?\n log: console // eslint-disable-line\n },\n deprecatedOptions: {\n fetchImages: 'gltf.loadImages',\n createImages: 'gltf.loadImages',\n decompress: 'gltf.decompressMeshes',\n postProcess: 'gltf.postProcess',\n gltf: {\n decompress: 'gltf.decompressMeshes'\n }\n }\n};\n\nexport async function parse(arrayBuffer, options: GLTFLoaderOptions = {}, context) {\n // Apps can call the parse method directly, we so apply default options here\n options = {...GLTFLoader.options, ...options};\n // @ts-ignore\n options.gltf = {...GLTFLoader.options.gltf, ...options.gltf};\n\n const {byteOffset = 0} = options;\n const gltf = {};\n return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);\n}\n","// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\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 - should we automatically parse the embedded glTF or leave it to the app?\n// - I.e. some apps might work directly on a GLB, in that case no need for us to decode...\n// - And if we decode, do we still keep the GLB in case it is needed?\n// - Do we add an option to control this?\n// - Also, should we have hard dependency on gltf module or use injection or auto-discovery for gltf parser?\n\nimport {GLTFLoader} from '@loaders.gl/gltf';\nimport {sliceArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport const GLTF_FORMAT = {\n URI: 0,\n EMBEDDED: 1\n};\n\nexport function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {\n // Set flags\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 tile.rotateYtoZ = true;\n\n // Assume glTF consumes rest of tile\n const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;\n if (gltfByteLength === 0) {\n throw new Error('glTF byte length must be greater than 0.');\n }\n\n // Save gltf up axis\n tile.gltfUpAxis =\n options['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis\n ? options['3d-tiles'].assetGltfUpAxis\n : 'Y';\n\n // TODO - We can avoid copy if already 4-byte aligned...\n // However the rest of the code may not be able to accept byteOffsets, so copy anyway\n tile.gltfArrayBuffer = sliceArrayBuffer(arrayBuffer, byteOffset, gltfByteLength);\n tile.gltfByteOffset = 0;\n tile.gltfByteLength = gltfByteLength;\n\n if (byteOffset % 4 === 0) {\n // tile.gltfArrayBuffer = arrayBuffer;\n // tile.gltfByteOffset = byteOffset;\n // tile.gltfByteLength = gltfByteLength;\n } else {\n // Create a copy of the glb so that it is 4-byte aligned\n // eslint-disable-next-line\n console.warn(`${tile.type}: embedded glb is not aligned to a 4-byte boundary.`);\n }\n\n // Entire tile is consumed\n return tile.byteOffset + tile.byteLength;\n}\n\nexport async function extractGLTF(tile, gltfFormat, options, context) {\n const tile3DOptions = options['3d-tiles'] || {};\n\n extractGLTFBufferOrURL(tile, gltfFormat, options);\n\n if (tile3DOptions.loadGLTF) {\n const {parse, fetch} = context;\n if (tile.gltfUrl) {\n tile.gltfArrayBuffer = await fetch(tile.gltfUrl, options);\n tile.gltfByteOffset = 0;\n }\n if (tile.gltfArrayBuffer) {\n // TODO - Should handle byteOffset... However, not used now...\n tile.gltf = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);\n delete tile.gltfArrayBuffer;\n delete tile.gltfByteOffset;\n delete tile.gltfByteLength;\n }\n }\n}\n\nfunction extractGLTFBufferOrURL(tile, gltfFormat, options) {\n switch (gltfFormat) {\n case GLTF_FORMAT.URI:\n // We need to remove padding from the end of the model URL in case this tile was part of a composite tile.\n // This removes all white space and null characters from the end of the string.\n const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);\n const textDecoder = new TextDecoder();\n const gltfUrl = textDecoder.decode(gltfUrlBytes);\n tile.gltfUrl = gltfUrl.replace(/[\\s\\0]+$/, '');\n delete tile.gltfArrayBuffer;\n delete tile.gltfByteOffset;\n delete tile.gltfByteLength;\n break;\n case GLTF_FORMAT.EMBEDDED:\n break;\n default:\n throw new Error(`b3dm: Illegal glTF format field`);\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 {GL} from '@loaders.gl/math'; // math.gl/geometry;\nimport Tile3DFeatureTable from '../classes/tile-3d-feature-table';\n// import Tile3DBatchTable from '../classes/tile-3d-batch-table';\n\nimport {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';\nimport {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/parse-3d-tile-tables';\nimport {parse3DTileGLTFViewSync, extractGLTF, GLTF_FORMAT} from './helpers/parse-3d-tile-gltf-view';\n\nexport async function parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {\n byteOffset = parseBatchedModel(tile, arrayBuffer, byteOffset, options, context);\n await extractGLTF(tile, GLTF_FORMAT.EMBEDDED, options, context);\n\n const extensions = tile?.gltf?.extensions;\n if (extensions && extensions.CESIUM_RTC) {\n tile.rtcCenter = extensions.CESIUM_RTC.center;\n }\n\n return byteOffset;\n}\n\nfunction parseBatchedModel(tile, arrayBuffer, byteOffset, options, context) {\n byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);\n\n byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);\n byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);\n\n byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);\n\n const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);\n tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', GL.FLOAT, 3);\n\n return byteOffset;\n}\n","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","// 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 {Vector3, Matrix3, Matrix4, Quaternion} from '@math.gl/core';\nimport {Ellipsoid} from '@math.gl/geospatial';\nimport {GL} from '@loaders.gl/math'; // 'math.gl/geometry';\nimport Tile3DFeatureTable from '../classes/tile-3d-feature-table';\nimport Tile3DBatchTable from '../classes/tile-3d-batch-table';\n\nimport {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';\nimport {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/parse-3d-tile-tables';\nimport {parse3DTileGLTFViewSync, extractGLTF} from './helpers/parse-3d-tile-gltf-view';\n\nexport async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {\n byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);\n await extractGLTF(tile, tile.gltfFormat, options, context);\n return byteOffset;\n}\n\nfunction parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {\n byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);\n if (tile.version !== 1) {\n throw new Error(`Instanced 3D Model version ${tile.version} is not supported`);\n }\n\n byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);\n\n const view = new DataView(arrayBuffer);\n\n tile.gltfFormat = view.getUint32(byteOffset, true);\n byteOffset += 4;\n\n // PARSE FEATURE TABLE\n byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);\n\n byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);\n\n // TODO - Is the feature table sometimes optional or can check be moved into table header parser?\n if (tile.featureTableJsonByteLength === 0) {\n throw new Error('i3dm parser: featureTableJsonByteLength is zero.');\n }\n\n const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);\n\n const instancesLength = featureTable.getGlobalProperty('INSTANCES_LENGTH');\n featureTable.featuresLength = instancesLength;\n\n if (!Number.isFinite(instancesLength)) {\n throw new Error('i3dm parser: INSTANCES_LENGTH must be defined');\n }\n\n tile.eastNorthUp = featureTable.getGlobalProperty('EAST_NORTH_UP');\n tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', GL.FLOAT, 3);\n\n const batchTable = new Tile3DBatchTable(\n tile.batchTableJson,\n tile.batchTableBinary,\n instancesLength\n );\n\n extractInstancedAttributes(tile, featureTable, batchTable, instancesLength);\n\n return byteOffset;\n}\n\n// eslint-disable-next-line max-statements, complexity\nfunction extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {\n // Create model instance collection\n const collectionOptions = {\n instances: new Array(instancesLength),\n batchTable: tile._batchTable,\n cull: false, // Already culled by 3D Tiles\n url: undefined,\n // requestType: RequestType.TILES3D,\n gltf: undefined,\n basePath: undefined,\n incrementallyLoadTextures: false,\n // TODO - tileset is not available at this stage, tile is parsed independently\n // upAxis: (tileset && tileset._gltfUpAxis) || [0, 1, 0],\n forwardAxis: [1, 0, 0]\n };\n\n const instances = collectionOptions.instances;\n const instancePosition = new Vector3();\n const instanceNormalRight = new Vector3();\n const instanceNormalUp = new Vector3();\n const instanceNormalForward = new Vector3();\n const instanceRotation = new Matrix3();\n const instanceQuaternion = new Quaternion();\n const instanceScale = new Vector3();\n const instanceTranslationRotationScale = {};\n const instanceTransform = new Matrix4();\n const scratch1 = [];\n const scratch2 = [];\n const scratchVector1 = new Vector3();\n const scratchVector2 = new Vector3();\n\n for (let i = 0; i < instancesLength; i++) {\n let position;\n\n // Get the instance position\n if (featureTable.hasProperty('POSITION')) {\n position = featureTable.getProperty('POSITION', GL.FLOAT, 3, i, instancePosition);\n } else if (featureTable.hasProperty('POSITION_QUANTIZED')) {\n position = featureTable.getProperty(\n 'POSITION_QUANTIZED',\n GL.UNSIGNED_SHORT,\n 3,\n i,\n instancePosition\n );\n\n const quantizedVolumeOffset = featureTable.getGlobalProperty(\n 'QUANTIZED_VOLUME_OFFSET',\n GL.FLOAT,\n 3,\n scratchVector1\n );\n if (!quantizedVolumeOffset) {\n throw new Error(\n 'i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.'\n );\n }\n\n const quantizedVolumeScale = featureTable.getGlobalProperty(\n 'QUANTIZED_VOLUME_SCALE',\n GL.FLOAT,\n 3,\n scratchVector2\n );\n if (!quantizedVolumeScale) {\n throw new Error(\n 'i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.'\n );\n }\n\n const MAX_UNSIGNED_SHORT = 65535.0;\n for (let j = 0; j < 3; j++) {\n position[j] =\n (position[j] / MAX_UNSIGNED_SHORT) * quantizedVolumeScale[j] + quantizedVolumeOffset[j];\n }\n }\n\n if (!position) {\n throw new Error('i3dm: POSITION or POSITION_QUANTIZED must be defined for each instance.');\n }\n\n instancePosition.copy(position);\n instanceTranslationRotationScale.translation = instancePosition;\n\n // Get the instance rotation\n tile.normalUp = featureTable.getProperty('NORMAL_UP', GL.FLOAT, 3, i, scratch1);\n tile.normalRight = featureTable.getProperty('NORMAL_RIGHT', GL.FLOAT, 3, i, scratch2);\n\n const hasCustomOrientation = false;\n if (tile.normalUp) {\n if (!tile.normalRight) {\n throw new Error('i3dm: Custom orientation requires both NORMAL_UP and NORMAL_RIGHT.');\n }\n // Vector3.unpack(normalUp, 0, instanceNormalUp);\n // Vector3.unpack(normalRight, 0, instanceNormalRight);\n tile.hasCustomOrientation = true;\n } else {\n tile.octNormalUp = featureTable.getProperty(\n 'NORMAL_UP_OCT32P',\n GL.UNSIGNED_SHORT,\n 2,\n scratch1\n );\n tile.octNormalRight = featureTable.getProperty(\n 'NORMAL_RIGHT_OCT32P',\n GL.UNSIGNED_SHORT,\n 2,\n scratch2\n );\n\n if (tile.octNormalUp) {\n if (!tile.octNormalRight) {\n throw new Error(\n 'i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P'\n );\n }\n\n throw new Error('i3dm: oct-encoded orientation not implemented');\n /*\n AttributeCompression.octDecodeInRange(octNormalUp[0], octNormalUp[1], 65535, instanceNormalUp);\n AttributeCompression.octDecodeInRange(octNormalRight[0], octNormalRight[1], 65535, instanceNormalRight);\n hasCustomOrientation = true;\n */\n } else if (tile.eastNorthUp) {\n Ellipsoid.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);\n instanceTransform.getRotationMatrix3(instanceRotation);\n } else {\n instanceRotation.identity();\n }\n }\n\n if (hasCustomOrientation) {\n instanceNormalForward.copy(instanceNormalRight).cross(instanceNormalUp).normalize();\n instanceRotation.setColumn(0, instanceNormalRight);\n instanceRotation.setColumn(1, instanceNormalUp);\n instanceRotation.setColumn(2, instanceNormalForward);\n }\n\n instanceQuaternion.fromMatrix3(instanceRotation);\n instanceTranslationRotationScale.rotation = instanceQuaternion;\n\n // Get the instance scale\n instanceScale.set(1.0, 1.0, 1.0);\n const scale = featureTable.getProperty('SCALE', GL.FLOAT, 1, i);\n if (Number.isFinite(scale)) {\n instanceScale.multiplyByScalar(scale);\n }\n const nonUniformScale = featureTable.getProperty('SCALE_NON_UNIFORM', GL.FLOAT, 3, i, scratch1);\n if (nonUniformScale) {\n instanceScale.scale(nonUniformScale);\n }\n\n instanceTranslationRotationScale.scale = instanceScale;\n\n // Get the batchId\n let batchId = featureTable.getProperty('BATCH_ID', GL.UNSIGNED_SHORT, 1, i);\n if (batchId === undefined) {\n // If BATCH_ID semantic is undefined, batchId is just the instance number\n batchId = i;\n }\n\n const rotationMatrix = new Matrix4().fromQuaternion(instanceTranslationRotationScale.rotation);\n\n // Create the model matrix and the instance\n instanceTransform.identity();\n instanceTransform.translate(instanceTranslationRotationScale.translation);\n instanceTransform.multiplyRight(rotationMatrix);\n instanceTransform.scale(instanceTranslationRotationScale.scale);\n\n const modelMatrix = instanceTransform.clone();\n instances[i] = {\n modelMatrix,\n batchId\n };\n }\n\n tile.instances = instances;\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_TYPE} from '../constants';\nimport {getMagicString} from './helpers/parse-utils';\n\nimport {parsePointCloud3DTile} from './parse-3d-tile-point-cloud';\nimport {parseBatchedModel3DTile} from './parse-3d-tile-batched-model';\nimport {parseInstancedModel3DTile} from './parse-3d-tile-instanced-model';\nimport {parseComposite3DTile} from './parse-3d-tile-composite';\n\n// Extracts\nexport async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = {}) {\n tile.byteOffset = byteOffset;\n tile.type = getMagicString(arrayBuffer, byteOffset);\n\n switch (tile.type) {\n case TILE3D_TYPE.COMPOSITE:\n // Note: We pass this function as argument so that embedded tiles can be parsed recursively\n return await parseComposite3DTile(\n tile,\n arrayBuffer,\n byteOffset,\n options,\n context,\n parse3DTile\n );\n\n case TILE3D_TYPE.BATCHED_3D_MODEL:\n return await parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context);\n\n case TILE3D_TYPE.INSTANCED_3D_MODEL:\n return await parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context);\n\n case TILE3D_TYPE.POINT_CLOUD:\n return await parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, context);\n\n default:\n throw new Error(`3DTileLoader: unknown type ${tile.type}`); // eslint-disable-line\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// Reference code:\n// https://github.com/AnalyticalGraphicsInc/cesium/blob/master/Source/Scene/Composite3DTileContent.js#L182\n\nimport {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';\n\n// eslint-disable-next-line max-params\nexport async function parseComposite3DTile(\n tile,\n arrayBuffer,\n byteOffset,\n options,\n context,\n parse3DTile\n) {\n byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);\n\n const view = new DataView(arrayBuffer);\n\n // Extract number of tiles\n tile.tilesLength = view.getUint32(byteOffset, true);\n byteOffset += 4;\n\n // extract each tile from the byte stream\n tile.tiles = [];\n while (tile.tiles.length < tile.tilesLength && tile.byteLength - byteOffset > 12) {\n const subtile = {};\n tile.tiles.push(subtile);\n byteOffset = await parse3DTile(arrayBuffer, byteOffset, options, context, subtile);\n // TODO - do we need to add any padding in between tiles?\n }\n\n return byteOffset;\n}\n","import {LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE} from '@loaders.gl/tiles';\n\nfunction getTileType(tile) {\n if (!tile.contentUrl) {\n return TILE_TYPE.EMPTY;\n }\n\n const contentUrl = tile.contentUrl;\n const fileExtension = contentUrl.split('.').pop();\n switch (fileExtension) {\n case 'pnts':\n return TILE_TYPE.POINTCLOUD;\n case 'i3dm':\n case 'b3dm':\n return TILE_TYPE.SCENEGRAPH;\n default:\n return fileExtension;\n }\n}\n\nfunction getRefine(refine) {\n switch (refine) {\n case 'REPLACE':\n case 'replace':\n return TILE_REFINEMENT.REPLACE;\n case 'ADD':\n case 'add':\n return TILE_REFINEMENT.ADD;\n default:\n return refine;\n }\n}\n\nexport function normalizeTileData(tile, options) {\n if (!tile) {\n return null;\n }\n if (tile.content) {\n const contentUri = tile.content.uri || tile.content.url;\n tile.contentUrl = `${options.basePath}/${contentUri}`;\n }\n tile.id = tile.contentUrl;\n tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;\n tile.lodMetricValue = tile.geometricError;\n tile.transformMatrix = tile.transform;\n tile.type = getTileType(tile);\n tile.refine = getRefine(tile.refine);\n return tile;\n}\n\n// normalize tile headers\nexport function normalizeTileHeaders(tileset) {\n const basePath = tileset.basePath;\n const root = normalizeTileData(tileset.root, tileset);\n\n const stack = [];\n stack.push(root);\n\n while (stack.length > 0) {\n const tile = stack.pop() || {};\n const children = tile.children || [];\n for (const childHeader of children) {\n normalizeTileData(childHeader, {basePath});\n stack.push(childHeader);\n }\n }\n\n return root;\n}\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {path} from '@loaders.gl/loader-utils';\nimport {TILESET_TYPE, LOD_METRIC_TYPE} from '@loaders.gl/tiles';\nimport {VERSION} from './lib/utils/version';\nimport {parse3DTile} from './lib/parsers/parse-3d-tile';\nimport {normalizeTileHeaders} from './lib/parsers/parse-3d-tile-header';\n\n/**\n * Loader for 3D Tiles\n */\nexport const Tiles3DLoader: LoaderWithParser = {\n id: '3d-tiles',\n name: '3D Tiles',\n module: '3d-tiles',\n version: VERSION,\n extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],\n mimeTypes: ['application/octet-stream'],\n tests: ['cmpt', 'pnts', 'b3dm', 'i3dm'],\n parse,\n options: {\n '3d-tiles': {\n loadGLTF: true,\n decodeQuantizedPositions: false,\n isTileset: 'auto',\n assetGltfUpAxis: null\n }\n }\n};\n\nfunction getBaseUri(tileset) {\n return path.dirname(tileset.url);\n}\n\nasync function parseTile(arrayBuffer, options, context) {\n const tile = {\n content: {\n featureIds: null\n }\n };\n const byteOffset = 0;\n await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);\n return tile.content;\n}\n\nasync function parseTileset(data, options, context) {\n const tilesetJson = JSON.parse(new TextDecoder().decode(data));\n // eslint-disable-next-line no-use-before-define\n tilesetJson.loader = options.loader || Tiles3DLoader;\n tilesetJson.url = context.url;\n // base path that non-absolute paths in tileset are relative to.\n tilesetJson.basePath = getBaseUri(tilesetJson);\n tilesetJson.root = normalizeTileHeaders(tilesetJson);\n tilesetJson.type = TILESET_TYPE.TILES3D;\n\n tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;\n tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;\n\n return tilesetJson;\n}\n\nasync function parse(data, options, context) {\n // auto detect file type\n const loaderOptions = options['3d-tiles'] || {};\n let isTileset;\n if (loaderOptions.isTileset === 'auto') {\n isTileset = context.url && context.url.indexOf('.json') !== -1;\n } else {\n isTileset = loaderOptions.isTileset;\n }\n\n if (isTileset) {\n data = await parseTileset(data, options, context);\n } else {\n data = await parseTile(data, options, context);\n }\n\n return data;\n}\n","// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n","// Simple file alias mechanisms for tests.\n\nlet pathPrefix = '';\nconst fileAliases: {[aliasPath: string]: string} = {};\n\n/*\n * Set a relative path prefix\n */\nexport function setPathPrefix(prefix: string): void {\n pathPrefix = prefix;\n}\n\n/*\n * Get the relative path prefix\n */\nexport function getPathPrefix(): string {\n return pathPrefix;\n}\n\n/**\n *\n * @param aliases\n *\n * Note: addAliases are an experimental export, they are only for testing of loaders.gl loaders\n * not intended as a generic aliasing mechanism\n */\nexport function addAliases(aliases: {[aliasPath: string]: string}): void {\n Object.assign(fileAliases, aliases);\n}\n\n/**\n * Resolves aliases and adds path-prefix to paths\n */\nexport function resolvePath(filename: string): string {\n for (const alias in fileAliases) {\n if (filename.startsWith(alias)) {\n const replacement = fileAliases[alias];\n filename = filename.replace(alias, replacement);\n }\n }\n if (!filename.startsWith('http://') && !filename.startsWith('https://')) {\n filename = `${pathPrefix}${filename}`;\n }\n return filename;\n}\n","import type {Readable} from 'stream';\n\n/** A DOM or Node readable stream */\nexport type ReadableStreamType = ReadableStream | Readable;\n\nconst isBoolean: (x: any) => boolean = (x) => typeof x === 'boolean';\nconst isFunction: (x: any) => boolean = (x) => typeof x === 'function';\n\nexport const isObject: (x: any) => boolean = (x) => x !== null && typeof x === 'object';\nexport const isPureObject: (x: any) => boolean = (x) =>\n isObject(x) && x.constructor === {}.constructor;\nexport const isPromise: (x: any) => boolean = (x) => isObject(x) && isFunction(x.then);\n\nexport const isIterable: (x: any) => boolean = (x) => x && typeof x[Symbol.iterator] === 'function';\nexport const isAsyncIterable: (x: any) => boolean = (x) =>\n x && typeof x[Symbol.asyncIterator] === 'function';\nexport const isIterator: (x: any) => boolean = (x) => x && isFunction(x.next);\n\nexport const isResponse: (x: any) => boolean = (x) =>\n (typeof Response !== 'undefined' && x instanceof Response) ||\n (x && x.arrayBuffer && x.text && x.json);\n\nexport const isFile: (x: any) => boolean = (x) => typeof File !== 'undefined' && x instanceof File;\nexport const isBlob: (x: any) => boolean = (x) => typeof Blob !== 'undefined' && x instanceof Blob;\n\n/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */\nexport const isBuffer: (x: any) => boolean = (x) => x && typeof x === 'object' && x.isBuffer;\n\nexport const isWritableDOMStream: (x: any) => boolean = (x) =>\n isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);\n\nexport const isReadableDOMStream: (x: any) => boolean = (x) =>\n (typeof ReadableStream !== 'undefined' && x instanceof ReadableStream) ||\n (isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader));\n// Not implemented in Firefox: && isFunction(x.pipeTo)\n\nexport const isWritableNodeStream: (x: any) => boolean = (x) =>\n isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);\nexport const isReadableNodeStream: (x: any) => boolean = (x) =>\n isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);\nexport const isReadableStream: (x: any) => boolean = (x) =>\n isReadableDOMStream(x) || isReadableNodeStream(x);\nexport const isWritableStream: (x: any) => boolean = (x) =>\n isWritableDOMStream(x) || isWritableNodeStream(x);\n","// TODO - build/integrate proper MIME type parsing\n// https://mimesniff.spec.whatwg.org/\n\nconst DATA_URL_PATTERN = /^data:([-\\w.]+\\/[-\\w.+]+)(;|,)/;\nconst MIME_TYPE_PATTERN = /^([-\\w.]+\\/[-\\w.+]+)/;\n\n/**\n * Remove extra data like `charset` from MIME types\n * @param mimeString\n * @returns A clean MIME type, or an empty string\n *\n * @todo - handle more advanced MIMETYpes, multiple types\n * @todo - extract charset etc\n */\nexport function parseMIMEType(mimeString: string): string {\n // If resource is a data url, extract any embedded mime type\n const matches = MIME_TYPE_PATTERN.exec(mimeString);\n if (matches) {\n return matches[1];\n }\n return mimeString;\n}\n\n/**\n * Extract MIME type from data URL\n *\n * @param mimeString\n * @returns A clean MIME type, or an empty string\n *\n * @todo - handle more advanced MIMETYpes, multiple types\n * @todo - extract charset etc\n */\nexport function parseMIMETypeFromURL(url: string): string {\n // If resource is a data URL, extract any embedded mime type\n const matches = DATA_URL_PATTERN.exec(url);\n if (matches) {\n return matches[1];\n }\n return '';\n}\n","import {isResponse, isBlob} from '../../javascript-utils/is-type';\nimport {parseMIMEType, parseMIMETypeFromURL} from './mime-type-utils';\n\nconst QUERY_STRING_PATTERN = /\\?.*/;\n\n/**\n * Returns an object with `url` and (MIME) `type` fields\n * If it cannot determine url or type, the corresponding value will be an empty string\n *\n * @param resource Any type, but only Responses, string URLs and data URLs are processed\n *\n * @todo string parameters are assumed to be URLs\n */\nexport function getResourceUrlAndType(resource: any): {url: string; type: string} {\n // If resource is a response, it contains the information directly\n if (isResponse(resource)) {\n const url = stripQueryString(resource.url || '');\n const contentTypeHeader = resource.headers.get('content-type') || '';\n return {\n url,\n type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)\n };\n }\n\n // If the resource is a Blob or a File (subclass of Blob)\n if (isBlob(resource)) {\n return {\n // File objects have a \"name\" property. Blob objects don't have any\n // url (name) information\n url: stripQueryString(resource.name || ''),\n type: resource.type || ''\n };\n }\n\n if (typeof resource === 'string') {\n return {\n // TODO this could mess up data URL but it doesn't matter as it is just used for inference\n url: stripQueryString(resource),\n // If a data url\n type: parseMIMETypeFromURL(resource)\n };\n }\n\n // Unknown\n return {\n url: '',\n type: ''\n };\n}\n\n/**\n * Returns (approximate) content length for a resource if it can be determined.\n * Returns -1 if content length cannot be determined.\n * @param resource\n\n * @note string parameters are NOT assumed to be URLs\n */\nexport function getResourceContentLength(resource: any): number {\n if (isResponse(resource)) {\n return resource.headers['content-length'] || -1;\n }\n if (isBlob(resource)) {\n return resource.size;\n }\n if (typeof resource === 'string') {\n // TODO - handle data URL?\n return resource.length;\n }\n if (resource instanceof ArrayBuffer) {\n return resource.byteLength;\n }\n if (ArrayBuffer.isView(resource)) {\n return resource.byteLength;\n }\n return -1;\n}\n\nfunction stripQueryString(url) {\n return url.replace(QUERY_STRING_PATTERN, '');\n}\n","import {isResponse} from '../../javascript-utils/is-type';\nimport {getResourceContentLength, getResourceUrlAndType} from './resource-utils';\n\n/**\n * Returns a Response object\n * Adds content-length header when possible\n *\n * @param resource\n */\nexport async function makeResponse(resource: any): Promise<Response> {\n if (isResponse(resource)) {\n return resource;\n }\n\n // Add content-length header if possible\n const headers: {[header: string]: string} = {};\n\n const contentLength = getResourceContentLength(resource);\n if (contentLength >= 0) {\n headers['content-length'] = String(contentLength);\n }\n\n // `new Response(File)` does not preserve content-type and URL\n // so we add them here\n const {url, type} = getResourceUrlAndType(resource);\n if (type) {\n headers['content-type'] = type;\n }\n\n // Add a custom header with initial bytes if available\n const initialDataUrl = await getInitialDataUrl(resource);\n if (initialDataUrl) {\n headers['x-first-bytes'] = initialDataUrl;\n }\n\n // TODO - is this the best way of handling strings?\n // Maybe package as data URL instead?\n if (typeof resource === 'string') {\n // Convert to ArrayBuffer to avoid Response treating it as a URL\n resource = new TextEncoder().encode(resource);\n }\n\n // Attempt to create a Response from the resource, adding headers and setting url\n const response = new Response(resource, {headers});\n // We can't control `Response.url` via constructor, use a property override to record URL.\n Object.defineProperty(response, 'url', {value: url});\n return response;\n}\n\n/**\n * Checks response status (async) and throws a helpful error message if status is not OK.\n * @param response\n */\nexport async function checkResponse(response: Response): Promise<void> {\n if (!response.ok) {\n const message = await getResponseError(response);\n throw new Error(message);\n }\n}\n\n/**\n * Checks response status (sync) and throws a helpful error message if status is not OK.\n * @param response\n */\nexport function checkResponseSync(response: Response): void {\n if (!response.ok) {\n let message = `${response.status} ${response.statusText}`;\n message = message.length > 60 ? `${message.slice(60)}...` : message;\n throw new Error(message);\n }\n}\n\n// HELPERS\n\nasync function getResponseError(response): Promise<string> {\n let message = `Failed to fetch resource ${response.url} (${response.status}): `;\n try {\n const contentType = response.headers.get('Content-Type');\n let text = response.statusText;\n if (contentType.includes('application/json')) {\n text += ` ${await response.text()}`;\n }\n message += text;\n message = message.length > 60 ? `${message.slice(60)}...` : message;\n } catch (error) {\n // eslint forbids return in a finally statement, so we just catch here\n }\n return message;\n}\n\nasync function getInitialDataUrl(resource): Promise<string | null> {\n const INITIAL_DATA_LENGTH = 5;\n if (typeof resource === 'string') {\n return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;\n }\n if (resource instanceof Blob) {\n const blobSlice = resource.slice(0, 5);\n return await new Promise((resolve) => {\n const reader = new FileReader();\n reader.onload = (event) => resolve(event?.target?.result as string);\n reader.readAsDataURL(blobSlice);\n });\n }\n if (resource instanceof ArrayBuffer) {\n const slice = resource.slice(0, INITIAL_DATA_LENGTH);\n const base64 = arrayBufferToBase64(slice);\n return `data:base64,${base64}`;\n }\n return null;\n}\n\n// https://stackoverflow.com/questions/9267899/arraybuffer-to-base64-encoded-string\nfunction arrayBufferToBase64(buffer) {\n let binary = '';\n const bytes = new Uint8Array(buffer);\n for (let i = 0; i < bytes.byteLength; i++) {\n binary += String.fromCharCode(bytes[i]);\n }\n return btoa(binary);\n}\n","import {resolvePath} from '@loaders.gl/loader-utils';\nimport {makeResponse} from '../utils/response-utils';\n// import {getErrorMessageFromResponse} from './fetch-error-message';\n\n/**\n * fetch compatible function\n * Reads file data from:\n * - http/http urls\n * - data urls\n * - File/Blob objects\n * Leverages `@loaders.gl/polyfills` for Node.js support\n * Respects pathPrefix and file aliases\n */\nexport async function fetchFile(\n url: string | Blob,\n options?: RequestInit & {fetch?: RequestInit | Function}\n): Promise<Response> {\n if (typeof url === 'string') {\n url = resolvePath(url);\n\n let fetchOptions: RequestInit = options as RequestInit;\n if (options?.fetch && typeof options?.fetch !== 'function') {\n fetchOptions = options.fetch;\n }\n\n return await fetch(url, fetchOptions);\n }\n\n return await makeResponse(url);\n}\n","// Minimal support to load tilsets from the Cesium ION services\n\nimport {fetchFile} from '@loaders.gl/core';\nimport {assert} from '@loaders.gl/loader-utils';\n\nconst CESIUM_ION_URL = 'https://api.cesium.com/v1/assets';\n\n// Returns `{url, headers, type, attributions}` for an ion tileset\nexport async function getIonTilesetMetadata(accessToken, assetId) {\n // Step 1, if no asset id, look for first 3DTILES asset associated with this token.\n if (!assetId) {\n const assets = await getIonAssets(accessToken);\n for (const item of assets.items) {\n if (item.type === '3DTILES') {\n assetId = item.id;\n }\n }\n }\n\n // Step 2: Query metdatadata for this asset.\n const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);\n const {type, url} = ionAssetMetadata;\n assert(type === '3DTILES' && url);\n\n // Prepare a headers object for fetch\n ionAssetMetadata.headers = {\n Authorization: `Bearer ${ionAssetMetadata.accessToken}`\n };\n return ionAssetMetadata;\n}\n\n// Return a list of all assets associated with accessToken\nexport async function getIonAssets(accessToken) {\n assert(accessToken);\n const url = CESIUM_ION_URL;\n const headers = {Authorization: `Bearer ${accessToken}`};\n const response = await fetchFile(url, {fetch: {headers}});\n if (!response.ok) {\n throw new Error(response.statusText);\n }\n return await response.json();\n}\n\n// Return metadata for a specific asset associated with token\nexport async function getIonAssetMetadata(accessToken, assetId) {\n assert(accessToken, assetId);\n const headers = {Authorization: `Bearer ${accessToken}`};\n\n const url = `${CESIUM_ION_URL}/${assetId}`;\n // https://cesium.com/docs/rest-api/#operation/getAsset\n // Retrieves metadata information about a specific asset.\n let response = await fetchFile(`${url}`, {fetch: {headers}});\n if (!response.ok) {\n throw new Error(response.statusText);\n }\n let metadata = await response.json();\n\n // https://cesium.com/docs/rest-api/#operation/getAssetEndpoint\n // Retrieves information and credentials that allow you to access the tiled asset data for visualization and analysis.\n response = await fetchFile(`${url}/endpoint`, {fetch: {headers}});\n if (!response.ok) {\n throw new Error(response.statusText);\n }\n const tilesetInfo = await response.json();\n\n // extract dataset description\n metadata = {\n ...metadata,\n ...tilesetInfo\n };\n\n return metadata;\n}\n","import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {Tiles3DLoader} from './tiles-3d-loader';\nimport {getIonTilesetMetadata} from './lib/ion/ion';\n\nasync function preload(url, options = {}) {\n options = options['cesium-ion'] || {};\n // @ts-ignore\n const {accessToken} = options;\n // @ts-ignore\n let assetId = options.assetId;\n if (!Number.isFinite(assetId)) {\n const matched = url.match(/\\/([0-9]+)\\/tileset.json/);\n assetId = matched && matched[1];\n }\n return getIonTilesetMetadata(accessToken, assetId);\n}\n\n/**\n * Loader for 3D tiles from Cesium ION\n */\nexport const CesiumIonLoader: LoaderWithParser = {\n ...Tiles3DLoader,\n id: 'cesium-ion',\n name: 'Cesium Ion',\n // @ts-ignore\n preload,\n parse: async (data, options?, context?) => {\n options = {...options};\n options['3d-tiles'] = options['cesium-ion'];\n // @ts-ignore\n options.loader = CesiumIonLoader;\n return Tiles3DLoader.parse(data, options, context); // , loader);\n },\n options: {\n 'cesium-ion': {\n ...Tiles3DLoader.options['3d-tiles'],\n accessToken: null\n }\n }\n};\n","// HELPER ENCODERS\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function encode3DTileHeader(tile, dataView, byteOffset) {\n const HEADER_SIZE = 12;\n\n if (!dataView) {\n return byteOffset + HEADER_SIZE;\n }\n\n const {magic, version = 1, byteLength = 12} = tile;\n\n assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));\n\n dataView.setUint8(byteOffset + 0, magic[0]);\n dataView.setUint8(byteOffset + 1, magic[1]);\n dataView.setUint8(byteOffset + 2, magic[2]);\n dataView.setUint8(byteOffset + 3, magic[3]);\n dataView.setUint32(byteOffset + 4, version, true); // version\n dataView.setUint32(byteOffset + 8, byteLength, true); // byteLength\n\n byteOffset += HEADER_SIZE;\n\n return byteOffset;\n}\n\n// Bytelength is sometimes only known at the end of writing a tile\nexport function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {\n if (!dataView) {\n return;\n }\n\n dataView.setUint32(byteOffsetTileStart + 8, byteLength, true); // byteLength\n}\n","import {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/**\n * Copy sourceBuffer to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {Array | TypedArray} sourceBuffer - source data buffer\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedArrayBufferToDataView(\n dataView: DataView | null,\n byteOffset: number,\n sourceBuffer: TypedArray,\n padding: number\n) {\n const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);\n const padLength = paddedLength - sourceBuffer.byteLength;\n\n if (dataView) {\n // Copy array\n const targetArray = new Uint8Array(\n dataView.buffer,\n dataView.byteOffset + byteOffset,\n sourceBuffer.byteLength\n );\n const sourceArray = new Uint8Array(sourceBuffer);\n targetArray.set(sourceArray);\n\n // Add PADDING\n for (let i = 0; i < padLength; ++i) {\n // json chunk is padded with spaces (ASCII 0x20)\n dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);\n }\n }\n byteOffset += paddedLength;\n return byteOffset;\n}\n\n/**\n * Copy string to dataView with some padding\n *\n * @param {DataView | null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {string} string - source string\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n *\n * @return new byteOffset of resulting dataView\n */\nexport function copyPaddedStringToDataView(\n dataView: DataView | null,\n byteOffset: number,\n string: string,\n padding: number\n): number {\n const textEncoder = new TextEncoder();\n // PERFORMANCE IDEA: We encode twice, once to get size and once to store\n // PERFORMANCE IDEA: Use TextEncoder.encodeInto() to avoid temporary copy\n const stringBuffer = textEncoder.encode(string);\n\n byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);\n\n return byteOffset;\n}\n","// Note: These were broken out from gltf loader...\n// eslint-disable-next-line complexity\n\n// PERFORMANCE IDEA: No need to copy string twice...\nexport function padStringToByteAlignment(string, byteAlignment) {\n const length = string.length;\n const paddedLength = Math.ceil(length / byteAlignment) * byteAlignment; // Round up to the required alignment\n const padding = paddedLength - length;\n let whitespace = '';\n for (let i = 0; i < padding; ++i) {\n whitespace += ' ';\n }\n return string + whitespace;\n}\n\nexport function copyStringToDataView(dataView, byteOffset, string, byteLength) {\n if (dataView) {\n for (let i = 0; i < byteLength; i++) {\n dataView.setUint8(byteOffset + i, string.charCodeAt(i));\n }\n }\n return byteOffset + byteLength;\n}\n\nexport function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {\n if (dataView) {\n for (let i = 0; i < byteLength; i++) {\n dataView.setUint8(byteOffset + i, binary[i]);\n }\n }\n return byteOffset + byteLength;\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 {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\nimport {\n padStringToByteAlignment,\n copyStringToDataView,\n copyBinaryToDataView\n} from '@loaders.gl/loader-utils';\n\nconst DEFAULT_FEATURE_TABLE_JSON = {\n POINTS_LENGTH: 1,\n POSITIONS: {\n byteOffset: 0\n }\n};\n\nexport function encodePointCloud3DTile(tile, dataView, byteOffset, options) {\n const {featureTableJson = DEFAULT_FEATURE_TABLE_JSON} = tile;\n\n let featureTableJsonString = JSON.stringify(featureTableJson);\n featureTableJsonString = padStringToByteAlignment(featureTableJsonString, 4);\n\n const {featureTableJsonByteLength = featureTableJsonString.length} = tile;\n\n const featureTableBinary = new ArrayBuffer(12); // Enough space to hold 3 floats\n const featureTableBinaryByteLength = featureTableBinary.byteLength;\n\n // Add default magic for this tile type\n tile = {magic: MAGIC_ARRAY.POINT_CLOUD, ...tile};\n\n const byteOffsetStart = byteOffset;\n\n byteOffset += encode3DTileHeader(tile, dataView, 0);\n\n if (dataView) {\n dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true); // featureTableJsonByteLength\n dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true); // featureTableBinaryByteLength\n dataView.setUint32(byteOffset + 8, 0, true); // batchTableJsonByteLength\n dataView.setUint32(byteOffset + 12, 0, true); // batchTableBinaryByteLength\n }\n byteOffset += 16;\n\n byteOffset += copyStringToDataView(\n dataView,\n byteOffset,\n featureTableJsonString,\n featureTableJsonByteLength\n );\n byteOffset += copyBinaryToDataView(\n dataView,\n byteOffset,\n featureTableBinary,\n featureTableBinaryByteLength\n );\n\n // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n return byteOffset;\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_TYPE} from '../constants';\nimport {assert} from '@loaders.gl/loader-utils';\n\nimport {encodeComposite3DTile} from './encode-3d-tile-composite';\nimport {encodeBatchedModel3DTile} from './encode-3d-tile-batched-model';\nimport {encodeInstancedModel3DTile} from './encode-3d-tile-instanced-model';\nimport {encodePointCloud3DTile} from './encode-3d-tile-point-cloud';\n\nexport default function encode3DTile(tile, options) {\n const byteLength = encode3DTileToDataView(tile, null, 0, options);\n const arrayBuffer = new ArrayBuffer(byteLength);\n const dataView = new DataView(arrayBuffer);\n encode3DTileToDataView(tile, dataView, 0, options);\n return arrayBuffer;\n}\n\nfunction encode3DTileToDataView(tile, dataView, byteOffset, options) {\n assert(typeof tile.type === 'string');\n\n switch (tile.type) {\n case TILE3D_TYPE.COMPOSITE:\n return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);\n case TILE3D_TYPE.POINT_CLOUD:\n return encodePointCloud3DTile(tile, dataView, byteOffset, options);\n case TILE3D_TYPE.BATCHED_3D_MODEL:\n return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);\n case TILE3D_TYPE.INSTANCED_3D_MODEL:\n return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);\n default:\n throw new Error('3D Tiles: unknown tile type');\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 {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\nexport function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile) {\n // Add default magic for this tile type\n tile = {magic: MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile};\n\n const byteOffsetStart = byteOffset;\n\n byteOffset += encode3DTileHeader(tile, dataView, byteOffset);\n\n if (dataView) {\n dataView.setUint32(byteOffset, tile.tiles.length, true); // tilesLength\n }\n byteOffset += 4;\n\n for (let i = 0; i < tile.tiles.length; ++i) {\n byteOffset += encode3DTile(tile.tiles[i], dataView, byteOffset, options);\n }\n\n // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n return byteOffset;\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 {\n padToNBytes,\n copyBinaryToDataView,\n copyPaddedStringToDataView\n} from '@loaders.gl/loader-utils';\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\n// Procedurally encode the tile array dataView for testing purposes\nexport function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {\n const {featuresLength = 0, batchTable} = tile;\n\n const featureTableJson = {\n BATCH_LENGTH: featuresLength\n };\n const featureTableJsonString = JSON.stringify(featureTableJson);\n const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : '';\n const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);\n const batchTableJsonByteLength = batchTableJsonString\n ? padToNBytes(batchTableJsonString.length, 8)\n : 0;\n\n // Add default magic for this tile type\n tile = {magic: MAGIC_ARRAY.BATCHED_MODEL, ...tile};\n\n const byteOffsetStart = byteOffset;\n\n byteOffset = encode3DTileHeader(tile, dataView, byteOffset);\n\n if (dataView) {\n dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength\n dataView.setUint32(16, 0, true); // featureTableBinaryByteLength\n dataView.setUint32(20, batchTableJsonByteLength, true); // batchTableJsonByteLength\n dataView.setUint32(24, 0, true); // batchTableBinaryByteLength\n }\n byteOffset += 16;\n\n // TODO feature table binary\n byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);\n\n if (batchTable) {\n byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);\n }\n\n // Add encoded GLTF to the end of data\n const gltfEncoded = tile.gltfEncoded;\n if (gltfEncoded) {\n byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);\n }\n\n // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n return byteOffset;\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 {copyStringToDataView} from '@loaders.gl/loader-utils';\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\n// Procedurally encode the tile array buffer for testing purposes\n// eslint-disable-next-line max-statements\nexport function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {\n const {featuresLength = 1, gltfFormat = 1, gltfUri = ''} = tile;\n\n const gltfUriByteLength = gltfUri.length;\n\n const featureTableJson = {\n INSTANCES_LENGTH: featuresLength,\n POSITION: new Array(featuresLength * 3).fill(0)\n };\n const featureTableJsonString = JSON.stringify(featureTableJson);\n const featureTableJsonByteLength = featureTableJsonString.length;\n\n // Add default magic for this tile type\n tile = {magic: MAGIC_ARRAY.INSTANCED_MODEL, ...tile};\n\n const byteOffsetStart = byteOffset;\n\n byteOffset = encode3DTileHeader(tile, dataView, 0);\n\n if (dataView) {\n dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength\n dataView.setUint32(16, 0, true); // featureTableBinaryByteLength\n dataView.setUint32(20, 0, true); // batchTableJsonByteLength\n dataView.setUint32(24, 0, true); // batchTableBinaryByteLength\n dataView.setUint32(28, gltfFormat, true); // gltfFormat\n }\n\n byteOffset += 20;\n\n byteOffset += copyStringToDataView(\n dataView,\n byteOffset,\n featureTableJsonString,\n featureTableJsonByteLength\n );\n byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);\n\n // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n return byteOffset;\n}\n","import type {Writer} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\nimport encode3DTile from './lib/encoders/encode-3d-tile';\n\n/**\n * Exporter for 3D Tiles\n */\nexport const Tile3DWriter: Writer = {\n name: '3D Tile',\n id: '3d-tiles',\n module: '3d-tiles',\n version: VERSION,\n extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],\n mimeTypes: ['application/octet-stream'],\n encodeSync,\n binary: true,\n options: {\n ['3d-tiles']: {}\n }\n};\n\nfunction encodeSync(tile, options) {\n return encode3DTile(tile, options);\n}\n","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","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 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"],"sourceRoot":""}