{"version":3,"sources":["webpack://twgl/webpack/universalModuleDefinition","webpack://twgl/webpack/bootstrap","webpack://twgl/./src/attributes.js","webpack://twgl/./src/draw.js","webpack://twgl/./src/framebuffers.js","webpack://twgl/./src/helper.js","webpack://twgl/./src/m4.js","webpack://twgl/./src/primitives.js","webpack://twgl/./src/programs.js","webpack://twgl/./src/textures.js","webpack://twgl/./src/twgl-full.js","webpack://twgl/./src/twgl.js","webpack://twgl/./src/typedarrays.js","webpack://twgl/./src/utils.js","webpack://twgl/./src/v3.js","webpack://twgl/./src/vertex-arrays.js"],"names":["STATIC_DRAW","ARRAY_BUFFER","ELEMENT_ARRAY_BUFFER","BUFFER_SIZE","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","gl","undefined","defaults","attribPrefix","setAttributePrefix","prefix","setDefaults","newDefaults","helper","copyExistingProperties","setBufferFromTypedArray","type","buffer","array","drawType","bindBuffer","bufferData","createBufferFromTypedArray","typedArray","isBuffer","createBuffer","isIndices","name","getNormalizationForTypedArray","Int8Array","Uint8Array","getNormalizationForTypedArrayType","typedArrayType","getArray","length","data","texcoordRE","colorRE","guessNumComponentsFromName","numComponents","test","Error","getNumComponents","arrayName","size","makeTypedArray","typedArrays","isArrayBuffer","Array","isArray","Type","Uint16Array","Float32Array","createAttribsFromArrays","arrays","attribs","Object","keys","forEach","attribName","attrib","value","normalization","WebGLBuffer","normalize","numValues","arrayType","numBytes","BYTES_PER_ELEMENT","getGLTypeForTypedArrayType","getGLTypeForTypedArray","stride","offset","divisor","setAttribInfoBufferFromArray","attribInfo","bufferSubData","getBytesPerValueForGLType","positionKeys","getNumElementsFromNonIndexedArrays","key","ii","numElements","getNumElementsFromAttributes","getBufferParameter","bytesPerValue","totalElements","createBufferInfoFromArrays","srcBufferInfo","newAttribs","bufferInfo","assign","indices","newIndices","elementType","createBufferFromArray","createBuffersFromArrays","buffers","TRIANGLES","drawBufferInfo","count","instanceCount","drawElementsInstanced","drawElements","drawArraysInstanced","drawArrays","drawObjectList","objectsToDraw","lastUsedProgramInfo","lastUsedBufferInfo","object","active","programInfo","vertexArrayInfo","bindBuffers","useProgram","program","vertexArrayObject","bindVertexArray","programs","setBuffersAndAttributes","setUniforms","uniforms","FRAMEBUFFER","RENDERBUFFER","TEXTURE_2D","DEPTH_COMPONENT","RGBA","DEPTH_COMPONENT24","DEPTH_COMPONENT32F","DEPTH24_STENCIL8","DEPTH32F_STENCIL8","RGBA4","RGB5_A1","RGB565","DEPTH_COMPONENT16","STENCIL_INDEX","STENCIL_INDEX8","DEPTH_STENCIL","COLOR_ATTACHMENT0","DEPTH_ATTACHMENT","STENCIL_ATTACHMENT","DEPTH_STENCIL_ATTACHMENT","CLAMP_TO_EDGE","LINEAR","defaultAttachments","format","min","wrap","attachmentsByFormat","getAttachmentPointForFormat","internalFormat","renderbufferFormats","isRenderbufferFormat","createFramebufferInfo","attachments","width","height","target","fb","createFramebuffer","bindFramebuffer","drawingBufferWidth","drawingBufferHeight","colorAttachmentCount","framebufferInfo","framebuffer","attachmentOptions","attachment","attachmentPoint","createRenderbuffer","bindRenderbuffer","renderbufferStorage","textureOptions","auto","minMag","mag","wrapS","wrapT","textures","createTexture","isRenderbuffer","framebufferRenderbuffer","isTexture","layer","framebufferTextureLayer","level","framebufferTexture2D","push","resizeFramebufferInfo","ndx","resizeTexture","bindFramebufferInfo","viewport","copyNamedProperties","names","src","dst","hasOwnProperty","error","console","warn","t","WebGLRenderbuffer","isShader","WebGLShader","WebGLTexture","isSampler","WebGLSampler","MatType","setDefaultType","ctor","oldType","negate","m","copy","identity","transpose","m00","m01","m02","m03","m10","m11","m12","m13","m20","m21","m22","m23","m30","m31","m32","m33","inverse","tmp_0","tmp_1","tmp_2","tmp_3","tmp_4","tmp_5","tmp_6","tmp_7","tmp_8","tmp_9","tmp_10","tmp_11","tmp_12","tmp_13","tmp_14","tmp_15","tmp_16","tmp_17","tmp_18","tmp_19","tmp_20","tmp_21","tmp_22","tmp_23","t0","t1","t2","t3","d","multiply","a","b","a00","a01","a02","a03","a10","a11","a12","a13","a20","a21","a22","a23","a30","a31","a32","a33","b00","b01","b02","b03","b10","b11","b12","b13","b20","b21","b22","b23","b30","b31","b32","b33","setTranslation","v","getTranslation","v3","create","getAxis","axis","off","setAxis","perspective","fieldOfViewYInRadians","aspect","zNear","zFar","f","Math","tan","PI","rangeInv","ortho","left","right","bottom","top","near","far","frustum","dx","dy","dz","xAxis","yAxis","zAxis","lookAt","eye","up","subtract","cross","translation","translate","v0","v1","v2","rotationX","angleInRadians","c","cos","s","sin","rotateX","rotationY","rotateY","rotationZ","rotateZ","axisRotation","x","y","z","n","sqrt","xx","yy","zz","oneMinusCosine","axisRotate","r00","r01","r02","r10","r11","r12","r20","r21","r22","scaling","scale","transformPoint","transformDirection","transformNormal","mi","attributes","getArray_","getNumComponents_","augmentTypedArray","cursor","arguments","jj","reset","opt_index","defineProperty","get","createAugmentedTypedArray","opt_type","allButIndices","deindexVertices","vertices","newVertices","expandToUnindexed","channel","srcBuffer","dstBuffer","constructor","filter","flattenNormals","normals","normal","numNormals","nax","nay","naz","nbx","nby","nbz","ncx","ncy","ncz","nx","ny","nz","applyFuncToV3Array","matrix","fn","len","tmp","reorientDirections","m4","reorientNormals","reorientPositions","reorientVertices","indexOf","createXYQuadVertices","xOffset","yOffset","position","texcoord","createPlaneVertices","depth","subdivisionsWidth","subdivisionsDepth","numVertices","positions","texcoords","u","numVertsAcross","createSphereVertices","radius","subdivisionsAxis","subdivisionsHeight","opt_startLatitudeInRadians","opt_endLatitudeInRadians","opt_startLongitudeInRadians","opt_endLongitudeInRadians","latRange","longRange","theta","phi","sinTheta","cosTheta","sinPhi","cosPhi","ux","uy","uz","numVertsAround","CUBE_FACE_INDICES","createCubeVertices","k","cornerVertices","faceNormals","uvCoords","faceIndices","uv","createTruncatedConeVertices","bottomRadius","topRadius","radialSubdivisions","verticalSubdivisions","opt_topCap","opt_bottomCap","topCap","bottomCap","extra","vertsAroundEdge","slant","atan2","cosSlant","sinSlant","start","end","ringRadius","expandRLEData","rleData","padding","runLength","element","slice","apply","create3DFVertices","colors","numVerts","color","createCrescentVertices","verticalRadius","outerRadius","innerRadius","thickness","subdivisionsDown","startOffset","endOffset","subdivisionsThick","offsetRange","lerp","createArc","arcRadius","normalMult","normalAdd","uMult","uAdd","uBack","xBack","angle","px","py","pz","add","createSurface","leftArcOffset","rightArcOffset","numVerticesDown","createCylinderVertices","createTorusVertices","bodySubdivisions","startAngle","endAngle","range","radialParts","bodyParts","sliceAngle","sliceSin","ring","ringAngle","xSin","zCos","nextRingIndex","nextSliceIndex","createDiscVertices","divisions","stacks","stackPower","firstIndex","radiusSpan","pointsPerStack","stack","stackRadius","pow","i","randInt","random","makeRandomVertexColors","options","vColors","rand","numVertsPerColor","vertsPerColor","numSets","createBufferFunc","prototype","call","createBufferInfoFunc","arraySpecPropertyNames","copyElements","dstNdx","createArrayOfSameType","srcArray","arraySrc","newArray","newArraySpec","concatVertices","arrayOfArrays","baseName","arrayInfo","getLengthOfCombinedArrays","arraySpec","spec","copyArraysToNewArray","base","baseIndex","newArrays","info","duplicateVertices","create3DFBufferInfo","create3DFBuffers","createCubeBufferInfo","createCubeBuffers","createPlaneBufferInfo","createPlaneBuffers","createSphereBufferInfo","createSphereBuffers","createTruncatedConeBufferInfo","createTruncatedConeBuffers","createXYQuadBufferInfo","createXYQuadBuffers","createCrescentBufferInfo","createCrescentBuffers","createCylinderBufferInfo","createCylinderBuffers","createTorusBufferInfo","createTorusBuffers","createDiscBufferInfo","createDiscBuffers","createCresentBufferInfo","createCresentBuffers","createCresentVertices","getElementById","id","document","TEXTURE0","DYNAMIC_DRAW","UNIFORM_BUFFER","TRANSFORM_FEEDBACK_BUFFER","TRANSFORM_FEEDBACK","COMPILE_STATUS","LINK_STATUS","FRAGMENT_SHADER","VERTEX_SHADER","SEPARATE_ATTRIBS","ACTIVE_UNIFORMS","ACTIVE_ATTRIBUTES","TRANSFORM_FEEDBACK_VARYINGS","ACTIVE_UNIFORM_BLOCKS","UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER","UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER","UNIFORM_BLOCK_DATA_SIZE","UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES","FLOAT_VEC2","FLOAT_VEC3","FLOAT_VEC4","INT_VEC2","INT_VEC3","INT_VEC4","BOOL","BOOL_VEC2","BOOL_VEC3","BOOL_VEC4","FLOAT_MAT2","FLOAT_MAT3","FLOAT_MAT4","SAMPLER_2D","SAMPLER_CUBE","SAMPLER_3D","SAMPLER_2D_SHADOW","FLOAT_MAT2x3","FLOAT_MAT2x4","FLOAT_MAT3x2","FLOAT_MAT3x4","FLOAT_MAT4x2","FLOAT_MAT4x3","SAMPLER_2D_ARRAY","SAMPLER_2D_ARRAY_SHADOW","SAMPLER_CUBE_SHADOW","UNSIGNED_INT_VEC2","UNSIGNED_INT_VEC3","UNSIGNED_INT_VEC4","INT_SAMPLER_2D","INT_SAMPLER_3D","INT_SAMPLER_CUBE","INT_SAMPLER_2D_ARRAY","UNSIGNED_INT_SAMPLER_2D","UNSIGNED_INT_SAMPLER_3D","UNSIGNED_INT_SAMPLER_CUBE","UNSIGNED_INT_SAMPLER_2D_ARRAY","TEXTURE_CUBE_MAP","TEXTURE_3D","TEXTURE_2D_ARRAY","typeMap","getBindPointForSamplerType","bindPoint","floatSetter","location","uniform1f","floatArraySetter","uniform1fv","floatVec2Setter","uniform2fv","floatVec3Setter","uniform3fv","floatVec4Setter","uniform4fv","intSetter","uniform1i","intArraySetter","uniform1iv","intVec2Setter","uniform2iv","intVec3Setter","uniform3iv","intVec4Setter","uniform4iv","uintSetter","uniform1ui","uintArraySetter","uniform1uiv","uintVec2Setter","uniform2uiv","uintVec3Setter","uniform3uiv","uintVec4Setter","uniform4uiv","floatMat2Setter","uniformMatrix2fv","floatMat3Setter","uniformMatrix3fv","floatMat4Setter","uniformMatrix4fv","floatMat23Setter","uniformMatrix2x3fv","floatMat32Setter","uniformMatrix3x2fv","floatMat24Setter","uniformMatrix2x4fv","floatMat42Setter","uniformMatrix4x2fv","floatMat34Setter","uniformMatrix3x4fv","floatMat43Setter","uniformMatrix4x3fv","samplerSetter","unit","utils","isWebGL2","textureOrPair","texture","sampler","activeTexture","bindTexture","bindSampler","samplerArraySetter","units","Int32Array","index","setter","arraySetter","cols","Uint32Array","rows","floatAttribSetter","disableVertexAttribArray","vertexAttrib4fv","vertexAttrib3fv","vertexAttrib2fv","vertexAttrib1fv","enableVertexAttribArray","vertexAttribPointer","vertexAttribDivisor","intAttribSetter","vertexAttrib4iv","vertexAttribIPointer","uintAttribSetter","vertexAttrib4uiv","matAttribSetter","typeInfo","defaultSize","rowOffset","attrTypeMap","errorRE","addLineNumbersWithError","log","lineOffset","matches","matchAll","lineNoToErrorMap","Map","map","lineNo","parseInt","next","msg","substring","split","line","err","join","spaceRE","loadShader","shaderSource","shaderType","opt_errorCallback","errFn","shader","createShader","replace","compileShader","compiled","getShaderParameter","lastError","getShaderInfoLog","glEnumToString","deleteShader","getProgramOptions","opt_attribs","opt_locations","transformFeedbackVaryings","transformFeedbackMode","errorCallback","opt","attribLocations","defaultShaderType","getShaderTypeFromScriptType","scriptType","deleteShaders","shaders","createProgram","progOptions","realShaders","newShaders","elem","text","attachShader","bindAttribLocation","varyings","linkProgram","linked","getProgramParameter","getProgramInfoLog","getShaderSource","SHADER_TYPE","deleteProgram","createShaderFromScript","scriptId","opt_shaderType","shaderScript","createProgramFromScripts","shaderScriptIds","createProgramFromSources","shaderSources","isBuiltIn","startsWith","tokenRE","isDigit","addSetterToUniformTree","fullPath","node","uniformSetters","tokens","tokenNdx","path","token","isArrayIndex","accessor","isLastToken","child","setUniformTree","createUniformSetters","textureUnit","createUniformSetter","uniformInfo","endsWith","toString","uniformTree","numUniforms","getActiveUniform","substr","getUniformLocation","createTransformFeedbackInfo","numVaryings","varying","getTransformFeedbackVarying","bindTransformFeedbackInfo","transformFeedbackInfo","buf","bindBufferRange","bindBufferBase","createTransformFeedback","tf","bindTransformFeedback","createUniformBlockSpecFromProgram","uniformData","uniformIndices","pair","pname","getActiveUniforms","blockSpecs","numUniformBlocks","getActiveUniformBlockName","blockSpec","getUniformBlockIndex","usedByVertexShader","getActiveUniformBlockParameter","usedByFragmentShader","used","arraySuffixRE","pad","createUniformBlockUniformSetter","view","totalRows","row","col","set","createUniformBlockInfoFromProgram","uniformBlockSpec","blockName","ArrayBuffer","uniformBufferIndex","uniformBlockBinding","setters","setterTree","uniformNdx","byteLength","uniformView","asFloat","createUniformBlockInfo","bindUniformBlock","uniformBlockInfo","bufferBindIndex","setUniformBlock","setBlockUniforms","values","tree","prop","actualSetters","numArgs","aNdx","setUniformsAndBindTextures","createAttributeSetters","attribSetters","numAttribs","getActiveAttrib","getAttribLocation","setAttributes","createProgramInfoFromProgram","createProgramInfo","good","source","script","textureColor","crossOrigin","getShared2DContext","s_ctx","createElement","getContext","ALPHA","RGB","LUMINANCE","LUMINANCE_ALPHA","NEAREST","TEXTURE_CUBE_MAP_POSITIVE_X","TEXTURE_CUBE_MAP_NEGATIVE_X","TEXTURE_CUBE_MAP_POSITIVE_Y","TEXTURE_CUBE_MAP_NEGATIVE_Y","TEXTURE_CUBE_MAP_POSITIVE_Z","TEXTURE_CUBE_MAP_NEGATIVE_Z","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","TEXTURE_WRAP_R","TEXTURE_MIN_LOD","TEXTURE_MAX_LOD","TEXTURE_BASE_LEVEL","TEXTURE_MAX_LEVEL","UNPACK_ALIGNMENT","UNPACK_ROW_LENGTH","UNPACK_IMAGE_HEIGHT","UNPACK_SKIP_PIXELS","UNPACK_SKIP_ROWS","UNPACK_SKIP_IMAGES","UNPACK_COLORSPACE_CONVERSION_WEBGL","UNPACK_PREMULTIPLY_ALPHA_WEBGL","UNPACK_FLIP_Y_WEBGL","R8","R8_SNORM","R16F","R32F","R8UI","R8I","RG16UI","RG16I","RG32UI","RG32I","RG8","RG8_SNORM","RG16F","RG32F","RG8UI","RG8I","R16UI","R16I","R32UI","R32I","RGB8","SRGB8","RGB8_SNORM","R11F_G11F_B10F","RGB9_E5","RGB16F","RGB32F","RGB8UI","RGB8I","RGB16UI","RGB16I","RGB32UI","RGB32I","RGBA8","SRGB8_ALPHA8","RGBA8_SNORM","RGB10_A2","RGBA16F","RGBA32F","RGBA8UI","RGBA8I","RGB10_A2UI","RGBA16UI","RGBA16I","RGBA32I","RGBA32UI","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","UNSIGNED_SHORT_5_6_5","HALF_FLOAT","HALF_FLOAT_OES","UNSIGNED_INT_2_10_10_10_REV","UNSIGNED_INT_10F_11F_11F_REV","UNSIGNED_INT_5_9_9_9_REV","FLOAT_32_UNSIGNED_INT_24_8_REV","UNSIGNED_INT_24_8","RG","RG_INTEGER","RED","RED_INTEGER","RGB_INTEGER","RGBA_INTEGER","formatInfo","numColorComponents","s_textureInternalFormatInfo","getTextureInternalFormatInfo","textureFormat","colorRenderable","textureFilterable","bytesPerElement","bytesPerElementMap","getBytesPerElementForInternalFormat","getFormatAndTypeForInternalFormat","isPowerOf2","canGenerateMipmap","canFilter","getNumComponentsForFormat","getTextureTypeForArrayType","defaultType","guessDimensions","setDefaultTextureColor","setPackState","colorspaceConversion","pixelStorei","premultiplyAlpha","flipY","setSkipStateToDefault","setTextureSamplerParameters","parameteriFn","wrapR","minLod","maxLod","baseLevel","maxLevel","setTextureParameters","tex","texParameteri","setSamplerParameters","samplerParameteri","createSampler","createSamplers","samplerOptions","samplers","make1Pixel","setTextureFilteringForSize","generateMipmap","filtering","shouldAutomaticallySetTextureFilteringForSize","getCubeFaceOrder","cubeFaceOrder","getCubeFacesWithNdx","faces","facesWithNdx","face","sort","setTextureFromElement","formatType","imgWidth","imgHeight","slices","nodeName","ctx","canvas","drawImage","texImage2D","createImageBitmap","colorSpaceConversion","then","imageBitmap","smallest","largest","max","xMult","yMult","texImage3D","srcX","srcY","texSubImage3D","noop","urlIsSameOrigin","url","href","hostname","port","protocol","localOrigin","URL","origin","urlOrigin","setToAnonymousIfUndefinedAndURLIsNotSameOrigin","loadImage","callback","img","Image","clearEventHandlers","removeEventListener","onError","onLoad","addEventListener","ImageBitmap","bm","cb","mode","fetch","response","ok","blob","bitmap","setTimeout","e","isTexImageSource","obj","ImageData","HTMLElement","loadAndUseImage","setTextureTo1PixelColor","loadTextureFromUrl","loadCubemapFromUrls","urls","numToLoad","errors","imgs","uploadImg","faceTarget","otherTarget","loadSlicesFromUrls","firstImage","setTextureFromArray","getTypedArrayTypeForGLType","Uint8ClampedArray","dimensions","cbrt","unpackAlignment","elementsPerElement","faceSize","subarray","setEmptyTexture","isAsyncSrc","createTextures","numDownloading","images","callCallbackIfReady","onLoadFn","addExtensionsToContext","setAttributeDefaults_","setTextureDefaults_","prefixRE","addExtensionToContext","extensionName","ext","getExtension","enums","fnSuffix","exec","enumSuffix","isFunc","suffix","origFn","supportedExtensions","create3DContext","context","getWebGLContext","createContext","resizeCanvasToDisplaySize","multiplier","clientWidth","clientHeight","glTypeToTypedArray","tt","Int16Array","CTOR","SharedArrayBuffer","isArrayBufferOrSharedArrayBuffer","texStorage2D","isWebGL1","haveEnumsForType","addEnums","existing","VecType","lerpV","mulScalar","divScalar","dot","lengthSq","distance","distanceSq","lenSq","divide","createVertexArrayInfo","programInfos","vao","createVertexArray","createVAOAndSetAttributes","createVAOFromBufferInfo"],"mappings":"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","file":"twgl-full.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 if(typeof exports === 'object')\n\t\texports[\"twgl\"] = factory();\n\telse\n\t\troot[\"twgl\"] = factory();\n})(typeof self !== 'undefined' ? self : this, 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 = \"./src/twgl-full.js\");\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as typedArrays from './typedarrays.js';\nimport * as helper from './helper.js';\n\nconst STATIC_DRAW                  = 0x88e4;\nconst ARRAY_BUFFER                 = 0x8892;\nconst ELEMENT_ARRAY_BUFFER         = 0x8893;\nconst BUFFER_SIZE                  = 0x8764;\n\nconst BYTE                         = 0x1400;\nconst UNSIGNED_BYTE                = 0x1401;\nconst SHORT                        = 0x1402;\nconst UNSIGNED_SHORT               = 0x1403;\nconst INT                          = 0x1404;\nconst UNSIGNED_INT                 = 0x1405;\nconst FLOAT                        = 0x1406;\n\n/**\n * Low level attribute and buffer related functions\n *\n * You should generally not need to use these functions. They are provided\n * for those cases where you're doing something out of the ordinary\n * and you need lower level access.\n *\n * For backward compatibility they are available at both `twgl.attributes` and `twgl`\n * itself\n *\n * See {@link module:twgl} for core functions\n *\n * @module twgl/attributes\n */\n\n// make sure we don't see a global gl\nconst gl = undefined;  /* eslint-disable-line */\nconst defaults = {\n  attribPrefix: \"\",\n};\n\n/**\n * Sets the default attrib prefix\n *\n * When writing shaders I prefer to name attributes with `a_`, uniforms with `u_` and varyings with `v_`\n * as it makes it clear where they came from. But, when building geometry I prefer using un-prefixed names.\n *\n * In other words I'll create arrays of geometry like this\n *\n *     var arrays = {\n *       position: ...\n *       normal: ...\n *       texcoord: ...\n *     };\n *\n * But need those mapped to attributes and my attributes start with `a_`.\n *\n * @deprecated see {@link module:twgl.setDefaults}\n * @param {string} prefix prefix for attribs\n * @memberOf module:twgl/attributes\n */\nfunction setAttributePrefix(prefix) {\n  defaults.attribPrefix = prefix;\n}\n\nfunction setDefaults(newDefaults) {\n  helper.copyExistingProperties(newDefaults, defaults);\n}\n\nfunction setBufferFromTypedArray(gl, type, buffer, array, drawType) {\n  gl.bindBuffer(type, buffer);\n  gl.bufferData(type, array, drawType || STATIC_DRAW);\n}\n\n/**\n * Given typed array creates a WebGLBuffer and copies the typed array\n * into it.\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @param {ArrayBuffer|SharedArrayBuffer|ArrayBufferView|WebGLBuffer} typedArray the typed array. Note: If a WebGLBuffer is passed in it will just be returned. No action will be taken\n * @param {number} [type] the GL bind type for the buffer. Default = `gl.ARRAY_BUFFER`.\n * @param {number} [drawType] the GL draw type for the buffer. Default = 'gl.STATIC_DRAW`.\n * @return {WebGLBuffer} the created WebGLBuffer\n * @memberOf module:twgl/attributes\n */\nfunction createBufferFromTypedArray(gl, typedArray, type, drawType) {\n  if (helper.isBuffer(gl, typedArray)) {\n    return typedArray;\n  }\n  type = type || ARRAY_BUFFER;\n  const buffer = gl.createBuffer();\n  setBufferFromTypedArray(gl, type, buffer, typedArray, drawType);\n  return buffer;\n}\n\nfunction isIndices(name) {\n  return name === \"indices\";\n}\n\n// This is really just a guess. Though I can't really imagine using\n// anything else? Maybe for some compression?\nfunction getNormalizationForTypedArray(typedArray) {\n  if (typedArray instanceof Int8Array)    { return true; }  // eslint-disable-line\n  if (typedArray instanceof Uint8Array)   { return true; }  // eslint-disable-line\n  return false;\n}\n\n// This is really just a guess. Though I can't really imagine using\n// anything else? Maybe for some compression?\nfunction getNormalizationForTypedArrayType(typedArrayType) {\n  if (typedArrayType === Int8Array)    { return true; }  // eslint-disable-line\n  if (typedArrayType === Uint8Array)   { return true; }  // eslint-disable-line\n  return false;\n}\n\nfunction getArray(array) {\n  return array.length ? array : array.data;\n}\n\nconst texcoordRE = /coord|texture/i;\nconst colorRE = /color|colour/i;\n\nfunction guessNumComponentsFromName(name, length) {\n  let numComponents;\n  if (texcoordRE.test(name)) {\n    numComponents = 2;\n  } else if (colorRE.test(name)) {\n    numComponents = 4;\n  } else {\n    numComponents = 3;  // position, normals, indices ...\n  }\n\n  if (length % numComponents > 0) {\n    throw new Error(`Can not guess numComponents for attribute '${name}'. Tried ${numComponents} but ${length} values is not evenly divisible by ${numComponents}. You should specify it.`);\n  }\n\n  return numComponents;\n}\n\nfunction getNumComponents(array, arrayName) {\n  return array.numComponents || array.size || guessNumComponentsFromName(arrayName, getArray(array).length);\n}\n\nfunction makeTypedArray(array, name) {\n  if (typedArrays.isArrayBuffer(array)) {\n    return array;\n  }\n\n  if (typedArrays.isArrayBuffer(array.data)) {\n    return array.data;\n  }\n\n  if (Array.isArray(array)) {\n    array = {\n      data: array,\n    };\n  }\n\n  let Type = array.type;\n  if (!Type) {\n    if (isIndices(name)) {\n      Type = Uint16Array;\n    } else {\n      Type = Float32Array;\n    }\n  }\n  return new Type(array.data);\n}\n\n/**\n * The info for an attribute. This is effectively just the arguments to `gl.vertexAttribPointer` plus the WebGLBuffer\n * for the attribute.\n *\n * @typedef {Object} AttribInfo\n * @property {number[]|ArrayBufferView} [value] a constant value for the attribute. Note: if this is set the attribute will be\n *    disabled and set to this constant value and all other values will be ignored.\n * @property {number} [numComponents] the number of components for this attribute.\n * @property {number} [size] synonym for `numComponents`.\n * @property {number} [type] the type of the attribute (eg. `gl.FLOAT`, `gl.UNSIGNED_BYTE`, etc...) Default = `gl.FLOAT`\n * @property {boolean} [normalize] whether or not to normalize the data. Default = false\n * @property {number} [offset] offset into buffer in bytes. Default = 0\n * @property {number} [stride] the stride in bytes per element. Default = 0\n * @property {number} [divisor] the divisor in instances. Default = undefined. Note: undefined = don't call gl.vertexAttribDivisor\n *    where as anything else = do call it with this value\n * @property {WebGLBuffer} buffer the buffer that contains the data for this attribute\n * @property {number} [drawType] the draw type passed to gl.bufferData. Default = gl.STATIC_DRAW\n * @memberOf module:twgl\n */\n\n/**\n * Use this type of array spec when TWGL can't guess the type or number of components of an array\n * @typedef {Object} FullArraySpec\n * @property {number[]|ArrayBufferView} [value] a constant value for the attribute. Note: if this is set the attribute will be\n *    disabled and set to this constant value and all other values will be ignored.\n * @property {(number|number[]|ArrayBufferView)} data The data of the array. A number alone becomes the number of elements of type.\n * @property {number} [numComponents] number of components for `vertexAttribPointer`. Default is based on the name of the array.\n *    If `coord` is in the name assumes `numComponents = 2`.\n *    If `color` is in the name assumes `numComponents = 4`.\n *    otherwise assumes `numComponents = 3`\n * @property {constructor} [type] type. This is only used if `data` is a JavaScript array. It is the constructor for the typedarray. (eg. `Uint8Array`).\n * For example if you want colors in a `Uint8Array` you might have a `FullArraySpec` like `{ type: Uint8Array, data: [255,0,255,255, ...], }`.\n * @property {number} [size] synonym for `numComponents`.\n * @property {boolean} [normalize] normalize for `vertexAttribPointer`. Default is true if type is `Int8Array` or `Uint8Array` otherwise false.\n * @property {number} [stride] stride for `vertexAttribPointer`. Default = 0\n * @property {number} [offset] offset for `vertexAttribPointer`. Default = 0\n * @property {number} [divisor] divisor for `vertexAttribDivisor`. Default = undefined. Note: undefined = don't call gl.vertexAttribDivisor\n *    where as anything else = do call it with this value\n * @property {string} [attrib] name of attribute this array maps to. Defaults to same name as array prefixed by the default attribPrefix.\n * @property {string} [name] synonym for `attrib`.\n * @property {string} [attribName] synonym for `attrib`.\n * @property {WebGLBuffer} [buffer] Buffer to use for this attribute. This lets you use your own buffer\n *    but you will need to supply `numComponents` and `type`. You can effectively pass an `AttribInfo`\n *    to provide this. Example:\n *\n *         const bufferInfo1 = twgl.createBufferInfoFromArrays(gl, {\n *           position: [1, 2, 3, ... ],\n *         });\n *         const bufferInfo2 = twgl.createBufferInfoFromArrays(gl, {\n *           position: bufferInfo1.attribs.position,  // use the same buffer from bufferInfo1\n *         });\n *\n * @memberOf module:twgl\n */\n\n/**\n * An individual array in {@link module:twgl.Arrays}\n *\n * When passed to {@link module:twgl.createBufferInfoFromArrays} if an ArraySpec is `number[]` or `ArrayBufferView`\n * the types will be guessed based on the name. `indices` will be `Uint16Array`, everything else will\n * be `Float32Array`. If an ArraySpec is a number it's the number of floats for an empty (zeroed) buffer.\n *\n * @typedef {(number|number[]|ArrayBufferView|module:twgl.FullArraySpec)} ArraySpec\n * @memberOf module:twgl\n */\n\n/**\n * This is a JavaScript object of arrays by name. The names should match your shader's attributes. If your\n * attributes have a common prefix you can specify it by calling {@link module:twgl.setAttributePrefix}.\n *\n *     Bare JavaScript Arrays\n *\n *         var arrays = {\n *            position: [-1, 1, 0],\n *            normal: [0, 1, 0],\n *            ...\n *         }\n *\n *     Bare TypedArrays\n *\n *         var arrays = {\n *            position: new Float32Array([-1, 1, 0]),\n *            color: new Uint8Array([255, 128, 64, 255]),\n *            ...\n *         }\n *\n * *   Will guess at `numComponents` if not specified based on name.\n *\n *     If `coord` is in the name assumes `numComponents = 2`\n *\n *     If `color` is in the name assumes `numComponents = 4`\n *\n *     otherwise assumes `numComponents = 3`\n *\n * Objects with various fields. See {@link module:twgl.FullArraySpec}.\n *\n *     var arrays = {\n *       position: { numComponents: 3, data: [0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0], },\n *       texcoord: { numComponents: 2, data: [0, 0, 0, 1, 1, 0, 1, 1],                 },\n *       normal:   { numComponents: 3, data: [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1],     },\n *       indices:  { numComponents: 3, data: [0, 1, 2, 1, 2, 3],                       },\n *     };\n *\n * @typedef {Object.<string, module:twgl.ArraySpec>} Arrays\n * @memberOf module:twgl\n */\n\n\n/**\n * Creates a set of attribute data and WebGLBuffers from set of arrays\n *\n * Given\n *\n *      var arrays = {\n *        position: { numComponents: 3, data: [0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0], },\n *        texcoord: { numComponents: 2, data: [0, 0, 0, 1, 1, 0, 1, 1],                 },\n *        normal:   { numComponents: 3, data: [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1],     },\n *        color:    { numComponents: 4, data: [255, 255, 255, 255, 255, 0, 0, 255, 0, 0, 255, 255], type: Uint8Array, },\n *        indices:  { numComponents: 3, data: [0, 1, 2, 1, 2, 3],                       },\n *      };\n *\n * returns something like\n *\n *      var attribs = {\n *        position: { numComponents: 3, type: gl.FLOAT,         normalize: false, buffer: WebGLBuffer, },\n *        texcoord: { numComponents: 2, type: gl.FLOAT,         normalize: false, buffer: WebGLBuffer, },\n *        normal:   { numComponents: 3, type: gl.FLOAT,         normalize: false, buffer: WebGLBuffer, },\n *        color:    { numComponents: 4, type: gl.UNSIGNED_BYTE, normalize: true,  buffer: WebGLBuffer, },\n *      };\n *\n * notes:\n *\n * *   Arrays can take various forms\n *\n *     Bare JavaScript Arrays\n *\n *         var arrays = {\n *            position: [-1, 1, 0],\n *            normal: [0, 1, 0],\n *            ...\n *         }\n *\n *     Bare TypedArrays\n *\n *         var arrays = {\n *            position: new Float32Array([-1, 1, 0]),\n *            color: new Uint8Array([255, 128, 64, 255]),\n *            ...\n *         }\n *\n * *   Will guess at `numComponents` if not specified based on name.\n *\n *     If `coord` is in the name assumes `numComponents = 2`\n *\n *     If `color` is in the name assumes `numComponents = 4`\n *\n *     otherwise assumes `numComponents = 3`\n *\n * @param {WebGLRenderingContext} gl The webgl rendering context.\n * @param {module:twgl.Arrays} arrays The arrays\n * @param {module:twgl.BufferInfo} [srcBufferInfo] a BufferInfo to copy from\n *   This lets you share buffers. Any arrays you supply will override\n *   the buffers from srcBufferInfo.\n * @return {Object.<string, module:twgl.AttribInfo>} the attribs\n * @memberOf module:twgl/attributes\n */\nfunction createAttribsFromArrays(gl, arrays) {\n  const attribs = {};\n  Object.keys(arrays).forEach(function(arrayName) {\n    if (!isIndices(arrayName)) {\n      const array = arrays[arrayName];\n      const attribName = array.attrib || array.name || array.attribName || (defaults.attribPrefix + arrayName);\n      if (array.value) {\n        if (!Array.isArray(array.value) && !typedArrays.isArrayBuffer(array.value)) {\n          throw new Error('array.value is not array or typedarray');\n        }\n        attribs[attribName] = {\n          value: array.value,\n        };\n      } else {\n        let buffer;\n        let type;\n        let normalization;\n        let numComponents;\n        if (array.buffer && array.buffer instanceof WebGLBuffer) {\n          buffer = array.buffer;\n          numComponents = array.numComponents || array.size;\n          type = array.type;\n          normalization = array.normalize;\n        } else if (typeof array === \"number\" || typeof array.data === \"number\") {\n          const numValues = array.data || array;\n          const arrayType = array.type || Float32Array;\n          const numBytes = numValues * arrayType.BYTES_PER_ELEMENT;\n          type = typedArrays.getGLTypeForTypedArrayType(arrayType);\n          normalization = array.normalize !== undefined ? array.normalize : getNormalizationForTypedArrayType(arrayType);\n          numComponents = array.numComponents || array.size || guessNumComponentsFromName(arrayName, numValues);\n          buffer = gl.createBuffer();\n          gl.bindBuffer(ARRAY_BUFFER, buffer);\n          gl.bufferData(ARRAY_BUFFER, numBytes, array.drawType || STATIC_DRAW);\n        } else {\n          const typedArray = makeTypedArray(array, arrayName);\n          buffer = createBufferFromTypedArray(gl, typedArray, undefined, array.drawType);\n          type = typedArrays.getGLTypeForTypedArray(typedArray);\n          normalization = array.normalize !== undefined ? array.normalize : getNormalizationForTypedArray(typedArray);\n          numComponents = getNumComponents(array, arrayName);\n        }\n        attribs[attribName] = {\n          buffer:        buffer,\n          numComponents: numComponents,\n          type:          type,\n          normalize:     normalization,\n          stride:        array.stride || 0,\n          offset:        array.offset || 0,\n          divisor:       array.divisor === undefined ? undefined : array.divisor,\n          drawType:      array.drawType,\n        };\n      }\n    }\n  });\n  gl.bindBuffer(ARRAY_BUFFER, null);\n  return attribs;\n}\n\n/**\n * Sets the contents of a buffer attached to an attribInfo\n *\n * This is helper function to dynamically update a buffer.\n *\n * Let's say you make a bufferInfo\n *\n *     var arrays = {\n *        position: new Float32Array([0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0]),\n *        texcoord: new Float32Array([0, 0, 0, 1, 1, 0, 1, 1]),\n *        normal:   new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]),\n *        indices:  new Uint16Array([0, 1, 2, 1, 2, 3]),\n *     };\n *     var bufferInfo = twgl.createBufferInfoFromArrays(gl, arrays);\n *\n *  And you want to dynamically update the positions. You could do this\n *\n *     // assuming arrays.position has already been updated with new data.\n *     twgl.setAttribInfoBufferFromArray(gl, bufferInfo.attribs.position, arrays.position);\n *\n * @param {WebGLRenderingContext} gl\n * @param {AttribInfo} attribInfo The attribInfo who's buffer contents to set. NOTE: If you have an attribute prefix\n *   the name of the attribute will include the prefix.\n * @param {ArraySpec} array Note: it is arguably inefficient to pass in anything but a typed array because anything\n *    else will have to be converted to a typed array before it can be used by WebGL. During init time that\n *    inefficiency is usually not important but if you're updating data dynamically best to be efficient.\n * @param {number} [offset] an optional offset into the buffer. This is only an offset into the WebGL buffer\n *    not the array. To pass in an offset into the array itself use a typed array and create an `ArrayBufferView`\n *    for the portion of the array you want to use.\n *\n *        var someArray = new Float32Array(1000); // an array with 1000 floats\n *        var someSubArray = new Float32Array(someArray.buffer, offsetInBytes, sizeInUnits); // a view into someArray\n *\n *    Now you can pass `someSubArray` into setAttribInfoBufferFromArray`\n * @memberOf module:twgl/attributes\n */\nfunction setAttribInfoBufferFromArray(gl, attribInfo, array, offset) {\n  array = makeTypedArray(array);\n  if (offset !== undefined) {\n    gl.bindBuffer(ARRAY_BUFFER, attribInfo.buffer);\n    gl.bufferSubData(ARRAY_BUFFER, offset, array);\n  } else {\n    setBufferFromTypedArray(gl, ARRAY_BUFFER, attribInfo.buffer, array, attribInfo.drawType);\n  }\n}\n\nfunction getBytesPerValueForGLType(gl, type) {\n  if (type === BYTE)           return 1;  // eslint-disable-line\n  if (type === UNSIGNED_BYTE)  return 1;  // eslint-disable-line\n  if (type === SHORT)          return 2;  // eslint-disable-line\n  if (type === UNSIGNED_SHORT) return 2;  // eslint-disable-line\n  if (type === INT)            return 4;  // eslint-disable-line\n  if (type === UNSIGNED_INT)   return 4;  // eslint-disable-line\n  if (type === FLOAT)          return 4;  // eslint-disable-line\n  return 0;\n}\n\n// Tries to get the number of elements from a set of arrays.\nconst positionKeys = ['position', 'positions', 'a_position'];\nfunction getNumElementsFromNonIndexedArrays(arrays) {\n  let key;\n  let ii;\n  for (ii = 0; ii < positionKeys.length; ++ii) {\n    key = positionKeys[ii];\n    if (key in arrays) {\n      break;\n    }\n  }\n  if (ii === positionKeys.length) {\n    key = Object.keys(arrays)[0];\n  }\n  const array = arrays[key];\n  const length = getArray(array).length;\n  const numComponents = getNumComponents(array, key);\n  const numElements = length / numComponents;\n  if (length % numComponents > 0) {\n    throw new Error(`numComponents ${numComponents} not correct for length ${length}`);\n  }\n  return numElements;\n}\n\nfunction getNumElementsFromAttributes(gl, attribs) {\n  let key;\n  let ii;\n  for (ii = 0; ii < positionKeys.length; ++ii) {\n    key = positionKeys[ii];\n    if (key in attribs) {\n      break;\n    }\n    key = defaults.attribPrefix + key;\n    if (key in attribs) {\n      break;\n    }\n  }\n  if (ii === positionKeys.length) {\n    key = Object.keys(attribs)[0];\n  }\n  const attrib = attribs[key];\n  gl.bindBuffer(ARRAY_BUFFER, attrib.buffer);\n  const numBytes = gl.getBufferParameter(ARRAY_BUFFER, BUFFER_SIZE);\n  gl.bindBuffer(ARRAY_BUFFER, null);\n\n  const bytesPerValue = getBytesPerValueForGLType(gl, attrib.type);\n  const totalElements = numBytes / bytesPerValue;\n  const numComponents = attrib.numComponents || attrib.size;\n  // TODO: check stride\n  const numElements = totalElements / numComponents;\n  if (numElements % 1 !== 0) {\n    throw new Error(`numComponents ${numComponents} not correct for length ${length}`);\n  }\n  return numElements;\n}\n\n/**\n * @typedef {Object} BufferInfo\n * @property {number} numElements The number of elements to pass to `gl.drawArrays` or `gl.drawElements`.\n * @property {number} [elementType] The type of indices `UNSIGNED_BYTE`, `UNSIGNED_SHORT` etc..\n * @property {WebGLBuffer} [indices] The indices `ELEMENT_ARRAY_BUFFER` if any indices exist.\n * @property {Object.<string, module:twgl.AttribInfo>} [attribs] The attribs appropriate to call `setAttributes`\n * @memberOf module:twgl\n */\n\n/**\n * Creates a BufferInfo from an object of arrays.\n *\n * This can be passed to {@link module:twgl.setBuffersAndAttributes} and to\n * {@link module:twgl:drawBufferInfo}.\n *\n * Given an object like\n *\n *     var arrays = {\n *       position: { numComponents: 3, data: [0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0], },\n *       texcoord: { numComponents: 2, data: [0, 0, 0, 1, 1, 0, 1, 1],                 },\n *       normal:   { numComponents: 3, data: [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1],     },\n *       indices:  { numComponents: 3, data: [0, 1, 2, 1, 2, 3],                       },\n *     };\n *\n *  Creates an BufferInfo like this\n *\n *     bufferInfo = {\n *       numElements: 4,        // or whatever the number of elements is\n *       indices: WebGLBuffer,  // this property will not exist if there are no indices\n *       attribs: {\n *         position: { buffer: WebGLBuffer, numComponents: 3, },\n *         normal:   { buffer: WebGLBuffer, numComponents: 3, },\n *         texcoord: { buffer: WebGLBuffer, numComponents: 2, },\n *       },\n *     };\n *\n *  The properties of arrays can be JavaScript arrays in which case the number of components\n *  will be guessed.\n *\n *     var arrays = {\n *        position: [0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0],\n *        texcoord: [0, 0, 0, 1, 1, 0, 1, 1],\n *        normal:   [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1],\n *        indices:  [0, 1, 2, 1, 2, 3],\n *     };\n *\n *  They can also be TypedArrays\n *\n *     var arrays = {\n *        position: new Float32Array([0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0]),\n *        texcoord: new Float32Array([0, 0, 0, 1, 1, 0, 1, 1]),\n *        normal:   new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]),\n *        indices:  new Uint16Array([0, 1, 2, 1, 2, 3]),\n *     };\n *\n *  Or AugmentedTypedArrays\n *\n *     var positions = createAugmentedTypedArray(3, 4);\n *     var texcoords = createAugmentedTypedArray(2, 4);\n *     var normals   = createAugmentedTypedArray(3, 4);\n *     var indices   = createAugmentedTypedArray(3, 2, Uint16Array);\n *\n *     positions.push([0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0]);\n *     texcoords.push([0, 0, 0, 1, 1, 0, 1, 1]);\n *     normals.push([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]);\n *     indices.push([0, 1, 2, 1, 2, 3]);\n *\n *     var arrays = {\n *        position: positions,\n *        texcoord: texcoords,\n *        normal:   normals,\n *        indices:  indices,\n *     };\n *\n * For the last example it is equivalent to\n *\n *     var bufferInfo = {\n *       attribs: {\n *         position: { numComponents: 3, buffer: gl.createBuffer(), },\n *         texcoord: { numComponents: 2, buffer: gl.createBuffer(), },\n *         normal: { numComponents: 3, buffer: gl.createBuffer(), },\n *       },\n *       indices: gl.createBuffer(),\n *       numElements: 6,\n *     };\n *\n *     gl.bindBuffer(gl.ARRAY_BUFFER, bufferInfo.attribs.position.buffer);\n *     gl.bufferData(gl.ARRAY_BUFFER, arrays.position, gl.STATIC_DRAW);\n *     gl.bindBuffer(gl.ARRAY_BUFFER, bufferInfo.attribs.texcoord.buffer);\n *     gl.bufferData(gl.ARRAY_BUFFER, arrays.texcoord, gl.STATIC_DRAW);\n *     gl.bindBuffer(gl.ARRAY_BUFFER, bufferInfo.attribs.normal.buffer);\n *     gl.bufferData(gl.ARRAY_BUFFER, arrays.normal, gl.STATIC_DRAW);\n *     gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, bufferInfo.indices);\n *     gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, arrays.indices, gl.STATIC_DRAW);\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @param {module:twgl.Arrays} arrays Your data\n * @param {module:twgl.BufferInfo} [srcBufferInfo] An existing\n *        buffer info to start from. WebGLBuffers etc specified\n *        in the srcBufferInfo will be used in a new BufferInfo\n *        with any arrays specified overriding the ones in\n *        srcBufferInfo.\n * @return {module:twgl.BufferInfo} A BufferInfo\n * @memberOf module:twgl/attributes\n */\nfunction createBufferInfoFromArrays(gl, arrays, srcBufferInfo) {\n  const newAttribs = createAttribsFromArrays(gl, arrays);\n  const bufferInfo = Object.assign({}, srcBufferInfo ? srcBufferInfo : {});\n  bufferInfo.attribs = Object.assign({}, srcBufferInfo ? srcBufferInfo.attribs : {}, newAttribs);\n  const indices = arrays.indices;\n  if (indices) {\n    const newIndices = makeTypedArray(indices, \"indices\");\n    bufferInfo.indices = createBufferFromTypedArray(gl, newIndices, ELEMENT_ARRAY_BUFFER);\n    bufferInfo.numElements = newIndices.length;\n    bufferInfo.elementType = typedArrays.getGLTypeForTypedArray(newIndices);\n  } else if (!bufferInfo.numElements) {\n    bufferInfo.numElements = getNumElementsFromAttributes(gl, bufferInfo.attribs);\n  }\n\n  return bufferInfo;\n}\n\n/**\n * Creates a buffer from an array, typed array, or array spec\n *\n * Given something like this\n *\n *     [1, 2, 3],\n *\n * or\n *\n *     new Uint16Array([1,2,3]);\n *\n * or\n *\n *     {\n *        data: [1, 2, 3],\n *        type: Uint8Array,\n *     }\n *\n * returns a WebGLBuffer that contains the given data.\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext.\n * @param {module:twgl.ArraySpec} array an array, typed array, or array spec.\n * @param {string} arrayName name of array. Used to guess the type if type can not be derived otherwise.\n * @return {WebGLBuffer} a WebGLBuffer containing the data in array.\n * @memberOf module:twgl/attributes\n */\nfunction createBufferFromArray(gl, array, arrayName) {\n  const type = arrayName === \"indices\" ? ELEMENT_ARRAY_BUFFER : ARRAY_BUFFER;\n  const typedArray = makeTypedArray(array, arrayName);\n  return createBufferFromTypedArray(gl, typedArray, type);\n}\n\n/**\n * Creates buffers from arrays or typed arrays\n *\n * Given something like this\n *\n *     var arrays = {\n *        positions: [1, 2, 3],\n *        normals: [0, 0, 1],\n *     }\n *\n * returns something like\n *\n *     buffers = {\n *       positions: WebGLBuffer,\n *       normals: WebGLBuffer,\n *     }\n *\n * If the buffer is named 'indices' it will be made an ELEMENT_ARRAY_BUFFER.\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext.\n * @param {module:twgl.Arrays} arrays\n * @return {Object<string, WebGLBuffer>} returns an object with one WebGLBuffer per array\n * @memberOf module:twgl/attributes\n */\nfunction createBuffersFromArrays(gl, arrays) {\n  const buffers = { };\n  Object.keys(arrays).forEach(function(key) {\n    buffers[key] = createBufferFromArray(gl, arrays[key], key);\n  });\n\n  // Ugh!\n  if (arrays.indices) {\n    buffers.numElements = arrays.indices.length;\n    buffers.elementType = typedArrays.getGLTypeForTypedArray(makeTypedArray(arrays.indices), 'indices');\n  } else {\n    buffers.numElements = getNumElementsFromNonIndexedArrays(arrays);\n  }\n\n  return buffers;\n}\n\nexport {\n  createAttribsFromArrays,\n  createBuffersFromArrays,\n  createBufferFromArray,\n  createBufferFromTypedArray,\n  createBufferInfoFromArrays,\n  setAttribInfoBufferFromArray,\n\n  setAttributePrefix,\n\n  setDefaults as setAttributeDefaults_,\n  getNumComponents as getNumComponents_,\n  getArray as getArray_,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as programs from './programs.js';\n\nconst TRIANGLES                      = 0x0004;\nconst UNSIGNED_SHORT                 = 0x1403;\n\n/**\n * Drawing related functions\n *\n * For backward compatibility they are available at both `twgl.draw` and `twgl`\n * itself\n *\n * See {@link module:twgl} for core functions\n *\n * @module twgl/draw\n */\n\n/**\n * Calls `gl.drawElements` or `gl.drawArrays`, whichever is appropriate\n *\n * normally you'd call `gl.drawElements` or `gl.drawArrays` yourself\n * but calling this means if you switch from indexed data to non-indexed\n * data you don't have to remember to update your draw call.\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @param {(module:twgl.BufferInfo|module:twgl.VertexArrayInfo)} bufferInfo A BufferInfo as returned from {@link module:twgl.createBufferInfoFromArrays} or\n *   a VertexArrayInfo as returned from {@link module:twgl.createVertexArrayInfo}\n * @param {number} [type] eg (gl.TRIANGLES, gl.LINES, gl.POINTS, gl.TRIANGLE_STRIP, ...). Defaults to `gl.TRIANGLES`\n * @param {number} [count] An optional count. Defaults to bufferInfo.numElements\n * @param {number} [offset] An optional offset. Defaults to 0.\n * @param {number} [instanceCount] An optional instanceCount. if set then `drawArraysInstanced` or `drawElementsInstanced` will be called\n * @memberOf module:twgl/draw\n */\nfunction drawBufferInfo(gl, bufferInfo, type, count, offset, instanceCount) {\n  type = type === undefined ? TRIANGLES : type;\n  const indices = bufferInfo.indices;\n  const elementType = bufferInfo.elementType;\n  const numElements = count === undefined ? bufferInfo.numElements : count;\n  offset = offset === undefined ? 0 : offset;\n  if (elementType || indices) {\n    if (instanceCount !== undefined) {\n      gl.drawElementsInstanced(type, numElements, elementType === undefined ? UNSIGNED_SHORT : bufferInfo.elementType, offset, instanceCount);\n    } else {\n      gl.drawElements(type, numElements, elementType === undefined ? UNSIGNED_SHORT : bufferInfo.elementType, offset);\n    }\n  } else {\n    if (instanceCount !== undefined) {\n      gl.drawArraysInstanced(type, offset, numElements, instanceCount);\n    } else {\n      gl.drawArrays(type, offset, numElements);\n    }\n  }\n}\n\n/**\n * A DrawObject is useful for putting objects in to an array and passing them to {@link module:twgl.drawObjectList}.\n *\n * You need either a `BufferInfo` or a `VertexArrayInfo`.\n *\n * @typedef {Object} DrawObject\n * @property {boolean} [active] whether or not to draw. Default = `true` (must be `false` to be not true). In other words `undefined` = `true`\n * @property {number} [type] type to draw eg. `gl.TRIANGLES`, `gl.LINES`, etc...\n * @property {module:twgl.ProgramInfo} programInfo A ProgramInfo as returned from {@link module:twgl.createProgramInfo}\n * @property {module:twgl.BufferInfo} [bufferInfo] A BufferInfo as returned from {@link module:twgl.createBufferInfoFromArrays}\n * @property {module:twgl.VertexArrayInfo} [vertexArrayInfo] A VertexArrayInfo as returned from {@link module:twgl.createVertexArrayInfo}\n * @property {Object<string, ?>} uniforms The values for the uniforms.\n *   You can pass multiple objects by putting them in an array. For example\n *\n *     var sharedUniforms = {\n *       u_fogNear: 10,\n *       u_projection: ...\n *       ...\n *     };\n *\n *     var localUniforms = {\n *       u_world: ...\n *       u_diffuseColor: ...\n *     };\n *\n *     var drawObj = {\n *       ...\n *       uniforms: [sharedUniforms, localUniforms],\n *     };\n *\n * @property {number} [offset] the offset to pass to `gl.drawArrays` or `gl.drawElements`. Defaults to 0.\n * @property {number} [count] the count to pass to `gl.drawArrays` or `gl.drawElements`. Defaults to bufferInfo.numElements.\n * @property {number} [instanceCount] the number of instances. Defaults to undefined.\n * @memberOf module:twgl\n */\n\n/**\n * Draws a list of objects\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @param {DrawObject[]} objectsToDraw an array of objects to draw.\n * @memberOf module:twgl/draw\n */\nfunction drawObjectList(gl, objectsToDraw) {\n  let lastUsedProgramInfo = null;\n  let lastUsedBufferInfo = null;\n\n  objectsToDraw.forEach(function(object) {\n    if (object.active === false) {\n      return;\n    }\n\n    const programInfo = object.programInfo;\n    const bufferInfo = object.vertexArrayInfo || object.bufferInfo;\n    let bindBuffers = false;\n    const type = object.type === undefined ? TRIANGLES : object.type;\n\n    if (programInfo !== lastUsedProgramInfo) {\n      lastUsedProgramInfo = programInfo;\n      gl.useProgram(programInfo.program);\n\n      // We have to rebind buffers when changing programs because we\n      // only bind buffers the program uses. So if 2 programs use the same\n      // bufferInfo but the 1st one uses only positions the when the\n      // we switch to the 2nd one some of the attributes will not be on.\n      bindBuffers = true;\n    }\n\n    // Setup all the needed attributes.\n    if (bindBuffers || bufferInfo !== lastUsedBufferInfo) {\n      if (lastUsedBufferInfo && lastUsedBufferInfo.vertexArrayObject && !bufferInfo.vertexArrayObject) {\n        gl.bindVertexArray(null);\n      }\n      lastUsedBufferInfo = bufferInfo;\n      programs.setBuffersAndAttributes(gl, programInfo, bufferInfo);\n    }\n\n    // Set the uniforms.\n    programs.setUniforms(programInfo, object.uniforms);\n\n    // Draw\n    drawBufferInfo(gl, bufferInfo, type, object.count, object.offset, object.instanceCount);\n  });\n\n  if (lastUsedBufferInfo && lastUsedBufferInfo.vertexArrayObject) {\n    gl.bindVertexArray(null);\n  }\n}\n\nexport {\n  drawBufferInfo,\n  drawObjectList,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as textures from './textures.js';\nimport * as helper from './helper.js';\n\n/**\n * Framebuffer related functions\n *\n * For backward compatibility they are available at both `twgl.framebuffer` and `twgl`\n * itself\n *\n * See {@link module:twgl} for core functions\n *\n * @module twgl/framebuffers\n */\n\n// make sure we don't see a global gl\nconst gl = undefined;  /* eslint-disable-line */\n\nconst FRAMEBUFFER                    = 0x8d40;\nconst RENDERBUFFER                   = 0x8d41;\nconst TEXTURE_2D                     = 0x0de1;\n\nconst UNSIGNED_BYTE                  = 0x1401;\n\n/* PixelFormat */\nconst DEPTH_COMPONENT                = 0x1902;\nconst RGBA                           = 0x1908;\nconst DEPTH_COMPONENT24              = 0x81a6;\nconst DEPTH_COMPONENT32F             = 0x8cac;\nconst DEPTH24_STENCIL8               = 0x88f0;\nconst DEPTH32F_STENCIL8              = 0x8cad;\n\n/* Framebuffer Object. */\nconst RGBA4                          = 0x8056;\nconst RGB5_A1                        = 0x8057;\nconst RGB565                         = 0x8D62;\nconst DEPTH_COMPONENT16              = 0x81A5;\nconst STENCIL_INDEX                  = 0x1901;\nconst STENCIL_INDEX8                 = 0x8D48;\nconst DEPTH_STENCIL                  = 0x84F9;\nconst COLOR_ATTACHMENT0              = 0x8CE0;\nconst DEPTH_ATTACHMENT               = 0x8D00;\nconst STENCIL_ATTACHMENT             = 0x8D20;\nconst DEPTH_STENCIL_ATTACHMENT       = 0x821A;\n\n/* TextureWrapMode */\nconst CLAMP_TO_EDGE                  = 0x812F;\n\n/* TextureMagFilter */\nconst LINEAR                         = 0x2601;\n\n/**\n * The options for a framebuffer attachment.\n *\n * Note: For a `format` that is a texture include all the texture\n * options from {@link module:twgl.TextureOptions} for example\n * `min`, `mag`, `clamp`, etc... Note that unlike {@link module:twgl.TextureOptions}\n * `auto` defaults to `false` for attachment textures but `min` and `mag` default\n * to `gl.LINEAR` and `wrap` defaults to `CLAMP_TO_EDGE`\n *\n * @typedef {Object} AttachmentOptions\n * @property {number} [attachmentPoint] The attachment point. Defaults\n *   to `gl.COLOR_ATTACHMENT0 + ndx` unless type is a depth or stencil type\n *   then it's gl.DEPTH_ATTACHMENT or `gl.DEPTH_STENCIL_ATTACHMENT` depending\n *   on the format or attachment type.\n * @property {number} [format] The format. If one of `gl.RGBA4`,\n *   `gl.RGB565`, `gl.RGB5_A1`, `gl.DEPTH_COMPONENT16`,\n *   `gl.STENCIL_INDEX8` or `gl.DEPTH_STENCIL` then will create a\n *   renderbuffer. Otherwise will create a texture. Default = `gl.RGBA`\n * @property {number} [type] The type. Used for texture. Default = `gl.UNSIGNED_BYTE`.\n * @property {number} [target] The texture target for `gl.framebufferTexture2D`.\n *   Defaults to `gl.TEXTURE_2D`. Set to appropriate face for cube maps.\n * @property {number} [level] level for `gl.framebufferTexture2D`. Defaults to 0.\n * @property {number} [layer] layer for `gl.framebufferTextureLayer`. Defaults to undefined.\n *   If set then `gl.framebufferTextureLayer` is called, if not then `gl.framebufferTexture2D`\n * @property {(WebGLRenderbuffer | WebGLTexture)} [attachment] An existing renderbuffer or texture.\n *    If provided will attach this Object. This allows you to share\n *    attachments across framebuffers.\n * @memberOf module:twgl\n * @mixes module:twgl.TextureOptions\n */\n\nconst defaultAttachments = [\n  { format: RGBA, type: UNSIGNED_BYTE, min: LINEAR, wrap: CLAMP_TO_EDGE, },\n  { format: DEPTH_STENCIL, },\n];\n\nconst attachmentsByFormat = {};\nattachmentsByFormat[DEPTH_STENCIL] = DEPTH_STENCIL_ATTACHMENT;\nattachmentsByFormat[STENCIL_INDEX] = STENCIL_ATTACHMENT;\nattachmentsByFormat[STENCIL_INDEX8] = STENCIL_ATTACHMENT;\nattachmentsByFormat[DEPTH_COMPONENT] = DEPTH_ATTACHMENT;\nattachmentsByFormat[DEPTH_COMPONENT16] = DEPTH_ATTACHMENT;\nattachmentsByFormat[DEPTH_COMPONENT24] = DEPTH_ATTACHMENT;\nattachmentsByFormat[DEPTH_COMPONENT32F] = DEPTH_ATTACHMENT;\nattachmentsByFormat[DEPTH24_STENCIL8] = DEPTH_STENCIL_ATTACHMENT;\nattachmentsByFormat[DEPTH32F_STENCIL8] = DEPTH_STENCIL_ATTACHMENT;\n\nfunction getAttachmentPointForFormat(format, internalFormat) {\n  return attachmentsByFormat[format] || attachmentsByFormat[internalFormat];\n}\n\nconst renderbufferFormats = {};\nrenderbufferFormats[RGBA4] = true;\nrenderbufferFormats[RGB5_A1] = true;\nrenderbufferFormats[RGB565] = true;\nrenderbufferFormats[DEPTH_STENCIL] = true;\nrenderbufferFormats[DEPTH_COMPONENT16] = true;\nrenderbufferFormats[STENCIL_INDEX] = true;\nrenderbufferFormats[STENCIL_INDEX8] = true;\n\nfunction isRenderbufferFormat(format) {\n  return renderbufferFormats[format];\n}\n\n/**\n * @typedef {Object} FramebufferInfo\n * @property {WebGLFramebuffer} framebuffer The WebGLFramebuffer for this framebufferInfo\n * @property {Array.<(WebGLRenderbuffer | WebGLTexture)>} attachments The created attachments in the same order as passed in to {@link module:twgl.createFramebufferInfo}.\n * @property {number} width The width of the framebuffer and its attachments\n * @property {number} height The width of the framebuffer and its attachments\n * @memberOf module:twgl\n */\n\n/**\n * Creates a framebuffer and attachments.\n *\n * This returns a {@link module:twgl.FramebufferInfo} because it needs to return the attachments as well as the framebuffer.\n *\n * The simplest usage\n *\n *     // create an RGBA/UNSIGNED_BYTE texture and DEPTH_STENCIL renderbuffer\n *     const fbi = twgl.createFramebufferInfo(gl);\n *\n * More complex usage\n *\n *     // create an RGB565 renderbuffer and a STENCIL_INDEX8 renderbuffer\n *     const attachments = [\n *       { format: RGB565, mag: NEAREST },\n *       { format: STENCIL_INDEX8 },\n *     ]\n *     const fbi = twgl.createFramebufferInfo(gl, attachments);\n *\n * Passing in a specific size\n *\n *     const width = 256;\n *     const height = 256;\n *     const fbi = twgl.createFramebufferInfo(gl, attachments, width, height);\n *\n * **Note!!** It is up to you to check if the framebuffer is renderable by calling `gl.checkFramebufferStatus`.\n * [WebGL1 only guarantees 3 combinations of attachments work](https://www.khronos.org/registry/webgl/specs/latest/1.0/#6.6).\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {module:twgl.AttachmentOptions[]} [attachments] which attachments to create. If not provided the default is a framebuffer with an\n *    `RGBA`, `UNSIGNED_BYTE` texture `COLOR_ATTACHMENT0` and a `DEPTH_STENCIL` renderbuffer `DEPTH_STENCIL_ATTACHMENT`.\n * @param {number} [width] the width for the attachments. Default = size of drawingBuffer\n * @param {number} [height] the height for the attachments. Default = size of drawingBuffer\n * @return {module:twgl.FramebufferInfo} the framebuffer and attachments.\n * @memberOf module:twgl/framebuffers\n */\nfunction createFramebufferInfo(gl, attachments, width, height) {\n  const target = FRAMEBUFFER;\n  const fb = gl.createFramebuffer();\n  gl.bindFramebuffer(target, fb);\n  width  = width  || gl.drawingBufferWidth;\n  height = height || gl.drawingBufferHeight;\n  attachments = attachments || defaultAttachments;\n  let colorAttachmentCount = 0;\n  const framebufferInfo = {\n    framebuffer: fb,\n    attachments: [],\n    width: width,\n    height: height,\n  };\n  attachments.forEach(function(attachmentOptions) {\n    let attachment = attachmentOptions.attachment;\n    const format = attachmentOptions.format;\n    let attachmentPoint = attachmentOptions.attachmentPoint || getAttachmentPointForFormat(format, attachmentOptions.internalFormat);\n    if (!attachmentPoint) {\n      attachmentPoint = COLOR_ATTACHMENT0 + colorAttachmentCount++;\n    }\n    if (!attachment) {\n      if (isRenderbufferFormat(format)) {\n        attachment = gl.createRenderbuffer();\n        gl.bindRenderbuffer(RENDERBUFFER, attachment);\n        gl.renderbufferStorage(RENDERBUFFER, format, width, height);\n      } else {\n        const textureOptions = Object.assign({}, attachmentOptions);\n        textureOptions.width = width;\n        textureOptions.height = height;\n        if (textureOptions.auto === undefined) {\n          textureOptions.auto = false;\n          textureOptions.min = textureOptions.min || textureOptions.minMag || LINEAR;\n          textureOptions.mag = textureOptions.mag || textureOptions.minMag || LINEAR;\n          textureOptions.wrapS = textureOptions.wrapS || textureOptions.wrap || CLAMP_TO_EDGE;\n          textureOptions.wrapT = textureOptions.wrapT || textureOptions.wrap || CLAMP_TO_EDGE;\n        }\n        attachment = textures.createTexture(gl, textureOptions);\n      }\n    }\n    if (helper.isRenderbuffer(gl, attachment)) {\n      gl.framebufferRenderbuffer(target, attachmentPoint, RENDERBUFFER, attachment);\n    } else if (helper.isTexture(gl, attachment)) {\n      if (attachmentOptions.layer !== undefined) {\n        gl.framebufferTextureLayer(\n          target,\n          attachmentPoint,\n          attachment,\n          attachmentOptions.level || 0,\n          attachmentOptions.layer);\n      } else {\n        gl.framebufferTexture2D(\n            target,\n            attachmentPoint,\n            attachmentOptions.target || TEXTURE_2D,\n            attachment,\n            attachmentOptions.level || 0);\n      }\n    } else {\n      throw new Error('unknown attachment type');\n    }\n    framebufferInfo.attachments.push(attachment);\n  });\n  return framebufferInfo;\n}\n\n/**\n * Resizes the attachments of a framebuffer.\n *\n * You need to pass in the same `attachments` as you passed in {@link module:twgl.createFramebufferInfo}\n * because TWGL has no idea the format/type of each attachment.\n *\n * The simplest usage\n *\n *     // create an RGBA/UNSIGNED_BYTE texture and DEPTH_STENCIL renderbuffer\n *     const fbi = twgl.createFramebufferInfo(gl);\n *\n *     ...\n *\n *     function render() {\n *       if (twgl.resizeCanvasToDisplaySize(gl.canvas)) {\n *         // resize the attachments\n *         twgl.resizeFramebufferInfo(gl, fbi);\n *       }\n *\n * More complex usage\n *\n *     // create an RGB565 renderbuffer and a STENCIL_INDEX8 renderbuffer\n *     const attachments = [\n *       { format: RGB565, mag: NEAREST },\n *       { format: STENCIL_INDEX8 },\n *     ]\n *     const fbi = twgl.createFramebufferInfo(gl, attachments);\n *\n *     ...\n *\n *     function render() {\n *       if (twgl.resizeCanvasToDisplaySize(gl.canvas)) {\n *         // resize the attachments to match\n *         twgl.resizeFramebufferInfo(gl, fbi, attachments);\n *       }\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {module:twgl.FramebufferInfo} framebufferInfo a framebufferInfo as returned from {@link module:twgl.createFramebufferInfo}.\n * @param {module:twgl.AttachmentOptions[]} [attachments] the same attachments options as passed to {@link module:twgl.createFramebufferInfo}.\n * @param {number} [width] the width for the attachments. Default = size of drawingBuffer\n * @param {number} [height] the height for the attachments. Default = size of drawingBuffer\n * @memberOf module:twgl/framebuffers\n */\nfunction resizeFramebufferInfo(gl, framebufferInfo, attachments, width, height) {\n  width  = width  || gl.drawingBufferWidth;\n  height = height || gl.drawingBufferHeight;\n  framebufferInfo.width = width;\n  framebufferInfo.height = height;\n  attachments = attachments || defaultAttachments;\n  attachments.forEach(function(attachmentOptions, ndx) {\n    const attachment = framebufferInfo.attachments[ndx];\n    const format = attachmentOptions.format;\n    if (helper.isRenderbuffer(gl, attachment)) {\n      gl.bindRenderbuffer(RENDERBUFFER, attachment);\n      gl.renderbufferStorage(RENDERBUFFER, format, width, height);\n    } else if (helper.isTexture(gl, attachment)) {\n      textures.resizeTexture(gl, attachment, attachmentOptions, width, height);\n    } else {\n      throw new Error('unknown attachment type');\n    }\n  });\n}\n\n/**\n * Binds a framebuffer\n *\n * This function pretty much solely exists because I spent hours\n * trying to figure out why something I wrote wasn't working only\n * to realize I forget to set the viewport dimensions.\n * My hope is this function will fix that.\n *\n * It is effectively the same as\n *\n *     gl.bindFramebuffer(gl.FRAMEBUFFER, someFramebufferInfo.framebuffer);\n *     gl.viewport(0, 0, someFramebufferInfo.width, someFramebufferInfo.height);\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {module:twgl.FramebufferInfo|null} [framebufferInfo] a framebufferInfo as returned from {@link module:twgl.createFramebufferInfo}.\n *   If falsy will bind the canvas.\n * @param {number} [target] The target. If not passed `gl.FRAMEBUFFER` will be used.\n * @memberOf module:twgl/framebuffers\n */\n\nfunction bindFramebufferInfo(gl, framebufferInfo, target) {\n  target = target || FRAMEBUFFER;\n  if (framebufferInfo) {\n    gl.bindFramebuffer(target, framebufferInfo.framebuffer);\n    gl.viewport(0, 0, framebufferInfo.width, framebufferInfo.height);\n  } else {\n    gl.bindFramebuffer(target, null);\n    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);\n  }\n}\n\nexport {\n  bindFramebufferInfo,\n  createFramebufferInfo,\n  resizeFramebufferInfo,\n};\n\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n/* eslint no-console: \"off\" */\n\n/**\n * Copy named properties\n *\n * @param {string[]} names names of properties to copy\n * @param {object} src object to copy properties from\n * @param {object} dst object to copy properties to\n * @private\n */\nfunction copyNamedProperties(names, src, dst) {\n  names.forEach(function(name) {\n    const value = src[name];\n    if (value !== undefined) {\n      dst[name] = value;\n    }\n  });\n}\n\n/**\n * Copies properties from source to dest only if a matching key is in dest\n *\n * @param {Object.<string, ?>} src the source\n * @param {Object.<string, ?>} dst the dest\n * @private\n */\nfunction copyExistingProperties(src, dst) {\n  Object.keys(dst).forEach(function(key) {\n    if (dst.hasOwnProperty(key) && src.hasOwnProperty(key)) {  /* eslint no-prototype-builtins: 0 */\n      dst[key] = src[key];\n    }\n  });\n}\n\nfunction error(...args) {\n  console.error(...args);\n}\n\nfunction warn(...args) {\n  console.warn(...args);\n}\n\nfunction isBuffer(gl, t) {\n  return typeof WebGLBuffer !== 'undefined' && t instanceof WebGLBuffer;\n}\n\nfunction isRenderbuffer(gl, t) {\n  return typeof WebGLRenderbuffer !== 'undefined' && t instanceof WebGLRenderbuffer;\n}\n\nfunction isShader(gl, t) {\n  return typeof WebGLShader !== 'undefined' && t instanceof WebGLShader;\n}\n\nfunction isTexture(gl, t) {\n  return typeof WebGLTexture !== 'undefined' && t instanceof WebGLTexture;\n}\n\nfunction isSampler(gl, t) {\n  return typeof WebGLSampler !== 'undefined' && t instanceof WebGLSampler;\n}\n\nexport {\n  copyExistingProperties,\n  copyNamedProperties,\n  error,\n  warn,\n  isBuffer,\n  isRenderbuffer,\n  isShader,\n  isTexture,\n  isSampler,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as v3 from './v3.js';\n\n/**\n * 4x4 Matrix math math functions.\n *\n * Almost all functions take an optional `dst` argument. If it is not passed in the\n * functions will create a new matrix. In other words you can do this\n *\n *     const mat = m4.translation([1, 2, 3]);  // Creates a new translation matrix\n *\n * or\n *\n *     const mat = m4.create();\n *     m4.translation([1, 2, 3], mat);  // Puts translation matrix in mat.\n *\n * The first style is often easier but depending on where it's used it generates garbage where\n * as there is almost never allocation with the second style.\n *\n * It is always save to pass any matrix as the destination. So for example\n *\n *     const mat = m4.identity();\n *     const trans = m4.translation([1, 2, 3]);\n *     m4.multiply(mat, trans, mat);  // Multiplies mat * trans and puts result in mat.\n *\n * @module twgl/m4\n */\nlet MatType = Float32Array;\n\n/**\n * A JavaScript array with 16 values or a Float32Array with 16 values.\n * When created by the library will create the default type which is `Float32Array`\n * but can be set by calling {@link module:twgl/m4.setDefaultType}.\n * @typedef {(number[]|Float32Array)} Mat4\n * @memberOf module:twgl/m4\n */\n\n/**\n * Sets the type this library creates for a Mat4\n * @param {constructor} ctor the constructor for the type. Either `Float32Array` or `Array`\n * @return {constructor} previous constructor for Mat4\n * @memberOf module:twgl/m4\n */\nfunction setDefaultType(ctor) {\n  const oldType = MatType;\n  MatType = ctor;\n  return oldType;\n}\n\n/**\n * Negates a matrix.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} -m.\n * @memberOf module:twgl/m4\n */\nfunction negate(m, dst) {\n  dst = dst || new MatType(16);\n\n  dst[ 0] = -m[ 0];\n  dst[ 1] = -m[ 1];\n  dst[ 2] = -m[ 2];\n  dst[ 3] = -m[ 3];\n  dst[ 4] = -m[ 4];\n  dst[ 5] = -m[ 5];\n  dst[ 6] = -m[ 6];\n  dst[ 7] = -m[ 7];\n  dst[ 8] = -m[ 8];\n  dst[ 9] = -m[ 9];\n  dst[10] = -m[10];\n  dst[11] = -m[11];\n  dst[12] = -m[12];\n  dst[13] = -m[13];\n  dst[14] = -m[14];\n  dst[15] = -m[15];\n\n  return dst;\n}\n\n/**\n * Copies a matrix.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/m4.Mat4} [dst] The matrix. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} A copy of m.\n * @memberOf module:twgl/m4\n */\nfunction copy(m, dst) {\n  dst = dst || new MatType(16);\n\n  dst[ 0] = m[ 0];\n  dst[ 1] = m[ 1];\n  dst[ 2] = m[ 2];\n  dst[ 3] = m[ 3];\n  dst[ 4] = m[ 4];\n  dst[ 5] = m[ 5];\n  dst[ 6] = m[ 6];\n  dst[ 7] = m[ 7];\n  dst[ 8] = m[ 8];\n  dst[ 9] = m[ 9];\n  dst[10] = m[10];\n  dst[11] = m[11];\n  dst[12] = m[12];\n  dst[13] = m[13];\n  dst[14] = m[14];\n  dst[15] = m[15];\n\n  return dst;\n}\n\n/**\n * Creates an n-by-n identity matrix.\n *\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} An n-by-n identity matrix.\n * @memberOf module:twgl/m4\n */\nfunction identity(dst) {\n  dst = dst || new MatType(16);\n\n  dst[ 0] = 1;\n  dst[ 1] = 0;\n  dst[ 2] = 0;\n  dst[ 3] = 0;\n  dst[ 4] = 0;\n  dst[ 5] = 1;\n  dst[ 6] = 0;\n  dst[ 7] = 0;\n  dst[ 8] = 0;\n  dst[ 9] = 0;\n  dst[10] = 1;\n  dst[11] = 0;\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = 0;\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Takes the transpose of a matrix.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The transpose of m.\n * @memberOf module:twgl/m4\n */\n function transpose(m, dst) {\n  dst = dst || new MatType(16);\n  if (dst === m) {\n    let t;\n\n    t = m[1];\n    m[1] = m[4];\n    m[4] = t;\n\n    t = m[2];\n    m[2] = m[8];\n    m[8] = t;\n\n    t = m[3];\n    m[3] = m[12];\n    m[12] = t;\n\n    t = m[6];\n    m[6] = m[9];\n    m[9] = t;\n\n    t = m[7];\n    m[7] = m[13];\n    m[13] = t;\n\n    t = m[11];\n    m[11] = m[14];\n    m[14] = t;\n    return dst;\n  }\n\n  const m00 = m[0 * 4 + 0];\n  const m01 = m[0 * 4 + 1];\n  const m02 = m[0 * 4 + 2];\n  const m03 = m[0 * 4 + 3];\n  const m10 = m[1 * 4 + 0];\n  const m11 = m[1 * 4 + 1];\n  const m12 = m[1 * 4 + 2];\n  const m13 = m[1 * 4 + 3];\n  const m20 = m[2 * 4 + 0];\n  const m21 = m[2 * 4 + 1];\n  const m22 = m[2 * 4 + 2];\n  const m23 = m[2 * 4 + 3];\n  const m30 = m[3 * 4 + 0];\n  const m31 = m[3 * 4 + 1];\n  const m32 = m[3 * 4 + 2];\n  const m33 = m[3 * 4 + 3];\n\n  dst[ 0] = m00;\n  dst[ 1] = m10;\n  dst[ 2] = m20;\n  dst[ 3] = m30;\n  dst[ 4] = m01;\n  dst[ 5] = m11;\n  dst[ 6] = m21;\n  dst[ 7] = m31;\n  dst[ 8] = m02;\n  dst[ 9] = m12;\n  dst[10] = m22;\n  dst[11] = m32;\n  dst[12] = m03;\n  dst[13] = m13;\n  dst[14] = m23;\n  dst[15] = m33;\n\n  return dst;\n}\n\n/**\n * Computes the inverse of a 4-by-4 matrix.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The inverse of m.\n * @memberOf module:twgl/m4\n */\nfunction inverse(m, dst) {\n  dst = dst || new MatType(16);\n\n  const m00 = m[0 * 4 + 0];\n  const m01 = m[0 * 4 + 1];\n  const m02 = m[0 * 4 + 2];\n  const m03 = m[0 * 4 + 3];\n  const m10 = m[1 * 4 + 0];\n  const m11 = m[1 * 4 + 1];\n  const m12 = m[1 * 4 + 2];\n  const m13 = m[1 * 4 + 3];\n  const m20 = m[2 * 4 + 0];\n  const m21 = m[2 * 4 + 1];\n  const m22 = m[2 * 4 + 2];\n  const m23 = m[2 * 4 + 3];\n  const m30 = m[3 * 4 + 0];\n  const m31 = m[3 * 4 + 1];\n  const m32 = m[3 * 4 + 2];\n  const m33 = m[3 * 4 + 3];\n  const tmp_0  = m22 * m33;\n  const tmp_1  = m32 * m23;\n  const tmp_2  = m12 * m33;\n  const tmp_3  = m32 * m13;\n  const tmp_4  = m12 * m23;\n  const tmp_5  = m22 * m13;\n  const tmp_6  = m02 * m33;\n  const tmp_7  = m32 * m03;\n  const tmp_8  = m02 * m23;\n  const tmp_9  = m22 * m03;\n  const tmp_10 = m02 * m13;\n  const tmp_11 = m12 * m03;\n  const tmp_12 = m20 * m31;\n  const tmp_13 = m30 * m21;\n  const tmp_14 = m10 * m31;\n  const tmp_15 = m30 * m11;\n  const tmp_16 = m10 * m21;\n  const tmp_17 = m20 * m11;\n  const tmp_18 = m00 * m31;\n  const tmp_19 = m30 * m01;\n  const tmp_20 = m00 * m21;\n  const tmp_21 = m20 * m01;\n  const tmp_22 = m00 * m11;\n  const tmp_23 = m10 * m01;\n\n  const t0 = (tmp_0 * m11 + tmp_3 * m21 + tmp_4 * m31) -\n      (tmp_1 * m11 + tmp_2 * m21 + tmp_5 * m31);\n  const t1 = (tmp_1 * m01 + tmp_6 * m21 + tmp_9 * m31) -\n      (tmp_0 * m01 + tmp_7 * m21 + tmp_8 * m31);\n  const t2 = (tmp_2 * m01 + tmp_7 * m11 + tmp_10 * m31) -\n      (tmp_3 * m01 + tmp_6 * m11 + tmp_11 * m31);\n  const t3 = (tmp_5 * m01 + tmp_8 * m11 + tmp_11 * m21) -\n      (tmp_4 * m01 + tmp_9 * m11 + tmp_10 * m21);\n\n  const d = 1.0 / (m00 * t0 + m10 * t1 + m20 * t2 + m30 * t3);\n\n  dst[ 0] = d * t0;\n  dst[ 1] = d * t1;\n  dst[ 2] = d * t2;\n  dst[ 3] = d * t3;\n  dst[ 4] = d * ((tmp_1 * m10 + tmp_2 * m20 + tmp_5 * m30) -\n          (tmp_0 * m10 + tmp_3 * m20 + tmp_4 * m30));\n  dst[ 5] = d * ((tmp_0 * m00 + tmp_7 * m20 + tmp_8 * m30) -\n          (tmp_1 * m00 + tmp_6 * m20 + tmp_9 * m30));\n  dst[ 6] = d * ((tmp_3 * m00 + tmp_6 * m10 + tmp_11 * m30) -\n          (tmp_2 * m00 + tmp_7 * m10 + tmp_10 * m30));\n  dst[ 7] = d * ((tmp_4 * m00 + tmp_9 * m10 + tmp_10 * m20) -\n          (tmp_5 * m00 + tmp_8 * m10 + tmp_11 * m20));\n  dst[ 8] = d * ((tmp_12 * m13 + tmp_15 * m23 + tmp_16 * m33) -\n          (tmp_13 * m13 + tmp_14 * m23 + tmp_17 * m33));\n  dst[ 9] = d * ((tmp_13 * m03 + tmp_18 * m23 + tmp_21 * m33) -\n          (tmp_12 * m03 + tmp_19 * m23 + tmp_20 * m33));\n  dst[10] = d * ((tmp_14 * m03 + tmp_19 * m13 + tmp_22 * m33) -\n          (tmp_15 * m03 + tmp_18 * m13 + tmp_23 * m33));\n  dst[11] = d * ((tmp_17 * m03 + tmp_20 * m13 + tmp_23 * m23) -\n          (tmp_16 * m03 + tmp_21 * m13 + tmp_22 * m23));\n  dst[12] = d * ((tmp_14 * m22 + tmp_17 * m32 + tmp_13 * m12) -\n          (tmp_16 * m32 + tmp_12 * m12 + tmp_15 * m22));\n  dst[13] = d * ((tmp_20 * m32 + tmp_12 * m02 + tmp_19 * m22) -\n          (tmp_18 * m22 + tmp_21 * m32 + tmp_13 * m02));\n  dst[14] = d * ((tmp_18 * m12 + tmp_23 * m32 + tmp_15 * m02) -\n          (tmp_22 * m32 + tmp_14 * m02 + tmp_19 * m12));\n  dst[15] = d * ((tmp_22 * m22 + tmp_16 * m02 + tmp_21 * m12) -\n          (tmp_20 * m12 + tmp_23 * m22 + tmp_17 * m02));\n\n  return dst;\n}\n\n/**\n * Multiplies two 4-by-4 matrices with a on the left and b on the right\n * @param {module:twgl/m4.Mat4} a The matrix on the left.\n * @param {module:twgl/m4.Mat4} b The matrix on the right.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The matrix product of a and b.\n * @memberOf module:twgl/m4\n */\nfunction multiply(a, b, dst) {\n  dst = dst || new MatType(16);\n\n  const a00 = a[0];\n  const a01 = a[1];\n  const a02 = a[2];\n  const a03 = a[3];\n  const a10 = a[ 4 + 0];\n  const a11 = a[ 4 + 1];\n  const a12 = a[ 4 + 2];\n  const a13 = a[ 4 + 3];\n  const a20 = a[ 8 + 0];\n  const a21 = a[ 8 + 1];\n  const a22 = a[ 8 + 2];\n  const a23 = a[ 8 + 3];\n  const a30 = a[12 + 0];\n  const a31 = a[12 + 1];\n  const a32 = a[12 + 2];\n  const a33 = a[12 + 3];\n  const b00 = b[0];\n  const b01 = b[1];\n  const b02 = b[2];\n  const b03 = b[3];\n  const b10 = b[ 4 + 0];\n  const b11 = b[ 4 + 1];\n  const b12 = b[ 4 + 2];\n  const b13 = b[ 4 + 3];\n  const b20 = b[ 8 + 0];\n  const b21 = b[ 8 + 1];\n  const b22 = b[ 8 + 2];\n  const b23 = b[ 8 + 3];\n  const b30 = b[12 + 0];\n  const b31 = b[12 + 1];\n  const b32 = b[12 + 2];\n  const b33 = b[12 + 3];\n\n  dst[ 0] = a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03;\n  dst[ 1] = a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03;\n  dst[ 2] = a02 * b00 + a12 * b01 + a22 * b02 + a32 * b03;\n  dst[ 3] = a03 * b00 + a13 * b01 + a23 * b02 + a33 * b03;\n  dst[ 4] = a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13;\n  dst[ 5] = a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13;\n  dst[ 6] = a02 * b10 + a12 * b11 + a22 * b12 + a32 * b13;\n  dst[ 7] = a03 * b10 + a13 * b11 + a23 * b12 + a33 * b13;\n  dst[ 8] = a00 * b20 + a10 * b21 + a20 * b22 + a30 * b23;\n  dst[ 9] = a01 * b20 + a11 * b21 + a21 * b22 + a31 * b23;\n  dst[10] = a02 * b20 + a12 * b21 + a22 * b22 + a32 * b23;\n  dst[11] = a03 * b20 + a13 * b21 + a23 * b22 + a33 * b23;\n  dst[12] = a00 * b30 + a10 * b31 + a20 * b32 + a30 * b33;\n  dst[13] = a01 * b30 + a11 * b31 + a21 * b32 + a31 * b33;\n  dst[14] = a02 * b30 + a12 * b31 + a22 * b32 + a32 * b33;\n  dst[15] = a03 * b30 + a13 * b31 + a23 * b32 + a33 * b33;\n\n  return dst;\n}\n\n/**\n * Sets the translation component of a 4-by-4 matrix to the given\n * vector.\n * @param {module:twgl/m4.Mat4} a The matrix.\n * @param {module:twgl/v3.Vec3} v The vector.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The matrix with translation set.\n * @memberOf module:twgl/m4\n */\nfunction setTranslation(a, v, dst) {\n  dst = dst || identity();\n  if (a !== dst) {\n    dst[ 0] = a[ 0];\n    dst[ 1] = a[ 1];\n    dst[ 2] = a[ 2];\n    dst[ 3] = a[ 3];\n    dst[ 4] = a[ 4];\n    dst[ 5] = a[ 5];\n    dst[ 6] = a[ 6];\n    dst[ 7] = a[ 7];\n    dst[ 8] = a[ 8];\n    dst[ 9] = a[ 9];\n    dst[10] = a[10];\n    dst[11] = a[11];\n  }\n  dst[12] = v[0];\n  dst[13] = v[1];\n  dst[14] = v[2];\n  dst[15] = 1;\n  return dst;\n}\n\n/**\n * Returns the translation component of a 4-by-4 matrix as a vector with 3\n * entries.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not passed a new one is created.\n * @return {module:twgl/v3.Vec3} The translation component of m.\n * @memberOf module:twgl/m4\n */\nfunction getTranslation(m, dst) {\n  dst = dst || v3.create();\n  dst[0] = m[12];\n  dst[1] = m[13];\n  dst[2] = m[14];\n  return dst;\n}\n\n/**\n * Returns an axis of a 4x4 matrix as a vector with 3 entries\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {number} axis The axis 0 = x, 1 = y, 2 = z;\n * @return {module:twgl/v3.Vec3} [dst] vector.\n * @return {module:twgl/v3.Vec3} The axis component of m.\n * @memberOf module:twgl/m4\n */\nfunction getAxis(m, axis, dst) {\n  dst = dst || v3.create();\n  const off = axis * 4;\n  dst[0] = m[off + 0];\n  dst[1] = m[off + 1];\n  dst[2] = m[off + 2];\n  return dst;\n}\n\n/**\n * Sets an axis of a 4x4 matrix as a vector with 3 entries\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/v3.Vec3} v the axis vector\n * @param {number} axis The axis  0 = x, 1 = y, 2 = z;\n * @param {module:twgl/m4.Mat4} [dst] The matrix to set. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The matrix with axis set.\n * @memberOf module:twgl/m4\n */\nfunction setAxis(a, v, axis, dst) {\n  if (dst !== a) {\n    dst = copy(a, dst);\n  }\n  const off = axis * 4;\n  dst[off + 0] = v[0];\n  dst[off + 1] = v[1];\n  dst[off + 2] = v[2];\n  return dst;\n}\n\n/**\n * Computes a 4-by-4 perspective transformation matrix given the angular height\n * of the frustum, the aspect ratio, and the near and far clipping planes.  The\n * arguments define a frustum extending in the negative z direction.  The given\n * angle is the vertical angle of the frustum, and the horizontal angle is\n * determined to produce the given aspect ratio.  The arguments near and far are\n * the distances to the near and far clipping planes.  Note that near and far\n * are not z coordinates, but rather they are distances along the negative\n * z-axis.  The matrix generated sends the viewing frustum to the unit box.\n * We assume a unit box extending from -1 to 1 in the x and y dimensions and\n * from 0 to 1 in the z dimension.\n * @param {number} fieldOfViewYInRadians The camera angle from top to bottom (in radians).\n * @param {number} aspect The aspect ratio width / height.\n * @param {number} zNear The depth (negative z coordinate)\n *     of the near clipping plane.\n * @param {number} zFar The depth (negative z coordinate)\n *     of the far clipping plane.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The perspective matrix.\n * @memberOf module:twgl/m4\n */\nfunction perspective(fieldOfViewYInRadians, aspect, zNear, zFar, dst) {\n  dst = dst || new MatType(16);\n\n  const f = Math.tan(Math.PI * 0.5 - 0.5 * fieldOfViewYInRadians);\n  const rangeInv = 1.0 / (zNear - zFar);\n\n  dst[0]  = f / aspect;\n  dst[1]  = 0;\n  dst[2]  = 0;\n  dst[3]  = 0;\n\n  dst[4]  = 0;\n  dst[5]  = f;\n  dst[6]  = 0;\n  dst[7]  = 0;\n\n  dst[8]  = 0;\n  dst[9]  = 0;\n  dst[10] = (zNear + zFar) * rangeInv;\n  dst[11] = -1;\n\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = zNear * zFar * rangeInv * 2;\n  dst[15] = 0;\n\n  return dst;\n}\n\n/**\n * Computes a 4-by-4 orthogonal transformation matrix given the left, right,\n * bottom, and top dimensions of the near clipping plane as well as the\n * near and far clipping plane distances.\n * @param {number} left Left side of the near clipping plane viewport.\n * @param {number} right Right side of the near clipping plane viewport.\n * @param {number} bottom Bottom of the near clipping plane viewport.\n * @param {number} top Top of the near clipping plane viewport.\n * @param {number} near The depth (negative z coordinate)\n *     of the near clipping plane.\n * @param {number} far The depth (negative z coordinate)\n *     of the far clipping plane.\n * @param {module:twgl/m4.Mat4} [dst] Output matrix. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The perspective matrix.\n * @memberOf module:twgl/m4\n */\nfunction ortho(left, right, bottom, top, near, far, dst) {\n  dst = dst || new MatType(16);\n\n  dst[0]  = 2 / (right - left);\n  dst[1]  = 0;\n  dst[2]  = 0;\n  dst[3]  = 0;\n\n  dst[4]  = 0;\n  dst[5]  = 2 / (top - bottom);\n  dst[6]  = 0;\n  dst[7]  = 0;\n\n  dst[8]  = 0;\n  dst[9]  = 0;\n  dst[10] = 2 / (near - far);\n  dst[11] = 0;\n\n  dst[12] = (right + left) / (left - right);\n  dst[13] = (top + bottom) / (bottom - top);\n  dst[14] = (far + near) / (near - far);\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Computes a 4-by-4 perspective transformation matrix given the left, right,\n * top, bottom, near and far clipping planes. The arguments define a frustum\n * extending in the negative z direction. The arguments near and far are the\n * distances to the near and far clipping planes. Note that near and far are not\n * z coordinates, but rather they are distances along the negative z-axis. The\n * matrix generated sends the viewing frustum to the unit box. We assume a unit\n * box extending from -1 to 1 in the x and y dimensions and from 0 to 1 in the z\n * dimension.\n * @param {number} left The x coordinate of the left plane of the box.\n * @param {number} right The x coordinate of the right plane of the box.\n * @param {number} bottom The y coordinate of the bottom plane of the box.\n * @param {number} top The y coordinate of the right plane of the box.\n * @param {number} near The negative z coordinate of the near plane of the box.\n * @param {number} far The negative z coordinate of the far plane of the box.\n * @param {module:twgl/m4.Mat4} [dst] Output matrix. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The perspective projection matrix.\n * @memberOf module:twgl/m4\n */\nfunction frustum(left, right, bottom, top, near, far, dst) {\n  dst = dst || new MatType(16);\n\n  const dx = (right - left);\n  const dy = (top - bottom);\n  const dz = (near - far);\n\n  dst[ 0] = 2 * near / dx;\n  dst[ 1] = 0;\n  dst[ 2] = 0;\n  dst[ 3] = 0;\n  dst[ 4] = 0;\n  dst[ 5] = 2 * near / dy;\n  dst[ 6] = 0;\n  dst[ 7] = 0;\n  dst[ 8] = (left + right) / dx;\n  dst[ 9] = (top + bottom) / dy;\n  dst[10] = far / dz;\n  dst[11] = -1;\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = near * far / dz;\n  dst[15] = 0;\n\n  return dst;\n}\n\nlet xAxis;\nlet yAxis;\nlet zAxis;\n\n/**\n * Computes a 4-by-4 look-at transformation.\n *\n * This is a matrix which positions the camera itself. If you want\n * a view matrix (a matrix which moves things in front of the camera)\n * take the inverse of this.\n *\n * @param {module:twgl/v3.Vec3} eye The position of the eye.\n * @param {module:twgl/v3.Vec3} target The position meant to be viewed.\n * @param {module:twgl/v3.Vec3} up A vector pointing up.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The look-at matrix.\n * @memberOf module:twgl/m4\n */\nfunction lookAt(eye, target, up, dst) {\n  dst = dst || new MatType(16);\n\n  xAxis = xAxis || v3.create();\n  yAxis = yAxis || v3.create();\n  zAxis = zAxis || v3.create();\n\n  v3.normalize(\n      v3.subtract(eye, target, zAxis), zAxis);\n  v3.normalize(v3.cross(up, zAxis, xAxis), xAxis);\n  v3.normalize(v3.cross(zAxis, xAxis, yAxis), yAxis);\n\n  dst[ 0] = xAxis[0];\n  dst[ 1] = xAxis[1];\n  dst[ 2] = xAxis[2];\n  dst[ 3] = 0;\n  dst[ 4] = yAxis[0];\n  dst[ 5] = yAxis[1];\n  dst[ 6] = yAxis[2];\n  dst[ 7] = 0;\n  dst[ 8] = zAxis[0];\n  dst[ 9] = zAxis[1];\n  dst[10] = zAxis[2];\n  dst[11] = 0;\n  dst[12] = eye[0];\n  dst[13] = eye[1];\n  dst[14] = eye[2];\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Creates a 4-by-4 matrix which translates by the given vector v.\n * @param {module:twgl/v3.Vec3} v The vector by\n *     which to translate.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The translation matrix.\n * @memberOf module:twgl/m4\n */\nfunction translation(v, dst) {\n  dst = dst || new MatType(16);\n\n  dst[ 0] = 1;\n  dst[ 1] = 0;\n  dst[ 2] = 0;\n  dst[ 3] = 0;\n  dst[ 4] = 0;\n  dst[ 5] = 1;\n  dst[ 6] = 0;\n  dst[ 7] = 0;\n  dst[ 8] = 0;\n  dst[ 9] = 0;\n  dst[10] = 1;\n  dst[11] = 0;\n  dst[12] = v[0];\n  dst[13] = v[1];\n  dst[14] = v[2];\n  dst[15] = 1;\n  return dst;\n}\n\n/**\n * Translates the given 4-by-4 matrix by the given vector v.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/v3.Vec3} v The vector by\n *     which to translate.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The translated matrix.\n * @memberOf module:twgl/m4\n */\nfunction translate(m, v, dst) {\n  dst = dst || new MatType(16);\n\n  const v0 = v[0];\n  const v1 = v[1];\n  const v2 = v[2];\n  const m00 = m[0];\n  const m01 = m[1];\n  const m02 = m[2];\n  const m03 = m[3];\n  const m10 = m[1 * 4 + 0];\n  const m11 = m[1 * 4 + 1];\n  const m12 = m[1 * 4 + 2];\n  const m13 = m[1 * 4 + 3];\n  const m20 = m[2 * 4 + 0];\n  const m21 = m[2 * 4 + 1];\n  const m22 = m[2 * 4 + 2];\n  const m23 = m[2 * 4 + 3];\n  const m30 = m[3 * 4 + 0];\n  const m31 = m[3 * 4 + 1];\n  const m32 = m[3 * 4 + 2];\n  const m33 = m[3 * 4 + 3];\n\n  if (m !== dst) {\n    dst[ 0] = m00;\n    dst[ 1] = m01;\n    dst[ 2] = m02;\n    dst[ 3] = m03;\n    dst[ 4] = m10;\n    dst[ 5] = m11;\n    dst[ 6] = m12;\n    dst[ 7] = m13;\n    dst[ 8] = m20;\n    dst[ 9] = m21;\n    dst[10] = m22;\n    dst[11] = m23;\n  }\n\n  dst[12] = m00 * v0 + m10 * v1 + m20 * v2 + m30;\n  dst[13] = m01 * v0 + m11 * v1 + m21 * v2 + m31;\n  dst[14] = m02 * v0 + m12 * v1 + m22 * v2 + m32;\n  dst[15] = m03 * v0 + m13 * v1 + m23 * v2 + m33;\n\n  return dst;\n}\n\n/**\n * Creates a 4-by-4 matrix which rotates around the x-axis by the given angle.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The rotation matrix.\n * @memberOf module:twgl/m4\n */\nfunction rotationX(angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n\n  dst[ 0] = 1;\n  dst[ 1] = 0;\n  dst[ 2] = 0;\n  dst[ 3] = 0;\n  dst[ 4] = 0;\n  dst[ 5] = c;\n  dst[ 6] = s;\n  dst[ 7] = 0;\n  dst[ 8] = 0;\n  dst[ 9] = -s;\n  dst[10] = c;\n  dst[11] = 0;\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = 0;\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Rotates the given 4-by-4 matrix around the x-axis by the given\n * angle.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The rotated matrix.\n * @memberOf module:twgl/m4\n */\nfunction rotateX(m, angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  const m10 = m[4];\n  const m11 = m[5];\n  const m12 = m[6];\n  const m13 = m[7];\n  const m20 = m[8];\n  const m21 = m[9];\n  const m22 = m[10];\n  const m23 = m[11];\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n\n  dst[4]  = c * m10 + s * m20;\n  dst[5]  = c * m11 + s * m21;\n  dst[6]  = c * m12 + s * m22;\n  dst[7]  = c * m13 + s * m23;\n  dst[8]  = c * m20 - s * m10;\n  dst[9]  = c * m21 - s * m11;\n  dst[10] = c * m22 - s * m12;\n  dst[11] = c * m23 - s * m13;\n\n  if (m !== dst) {\n    dst[ 0] = m[ 0];\n    dst[ 1] = m[ 1];\n    dst[ 2] = m[ 2];\n    dst[ 3] = m[ 3];\n    dst[12] = m[12];\n    dst[13] = m[13];\n    dst[14] = m[14];\n    dst[15] = m[15];\n  }\n\n  return dst;\n}\n\n/**\n * Creates a 4-by-4 matrix which rotates around the y-axis by the given angle.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The rotation matrix.\n * @memberOf module:twgl/m4\n */\nfunction rotationY(angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n\n  dst[ 0] = c;\n  dst[ 1] = 0;\n  dst[ 2] = -s;\n  dst[ 3] = 0;\n  dst[ 4] = 0;\n  dst[ 5] = 1;\n  dst[ 6] = 0;\n  dst[ 7] = 0;\n  dst[ 8] = s;\n  dst[ 9] = 0;\n  dst[10] = c;\n  dst[11] = 0;\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = 0;\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Rotates the given 4-by-4 matrix around the y-axis by the given\n * angle.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The rotated matrix.\n * @memberOf module:twgl/m4\n */\nfunction rotateY(m, angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  const m00 = m[0 * 4 + 0];\n  const m01 = m[0 * 4 + 1];\n  const m02 = m[0 * 4 + 2];\n  const m03 = m[0 * 4 + 3];\n  const m20 = m[2 * 4 + 0];\n  const m21 = m[2 * 4 + 1];\n  const m22 = m[2 * 4 + 2];\n  const m23 = m[2 * 4 + 3];\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n\n  dst[ 0] = c * m00 - s * m20;\n  dst[ 1] = c * m01 - s * m21;\n  dst[ 2] = c * m02 - s * m22;\n  dst[ 3] = c * m03 - s * m23;\n  dst[ 8] = c * m20 + s * m00;\n  dst[ 9] = c * m21 + s * m01;\n  dst[10] = c * m22 + s * m02;\n  dst[11] = c * m23 + s * m03;\n\n  if (m !== dst) {\n    dst[ 4] = m[ 4];\n    dst[ 5] = m[ 5];\n    dst[ 6] = m[ 6];\n    dst[ 7] = m[ 7];\n    dst[12] = m[12];\n    dst[13] = m[13];\n    dst[14] = m[14];\n    dst[15] = m[15];\n  }\n\n  return dst;\n}\n\n/**\n * Creates a 4-by-4 matrix which rotates around the z-axis by the given angle.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The rotation matrix.\n * @memberOf module:twgl/m4\n */\nfunction rotationZ(angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n\n  dst[ 0] = c;\n  dst[ 1] = s;\n  dst[ 2] = 0;\n  dst[ 3] = 0;\n  dst[ 4] = -s;\n  dst[ 5] = c;\n  dst[ 6] = 0;\n  dst[ 7] = 0;\n  dst[ 8] = 0;\n  dst[ 9] = 0;\n  dst[10] = 1;\n  dst[11] = 0;\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = 0;\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Rotates the given 4-by-4 matrix around the z-axis by the given\n * angle.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The rotated matrix.\n * @memberOf module:twgl/m4\n */\nfunction rotateZ(m, angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  const m00 = m[0 * 4 + 0];\n  const m01 = m[0 * 4 + 1];\n  const m02 = m[0 * 4 + 2];\n  const m03 = m[0 * 4 + 3];\n  const m10 = m[1 * 4 + 0];\n  const m11 = m[1 * 4 + 1];\n  const m12 = m[1 * 4 + 2];\n  const m13 = m[1 * 4 + 3];\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n\n  dst[ 0] = c * m00 + s * m10;\n  dst[ 1] = c * m01 + s * m11;\n  dst[ 2] = c * m02 + s * m12;\n  dst[ 3] = c * m03 + s * m13;\n  dst[ 4] = c * m10 - s * m00;\n  dst[ 5] = c * m11 - s * m01;\n  dst[ 6] = c * m12 - s * m02;\n  dst[ 7] = c * m13 - s * m03;\n\n  if (m !== dst) {\n    dst[ 8] = m[ 8];\n    dst[ 9] = m[ 9];\n    dst[10] = m[10];\n    dst[11] = m[11];\n    dst[12] = m[12];\n    dst[13] = m[13];\n    dst[14] = m[14];\n    dst[15] = m[15];\n  }\n\n  return dst;\n}\n\n/**\n * Creates a 4-by-4 matrix which rotates around the given axis by the given\n * angle.\n * @param {module:twgl/v3.Vec3} axis The axis\n *     about which to rotate.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} A matrix which rotates angle radians\n *     around the axis.\n * @memberOf module:twgl/m4\n */\nfunction axisRotation(axis, angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  let x = axis[0];\n  let y = axis[1];\n  let z = axis[2];\n  const n = Math.sqrt(x * x + y * y + z * z);\n  x /= n;\n  y /= n;\n  z /= n;\n  const xx = x * x;\n  const yy = y * y;\n  const zz = z * z;\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n  const oneMinusCosine = 1 - c;\n\n  dst[ 0] = xx + (1 - xx) * c;\n  dst[ 1] = x * y * oneMinusCosine + z * s;\n  dst[ 2] = x * z * oneMinusCosine - y * s;\n  dst[ 3] = 0;\n  dst[ 4] = x * y * oneMinusCosine - z * s;\n  dst[ 5] = yy + (1 - yy) * c;\n  dst[ 6] = y * z * oneMinusCosine + x * s;\n  dst[ 7] = 0;\n  dst[ 8] = x * z * oneMinusCosine + y * s;\n  dst[ 9] = y * z * oneMinusCosine - x * s;\n  dst[10] = zz + (1 - zz) * c;\n  dst[11] = 0;\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = 0;\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Rotates the given 4-by-4 matrix around the given axis by the\n * given angle.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/v3.Vec3} axis The axis\n *     about which to rotate.\n * @param {number} angleInRadians The angle by which to rotate (in radians).\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The rotated matrix.\n * @memberOf module:twgl/m4\n */\nfunction axisRotate(m, axis, angleInRadians, dst) {\n  dst = dst || new MatType(16);\n\n  let x = axis[0];\n  let y = axis[1];\n  let z = axis[2];\n  const n = Math.sqrt(x * x + y * y + z * z);\n  x /= n;\n  y /= n;\n  z /= n;\n  const xx = x * x;\n  const yy = y * y;\n  const zz = z * z;\n  const c = Math.cos(angleInRadians);\n  const s = Math.sin(angleInRadians);\n  const oneMinusCosine = 1 - c;\n\n  const r00 = xx + (1 - xx) * c;\n  const r01 = x * y * oneMinusCosine + z * s;\n  const r02 = x * z * oneMinusCosine - y * s;\n  const r10 = x * y * oneMinusCosine - z * s;\n  const r11 = yy + (1 - yy) * c;\n  const r12 = y * z * oneMinusCosine + x * s;\n  const r20 = x * z * oneMinusCosine + y * s;\n  const r21 = y * z * oneMinusCosine - x * s;\n  const r22 = zz + (1 - zz) * c;\n\n  const m00 = m[0];\n  const m01 = m[1];\n  const m02 = m[2];\n  const m03 = m[3];\n  const m10 = m[4];\n  const m11 = m[5];\n  const m12 = m[6];\n  const m13 = m[7];\n  const m20 = m[8];\n  const m21 = m[9];\n  const m22 = m[10];\n  const m23 = m[11];\n\n  dst[ 0] = r00 * m00 + r01 * m10 + r02 * m20;\n  dst[ 1] = r00 * m01 + r01 * m11 + r02 * m21;\n  dst[ 2] = r00 * m02 + r01 * m12 + r02 * m22;\n  dst[ 3] = r00 * m03 + r01 * m13 + r02 * m23;\n  dst[ 4] = r10 * m00 + r11 * m10 + r12 * m20;\n  dst[ 5] = r10 * m01 + r11 * m11 + r12 * m21;\n  dst[ 6] = r10 * m02 + r11 * m12 + r12 * m22;\n  dst[ 7] = r10 * m03 + r11 * m13 + r12 * m23;\n  dst[ 8] = r20 * m00 + r21 * m10 + r22 * m20;\n  dst[ 9] = r20 * m01 + r21 * m11 + r22 * m21;\n  dst[10] = r20 * m02 + r21 * m12 + r22 * m22;\n  dst[11] = r20 * m03 + r21 * m13 + r22 * m23;\n\n  if (m !== dst) {\n    dst[12] = m[12];\n    dst[13] = m[13];\n    dst[14] = m[14];\n    dst[15] = m[15];\n  }\n\n  return dst;\n}\n\n/**\n * Creates a 4-by-4 matrix which scales in each dimension by an amount given by\n * the corresponding entry in the given vector; assumes the vector has three\n * entries.\n * @param {module:twgl/v3.Vec3} v A vector of\n *     three entries specifying the factor by which to scale in each dimension.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The scaling matrix.\n * @memberOf module:twgl/m4\n */\nfunction scaling(v, dst) {\n  dst = dst || new MatType(16);\n\n  dst[ 0] = v[0];\n  dst[ 1] = 0;\n  dst[ 2] = 0;\n  dst[ 3] = 0;\n  dst[ 4] = 0;\n  dst[ 5] = v[1];\n  dst[ 6] = 0;\n  dst[ 7] = 0;\n  dst[ 8] = 0;\n  dst[ 9] = 0;\n  dst[10] = v[2];\n  dst[11] = 0;\n  dst[12] = 0;\n  dst[13] = 0;\n  dst[14] = 0;\n  dst[15] = 1;\n\n  return dst;\n}\n\n/**\n * Scales the given 4-by-4 matrix in each dimension by an amount\n * given by the corresponding entry in the given vector; assumes the vector has\n * three entries.\n * @param {module:twgl/m4.Mat4} m The matrix to be modified.\n * @param {module:twgl/v3.Vec3} v A vector of three entries specifying the\n *     factor by which to scale in each dimension.\n * @param {module:twgl/m4.Mat4} [dst] matrix to hold result. If not passed a new one is created.\n * @return {module:twgl/m4.Mat4} The scaled matrix.\n * @memberOf module:twgl/m4\n */\nfunction scale(m, v, dst) {\n  dst = dst || new MatType(16);\n\n  const v0 = v[0];\n  const v1 = v[1];\n  const v2 = v[2];\n\n  dst[ 0] = v0 * m[0 * 4 + 0];\n  dst[ 1] = v0 * m[0 * 4 + 1];\n  dst[ 2] = v0 * m[0 * 4 + 2];\n  dst[ 3] = v0 * m[0 * 4 + 3];\n  dst[ 4] = v1 * m[1 * 4 + 0];\n  dst[ 5] = v1 * m[1 * 4 + 1];\n  dst[ 6] = v1 * m[1 * 4 + 2];\n  dst[ 7] = v1 * m[1 * 4 + 3];\n  dst[ 8] = v2 * m[2 * 4 + 0];\n  dst[ 9] = v2 * m[2 * 4 + 1];\n  dst[10] = v2 * m[2 * 4 + 2];\n  dst[11] = v2 * m[2 * 4 + 3];\n\n  if (m !== dst) {\n    dst[12] = m[12];\n    dst[13] = m[13];\n    dst[14] = m[14];\n    dst[15] = m[15];\n  }\n\n  return dst;\n}\n\n/**\n * Takes a 4-by-4 matrix and a vector with 3 entries,\n * interprets the vector as a point, transforms that point by the matrix, and\n * returns the result as a vector with 3 entries.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/v3.Vec3} v The point.\n * @param {module:twgl/v3.Vec3} [dst] optional vec3 to store result. If not passed a new one is created.\n * @return {module:twgl/v3.Vec3} The transformed point.\n * @memberOf module:twgl/m4\n */\nfunction transformPoint(m, v, dst) {\n  dst = dst || v3.create();\n  const v0 = v[0];\n  const v1 = v[1];\n  const v2 = v[2];\n  const d = v0 * m[0 * 4 + 3] + v1 * m[1 * 4 + 3] + v2 * m[2 * 4 + 3] + m[3 * 4 + 3];\n\n  dst[0] = (v0 * m[0 * 4 + 0] + v1 * m[1 * 4 + 0] + v2 * m[2 * 4 + 0] + m[3 * 4 + 0]) / d;\n  dst[1] = (v0 * m[0 * 4 + 1] + v1 * m[1 * 4 + 1] + v2 * m[2 * 4 + 1] + m[3 * 4 + 1]) / d;\n  dst[2] = (v0 * m[0 * 4 + 2] + v1 * m[1 * 4 + 2] + v2 * m[2 * 4 + 2] + m[3 * 4 + 2]) / d;\n\n  return dst;\n}\n\n/**\n * Takes a 4-by-4 matrix and a vector with 3 entries, interprets the vector as a\n * direction, transforms that direction by the matrix, and returns the result;\n * assumes the transformation of 3-dimensional space represented by the matrix\n * is parallel-preserving, i.e. any combination of rotation, scaling and\n * translation, but not a perspective distortion. Returns a vector with 3\n * entries.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/v3.Vec3} v The direction.\n * @param {module:twgl/v3.Vec3} [dst] optional Vec3 to store result. If not passed a new one is created.\n * @return {module:twgl/v3.Vec3} The transformed direction.\n * @memberOf module:twgl/m4\n */\nfunction transformDirection(m, v, dst) {\n  dst = dst || v3.create();\n\n  const v0 = v[0];\n  const v1 = v[1];\n  const v2 = v[2];\n\n  dst[0] = v0 * m[0 * 4 + 0] + v1 * m[1 * 4 + 0] + v2 * m[2 * 4 + 0];\n  dst[1] = v0 * m[0 * 4 + 1] + v1 * m[1 * 4 + 1] + v2 * m[2 * 4 + 1];\n  dst[2] = v0 * m[0 * 4 + 2] + v1 * m[1 * 4 + 2] + v2 * m[2 * 4 + 2];\n\n  return dst;\n}\n\n/**\n * Takes a 4-by-4 matrix m and a vector v with 3 entries, interprets the vector\n * as a normal to a surface, and computes a vector which is normal upon\n * transforming that surface by the matrix. The effect of this function is the\n * same as transforming v (as a direction) by the inverse-transpose of m.  This\n * function assumes the transformation of 3-dimensional space represented by the\n * matrix is parallel-preserving, i.e. any combination of rotation, scaling and\n * translation, but not a perspective distortion.  Returns a vector with 3\n * entries.\n * @param {module:twgl/m4.Mat4} m The matrix.\n * @param {module:twgl/v3.Vec3} v The normal.\n * @param {module:twgl/v3.Vec3} [dst] The direction. If not passed a new one is created.\n * @return {module:twgl/v3.Vec3} The transformed normal.\n * @memberOf module:twgl/m4\n */\nfunction transformNormal(m, v, dst) {\n  dst = dst || v3.create();\n  const mi = inverse(m);\n  const v0 = v[0];\n  const v1 = v[1];\n  const v2 = v[2];\n\n  dst[0] = v0 * mi[0 * 4 + 0] + v1 * mi[0 * 4 + 1] + v2 * mi[0 * 4 + 2];\n  dst[1] = v0 * mi[1 * 4 + 0] + v1 * mi[1 * 4 + 1] + v2 * mi[1 * 4 + 2];\n  dst[2] = v0 * mi[2 * 4 + 0] + v1 * mi[2 * 4 + 1] + v2 * mi[2 * 4 + 2];\n\n  return dst;\n}\n\nexport {\n  axisRotate,\n  axisRotation,\n  copy,\n  frustum,\n  getAxis,\n  getTranslation,\n  identity,\n  inverse,\n  lookAt,\n  multiply,\n  negate,\n  ortho,\n  perspective,\n  rotateX,\n  rotateY,\n  rotateZ,\n  rotationX,\n  rotationY,\n  rotationZ,\n  scale,\n  scaling,\n  setAxis,\n  setDefaultType,\n  setTranslation,\n  transformDirection,\n  transformNormal,\n  transformPoint,\n  translate,\n  translation,\n  transpose,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n/**\n * Various functions to make simple primitives\n *\n * note: Most primitive functions come in 3 styles\n *\n * *  `createSomeShapeBufferInfo`\n *\n *    These functions are almost always the functions you want to call. They\n *    create vertices then make WebGLBuffers and create {@link module:twgl.AttribInfo}s\n *    returning a {@link module:twgl.BufferInfo} you can pass to {@link module:twgl.setBuffersAndAttributes}\n *    and {@link module:twgl.drawBufferInfo} etc...\n *\n * *  `createSomeShapeBuffers`\n *\n *    These create WebGLBuffers and put your data in them but nothing else.\n *    It's a shortcut to doing it yourself if you don't want to use\n *    the higher level functions.\n *\n * *  `createSomeShapeVertices`\n *\n *    These just create vertices, no buffers. This allows you to manipulate the vertices\n *    or add more data before generating a {@link module:twgl.BufferInfo}. Once you're finished\n *    manipulating the vertices call {@link module:twgl.createBufferInfoFromArrays}.\n *\n *    example:\n *\n *        const arrays = twgl.primitives.createPlaneArrays(1);\n *        twgl.primitives.reorientVertices(arrays, m4.rotationX(Math.PI * 0.5));\n *        const bufferInfo = twgl.createBufferInfoFromArrays(gl, arrays);\n *\n * @module twgl/primitives\n */\nimport * as attributes from './attributes.js';\nimport * as helper from './helper.js';\nimport * as typedArrays from './typedarrays.js';\nimport * as m4 from './m4.js';\nimport * as v3 from './v3.js';\n\nconst getArray = attributes.getArray_;  // eslint-disable-line\nconst getNumComponents = attributes.getNumComponents_;  // eslint-disable-line\n\n/**\n * @typedef {(Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array)} TypedArray\n */\n\n/**\n * Add `push` to a typed array. It just keeps a 'cursor'\n * and allows use to `push` values into the array so we\n * don't have to manually compute offsets\n * @param {TypedArray} typedArray TypedArray to augment\n * @param {number} numComponents number of components.\n * @private\n */\nfunction augmentTypedArray(typedArray, numComponents) {\n  let cursor = 0;\n  typedArray.push = function() {\n    for (let ii = 0; ii < arguments.length; ++ii) {\n      const value = arguments[ii];\n      if (value instanceof Array || typedArrays.isArrayBuffer(value)) {\n        for (let jj = 0; jj < value.length; ++jj) {\n          typedArray[cursor++] = value[jj];\n        }\n      } else {\n        typedArray[cursor++] = value;\n      }\n    }\n  };\n  typedArray.reset = function(opt_index) {\n    cursor = opt_index || 0;\n  };\n  typedArray.numComponents = numComponents;\n  Object.defineProperty(typedArray, 'numElements', {\n    get: function() {\n      return this.length / this.numComponents | 0;\n    },\n  });\n  return typedArray;\n}\n\n/**\n * creates a typed array with a `push` function attached\n * so that you can easily *push* values.\n *\n * `push` can take multiple arguments. If an argument is an array each element\n * of the array will be added to the typed array.\n *\n * Example:\n *\n *     const array = createAugmentedTypedArray(3, 2);  // creates a Float32Array with 6 values\n *     array.push(1, 2, 3);\n *     array.push([4, 5, 6]);\n *     // array now contains [1, 2, 3, 4, 5, 6]\n *\n * Also has `numComponents` and `numElements` properties.\n *\n * @param {number} numComponents number of components\n * @param {number} numElements number of elements. The total size of the array will be `numComponents * numElements`.\n * @param {constructor} opt_type A constructor for the type. Default = `Float32Array`.\n * @return {ArrayBufferView} A typed array.\n * @memberOf module:twgl/primitives\n */\nfunction createAugmentedTypedArray(numComponents, numElements, opt_type) {\n  const Type = opt_type || Float32Array;\n  return augmentTypedArray(new Type(numComponents * numElements), numComponents);\n}\n\nfunction allButIndices(name) {\n  return name !== \"indices\";\n}\n\n/**\n * Given indexed vertices creates a new set of vertices un-indexed by expanding the indexed vertices.\n * @param {Object.<string, TypedArray>} vertices The indexed vertices to deindex\n * @return {Object.<string, TypedArray>} The deindexed vertices\n * @memberOf module:twgl/primitives\n */\nfunction deindexVertices(vertices) {\n  const indices = vertices.indices;\n  const newVertices = {};\n  const numElements = indices.length;\n\n  function expandToUnindexed(channel) {\n    const srcBuffer = vertices[channel];\n    const numComponents = srcBuffer.numComponents;\n    const dstBuffer = createAugmentedTypedArray(numComponents, numElements, srcBuffer.constructor);\n    for (let ii = 0; ii < numElements; ++ii) {\n      const ndx = indices[ii];\n      const offset = ndx * numComponents;\n      for (let jj = 0; jj < numComponents; ++jj) {\n        dstBuffer.push(srcBuffer[offset + jj]);\n      }\n    }\n    newVertices[channel] = dstBuffer;\n  }\n\n  Object.keys(vertices).filter(allButIndices).forEach(expandToUnindexed);\n\n  return newVertices;\n}\n\n/**\n * flattens the normals of deindexed vertices in place.\n * @param {Object.<string, TypedArray>} vertices The deindexed vertices who's normals to flatten\n * @return {Object.<string, TypedArray>} The flattened vertices (same as was passed in)\n * @memberOf module:twgl/primitives\n */\nfunction flattenNormals(vertices) {\n  if (vertices.indices) {\n    throw new Error('can not flatten normals of indexed vertices. deindex them first');\n  }\n\n  const normals = vertices.normal;\n  const numNormals = normals.length;\n  for (let ii = 0; ii < numNormals; ii += 9) {\n    // pull out the 3 normals for this triangle\n    const nax = normals[ii + 0];\n    const nay = normals[ii + 1];\n    const naz = normals[ii + 2];\n\n    const nbx = normals[ii + 3];\n    const nby = normals[ii + 4];\n    const nbz = normals[ii + 5];\n\n    const ncx = normals[ii + 6];\n    const ncy = normals[ii + 7];\n    const ncz = normals[ii + 8];\n\n    // add them\n    let nx = nax + nbx + ncx;\n    let ny = nay + nby + ncy;\n    let nz = naz + nbz + ncz;\n\n    // normalize them\n    const length = Math.sqrt(nx * nx + ny * ny + nz * nz);\n\n    nx /= length;\n    ny /= length;\n    nz /= length;\n\n    // copy them back in\n    normals[ii + 0] = nx;\n    normals[ii + 1] = ny;\n    normals[ii + 2] = nz;\n\n    normals[ii + 3] = nx;\n    normals[ii + 4] = ny;\n    normals[ii + 5] = nz;\n\n    normals[ii + 6] = nx;\n    normals[ii + 7] = ny;\n    normals[ii + 8] = nz;\n  }\n\n  return vertices;\n}\n\nfunction applyFuncToV3Array(array, matrix, fn) {\n  const len = array.length;\n  const tmp = new Float32Array(3);\n  for (let ii = 0; ii < len; ii += 3) {\n    fn(matrix, [array[ii], array[ii + 1], array[ii + 2]], tmp);\n    array[ii    ] = tmp[0];\n    array[ii + 1] = tmp[1];\n    array[ii + 2] = tmp[2];\n  }\n}\n\nfunction transformNormal(mi, v, dst) {\n  dst = dst || v3.create();\n  const v0 = v[0];\n  const v1 = v[1];\n  const v2 = v[2];\n\n  dst[0] = v0 * mi[0 * 4 + 0] + v1 * mi[0 * 4 + 1] + v2 * mi[0 * 4 + 2];\n  dst[1] = v0 * mi[1 * 4 + 0] + v1 * mi[1 * 4 + 1] + v2 * mi[1 * 4 + 2];\n  dst[2] = v0 * mi[2 * 4 + 0] + v1 * mi[2 * 4 + 1] + v2 * mi[2 * 4 + 2];\n\n  return dst;\n}\n\n/**\n * Reorients directions by the given matrix..\n * @param {(number[]|TypedArray)} array The array. Assumes value floats per element.\n * @param {module:twgl/m4.Mat4} matrix A matrix to multiply by.\n * @return {(number[]|TypedArray)} the same array that was passed in\n * @memberOf module:twgl/primitives\n */\nfunction reorientDirections(array, matrix) {\n  applyFuncToV3Array(array, matrix, m4.transformDirection);\n  return array;\n}\n\n/**\n * Reorients normals by the inverse-transpose of the given\n * matrix..\n * @param {(number[]|TypedArray)} array The array. Assumes value floats per element.\n * @param {module:twgl/m4.Mat4} matrix A matrix to multiply by.\n * @return {(number[]|TypedArray)} the same array that was passed in\n * @memberOf module:twgl/primitives\n */\nfunction reorientNormals(array, matrix) {\n  applyFuncToV3Array(array, m4.inverse(matrix), transformNormal);\n  return array;\n}\n\n/**\n * Reorients positions by the given matrix. In other words, it\n * multiplies each vertex by the given matrix.\n * @param {(number[]|TypedArray)} array The array. Assumes value floats per element.\n * @param {module:twgl/m4.Mat4} matrix A matrix to multiply by.\n * @return {(number[]|TypedArray)} the same array that was passed in\n * @memberOf module:twgl/primitives\n */\nfunction reorientPositions(array, matrix) {\n  applyFuncToV3Array(array, matrix, m4.transformPoint);\n  return array;\n}\n\n/**\n * @typedef {(number[]|TypedArray)} NativeArrayOrTypedArray\n */\n\n/**\n * Reorients arrays by the given matrix. Assumes arrays have\n * names that contains 'pos' could be reoriented as positions,\n * 'binorm' or 'tan' as directions, and 'norm' as normals.\n *\n * @param {Object.<string, NativeArrayOrTypedArray>} arrays The vertices to reorient\n * @param {module:twgl/m4.Mat4} matrix matrix to reorient by.\n * @return {Object.<string, NativeArrayOrTypedArray>} same arrays that were passed in.\n * @memberOf module:twgl/primitives\n */\nfunction reorientVertices(arrays, matrix) {\n  Object.keys(arrays).forEach(function(name) {\n    const array = arrays[name];\n    if (name.indexOf(\"pos\") >= 0) {\n      reorientPositions(array, matrix);\n    } else if (name.indexOf(\"tan\") >= 0 || name.indexOf(\"binorm\") >= 0) {\n      reorientDirections(array, matrix);\n    } else if (name.indexOf(\"norm\") >= 0) {\n      reorientNormals(array, matrix);\n    }\n  });\n  return arrays;\n}\n\n/**\n * Creates XY quad BufferInfo\n *\n * The default with no parameters will return a 2x2 quad with values from -1 to +1.\n * If you want a unit quad with that goes from 0 to 1 you'd call it with\n *\n *     twgl.primitives.createXYQuadBufferInfo(gl, 1, 0.5, 0.5);\n *\n * If you want a unit quad centered above 0,0 you'd call it with\n *\n *     twgl.primitives.createXYQuadBufferInfo(gl, 1, 0, 0.5);\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} [size] the size across the quad. Defaults to 2 which means vertices will go from -1 to +1\n * @param {number} [xOffset] the amount to offset the quad in X\n * @param {number} [yOffset] the amount to offset the quad in Y\n * @return {Object.<string, WebGLBuffer>} the created XY Quad BufferInfo\n * @memberOf module:twgl/primitives\n * @function createXYQuadBuffers\n */\n\n/**\n * Creates XY quad Buffers\n *\n * The default with no parameters will return a 2x2 quad with values from -1 to +1.\n * If you want a unit quad with that goes from 0 to 1 you'd call it with\n *\n *     twgl.primitives.createXYQuadBufferInfo(gl, 1, 0.5, 0.5);\n *\n * If you want a unit quad centered above 0,0 you'd call it with\n *\n *     twgl.primitives.createXYQuadBufferInfo(gl, 1, 0, 0.5);\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} [size] the size across the quad. Defaults to 2 which means vertices will go from -1 to +1\n * @param {number} [xOffset] the amount to offset the quad in X\n * @param {number} [yOffset] the amount to offset the quad in Y\n * @return {module:twgl.BufferInfo} the created XY Quad buffers\n * @memberOf module:twgl/primitives\n * @function createXYQuadBufferInfo\n */\n\n/**\n * Creates XY quad vertices\n *\n * The default with no parameters will return a 2x2 quad with values from -1 to +1.\n * If you want a unit quad with that goes from 0 to 1 you'd call it with\n *\n *     twgl.primitives.createXYQuadVertices(1, 0.5, 0.5);\n *\n * If you want a unit quad centered above 0,0 you'd call it with\n *\n *     twgl.primitives.createXYQuadVertices(1, 0, 0.5);\n *\n * @param {number} [size] the size across the quad. Defaults to 2 which means vertices will go from -1 to +1\n * @param {number} [xOffset] the amount to offset the quad in X\n * @param {number} [yOffset] the amount to offset the quad in Y\n * @return {Object.<string, TypedArray>} the created XY Quad vertices\n * @memberOf module:twgl/primitives\n */\nfunction createXYQuadVertices(size, xOffset, yOffset) {\n  size = size || 2;\n  xOffset = xOffset || 0;\n  yOffset = yOffset || 0;\n  size *= 0.5;\n  return {\n    position: {\n      numComponents: 2,\n      data: [\n        xOffset + -1 * size, yOffset + -1 * size,\n        xOffset +  1 * size, yOffset + -1 * size,\n        xOffset + -1 * size, yOffset +  1 * size,\n        xOffset +  1 * size, yOffset +  1 * size,\n      ],\n    },\n    normal: [\n      0, 0, 1,\n      0, 0, 1,\n      0, 0, 1,\n      0, 0, 1,\n    ],\n    texcoord: [\n      0, 0,\n      1, 0,\n      0, 1,\n      1, 1,\n    ],\n    indices: [ 0, 1, 2, 2, 1, 3 ],\n  };\n}\n\n/**\n * Creates XZ plane BufferInfo.\n *\n * The created plane has position, normal, and texcoord data\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} [width] Width of the plane. Default = 1\n * @param {number} [depth] Depth of the plane. Default = 1\n * @param {number} [subdivisionsWidth] Number of steps across the plane. Default = 1\n * @param {number} [subdivisionsDepth] Number of steps down the plane. Default = 1\n * @param {module:twgl/m4.Mat4} [matrix] A matrix by which to multiply all the vertices.\n * @return {module:twgl.BufferInfo} The created plane BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createPlaneBufferInfo\n */\n\n/**\n * Creates XZ plane buffers.\n *\n * The created plane has position, normal, and texcoord data\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} [width] Width of the plane. Default = 1\n * @param {number} [depth] Depth of the plane. Default = 1\n * @param {number} [subdivisionsWidth] Number of steps across the plane. Default = 1\n * @param {number} [subdivisionsDepth] Number of steps down the plane. Default = 1\n * @param {module:twgl/m4.Mat4} [matrix] A matrix by which to multiply all the vertices.\n * @return {Object.<string, WebGLBuffer>} The created plane buffers.\n * @memberOf module:twgl/primitives\n * @function createPlaneBuffers\n */\n\n/**\n * Creates XZ plane vertices.\n *\n * The created plane has position, normal, and texcoord data\n *\n * @param {number} [width] Width of the plane. Default = 1\n * @param {number} [depth] Depth of the plane. Default = 1\n * @param {number} [subdivisionsWidth] Number of steps across the plane. Default = 1\n * @param {number} [subdivisionsDepth] Number of steps down the plane. Default = 1\n * @param {module:twgl/m4.Mat4} [matrix] A matrix by which to multiply all the vertices.\n * @return {Object.<string, TypedArray>} The created plane vertices.\n * @memberOf module:twgl/primitives\n */\nfunction createPlaneVertices(\n    width,\n    depth,\n    subdivisionsWidth,\n    subdivisionsDepth,\n    matrix) {\n  width = width || 1;\n  depth = depth || 1;\n  subdivisionsWidth = subdivisionsWidth || 1;\n  subdivisionsDepth = subdivisionsDepth || 1;\n  matrix = matrix || m4.identity();\n\n  const numVertices = (subdivisionsWidth + 1) * (subdivisionsDepth + 1);\n  const positions = createAugmentedTypedArray(3, numVertices);\n  const normals = createAugmentedTypedArray(3, numVertices);\n  const texcoords = createAugmentedTypedArray(2, numVertices);\n\n  for (let z = 0; z <= subdivisionsDepth; z++) {\n    for (let x = 0; x <= subdivisionsWidth; x++) {\n      const u = x / subdivisionsWidth;\n      const v = z / subdivisionsDepth;\n      positions.push(\n          width * u - width * 0.5,\n          0,\n          depth * v - depth * 0.5);\n      normals.push(0, 1, 0);\n      texcoords.push(u, v);\n    }\n  }\n\n  const numVertsAcross = subdivisionsWidth + 1;\n  const indices = createAugmentedTypedArray(\n      3, subdivisionsWidth * subdivisionsDepth * 2, Uint16Array);\n\n  for (let z = 0; z < subdivisionsDepth; z++) {  // eslint-disable-line\n    for (let x = 0; x < subdivisionsWidth; x++) {  // eslint-disable-line\n      // Make triangle 1 of quad.\n      indices.push(\n          (z + 0) * numVertsAcross + x,\n          (z + 1) * numVertsAcross + x,\n          (z + 0) * numVertsAcross + x + 1);\n\n      // Make triangle 2 of quad.\n      indices.push(\n          (z + 1) * numVertsAcross + x,\n          (z + 1) * numVertsAcross + x + 1,\n          (z + 0) * numVertsAcross + x + 1);\n    }\n  }\n\n  const arrays = reorientVertices({\n    position: positions,\n    normal: normals,\n    texcoord: texcoords,\n    indices: indices,\n  }, matrix);\n  return arrays;\n}\n\n/**\n * Creates sphere BufferInfo.\n *\n * The created sphere has position, normal, and texcoord data\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} radius radius of the sphere.\n * @param {number} subdivisionsAxis number of steps around the sphere.\n * @param {number} subdivisionsHeight number of vertically on the sphere.\n * @param {number} [opt_startLatitudeInRadians] where to start the\n *     top of the sphere. Default = 0.\n * @param {number} [opt_endLatitudeInRadians] Where to end the\n *     bottom of the sphere. Default = Math.PI.\n * @param {number} [opt_startLongitudeInRadians] where to start\n *     wrapping the sphere. Default = 0.\n * @param {number} [opt_endLongitudeInRadians] where to end\n *     wrapping the sphere. Default = 2 * Math.PI.\n * @return {module:twgl.BufferInfo} The created sphere BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createSphereBufferInfo\n */\n\n/**\n * Creates sphere buffers.\n *\n * The created sphere has position, normal, and texcoord data\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} radius radius of the sphere.\n * @param {number} subdivisionsAxis number of steps around the sphere.\n * @param {number} subdivisionsHeight number of vertically on the sphere.\n * @param {number} [opt_startLatitudeInRadians] where to start the\n *     top of the sphere. Default = 0.\n * @param {number} [opt_endLatitudeInRadians] Where to end the\n *     bottom of the sphere. Default = Math.PI.\n * @param {number} [opt_startLongitudeInRadians] where to start\n *     wrapping the sphere. Default = 0.\n * @param {number} [opt_endLongitudeInRadians] where to end\n *     wrapping the sphere. Default = 2 * Math.PI.\n * @return {Object.<string, WebGLBuffer>} The created sphere buffers.\n * @memberOf module:twgl/primitives\n * @function createSphereBuffers\n */\n\n/**\n * Creates sphere vertices.\n *\n * The created sphere has position, normal, and texcoord data\n *\n * @param {number} radius radius of the sphere.\n * @param {number} subdivisionsAxis number of steps around the sphere.\n * @param {number} subdivisionsHeight number of vertically on the sphere.\n * @param {number} [opt_startLatitudeInRadians] where to start the\n *     top of the sphere. Default = 0.\n * @param {number} [opt_endLatitudeInRadians] Where to end the\n *     bottom of the sphere. Default = Math.PI.\n * @param {number} [opt_startLongitudeInRadians] where to start\n *     wrapping the sphere. Default = 0.\n * @param {number} [opt_endLongitudeInRadians] where to end\n *     wrapping the sphere. Default = 2 * Math.PI.\n * @return {Object.<string, TypedArray>} The created sphere vertices.\n * @memberOf module:twgl/primitives\n */\nfunction createSphereVertices(\n    radius,\n    subdivisionsAxis,\n    subdivisionsHeight,\n    opt_startLatitudeInRadians,\n    opt_endLatitudeInRadians,\n    opt_startLongitudeInRadians,\n    opt_endLongitudeInRadians) {\n  if (subdivisionsAxis <= 0 || subdivisionsHeight <= 0) {\n    throw new Error('subdivisionAxis and subdivisionHeight must be > 0');\n  }\n\n  opt_startLatitudeInRadians = opt_startLatitudeInRadians || 0;\n  opt_endLatitudeInRadians = opt_endLatitudeInRadians || Math.PI;\n  opt_startLongitudeInRadians = opt_startLongitudeInRadians || 0;\n  opt_endLongitudeInRadians = opt_endLongitudeInRadians || (Math.PI * 2);\n\n  const latRange = opt_endLatitudeInRadians - opt_startLatitudeInRadians;\n  const longRange = opt_endLongitudeInRadians - opt_startLongitudeInRadians;\n\n  // We are going to generate our sphere by iterating through its\n  // spherical coordinates and generating 2 triangles for each quad on a\n  // ring of the sphere.\n  const numVertices = (subdivisionsAxis + 1) * (subdivisionsHeight + 1);\n  const positions = createAugmentedTypedArray(3, numVertices);\n  const normals   = createAugmentedTypedArray(3, numVertices);\n  const texcoords = createAugmentedTypedArray(2, numVertices);\n\n  // Generate the individual vertices in our vertex buffer.\n  for (let y = 0; y <= subdivisionsHeight; y++) {\n    for (let x = 0; x <= subdivisionsAxis; x++) {\n      // Generate a vertex based on its spherical coordinates\n      const u = x / subdivisionsAxis;\n      const v = y / subdivisionsHeight;\n      const theta = longRange * u + opt_startLongitudeInRadians;\n      const phi = latRange * v + opt_startLatitudeInRadians;\n      const sinTheta = Math.sin(theta);\n      const cosTheta = Math.cos(theta);\n      const sinPhi = Math.sin(phi);\n      const cosPhi = Math.cos(phi);\n      const ux = cosTheta * sinPhi;\n      const uy = cosPhi;\n      const uz = sinTheta * sinPhi;\n      positions.push(radius * ux, radius * uy, radius * uz);\n      normals.push(ux, uy, uz);\n      texcoords.push(1 - u, v);\n    }\n  }\n\n  const numVertsAround = subdivisionsAxis + 1;\n  const indices = createAugmentedTypedArray(3, subdivisionsAxis * subdivisionsHeight * 2, Uint16Array);\n  for (let x = 0; x < subdivisionsAxis; x++) {  // eslint-disable-line\n    for (let y = 0; y < subdivisionsHeight; y++) {  // eslint-disable-line\n      // Make triangle 1 of quad.\n      indices.push(\n          (y + 0) * numVertsAround + x,\n          (y + 0) * numVertsAround + x + 1,\n          (y + 1) * numVertsAround + x);\n\n      // Make triangle 2 of quad.\n      indices.push(\n          (y + 1) * numVertsAround + x,\n          (y + 0) * numVertsAround + x + 1,\n          (y + 1) * numVertsAround + x + 1);\n    }\n  }\n\n  return {\n    position: positions,\n    normal: normals,\n    texcoord: texcoords,\n    indices: indices,\n  };\n}\n\n/**\n * Array of the indices of corners of each face of a cube.\n * @type {Array.<number[]>}\n * @private\n */\nconst CUBE_FACE_INDICES = [\n  [3, 7, 5, 1],  // right\n  [6, 2, 0, 4],  // left\n  [6, 7, 3, 2],  // ??\n  [0, 1, 5, 4],  // ??\n  [7, 6, 4, 5],  // front\n  [2, 3, 1, 0],  // back\n];\n\n/**\n * Creates a BufferInfo for a cube.\n *\n * The cube is created around the origin. (-size / 2, size / 2).\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} [size] width, height and depth of the cube.\n * @return {module:twgl.BufferInfo} The created BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createCubeBufferInfo\n */\n\n/**\n * Creates the buffers and indices for a cube.\n *\n * The cube is created around the origin. (-size / 2, size / 2).\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} [size] width, height and depth of the cube.\n * @return {Object.<string, WebGLBuffer>} The created buffers.\n * @memberOf module:twgl/primitives\n * @function createCubeBuffers\n */\n\n/**\n * Creates the vertices and indices for a cube.\n *\n * The cube is created around the origin. (-size / 2, size / 2).\n *\n * @param {number} [size] width, height and depth of the cube.\n * @return {Object.<string, TypedArray>} The created vertices.\n * @memberOf module:twgl/primitives\n */\nfunction createCubeVertices(size) {\n  size = size || 1;\n  const k = size / 2;\n\n  const cornerVertices = [\n    [-k, -k, -k],\n    [+k, -k, -k],\n    [-k, +k, -k],\n    [+k, +k, -k],\n    [-k, -k, +k],\n    [+k, -k, +k],\n    [-k, +k, +k],\n    [+k, +k, +k],\n  ];\n\n  const faceNormals = [\n    [+1, +0, +0],\n    [-1, +0, +0],\n    [+0, +1, +0],\n    [+0, -1, +0],\n    [+0, +0, +1],\n    [+0, +0, -1],\n  ];\n\n  const uvCoords = [\n    [1, 0],\n    [0, 0],\n    [0, 1],\n    [1, 1],\n  ];\n\n  const numVertices = 6 * 4;\n  const positions = createAugmentedTypedArray(3, numVertices);\n  const normals   = createAugmentedTypedArray(3, numVertices);\n  const texcoords = createAugmentedTypedArray(2 , numVertices);\n  const indices   = createAugmentedTypedArray(3, 6 * 2, Uint16Array);\n\n  for (let f = 0; f < 6; ++f) {\n    const faceIndices = CUBE_FACE_INDICES[f];\n    for (let v = 0; v < 4; ++v) {\n      const position = cornerVertices[faceIndices[v]];\n      const normal = faceNormals[f];\n      const uv = uvCoords[v];\n\n      // Each face needs all four vertices because the normals and texture\n      // coordinates are not all the same.\n      positions.push(position);\n      normals.push(normal);\n      texcoords.push(uv);\n\n    }\n    // Two triangles make a square face.\n    const offset = 4 * f;\n    indices.push(offset + 0, offset + 1, offset + 2);\n    indices.push(offset + 0, offset + 2, offset + 3);\n  }\n\n  return {\n    position: positions,\n    normal: normals,\n    texcoord: texcoords,\n    indices: indices,\n  };\n}\n\n/**\n * Creates a BufferInfo for a truncated cone, which is like a cylinder\n * except that it has different top and bottom radii. A truncated cone\n * can also be used to create cylinders and regular cones. The\n * truncated cone will be created centered about the origin, with the\n * y axis as its vertical axis.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} bottomRadius Bottom radius of truncated cone.\n * @param {number} topRadius Top radius of truncated cone.\n * @param {number} height Height of truncated cone.\n * @param {number} radialSubdivisions The number of subdivisions around the\n *     truncated cone.\n * @param {number} verticalSubdivisions The number of subdivisions down the\n *     truncated cone.\n * @param {boolean} [opt_topCap] Create top cap. Default = true.\n * @param {boolean} [opt_bottomCap] Create bottom cap. Default = true.\n * @return {module:twgl.BufferInfo} The created cone BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createTruncatedConeBufferInfo\n */\n\n/**\n * Creates buffers for a truncated cone, which is like a cylinder\n * except that it has different top and bottom radii. A truncated cone\n * can also be used to create cylinders and regular cones. The\n * truncated cone will be created centered about the origin, with the\n * y axis as its vertical axis.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} bottomRadius Bottom radius of truncated cone.\n * @param {number} topRadius Top radius of truncated cone.\n * @param {number} height Height of truncated cone.\n * @param {number} radialSubdivisions The number of subdivisions around the\n *     truncated cone.\n * @param {number} verticalSubdivisions The number of subdivisions down the\n *     truncated cone.\n * @param {boolean} [opt_topCap] Create top cap. Default = true.\n * @param {boolean} [opt_bottomCap] Create bottom cap. Default = true.\n * @return {Object.<string, WebGLBuffer>} The created cone buffers.\n * @memberOf module:twgl/primitives\n * @function createTruncatedConeBuffers\n */\n\n/**\n * Creates vertices for a truncated cone, which is like a cylinder\n * except that it has different top and bottom radii. A truncated cone\n * can also be used to create cylinders and regular cones. The\n * truncated cone will be created centered about the origin, with the\n * y axis as its vertical axis. .\n *\n * @param {number} bottomRadius Bottom radius of truncated cone.\n * @param {number} topRadius Top radius of truncated cone.\n * @param {number} height Height of truncated cone.\n * @param {number} radialSubdivisions The number of subdivisions around the\n *     truncated cone.\n * @param {number} verticalSubdivisions The number of subdivisions down the\n *     truncated cone.\n * @param {boolean} [opt_topCap] Create top cap. Default = true.\n * @param {boolean} [opt_bottomCap] Create bottom cap. Default = true.\n * @return {Object.<string, TypedArray>} The created cone vertices.\n * @memberOf module:twgl/primitives\n */\nfunction createTruncatedConeVertices(\n    bottomRadius,\n    topRadius,\n    height,\n    radialSubdivisions,\n    verticalSubdivisions,\n    opt_topCap,\n    opt_bottomCap) {\n  if (radialSubdivisions < 3) {\n    throw new Error('radialSubdivisions must be 3 or greater');\n  }\n\n  if (verticalSubdivisions < 1) {\n    throw new Error('verticalSubdivisions must be 1 or greater');\n  }\n\n  const topCap = (opt_topCap === undefined) ? true : opt_topCap;\n  const bottomCap = (opt_bottomCap === undefined) ? true : opt_bottomCap;\n\n  const extra = (topCap ? 2 : 0) + (bottomCap ? 2 : 0);\n\n  const numVertices = (radialSubdivisions + 1) * (verticalSubdivisions + 1 + extra);\n  const positions = createAugmentedTypedArray(3, numVertices);\n  const normals   = createAugmentedTypedArray(3, numVertices);\n  const texcoords = createAugmentedTypedArray(2, numVertices);\n  const indices   = createAugmentedTypedArray(3, radialSubdivisions * (verticalSubdivisions + extra / 2) * 2, Uint16Array);\n\n  const vertsAroundEdge = radialSubdivisions + 1;\n\n  // The slant of the cone is constant across its surface\n  const slant = Math.atan2(bottomRadius - topRadius, height);\n  const cosSlant = Math.cos(slant);\n  const sinSlant = Math.sin(slant);\n\n  const start = topCap ? -2 : 0;\n  const end = verticalSubdivisions + (bottomCap ? 2 : 0);\n\n  for (let yy = start; yy <= end; ++yy) {\n    let v = yy / verticalSubdivisions;\n    let y = height * v;\n    let ringRadius;\n    if (yy < 0) {\n      y = 0;\n      v = 1;\n      ringRadius = bottomRadius;\n    } else if (yy > verticalSubdivisions) {\n      y = height;\n      v = 1;\n      ringRadius = topRadius;\n    } else {\n      ringRadius = bottomRadius +\n        (topRadius - bottomRadius) * (yy / verticalSubdivisions);\n    }\n    if (yy === -2 || yy === verticalSubdivisions + 2) {\n      ringRadius = 0;\n      v = 0;\n    }\n    y -= height / 2;\n    for (let ii = 0; ii < vertsAroundEdge; ++ii) {\n      const sin = Math.sin(ii * Math.PI * 2 / radialSubdivisions);\n      const cos = Math.cos(ii * Math.PI * 2 / radialSubdivisions);\n      positions.push(sin * ringRadius, y, cos * ringRadius);\n      if (yy < 0) {\n        normals.push(0, -1, 0);\n      } else if (yy > verticalSubdivisions) {\n        normals.push(0, 1, 0);\n      } else if (ringRadius === 0.0) {\n        normals.push(0, 0, 0);\n      } else {\n        normals.push(sin * cosSlant, sinSlant, cos * cosSlant);\n      }\n      texcoords.push((ii / radialSubdivisions), 1 - v);\n    }\n  }\n\n  for (let yy = 0; yy < verticalSubdivisions + extra; ++yy) {  // eslint-disable-line\n    if (yy === 1 && topCap || yy === verticalSubdivisions + extra - 2 && bottomCap) {\n      continue;\n    }\n    for (let ii = 0; ii < radialSubdivisions; ++ii) {  // eslint-disable-line\n      indices.push(vertsAroundEdge * (yy + 0) + 0 + ii,\n                   vertsAroundEdge * (yy + 0) + 1 + ii,\n                   vertsAroundEdge * (yy + 1) + 1 + ii);\n      indices.push(vertsAroundEdge * (yy + 0) + 0 + ii,\n                   vertsAroundEdge * (yy + 1) + 1 + ii,\n                   vertsAroundEdge * (yy + 1) + 0 + ii);\n    }\n  }\n\n  return {\n    position: positions,\n    normal: normals,\n    texcoord: texcoords,\n    indices: indices,\n  };\n}\n\n/**\n * Expands RLE data\n * @param {number[]} rleData data in format of run-length, x, y, z, run-length, x, y, z\n * @param {number[]} [padding] value to add each entry with.\n * @return {number[]} the expanded rleData\n * @private\n */\nfunction expandRLEData(rleData, padding) {\n  padding = padding || [];\n  const data = [];\n  for (let ii = 0; ii < rleData.length; ii += 4) {\n    const runLength = rleData[ii];\n    const element = rleData.slice(ii + 1, ii + 4);\n    element.push.apply(element, padding);\n    for (let jj = 0; jj < runLength; ++jj) {\n      data.push.apply(data, element);\n    }\n  }\n  return data;\n}\n\n/**\n * Creates 3D 'F' BufferInfo.\n * An 'F' is useful because you can easily tell which way it is oriented.\n * The created 'F' has position, normal, texcoord, and color buffers.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @return {module:twgl.BufferInfo} The created BufferInfo.\n * @memberOf module:twgl/primitives\n * @function create3DFBufferInfo\n */\n\n/**\n * Creates 3D 'F' buffers.\n * An 'F' is useful because you can easily tell which way it is oriented.\n * The created 'F' has position, normal, texcoord, and color buffers.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @return {Object.<string, WebGLBuffer>} The created buffers.\n * @memberOf module:twgl/primitives\n * @function create3DFBuffers\n */\n\n/**\n * Creates 3D 'F' vertices.\n * An 'F' is useful because you can easily tell which way it is oriented.\n * The created 'F' has position, normal, texcoord, and color arrays.\n *\n * @return {Object.<string, TypedArray>} The created vertices.\n * @memberOf module:twgl/primitives\n */\nfunction create3DFVertices() {\n\n  const positions = [\n    // left column front\n    0,   0,  0,\n    0, 150,  0,\n    30,   0,  0,\n    0, 150,  0,\n    30, 150,  0,\n    30,   0,  0,\n\n    // top rung front\n    30,   0,  0,\n    30,  30,  0,\n    100,   0,  0,\n    30,  30,  0,\n    100,  30,  0,\n    100,   0,  0,\n\n    // middle rung front\n    30,  60,  0,\n    30,  90,  0,\n    67,  60,  0,\n    30,  90,  0,\n    67,  90,  0,\n    67,  60,  0,\n\n    // left column back\n      0,   0,  30,\n     30,   0,  30,\n      0, 150,  30,\n      0, 150,  30,\n     30,   0,  30,\n     30, 150,  30,\n\n    // top rung back\n     30,   0,  30,\n    100,   0,  30,\n     30,  30,  30,\n     30,  30,  30,\n    100,   0,  30,\n    100,  30,  30,\n\n    // middle rung back\n     30,  60,  30,\n     67,  60,  30,\n     30,  90,  30,\n     30,  90,  30,\n     67,  60,  30,\n     67,  90,  30,\n\n    // top\n      0,   0,   0,\n    100,   0,   0,\n    100,   0,  30,\n      0,   0,   0,\n    100,   0,  30,\n      0,   0,  30,\n\n    // top rung front\n    100,   0,   0,\n    100,  30,   0,\n    100,  30,  30,\n    100,   0,   0,\n    100,  30,  30,\n    100,   0,  30,\n\n    // under top rung\n    30,   30,   0,\n    30,   30,  30,\n    100,  30,  30,\n    30,   30,   0,\n    100,  30,  30,\n    100,  30,   0,\n\n    // between top rung and middle\n    30,   30,   0,\n    30,   60,  30,\n    30,   30,  30,\n    30,   30,   0,\n    30,   60,   0,\n    30,   60,  30,\n\n    // top of middle rung\n    30,   60,   0,\n    67,   60,  30,\n    30,   60,  30,\n    30,   60,   0,\n    67,   60,   0,\n    67,   60,  30,\n\n    // front of middle rung\n    67,   60,   0,\n    67,   90,  30,\n    67,   60,  30,\n    67,   60,   0,\n    67,   90,   0,\n    67,   90,  30,\n\n    // bottom of middle rung.\n    30,   90,   0,\n    30,   90,  30,\n    67,   90,  30,\n    30,   90,   0,\n    67,   90,  30,\n    67,   90,   0,\n\n    // front of bottom\n    30,   90,   0,\n    30,  150,  30,\n    30,   90,  30,\n    30,   90,   0,\n    30,  150,   0,\n    30,  150,  30,\n\n    // bottom\n    0,   150,   0,\n    0,   150,  30,\n    30,  150,  30,\n    0,   150,   0,\n    30,  150,  30,\n    30,  150,   0,\n\n    // left side\n    0,   0,   0,\n    0,   0,  30,\n    0, 150,  30,\n    0,   0,   0,\n    0, 150,  30,\n    0, 150,   0,\n  ];\n\n  const texcoords = [\n    // left column front\n    0.22, 0.19,\n    0.22, 0.79,\n    0.34, 0.19,\n    0.22, 0.79,\n    0.34, 0.79,\n    0.34, 0.19,\n\n    // top rung front\n    0.34, 0.19,\n    0.34, 0.31,\n    0.62, 0.19,\n    0.34, 0.31,\n    0.62, 0.31,\n    0.62, 0.19,\n\n    // middle rung front\n    0.34, 0.43,\n    0.34, 0.55,\n    0.49, 0.43,\n    0.34, 0.55,\n    0.49, 0.55,\n    0.49, 0.43,\n\n    // left column back\n    0, 0,\n    1, 0,\n    0, 1,\n    0, 1,\n    1, 0,\n    1, 1,\n\n    // top rung back\n    0, 0,\n    1, 0,\n    0, 1,\n    0, 1,\n    1, 0,\n    1, 1,\n\n    // middle rung back\n    0, 0,\n    1, 0,\n    0, 1,\n    0, 1,\n    1, 0,\n    1, 1,\n\n    // top\n    0, 0,\n    1, 0,\n    1, 1,\n    0, 0,\n    1, 1,\n    0, 1,\n\n    // top rung front\n    0, 0,\n    1, 0,\n    1, 1,\n    0, 0,\n    1, 1,\n    0, 1,\n\n    // under top rung\n    0, 0,\n    0, 1,\n    1, 1,\n    0, 0,\n    1, 1,\n    1, 0,\n\n    // between top rung and middle\n    0, 0,\n    1, 1,\n    0, 1,\n    0, 0,\n    1, 0,\n    1, 1,\n\n    // top of middle rung\n    0, 0,\n    1, 1,\n    0, 1,\n    0, 0,\n    1, 0,\n    1, 1,\n\n    // front of middle rung\n    0, 0,\n    1, 1,\n    0, 1,\n    0, 0,\n    1, 0,\n    1, 1,\n\n    // bottom of middle rung.\n    0, 0,\n    0, 1,\n    1, 1,\n    0, 0,\n    1, 1,\n    1, 0,\n\n    // front of bottom\n    0, 0,\n    1, 1,\n    0, 1,\n    0, 0,\n    1, 0,\n    1, 1,\n\n    // bottom\n    0, 0,\n    0, 1,\n    1, 1,\n    0, 0,\n    1, 1,\n    1, 0,\n\n    // left side\n    0, 0,\n    0, 1,\n    1, 1,\n    0, 0,\n    1, 1,\n    1, 0,\n  ];\n\n  const normals = expandRLEData([\n    // left column front\n    // top rung front\n    // middle rung front\n    18, 0, 0, 1,\n\n    // left column back\n    // top rung back\n    // middle rung back\n    18, 0, 0, -1,\n\n    // top\n    6, 0, 1, 0,\n\n    // top rung front\n    6, 1, 0, 0,\n\n    // under top rung\n    6, 0, -1, 0,\n\n    // between top rung and middle\n    6, 1, 0, 0,\n\n    // top of middle rung\n    6, 0, 1, 0,\n\n    // front of middle rung\n    6, 1, 0, 0,\n\n    // bottom of middle rung.\n    6, 0, -1, 0,\n\n    // front of bottom\n    6, 1, 0, 0,\n\n    // bottom\n    6, 0, -1, 0,\n\n    // left side\n    6, -1, 0, 0,\n  ]);\n\n  const colors = expandRLEData([\n        // left column front\n        // top rung front\n        // middle rung front\n      18, 200,  70, 120,\n\n        // left column back\n        // top rung back\n        // middle rung back\n      18, 80, 70, 200,\n\n        // top\n      6, 70, 200, 210,\n\n        // top rung front\n      6, 200, 200, 70,\n\n        // under top rung\n      6, 210, 100, 70,\n\n        // between top rung and middle\n      6, 210, 160, 70,\n\n        // top of middle rung\n      6, 70, 180, 210,\n\n        // front of middle rung\n      6, 100, 70, 210,\n\n        // bottom of middle rung.\n      6, 76, 210, 100,\n\n        // front of bottom\n      6, 140, 210, 80,\n\n        // bottom\n      6, 90, 130, 110,\n\n        // left side\n      6, 160, 160, 220,\n  ], [255]);\n\n  const numVerts = positions.length / 3;\n\n  const arrays = {\n    position: createAugmentedTypedArray(3, numVerts),\n    texcoord: createAugmentedTypedArray(2,  numVerts),\n    normal: createAugmentedTypedArray(3, numVerts),\n    color: createAugmentedTypedArray(4, numVerts, Uint8Array),\n    indices: createAugmentedTypedArray(3, numVerts / 3, Uint16Array),\n  };\n\n  arrays.position.push(positions);\n  arrays.texcoord.push(texcoords);\n  arrays.normal.push(normals);\n  arrays.color.push(colors);\n\n  for (let ii = 0; ii < numVerts; ++ii) {\n    arrays.indices.push(ii);\n  }\n\n  return arrays;\n}\n\n/**\n * Creates crescent BufferInfo.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} verticalRadius The vertical radius of the crescent.\n * @param {number} outerRadius The outer radius of the crescent.\n * @param {number} innerRadius The inner radius of the crescent.\n * @param {number} thickness The thickness of the crescent.\n * @param {number} subdivisionsDown number of steps around the crescent.\n * @param {number} [startOffset] Where to start arc. Default 0.\n * @param {number} [endOffset] Where to end arg. Default 1.\n * @return {module:twgl.BufferInfo} The created BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createCresentBufferInfo\n */\n\n/**\n * Creates crescent buffers.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} verticalRadius The vertical radius of the crescent.\n * @param {number} outerRadius The outer radius of the crescent.\n * @param {number} innerRadius The inner radius of the crescent.\n * @param {number} thickness The thickness of the crescent.\n * @param {number} subdivisionsDown number of steps around the crescent.\n * @param {number} [startOffset] Where to start arc. Default 0.\n * @param {number} [endOffset] Where to end arg. Default 1.\n * @return {Object.<string, WebGLBuffer>} The created buffers.\n * @memberOf module:twgl/primitives\n * @function createCresentBuffers\n */\n\n/**\n * Creates crescent vertices.\n *\n * @param {number} verticalRadius The vertical radius of the crescent.\n * @param {number} outerRadius The outer radius of the crescent.\n * @param {number} innerRadius The inner radius of the crescent.\n * @param {number} thickness The thickness of the crescent.\n * @param {number} subdivisionsDown number of steps around the crescent.\n * @param {number} [startOffset] Where to start arc. Default 0.\n * @param {number} [endOffset] Where to end arg. Default 1.\n * @return {Object.<string, TypedArray>} The created vertices.\n * @memberOf module:twgl/primitives\n * @function createCresentBuffers\n */\n\n/**\n * Creates crescent BufferInfo.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} verticalRadius The vertical radius of the crescent.\n * @param {number} outerRadius The outer radius of the crescent.\n * @param {number} innerRadius The inner radius of the crescent.\n * @param {number} thickness The thickness of the crescent.\n * @param {number} subdivisionsDown number of steps around the crescent.\n * @param {number} [startOffset] Where to start arc. Default 0.\n * @param {number} [endOffset] Where to end arg. Default 1.\n * @return {module:twgl.BufferInfo} The created BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createCrescentBufferInfo\n */\n\n/**\n * Creates crescent buffers.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} verticalRadius The vertical radius of the crescent.\n * @param {number} outerRadius The outer radius of the crescent.\n * @param {number} innerRadius The inner radius of the crescent.\n * @param {number} thickness The thickness of the crescent.\n * @param {number} subdivisionsDown number of steps around the crescent.\n * @param {number} [startOffset] Where to start arc. Default 0.\n * @param {number} [endOffset] Where to end arg. Default 1.\n * @return {Object.<string, WebGLBuffer>} The created buffers.\n * @memberOf module:twgl/primitives\n * @function createCrescentBuffers\n */\n\n/**\n * Creates crescent vertices.\n *\n * @param {number} verticalRadius The vertical radius of the crescent.\n * @param {number} outerRadius The outer radius of the crescent.\n * @param {number} innerRadius The inner radius of the crescent.\n * @param {number} thickness The thickness of the crescent.\n * @param {number} subdivisionsDown number of steps around the crescent.\n * @param {number} [startOffset] Where to start arc. Default 0.\n * @param {number} [endOffset] Where to end arg. Default 1.\n * @return {Object.<string, TypedArray>} The created vertices.\n * @memberOf module:twgl/primitives\n */\n function createCrescentVertices(\n    verticalRadius,\n    outerRadius,\n    innerRadius,\n    thickness,\n    subdivisionsDown,\n    startOffset,\n    endOffset) {\n  if (subdivisionsDown <= 0) {\n    throw new Error('subdivisionDown must be > 0');\n  }\n\n  startOffset = startOffset || 0;\n  endOffset   = endOffset || 1;\n\n  const subdivisionsThick = 2;\n\n  const offsetRange = endOffset - startOffset;\n  const numVertices = (subdivisionsDown + 1) * 2 * (2 + subdivisionsThick);\n  const positions   = createAugmentedTypedArray(3, numVertices);\n  const normals     = createAugmentedTypedArray(3, numVertices);\n  const texcoords   = createAugmentedTypedArray(2, numVertices);\n\n  function lerp(a, b, s) {\n    return a + (b - a) * s;\n  }\n\n  function createArc(arcRadius, x, normalMult, normalAdd, uMult, uAdd) {\n    for (let z = 0; z <= subdivisionsDown; z++) {\n      const uBack = x / (subdivisionsThick - 1);\n      const v = z / subdivisionsDown;\n      const xBack = (uBack - 0.5) * 2;\n      const angle = (startOffset + (v * offsetRange)) * Math.PI;\n      const s = Math.sin(angle);\n      const c = Math.cos(angle);\n      const radius = lerp(verticalRadius, arcRadius, s);\n      const px = xBack * thickness;\n      const py = c * verticalRadius;\n      const pz = s * radius;\n      positions.push(px, py, pz);\n      const n = v3.add(v3.multiply([0, s, c], normalMult), normalAdd);\n      normals.push(n);\n      texcoords.push(uBack * uMult + uAdd, v);\n    }\n  }\n\n  // Generate the individual vertices in our vertex buffer.\n  for (let x = 0; x < subdivisionsThick; x++) {\n    const uBack = (x / (subdivisionsThick - 1) - 0.5) * 2;\n    createArc(outerRadius, x, [1, 1, 1], [0,     0, 0], 1, 0);\n    createArc(outerRadius, x, [0, 0, 0], [uBack, 0, 0], 0, 0);\n    createArc(innerRadius, x, [1, 1, 1], [0,     0, 0], 1, 0);\n    createArc(innerRadius, x, [0, 0, 0], [uBack, 0, 0], 0, 1);\n  }\n\n  // Do outer surface.\n  const indices = createAugmentedTypedArray(3, (subdivisionsDown * 2) * (2 + subdivisionsThick), Uint16Array);\n\n  function createSurface(leftArcOffset, rightArcOffset) {\n    for (let z = 0; z < subdivisionsDown; ++z) {\n      // Make triangle 1 of quad.\n      indices.push(\n          leftArcOffset + z + 0,\n          leftArcOffset + z + 1,\n          rightArcOffset + z + 0);\n\n      // Make triangle 2 of quad.\n      indices.push(\n          leftArcOffset + z + 1,\n          rightArcOffset + z + 1,\n          rightArcOffset + z + 0);\n    }\n  }\n\n  const numVerticesDown = subdivisionsDown + 1;\n  // front\n  createSurface(numVerticesDown * 0, numVerticesDown * 4);\n  // right\n  createSurface(numVerticesDown * 5, numVerticesDown * 7);\n  // back\n  createSurface(numVerticesDown * 6, numVerticesDown * 2);\n  // left\n  createSurface(numVerticesDown * 3, numVerticesDown * 1);\n\n  return {\n    position: positions,\n    normal:   normals,\n    texcoord: texcoords,\n    indices:  indices,\n  };\n}\n\n/**\n * Creates cylinder BufferInfo. The cylinder will be created around the origin\n * along the y-axis.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} radius Radius of cylinder.\n * @param {number} height Height of cylinder.\n * @param {number} radialSubdivisions The number of subdivisions around the cylinder.\n * @param {number} verticalSubdivisions The number of subdivisions down the cylinder.\n * @param {boolean} [topCap] Create top cap. Default = true.\n * @param {boolean} [bottomCap] Create bottom cap. Default = true.\n * @return {module:twgl.BufferInfo} The created BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createCylinderBufferInfo\n */\n\n /**\n  * Creates cylinder buffers. The cylinder will be created around the origin\n  * along the y-axis.\n  *\n  * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n  * @param {number} radius Radius of cylinder.\n  * @param {number} height Height of cylinder.\n  * @param {number} radialSubdivisions The number of subdivisions around the cylinder.\n  * @param {number} verticalSubdivisions The number of subdivisions down the cylinder.\n  * @param {boolean} [topCap] Create top cap. Default = true.\n  * @param {boolean} [bottomCap] Create bottom cap. Default = true.\n  * @return {Object.<string, WebGLBuffer>} The created buffers.\n  * @memberOf module:twgl/primitives\n  * @function createCylinderBuffers\n  */\n\n /**\n  * Creates cylinder vertices. The cylinder will be created around the origin\n  * along the y-axis.\n  *\n  * @param {number} radius Radius of cylinder.\n  * @param {number} height Height of cylinder.\n  * @param {number} radialSubdivisions The number of subdivisions around the cylinder.\n  * @param {number} verticalSubdivisions The number of subdivisions down the cylinder.\n  * @param {boolean} [topCap] Create top cap. Default = true.\n  * @param {boolean} [bottomCap] Create bottom cap. Default = true.\n  * @return {Object.<string, TypedArray>} The created vertices.\n  * @memberOf module:twgl/primitives\n  */\nfunction createCylinderVertices(\n    radius,\n    height,\n    radialSubdivisions,\n    verticalSubdivisions,\n    topCap,\n    bottomCap) {\n  return createTruncatedConeVertices(\n      radius,\n      radius,\n      height,\n      radialSubdivisions,\n      verticalSubdivisions,\n      topCap,\n      bottomCap);\n}\n\n/**\n * Creates BufferInfo for a torus\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} radius radius of center of torus circle.\n * @param {number} thickness radius of torus ring.\n * @param {number} radialSubdivisions The number of subdivisions around the torus.\n * @param {number} bodySubdivisions The number of subdivisions around the body torus.\n * @param {boolean} [startAngle] start angle in radians. Default = 0.\n * @param {boolean} [endAngle] end angle in radians. Default = Math.PI * 2.\n * @return {module:twgl.BufferInfo} The created BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createTorusBufferInfo\n */\n\n/**\n * Creates buffers for a torus\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} radius radius of center of torus circle.\n * @param {number} thickness radius of torus ring.\n * @param {number} radialSubdivisions The number of subdivisions around the torus.\n * @param {number} bodySubdivisions The number of subdivisions around the body torus.\n * @param {boolean} [startAngle] start angle in radians. Default = 0.\n * @param {boolean} [endAngle] end angle in radians. Default = Math.PI * 2.\n * @return {Object.<string, WebGLBuffer>} The created buffers.\n * @memberOf module:twgl/primitives\n * @function createTorusBuffers\n */\n\n/**\n * Creates vertices for a torus\n *\n * @param {number} radius radius of center of torus circle.\n * @param {number} thickness radius of torus ring.\n * @param {number} radialSubdivisions The number of subdivisions around the torus.\n * @param {number} bodySubdivisions The number of subdivisions around the body torus.\n * @param {boolean} [startAngle] start angle in radians. Default = 0.\n * @param {boolean} [endAngle] end angle in radians. Default = Math.PI * 2.\n * @return {Object.<string, TypedArray>} The created vertices.\n * @memberOf module:twgl/primitives\n */\nfunction createTorusVertices(\n    radius,\n    thickness,\n    radialSubdivisions,\n    bodySubdivisions,\n    startAngle,\n    endAngle) {\n  if (radialSubdivisions < 3) {\n    throw new Error('radialSubdivisions must be 3 or greater');\n  }\n\n  if (bodySubdivisions < 3) {\n    throw new Error('verticalSubdivisions must be 3 or greater');\n  }\n\n  startAngle = startAngle || 0;\n  endAngle = endAngle || Math.PI * 2;\n  const range = endAngle - startAngle;\n\n  const radialParts = radialSubdivisions + 1;\n  const bodyParts   = bodySubdivisions + 1;\n  const numVertices = radialParts * bodyParts;\n  const positions   = createAugmentedTypedArray(3, numVertices);\n  const normals     = createAugmentedTypedArray(3, numVertices);\n  const texcoords   = createAugmentedTypedArray(2, numVertices);\n  const indices     = createAugmentedTypedArray(3, (radialSubdivisions) * (bodySubdivisions) * 2, Uint16Array);\n\n  for (let slice = 0; slice < bodyParts; ++slice) {\n    const v = slice / bodySubdivisions;\n    const sliceAngle = v * Math.PI * 2;\n    const sliceSin = Math.sin(sliceAngle);\n    const ringRadius = radius + sliceSin * thickness;\n    const ny = Math.cos(sliceAngle);\n    const y = ny * thickness;\n    for (let ring = 0; ring < radialParts; ++ring) {\n      const u = ring / radialSubdivisions;\n      const ringAngle = startAngle + u * range;\n      const xSin = Math.sin(ringAngle);\n      const zCos = Math.cos(ringAngle);\n      const x = xSin * ringRadius;\n      const z = zCos * ringRadius;\n      const nx = xSin * sliceSin;\n      const nz = zCos * sliceSin;\n      positions.push(x, y, z);\n      normals.push(nx, ny, nz);\n      texcoords.push(u, 1 - v);\n    }\n  }\n\n  for (let slice = 0; slice < bodySubdivisions; ++slice) {  // eslint-disable-line\n    for (let ring = 0; ring < radialSubdivisions; ++ring) {  // eslint-disable-line\n      const nextRingIndex  = 1 + ring;\n      const nextSliceIndex = 1 + slice;\n      indices.push(radialParts * slice          + ring,\n                   radialParts * nextSliceIndex + ring,\n                   radialParts * slice          + nextRingIndex);\n      indices.push(radialParts * nextSliceIndex + ring,\n                   radialParts * nextSliceIndex + nextRingIndex,\n                   radialParts * slice          + nextRingIndex);\n    }\n  }\n\n  return {\n    position: positions,\n    normal:   normals,\n    texcoord: texcoords,\n    indices:  indices,\n  };\n}\n\n\n/**\n * Creates a disc BufferInfo. The disc will be in the xz plane, centered at\n * the origin. When creating, at least 3 divisions, or pie\n * pieces, need to be specified, otherwise the triangles making\n * up the disc will be degenerate. You can also specify the\n * number of radial pieces `stacks`. A value of 1 for\n * stacks will give you a simple disc of pie pieces.  If you\n * want to create an annulus you can set `innerRadius` to a\n * value > 0. Finally, `stackPower` allows you to have the widths\n * increase or decrease as you move away from the center. This\n * is particularly useful when using the disc as a ground plane\n * with a fixed camera such that you don't need the resolution\n * of small triangles near the perimeter. For example, a value\n * of 2 will produce stacks whose outside radius increases with\n * the square of the stack index. A value of 1 will give uniform\n * stacks.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} radius Radius of the ground plane.\n * @param {number} divisions Number of triangles in the ground plane (at least 3).\n * @param {number} [stacks] Number of radial divisions (default=1).\n * @param {number} [innerRadius] Default 0.\n * @param {number} [stackPower] Power to raise stack size to for decreasing width.\n * @return {module:twgl.BufferInfo} The created BufferInfo.\n * @memberOf module:twgl/primitives\n * @function createDiscBufferInfo\n */\n\n/**\n * Creates disc buffers. The disc will be in the xz plane, centered at\n * the origin. When creating, at least 3 divisions, or pie\n * pieces, need to be specified, otherwise the triangles making\n * up the disc will be degenerate. You can also specify the\n * number of radial pieces `stacks`. A value of 1 for\n * stacks will give you a simple disc of pie pieces.  If you\n * want to create an annulus you can set `innerRadius` to a\n * value > 0. Finally, `stackPower` allows you to have the widths\n * increase or decrease as you move away from the center. This\n * is particularly useful when using the disc as a ground plane\n * with a fixed camera such that you don't need the resolution\n * of small triangles near the perimeter. For example, a value\n * of 2 will produce stacks whose outside radius increases with\n * the square of the stack index. A value of 1 will give uniform\n * stacks.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext.\n * @param {number} radius Radius of the ground plane.\n * @param {number} divisions Number of triangles in the ground plane (at least 3).\n * @param {number} [stacks] Number of radial divisions (default=1).\n * @param {number} [innerRadius] Default 0.\n * @param {number} [stackPower] Power to raise stack size to for decreasing width.\n * @return {Object.<string, WebGLBuffer>} The created buffers.\n * @memberOf module:twgl/primitives\n * @function createDiscBuffers\n */\n\n/**\n * Creates disc vertices. The disc will be in the xz plane, centered at\n * the origin. When creating, at least 3 divisions, or pie\n * pieces, need to be specified, otherwise the triangles making\n * up the disc will be degenerate. You can also specify the\n * number of radial pieces `stacks`. A value of 1 for\n * stacks will give you a simple disc of pie pieces.  If you\n * want to create an annulus you can set `innerRadius` to a\n * value > 0. Finally, `stackPower` allows you to have the widths\n * increase or decrease as you move away from the center. This\n * is particularly useful when using the disc as a ground plane\n * with a fixed camera such that you don't need the resolution\n * of small triangles near the perimeter. For example, a value\n * of 2 will produce stacks whose outside radius increases with\n * the square of the stack index. A value of 1 will give uniform\n * stacks.\n *\n * @param {number} radius Radius of the ground plane.\n * @param {number} divisions Number of triangles in the ground plane (at least 3).\n * @param {number} [stacks] Number of radial divisions (default=1).\n * @param {number} [innerRadius] Default 0.\n * @param {number} [stackPower] Power to raise stack size to for decreasing width.\n * @return {Object.<string, TypedArray>} The created vertices.\n * @memberOf module:twgl/primitives\n */\nfunction createDiscVertices(\n    radius,\n    divisions,\n    stacks,\n    innerRadius,\n    stackPower) {\n  if (divisions < 3) {\n    throw new Error('divisions must be at least 3');\n  }\n\n  stacks = stacks ? stacks : 1;\n  stackPower = stackPower ? stackPower : 1;\n  innerRadius = innerRadius ? innerRadius : 0;\n\n  // Note: We don't share the center vertex because that would\n  // mess up texture coordinates.\n  const numVertices = (divisions + 1) * (stacks + 1);\n\n  const positions = createAugmentedTypedArray(3, numVertices);\n  const normals   = createAugmentedTypedArray(3, numVertices);\n  const texcoords = createAugmentedTypedArray(2, numVertices);\n  const indices   = createAugmentedTypedArray(3, stacks * divisions * 2, Uint16Array);\n\n  let firstIndex = 0;\n  const radiusSpan = radius - innerRadius;\n  const pointsPerStack = divisions + 1;\n\n  // Build the disk one stack at a time.\n  for (let stack = 0; stack <= stacks; ++stack) {\n    const stackRadius = innerRadius + radiusSpan * Math.pow(stack / stacks, stackPower);\n\n    for (let i = 0; i <= divisions; ++i) {\n      const theta = 2.0 * Math.PI * i / divisions;\n      const x = stackRadius * Math.cos(theta);\n      const z = stackRadius * Math.sin(theta);\n\n      positions.push(x, 0, z);\n      normals.push(0, 1, 0);\n      texcoords.push(1 - (i / divisions), stack / stacks);\n      if (stack > 0 && i !== divisions) {\n        // a, b, c and d are the indices of the vertices of a quad.  unless\n        // the current stack is the one closest to the center, in which case\n        // the vertices a and b connect to the center vertex.\n        const a = firstIndex + (i + 1);\n        const b = firstIndex + i;\n        const c = firstIndex + i - pointsPerStack;\n        const d = firstIndex + (i + 1) - pointsPerStack;\n\n        // Make a quad of the vertices a, b, c, d.\n        indices.push(a, b, c);\n        indices.push(a, c, d);\n      }\n    }\n\n    firstIndex += divisions + 1;\n  }\n\n  return {\n    position: positions,\n    normal: normals,\n    texcoord: texcoords,\n    indices: indices,\n  };\n}\n\n/**\n * creates a random integer between 0 and range - 1 inclusive.\n * @param {number} range\n * @return {number} random value between 0 and range - 1 inclusive.\n * @private\n */\nfunction randInt(range) {\n  return Math.random() * range | 0;\n}\n\n/**\n * Used to supply random colors\n * @callback RandomColorFunc\n * @param {number} ndx index of triangle/quad if unindexed or index of vertex if indexed\n * @param {number} channel 0 = red, 1 = green, 2 = blue, 3 = alpha\n * @return {number} a number from 0 to 255\n * @memberOf module:twgl/primitives\n */\n\n/**\n * @typedef {Object} RandomVerticesOptions\n * @property {number} [vertsPerColor] Defaults to 3 for non-indexed vertices\n * @property {module:twgl/primitives.RandomColorFunc} [rand] A function to generate random numbers\n * @memberOf module:twgl/primitives\n */\n\n/**\n * Creates an augmentedTypedArray of random vertex colors.\n * If the vertices are indexed (have an indices array) then will\n * just make random colors. Otherwise assumes they are triangles\n * and makes one random color for every 3 vertices.\n * @param {Object.<string, AugmentedTypedArray>} vertices Vertices as returned from one of the createXXXVertices functions.\n * @param {module:twgl/primitives.RandomVerticesOptions} [options] options.\n * @return {Object.<string, AugmentedTypedArray>} same vertices as passed in with `color` added.\n * @memberOf module:twgl/primitives\n */\nfunction makeRandomVertexColors(vertices, options) {\n  options = options || {};\n  const numElements = vertices.position.numElements;\n  const vColors = createAugmentedTypedArray(4, numElements, Uint8Array);\n  const rand = options.rand || function(ndx, channel) {\n    return channel < 3 ? randInt(256) : 255;\n  };\n  vertices.color = vColors;\n  if (vertices.indices) {\n    // just make random colors if index\n    for (let ii = 0; ii < numElements; ++ii) {\n      vColors.push(rand(ii, 0), rand(ii, 1), rand(ii, 2), rand(ii, 3));\n    }\n  } else {\n    // make random colors per triangle\n    const numVertsPerColor = options.vertsPerColor || 3;\n    const numSets = numElements / numVertsPerColor;\n    for (let ii = 0; ii < numSets; ++ii) {  // eslint-disable-line\n      const color = [rand(ii, 0), rand(ii, 1), rand(ii, 2), rand(ii, 3)];\n      for (let jj = 0; jj < numVertsPerColor; ++jj) {\n        vColors.push(color);\n      }\n    }\n  }\n  return vertices;\n}\n\n/**\n * creates a function that calls fn to create vertices and then\n * creates a buffers for them\n * @private\n */\nfunction createBufferFunc(fn) {\n  return function(gl) {\n    const arrays = fn.apply(this, Array.prototype.slice.call(arguments, 1));\n    return attributes.createBuffersFromArrays(gl, arrays);\n  };\n}\n\n/**\n * creates a function that calls fn to create vertices and then\n * creates a bufferInfo object for them\n * @private\n */\nfunction createBufferInfoFunc(fn) {\n  return function(gl) {\n    const arrays = fn.apply(null,  Array.prototype.slice.call(arguments, 1));\n    return attributes.createBufferInfoFromArrays(gl, arrays);\n  };\n}\n\nconst arraySpecPropertyNames = [\n  \"numComponents\",\n  \"size\",\n  \"type\",\n  \"normalize\",\n  \"stride\",\n  \"offset\",\n  \"attrib\",\n  \"name\",\n  \"attribName\",\n];\n\n/**\n * Copy elements from one array to another\n *\n * @param {Array|TypedArray} src source array\n * @param {Array|TypedArray} dst dest array\n * @param {number} dstNdx index in dest to copy src\n * @param {number} [offset] offset to add to copied values\n * @private\n */\nfunction copyElements(src, dst, dstNdx, offset) {\n  offset = offset || 0;\n  const length = src.length;\n  for (let ii = 0; ii < length; ++ii) {\n    dst[dstNdx + ii] = src[ii] + offset;\n  }\n}\n\n/**\n * Creates an array of the same time\n *\n * @param {(number[]|ArrayBufferView|module:twgl.FullArraySpec)} srcArray array who's type to copy\n * @param {number} length size of new array\n * @return {(number[]|ArrayBufferView|module:twgl.FullArraySpec)} array with same type as srcArray\n * @private\n */\nfunction createArrayOfSameType(srcArray, length) {\n  const arraySrc = getArray(srcArray);\n  const newArray = new arraySrc.constructor(length);\n  let newArraySpec = newArray;\n  // If it appears to have been augmented make new one augmented\n  if (arraySrc.numComponents && arraySrc.numElements) {\n    augmentTypedArray(newArray, arraySrc.numComponents);\n  }\n  // If it was a full spec make new one a full spec\n  if (srcArray.data) {\n    newArraySpec = {\n      data: newArray,\n    };\n    helper.copyNamedProperties(arraySpecPropertyNames, srcArray, newArraySpec);\n  }\n  return newArraySpec;\n}\n\n/**\n * Concatenates sets of vertices\n *\n * Assumes the vertices match in composition. For example\n * if one set of vertices has positions, normals, and indices\n * all sets of vertices must have positions, normals, and indices\n * and of the same type.\n *\n * Example:\n *\n *      const cubeVertices = twgl.primitives.createCubeVertices(2);\n *      const sphereVertices = twgl.primitives.createSphereVertices(1, 10, 10);\n *      // move the sphere 2 units up\n *      twgl.primitives.reorientVertices(\n *          sphereVertices, twgl.m4.translation([0, 2, 0]));\n *      // merge the sphere with the cube\n *      const cubeSphereVertices = twgl.primitives.concatVertices(\n *          [cubeVertices, sphereVertices]);\n *      // turn them into WebGL buffers and attrib data\n *      const bufferInfo = twgl.createBufferInfoFromArrays(gl, cubeSphereVertices);\n *\n * @param {module:twgl.Arrays[]} arrays Array of arrays of vertices\n * @return {module:twgl.Arrays} The concatenated vertices.\n * @memberOf module:twgl/primitives\n */\nfunction concatVertices(arrayOfArrays) {\n  const names = {};\n  let baseName;\n  // get names of all arrays.\n  // and numElements for each set of vertices\n  for (let ii = 0; ii < arrayOfArrays.length; ++ii) {\n    const arrays = arrayOfArrays[ii];\n    Object.keys(arrays).forEach(function(name) {  // eslint-disable-line\n      if (!names[name]) {\n        names[name] = [];\n      }\n      if (!baseName && name !== 'indices') {\n        baseName = name;\n      }\n      const arrayInfo = arrays[name];\n      const numComponents = getNumComponents(arrayInfo, name);\n      const array = getArray(arrayInfo);\n      const numElements = array.length / numComponents;\n      names[name].push(numElements);\n    });\n  }\n\n  // compute length of combined array\n  // and return one for reference\n  function getLengthOfCombinedArrays(name) {\n    let length = 0;\n    let arraySpec;\n    for (let ii = 0; ii < arrayOfArrays.length; ++ii) {\n      const arrays = arrayOfArrays[ii];\n      const arrayInfo = arrays[name];\n      const array = getArray(arrayInfo);\n      length += array.length;\n      if (!arraySpec || arrayInfo.data) {\n        arraySpec = arrayInfo;\n      }\n    }\n    return {\n      length: length,\n      spec: arraySpec,\n    };\n  }\n\n  function copyArraysToNewArray(name, base, newArray) {\n    let baseIndex = 0;\n    let offset = 0;\n    for (let ii = 0; ii < arrayOfArrays.length; ++ii) {\n      const arrays = arrayOfArrays[ii];\n      const arrayInfo = arrays[name];\n      const array = getArray(arrayInfo);\n      if (name === 'indices') {\n        copyElements(array, newArray, offset, baseIndex);\n        baseIndex += base[ii];\n      } else {\n        copyElements(array, newArray, offset);\n      }\n      offset += array.length;\n    }\n  }\n\n  const base = names[baseName];\n\n  const newArrays = {};\n  Object.keys(names).forEach(function(name) {\n    const info = getLengthOfCombinedArrays(name);\n    const newArraySpec = createArrayOfSameType(info.spec, info.length);\n    copyArraysToNewArray(name, base, getArray(newArraySpec));\n    newArrays[name] = newArraySpec;\n  });\n  return newArrays;\n}\n\n/**\n * Creates a duplicate set of vertices\n *\n * This is useful for calling reorientVertices when you\n * also want to keep the original available\n *\n * @param {module:twgl.Arrays} arrays of vertices\n * @return {module:twgl.Arrays} The duplicated vertices.\n * @memberOf module:twgl/primitives\n */\nfunction duplicateVertices(arrays) {\n  const newArrays = {};\n  Object.keys(arrays).forEach(function(name) {\n    const arraySpec = arrays[name];\n    const srcArray = getArray(arraySpec);\n    const newArraySpec = createArrayOfSameType(arraySpec, srcArray.length);\n    copyElements(srcArray, getArray(newArraySpec), 0);\n    newArrays[name] = newArraySpec;\n  });\n  return newArrays;\n}\n\nconst create3DFBufferInfo = createBufferInfoFunc(create3DFVertices);\nconst create3DFBuffers = createBufferFunc(create3DFVertices);\nconst createCubeBufferInfo = createBufferInfoFunc(createCubeVertices);\nconst createCubeBuffers = createBufferFunc(createCubeVertices);\nconst createPlaneBufferInfo = createBufferInfoFunc(createPlaneVertices);\nconst createPlaneBuffers = createBufferFunc(createPlaneVertices);\nconst createSphereBufferInfo = createBufferInfoFunc(createSphereVertices);\nconst createSphereBuffers = createBufferFunc(createSphereVertices);\nconst createTruncatedConeBufferInfo = createBufferInfoFunc(createTruncatedConeVertices);\nconst createTruncatedConeBuffers = createBufferFunc(createTruncatedConeVertices);\nconst createXYQuadBufferInfo = createBufferInfoFunc(createXYQuadVertices);\nconst createXYQuadBuffers = createBufferFunc(createXYQuadVertices);\nconst createCrescentBufferInfo = createBufferInfoFunc(createCrescentVertices);\nconst createCrescentBuffers = createBufferFunc(createCrescentVertices);\nconst createCylinderBufferInfo = createBufferInfoFunc(createCylinderVertices);\nconst createCylinderBuffers = createBufferFunc(createCylinderVertices);\nconst createTorusBufferInfo = createBufferInfoFunc(createTorusVertices);\nconst createTorusBuffers = createBufferFunc(createTorusVertices);\nconst createDiscBufferInfo = createBufferInfoFunc(createDiscVertices);\nconst createDiscBuffers = createBufferFunc(createDiscVertices);\n\n// these were mis-spelled until 4.12\nconst createCresentBufferInfo = createCrescentBufferInfo;\nconst createCresentBuffers = createCrescentBuffers;\nconst createCresentVertices = createCrescentVertices;\n\nexport {\n  create3DFBufferInfo,\n  create3DFBuffers,\n  create3DFVertices,\n  createAugmentedTypedArray,\n  createCubeBufferInfo,\n  createCubeBuffers,\n  createCubeVertices,\n  createPlaneBufferInfo,\n  createPlaneBuffers,\n  createPlaneVertices,\n  createSphereBufferInfo,\n  createSphereBuffers,\n  createSphereVertices,\n  createTruncatedConeBufferInfo,\n  createTruncatedConeBuffers,\n  createTruncatedConeVertices,\n  createXYQuadBufferInfo,\n  createXYQuadBuffers,\n  createXYQuadVertices,\n  createCresentBufferInfo,\n  createCresentBuffers,\n  createCresentVertices,\n  createCrescentBufferInfo,\n  createCrescentBuffers,\n  createCrescentVertices,\n  createCylinderBufferInfo,\n  createCylinderBuffers,\n  createCylinderVertices,\n  createTorusBufferInfo,\n  createTorusBuffers,\n  createTorusVertices,\n  createDiscBufferInfo,\n  createDiscBuffers,\n  createDiscVertices,\n  deindexVertices,\n  flattenNormals,\n  makeRandomVertexColors,\n  reorientDirections,\n  reorientNormals,\n  reorientPositions,\n  reorientVertices,\n  concatVertices,\n  duplicateVertices,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as utils from './utils.js';\nimport * as helper from './helper.js';\n\n/**\n * Low level shader program related functions\n *\n * You should generally not need to use these functions. They are provided\n * for those cases where you're doing something out of the ordinary\n * and you need lower level access.\n *\n * For backward compatibility they are available at both `twgl.programs` and `twgl`\n * itself\n *\n * See {@link module:twgl} for core functions\n *\n * @module twgl/programs\n */\n\nconst error = helper.error;\nconst warn = helper.warn;\nfunction getElementById(id) {\n  return (typeof document !== 'undefined' && document.getElementById)\n      ? document.getElementById(id)\n      : null;\n}\n\nconst TEXTURE0                       = 0x84c0;\nconst DYNAMIC_DRAW                   = 0x88e8;\n\nconst ARRAY_BUFFER                   = 0x8892;\nconst ELEMENT_ARRAY_BUFFER           = 0x8893;\nconst UNIFORM_BUFFER                 = 0x8a11;\nconst TRANSFORM_FEEDBACK_BUFFER      = 0x8c8e;\n\nconst TRANSFORM_FEEDBACK             = 0x8e22;\n\nconst COMPILE_STATUS                 = 0x8b81;\nconst LINK_STATUS                    = 0x8b82;\nconst FRAGMENT_SHADER                = 0x8b30;\nconst VERTEX_SHADER                  = 0x8b31;\nconst SEPARATE_ATTRIBS               = 0x8c8d;\n\nconst ACTIVE_UNIFORMS                = 0x8b86;\nconst ACTIVE_ATTRIBUTES              = 0x8b89;\nconst TRANSFORM_FEEDBACK_VARYINGS    = 0x8c83;\nconst ACTIVE_UNIFORM_BLOCKS          = 0x8a36;\nconst UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER   = 0x8a44;\nconst UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8a46;\nconst UNIFORM_BLOCK_DATA_SIZE                     = 0x8a40;\nconst UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES        = 0x8a43;\n\nconst FLOAT                         = 0x1406;\nconst FLOAT_VEC2                    = 0x8B50;\nconst FLOAT_VEC3                    = 0x8B51;\nconst FLOAT_VEC4                    = 0x8B52;\nconst INT                           = 0x1404;\nconst INT_VEC2                      = 0x8B53;\nconst INT_VEC3                      = 0x8B54;\nconst INT_VEC4                      = 0x8B55;\nconst BOOL                          = 0x8B56;\nconst BOOL_VEC2                     = 0x8B57;\nconst BOOL_VEC3                     = 0x8B58;\nconst BOOL_VEC4                     = 0x8B59;\nconst FLOAT_MAT2                    = 0x8B5A;\nconst FLOAT_MAT3                    = 0x8B5B;\nconst FLOAT_MAT4                    = 0x8B5C;\nconst SAMPLER_2D                    = 0x8B5E;\nconst SAMPLER_CUBE                  = 0x8B60;\nconst SAMPLER_3D                    = 0x8B5F;\nconst SAMPLER_2D_SHADOW             = 0x8B62;\nconst FLOAT_MAT2x3                  = 0x8B65;\nconst FLOAT_MAT2x4                  = 0x8B66;\nconst FLOAT_MAT3x2                  = 0x8B67;\nconst FLOAT_MAT3x4                  = 0x8B68;\nconst FLOAT_MAT4x2                  = 0x8B69;\nconst FLOAT_MAT4x3                  = 0x8B6A;\nconst SAMPLER_2D_ARRAY              = 0x8DC1;\nconst SAMPLER_2D_ARRAY_SHADOW       = 0x8DC4;\nconst SAMPLER_CUBE_SHADOW           = 0x8DC5;\nconst UNSIGNED_INT                  = 0x1405;\nconst UNSIGNED_INT_VEC2             = 0x8DC6;\nconst UNSIGNED_INT_VEC3             = 0x8DC7;\nconst UNSIGNED_INT_VEC4             = 0x8DC8;\nconst INT_SAMPLER_2D                = 0x8DCA;\nconst INT_SAMPLER_3D                = 0x8DCB;\nconst INT_SAMPLER_CUBE              = 0x8DCC;\nconst INT_SAMPLER_2D_ARRAY          = 0x8DCF;\nconst UNSIGNED_INT_SAMPLER_2D       = 0x8DD2;\nconst UNSIGNED_INT_SAMPLER_3D       = 0x8DD3;\nconst UNSIGNED_INT_SAMPLER_CUBE     = 0x8DD4;\nconst UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7;\n\nconst TEXTURE_2D                    = 0x0DE1;\nconst TEXTURE_CUBE_MAP              = 0x8513;\nconst TEXTURE_3D                    = 0x806F;\nconst TEXTURE_2D_ARRAY              = 0x8C1A;\n\nconst typeMap = {};\n\n/**\n * Returns the corresponding bind point for a given sampler type\n */\nfunction getBindPointForSamplerType(gl, type) {\n  return typeMap[type].bindPoint;\n}\n\n// This kind of sucks! If you could compose functions as in `var fn = gl[name];`\n// this code could be a lot smaller but that is sadly really slow (T_T)\n\nfunction floatSetter(gl, location) {\n  return function(v) {\n    gl.uniform1f(location, v);\n  };\n}\n\nfunction floatArraySetter(gl, location) {\n  return function(v) {\n    gl.uniform1fv(location, v);\n  };\n}\n\nfunction floatVec2Setter(gl, location) {\n  return function(v) {\n    gl.uniform2fv(location, v);\n  };\n}\n\nfunction floatVec3Setter(gl, location) {\n  return function(v) {\n    gl.uniform3fv(location, v);\n  };\n}\n\nfunction floatVec4Setter(gl, location) {\n  return function(v) {\n    gl.uniform4fv(location, v);\n  };\n}\n\nfunction intSetter(gl, location) {\n  return function(v) {\n    gl.uniform1i(location, v);\n  };\n}\n\nfunction intArraySetter(gl, location) {\n  return function(v) {\n    gl.uniform1iv(location, v);\n  };\n}\n\nfunction intVec2Setter(gl, location) {\n  return function(v) {\n    gl.uniform2iv(location, v);\n  };\n}\n\nfunction intVec3Setter(gl, location) {\n  return function(v) {\n    gl.uniform3iv(location, v);\n  };\n}\n\nfunction intVec4Setter(gl, location) {\n  return function(v) {\n    gl.uniform4iv(location, v);\n  };\n}\n\nfunction uintSetter(gl, location) {\n  return function(v) {\n    gl.uniform1ui(location, v);\n  };\n}\n\nfunction uintArraySetter(gl, location) {\n  return function(v) {\n    gl.uniform1uiv(location, v);\n  };\n}\n\nfunction uintVec2Setter(gl, location) {\n  return function(v) {\n    gl.uniform2uiv(location, v);\n  };\n}\n\nfunction uintVec3Setter(gl, location) {\n  return function(v) {\n    gl.uniform3uiv(location, v);\n  };\n}\n\nfunction uintVec4Setter(gl, location) {\n  return function(v) {\n    gl.uniform4uiv(location, v);\n  };\n}\n\nfunction floatMat2Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix2fv(location, false, v);\n  };\n}\n\nfunction floatMat3Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix3fv(location, false, v);\n  };\n}\n\nfunction floatMat4Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix4fv(location, false, v);\n  };\n}\n\nfunction floatMat23Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix2x3fv(location, false, v);\n  };\n}\n\nfunction floatMat32Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix3x2fv(location, false, v);\n  };\n}\n\nfunction floatMat24Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix2x4fv(location, false, v);\n  };\n}\n\nfunction floatMat42Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix4x2fv(location, false, v);\n  };\n}\n\nfunction floatMat34Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix3x4fv(location, false, v);\n  };\n}\n\nfunction floatMat43Setter(gl, location) {\n  return function(v) {\n    gl.uniformMatrix4x3fv(location, false, v);\n  };\n}\n\nfunction samplerSetter(gl, type, unit, location) {\n  const bindPoint = getBindPointForSamplerType(gl, type);\n  return utils.isWebGL2(gl) ? function(textureOrPair) {\n    let texture;\n    let sampler;\n    if (helper.isTexture(gl, textureOrPair)) {\n      texture = textureOrPair;\n      sampler = null;\n    } else {\n      texture = textureOrPair.texture;\n      sampler = textureOrPair.sampler;\n    }\n    gl.uniform1i(location, unit);\n    gl.activeTexture(TEXTURE0 + unit);\n    gl.bindTexture(bindPoint, texture);\n    gl.bindSampler(unit, sampler);\n  } : function(texture) {\n    gl.uniform1i(location, unit);\n    gl.activeTexture(TEXTURE0 + unit);\n    gl.bindTexture(bindPoint, texture);\n  };\n}\n\nfunction samplerArraySetter(gl, type, unit, location, size) {\n  const bindPoint = getBindPointForSamplerType(gl, type);\n  const units = new Int32Array(size);\n  for (let ii = 0; ii < size; ++ii) {\n    units[ii] = unit + ii;\n  }\n\n  return utils.isWebGL2(gl) ? function(textures) {\n    gl.uniform1iv(location, units);\n    textures.forEach(function(textureOrPair, index) {\n      gl.activeTexture(TEXTURE0 + units[index]);\n      let texture;\n      let sampler;\n      if (helper.isTexture(gl, textureOrPair)) {\n        texture = textureOrPair;\n        sampler = null;\n      } else {\n        texture = textureOrPair.texture;\n        sampler = textureOrPair.sampler;\n      }\n      gl.bindSampler(unit, sampler);\n      gl.bindTexture(bindPoint, texture);\n    });\n  } : function(textures) {\n    gl.uniform1iv(location, units);\n    textures.forEach(function(texture, index) {\n      gl.activeTexture(TEXTURE0 + units[index]);\n      gl.bindTexture(bindPoint, texture);\n    });\n  };\n}\n\ntypeMap[FLOAT]                         = { Type: Float32Array, size:  4, setter: floatSetter,      arraySetter: floatArraySetter, };\ntypeMap[FLOAT_VEC2]                    = { Type: Float32Array, size:  8, setter: floatVec2Setter,  cols: 2, };\ntypeMap[FLOAT_VEC3]                    = { Type: Float32Array, size: 12, setter: floatVec3Setter,  cols: 3, };\ntypeMap[FLOAT_VEC4]                    = { Type: Float32Array, size: 16, setter: floatVec4Setter,  cols: 4, };\ntypeMap[INT]                           = { Type: Int32Array,   size:  4, setter: intSetter,        arraySetter: intArraySetter, };\ntypeMap[INT_VEC2]                      = { Type: Int32Array,   size:  8, setter: intVec2Setter,    cols: 2, };\ntypeMap[INT_VEC3]                      = { Type: Int32Array,   size: 12, setter: intVec3Setter,    cols: 3, };\ntypeMap[INT_VEC4]                      = { Type: Int32Array,   size: 16, setter: intVec4Setter,    cols: 4, };\ntypeMap[UNSIGNED_INT]                  = { Type: Uint32Array,  size:  4, setter: uintSetter,       arraySetter: uintArraySetter, };\ntypeMap[UNSIGNED_INT_VEC2]             = { Type: Uint32Array,  size:  8, setter: uintVec2Setter,   cols: 2, };\ntypeMap[UNSIGNED_INT_VEC3]             = { Type: Uint32Array,  size: 12, setter: uintVec3Setter,   cols: 3, };\ntypeMap[UNSIGNED_INT_VEC4]             = { Type: Uint32Array,  size: 16, setter: uintVec4Setter,   cols: 4, };\ntypeMap[BOOL]                          = { Type: Uint32Array,  size:  4, setter: intSetter,        arraySetter: intArraySetter, };\ntypeMap[BOOL_VEC2]                     = { Type: Uint32Array,  size:  8, setter: intVec2Setter,    cols: 2, };\ntypeMap[BOOL_VEC3]                     = { Type: Uint32Array,  size: 12, setter: intVec3Setter,    cols: 3, };\ntypeMap[BOOL_VEC4]                     = { Type: Uint32Array,  size: 16, setter: intVec4Setter,    cols: 4, };\ntypeMap[FLOAT_MAT2]                    = { Type: Float32Array, size: 32, setter: floatMat2Setter,  rows: 2, cols: 2, };\ntypeMap[FLOAT_MAT3]                    = { Type: Float32Array, size: 48, setter: floatMat3Setter,  rows: 3, cols: 3, };\ntypeMap[FLOAT_MAT4]                    = { Type: Float32Array, size: 64, setter: floatMat4Setter,  rows: 4, cols: 4, };\ntypeMap[FLOAT_MAT2x3]                  = { Type: Float32Array, size: 32, setter: floatMat23Setter, rows: 2, cols: 3, };\ntypeMap[FLOAT_MAT2x4]                  = { Type: Float32Array, size: 32, setter: floatMat24Setter, rows: 2, cols: 4, };\ntypeMap[FLOAT_MAT3x2]                  = { Type: Float32Array, size: 48, setter: floatMat32Setter, rows: 3, cols: 2, };\ntypeMap[FLOAT_MAT3x4]                  = { Type: Float32Array, size: 48, setter: floatMat34Setter, rows: 3, cols: 4, };\ntypeMap[FLOAT_MAT4x2]                  = { Type: Float32Array, size: 64, setter: floatMat42Setter, rows: 4, cols: 2, };\ntypeMap[FLOAT_MAT4x3]                  = { Type: Float32Array, size: 64, setter: floatMat43Setter, rows: 4, cols: 3, };\ntypeMap[SAMPLER_2D]                    = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D,       };\ntypeMap[SAMPLER_CUBE]                  = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_CUBE_MAP, };\ntypeMap[SAMPLER_3D]                    = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_3D,       };\ntypeMap[SAMPLER_2D_SHADOW]             = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D,       };\ntypeMap[SAMPLER_2D_ARRAY]              = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D_ARRAY, };\ntypeMap[SAMPLER_2D_ARRAY_SHADOW]       = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D_ARRAY, };\ntypeMap[SAMPLER_CUBE_SHADOW]           = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_CUBE_MAP, };\ntypeMap[INT_SAMPLER_2D]                = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D,       };\ntypeMap[INT_SAMPLER_3D]                = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_3D,       };\ntypeMap[INT_SAMPLER_CUBE]              = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_CUBE_MAP, };\ntypeMap[INT_SAMPLER_2D_ARRAY]          = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D_ARRAY, };\ntypeMap[UNSIGNED_INT_SAMPLER_2D]       = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D,       };\ntypeMap[UNSIGNED_INT_SAMPLER_3D]       = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_3D,       };\ntypeMap[UNSIGNED_INT_SAMPLER_CUBE]     = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_CUBE_MAP, };\ntypeMap[UNSIGNED_INT_SAMPLER_2D_ARRAY] = { Type: null,         size:  0, setter: samplerSetter,    arraySetter: samplerArraySetter, bindPoint: TEXTURE_2D_ARRAY, };\n\nfunction floatAttribSetter(gl, index) {\n  return function(b) {\n    if (b.value) {\n      gl.disableVertexAttribArray(index);\n      switch (b.value.length) {\n        case 4:\n          gl.vertexAttrib4fv(index, b.value);\n          break;\n        case 3:\n          gl.vertexAttrib3fv(index, b.value);\n          break;\n        case 2:\n          gl.vertexAttrib2fv(index, b.value);\n          break;\n        case 1:\n          gl.vertexAttrib1fv(index, b.value);\n          break;\n        default:\n          throw new Error('the length of a float constant value must be between 1 and 4!');\n      }\n    } else {\n      gl.bindBuffer(ARRAY_BUFFER, b.buffer);\n      gl.enableVertexAttribArray(index);\n      gl.vertexAttribPointer(\n          index, b.numComponents || b.size, b.type || FLOAT, b.normalize || false, b.stride || 0, b.offset || 0);\n      if (b.divisor !== undefined) {\n        gl.vertexAttribDivisor(index, b.divisor);\n      }\n    }\n  };\n}\n\nfunction intAttribSetter(gl, index) {\n  return function(b) {\n    if (b.value) {\n      gl.disableVertexAttribArray(index);\n      if (b.value.length === 4) {\n        gl.vertexAttrib4iv(index, b.value);\n      } else {\n        throw new Error('The length of an integer constant value must be 4!');\n      }\n    } else {\n      gl.bindBuffer(ARRAY_BUFFER, b.buffer);\n      gl.enableVertexAttribArray(index);\n      gl.vertexAttribIPointer(\n          index, b.numComponents || b.size, b.type || INT, b.stride || 0, b.offset || 0);\n      if (b.divisor !== undefined) {\n        gl.vertexAttribDivisor(index, b.divisor);\n      }\n    }\n  };\n}\n\nfunction uintAttribSetter(gl, index) {\n  return function(b) {\n    if (b.value) {\n      gl.disableVertexAttribArray(index);\n      if (b.value.length === 4) {\n        gl.vertexAttrib4uiv(index, b.value);\n      } else {\n        throw new Error('The length of an unsigned integer constant value must be 4!');\n      }\n    } else {\n      gl.bindBuffer(ARRAY_BUFFER, b.buffer);\n      gl.enableVertexAttribArray(index);\n      gl.vertexAttribIPointer(\n          index, b.numComponents || b.size, b.type || UNSIGNED_INT, b.stride || 0, b.offset || 0);\n      if (b.divisor !== undefined) {\n        gl.vertexAttribDivisor(index, b.divisor);\n      }\n    }\n  };\n}\n\nfunction matAttribSetter(gl, index, typeInfo) {\n  const defaultSize = typeInfo.size;\n  const count = typeInfo.count;\n\n  return function(b) {\n    gl.bindBuffer(ARRAY_BUFFER, b.buffer);\n    const numComponents = b.size || b.numComponents || defaultSize;\n    const size = numComponents / count;\n    const type = b.type || FLOAT;\n    const typeInfo = typeMap[type];\n    const stride = typeInfo.size * numComponents;\n    const normalize = b.normalize || false;\n    const offset = b.offset || 0;\n    const rowOffset = stride / count;\n    for (let i = 0; i < count; ++i) {\n      gl.enableVertexAttribArray(index + i);\n      gl.vertexAttribPointer(\n          index + i, size, type, normalize, stride, offset + rowOffset * i);\n      if (b.divisor !== undefined) {\n        gl.vertexAttribDivisor(index + i, b.divisor);\n      }\n    }\n  };\n}\n\n\n\nconst attrTypeMap = {};\nattrTypeMap[FLOAT]             = { size:  4, setter: floatAttribSetter, };\nattrTypeMap[FLOAT_VEC2]        = { size:  8, setter: floatAttribSetter, };\nattrTypeMap[FLOAT_VEC3]        = { size: 12, setter: floatAttribSetter, };\nattrTypeMap[FLOAT_VEC4]        = { size: 16, setter: floatAttribSetter, };\nattrTypeMap[INT]               = { size:  4, setter: intAttribSetter,   };\nattrTypeMap[INT_VEC2]          = { size:  8, setter: intAttribSetter,   };\nattrTypeMap[INT_VEC3]          = { size: 12, setter: intAttribSetter,   };\nattrTypeMap[INT_VEC4]          = { size: 16, setter: intAttribSetter,   };\nattrTypeMap[UNSIGNED_INT]      = { size:  4, setter: uintAttribSetter,  };\nattrTypeMap[UNSIGNED_INT_VEC2] = { size:  8, setter: uintAttribSetter,  };\nattrTypeMap[UNSIGNED_INT_VEC3] = { size: 12, setter: uintAttribSetter,  };\nattrTypeMap[UNSIGNED_INT_VEC4] = { size: 16, setter: uintAttribSetter,  };\nattrTypeMap[BOOL]              = { size:  4, setter: intAttribSetter,   };\nattrTypeMap[BOOL_VEC2]         = { size:  8, setter: intAttribSetter,   };\nattrTypeMap[BOOL_VEC3]         = { size: 12, setter: intAttribSetter,   };\nattrTypeMap[BOOL_VEC4]         = { size: 16, setter: intAttribSetter,   };\nattrTypeMap[FLOAT_MAT2]        = { size:  4, setter: matAttribSetter,   count: 2, };\nattrTypeMap[FLOAT_MAT3]        = { size:  9, setter: matAttribSetter,   count: 3, };\nattrTypeMap[FLOAT_MAT4]        = { size: 16, setter: matAttribSetter,   count: 4, };\n\n// make sure we don't see a global gl\nconst gl = undefined;  /* eslint-disable-line */\n\nconst errorRE = /ERROR:\\s*\\d+:(\\d+)/gi;\nfunction addLineNumbersWithError(src, log = '', lineOffset = 0) {\n  // Note: Error message formats are not defined by any spec so this may or may not work.\n  const matches = [...log.matchAll(errorRE)];\n  const lineNoToErrorMap = new Map(matches.map((m, ndx) => {\n    const lineNo = parseInt(m[1]);\n    const next = matches[ndx + 1];\n    const end = next ? next.index : log.length;\n    const msg = log.substring(m.index, end);\n    return [lineNo - 1, msg];\n  }));\n  return src.split('\\n').map((line, lineNo) => {\n    const err = lineNoToErrorMap.get(lineNo);\n    return `${lineNo + 1 + lineOffset}: ${line}${err ? `\\n\\n^^^ ${err}` : ''}`;\n  }).join('\\n');\n}\n\n/**\n * Error Callback\n * @callback ErrorCallback\n * @param {string} msg error message.\n * @param {number} [lineOffset] amount to add to line number\n * @memberOf module:twgl\n */\n\nconst spaceRE = /^[ \\t]*\\n/;\n\n/**\n * Loads a shader.\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {string} shaderSource The shader source.\n * @param {number} shaderType The type of shader.\n * @param {module:twgl.ErrorCallback} opt_errorCallback callback for errors.\n * @return {WebGLShader} The created shader.\n * @private\n */\nfunction loadShader(gl, shaderSource, shaderType, opt_errorCallback) {\n  const errFn = opt_errorCallback || error;\n  // Create the shader object\n  const shader = gl.createShader(shaderType);\n\n  // Remove the first end of line because WebGL 2.0 requires\n  // #version 300 es\n  // as the first line. No whitespace allowed before that line\n  // so\n  //\n  // <script>\n  // #version 300 es\n  // </script>\n  //\n  // Has one line before it which is invalid according to GLSL ES 3.00\n  //\n  let lineOffset = 0;\n  if (spaceRE.test(shaderSource)) {\n    lineOffset = 1;\n    shaderSource = shaderSource.replace(spaceRE, '');\n  }\n\n  // Load the shader source\n  gl.shaderSource(shader, shaderSource);\n\n  // Compile the shader\n  gl.compileShader(shader);\n\n  // Check the compile status\n  const compiled = gl.getShaderParameter(shader, COMPILE_STATUS);\n  if (!compiled) {\n    // Something went wrong during compilation; get the error\n    const lastError = gl.getShaderInfoLog(shader);\n    errFn(`${addLineNumbersWithError(shaderSource, lastError, lineOffset)}\\nError compiling ${utils.glEnumToString(gl, shaderType)}: ${lastError}`);\n    gl.deleteShader(shader);\n    return null;\n  }\n\n  return shader;\n}\n\n/**\n * @typedef {Object} ProgramOptions\n * @property {function(string)} [errorCallback] callback for errors\n * @property {Object.<string,number>} [attribLocations] a attribute name to location map\n * @property {(module:twgl.BufferInfo|Object.<string,module:twgl.AttribInfo>|string[])} [transformFeedbackVaryings] If passed\n *   a BufferInfo will use the attribs names inside. If passed an object of AttribInfos will use the names from that object. Otherwise\n *   you can pass an array of names.\n * @property {number} [transformFeedbackMode] the mode to pass `gl.transformFeedbackVaryings`. Defaults to `SEPARATE_ATTRIBS`.\n * @memberOf module:twgl\n */\n\n/**\n * Gets the program options based on all these optional arguments\n * @param {module:twgl.ProgramOptions|string[]} [opt_attribs] Options for the program or an array of attribs names. Locations will be assigned by index if not passed in\n * @param {number[]} [opt_locations] The locations for the. A parallel array to opt_attribs letting you assign locations.\n * @param {module:twgl.ErrorCallback} [opt_errorCallback] callback for errors. By default it just prints an error to the console\n *        on error. If you want something else pass an callback. It's passed an error message.\n * @return {module:twgl.ProgramOptions} an instance of ProgramOptions based on the arguments passed in\n * @private\n */\nfunction getProgramOptions(opt_attribs, opt_locations, opt_errorCallback) {\n  let transformFeedbackVaryings;\n  let transformFeedbackMode;\n  if (typeof opt_locations === 'function') {\n    opt_errorCallback = opt_locations;\n    opt_locations = undefined;\n  }\n  if (typeof opt_attribs === 'function') {\n    opt_errorCallback = opt_attribs;\n    opt_attribs = undefined;\n  } else if (opt_attribs && !Array.isArray(opt_attribs)) {\n    // If we have an errorCallback we can just return this object\n    // Otherwise we need to construct one with default errorCallback\n    if (opt_attribs.errorCallback) {\n      return opt_attribs;\n    }\n    const opt = opt_attribs;\n    opt_errorCallback = opt.errorCallback;\n    opt_attribs = opt.attribLocations;\n    transformFeedbackVaryings = opt.transformFeedbackVaryings;\n    transformFeedbackMode = opt.transformFeedbackMode;\n  }\n\n  const options = {\n    errorCallback: opt_errorCallback || error,\n    transformFeedbackVaryings: transformFeedbackVaryings,\n    transformFeedbackMode: transformFeedbackMode,\n  };\n\n  if (opt_attribs) {\n    let attribLocations = {};\n    if (Array.isArray(opt_attribs)) {\n      opt_attribs.forEach(function(attrib,  ndx) {\n        attribLocations[attrib] = opt_locations ? opt_locations[ndx] : ndx;\n      });\n    } else {\n      attribLocations = opt_attribs;\n    }\n    options.attribLocations = attribLocations;\n  }\n\n  return options;\n}\n\nconst defaultShaderType = [\n  \"VERTEX_SHADER\",\n  \"FRAGMENT_SHADER\",\n];\n\nfunction getShaderTypeFromScriptType(gl, scriptType) {\n  if (scriptType.indexOf(\"frag\") >= 0) {\n    return FRAGMENT_SHADER;\n  } else if (scriptType.indexOf(\"vert\") >= 0) {\n    return VERTEX_SHADER;\n  }\n  return undefined;\n}\n\nfunction deleteShaders(gl, shaders) {\n  shaders.forEach(function(shader) {\n    gl.deleteShader(shader);\n  });\n}\n\n/**\n * Creates a program, attaches (and/or compiles) shaders, binds attrib locations, links the\n * program and calls useProgram.\n *\n * NOTE: There are 4 signatures for this function\n *\n *     twgl.createProgram(gl, [vs, fs], options);\n *     twgl.createProgram(gl, [vs, fs], opt_errFunc);\n *     twgl.createProgram(gl, [vs, fs], opt_attribs, opt_errFunc);\n *     twgl.createProgram(gl, [vs, fs], opt_attribs, opt_locations, opt_errFunc);\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {WebGLShader[]|string[]} shaders The shaders to attach, or element ids for their source, or strings that contain their source\n * @param {module:twgl.ProgramOptions|string[]|module:twgl.ErrorCallback} [opt_attribs] Options for the program or an array of attribs names or an error callback. Locations will be assigned by index if not passed in\n * @param {number[]} [opt_locations|module:twgl.ErrorCallback] The locations for the. A parallel array to opt_attribs letting you assign locations or an error callback.\n * @param {module:twgl.ErrorCallback} [opt_errorCallback] callback for errors. By default it just prints an error to the console\n *        on error. If you want something else pass an callback. It's passed an error message.\n * @return {WebGLProgram?} the created program or null if error.\n * @memberOf module:twgl/programs\n */\nfunction createProgram(\n    gl, shaders, opt_attribs, opt_locations, opt_errorCallback) {\n  const progOptions = getProgramOptions(opt_attribs, opt_locations, opt_errorCallback);\n  const realShaders = [];\n  const newShaders = [];\n  for (let ndx = 0; ndx < shaders.length; ++ndx) {\n    let shader = shaders[ndx];\n    if (typeof (shader) === 'string') {\n      const elem = getElementById(shader);\n      const src = elem ? elem.text : shader;\n      let type = gl[defaultShaderType[ndx]];\n      if (elem && elem.type) {\n        type = getShaderTypeFromScriptType(gl, elem.type) || type;\n      }\n      shader = loadShader(gl, src, type, progOptions.errorCallback);\n      newShaders.push(shader);\n    }\n    if (helper.isShader(gl, shader)) {\n      realShaders.push(shader);\n    }\n  }\n\n  if (realShaders.length !== shaders.length) {\n    progOptions.errorCallback(\"not enough shaders for program\");\n    deleteShaders(gl, newShaders);\n    return null;\n  }\n\n  const program = gl.createProgram();\n  realShaders.forEach(function(shader) {\n    gl.attachShader(program, shader);\n  });\n  if (progOptions.attribLocations) {\n    Object.keys(progOptions.attribLocations).forEach(function(attrib) {\n      gl.bindAttribLocation(program, progOptions.attribLocations[attrib], attrib);\n    });\n  }\n  let varyings = progOptions.transformFeedbackVaryings;\n  if (varyings) {\n    if (varyings.attribs) {\n      varyings = varyings.attribs;\n    }\n    if (!Array.isArray(varyings)) {\n      varyings = Object.keys(varyings);\n    }\n    gl.transformFeedbackVaryings(program, varyings, progOptions.transformFeedbackMode || SEPARATE_ATTRIBS);\n  }\n  gl.linkProgram(program);\n\n  // Check the link status\n  const linked = gl.getProgramParameter(program, LINK_STATUS);\n  if (!linked) {\n    // something went wrong with the link\n    const lastError = gl.getProgramInfoLog(program);\n    progOptions.errorCallback(`${\n      realShaders.map(shader => {\n        const src = addLineNumbersWithError(gl.getShaderSource(shader), '', 0);\n        const type = gl.getShaderParameter(shader, gl.SHADER_TYPE);\n        return `${utils.glEnumToString(gl, type)}\\n${src}}`;\n      }).join('\\n')\n    }\\nError in program linking: ${lastError}`);\n\n    gl.deleteProgram(program);\n    deleteShaders(gl, newShaders);\n    return null;\n  }\n  return program;\n}\n\n/**\n * Loads a shader from a script tag.\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {string} scriptId The id of the script tag.\n * @param {number} [opt_shaderType] The type of shader. If not passed in it will\n *     be derived from the type of the script tag.\n * @param {module:twgl.ErrorCallback} [opt_errorCallback] callback for errors.\n * @return {WebGLShader?} The created shader or null if error.\n * @private\n */\nfunction createShaderFromScript(\n    gl, scriptId, opt_shaderType, opt_errorCallback) {\n  let shaderSource = \"\";\n  const shaderScript = getElementById(scriptId);\n  if (!shaderScript) {\n    throw new Error(`unknown script element: ${scriptId}`);\n  }\n  shaderSource = shaderScript.text;\n\n  const shaderType = opt_shaderType || getShaderTypeFromScriptType(gl, shaderScript.type);\n  if (!shaderType) {\n    throw new Error('unknown shader type');\n  }\n\n  return loadShader(gl, shaderSource, shaderType, opt_errorCallback);\n}\n\n/**\n * Creates a program from 2 script tags.\n *\n * NOTE: There are 4 signatures for this function\n *\n *     twgl.createProgramFromScripts(gl, [vs, fs], opt_options);\n *     twgl.createProgramFromScripts(gl, [vs, fs], opt_errFunc);\n *     twgl.createProgramFromScripts(gl, [vs, fs], opt_attribs, opt_errFunc);\n *     twgl.createProgramFromScripts(gl, [vs, fs], opt_attribs, opt_locations, opt_errFunc);\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext\n *        to use.\n * @param {string[]} shaderScriptIds Array of ids of the script\n *        tags for the shaders. The first is assumed to be the\n *        vertex shader, the second the fragment shader.\n * @param {module:twgl.ProgramOptions|string[]|module:twgl.ErrorCallback} [opt_attribs] Options for the program or an array of attribs names or an error callback. Locations will be assigned by index if not passed in\n * @param {number[]} [opt_locations|module:twgl.ErrorCallback] The locations for the. A parallel array to opt_attribs letting you assign locations or an error callback.\n * @param {module:twgl.ErrorCallback} [opt_errorCallback] callback for errors. By default it just prints an error to the console\n *        on error. If you want something else pass an callback. It's passed an error message.\n * @return {WebGLProgram?} the created program or null if error.\n * @memberOf module:twgl/programs\n */\nfunction createProgramFromScripts(\n    gl, shaderScriptIds, opt_attribs, opt_locations, opt_errorCallback) {\n  const progOptions = getProgramOptions(opt_attribs, opt_locations, opt_errorCallback);\n  const shaders = [];\n  for (let ii = 0; ii < shaderScriptIds.length; ++ii) {\n    const shader = createShaderFromScript(\n        gl, shaderScriptIds[ii], gl[defaultShaderType[ii]], progOptions.errorCallback);\n    if (!shader) {\n      return null;\n    }\n    shaders.push(shader);\n  }\n  return createProgram(gl, shaders, progOptions);\n}\n\n/**\n * Creates a program from 2 sources.\n *\n * NOTE: There are 4 signatures for this function\n *\n *     twgl.createProgramFromSource(gl, [vs, fs], opt_options);\n *     twgl.createProgramFromSource(gl, [vs, fs], opt_errFunc);\n *     twgl.createProgramFromSource(gl, [vs, fs], opt_attribs, opt_errFunc);\n *     twgl.createProgramFromSource(gl, [vs, fs], opt_attribs, opt_locations, opt_errFunc);\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext\n *        to use.\n * @param {string[]} shaderSources Array of sources for the\n *        shaders. The first is assumed to be the vertex shader,\n *        the second the fragment shader.\n * @param {module:twgl.ProgramOptions|string[]|module:twgl.ErrorCallback} [opt_attribs] Options for the program or an array of attribs names or an error callback. Locations will be assigned by index if not passed in\n * @param {number[]} [opt_locations|module:twgl.ErrorCallback] The locations for the. A parallel array to opt_attribs letting you assign locations or an error callback.\n * @param {module:twgl.ErrorCallback} [opt_errorCallback] callback for errors. By default it just prints an error to the console\n *        on error. If you want something else pass an callback. It's passed an error message.\n * @return {WebGLProgram?} the created program or null if error.\n * @memberOf module:twgl/programs\n */\nfunction createProgramFromSources(\n    gl, shaderSources, opt_attribs, opt_locations, opt_errorCallback) {\n  const progOptions = getProgramOptions(opt_attribs, opt_locations, opt_errorCallback);\n  const shaders = [];\n  for (let ii = 0; ii < shaderSources.length; ++ii) {\n    const shader = loadShader(\n        gl, shaderSources[ii], gl[defaultShaderType[ii]], progOptions.errorCallback);\n    if (!shader) {\n      return null;\n    }\n    shaders.push(shader);\n  }\n  return createProgram(gl, shaders, progOptions);\n}\n\n/**\n * Returns true if attribute/uniform is a reserved/built in\n *\n * It makes no sense to me why GL returns these because it's\n * illegal to call `gl.getUniformLocation` and `gl.getAttribLocation`\n * with names that start with `gl_` (and `webgl_` in WebGL)\n *\n * I can only assume they are there because they might count\n * when computing the number of uniforms/attributes used when you want to\n * know if you are near the limit. That doesn't really make sense\n * to me but the fact that these get returned are in the spec.\n *\n * @param {WebGLActiveInfo} info As returned from `gl.getActiveUniform` or\n *    `gl.getActiveAttrib`.\n * @return {bool} true if it's reserved\n * @private\n */\nfunction isBuiltIn(info) {\n  const name = info.name;\n  return name.startsWith(\"gl_\") || name.startsWith(\"webgl_\");\n}\n\nconst tokenRE = /(\\.|\\[|]|\\w+)/g;\nconst isDigit = s => s >= '0' && s <= '9';\nfunction addSetterToUniformTree(fullPath, setter, node, uniformSetters) {\n  const tokens = fullPath.split(tokenRE).filter(s => s !== '');\n  let tokenNdx = 0;\n  let path = '';\n\n  for (;;) {\n    const token = tokens[tokenNdx++];  // has to be name or number\n    path += token;\n    const isArrayIndex = isDigit(token[0]);\n    const accessor = isArrayIndex\n        ? parseInt(token)\n        : token;\n    if (isArrayIndex) {\n      path += tokens[tokenNdx++];  // skip ']'\n    }\n    const isLastToken = tokenNdx === tokens.length;\n    if (isLastToken) {\n      node[accessor] = setter;\n      break;\n    } else {\n      const token = tokens[tokenNdx++];  // has to be . or [\n      const isArray = token === '[';\n      const child = node[accessor] || (isArray ? [] : {});\n      node[accessor] = child;\n      node = child;\n      uniformSetters[path] = uniformSetters[path] || function(node) {\n        return function(value) {\n          setUniformTree(node, value);\n        };\n      }(child);\n      path += token;\n    }\n  }\n}\n\n/**\n * Creates setter functions for all uniforms of a shader\n * program.\n *\n * @see {@link module:twgl.setUniforms}\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {WebGLProgram} program the program to create setters for.\n * @returns {Object.<string, function>} an object with a setter by name for each uniform\n * @memberOf module:twgl/programs\n */\nfunction createUniformSetters(gl, program) {\n  let textureUnit = 0;\n\n  /**\n   * Creates a setter for a uniform of the given program with it's\n   * location embedded in the setter.\n   * @param {WebGLProgram} program\n   * @param {WebGLUniformInfo} uniformInfo\n   * @returns {function} the created setter.\n   */\n  function createUniformSetter(program, uniformInfo, location) {\n    const isArray = uniformInfo.name.endsWith(\"[0]\");\n    const type = uniformInfo.type;\n    const typeInfo = typeMap[type];\n    if (!typeInfo) {\n      throw new Error(`unknown type: 0x${type.toString(16)}`); // we should never get here.\n    }\n    let setter;\n    if (typeInfo.bindPoint) {\n      // it's a sampler\n      const unit = textureUnit;\n      textureUnit += uniformInfo.size;\n      if (isArray) {\n        setter = typeInfo.arraySetter(gl, type, unit, location, uniformInfo.size);\n      } else {\n        setter = typeInfo.setter(gl, type, unit, location, uniformInfo.size);\n      }\n    } else {\n      if (typeInfo.arraySetter && isArray) {\n        setter = typeInfo.arraySetter(gl, location);\n      } else {\n        setter = typeInfo.setter(gl, location);\n      }\n    }\n    setter.location = location;\n    return setter;\n  }\n\n  const uniformSetters = {};\n  const uniformTree = {};\n  const numUniforms = gl.getProgramParameter(program, ACTIVE_UNIFORMS);\n\n  for (let ii = 0; ii < numUniforms; ++ii) {\n    const uniformInfo = gl.getActiveUniform(program, ii);\n    if (isBuiltIn(uniformInfo)) {\n      continue;\n    }\n    let name = uniformInfo.name;\n    // remove the array suffix.\n    if (name.endsWith(\"[0]\")) {\n      name = name.substr(0, name.length - 3);\n    }\n    const location = gl.getUniformLocation(program, uniformInfo.name);\n    // the uniform will have no location if it's in a uniform block\n    if (location) {\n      const setter = createUniformSetter(program, uniformInfo, location);\n      uniformSetters[name] = setter;\n      addSetterToUniformTree(name, setter, uniformTree, uniformSetters);\n    }\n  }\n\n  return uniformSetters;\n}\n\n/**\n * @typedef {Object} TransformFeedbackInfo\n * @property {number} index index of transform feedback\n * @property {number} type GL type\n * @property {number} size 1 - 4\n * @memberOf module:twgl\n */\n\n/**\n * Create TransformFeedbackInfo for passing to bindTransformFeedbackInfo.\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {WebGLProgram} program an existing WebGLProgram.\n * @return {Object<string, module:twgl.TransformFeedbackInfo>}\n * @memberOf module:twgl\n */\nfunction createTransformFeedbackInfo(gl, program) {\n  const info = {};\n  const numVaryings = gl.getProgramParameter(program, TRANSFORM_FEEDBACK_VARYINGS);\n  for (let ii = 0; ii < numVaryings; ++ii) {\n    const varying = gl.getTransformFeedbackVarying(program, ii);\n    info[varying.name] = {\n      index: ii,\n      type: varying.type,\n      size: varying.size,\n    };\n  }\n  return info;\n}\n\n/**\n * Binds buffers for transform feedback.\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {(module:twgl.ProgramInfo|Object<string, module:twgl.TransformFeedbackInfo>)} transformFeedbackInfo A ProgramInfo or TransformFeedbackInfo.\n * @param {(module:twgl.BufferInfo|Object<string, module:twgl.AttribInfo>)} [bufferInfo] A BufferInfo or set of AttribInfos.\n * @memberOf module:twgl\n */\nfunction bindTransformFeedbackInfo(gl, transformFeedbackInfo, bufferInfo) {\n  if (transformFeedbackInfo.transformFeedbackInfo) {\n    transformFeedbackInfo = transformFeedbackInfo.transformFeedbackInfo;\n  }\n  if (bufferInfo.attribs) {\n    bufferInfo = bufferInfo.attribs;\n  }\n  for (const name in bufferInfo) {\n    const varying = transformFeedbackInfo[name];\n    if (varying) {\n      const buf = bufferInfo[name];\n      if (buf.offset) {\n        gl.bindBufferRange(TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer, buf.offset, buf.size);\n      } else {\n        gl.bindBufferBase(TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer);\n      }\n    }\n  }\n}\n\n/**\n * Creates a transform feedback and sets the buffers\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {module:twgl.ProgramInfo} programInfo A ProgramInfo as returned from {@link module:twgl.createProgramInfo}\n * @param {(module:twgl.BufferInfo|Object<string, module:twgl.AttribInfo>)} [bufferInfo] A BufferInfo or set of AttribInfos.\n * @return {WebGLTransformFeedback} the created transform feedback\n * @memberOf module:twgl\n */\nfunction createTransformFeedback(gl, programInfo, bufferInfo) {\n  const tf = gl.createTransformFeedback();\n  gl.bindTransformFeedback(TRANSFORM_FEEDBACK, tf);\n  gl.useProgram(programInfo.program);\n  bindTransformFeedbackInfo(gl, programInfo, bufferInfo);\n  gl.bindTransformFeedback(TRANSFORM_FEEDBACK, null);\n  return tf;\n}\n\n/**\n * @typedef {Object} UniformData\n * @property {string} name The name of the uniform\n * @property {number} type The WebGL type enum for this uniform\n * @property {number} size The number of elements for this uniform\n * @property {number} blockNdx The block index this uniform appears in\n * @property {number} offset The byte offset in the block for this uniform's value\n * @memberOf module:twgl\n */\n\n/**\n * The specification for one UniformBlockObject\n *\n * @typedef {Object} BlockSpec\n * @property {number} index The index of the block.\n * @property {number} size The size in bytes needed for the block\n * @property {number[]} uniformIndices The indices of the uniforms used by the block. These indices\n *    correspond to entries in a UniformData array in the {@link module:twgl.UniformBlockSpec}.\n * @property {bool} usedByVertexShader Self explanatory\n * @property {bool} usedByFragmentShader Self explanatory\n * @property {bool} used Self explanatory\n * @memberOf module:twgl\n */\n\n/**\n * A `UniformBlockSpec` represents the data needed to create and bind\n * UniformBlockObjects for a given program\n *\n * @typedef {Object} UniformBlockSpec\n * @property {Object.<string, module:twgl.BlockSpec>} blockSpecs The BlockSpec for each block by block name\n * @property {UniformData[]} uniformData An array of data for each uniform by uniform index.\n * @memberOf module:twgl\n */\n\n/**\n * Creates a UniformBlockSpec for the given program.\n *\n * A UniformBlockSpec represents the data needed to create and bind\n * UniformBlockObjects\n *\n * @param {WebGL2RenderingContext} gl A WebGL2 Rendering Context\n * @param {WebGLProgram} program A WebGLProgram for a successfully linked program\n * @return {module:twgl.UniformBlockSpec} The created UniformBlockSpec\n * @memberOf module:twgl/programs\n */\nfunction createUniformBlockSpecFromProgram(gl, program) {\n  const numUniforms = gl.getProgramParameter(program, ACTIVE_UNIFORMS);\n  const uniformData = [];\n  const uniformIndices = [];\n\n  for (let ii = 0; ii < numUniforms; ++ii) {\n    uniformIndices.push(ii);\n    uniformData.push({});\n    const uniformInfo = gl.getActiveUniform(program, ii);\n    uniformData[ii].name = uniformInfo.name;\n  }\n\n  [\n    [ \"UNIFORM_TYPE\", \"type\" ],\n    [ \"UNIFORM_SIZE\", \"size\" ],  // num elements\n    [ \"UNIFORM_BLOCK_INDEX\", \"blockNdx\" ],\n    [ \"UNIFORM_OFFSET\", \"offset\", ],\n  ].forEach(function(pair) {\n    const pname = pair[0];\n    const key = pair[1];\n    gl.getActiveUniforms(program, uniformIndices, gl[pname]).forEach(function(value, ndx) {\n      uniformData[ndx][key] = value;\n    });\n  });\n\n  const blockSpecs = {};\n\n  const numUniformBlocks = gl.getProgramParameter(program, ACTIVE_UNIFORM_BLOCKS);\n  for (let ii = 0; ii < numUniformBlocks; ++ii) {\n    const name = gl.getActiveUniformBlockName(program, ii);\n    const blockSpec = {\n      index: gl.getUniformBlockIndex(program, name),\n      usedByVertexShader: gl.getActiveUniformBlockParameter(program, ii, UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n      usedByFragmentShader: gl.getActiveUniformBlockParameter(program, ii, UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n      size: gl.getActiveUniformBlockParameter(program, ii, UNIFORM_BLOCK_DATA_SIZE),\n      uniformIndices: gl.getActiveUniformBlockParameter(program, ii, UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES),\n    };\n    blockSpec.used = blockSpec.usedByVertexShader || blockSpec.usedByFragmentShader;\n    blockSpecs[name] = blockSpec;\n  }\n\n  return {\n    blockSpecs: blockSpecs,\n    uniformData: uniformData,\n  };\n}\n\nconst arraySuffixRE = /\\[\\d+\\]\\.$/;  // better way to check?\n\nconst pad = (v, padding) => ((v + (padding - 1)) / padding | 0) * padding;\n\nfunction createUniformBlockUniformSetter(view, isArray, rows, cols) {\n  if (isArray || rows) {\n    cols = cols || 1;\n    const numElements = view.length;\n    const totalRows = numElements / 4;\n    return function(value) {\n      let dst = 0;\n      let src = 0;\n      for (let row = 0; row < totalRows; ++row) {\n        for (let col = 0; col < cols; ++col) {\n          view[dst++] = value[src++];\n        }\n        dst += 4 - cols;\n      }\n    };\n  } else {\n    return function(value) {\n      if (value.length) {\n        view.set(value);\n      } else {\n        view[0] = value;\n      }\n    };\n  }\n}\n\n/**\n * Represents a UniformBlockObject including an ArrayBuffer with all the uniform values\n * and a corresponding WebGLBuffer to hold those values on the GPU\n *\n * @typedef {Object} UniformBlockInfo\n * @property {string} name The name of the block\n * @property {ArrayBuffer} array The array buffer that contains the uniform values\n * @property {Float32Array} asFloat A float view on the array buffer. This is useful\n *    inspecting the contents of the buffer in the debugger.\n * @property {WebGLBuffer} buffer A WebGL buffer that will hold a copy of the uniform values for rendering.\n * @property {number} [offset] offset into buffer\n * @property {Object<string, ArrayBufferView>} uniforms A uniform name to ArrayBufferView map.\n *   each Uniform has a correctly typed `ArrayBufferView` into array at the correct offset\n *   and length of that uniform. So for example a float uniform would have a 1 float `Float32Array`\n *   view. A single mat4 would have a 16 element `Float32Array` view. An ivec2 would have an\n *   `Int32Array` view, etc.\n * @property {Object<string, function>} setters A setter for this uniform.\n *   The reason to use setters is elements of arrays are padded to vec4 sizes which\n *   means if you want to set an array of 4 floats you'd need to set 16 values\n *   (or set elements 0, 4, 8, 12). In other words\n *   `someBlockInfo.uniforms.some4FloatArrayUniform.set([0, , , , 1, , , , 2, , , , 3])`\n *   where as the setter handles just passing in [0, 1, 2, 3] either directly as in\n *   `someBlockInfo.setter.some4FloatArrayUniform.set([0, 1, 2, 3])` (not recommended)\n *   or via {@link module:twgl.setBlockUniforms}\n * @memberOf module:twgl\n */\n\n/**\n * Creates a `UniformBlockInfo` for the specified block\n *\n * Note: **If the blockName matches no existing blocks a warning is printed to the console and a dummy\n * `UniformBlockInfo` is returned**. This is because when debugging GLSL\n * it is common to comment out large portions of a shader or for example set\n * the final output to a constant. When that happens blocks get optimized out.\n * If this function did not create dummy blocks your code would crash when debugging.\n *\n * @param {WebGL2RenderingContext} gl A WebGL2RenderingContext\n * @param {WebGLProgram} program A WebGLProgram\n * @param {module:twgl.UniformBlockSpec} uniformBlockSpec. A UniformBlockSpec as returned\n *     from {@link module:twgl.createUniformBlockSpecFromProgram}.\n * @param {string} blockName The name of the block.\n * @return {module:twgl.UniformBlockInfo} The created UniformBlockInfo\n * @memberOf module:twgl/programs\n */\nfunction createUniformBlockInfoFromProgram(gl, program, uniformBlockSpec, blockName) {\n  const blockSpecs = uniformBlockSpec.blockSpecs;\n  const uniformData = uniformBlockSpec.uniformData;\n  const blockSpec = blockSpecs[blockName];\n  if (!blockSpec) {\n    warn(\"no uniform block object named:\", blockName);\n    return {\n      name: blockName,\n      uniforms: {},\n    };\n  }\n  const array = new ArrayBuffer(blockSpec.size);\n  const buffer = gl.createBuffer();\n  const uniformBufferIndex = blockSpec.index;\n  gl.bindBuffer(UNIFORM_BUFFER, buffer);\n  gl.uniformBlockBinding(program, blockSpec.index, uniformBufferIndex);\n\n  let prefix = blockName + \".\";\n  if (arraySuffixRE.test(prefix)) {\n    prefix = prefix.replace(arraySuffixRE, \".\");\n  }\n  const uniforms = {};\n  const setters = {};\n  const setterTree = {};\n  blockSpec.uniformIndices.forEach(function(uniformNdx) {\n    const data = uniformData[uniformNdx];\n    let name = data.name;\n    if (name.startsWith(prefix)) {\n      name = name.substr(prefix.length);\n    }\n    const isArray = name.endsWith('[0]');\n    if (isArray) {\n      name = name.substr(0, name.length - 3);\n    }\n    const typeInfo = typeMap[data.type];\n    const Type = typeInfo.Type;\n    const byteLength = isArray\n        ? pad(typeInfo.size, 16) * data.size\n        : typeInfo.size * data.size;\n    const uniformView = new Type(array, data.offset, byteLength / Type.BYTES_PER_ELEMENT);\n    uniforms[name] = uniformView;\n    // Note: I'm not sure what to do here. The original\n    // idea was to create TypedArray views into each part\n    // of the block. This is useful, for example if you have\n    // a block with { mat4: model; mat4 view; mat4 projection; }\n    // you'll get a Float32Array for each one suitable for\n    // passing to most JS math libraries including twgl's and glMatrix.js.\n    //\n    // But, if you have a an array of structures, especially if that\n    // array is large, you get a whole bunch of TypedArray views.\n    // Every one of them has overhead and switching between them all\n    // is probably a cache miss. In that case it would really be better\n    // to just have one view (asFloat) and have all the setters\n    // just reference the correct portion. But, then you can't easily\n    // treat a matrix, or a vec4, as a standalone thing like you can\n    // with all the views.\n    //\n    // Another problem with the views is they are not shared. With\n    // uniforms you have one set of setters. With UniformBlockInfo\n    // you have a set of setters *pre block instance*. That's because\n    // TypedArray views can't be mapped to different buffers.\n    //\n    // My gut right now is if you really want the speed and compactness\n    // then you should probably roll your own solution. TWGL's goal\n    // here is ease of use as AFAICT there is no simple generic efficient\n    // solution.\n    const setter = createUniformBlockUniformSetter(uniformView, isArray, typeInfo.rows, typeInfo.cols);\n    setters[name] = setter;\n    addSetterToUniformTree(name, setter, setterTree, setters);\n  });\n  return {\n    name: blockName,\n    array,\n    asFloat: new Float32Array(array),  // for debugging\n    buffer,\n    uniforms,\n    setters,\n  };\n}\n\n/**\n * Creates a `UniformBlockInfo` for the specified block\n *\n * Note: **If the blockName matches no existing blocks a warning is printed to the console and a dummy\n * `UniformBlockInfo` is returned**. This is because when debugging GLSL\n * it is common to comment out large portions of a shader or for example set\n * the final output to a constant. When that happens blocks get optimized out.\n * If this function did not create dummy blocks your code would crash when debugging.\n *\n * @param {WebGL2RenderingContext} gl A WebGL2RenderingContext\n * @param {module:twgl.ProgramInfo} programInfo a `ProgramInfo`\n *     as returned from {@link module:twgl.createProgramInfo}\n * @param {string} blockName The name of the block.\n * @return {module:twgl.UniformBlockInfo} The created UniformBlockInfo\n * @memberOf module:twgl/programs\n */\nfunction createUniformBlockInfo(gl, programInfo, blockName) {\n  return createUniformBlockInfoFromProgram(gl, programInfo.program, programInfo.uniformBlockSpec, blockName);\n}\n\n/**\n * Binds a uniform block to the matching uniform block point.\n * Matches by blocks by name so blocks must have the same name not just the same\n * structure.\n *\n * If you have changed any values and you upload the values into the corresponding WebGLBuffer\n * call {@link module:twgl.setUniformBlock} instead.\n *\n * @param {WebGL2RenderingContext} gl A WebGL 2 rendering context.\n * @param {(module:twgl.ProgramInfo|module:twgl.UniformBlockSpec)} programInfo a `ProgramInfo`\n *     as returned from {@link module:twgl.createProgramInfo} or or `UniformBlockSpec` as\n *     returned from {@link module:twgl.createUniformBlockSpecFromProgram}.\n * @param {module:twgl.UniformBlockInfo} uniformBlockInfo a `UniformBlockInfo` as returned from\n *     {@link module:twgl.createUniformBlockInfo}.\n * @return {bool} true if buffer was bound. If the programInfo has no block with the same block name\n *     no buffer is bound.\n * @memberOf module:twgl/programs\n */\nfunction bindUniformBlock(gl, programInfo, uniformBlockInfo) {\n  const uniformBlockSpec = programInfo.uniformBlockSpec || programInfo;\n  const blockSpec = uniformBlockSpec.blockSpecs[uniformBlockInfo.name];\n  if (blockSpec) {\n    const bufferBindIndex = blockSpec.index;\n    gl.bindBufferRange(UNIFORM_BUFFER, bufferBindIndex, uniformBlockInfo.buffer, uniformBlockInfo.offset || 0, uniformBlockInfo.array.byteLength);\n    return true;\n  }\n  return false;\n}\n\n/**\n * Uploads the current uniform values to the corresponding WebGLBuffer\n * and binds that buffer to the program's corresponding bind point for the uniform block object.\n *\n * If you haven't changed any values and you only need to bind the uniform block object\n * call {@link module:twgl.bindUniformBlock} instead.\n *\n * @param {WebGL2RenderingContext} gl A WebGL 2 rendering context.\n * @param {(module:twgl.ProgramInfo|module:twgl.UniformBlockSpec)} programInfo a `ProgramInfo`\n *     as returned from {@link module:twgl.createProgramInfo} or or `UniformBlockSpec` as\n *     returned from {@link module:twgl.createUniformBlockSpecFromProgram}.\n * @param {module:twgl.UniformBlockInfo} uniformBlockInfo a `UniformBlockInfo` as returned from\n *     {@link module:twgl.createUniformBlockInfo}.\n * @memberOf module:twgl/programs\n */\nfunction setUniformBlock(gl, programInfo, uniformBlockInfo) {\n  if (bindUniformBlock(gl, programInfo, uniformBlockInfo)) {\n    gl.bufferData(UNIFORM_BUFFER, uniformBlockInfo.array, DYNAMIC_DRAW);\n  }\n}\n\n/**\n * Sets values of a uniform block object\n *\n * @param {module:twgl.UniformBlockInfo} uniformBlockInfo A UniformBlockInfo as returned by {@link module:twgl.createUniformBlockInfo}.\n * @param {Object.<string, ?>} values A uniform name to value map where the value is correct for the given\n *    type of uniform. So for example given a block like\n *\n *       uniform SomeBlock {\n *         float someFloat;\n *         vec2 someVec2;\n *         vec3 someVec3Array[2];\n *         int someInt;\n *       }\n *\n *  You can set the values of the uniform block with\n *\n *       twgl.setBlockUniforms(someBlockInfo, {\n *          someFloat: 12.3,\n *          someVec2: [1, 2],\n *          someVec3Array: [1, 2, 3, 4, 5, 6],\n *          someInt: 5,\n *       }\n *\n *  Arrays can be JavaScript arrays or typed arrays\n *\n *  You can also fill out structure and array values either via\n *  shortcut. Example\n *\n *     // -- in shader --\n *     struct Light {\n *       float intensity;\n *       vec4 color;\n *       float nearFar[2];\n *     };\n *     uniform Lights {\n *       Light lights[2];\n *     };\n *\n *     // in JavaScript\n *\n *     twgl.setBlockUniforms(someBlockInfo, {\n *       lights: [\n *         { intensity: 5.0, color: [1, 0, 0, 1], nearFar[0.1, 10] },\n *         { intensity: 2.0, color: [0, 0, 1, 1], nearFar[0.2, 15] },\n *       ],\n *     });\n *\n *   or the more traditional way\n *\n *     twgl.setBlockUniforms(someBlockInfo, {\n *       \"lights[0].intensity\": 5.0,\n *       \"lights[0].color\": [1, 0, 0, 1],\n *       \"lights[0].nearFar\": [0.1, 10],\n *       \"lights[1].intensity\": 2.0,\n *       \"lights[1].color\": [0, 0, 1, 1],\n *       \"lights[1].nearFar\": [0.2, 15],\n *     });\n *\n *   You can also specify partial paths\n *\n *     twgl.setBlockUniforms(someBlockInfo, {\n *       'lights[1]': { intensity: 5.0, color: [1, 0, 0, 1], nearFar[0.2, 15] },\n *     });\n *\n *   But you can not specify leaf array indices.\n *\n *     twgl.setBlockUniforms(someBlockInfo, {\n *       'lights[1].nearFar[1]': 15,     // BAD! nearFar is a leaf\n *       'lights[1].nearFar': [0.2, 15], // GOOD\n *     });\n *\n *  **IMPORTANT!**, packing in a UniformBlock is unintuitive.\n *  For example the actual layout of `someVec3Array` above in memory\n *  is `1, 2, 3, unused, 4, 5, 6, unused`. twgl takes in 6 values\n *  as shown about and copies them, skipping the padding. This might\n *  be confusing if you're already familiar with Uniform blocks.\n *\n *  If you want to deal with the padding yourself you can access the array\n *  buffer views directly. eg:\n *\n *      someBlockInfo.someVec3Array.set([1, 2, 3, 0, 4, 5, 6, 0]);\n *\n *  Any name that doesn't match will be ignored\n * @memberOf module:twgl/programs\n */\nfunction setBlockUniforms(uniformBlockInfo, values) {\n  const setters = uniformBlockInfo.setters;\n  for (const name in values) {\n    const setter = setters[name];\n    if (setter) {\n      const value = values[name];\n      setter(value);\n    }\n  }\n}\n\nfunction setUniformTree(tree, values) {\n  for (const name in values) {\n    const prop = tree[name];\n    if (typeof prop === 'function') {\n      prop(values[name]);\n    } else {\n      setUniformTree(tree[name], values[name]);\n    }\n  }\n}\n\n/**\n * Set uniforms and binds related textures.\n *\n * example:\n *\n *     const programInfo = createProgramInfo(\n *         gl, [\"some-vs\", \"some-fs\"]);\n *\n *     const tex1 = gl.createTexture();\n *     const tex2 = gl.createTexture();\n *\n *     ... assume we setup the textures with data ...\n *\n *     const uniforms = {\n *       u_someSampler: tex1,\n *       u_someOtherSampler: tex2,\n *       u_someColor: [1,0,0,1],\n *       u_somePosition: [0,1,1],\n *       u_someMatrix: [\n *         1,0,0,0,\n *         0,1,0,0,\n *         0,0,1,0,\n *         0,0,0,0,\n *       ],\n *     };\n *\n *     gl.useProgram(program);\n *\n * This will automatically bind the textures AND set the\n * uniforms.\n *\n *     twgl.setUniforms(programInfo, uniforms);\n *\n * For the example above it is equivalent to\n *\n *     var texUnit = 0;\n *     gl.activeTexture(gl.TEXTURE0 + texUnit);\n *     gl.bindTexture(gl.TEXTURE_2D, tex1);\n *     gl.uniform1i(u_someSamplerLocation, texUnit++);\n *     gl.activeTexture(gl.TEXTURE0 + texUnit);\n *     gl.bindTexture(gl.TEXTURE_2D, tex2);\n *     gl.uniform1i(u_someSamplerLocation, texUnit++);\n *     gl.uniform4fv(u_someColorLocation, [1, 0, 0, 1]);\n *     gl.uniform3fv(u_somePositionLocation, [0, 1, 1]);\n *     gl.uniformMatrix4fv(u_someMatrix, false, [\n *         1,0,0,0,\n *         0,1,0,0,\n *         0,0,1,0,\n *         0,0,0,0,\n *       ]);\n *\n * Note it is perfectly reasonable to call `setUniforms` multiple times. For example\n *\n *     const uniforms = {\n *       u_someSampler: tex1,\n *       u_someOtherSampler: tex2,\n *     };\n *\n *     const moreUniforms {\n *       u_someColor: [1,0,0,1],\n *       u_somePosition: [0,1,1],\n *       u_someMatrix: [\n *         1,0,0,0,\n *         0,1,0,0,\n *         0,0,1,0,\n *         0,0,0,0,\n *       ],\n *     };\n *\n *     twgl.setUniforms(programInfo, uniforms);\n *     twgl.setUniforms(programInfo, moreUniforms);\n *\n * You can also add WebGLSamplers to uniform samplers as in\n *\n *     const uniforms = {\n *       u_someSampler: {\n *         texture: someWebGLTexture,\n *         sampler: someWebGLSampler,\n *       },\n *     };\n *\n * In which case both the sampler and texture will be bound to the\n * same unit.\n *\n * @param {(module:twgl.ProgramInfo|Object.<string, function>)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n *        `createUniformSetters`.\n * @param {Object.<string, ?>} values an object with values for the\n *        uniforms.\n *   You can pass multiple objects by putting them in an array or by calling with more arguments.For example\n *\n *     const sharedUniforms = {\n *       u_fogNear: 10,\n *       u_projection: ...\n *       ...\n *     };\n *\n *     const localUniforms = {\n *       u_world: ...\n *       u_diffuseColor: ...\n *     };\n *\n *     twgl.setUniforms(programInfo, sharedUniforms, localUniforms);\n *\n *     // is the same as\n *\n *     twgl.setUniforms(programInfo, [sharedUniforms, localUniforms]);\n *\n *     // is the same as\n *\n *     twgl.setUniforms(programInfo, sharedUniforms);\n *     twgl.setUniforms(programInfo, localUniforms};\n *\n *   You can also fill out structure and array values either via\n *   shortcut. Example\n *\n *     // -- in shader --\n *     struct Light {\n *       float intensity;\n *       vec4 color;\n *       float nearFar[2];\n *     };\n *     uniform Light lights[2];\n *\n *     // in JavaScript\n *\n *     twgl.setUniforms(programInfo, {\n *       lights: [\n *         { intensity: 5.0, color: [1, 0, 0, 1], nearFar[0.1, 10] },\n *         { intensity: 2.0, color: [0, 0, 1, 1], nearFar[0.2, 15] },\n *       ],\n *     });\n *\n *   or the more traditional way\n *\n *     twgl.setUniforms(programInfo, {\n *       \"lights[0].intensity\": 5.0,\n *       \"lights[0].color\": [1, 0, 0, 1],\n *       \"lights[0].nearFar\": [0.1, 10],\n *       \"lights[1].intensity\": 2.0,\n *       \"lights[1].color\": [0, 0, 1, 1],\n *       \"lights[1].nearFar\": [0.2, 15],\n *     });\n *\n *   You can also specify partial paths\n *\n *     twgl.setUniforms(programInfo, {\n *       'lights[1]': { intensity: 5.0, color: [1, 0, 0, 1], nearFar[0.2, 15] },\n *     });\n *\n *   But you can not specify leaf array indices\n *\n *     twgl.setUniforms(programInfo, {\n *       'lights[1].nearFar[1]': 15,     // BAD! nearFar is a leaf\n *       'lights[1].nearFar': [0.2, 15], // GOOD\n *     });\n *\n * @memberOf module:twgl/programs\n */\nfunction setUniforms(setters, ...args) {  // eslint-disable-line\n  const actualSetters = setters.uniformSetters || setters;\n  const numArgs = args.length;\n  for (let aNdx = 0; aNdx < numArgs; ++aNdx) {\n    const values = args[aNdx];\n    if (Array.isArray(values)) {\n      const numValues = values.length;\n      for (let ii = 0; ii < numValues; ++ii) {\n        setUniforms(actualSetters, values[ii]);\n      }\n    } else {\n      for (const name in values) {\n        const setter = actualSetters[name];\n        if (setter) {\n          setter(values[name]);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Alias for `setUniforms`\n * @function\n * @param {(module:twgl.ProgramInfo|Object.<string, function>)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n *        `createUniformSetters`.\n * @param {Object.<string, ?>} values an object with values for the\n * @memberOf module:twgl/programs\n */\nconst setUniformsAndBindTextures = setUniforms;\n\n/**\n * Creates setter functions for all attributes of a shader\n * program. You can pass this to {@link module:twgl.setBuffersAndAttributes} to set all your buffers and attributes.\n *\n * @see {@link module:twgl.setAttributes} for example\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {WebGLProgram} program the program to create setters for.\n * @return {Object.<string, function>} an object with a setter for each attribute by name.\n * @memberOf module:twgl/programs\n */\nfunction createAttributeSetters(gl, program) {\n  const attribSetters = {\n  };\n\n  const numAttribs = gl.getProgramParameter(program, ACTIVE_ATTRIBUTES);\n  for (let ii = 0; ii < numAttribs; ++ii) {\n    const attribInfo = gl.getActiveAttrib(program, ii);\n    if (isBuiltIn(attribInfo)) {\n      continue;\n    }\n    const index = gl.getAttribLocation(program, attribInfo.name);\n    const typeInfo = attrTypeMap[attribInfo.type];\n    const setter = typeInfo.setter(gl, index, typeInfo);\n    setter.location = index;\n    attribSetters[attribInfo.name] = setter;\n  }\n\n  return attribSetters;\n}\n\n/**\n * Sets attributes and binds buffers (deprecated... use {@link module:twgl.setBuffersAndAttributes})\n *\n * Example:\n *\n *     const program = createProgramFromScripts(\n *         gl, [\"some-vs\", \"some-fs\");\n *\n *     const attribSetters = createAttributeSetters(program);\n *\n *     const positionBuffer = gl.createBuffer();\n *     const texcoordBuffer = gl.createBuffer();\n *\n *     const attribs = {\n *       a_position: {buffer: positionBuffer, numComponents: 3},\n *       a_texcoord: {buffer: texcoordBuffer, numComponents: 2},\n *     };\n *\n *     gl.useProgram(program);\n *\n * This will automatically bind the buffers AND set the\n * attributes.\n *\n *     setAttributes(attribSetters, attribs);\n *\n * Properties of attribs. For each attrib you can add\n * properties:\n *\n * *   type: the type of data in the buffer. Default = gl.FLOAT\n * *   normalize: whether or not to normalize the data. Default = false\n * *   stride: the stride. Default = 0\n * *   offset: offset into the buffer. Default = 0\n * *   divisor: the divisor for instances. Default = undefined\n *\n * For example if you had 3 value float positions, 2 value\n * float texcoord and 4 value uint8 colors you'd setup your\n * attribs like this\n *\n *     const attribs = {\n *       a_position: {buffer: positionBuffer, numComponents: 3},\n *       a_texcoord: {buffer: texcoordBuffer, numComponents: 2},\n *       a_color: {\n *         buffer: colorBuffer,\n *         numComponents: 4,\n *         type: gl.UNSIGNED_BYTE,\n *         normalize: true,\n *       },\n *     };\n *\n * @param {Object.<string, function>} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.<string, module:twgl.AttribInfo>} buffers AttribInfos mapped by attribute name.\n * @memberOf module:twgl/programs\n * @deprecated use {@link module:twgl.setBuffersAndAttributes}\n */\nfunction setAttributes(setters, buffers) {\n  for (const name in buffers) {\n    const setter = setters[name];\n    if (setter) {\n      setter(buffers[name]);\n    }\n  }\n}\n\n/**\n * Sets attributes and buffers including the `ELEMENT_ARRAY_BUFFER` if appropriate\n *\n * Example:\n *\n *     const programInfo = createProgramInfo(\n *         gl, [\"some-vs\", \"some-fs\");\n *\n *     const arrays = {\n *       position: { numComponents: 3, data: [0, 0, 0, 10, 0, 0, 0, 10, 0, 10, 10, 0], },\n *       texcoord: { numComponents: 2, data: [0, 0, 0, 1, 1, 0, 1, 1],                 },\n *     };\n *\n *     const bufferInfo = createBufferInfoFromArrays(gl, arrays);\n *\n *     gl.useProgram(programInfo.program);\n *\n * This will automatically bind the buffers AND set the\n * attributes.\n *\n *     setBuffersAndAttributes(gl, programInfo, bufferInfo);\n *\n * For the example above it is equivalent to\n *\n *     gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);\n *     gl.enableVertexAttribArray(a_positionLocation);\n *     gl.vertexAttribPointer(a_positionLocation, 3, gl.FLOAT, false, 0, 0);\n *     gl.bindBuffer(gl.ARRAY_BUFFER, texcoordBuffer);\n *     gl.enableVertexAttribArray(a_texcoordLocation);\n *     gl.vertexAttribPointer(a_texcoordLocation, 4, gl.FLOAT, false, 0, 0);\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext.\n * @param {(module:twgl.ProgramInfo|Object.<string, function>)} setters A `ProgramInfo` as returned from {@link module:twgl.createProgramInfo} or Attribute setters as returned from {@link module:twgl.createAttributeSetters}\n * @param {(module:twgl.BufferInfo|module:twgl.VertexArrayInfo)} buffers a `BufferInfo` as returned from {@link module:twgl.createBufferInfoFromArrays}.\n *   or a `VertexArrayInfo` as returned from {@link module:twgl.createVertexArrayInfo}\n * @memberOf module:twgl/programs\n */\nfunction setBuffersAndAttributes(gl, programInfo, buffers) {\n  if (buffers.vertexArrayObject) {\n    gl.bindVertexArray(buffers.vertexArrayObject);\n  } else {\n    setAttributes(programInfo.attribSetters || programInfo, buffers.attribs);\n    if (buffers.indices) {\n      gl.bindBuffer(ELEMENT_ARRAY_BUFFER, buffers.indices);\n    }\n  }\n}\n\n/**\n * @typedef {Object} ProgramInfo\n * @property {WebGLProgram} program A shader program\n * @property {Object<string, function>} uniformSetters object of setters as returned from createUniformSetters,\n * @property {Object<string, function>} attribSetters object of setters as returned from createAttribSetters,\n * @property {module:twgl.UniformBlockSpec} [uniformBlockSpec] a uniform block spec for making UniformBlockInfos with createUniformBlockInfo etc..\n * @property {Object<string, module:twgl.TransformFeedbackInfo>} [transformFeedbackInfo] info for transform feedbacks\n * @memberOf module:twgl\n */\n\n/**\n * Creates a ProgramInfo from an existing program.\n *\n * A ProgramInfo contains\n *\n *     programInfo = {\n *        program: WebGLProgram,\n *        uniformSetters: object of setters as returned from createUniformSetters,\n *        attribSetters: object of setters as returned from createAttribSetters,\n *     }\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext\n *        to use.\n * @param {WebGLProgram} program an existing WebGLProgram.\n * @return {module:twgl.ProgramInfo} The created ProgramInfo.\n * @memberOf module:twgl/programs\n */\nfunction createProgramInfoFromProgram(gl, program) {\n  const uniformSetters = createUniformSetters(gl, program);\n  const attribSetters = createAttributeSetters(gl, program);\n  const programInfo = {\n    program,\n    uniformSetters,\n    attribSetters,\n  };\n\n  if (utils.isWebGL2(gl)) {\n    programInfo.uniformBlockSpec = createUniformBlockSpecFromProgram(gl, program);\n    programInfo.transformFeedbackInfo = createTransformFeedbackInfo(gl, program);\n  }\n\n  return programInfo;\n}\n\n/**\n * Creates a ProgramInfo from 2 sources.\n *\n * A ProgramInfo contains\n *\n *     programInfo = {\n *        program: WebGLProgram,\n *        uniformSetters: object of setters as returned from createUniformSetters,\n *        attribSetters: object of setters as returned from createAttribSetters,\n *     }\n *\n * NOTE: There are 4 signatures for this function\n *\n *     twgl.createProgramInfo(gl, [vs, fs], options);\n *     twgl.createProgramInfo(gl, [vs, fs], opt_errFunc);\n *     twgl.createProgramInfo(gl, [vs, fs], opt_attribs, opt_errFunc);\n *     twgl.createProgramInfo(gl, [vs, fs], opt_attribs, opt_locations, opt_errFunc);\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext\n *        to use.\n * @param {string[]} shaderSources Array of sources for the\n *        shaders or ids. The first is assumed to be the vertex shader,\n *        the second the fragment shader.\n * @param {module:twgl.ProgramOptions|string[]|module:twgl.ErrorCallback} [opt_attribs] Options for the program or an array of attribs names or an error callback. Locations will be assigned by index if not passed in\n * @param {number[]} [opt_locations|module:twgl.ErrorCallback] The locations for the. A parallel array to opt_attribs letting you assign locations or an error callback.\n * @param {module:twgl.ErrorCallback} [opt_errorCallback] callback for errors. By default it just prints an error to the console\n *        on error. If you want something else pass an callback. It's passed an error message.\n * @return {module:twgl.ProgramInfo?} The created ProgramInfo or null if it failed to link or compile\n * @memberOf module:twgl/programs\n */\nfunction createProgramInfo(\n    gl, shaderSources, opt_attribs, opt_locations, opt_errorCallback) {\n  const progOptions = getProgramOptions(opt_attribs, opt_locations, opt_errorCallback);\n  let good = true;\n  shaderSources = shaderSources.map(function(source) {\n    // Lets assume if there is no \\n it's an id\n    if (source.indexOf(\"\\n\") < 0) {\n      const script = getElementById(source);\n      if (!script) {\n        progOptions.errorCallback(\"no element with id: \" + source);\n        good = false;\n      } else {\n        source = script.text;\n      }\n    }\n    return source;\n  });\n  if (!good) {\n    return null;\n  }\n  const program = createProgramFromSources(gl, shaderSources, progOptions);\n  if (!program) {\n    return null;\n  }\n  return createProgramInfoFromProgram(gl, program);\n}\n\nexport {\n  createAttributeSetters,\n\n  createProgram,\n  createProgramFromScripts,\n  createProgramFromSources,\n  createProgramInfo,\n  createProgramInfoFromProgram,\n  createUniformSetters,\n  createUniformBlockSpecFromProgram,\n  createUniformBlockInfoFromProgram,\n  createUniformBlockInfo,\n\n  createTransformFeedback,\n  createTransformFeedbackInfo,\n  bindTransformFeedbackInfo,\n\n  setAttributes,\n  setBuffersAndAttributes,\n  setUniforms,\n  setUniformsAndBindTextures,\n  setUniformBlock,\n  setBlockUniforms,\n  bindUniformBlock,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as utils from './utils.js';\nimport * as typedArrays from './typedarrays.js';\nimport * as helper from './helper.js';\n\n/**\n * Low level texture related functions\n *\n * You should generally not need to use these functions. They are provided\n * for those cases where you're doing something out of the ordinary\n * and you need lower level access.\n *\n * For backward compatibility they are available at both `twgl.textures` and `twgl`\n * itself\n *\n * See {@link module:twgl} for core functions\n *\n * @module twgl/textures\n */\n\n// make sure we don't see a global gl\nconst gl = undefined;  /* eslint-disable-line */\nconst defaults = {\n  textureColor: new Uint8Array([128, 192, 255, 255]),\n  textureOptions: {},\n  crossOrigin: undefined,\n};\nconst isArrayBuffer = typedArrays.isArrayBuffer;\n\n// Should we make this on demand?\nconst getShared2DContext = function() {\n  let s_ctx;\n  return function getShared2DContext() {\n    s_ctx = s_ctx ||\n        ((typeof document !== 'undefined' && document.createElement)\n          ? document.createElement(\"canvas\").getContext(\"2d\")\n          : null);\n    return s_ctx;\n  };\n}();\n\n// NOTE: Chrome supports 2D canvas in a Worker (behind flag as of v64 but\n//       not only does Firefox NOT support it but Firefox freezes immediately\n//       if you try to create one instead of just returning null and continuing.\n//  : (global.OffscreenCanvas && (new global.OffscreenCanvas(1, 1)).getContext(\"2d\"));  // OffscreenCanvas may not support 2d\n\n// NOTE: We can maybe remove some of the need for the 2d canvas. In WebGL2\n// we can use the various unpack settings. Otherwise we could try using\n// the ability of an ImageBitmap to be cut. Unfortunately cutting an ImageBitmap\n// is async and the current TWGL code expects a non-Async result though that\n// might not be a problem. ImageBitmap though is not available in Edge or Safari\n// as of 2018-01-02\n\n/* PixelFormat */\nconst ALPHA                          = 0x1906;\nconst RGB                            = 0x1907;\nconst RGBA                           = 0x1908;\nconst LUMINANCE                      = 0x1909;\nconst LUMINANCE_ALPHA                = 0x190A;\nconst DEPTH_COMPONENT                = 0x1902;\nconst DEPTH_STENCIL                  = 0x84F9;\n\n/* TextureWrapMode */\n// const REPEAT                         = 0x2901;\n// const MIRRORED_REPEAT                = 0x8370;\nconst CLAMP_TO_EDGE                  = 0x812f;\n\n/* TextureMagFilter */\nconst NEAREST                        = 0x2600;\nconst LINEAR                         = 0x2601;\n\n/* TextureMinFilter */\n// const NEAREST_MIPMAP_NEAREST         = 0x2700;\n// const LINEAR_MIPMAP_NEAREST          = 0x2701;\n// const NEAREST_MIPMAP_LINEAR          = 0x2702;\n// const LINEAR_MIPMAP_LINEAR           = 0x2703;\n\n/* Texture Target */\nconst TEXTURE_2D                     = 0x0de1;\nconst TEXTURE_CUBE_MAP               = 0x8513;\nconst TEXTURE_3D                     = 0x806f;\nconst TEXTURE_2D_ARRAY               = 0x8c1a;\n\n/* Cubemap Targets */\nconst TEXTURE_CUBE_MAP_POSITIVE_X    = 0x8515;\nconst TEXTURE_CUBE_MAP_NEGATIVE_X    = 0x8516;\nconst TEXTURE_CUBE_MAP_POSITIVE_Y    = 0x8517;\nconst TEXTURE_CUBE_MAP_NEGATIVE_Y    = 0x8518;\nconst TEXTURE_CUBE_MAP_POSITIVE_Z    = 0x8519;\nconst TEXTURE_CUBE_MAP_NEGATIVE_Z    = 0x851a;\n\n/* Texture Parameters */\nconst TEXTURE_MIN_FILTER             = 0x2801;\nconst TEXTURE_MAG_FILTER             = 0x2800;\nconst TEXTURE_WRAP_S                 = 0x2802;\nconst TEXTURE_WRAP_T                 = 0x2803;\nconst TEXTURE_WRAP_R                 = 0x8072;\nconst TEXTURE_MIN_LOD                = 0x813a;\nconst TEXTURE_MAX_LOD                = 0x813b;\nconst TEXTURE_BASE_LEVEL             = 0x813c;\nconst TEXTURE_MAX_LEVEL              = 0x813d;\n\n\n/* Pixel store */\nconst UNPACK_ALIGNMENT                   = 0x0cf5;\nconst UNPACK_ROW_LENGTH                  = 0x0cf2;\nconst UNPACK_IMAGE_HEIGHT                = 0x806e;\nconst UNPACK_SKIP_PIXELS                 = 0x0cf4;\nconst UNPACK_SKIP_ROWS                   = 0x0cf3;\nconst UNPACK_SKIP_IMAGES                 = 0x806d;\nconst UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;\nconst UNPACK_PREMULTIPLY_ALPHA_WEBGL     = 0x9241;\nconst UNPACK_FLIP_Y_WEBGL                = 0x9240;\n\nconst R8                           = 0x8229;\nconst R8_SNORM                     = 0x8F94;\nconst R16F                         = 0x822D;\nconst R32F                         = 0x822E;\nconst R8UI                         = 0x8232;\nconst R8I                          = 0x8231;\nconst RG16UI                       = 0x823A;\nconst RG16I                        = 0x8239;\nconst RG32UI                       = 0x823C;\nconst RG32I                        = 0x823B;\nconst RG8                          = 0x822B;\nconst RG8_SNORM                    = 0x8F95;\nconst RG16F                        = 0x822F;\nconst RG32F                        = 0x8230;\nconst RG8UI                        = 0x8238;\nconst RG8I                         = 0x8237;\nconst R16UI                        = 0x8234;\nconst R16I                         = 0x8233;\nconst R32UI                        = 0x8236;\nconst R32I                         = 0x8235;\nconst RGB8                         = 0x8051;\nconst SRGB8                        = 0x8C41;\nconst RGB565                       = 0x8D62;\nconst RGB8_SNORM                   = 0x8F96;\nconst R11F_G11F_B10F               = 0x8C3A;\nconst RGB9_E5                      = 0x8C3D;\nconst RGB16F                       = 0x881B;\nconst RGB32F                       = 0x8815;\nconst RGB8UI                       = 0x8D7D;\nconst RGB8I                        = 0x8D8F;\nconst RGB16UI                      = 0x8D77;\nconst RGB16I                       = 0x8D89;\nconst RGB32UI                      = 0x8D71;\nconst RGB32I                       = 0x8D83;\nconst RGBA8                        = 0x8058;\nconst SRGB8_ALPHA8                 = 0x8C43;\nconst RGBA8_SNORM                  = 0x8F97;\nconst RGB5_A1                      = 0x8057;\nconst RGBA4                        = 0x8056;\nconst RGB10_A2                     = 0x8059;\nconst RGBA16F                      = 0x881A;\nconst RGBA32F                      = 0x8814;\nconst RGBA8UI                      = 0x8D7C;\nconst RGBA8I                       = 0x8D8E;\nconst RGB10_A2UI                   = 0x906F;\nconst RGBA16UI                     = 0x8D76;\nconst RGBA16I                      = 0x8D88;\nconst RGBA32I                      = 0x8D82;\nconst RGBA32UI                     = 0x8D70;\n\nconst DEPTH_COMPONENT16            = 0x81A5;\nconst DEPTH_COMPONENT24            = 0x81A6;\nconst DEPTH_COMPONENT32F           = 0x8CAC;\nconst DEPTH32F_STENCIL8            = 0x8CAD;\nconst DEPTH24_STENCIL8             = 0x88F0;\n\n/* DataType */\nconst BYTE                         = 0x1400;\nconst UNSIGNED_BYTE                = 0x1401;\nconst SHORT                        = 0x1402;\nconst UNSIGNED_SHORT               = 0x1403;\nconst INT                          = 0x1404;\nconst UNSIGNED_INT                 = 0x1405;\nconst FLOAT                        = 0x1406;\nconst UNSIGNED_SHORT_4_4_4_4       = 0x8033;\nconst UNSIGNED_SHORT_5_5_5_1       = 0x8034;\nconst UNSIGNED_SHORT_5_6_5         = 0x8363;\nconst HALF_FLOAT                   = 0x140B;\nconst HALF_FLOAT_OES               = 0x8D61;  // Thanks Khronos for making this different >:(\nconst UNSIGNED_INT_2_10_10_10_REV  = 0x8368;\nconst UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B;\nconst UNSIGNED_INT_5_9_9_9_REV     = 0x8C3E;\nconst FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD;\nconst UNSIGNED_INT_24_8            = 0x84FA;\n\nconst RG                           = 0x8227;\nconst RG_INTEGER                   = 0x8228;\nconst RED                          = 0x1903;\nconst RED_INTEGER                  = 0x8D94;\nconst RGB_INTEGER                  = 0x8D98;\nconst RGBA_INTEGER                 = 0x8D99;\n\nconst formatInfo = {};\n{\n  // NOTE: this is named `numColorComponents` vs `numComponents` so we can let Uglify mangle\n  // the name.\n  const f = formatInfo;\n  f[ALPHA]           = { numColorComponents: 1, };\n  f[LUMINANCE]       = { numColorComponents: 1, };\n  f[LUMINANCE_ALPHA] = { numColorComponents: 2, };\n  f[RGB]             = { numColorComponents: 3, };\n  f[RGBA]            = { numColorComponents: 4, };\n  f[RED]             = { numColorComponents: 1, };\n  f[RED_INTEGER]     = { numColorComponents: 1, };\n  f[RG]              = { numColorComponents: 2, };\n  f[RG_INTEGER]      = { numColorComponents: 2, };\n  f[RGB]             = { numColorComponents: 3, };\n  f[RGB_INTEGER]     = { numColorComponents: 3, };\n  f[RGBA]            = { numColorComponents: 4, };\n  f[RGBA_INTEGER]    = { numColorComponents: 4, };\n  f[DEPTH_COMPONENT] = { numColorComponents: 1, };\n  f[DEPTH_STENCIL]   = { numColorComponents: 2, };\n}\n\n/**\n * @typedef {Object} TextureFormatDetails\n * @property {number} textureFormat format to pass texImage2D and similar functions.\n * @property {boolean} colorRenderable true if you can render to this format of texture.\n * @property {boolean} textureFilterable true if you can filter the texture, false if you can ony use `NEAREST`.\n * @property {number[]} type Array of possible types you can pass to texImage2D and similar function\n * @property {Object.<number,number>} bytesPerElementMap A map of types to bytes per element\n * @private\n */\n\nlet s_textureInternalFormatInfo;\nfunction getTextureInternalFormatInfo(internalFormat) {\n  if (!s_textureInternalFormatInfo) {\n    // NOTE: these properties need unique names so we can let Uglify mangle the name.\n    const t = {};\n    // unsized formats\n    t[ALPHA]              = { textureFormat: ALPHA,           colorRenderable: true,  textureFilterable: true,  bytesPerElement: [1, 2, 2, 4],        type: [UNSIGNED_BYTE, HALF_FLOAT, HALF_FLOAT_OES, FLOAT], };\n    t[LUMINANCE]          = { textureFormat: LUMINANCE,       colorRenderable: true,  textureFilterable: true,  bytesPerElement: [1, 2, 2, 4],        type: [UNSIGNED_BYTE, HALF_FLOAT, HALF_FLOAT_OES, FLOAT], };\n    t[LUMINANCE_ALPHA]    = { textureFormat: LUMINANCE_ALPHA, colorRenderable: true,  textureFilterable: true,  bytesPerElement: [2, 4, 4, 8],        type: [UNSIGNED_BYTE, HALF_FLOAT, HALF_FLOAT_OES, FLOAT], };\n    t[RGB]                = { textureFormat: RGB,             colorRenderable: true,  textureFilterable: true,  bytesPerElement: [3, 6, 6, 12, 2],    type: [UNSIGNED_BYTE, HALF_FLOAT, HALF_FLOAT_OES, FLOAT, UNSIGNED_SHORT_5_6_5], };\n    t[RGBA]               = { textureFormat: RGBA,            colorRenderable: true,  textureFilterable: true,  bytesPerElement: [4, 8, 8, 16, 2, 2], type: [UNSIGNED_BYTE, HALF_FLOAT, HALF_FLOAT_OES, FLOAT, UNSIGNED_SHORT_4_4_4_4, UNSIGNED_SHORT_5_5_5_1], };\n    t[DEPTH_COMPONENT]    = { textureFormat: DEPTH_COMPONENT, colorRenderable: true,  textureFilterable: false, bytesPerElement: [2, 4],              type: [UNSIGNED_INT, UNSIGNED_SHORT], };\n\n    // sized formats\n    t[R8]                 = { textureFormat: RED,             colorRenderable: true,  textureFilterable: true,  bytesPerElement: [1],        type: [UNSIGNED_BYTE], };\n    t[R8_SNORM]           = { textureFormat: RED,             colorRenderable: false, textureFilterable: true,  bytesPerElement: [1],        type: [BYTE], };\n    t[R16F]               = { textureFormat: RED,             colorRenderable: false, textureFilterable: true,  bytesPerElement: [4, 2],     type: [FLOAT, HALF_FLOAT], };\n    t[R32F]               = { textureFormat: RED,             colorRenderable: false, textureFilterable: false, bytesPerElement: [4],        type: [FLOAT], };\n    t[R8UI]               = { textureFormat: RED_INTEGER,     colorRenderable: true,  textureFilterable: false, bytesPerElement: [1],        type: [UNSIGNED_BYTE], };\n    t[R8I]                = { textureFormat: RED_INTEGER,     colorRenderable: true,  textureFilterable: false, bytesPerElement: [1],        type: [BYTE], };\n    t[R16UI]              = { textureFormat: RED_INTEGER,     colorRenderable: true,  textureFilterable: false, bytesPerElement: [2],        type: [UNSIGNED_SHORT], };\n    t[R16I]               = { textureFormat: RED_INTEGER,     colorRenderable: true,  textureFilterable: false, bytesPerElement: [2],        type: [SHORT], };\n    t[R32UI]              = { textureFormat: RED_INTEGER,     colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [UNSIGNED_INT], };\n    t[R32I]               = { textureFormat: RED_INTEGER,     colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [INT], };\n    t[RG8]                = { textureFormat: RG,              colorRenderable: true,  textureFilterable: true,  bytesPerElement: [2],        type: [UNSIGNED_BYTE], };\n    t[RG8_SNORM]          = { textureFormat: RG,              colorRenderable: false, textureFilterable: true,  bytesPerElement: [2],        type: [BYTE], };\n    t[RG16F]              = { textureFormat: RG,              colorRenderable: false, textureFilterable: true,  bytesPerElement: [8, 4],     type: [FLOAT, HALF_FLOAT], };\n    t[RG32F]              = { textureFormat: RG,              colorRenderable: false, textureFilterable: false, bytesPerElement: [8],        type: [FLOAT], };\n    t[RG8UI]              = { textureFormat: RG_INTEGER,      colorRenderable: true,  textureFilterable: false, bytesPerElement: [2],        type: [UNSIGNED_BYTE], };\n    t[RG8I]               = { textureFormat: RG_INTEGER,      colorRenderable: true,  textureFilterable: false, bytesPerElement: [2],        type: [BYTE], };\n    t[RG16UI]             = { textureFormat: RG_INTEGER,      colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [UNSIGNED_SHORT], };\n    t[RG16I]              = { textureFormat: RG_INTEGER,      colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [SHORT], };\n    t[RG32UI]             = { textureFormat: RG_INTEGER,      colorRenderable: true,  textureFilterable: false, bytesPerElement: [8],        type: [UNSIGNED_INT], };\n    t[RG32I]              = { textureFormat: RG_INTEGER,      colorRenderable: true,  textureFilterable: false, bytesPerElement: [8],        type: [INT], };\n    t[RGB8]               = { textureFormat: RGB,             colorRenderable: true,  textureFilterable: true,  bytesPerElement: [3],        type: [UNSIGNED_BYTE], };\n    t[SRGB8]              = { textureFormat: RGB,             colorRenderable: false, textureFilterable: true,  bytesPerElement: [3],        type: [UNSIGNED_BYTE], };\n    t[RGB565]             = { textureFormat: RGB,             colorRenderable: true,  textureFilterable: true,  bytesPerElement: [3, 2],     type: [UNSIGNED_BYTE, UNSIGNED_SHORT_5_6_5], };\n    t[RGB8_SNORM]         = { textureFormat: RGB,             colorRenderable: false, textureFilterable: true,  bytesPerElement: [3],        type: [BYTE], };\n    t[R11F_G11F_B10F]     = { textureFormat: RGB,             colorRenderable: false, textureFilterable: true,  bytesPerElement: [12, 6, 4], type: [FLOAT, HALF_FLOAT, UNSIGNED_INT_10F_11F_11F_REV], };\n    t[RGB9_E5]            = { textureFormat: RGB,             colorRenderable: false, textureFilterable: true,  bytesPerElement: [12, 6, 4], type: [FLOAT, HALF_FLOAT, UNSIGNED_INT_5_9_9_9_REV], };\n    t[RGB16F]             = { textureFormat: RGB,             colorRenderable: false, textureFilterable: true,  bytesPerElement: [12, 6],    type: [FLOAT, HALF_FLOAT], };\n    t[RGB32F]             = { textureFormat: RGB,             colorRenderable: false, textureFilterable: false, bytesPerElement: [12],       type: [FLOAT], };\n    t[RGB8UI]             = { textureFormat: RGB_INTEGER,     colorRenderable: false, textureFilterable: false, bytesPerElement: [3],        type: [UNSIGNED_BYTE], };\n    t[RGB8I]              = { textureFormat: RGB_INTEGER,     colorRenderable: false, textureFilterable: false, bytesPerElement: [3],        type: [BYTE], };\n    t[RGB16UI]            = { textureFormat: RGB_INTEGER,     colorRenderable: false, textureFilterable: false, bytesPerElement: [6],        type: [UNSIGNED_SHORT], };\n    t[RGB16I]             = { textureFormat: RGB_INTEGER,     colorRenderable: false, textureFilterable: false, bytesPerElement: [6],        type: [SHORT], };\n    t[RGB32UI]            = { textureFormat: RGB_INTEGER,     colorRenderable: false, textureFilterable: false, bytesPerElement: [12],       type: [UNSIGNED_INT], };\n    t[RGB32I]             = { textureFormat: RGB_INTEGER,     colorRenderable: false, textureFilterable: false, bytesPerElement: [12],       type: [INT], };\n    t[RGBA8]              = { textureFormat: RGBA,            colorRenderable: true,  textureFilterable: true,  bytesPerElement: [4],        type: [UNSIGNED_BYTE], };\n    t[SRGB8_ALPHA8]       = { textureFormat: RGBA,            colorRenderable: true,  textureFilterable: true,  bytesPerElement: [4],        type: [UNSIGNED_BYTE], };\n    t[RGBA8_SNORM]        = { textureFormat: RGBA,            colorRenderable: false, textureFilterable: true,  bytesPerElement: [4],        type: [BYTE], };\n    t[RGB5_A1]            = { textureFormat: RGBA,            colorRenderable: true,  textureFilterable: true,  bytesPerElement: [4, 2, 4],  type: [UNSIGNED_BYTE, UNSIGNED_SHORT_5_5_5_1, UNSIGNED_INT_2_10_10_10_REV], };\n    t[RGBA4]              = { textureFormat: RGBA,            colorRenderable: true,  textureFilterable: true,  bytesPerElement: [4, 2],     type: [UNSIGNED_BYTE, UNSIGNED_SHORT_4_4_4_4], };\n    t[RGB10_A2]           = { textureFormat: RGBA,            colorRenderable: true,  textureFilterable: true,  bytesPerElement: [4],        type: [UNSIGNED_INT_2_10_10_10_REV], };\n    t[RGBA16F]            = { textureFormat: RGBA,            colorRenderable: false, textureFilterable: true,  bytesPerElement: [16, 8],    type: [FLOAT, HALF_FLOAT], };\n    t[RGBA32F]            = { textureFormat: RGBA,            colorRenderable: false, textureFilterable: false, bytesPerElement: [16],       type: [FLOAT], };\n    t[RGBA8UI]            = { textureFormat: RGBA_INTEGER,    colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [UNSIGNED_BYTE], };\n    t[RGBA8I]             = { textureFormat: RGBA_INTEGER,    colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [BYTE], };\n    t[RGB10_A2UI]         = { textureFormat: RGBA_INTEGER,    colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [UNSIGNED_INT_2_10_10_10_REV], };\n    t[RGBA16UI]           = { textureFormat: RGBA_INTEGER,    colorRenderable: true,  textureFilterable: false, bytesPerElement: [8],        type: [UNSIGNED_SHORT], };\n    t[RGBA16I]            = { textureFormat: RGBA_INTEGER,    colorRenderable: true,  textureFilterable: false, bytesPerElement: [8],        type: [SHORT], };\n    t[RGBA32I]            = { textureFormat: RGBA_INTEGER,    colorRenderable: true,  textureFilterable: false, bytesPerElement: [16],       type: [INT], };\n    t[RGBA32UI]           = { textureFormat: RGBA_INTEGER,    colorRenderable: true,  textureFilterable: false, bytesPerElement: [16],       type: [UNSIGNED_INT], };\n    // Sized Internal\n    t[DEPTH_COMPONENT16]  = { textureFormat: DEPTH_COMPONENT, colorRenderable: true,  textureFilterable: false, bytesPerElement: [2, 4],     type: [UNSIGNED_SHORT, UNSIGNED_INT], };\n    t[DEPTH_COMPONENT24]  = { textureFormat: DEPTH_COMPONENT, colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [UNSIGNED_INT], };\n    t[DEPTH_COMPONENT32F] = { textureFormat: DEPTH_COMPONENT, colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [FLOAT], };\n    t[DEPTH24_STENCIL8]   = { textureFormat: DEPTH_STENCIL,   colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [UNSIGNED_INT_24_8], };\n    t[DEPTH32F_STENCIL8]  = { textureFormat: DEPTH_STENCIL,   colorRenderable: true,  textureFilterable: false, bytesPerElement: [4],        type: [FLOAT_32_UNSIGNED_INT_24_8_REV], };\n\n    Object.keys(t).forEach(function(internalFormat) {\n      const info = t[internalFormat];\n      info.bytesPerElementMap = {};\n      info.bytesPerElement.forEach(function(bytesPerElement, ndx) {\n        const type = info.type[ndx];\n        info.bytesPerElementMap[type] = bytesPerElement;\n      });\n    });\n    s_textureInternalFormatInfo = t;\n  }\n  return s_textureInternalFormatInfo[internalFormat];\n}\n\n/**\n * Gets the number of bytes per element for a given internalFormat / type\n * @param {number} internalFormat The internalFormat parameter from texImage2D etc..\n * @param {number} type The type parameter for texImage2D etc..\n * @return {number} the number of bytes per element for the given internalFormat, type combo\n * @memberOf module:twgl/textures\n */\nfunction getBytesPerElementForInternalFormat(internalFormat, type) {\n  const info = getTextureInternalFormatInfo(internalFormat);\n  if (!info) {\n    throw \"unknown internal format\";\n  }\n  const bytesPerElement = info.bytesPerElementMap[type];\n  if (bytesPerElement === undefined) {\n    throw \"unknown internal format\";\n  }\n  return bytesPerElement;\n}\n\n/**\n * Info related to a specific texture internalFormat as returned\n * from {@link module:twgl/textures.getFormatAndTypeForInternalFormat}.\n *\n * @typedef {Object} TextureFormatInfo\n * @property {number} format Format to pass to texImage2D and related functions\n * @property {number} type Type to pass to texImage2D and related functions\n * @memberOf module:twgl/textures\n */\n\n/**\n * Gets the format and type for a given internalFormat\n *\n * @param {number} internalFormat The internal format\n * @return {module:twgl/textures.TextureFormatInfo} the corresponding format and type,\n * @memberOf module:twgl/textures\n */\nfunction getFormatAndTypeForInternalFormat(internalFormat) {\n  const info = getTextureInternalFormatInfo(internalFormat);\n  if (!info) {\n    throw \"unknown internal format\";\n  }\n  return {\n    format: info.textureFormat,\n    type: info.type[0],\n  };\n}\n\n/**\n * Returns true if value is power of 2\n * @param {number} value number to check.\n * @return true if value is power of 2\n * @private\n */\nfunction isPowerOf2(value) {\n  return (value & (value - 1)) === 0;\n}\n\n/**\n * Gets whether or not we can generate mips for the given\n * internal format.\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {number} width The width parameter from texImage2D etc..\n * @param {number} height The height parameter from texImage2D etc..\n * @param {number} internalFormat The internalFormat parameter from texImage2D etc..\n * @return {boolean} true if we can generate mips\n * @memberOf module:twgl/textures\n */\nfunction canGenerateMipmap(gl, width, height, internalFormat) {\n  if (!utils.isWebGL2(gl)) {\n    return isPowerOf2(width) && isPowerOf2(height);\n  }\n  const info = getTextureInternalFormatInfo(internalFormat);\n  if (!info) {\n    throw \"unknown internal format\";\n  }\n  return info.colorRenderable && info.textureFilterable;\n}\n\n/**\n * Gets whether or not we can generate mips for the given format\n * @param {number} internalFormat The internalFormat parameter from texImage2D etc..\n * @return {boolean} true if we can generate mips\n * @memberOf module:twgl/textures\n */\nfunction canFilter(internalFormat) {\n  const info = getTextureInternalFormatInfo(internalFormat);\n  if (!info) {\n    throw \"unknown internal format\";\n  }\n  return info.textureFilterable;\n}\n\n/**\n * Gets the number of components for a given image format.\n * @param {number} format the format.\n * @return {number} the number of components for the format.\n * @memberOf module:twgl/textures\n */\nfunction getNumComponentsForFormat(format) {\n  const info = formatInfo[format];\n  if (!info) {\n    throw \"unknown format: \" + format;\n  }\n  return info.numColorComponents;\n}\n\n/**\n * Gets the texture type for a given array type.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @return {number} the gl texture type\n * @private\n */\nfunction getTextureTypeForArrayType(gl, src, defaultType) {\n  if (isArrayBuffer(src)) {\n    return typedArrays.getGLTypeForTypedArray(src);\n  }\n  return defaultType || UNSIGNED_BYTE;\n}\n\nfunction guessDimensions(gl, target, width, height, numElements) {\n  if (numElements % 1 !== 0) {\n    throw \"can't guess dimensions\";\n  }\n  if (!width && !height) {\n    const size = Math.sqrt(numElements / (target === TEXTURE_CUBE_MAP ? 6 : 1));\n    if (size % 1 === 0) {\n      width = size;\n      height = size;\n    } else {\n      width = numElements;\n      height = 1;\n    }\n  } else if (!height) {\n    height = numElements / width;\n    if (height % 1) {\n      throw \"can't guess dimensions\";\n    }\n  } else if (!width) {\n    width = numElements / height;\n    if (width % 1) {\n      throw \"can't guess dimensions\";\n    }\n  }\n  return {\n    width: width,\n    height: height,\n  };\n}\n\n/**\n * Sets the default texture color.\n *\n * The default texture color is used when loading textures from\n * urls. Because the URL will be loaded async we'd like to be\n * able to use the texture immediately. By putting a 1x1 pixel\n * color in the texture we can start using the texture before\n * the URL has loaded.\n *\n * @param {number[]} color Array of 4 values in the range 0 to 1\n * @deprecated see {@link module:twgl.setDefaults}\n * @memberOf module:twgl/textures\n */\nfunction setDefaultTextureColor(color) {\n  defaults.textureColor = new Uint8Array([color[0] * 255, color[1] * 255, color[2] * 255, color[3] * 255]);\n}\n\nfunction setDefaults(newDefaults) {\n  helper.copyExistingProperties(newDefaults, defaults);\n  if (newDefaults.textureColor) {\n    setDefaultTextureColor(newDefaults.textureColor);\n  }\n}\n\n/**\n * A function to generate the source for a texture.\n * @callback TextureFunc\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @param {module:twgl.TextureOptions} options the texture options\n * @return {*} Returns any of the things documented for `src` for {@link module:twgl.TextureOptions}.\n * @memberOf module:twgl\n */\n\n/**\n * Texture options passed to most texture functions. Each function will use whatever options\n * are appropriate for its needs. This lets you pass the same options to all functions.\n *\n * Note: A `TexImageSource` is defined in the WebGL spec as a `HTMLImageElement`, `HTMLVideoElement`,\n * `HTMLCanvasElement`, `ImageBitmap`, or `ImageData`.\n *\n * @typedef {Object} TextureOptions\n * @property {number} [target] the type of texture `gl.TEXTURE_2D` or `gl.TEXTURE_CUBE_MAP`. Defaults to `gl.TEXTURE_2D`.\n * @property {number} [level] the mip level to affect. Defaults to 0. Note, if set auto will be considered false unless explicitly set to true.\n * @property {number} [width] the width of the texture. Only used if src is an array or typed array or null.\n * @property {number} [height] the height of a texture. Only used if src is an array or typed array or null.\n * @property {number} [depth] the depth of a texture. Only used if src is an array or type array or null and target is `TEXTURE_3D` .\n * @property {number} [min] the min filter setting (eg. `gl.LINEAR`). Defaults to `gl.NEAREST_MIPMAP_LINEAR`\n *     or if texture is not a power of 2 on both dimensions then defaults to `gl.LINEAR`.\n * @property {number} [mag] the mag filter setting (eg. `gl.LINEAR`). Defaults to `gl.LINEAR`\n * @property {number} [minMag] both the min and mag filter settings.\n * @property {number} [internalFormat] internal format for texture. Defaults to `gl.RGBA`\n * @property {number} [format] format for texture. Defaults to `gl.RGBA`.\n * @property {number} [type] type for texture. Defaults to `gl.UNSIGNED_BYTE` unless `src` is ArrayBufferView. If `src`\n *     is ArrayBufferView defaults to type that matches ArrayBufferView type.\n * @property {number} [wrap] Texture wrapping for both S and T (and R if TEXTURE_3D or WebGLSampler). Defaults to `gl.REPEAT` for 2D unless src is WebGL1 and src not npot and `gl.CLAMP_TO_EDGE` for cube\n * @property {number} [wrapS] Texture wrapping for S. Defaults to `gl.REPEAT` and `gl.CLAMP_TO_EDGE` for cube. If set takes precedence over `wrap`.\n * @property {number} [wrapT] Texture wrapping for T. Defaults to `gl.REPEAT` and `gl.CLAMP_TO_EDGE` for cube. If set takes precedence over `wrap`.\n * @property {number} [wrapR] Texture wrapping for R. Defaults to `gl.REPEAT` and `gl.CLAMP_TO_EDGE` for cube. If set takes precedence over `wrap`.\n * @property {number} [minLod] TEXTURE_MIN_LOD setting\n * @property {number} [maxLod] TEXTURE_MAX_LOD setting\n * @property {number} [baseLevel] TEXTURE_BASE_LEVEL setting\n * @property {number} [maxLevel] TEXTURE_MAX_LEVEL setting\n * @property {number} [unpackAlignment] The `gl.UNPACK_ALIGNMENT` used when uploading an array. Defaults to 1.\n * @property {number[]|ArrayBufferView} [color] Color to initialize this texture with if loading an image asynchronously.\n *     The default use a blue 1x1 pixel texture. You can set another default by calling `twgl.setDefaults`\n *     or you can set an individual texture's initial color by setting this property. Example: `[1, .5, .5, 1]` = pink\n * @property {number} [premultiplyAlpha] Whether or not to premultiply alpha. Defaults to whatever the current setting is.\n *     This lets you set it once before calling `twgl.createTexture` or `twgl.createTextures` and only override\n *     the current setting for specific textures.\n * @property {number} [flipY] Whether or not to flip the texture vertically on upload. Defaults to whatever the current setting is.\n *     This lets you set it once before calling `twgl.createTexture` or `twgl.createTextures` and only override\n *     the current setting for specific textures.\n * @property {number} [colorspaceConversion] Whether or not to let the browser do colorspace conversion of the texture on upload. Defaults to whatever the current setting is.\n *     This lets you set it once before calling `twgl.createTexture` or `twgl.createTextures` and only override\n *     the current setting for specific textures.\n * @property {boolean} [auto] If `undefined` or `true`, in WebGL1, texture filtering is set automatically for non-power of 2 images and\n *    mips are generated for power of 2 images. In WebGL2 mips are generated if they can be. Note: if `level` is set above\n *    then then `auto` is assumed to be `false` unless explicity set to `true`.\n * @property {number[]} [cubeFaceOrder] The order that cube faces are pulled out of an img or set of images. The default is\n *\n *     [gl.TEXTURE_CUBE_MAP_POSITIVE_X,\n *      gl.TEXTURE_CUBE_MAP_NEGATIVE_X,\n *      gl.TEXTURE_CUBE_MAP_POSITIVE_Y,\n *      gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,\n *      gl.TEXTURE_CUBE_MAP_POSITIVE_Z,\n *      gl.TEXTURE_CUBE_MAP_NEGATIVE_Z]\n *\n * @property {(number[]|ArrayBufferView|TexImageSource|TexImageSource[]|string|string[]|module:twgl.TextureFunc)} [src] source for texture\n *\n *    If `string` then it's assumed to be a URL to an image. The image will be downloaded async. A usable\n *    1x1 pixel texture will be returned immediately. The texture will be updated once the image has downloaded.\n *    If `target` is `gl.TEXTURE_CUBE_MAP` will attempt to divide image into 6 square pieces. 1x6, 6x1, 3x2, 2x3.\n *    The pieces will be uploaded in `cubeFaceOrder`\n *\n *    If `string[]` or `TexImageSource[]` and target is `gl.TEXTURE_CUBE_MAP` then it must have 6 entries, one for each face of a cube map.\n *\n *    If `string[]` or `TexImageSource[]` and target is `gl.TEXTURE_2D_ARRAY` then each entry is a slice of the a 2d array texture\n *    and will be scaled to the specified width and height OR to the size of the first image that loads.\n *\n *    If `TexImageSource` then it wil be used immediately to create the contents of the texture. Examples `HTMLImageElement`,\n *    `HTMLCanvasElement`, `HTMLVideoElement`.\n *\n *    If `number[]` or `ArrayBufferView` it's assumed to be data for a texture. If `width` or `height` is\n *    not specified it is guessed as follows. First the number of elements is computed by `src.length / numComponents`\n *    where `numComponents` is derived from `format`. If `target` is `gl.TEXTURE_CUBE_MAP` then `numElements` is divided\n *    by 6. Then\n *\n *    *   If neither `width` nor `height` are specified and `sqrt(numElements)` is an integer then width and height\n *        are set to `sqrt(numElements)`. Otherwise `width = numElements` and `height = 1`.\n *\n *    *   If only one of `width` or `height` is specified then the other equals `numElements / specifiedDimension`.\n *\n * If `number[]` will be converted to `type`.\n *\n * If `src` is a function it will be called with a `WebGLRenderingContext` and these options.\n * Whatever it returns is subject to these rules. So it can return a string url, an `HTMLElement`\n * an array etc...\n *\n * If `src` is undefined then an empty texture will be created of size `width` by `height`.\n *\n * @property {string} [crossOrigin] What to set the crossOrigin property of images when they are downloaded.\n *    default: undefined. Also see {@link module:twgl.setDefaults}.\n *\n * @memberOf module:twgl\n */\n\n/**\n * Sets any packing state that will be set based on the options.\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction setPackState(gl, options) {\n  if (options.colorspaceConversion !== undefined) {\n    gl.pixelStorei(UNPACK_COLORSPACE_CONVERSION_WEBGL, options.colorspaceConversion);\n  }\n  if (options.premultiplyAlpha !== undefined) {\n    gl.pixelStorei(UNPACK_PREMULTIPLY_ALPHA_WEBGL, options.premultiplyAlpha);\n  }\n  if (options.flipY !== undefined) {\n    gl.pixelStorei(UNPACK_FLIP_Y_WEBGL, options.flipY);\n  }\n}\n\n/**\n * Set skip state to defaults\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction setSkipStateToDefault(gl) {\n  gl.pixelStorei(UNPACK_ALIGNMENT, 4);\n  if (utils.isWebGL2(gl)) {\n    gl.pixelStorei(UNPACK_ROW_LENGTH, 0);\n    gl.pixelStorei(UNPACK_IMAGE_HEIGHT, 0);\n    gl.pixelStorei(UNPACK_SKIP_PIXELS, 0);\n    gl.pixelStorei(UNPACK_SKIP_ROWS, 0);\n    gl.pixelStorei(UNPACK_SKIP_IMAGES, 0);\n  }\n}\n\n/**\n * Sets the parameters of a texture or sampler\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {number|WebGLSampler} target texture target or sampler\n * @param {function()} parameteriFn texParameteri or samplerParameteri fn\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n *   This is often the same options you passed in when you created the texture.\n * @private\n */\nfunction setTextureSamplerParameters(gl, target, parameteriFn, options) {\n  if (options.minMag) {\n    parameteriFn.call(gl, target, TEXTURE_MIN_FILTER, options.minMag);\n    parameteriFn.call(gl, target, TEXTURE_MAG_FILTER, options.minMag);\n  }\n  if (options.min) {\n    parameteriFn.call(gl, target, TEXTURE_MIN_FILTER, options.min);\n  }\n  if (options.mag) {\n    parameteriFn.call(gl, target, TEXTURE_MAG_FILTER, options.mag);\n  }\n  if (options.wrap) {\n    parameteriFn.call(gl, target, TEXTURE_WRAP_S, options.wrap);\n    parameteriFn.call(gl, target, TEXTURE_WRAP_T, options.wrap);\n    if (target === TEXTURE_3D || helper.isSampler(gl, target)) {\n      parameteriFn.call(gl, target, TEXTURE_WRAP_R, options.wrap);\n    }\n  }\n  if (options.wrapR) {\n    parameteriFn.call(gl, target, TEXTURE_WRAP_R, options.wrapR);\n  }\n  if (options.wrapS) {\n    parameteriFn.call(gl, target, TEXTURE_WRAP_S, options.wrapS);\n  }\n  if (options.wrapT) {\n    parameteriFn.call(gl, target, TEXTURE_WRAP_T, options.wrapT);\n  }\n  if (options.minLod) {\n    parameteriFn.call(gl, target, TEXTURE_MIN_LOD, options.minLod);\n  }\n  if (options.maxLod) {\n    parameteriFn.call(gl, target, TEXTURE_MAX_LOD, options.maxLod);\n  }\n  if (options.baseLevel) {\n    parameteriFn.call(gl, target, TEXTURE_BASE_LEVEL, options.baseLevel);\n  }\n  if (options.maxLevel) {\n    parameteriFn.call(gl, target, TEXTURE_MAX_LEVEL, options.maxLevel);\n  }\n}\n\n/**\n * Sets the texture parameters of a texture.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n *   This is often the same options you passed in when you created the texture.\n * @memberOf module:twgl/textures\n */\nfunction setTextureParameters(gl, tex, options) {\n  const target = options.target || TEXTURE_2D;\n  gl.bindTexture(target, tex);\n  setTextureSamplerParameters(gl, target, gl.texParameteri, options);\n}\n\n/**\n * Sets the sampler parameters of a sampler.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLSampler} sampler the WebGLSampler to set parameters for\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n * @memberOf module:twgl/textures\n */\nfunction setSamplerParameters(gl, sampler, options) {\n  setTextureSamplerParameters(gl, sampler, gl.samplerParameteri, options);\n}\n\n/**\n * Creates a new sampler object and sets parameters.\n *\n * Example:\n *\n *      const sampler = twgl.createSampler(gl, {\n *        minMag: gl.NEAREST,         // sets both TEXTURE_MIN_FILTER and TEXTURE_MAG_FILTER\n *        wrap: gl.CLAMP_TO_NEAREST,  // sets both TEXTURE_WRAP_S and TEXTURE_WRAP_T and TEXTURE_WRAP_R\n *      });\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {Object.<string,module:twgl.TextureOptions>} options A object of TextureOptions one per sampler.\n * @return {Object.<string,WebGLSampler>} the created samplers by name\n * @private\n */\nfunction createSampler(gl, options) {\n  const sampler = gl.createSampler();\n  setSamplerParameters(gl, sampler, options);\n  return sampler;\n}\n\n/**\n * Creates a multiple sampler objects and sets parameters on each.\n *\n * Example:\n *\n *      const samplers = twgl.createSamplers(gl, {\n *        nearest: {\n *          minMag: gl.NEAREST,\n *        },\n *        nearestClampS: {\n *          minMag: gl.NEAREST,\n *          wrapS: gl.CLAMP_TO_NEAREST,\n *        },\n *        linear: {\n *          minMag: gl.LINEAR,\n *        },\n *        nearestClamp: {\n *          minMag: gl.NEAREST,\n *          wrap: gl.CLAMP_TO_EDGE,\n *        },\n *        linearClamp: {\n *          minMag: gl.LINEAR,\n *          wrap: gl.CLAMP_TO_EDGE,\n *        },\n *        linearClampT: {\n *          minMag: gl.LINEAR,\n *          wrapT: gl.CLAMP_TO_EDGE,\n *        },\n *      });\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {module:twgl.TextureOptions} [options] A TextureOptions object with whatever parameters you want set on the sampler\n * @private\n */\nfunction createSamplers(gl, samplerOptions) {\n  const samplers = {};\n  Object.keys(samplerOptions).forEach(function(name) {\n    samplers[name] = createSampler(gl, samplerOptions[name]);\n  });\n  return samplers;\n}\n\n/**\n * Makes a 1x1 pixel\n * If no color is passed in uses the default color which can be set by calling `setDefaultTextureColor`.\n * @param {(number[]|ArrayBufferView)} [color] The color using 0-1 values\n * @return {Uint8Array} Unit8Array with color.\n * @private\n */\nfunction make1Pixel(color) {\n  color = color || defaults.textureColor;\n  if (isArrayBuffer(color)) {\n    return color;\n  }\n  return new Uint8Array([color[0] * 255, color[1] * 255, color[2] * 255, color[3] * 255]);\n}\n\n/**\n * Sets filtering or generates mips for texture based on width or height\n * If width or height is not passed in uses `options.width` and//or `options.height`\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} [options] A TextureOptions object with whatever parameters you want set.\n *   This is often the same options you passed in when you created the texture.\n * @param {number} [width] width of texture\n * @param {number} [height] height of texture\n * @param {number} [internalFormat] The internalFormat parameter from texImage2D etc..\n * @memberOf module:twgl/textures\n */\nfunction setTextureFilteringForSize(gl, tex, options, width, height, internalFormat) {\n  options = options || defaults.textureOptions;\n  internalFormat = internalFormat || RGBA;\n  const target = options.target || TEXTURE_2D;\n  width = width || options.width;\n  height = height || options.height;\n  gl.bindTexture(target, tex);\n  if (canGenerateMipmap(gl, width, height, internalFormat)) {\n    gl.generateMipmap(target);\n  } else {\n    const filtering = canFilter(internalFormat) ? LINEAR : NEAREST;\n    gl.texParameteri(target, TEXTURE_MIN_FILTER, filtering);\n    gl.texParameteri(target, TEXTURE_MAG_FILTER, filtering);\n    gl.texParameteri(target, TEXTURE_WRAP_S, CLAMP_TO_EDGE);\n    gl.texParameteri(target, TEXTURE_WRAP_T, CLAMP_TO_EDGE);\n  }\n}\n\nfunction shouldAutomaticallySetTextureFilteringForSize(options) {\n  return options.auto === true || (options.auto === undefined && options.level === undefined);\n}\n\n/**\n * Gets an array of cubemap face enums\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n *   This is often the same options you passed in when you created the texture.\n * @return {number[]} cubemap face enums\n * @private\n */\nfunction getCubeFaceOrder(gl, options) {\n  options = options || {};\n  return options.cubeFaceOrder || [\n      TEXTURE_CUBE_MAP_POSITIVE_X,\n      TEXTURE_CUBE_MAP_NEGATIVE_X,\n      TEXTURE_CUBE_MAP_POSITIVE_Y,\n      TEXTURE_CUBE_MAP_NEGATIVE_Y,\n      TEXTURE_CUBE_MAP_POSITIVE_Z,\n      TEXTURE_CUBE_MAP_NEGATIVE_Z,\n    ];\n}\n\n/**\n * @typedef {Object} FaceInfo\n * @property {number} face gl enum for texImage2D\n * @property {number} ndx face index (0 - 5) into source data\n * @ignore\n */\n\n/**\n * Gets an array of FaceInfos\n * There's a bug in some NVidia drivers that will crash the driver if\n * `gl.TEXTURE_CUBE_MAP_POSITIVE_X` is not uploaded first. So, we take\n * the user's desired order from his faces to WebGL and make sure we\n * do the faces in WebGL order\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n * @return {FaceInfo[]} cubemap face infos. Arguably the `face` property of each element is redundant but\n *    it's needed internally to sort the array of `ndx` properties by `face`.\n * @private\n */\nfunction getCubeFacesWithNdx(gl, options) {\n  const faces = getCubeFaceOrder(gl, options);\n  // work around bug in NVidia drivers. We have to upload the first face first else the driver crashes :(\n  const facesWithNdx = faces.map(function(face, ndx) {\n    return { face: face, ndx: ndx };\n  });\n  facesWithNdx.sort(function(a, b) {\n    return a.face - b.face;\n  });\n  return facesWithNdx;\n}\n\n/**\n * Set a texture from the contents of an element. Will also set\n * texture filtering or generate mips based on the dimensions of the element\n * unless `options.auto === false`. If `target === gl.TEXTURE_CUBE_MAP` will\n * attempt to slice image into 1x6, 2x3, 3x2, or 6x1 images, one for each face.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {HTMLElement} element a canvas, img, or video element.\n * @param {module:twgl.TextureOptions} [options] A TextureOptions object with whatever parameters you want set.\n *   This is often the same options you passed in when you created the texture.\n * @memberOf module:twgl/textures\n * @kind function\n */\nfunction setTextureFromElement(gl, tex, element, options) {\n  options = options || defaults.textureOptions;\n  const target = options.target || TEXTURE_2D;\n  const level = options.level || 0;\n  let width = element.width;\n  let height = element.height;\n  const internalFormat = options.internalFormat || options.format || RGBA;\n  const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n  const format = options.format || formatType.format;\n  const type = options.type || formatType.type;\n  setPackState(gl, options);\n  gl.bindTexture(target, tex);\n  if (target === TEXTURE_CUBE_MAP) {\n    // guess the parts\n    const imgWidth  = element.width;\n    const imgHeight = element.height;\n    let size;\n    let slices;\n    if (imgWidth / 6 === imgHeight) {\n      // It's 6x1\n      size = imgHeight;\n      slices = [0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0];\n    } else if (imgHeight / 6 === imgWidth) {\n      // It's 1x6\n      size = imgWidth;\n      slices = [0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5];\n    } else if (imgWidth / 3 === imgHeight / 2) {\n      // It's 3x2\n      size = imgWidth / 3;\n      slices = [0, 0, 1, 0, 2, 0, 0, 1, 1, 1, 2, 1];\n    } else if (imgWidth / 2 === imgHeight / 3) {\n      // It's 2x3\n      size = imgWidth / 2;\n      slices = [0, 0, 1, 0, 0, 1, 1, 1, 0, 2, 1, 2];\n    } else {\n      throw \"can't figure out cube map from element: \" + (element.src ? element.src : element.nodeName);\n    }\n    const ctx = getShared2DContext();\n    if (ctx) {\n      ctx.canvas.width = size;\n      ctx.canvas.height = size;\n      width = size;\n      height = size;\n      getCubeFacesWithNdx(gl, options).forEach(function(f) {\n        const xOffset = slices[f.ndx * 2 + 0] * size;\n        const yOffset = slices[f.ndx * 2 + 1] * size;\n        ctx.drawImage(element, xOffset, yOffset, size, size, 0, 0, size, size);\n        gl.texImage2D(f.face, level, internalFormat, format, type, ctx.canvas);\n      });\n      // Free up the canvas memory\n      ctx.canvas.width = 1;\n      ctx.canvas.height = 1;\n    } else if (typeof createImageBitmap !== 'undefined') {\n      // NOTE: It seems like we should prefer ImageBitmap because unlike canvas it's\n      // note lossy? (alpha is not premultiplied? although I'm not sure what\n      width = size;\n      height = size;\n      getCubeFacesWithNdx(gl, options).forEach(function(f) {\n        const xOffset = slices[f.ndx * 2 + 0] * size;\n        const yOffset = slices[f.ndx * 2 + 1] * size;\n        // We can't easily use a default texture color here as it would have to match\n        // the type across all faces where as with a 2D one there's only one face\n        // so we're replacing everything all at once. It also has to be the correct size.\n        // On the other hand we need all faces to be the same size so as one face loads\n        // the rest match else the texture will be un-renderable.\n        gl.texImage2D(f.face, level, internalFormat, size, size, 0, format, type, null);\n        createImageBitmap(element, xOffset, yOffset, size, size, {\n          premultiplyAlpha: 'none',\n          colorSpaceConversion: 'none',\n        })\n        .then(function(imageBitmap) {\n          setPackState(gl, options);\n          gl.bindTexture(target, tex);\n          gl.texImage2D(f.face, level, internalFormat, format, type, imageBitmap);\n          if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n            setTextureFilteringForSize(gl, tex, options, width, height, internalFormat);\n          }\n        });\n      });\n    }\n  } else if (target === TEXTURE_3D || target === TEXTURE_2D_ARRAY) {\n    const smallest = Math.min(element.width, element.height);\n    const largest = Math.max(element.width, element.height);\n    const depth = largest / smallest;\n    if (depth % 1 !== 0) {\n      throw \"can not compute 3D dimensions of element\";\n    }\n    const xMult = element.width  === largest ? 1 : 0;\n    const yMult = element.height === largest ? 1 : 0;\n    gl.pixelStorei(UNPACK_ALIGNMENT, 1);\n    gl.pixelStorei(UNPACK_ROW_LENGTH, element.width);\n    gl.pixelStorei(UNPACK_IMAGE_HEIGHT, 0);\n    gl.pixelStorei(UNPACK_SKIP_IMAGES, 0);\n    gl.texImage3D(target, level, internalFormat, smallest, smallest, smallest, 0, format, type, null);\n    for (let d = 0; d < depth; ++d) {\n      const srcX = d * smallest * xMult;\n      const srcY = d * smallest * yMult;\n      gl.pixelStorei(UNPACK_SKIP_PIXELS, srcX);\n      gl.pixelStorei(UNPACK_SKIP_ROWS, srcY);\n      gl.texSubImage3D(target, level, 0, 0, d, smallest, smallest, 1, format, type, element);\n    }\n    setSkipStateToDefault(gl);\n  } else {\n    gl.texImage2D(target, level, internalFormat, format, type, element);\n  }\n  if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n    setTextureFilteringForSize(gl, tex, options, width, height, internalFormat);\n  }\n  setTextureParameters(gl, tex, options);\n}\n\nfunction noop() {\n}\n\n/**\n * Checks whether the url's origin is the same so that we can set the `crossOrigin`\n * @param {string} url url to image\n * @returns {boolean} true if the window's origin is the same as image's url\n * @private\n */\nfunction urlIsSameOrigin(url) {\n  if (typeof document !== 'undefined') {\n    // for IE really\n    const a = document.createElement('a');\n    a.href = url;\n    return a.hostname === location.hostname &&\n           a.port     === location.port &&\n           a.protocol === location.protocol;\n  } else {\n    const localOrigin = (new URL(location.href)).origin;\n    const urlOrigin = (new URL(url, location.href)).origin;\n    return urlOrigin === localOrigin;\n  }\n}\n\nfunction setToAnonymousIfUndefinedAndURLIsNotSameOrigin(url, crossOrigin) {\n  return crossOrigin === undefined && !urlIsSameOrigin(url)\n     ? 'anonymous'\n     : crossOrigin;\n}\n\n/**\n * Loads an image\n * @param {string} url url to image\n * @param {string} crossOrigin\n * @param {function(err, img)} [callback] a callback that's passed an error and the image. The error will be non-null\n *     if there was an error\n * @return {HTMLImageElement} the image being loaded.\n * @private\n */\nfunction loadImage(url, crossOrigin, callback) {\n  callback = callback || noop;\n  let img;\n  crossOrigin = crossOrigin !== undefined ? crossOrigin : defaults.crossOrigin;\n  crossOrigin = setToAnonymousIfUndefinedAndURLIsNotSameOrigin(url, crossOrigin);\n  if (typeof Image !== 'undefined') {\n    img = new Image();\n    if (crossOrigin !== undefined) {\n      img.crossOrigin = crossOrigin;\n    }\n\n    const clearEventHandlers = function clearEventHandlers() {\n      img.removeEventListener('error', onError);  // eslint-disable-line\n      img.removeEventListener('load', onLoad);  // eslint-disable-line\n      img = null;\n    };\n\n    const onError = function onError() {\n      const msg = \"couldn't load image: \" + url;\n      helper.error(msg);\n      callback(msg, img);\n      clearEventHandlers();\n    };\n\n    const onLoad = function onLoad() {\n      callback(null, img);\n      clearEventHandlers();\n    };\n\n    img.addEventListener('error', onError);\n    img.addEventListener('load', onLoad);\n    img.src = url;\n    return img;\n  } else if (typeof ImageBitmap !== 'undefined') {\n    let err;\n    let bm;\n    const cb = function cb() {\n      callback(err, bm);\n    };\n\n    const options = {};\n    if (crossOrigin) {\n      options.mode = 'cors'; // TODO: not sure how to translate image.crossOrigin\n    }\n    fetch(url, options).then(function(response) {\n      if (!response.ok) {\n        throw response;\n      }\n      return response.blob();\n    }).then(function(blob) {\n      return createImageBitmap(blob, {\n        premultiplyAlpha: 'none',\n        colorSpaceConversion: 'none',\n      });\n    }).then(function(bitmap) {\n      // not sure if this works. We don't want\n      // to catch the user's error. So, call\n      // the callback in a timeout so we're\n      // not in this scope inside the promise.\n      bm = bitmap;\n      setTimeout(cb);\n    }).catch(function(e) {\n      err = e;\n      setTimeout(cb);\n    });\n    img = null;\n  }\n  return img;\n}\n\n/**\n * check if object is a TexImageSource\n *\n * @param {Object} obj Object to test\n * @return {boolean} true if object is a TexImageSource\n * @private\n */\nfunction isTexImageSource(obj) {\n  return (typeof ImageBitmap !== 'undefined' && obj instanceof ImageBitmap) ||\n         (typeof ImageData !== 'undefined'  && obj instanceof ImageData) ||\n         (typeof HTMLElement !== 'undefined'  && obj instanceof HTMLElement);\n}\n\n/**\n * if obj is an TexImageSource then just\n * uses it otherwise if obj is a string\n * then load it first.\n *\n * @param {string|TexImageSource} obj\n * @param {string} crossOrigin\n * @param {function(err, img)} [callback] a callback that's passed an error and the image. The error will be non-null\n *     if there was an error\n * @private\n */\nfunction loadAndUseImage(obj, crossOrigin, callback) {\n  if (isTexImageSource(obj)) {\n    setTimeout(function() {\n      callback(null, obj);\n    });\n    return obj;\n  }\n\n  return loadImage(obj, crossOrigin, callback);\n}\n\n/**\n * Sets a texture to a 1x1 pixel color. If `options.color === false` is nothing happens. If it's not set\n * the default texture color is used which can be set by calling `setDefaultTextureColor`.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} [options] A TextureOptions object with whatever parameters you want set.\n *   This is often the same options you passed in when you created the texture.\n * @memberOf module:twgl/textures\n */\nfunction setTextureTo1PixelColor(gl, tex, options) {\n  options = options || defaults.textureOptions;\n  const target = options.target || TEXTURE_2D;\n  gl.bindTexture(target, tex);\n  if (options.color === false) {\n    return;\n  }\n  // Assume it's a URL\n  // Put 1x1 pixels in texture. That makes it renderable immediately regardless of filtering.\n  const color = make1Pixel(options.color);\n  if (target === TEXTURE_CUBE_MAP) {\n    for (let ii = 0; ii < 6; ++ii) {\n      gl.texImage2D(TEXTURE_CUBE_MAP_POSITIVE_X + ii, 0, RGBA, 1, 1, 0, RGBA, UNSIGNED_BYTE, color);\n    }\n  } else if (target === TEXTURE_3D || target === TEXTURE_2D_ARRAY) {\n    gl.texImage3D(target, 0, RGBA, 1, 1, 1, 0, RGBA, UNSIGNED_BYTE, color);\n  } else {\n    gl.texImage2D(target, 0, RGBA, 1, 1, 0, RGBA, UNSIGNED_BYTE, color);\n  }\n}\n\n/**\n * The src image(s) used to create a texture.\n *\n * When you call {@link module:twgl.createTexture} or {@link module:twgl.createTextures}\n * you can pass in urls for images to load into the textures. If it's a single url\n * then this will be a single HTMLImageElement. If it's an array of urls used for a cubemap\n * this will be a corresponding array of images for the cubemap.\n *\n * @typedef {HTMLImageElement|HTMLImageElement[]} TextureSrc\n * @memberOf module:twgl\n */\n\n/**\n * A callback for when an image finished downloading and been uploaded into a texture\n * @callback TextureReadyCallback\n * @param {*} err If truthy there was an error.\n * @param {WebGLTexture} texture the texture.\n * @param {module:twgl.TextureSrc} source image(s) used to as the src for the texture\n * @memberOf module:twgl\n */\n\n/**\n * A callback for when all images have finished downloading and been uploaded into their respective textures\n * @callback TexturesReadyCallback\n * @param {*} err If truthy there was an error.\n * @param {Object.<string, WebGLTexture>} textures the created textures by name. Same as returned by {@link module:twgl.createTextures}.\n * @param {Object.<string, module:twgl.TextureSrc>} sources the image(s) used for the texture by name.\n * @memberOf module:twgl\n */\n\n/**\n * A callback for when an image finished downloading and been uploaded into a texture\n * @callback CubemapReadyCallback\n * @param {*} err If truthy there was an error.\n * @param {WebGLTexture} tex the texture.\n * @param {HTMLImageElement[]} imgs the images for each face.\n * @memberOf module:twgl\n */\n\n/**\n * A callback for when an image finished downloading and been uploaded into a texture\n * @callback ThreeDReadyCallback\n * @param {*} err If truthy there was an error.\n * @param {WebGLTexture} tex the texture.\n * @param {HTMLImageElement[]} imgs the images for each slice.\n * @memberOf module:twgl\n */\n\n/**\n * Loads a texture from an image from a Url as specified in `options.src`\n * If `options.color !== false` will set the texture to a 1x1 pixel color so that the texture is\n * immediately useable. It will be updated with the contents of the image once the image has finished\n * downloading. Filtering options will be set as appropriate for image unless `options.auto === false`.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} [options] A TextureOptions object with whatever parameters you want set.\n * @param {module:twgl.TextureReadyCallback} [callback] A function to be called when the image has finished loading. err will\n *    be non null if there was an error.\n * @return {HTMLImageElement} the image being downloaded.\n * @memberOf module:twgl/textures\n */\nfunction loadTextureFromUrl(gl, tex, options, callback) {\n  callback = callback || noop;\n  options = options || defaults.textureOptions;\n  setTextureTo1PixelColor(gl, tex, options);\n  // Because it's async we need to copy the options.\n  options = Object.assign({}, options);\n  const img = loadAndUseImage(options.src, options.crossOrigin, function(err, img) {\n    if (err) {\n      callback(err, tex, img);\n    } else {\n      setTextureFromElement(gl, tex, img, options);\n      callback(null, tex, img);\n    }\n  });\n  return img;\n}\n\n/**\n * Loads a cubemap from 6 urls or TexImageSources as specified in `options.src`. Will set the cubemap to a 1x1 pixel color\n * so that it is usable immediately unless `option.color === false`.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n * @param {module:twgl.CubemapReadyCallback} [callback] A function to be called when all the images have finished loading. err will\n *    be non null if there was an error.\n * @memberOf module:twgl/textures\n */\nfunction loadCubemapFromUrls(gl, tex, options, callback) {\n  callback = callback || noop;\n  const urls = options.src;\n  if (urls.length !== 6) {\n    throw \"there must be 6 urls for a cubemap\";\n  }\n  const level = options.level || 0;\n  const internalFormat = options.internalFormat || options.format || RGBA;\n  const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n  const format = options.format || formatType.format;\n  const type = options.type || UNSIGNED_BYTE;\n  const target = options.target || TEXTURE_2D;\n  if (target !== TEXTURE_CUBE_MAP) {\n    throw \"target must be TEXTURE_CUBE_MAP\";\n  }\n  setTextureTo1PixelColor(gl, tex, options);\n  // Because it's async we need to copy the options.\n  options = Object.assign({}, options);\n  let numToLoad = 6;\n  const errors = [];\n  const faces = getCubeFaceOrder(gl, options);\n  let imgs;  // eslint-disable-line\n\n  function uploadImg(faceTarget) {\n    return function(err, img) {\n      --numToLoad;\n      if (err) {\n        errors.push(err);\n      } else {\n        if (img.width !== img.height) {\n          errors.push(\"cubemap face img is not a square: \" + img.src);\n        } else {\n          setPackState(gl, options);\n          gl.bindTexture(target, tex);\n\n          // So assuming this is the first image we now have one face that's img sized\n          // and 5 faces that are 1x1 pixel so size the other faces\n          if (numToLoad === 5) {\n            // use the default order\n            getCubeFaceOrder(gl).forEach(function(otherTarget) {\n              // Should we re-use the same face or a color?\n              gl.texImage2D(otherTarget, level, internalFormat, format, type, img);\n            });\n          } else {\n            gl.texImage2D(faceTarget, level, internalFormat, format, type, img);\n          }\n\n          if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n            gl.generateMipmap(target);\n          }\n        }\n      }\n\n      if (numToLoad === 0) {\n        callback(errors.length ? errors : undefined, tex, imgs);\n      }\n    };\n  }\n\n  imgs = urls.map(function(url, ndx) {\n    return loadAndUseImage(url, options.crossOrigin, uploadImg(faces[ndx]));\n  });\n}\n\n/**\n * Loads a 2d array or 3d texture from urls OR TexImageSources as specified in `options.src`.\n * Will set the texture to a 1x1 pixel color\n * so that it is usable immediately unless `option.color === false`.\n *\n * If the width and height is not specified the width and height of the first\n * image loaded will be used. Note that since images are loaded async\n * which image downloads first is unknown.\n *\n * If an image is not the same size as the width and height it will be scaled\n * to that width and height.\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n * @param {module:twgl.ThreeDReadyCallback} [callback] A function to be called when all the images have finished loading. err will\n *    be non null if there was an error.\n * @memberOf module:twgl/textures\n */\nfunction loadSlicesFromUrls(gl, tex, options, callback) {\n  callback = callback || noop;\n  const urls = options.src;\n  const internalFormat = options.internalFormat || options.format || RGBA;\n  const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n  const format = options.format || formatType.format;\n  const type = options.type || UNSIGNED_BYTE;\n  const target = options.target || TEXTURE_2D_ARRAY;\n  if (target !== TEXTURE_3D && target !== TEXTURE_2D_ARRAY) {\n    throw \"target must be TEXTURE_3D or TEXTURE_2D_ARRAY\";\n  }\n  setTextureTo1PixelColor(gl, tex, options);\n  // Because it's async we need to copy the options.\n  options = Object.assign({}, options);\n  let numToLoad = urls.length;\n  const errors = [];\n  let imgs;  // eslint-disable-line\n  const level = options.level || 0;\n  let width = options.width;\n  let height = options.height;\n  const depth = urls.length;\n  let firstImage = true;\n\n  function uploadImg(slice) {\n    return function(err, img) {\n      --numToLoad;\n      if (err) {\n        errors.push(err);\n      } else {\n        setPackState(gl, options);\n        gl.bindTexture(target, tex);\n\n        if (firstImage) {\n          firstImage = false;\n          width = options.width || img.width;\n          height = options.height || img.height;\n          gl.texImage3D(target, level, internalFormat, width, height, depth, 0, format, type, null);\n\n          // put it in every slice otherwise some slices will be 0,0,0,0\n          for (let s = 0; s < depth; ++s) {\n            gl.texSubImage3D(target, level, 0, 0, s, width, height, 1, format, type, img);\n          }\n        } else {\n          let src = img;\n          let ctx;\n          if (img.width !== width || img.height !== height) {\n            // Size the image to fix\n            ctx = getShared2DContext();\n            src = ctx.canvas;\n            ctx.canvas.width = width;\n            ctx.canvas.height = height;\n            ctx.drawImage(img, 0, 0, width, height);\n          }\n\n          gl.texSubImage3D(target, level, 0, 0, slice, width, height, 1, format, type, src);\n\n          // free the canvas memory\n          if (ctx && src === ctx.canvas) {\n            ctx.canvas.width = 0;\n            ctx.canvas.height = 0;\n          }\n        }\n\n        if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n          gl.generateMipmap(target);\n        }\n      }\n\n      if (numToLoad === 0) {\n        callback(errors.length ? errors : undefined, tex, imgs);\n      }\n    };\n  }\n\n  imgs = urls.map(function(url, ndx) {\n    return loadAndUseImage(url, options.crossOrigin, uploadImg(ndx));\n  });\n}\n\n/**\n * Sets a texture from an array or typed array. If the width or height is not provided will attempt to\n * guess the size. See {@link module:twgl.TextureOptions}.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {(number[]|ArrayBufferView)} src An array or typed arry with texture data.\n * @param {module:twgl.TextureOptions} [options] A TextureOptions object with whatever parameters you want set.\n *   This is often the same options you passed in when you created the texture.\n * @memberOf module:twgl/textures\n */\nfunction setTextureFromArray(gl, tex, src, options) {\n  options = options || defaults.textureOptions;\n  const target = options.target || TEXTURE_2D;\n  gl.bindTexture(target, tex);\n  let width = options.width;\n  let height = options.height;\n  let depth = options.depth;\n  const level = options.level || 0;\n  const internalFormat = options.internalFormat || options.format || RGBA;\n  const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n  const format = options.format || formatType.format;\n  const type = options.type || getTextureTypeForArrayType(gl, src, formatType.type);\n  if (!isArrayBuffer(src)) {\n    const Type = typedArrays.getTypedArrayTypeForGLType(type);\n    src = new Type(src);\n  } else if (src instanceof Uint8ClampedArray) {\n    src = new Uint8Array(src.buffer);\n  }\n\n  const bytesPerElement = getBytesPerElementForInternalFormat(internalFormat, type);\n  const numElements = src.byteLength / bytesPerElement;  // TODO: check UNPACK_ALIGNMENT?\n  if (numElements % 1) {\n    throw \"length wrong size for format: \" + utils.glEnumToString(gl, format);\n  }\n  let dimensions;\n  if (target === TEXTURE_3D || target === TEXTURE_2D_ARRAY) {\n    if (!width && !height && !depth) {\n      const size = Math.cbrt(numElements);\n      if (size % 1 !== 0) {\n        throw \"can't guess cube size of array of numElements: \" + numElements;\n      }\n      width = size;\n      height = size;\n      depth = size;\n    } else if (width && (!height || !depth)) {\n      dimensions = guessDimensions(gl, target, height, depth, numElements / width);\n      height = dimensions.width;\n      depth = dimensions.height;\n    } else if (height && (!width || !depth)) {\n      dimensions = guessDimensions(gl, target, width, depth, numElements / height);\n      width = dimensions.width;\n      depth = dimensions.height;\n    } else {\n      dimensions = guessDimensions(gl, target, width, height, numElements / depth);\n      width = dimensions.width;\n      height = dimensions.height;\n    }\n  } else {\n    dimensions = guessDimensions(gl, target, width, height, numElements);\n    width = dimensions.width;\n    height = dimensions.height;\n  }\n  setSkipStateToDefault(gl);\n  gl.pixelStorei(UNPACK_ALIGNMENT, options.unpackAlignment || 1);\n  setPackState(gl, options);\n  if (target === TEXTURE_CUBE_MAP) {\n    const elementsPerElement = bytesPerElement / src.BYTES_PER_ELEMENT;\n    const faceSize = numElements / 6 * elementsPerElement;\n\n    getCubeFacesWithNdx(gl, options).forEach(f => {\n      const offset = faceSize * f.ndx;\n      const data = src.subarray(offset, offset + faceSize);\n      gl.texImage2D(f.face, level, internalFormat, width, height, 0, format, type, data);\n    });\n  } else if (target === TEXTURE_3D || target === TEXTURE_2D_ARRAY) {\n    gl.texImage3D(target, level, internalFormat, width, height, depth, 0, format, type, src);\n  } else {\n    gl.texImage2D(target, level, internalFormat, width, height, 0, format, type, src);\n  }\n  return {\n    width: width,\n    height: height,\n    depth: depth,\n    type: type,\n  };\n}\n\n/**\n * Sets a texture with no contents of a certain size. In other words calls `gl.texImage2D` with `null`.\n * You must set `options.width` and `options.height`.\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the WebGLTexture to set parameters for\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n * @memberOf module:twgl/textures\n */\nfunction setEmptyTexture(gl, tex, options) {\n  const target = options.target || TEXTURE_2D;\n  gl.bindTexture(target, tex);\n  const level = options.level || 0;\n  const internalFormat = options.internalFormat || options.format || RGBA;\n  const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n  const format = options.format || formatType.format;\n  const type = options.type || formatType.type;\n  setPackState(gl, options);\n  if (target === TEXTURE_CUBE_MAP) {\n    for (let ii = 0; ii < 6; ++ii) {\n      gl.texImage2D(TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, options.width, options.height, 0, format, type, null);\n    }\n  } else if (target === TEXTURE_3D || target === TEXTURE_2D_ARRAY) {\n    gl.texImage3D(target, level, internalFormat, options.width, options.height, options.depth, 0, format, type, null);\n  } else {\n    gl.texImage2D(target, level, internalFormat, options.width, options.height, 0, format, type, null);\n  }\n}\n\n/**\n * Creates a texture based on the options passed in.\n *\n * Note: may reset UNPACK_ALIGNMENT, UNPACK_ROW_LENGTH, UNPACK_IMAGE_HEIGHT, UNPACK_SKIP_IMAGES\n * UNPACK_SKIP_PIXELS, and UNPACK_SKIP_ROWS\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {module:twgl.TextureOptions} [options] A TextureOptions object with whatever parameters you want set.\n * @param {module:twgl.TextureReadyCallback} [callback] A callback called when an image has been downloaded and uploaded to the texture.\n * @return {WebGLTexture} the created texture.\n * @memberOf module:twgl/textures\n */\nfunction createTexture(gl, options, callback) {\n  callback = callback || noop;\n  options = options || defaults.textureOptions;\n  const tex = gl.createTexture();\n  const target = options.target || TEXTURE_2D;\n  let width  = options.width  || 1;\n  let height = options.height || 1;\n  const internalFormat = options.internalFormat || RGBA;\n  gl.bindTexture(target, tex);\n  if (target === TEXTURE_CUBE_MAP) {\n    // this should have been the default for cubemaps :(\n    gl.texParameteri(target, TEXTURE_WRAP_S, CLAMP_TO_EDGE);\n    gl.texParameteri(target, TEXTURE_WRAP_T, CLAMP_TO_EDGE);\n  }\n  let src = options.src;\n  if (src) {\n    if (typeof src === \"function\") {\n      src = src(gl, options);\n    }\n    if (typeof (src) === \"string\") {\n      loadTextureFromUrl(gl, tex, options, callback);\n    } else if (isArrayBuffer(src) ||\n               (Array.isArray(src) && (\n                    typeof src[0] === 'number' ||\n                    Array.isArray(src[0]) ||\n                    isArrayBuffer(src[0]))\n               )\n              ) {\n      const dimensions = setTextureFromArray(gl, tex, src, options);\n      width  = dimensions.width;\n      height = dimensions.height;\n    } else if (Array.isArray(src) && (typeof (src[0]) === 'string' || isTexImageSource(src[0]))) {\n      if (target === TEXTURE_CUBE_MAP) {\n        loadCubemapFromUrls(gl, tex, options, callback);\n      } else {\n        loadSlicesFromUrls(gl, tex, options, callback);\n      }\n    } else { // if (isTexImageSource(src))\n      setTextureFromElement(gl, tex, src, options);\n      width  = src.width;\n      height = src.height;\n    }\n  } else {\n    setEmptyTexture(gl, tex, options);\n  }\n  if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n    setTextureFilteringForSize(gl, tex, options, width, height, internalFormat);\n  }\n  setTextureParameters(gl, tex, options);\n  return tex;\n}\n\n/**\n * Resizes a texture based on the options passed in.\n *\n * Note: This is not a generic resize anything function.\n * It's mostly used by {@link module:twgl.resizeFramebufferInfo}\n * It will use `options.src` if it exists to try to determine a `type`\n * otherwise it will assume `gl.UNSIGNED_BYTE`. No data is provided\n * for the texture. Texture parameters will be set accordingly\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {WebGLTexture} tex the texture to resize\n * @param {module:twgl.TextureOptions} options A TextureOptions object with whatever parameters you want set.\n * @param {number} [width] the new width. If not passed in will use `options.width`\n * @param {number} [height] the new height. If not passed in will use `options.height`\n * @param {number} [depth] the new depth. If not passed in will use `options.depth`\n * @memberOf module:twgl/textures\n */\nfunction resizeTexture(gl, tex, options, width, height, depth) {\n  width = width || options.width;\n  height = height || options.height;\n  depth = depth || options.depth;\n  const target = options.target || TEXTURE_2D;\n  gl.bindTexture(target, tex);\n  const level = options.level || 0;\n  const internalFormat = options.internalFormat || options.format || RGBA;\n  const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n  const format = options.format || formatType.format;\n  let type;\n  const src = options.src;\n  if (!src) {\n    type = options.type || formatType.type;\n  } else if (isArrayBuffer(src) || (Array.isArray(src) && typeof (src[0]) === 'number')) {\n    type = options.type || getTextureTypeForArrayType(gl, src, formatType.type);\n  } else {\n    type = options.type || formatType.type;\n  }\n  if (target === TEXTURE_CUBE_MAP) {\n    for (let ii = 0; ii < 6; ++ii) {\n      gl.texImage2D(TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, width, height, 0, format, type, null);\n    }\n  } else if (target === TEXTURE_3D || target === TEXTURE_2D_ARRAY) {\n    gl.texImage3D(target, level, internalFormat, width, height, depth, 0, format, type, null);\n  } else {\n    gl.texImage2D(target, level, internalFormat, width, height, 0, format, type, null);\n  }\n}\n\n/**\n * Check if a src is an async request.\n * if src is a string we're going to download an image\n * if src is an array of strings we're going to download cubemap images\n * @param {*} src The src from a TextureOptions\n * @returns {bool} true if src is async.\n * @private\n */\nfunction isAsyncSrc(src) {\n  return typeof src === 'string' ||\n         (Array.isArray(src) && typeof src[0] === 'string');\n}\n\n/**\n * Creates a bunch of textures based on the passed in options.\n *\n * Example:\n *\n *     const textures = twgl.createTextures(gl, {\n *       // a power of 2 image\n *       hftIcon: { src: \"images/hft-icon-16.png\", mag: gl.NEAREST },\n *       // a non-power of 2 image\n *       clover: { src: \"images/clover.jpg\" },\n *       // From a canvas\n *       fromCanvas: { src: ctx.canvas },\n *       // A cubemap from 6 images\n *       yokohama: {\n *         target: gl.TEXTURE_CUBE_MAP,\n *         src: [\n *           'images/yokohama/posx.jpg',\n *           'images/yokohama/negx.jpg',\n *           'images/yokohama/posy.jpg',\n *           'images/yokohama/negy.jpg',\n *           'images/yokohama/posz.jpg',\n *           'images/yokohama/negz.jpg',\n *         ],\n *       },\n *       // A cubemap from 1 image (can be 1x6, 2x3, 3x2, 6x1)\n *       goldengate: {\n *         target: gl.TEXTURE_CUBE_MAP,\n *         src: 'images/goldengate.jpg',\n *       },\n *       // A 2x2 pixel texture from a JavaScript array\n *       checker: {\n *         mag: gl.NEAREST,\n *         min: gl.LINEAR,\n *         src: [\n *           255,255,255,255,\n *           192,192,192,255,\n *           192,192,192,255,\n *           255,255,255,255,\n *         ],\n *       },\n *       // a 1x2 pixel texture from a typed array.\n *       stripe: {\n *         mag: gl.NEAREST,\n *         min: gl.LINEAR,\n *         format: gl.LUMINANCE,\n *         src: new Uint8Array([\n *           255,\n *           128,\n *           255,\n *           128,\n *           255,\n *           128,\n *           255,\n *           128,\n *         ]),\n *         width: 1,\n *       },\n *     });\n *\n * Now\n *\n * *   `textures.hftIcon` will be a 2d texture\n * *   `textures.clover` will be a 2d texture\n * *   `textures.fromCanvas` will be a 2d texture\n * *   `textures.yohohama` will be a cubemap texture\n * *   `textures.goldengate` will be a cubemap texture\n * *   `textures.checker` will be a 2d texture\n * *   `textures.stripe` will be a 2d texture\n *\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @param {Object.<string,module:twgl.TextureOptions>} options A object of TextureOptions one per texture.\n * @param {module:twgl.TexturesReadyCallback} [callback] A callback called when all textures have been downloaded.\n * @return {Object.<string,WebGLTexture>} the created textures by name\n * @memberOf module:twgl/textures\n */\nfunction createTextures(gl, textureOptions, callback) {\n  callback = callback || noop;\n  let numDownloading = 0;\n  const errors = [];\n  const textures = {};\n  const images = {};\n\n  function callCallbackIfReady() {\n    if (numDownloading === 0) {\n      setTimeout(function() {\n        callback(errors.length ? errors : undefined, textures, images);\n      }, 0);\n    }\n  }\n\n  Object.keys(textureOptions).forEach(function(name) {\n    const options = textureOptions[name];\n    let onLoadFn;\n    if (isAsyncSrc(options.src)) {\n      onLoadFn = function(err, tex, img) {\n        images[name] = img;\n        --numDownloading;\n        if (err) {\n          errors.push(err);\n        }\n        callCallbackIfReady();\n      };\n      ++numDownloading;\n    }\n    textures[name] = createTexture(gl, options, onLoadFn);\n  });\n\n  // queue the callback if there are no images to download.\n  // We do this because if your code is structured to wait for\n  // images to download but then you comment out all the async\n  // images your code would break.\n  callCallbackIfReady();\n\n  return textures;\n}\n\nexport {\n  setDefaults as setTextureDefaults_,\n\n  createSampler,\n  createSamplers,\n  setSamplerParameters,\n\n  createTexture,\n  setEmptyTexture,\n  setTextureFromArray,\n  loadTextureFromUrl,\n  setTextureFromElement,\n  setTextureFilteringForSize,\n  setTextureParameters,\n  setDefaultTextureColor,\n  createTextures,\n  resizeTexture,\n\n  canGenerateMipmap,\n  canFilter,\n  getNumComponentsForFormat,\n  getBytesPerElementForInternalFormat,\n  getFormatAndTypeForInternalFormat,\n};\n\n","import * as m4 from './m4.js';\nimport * as v3 from './v3.js';\nimport * as primitives from './primitives.js';\n\nexport * from './twgl.js';\nexport {\n  m4,\n  v3,\n  primitives,\n};\n\n\n\n\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as attributes from './attributes.js';\nimport * as textures from './textures.js';\nimport * as helper from './helper.js';\nimport * as utils from './utils.js';\n\nimport * as draw from './draw.js';\nimport * as framebuffers from './framebuffers.js';\nimport * as programs from './programs.js';\nimport * as typedarrays from './typedarrays.js';\nimport * as vertexArrays from './vertex-arrays.js';\n\n/**\n * The main TWGL module.\n *\n * For most use cases you shouldn't need anything outside this module.\n * Exceptions between the stuff added to twgl-full (v3, m4, primitives)\n *\n * @module twgl\n * @borrows module:twgl/attributes.setAttribInfoBufferFromArray as setAttribInfoBufferFromArray\n * @borrows module:twgl/attributes.createBufferInfoFromArrays as createBufferInfoFromArrays\n * @borrows module:twgl/attributes.createVertexArrayInfo as createVertexArrayInfo\n * @borrows module:twgl/draw.drawBufferInfo as drawBufferInfo\n * @borrows module:twgl/draw.drawObjectList as drawObjectList\n * @borrows module:twgl/framebuffers.createFramebufferInfo as createFramebufferInfo\n * @borrows module:twgl/framebuffers.resizeFramebufferInfo as resizeFramebufferInfo\n * @borrows module:twgl/framebuffers.bindFramebufferInfo as bindFramebufferInfo\n * @borrows module:twgl/programs.createProgramInfo as createProgramInfo\n * @borrows module:twgl/programs.createUniformBlockInfo as createUniformBlockInfo\n * @borrows module:twgl/programs.bindUniformBlock as bindUniformBlock\n * @borrows module:twgl/programs.setUniformBlock as setUniformBlock\n * @borrows module:twgl/programs.setBlockUniforms as setBlockUniforms\n * @borrows module:twgl/programs.setUniforms as setUniforms\n * @borrows module:twgl/programs.setBuffersAndAttributes as setBuffersAndAttributes\n * @borrows module:twgl/textures.setTextureFromArray as setTextureFromArray\n * @borrows module:twgl/textures.createTexture as createTexture\n * @borrows module:twgl/textures.resizeTexture as resizeTexture\n * @borrows module:twgl/textures.createTextures as createTextures\n */\n\n// make sure we don't see a global gl\nconst gl = undefined;  /* eslint-disable-line */\nconst defaults = {\n  addExtensionsToContext: true,\n};\n\n/**\n * Various default settings for twgl.\n *\n * Note: You can call this any number of times. Example:\n *\n *     twgl.setDefaults({ textureColor: [1, 0, 0, 1] });\n *     twgl.setDefaults({ attribPrefix: 'a_' });\n *\n * is equivalent to\n *\n *     twgl.setDefaults({\n *       textureColor: [1, 0, 0, 1],\n *       attribPrefix: 'a_',\n *     });\n *\n * @typedef {Object} Defaults\n * @property {string} [attribPrefix] The prefix to stick on attributes\n *\n *   When writing shaders I prefer to name attributes with `a_`, uniforms with `u_` and varyings with `v_`\n *   as it makes it clear where they came from. But, when building geometry I prefer using un-prefixed names.\n *\n *   In other words I'll create arrays of geometry like this\n *\n *       const arrays = {\n *         position: ...\n *         normal: ...\n *         texcoord: ...\n *       };\n *\n *   But need those mapped to attributes and my attributes start with `a_`.\n *\n *   Default: `\"\"`\n *\n * @property {number[]} [textureColor] Array of 4 values in the range 0 to 1\n *\n *   The default texture color is used when loading textures from\n *   urls. Because the URL will be loaded async we'd like to be\n *   able to use the texture immediately. By putting a 1x1 pixel\n *   color in the texture we can start using the texture before\n *   the URL has loaded.\n *\n *   Default: `[0.5, 0.75, 1, 1]`\n *\n * @property {string} [crossOrigin]\n *\n *   If not undefined sets the crossOrigin attribute on images\n *   that twgl creates when downloading images for textures.\n *\n *   Also see {@link module:twgl.TextureOptions}.\n *\n * @property {bool} [addExtensionsToContext]\n *\n *   If true, then, when twgl will try to add any supported WebGL extensions\n *   directly to the context under their normal GL names. For example\n *   if ANGLE_instances_arrays exists then twgl would enable it,\n *   add the functions `vertexAttribDivisor`, `drawArraysInstanced`,\n *   `drawElementsInstanced`, and the constant `VERTEX_ATTRIB_ARRAY_DIVISOR`\n *   to the `WebGLRenderingContext`.\n *\n * @memberOf module:twgl\n */\n\n/**\n * Sets various defaults for twgl.\n *\n * In the interest of terseness which is kind of the point\n * of twgl I've integrated a few of the older functions here\n *\n * @param {module:twgl.Defaults} newDefaults The default settings.\n * @memberOf module:twgl\n */\nfunction setDefaults(newDefaults) {\n  helper.copyExistingProperties(newDefaults, defaults);\n  attributes.setAttributeDefaults_(newDefaults);  // eslint-disable-line\n  textures.setTextureDefaults_(newDefaults);  // eslint-disable-line\n}\n\nconst prefixRE = /^(.*?)_/;\nfunction addExtensionToContext(gl, extensionName) {\n  utils.glEnumToString(gl, 0);\n  const ext = gl.getExtension(extensionName);\n  if (ext) {\n    const enums = {};\n    const fnSuffix = prefixRE.exec(extensionName)[1];\n    const enumSuffix = '_' + fnSuffix;\n    for (const key in ext) {\n      const value = ext[key];\n      const isFunc = typeof (value) === 'function';\n      const suffix = isFunc ? fnSuffix : enumSuffix;\n      let name = key;\n      // examples of where this is not true are WEBGL_compressed_texture_s3tc\n      // and WEBGL_compressed_texture_pvrtc\n      if (key.endsWith(suffix)) {\n        name = key.substring(0, key.length - suffix.length);\n      }\n      if (gl[name] !== undefined) {\n        if (!isFunc && gl[name] !== value) {\n          helper.warn(name, gl[name], value, key);\n        }\n      } else {\n        if (isFunc) {\n          gl[name] = function(origFn) {\n            return function() {\n              return origFn.apply(ext, arguments);\n            };\n          }(value);\n        } else {\n          gl[name] = value;\n          enums[name] = value;\n        }\n      }\n    }\n    // pass the modified enums to glEnumToString\n    enums.constructor = {\n      name: ext.constructor.name,\n    };\n    utils.glEnumToString(enums, 0);\n  }\n  return ext;\n}\n\n/*\n * If you're wondering why the code doesn't just iterate\n * over all extensions using `gl.getExtensions` is that it's possible\n * some future extension is incompatible with this code. Rather than\n * have thing suddenly break it seems better to manually add to this\n * list.\n *\n */\nconst supportedExtensions = [\n  'ANGLE_instanced_arrays',\n  'EXT_blend_minmax',\n  'EXT_color_buffer_float',\n  'EXT_color_buffer_half_float',\n  'EXT_disjoint_timer_query',\n  'EXT_disjoint_timer_query_webgl2',\n  'EXT_frag_depth',\n  'EXT_sRGB',\n  'EXT_shader_texture_lod',\n  'EXT_texture_filter_anisotropic',\n  'OES_element_index_uint',\n  'OES_standard_derivatives',\n  'OES_texture_float',\n  'OES_texture_float_linear',\n  'OES_texture_half_float',\n  'OES_texture_half_float_linear',\n  'OES_vertex_array_object',\n  'WEBGL_color_buffer_float',\n  'WEBGL_compressed_texture_atc',\n  'WEBGL_compressed_texture_etc1',\n  'WEBGL_compressed_texture_pvrtc',\n  'WEBGL_compressed_texture_s3tc',\n  'WEBGL_compressed_texture_s3tc_srgb',\n  'WEBGL_depth_texture',\n  'WEBGL_draw_buffers',\n];\n\n/**\n * Attempts to enable all of the following extensions\n * and add their functions and constants to the\n * `WebGLRenderingContext` using their normal non-extension like names.\n *\n *      ANGLE_instanced_arrays\n *      EXT_blend_minmax\n *      EXT_color_buffer_float\n *      EXT_color_buffer_half_float\n *      EXT_disjoint_timer_query\n *      EXT_disjoint_timer_query_webgl2\n *      EXT_frag_depth\n *      EXT_sRGB\n *      EXT_shader_texture_lod\n *      EXT_texture_filter_anisotropic\n *      OES_element_index_uint\n *      OES_standard_derivatives\n *      OES_texture_float\n *      OES_texture_float_linear\n *      OES_texture_half_float\n *      OES_texture_half_float_linear\n *      OES_vertex_array_object\n *      WEBGL_color_buffer_float\n *      WEBGL_compressed_texture_atc\n *      WEBGL_compressed_texture_etc1\n *      WEBGL_compressed_texture_pvrtc\n *      WEBGL_compressed_texture_s3tc\n *      WEBGL_compressed_texture_s3tc_srgb\n *      WEBGL_depth_texture\n *      WEBGL_draw_buffers\n *\n * For example if `ANGLE_instanced_arrays` exists then the functions\n * `drawArraysInstanced`, `drawElementsInstanced`, `vertexAttribDivisor`\n * and the constant `VERTEX_ATTRIB_ARRAY_DIVISOR` are added to the\n * `WebGLRenderingContext`.\n *\n * Note that if you want to know if the extension exists you should\n * probably call `gl.getExtension` for each extension. Alternatively\n * you can check for the existence of the functions or constants that\n * are expected to be added. For example\n *\n *    if (gl.drawBuffers) {\n *      // Either WEBGL_draw_buffers was enabled OR you're running in WebGL2\n *      ....\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @memberOf module:twgl\n */\nfunction addExtensionsToContext(gl) {\n  for (let ii = 0; ii < supportedExtensions.length; ++ii) {\n    addExtensionToContext(gl, supportedExtensions[ii]);\n  }\n}\n\n/**\n * Creates a webgl context.\n * @param {HTMLCanvasElement} canvas The canvas tag to get\n *     context from. If one is not passed in one will be\n *     created.\n * @return {WebGLRenderingContext} The created context.\n * @private\n */\nfunction create3DContext(canvas, opt_attribs) {\n  const names = [\"webgl\", \"experimental-webgl\"];\n  let context = null;\n  for (let ii = 0; ii < names.length; ++ii) {\n    context = canvas.getContext(names[ii], opt_attribs);\n    if (context) {\n      if (defaults.addExtensionsToContext) {\n        addExtensionsToContext(context);\n      }\n      break;\n    }\n  }\n  return context;\n}\n\n/**\n * Gets a WebGL1 context.\n *\n * Note: Will attempt to enable Vertex Array Objects\n * and add WebGL2 entry points. (unless you first set defaults with\n * `twgl.setDefaults({enableVertexArrayObjects: false})`;\n *\n * @param {HTMLCanvasElement} canvas a canvas element.\n * @param {WebGLContextAttributes} [opt_attribs] optional webgl context creation attributes\n * @return {WebGLRenderingContext} The created context.\n * @memberOf module:twgl\n */\nfunction getWebGLContext(canvas, opt_attribs) {\n  const gl = create3DContext(canvas, opt_attribs);\n  return gl;\n}\n\n/**\n * Creates a webgl context.\n *\n * Will return a WebGL2 context if possible.\n *\n * You can check if it's WebGL2 with\n *\n *     twgl.isWebGL2(gl);\n *\n * @param {HTMLCanvasElement} canvas The canvas tag to get\n *     context from. If one is not passed in one will be\n *     created.\n * @return {WebGLRenderingContext} The created context.\n */\nfunction createContext(canvas, opt_attribs) {\n  const names = [\"webgl2\", \"webgl\", \"experimental-webgl\"];\n  let context = null;\n  for (let ii = 0; ii < names.length; ++ii) {\n    context = canvas.getContext(names[ii], opt_attribs);\n    if (context) {\n      if (defaults.addExtensionsToContext) {\n        addExtensionsToContext(context);\n      }\n      break;\n    }\n  }\n  return context;\n}\n\n/**\n * Gets a WebGL context.  Will create a WebGL2 context if possible.\n *\n * You can check if it's WebGL2 with\n *\n *    function isWebGL2(gl) {\n *      return gl.getParameter(gl.VERSION).indexOf(\"WebGL 2.0 \") == 0;\n *    }\n *\n * Note: For a WebGL1 context will attempt to enable Vertex Array Objects\n * and add WebGL2 entry points. (unless you first set defaults with\n * `twgl.setDefaults({enableVertexArrayObjects: false})`;\n *\n * @param {HTMLCanvasElement} canvas a canvas element.\n * @param {WebGLContextAttributes} [opt_attribs] optional webgl context creation attributes\n * @return {WebGLRenderingContext} The created context.\n * @memberOf module:twgl\n */\nfunction getContext(canvas, opt_attribs) {\n  const gl = createContext(canvas, opt_attribs);\n  return gl;\n}\n\n/**\n * Resize a canvas to match the size it's displayed.\n * @param {HTMLCanvasElement} canvas The canvas to resize.\n * @param {number} [multiplier] So you can pass in `window.devicePixelRatio` or other scale value if you want to.\n * @return {boolean} true if the canvas was resized.\n * @memberOf module:twgl\n */\nfunction resizeCanvasToDisplaySize(canvas, multiplier) {\n  multiplier = multiplier || 1;\n  multiplier = Math.max(0, multiplier);\n  const width  = canvas.clientWidth  * multiplier | 0;\n  const height = canvas.clientHeight * multiplier | 0;\n  if (canvas.width !== width || canvas.height !== height) {\n    canvas.width = width;\n    canvas.height = height;\n    return true;\n  }\n  return false;\n}\n\nexport {\n  addExtensionsToContext,\n  getContext,\n  getWebGLContext,\n  resizeCanvasToDisplaySize,\n  setDefaults,\n\n  attributes,\n  draw,\n  framebuffers,\n  programs,\n  textures,\n  typedarrays,\n  utils,\n  vertexArrays,\n};\n\n// function notPrivate(name) {\n//   return name[name.length - 1] !== '_';\n// }\n//\n// function copyPublicProperties(src, dst) {\n//   Object.keys(src).filter(notPrivate).forEach(function(key) {\n//     dst[key] = src[key];\n//   });\n//   return dst;\n// }\n\nexport * from './attributes.js';\nexport * from './draw.js';\nexport * from './framebuffers.js';\nexport * from './programs.js';\nexport * from './textures.js';\nexport * from './typedarrays.js';\nexport * from './utils.js';\nexport * from './vertex-arrays.js';\n\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n/**\n * Low level shader typed array related functions\n *\n * You should generally not need to use these functions. They are provided\n * for those cases where you're doing something out of the ordinary\n * and you need lower level access.\n *\n * For backward compatibility they are available at both `twgl.typedArray` and `twgl`\n * itself\n *\n * See {@link module:twgl} for core functions\n *\n * @module twgl/typedArray\n */\n\n// make sure we don't see a global gl\nconst gl = undefined;  /* eslint-disable-line */\n\n/* DataType */\nconst BYTE                           = 0x1400;\nconst UNSIGNED_BYTE                  = 0x1401;\nconst SHORT                          = 0x1402;\nconst UNSIGNED_SHORT                 = 0x1403;\nconst INT                            = 0x1404;\nconst UNSIGNED_INT                   = 0x1405;\nconst FLOAT                          = 0x1406;\nconst UNSIGNED_SHORT_4_4_4_4       = 0x8033;\nconst UNSIGNED_SHORT_5_5_5_1       = 0x8034;\nconst UNSIGNED_SHORT_5_6_5         = 0x8363;\nconst HALF_FLOAT                   = 0x140B;\nconst UNSIGNED_INT_2_10_10_10_REV  = 0x8368;\nconst UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B;\nconst UNSIGNED_INT_5_9_9_9_REV     = 0x8C3E;\nconst FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD;\nconst UNSIGNED_INT_24_8            = 0x84FA;\n\nconst glTypeToTypedArray = {};\n{\n  const tt = glTypeToTypedArray;\n  tt[BYTE]                           = Int8Array;\n  tt[UNSIGNED_BYTE]                  = Uint8Array;\n  tt[SHORT]                          = Int16Array;\n  tt[UNSIGNED_SHORT]                 = Uint16Array;\n  tt[INT]                            = Int32Array;\n  tt[UNSIGNED_INT]                   = Uint32Array;\n  tt[FLOAT]                          = Float32Array;\n  tt[UNSIGNED_SHORT_4_4_4_4]         = Uint16Array;\n  tt[UNSIGNED_SHORT_5_5_5_1]         = Uint16Array;\n  tt[UNSIGNED_SHORT_5_6_5]           = Uint16Array;\n  tt[HALF_FLOAT]                     = Uint16Array;\n  tt[UNSIGNED_INT_2_10_10_10_REV]    = Uint32Array;\n  tt[UNSIGNED_INT_10F_11F_11F_REV]   = Uint32Array;\n  tt[UNSIGNED_INT_5_9_9_9_REV]       = Uint32Array;\n  tt[FLOAT_32_UNSIGNED_INT_24_8_REV] = Uint32Array;\n  tt[UNSIGNED_INT_24_8]              = Uint32Array;\n}\n\n/**\n * Get the GL type for a typedArray\n * @param {ArrayBufferView} typedArray a typedArray\n * @return {number} the GL type for array. For example pass in an `Int8Array` and `gl.BYTE` will\n *   be returned. Pass in a `Uint32Array` and `gl.UNSIGNED_INT` will be returned\n * @memberOf module:twgl/typedArray\n */\nfunction getGLTypeForTypedArray(typedArray) {\n  if (typedArray instanceof Int8Array)         { return BYTE; }           // eslint-disable-line\n  if (typedArray instanceof Uint8Array)        { return UNSIGNED_BYTE; }  // eslint-disable-line\n  if (typedArray instanceof Uint8ClampedArray) { return UNSIGNED_BYTE; }  // eslint-disable-line\n  if (typedArray instanceof Int16Array)        { return SHORT; }          // eslint-disable-line\n  if (typedArray instanceof Uint16Array)       { return UNSIGNED_SHORT; } // eslint-disable-line\n  if (typedArray instanceof Int32Array)        { return INT; }            // eslint-disable-line\n  if (typedArray instanceof Uint32Array)       { return UNSIGNED_INT; }   // eslint-disable-line\n  if (typedArray instanceof Float32Array)      { return FLOAT; }          // eslint-disable-line\n  throw new Error('unsupported typed array type');\n}\n\n/**\n * Get the GL type for a typedArray type\n * @param {ArrayBufferView} typedArrayType a typedArray constructor\n * @return {number} the GL type for type. For example pass in `Int8Array` and `gl.BYTE` will\n *   be returned. Pass in `Uint32Array` and `gl.UNSIGNED_INT` will be returned\n * @memberOf module:twgl/typedArray\n */\nfunction getGLTypeForTypedArrayType(typedArrayType) {\n  if (typedArrayType === Int8Array)         { return BYTE; }           // eslint-disable-line\n  if (typedArrayType === Uint8Array)        { return UNSIGNED_BYTE; }  // eslint-disable-line\n  if (typedArrayType === Uint8ClampedArray) { return UNSIGNED_BYTE; }  // eslint-disable-line\n  if (typedArrayType === Int16Array)        { return SHORT; }          // eslint-disable-line\n  if (typedArrayType === Uint16Array)       { return UNSIGNED_SHORT; } // eslint-disable-line\n  if (typedArrayType === Int32Array)        { return INT; }            // eslint-disable-line\n  if (typedArrayType === Uint32Array)       { return UNSIGNED_INT; }   // eslint-disable-line\n  if (typedArrayType === Float32Array)      { return FLOAT; }          // eslint-disable-line\n  throw new Error('unsupported typed array type');\n}\n\n/**\n * Get the typed array constructor for a given GL type\n * @param {number} type the GL type. (eg: `gl.UNSIGNED_INT`)\n * @return {function} the constructor for a the corresponding typed array. (eg. `Uint32Array`).\n * @memberOf module:twgl/typedArray\n */\nfunction getTypedArrayTypeForGLType(type) {\n  const CTOR = glTypeToTypedArray[type];\n  if (!CTOR) {\n    throw new Error('unknown gl type');\n  }\n  return CTOR;\n}\n\nconst isArrayBuffer = typeof SharedArrayBuffer !== 'undefined'\n  ? function isArrayBufferOrSharedArrayBuffer(a) {\n    return a && a.buffer && (a.buffer instanceof ArrayBuffer || a.buffer instanceof SharedArrayBuffer);\n  }\n  : function isArrayBuffer(a) {\n    return a && a.buffer && a.buffer instanceof ArrayBuffer;\n  };\n\nexport {\n  getGLTypeForTypedArray,\n  getGLTypeForTypedArrayType,\n  getTypedArrayTypeForGLType,\n  isArrayBuffer,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n/**\n * Gets the gl version as a number\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @return {number} version of gl\n * @private\n */\n//function getVersionAsNumber(gl) {\n//  return parseFloat(gl.getParameter(gl.VERSION).substr(6));\n//}\n\n/**\n * Check if context is WebGL 2.0\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @return {bool} true if it's WebGL 2.0\n * @memberOf module:twgl\n */\nfunction isWebGL2(gl) {\n  // This is the correct check but it's slow\n  //  return gl.getParameter(gl.VERSION).indexOf(\"WebGL 2.0\") === 0;\n  // This might also be the correct check but I'm assuming it's slow-ish\n  // return gl instanceof WebGL2RenderingContext;\n  return !!gl.texStorage2D;\n}\n\n/**\n * Check if context is WebGL 1.0\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @return {bool} true if it's WebGL 1.0\n * @memberOf module:twgl\n */\nfunction isWebGL1(gl) {\n  // This is the correct check but it's slow\n  // const version = getVersionAsNumber(gl);\n  // return version <= 1.0 && version > 0.0;  // because as of 2016/5 Edge returns 0.96\n  // This might also be the correct check but I'm assuming it's slow-ish\n  // return gl instanceof WebGLRenderingContext;\n  return !gl.texStorage2D;\n}\n\n/**\n * Gets a string for WebGL enum\n *\n * Note: Several enums are the same. Without more\n * context (which function) it's impossible to always\n * give the correct enum. As it is, for matching values\n * it gives all enums. Checking the WebGL2RenderingContext\n * that means\n *\n *      0     = ZERO | POINT | NONE | NO_ERROR\n *      1     = ONE | LINES | SYNC_FLUSH_COMMANDS_BIT\n *      32777 = BLEND_EQUATION_RGB | BLEND_EQUATION_RGB\n *      36662 = COPY_READ_BUFFER | COPY_READ_BUFFER_BINDING\n *      36663 = COPY_WRITE_BUFFER | COPY_WRITE_BUFFER_BINDING\n *      36006 = FRAMEBUFFER_BINDING | DRAW_FRAMEBUFFER_BINDING\n *\n * It's also not useful for bits really unless you pass in individual bits.\n * In other words\n *\n *     const bits = gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT;\n *     twgl.glEnumToString(gl, bits);  // not going to work\n *\n * Note that some enums only exist on extensions. If you\n * want them to show up you need to pass the extension at least\n * once. For example\n *\n *     const ext = gl.getExtension('WEBGL_compressed_texture_s3tc');\n *     if (ext) {\n *        twgl.glEnumToString(ext, 0);  // just prime the function\n *\n *        ..later..\n *\n *        const internalFormat = ext.COMPRESSED_RGB_S3TC_DXT1_EXT;\n *        console.log(twgl.glEnumToString(gl, internalFormat));\n *\n * Notice I didn't have to pass the extension the second time. This means\n * you can have place that generically gets an enum for texture formats for example.\n * and as long as you primed the function with the extensions\n *\n * If you're using `twgl.addExtensionsToContext` to enable your extensions\n * then twgl will automatically get the extension's enums.\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext or any extension object\n * @param {number} value the value of the enum you want to look up.\n * @return {string} enum string or hex value\n * @memberOf module:twgl\n * @function glEnumToString\n */\nconst glEnumToString = (function() {\n  const haveEnumsForType = {};\n  const enums = {};\n\n  function addEnums(gl) {\n    const type = gl.constructor.name;\n    if (!haveEnumsForType[type]) {\n      for (const key in gl) {\n        if (typeof gl[key] === 'number') {\n          const existing = enums[gl[key]];\n          enums[gl[key]] = existing ? `${existing} | ${key}` : key;\n        }\n      }\n      haveEnumsForType[type] = true;\n    }\n  }\n\n  return function glEnumToString(gl, value) {\n    addEnums(gl);\n    return enums[value] || (typeof value === 'number' ? `0x${value.toString(16)}` : value);\n  };\n}());\n\nexport {\n  glEnumToString,\n  isWebGL1,\n  isWebGL2,\n};\n\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\n/**\n *\n * Vec3 math math functions.\n *\n * Almost all functions take an optional `dst` argument. If it is not passed in the\n * functions will create a new Vec3. In other words you can do this\n *\n *     var v = v3.cross(v1, v2);  // Creates a new Vec3 with the cross product of v1 x v2.\n *\n * or\n *\n *     var v = v3.create();\n *     v3.cross(v1, v2, v);  // Puts the cross product of v1 x v2 in v\n *\n * The first style is often easier but depending on where it's used it generates garbage where\n * as there is almost never allocation with the second style.\n *\n * It is always save to pass any vector as the destination. So for example\n *\n *     v3.cross(v1, v2, v1);  // Puts the cross product of v1 x v2 in v1\n *\n * @module twgl/v3\n */\n\nlet VecType = Float32Array;\n\n/**\n * A JavaScript array with 3 values or a Float32Array with 3 values.\n * When created by the library will create the default type which is `Float32Array`\n * but can be set by calling {@link module:twgl/v3.setDefaultType}.\n * @typedef {(number[]|Float32Array)} Vec3\n * @memberOf module:twgl/v3\n */\n\n/**\n * Sets the type this library creates for a Vec3\n * @param {constructor} ctor the constructor for the type. Either `Float32Array` or `Array`\n * @return {constructor} previous constructor for Vec3\n * @memberOf module:twgl/v3\n */\nfunction setDefaultType(ctor) {\n  const oldType = VecType;\n  VecType = ctor;\n  return oldType;\n}\n\n/**\n * Creates a vec3; may be called with x, y, z to set initial values.\n * @param {number} [x] Initial x value.\n * @param {number} [y] Initial y value.\n * @param {number} [z] Initial z value.\n * @return {module:twgl/v3.Vec3} the created vector\n * @memberOf module:twgl/v3\n */\nfunction create(x, y, z) {\n  const dst = new VecType(3);\n  if (x) {\n    dst[0] = x;\n  }\n  if (y) {\n    dst[1] = y;\n  }\n  if (z) {\n    dst[2] = z;\n  }\n  return dst;\n}\n\n/**\n * Adds two vectors; assumes a and b have the same dimension.\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} A vector tha tis the sum of a and b.\n * @memberOf module:twgl/v3\n */\nfunction add(a, b, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = a[0] + b[0];\n  dst[1] = a[1] + b[1];\n  dst[2] = a[2] + b[2];\n\n  return dst;\n}\n\n/**\n * Subtracts two vectors.\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} A vector that is the difference of a and b.\n * @memberOf module:twgl/v3\n */\nfunction subtract(a, b, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = a[0] - b[0];\n  dst[1] = a[1] - b[1];\n  dst[2] = a[2] - b[2];\n\n  return dst;\n}\n\n/**\n * Performs linear interpolation on two vectors.\n * Given vectors a and b and interpolation coefficient t, returns\n * a + t * (b - a).\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {number} t Interpolation coefficient.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The linear interpolated result.\n * @memberOf module:twgl/v3\n */\nfunction lerp(a, b, t, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = a[0] + t * (b[0] - a[0]);\n  dst[1] = a[1] + t * (b[1] - a[1]);\n  dst[2] = a[2] + t * (b[2] - a[2]);\n\n  return dst;\n}\n\n/**\n * Performs linear interpolation on two vectors.\n * Given vectors a and b and interpolation coefficient vector t, returns\n * a + t * (b - a).\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} t Interpolation coefficients vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} the linear interpolated result.\n * @memberOf module:twgl/v3\n */\nfunction lerpV(a, b, t, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = a[0] + t[0] * (b[0] - a[0]);\n  dst[1] = a[1] + t[1] * (b[1] - a[1]);\n  dst[2] = a[2] + t[2] * (b[2] - a[2]);\n\n  return dst;\n}\n\n/**\n * Return max values of two vectors.\n * Given vectors a and b returns\n * [max(a[0], b[0]), max(a[1], b[1]), max(a[2], b[2])].\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The max components vector.\n * @memberOf module:twgl/v3\n */\nfunction max(a, b, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = Math.max(a[0], b[0]);\n  dst[1] = Math.max(a[1], b[1]);\n  dst[2] = Math.max(a[2], b[2]);\n\n  return dst;\n}\n\n/**\n * Return min values of two vectors.\n * Given vectors a and b returns\n * [min(a[0], b[0]), min(a[1], b[1]), min(a[2], b[2])].\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The min components vector.\n * @memberOf module:twgl/v3\n */\nfunction min(a, b, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = Math.min(a[0], b[0]);\n  dst[1] = Math.min(a[1], b[1]);\n  dst[2] = Math.min(a[2], b[2]);\n\n  return dst;\n}\n\n/**\n * Multiplies a vector by a scalar.\n * @param {module:twgl/v3.Vec3} v The vector.\n * @param {number} k The scalar.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The scaled vector.\n * @memberOf module:twgl/v3\n */\nfunction mulScalar(v, k, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = v[0] * k;\n  dst[1] = v[1] * k;\n  dst[2] = v[2] * k;\n\n  return dst;\n}\n\n/**\n * Divides a vector by a scalar.\n * @param {module:twgl/v3.Vec3} v The vector.\n * @param {number} k The scalar.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The scaled vector.\n * @memberOf module:twgl/v3\n */\nfunction divScalar(v, k, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = v[0] / k;\n  dst[1] = v[1] / k;\n  dst[2] = v[2] / k;\n\n  return dst;\n}\n\n/**\n * Computes the cross product of two vectors; assumes both vectors have\n * three entries.\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The vector of a cross b.\n * @memberOf module:twgl/v3\n */\nfunction cross(a, b, dst) {\n  dst = dst || new VecType(3);\n\n  const t1 = a[2] * b[0] - a[0] * b[2];\n  const t2 = a[0] * b[1] - a[1] * b[0];\n  dst[0] = a[1] * b[2] - a[2] * b[1];\n  dst[1] = t1;\n  dst[2] = t2;\n\n  return dst;\n}\n\n/**\n * Computes the dot product of two vectors; assumes both vectors have\n * three entries.\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @return {number} dot product\n * @memberOf module:twgl/v3\n */\nfunction dot(a, b) {\n  return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]);\n}\n\n/**\n * Computes the length of vector\n * @param {module:twgl/v3.Vec3} v vector.\n * @return {number} length of vector.\n * @memberOf module:twgl/v3\n */\nfunction length(v) {\n  return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);\n}\n\n/**\n * Computes the square of the length of vector\n * @param {module:twgl/v3.Vec3} v vector.\n * @return {number} square of the length of vector.\n * @memberOf module:twgl/v3\n */\nfunction lengthSq(v) {\n  return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];\n}\n\n/**\n * Computes the distance between 2 points\n * @param {module:twgl/v3.Vec3} a vector.\n * @param {module:twgl/v3.Vec3} b vector.\n * @return {number} distance between a and b\n * @memberOf module:twgl/v3\n */\nfunction distance(a, b) {\n  const dx = a[0] - b[0];\n  const dy = a[1] - b[1];\n  const dz = a[2] - b[2];\n  return Math.sqrt(dx * dx + dy * dy + dz * dz);\n}\n\n/**\n * Computes the square of the distance between 2 points\n * @param {module:twgl/v3.Vec3} a vector.\n * @param {module:twgl/v3.Vec3} b vector.\n * @return {number} square of the distance between a and b\n * @memberOf module:twgl/v3\n */\nfunction distanceSq(a, b) {\n  const dx = a[0] - b[0];\n  const dy = a[1] - b[1];\n  const dz = a[2] - b[2];\n  return dx * dx + dy * dy + dz * dz;\n}\n\n/**\n * Divides a vector by its Euclidean length and returns the quotient.\n * @param {module:twgl/v3.Vec3} a The vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The normalized vector.\n * @memberOf module:twgl/v3\n */\nfunction normalize(a, dst) {\n  dst = dst || new VecType(3);\n\n  const lenSq = a[0] * a[0] + a[1] * a[1] + a[2] * a[2];\n  const len = Math.sqrt(lenSq);\n  if (len > 0.00001) {\n    dst[0] = a[0] / len;\n    dst[1] = a[1] / len;\n    dst[2] = a[2] / len;\n  } else {\n    dst[0] = 0;\n    dst[1] = 0;\n    dst[2] = 0;\n  }\n\n  return dst;\n}\n\n/**\n * Negates a vector.\n * @param {module:twgl/v3.Vec3} v The vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} -v.\n * @memberOf module:twgl/v3\n */\nfunction negate(v, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = -v[0];\n  dst[1] = -v[1];\n  dst[2] = -v[2];\n\n  return dst;\n}\n\n/**\n * Copies a vector.\n * @param {module:twgl/v3.Vec3} v The vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} A copy of v.\n * @memberOf module:twgl/v3\n */\nfunction copy(v, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = v[0];\n  dst[1] = v[1];\n  dst[2] = v[2];\n\n  return dst;\n}\n\n/**\n * Multiplies a vector by another vector (component-wise); assumes a and\n * b have the same length.\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The vector of products of entries of a and\n *     b.\n * @memberOf module:twgl/v3\n */\nfunction multiply(a, b, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = a[0] * b[0];\n  dst[1] = a[1] * b[1];\n  dst[2] = a[2] * b[2];\n\n  return dst;\n}\n\n/**\n * Divides a vector by another vector (component-wise); assumes a and\n * b have the same length.\n * @param {module:twgl/v3.Vec3} a Operand vector.\n * @param {module:twgl/v3.Vec3} b Operand vector.\n * @param {module:twgl/v3.Vec3} [dst] vector to hold result. If not new one is created.\n * @return {module:twgl/v3.Vec3} The vector of quotients of entries of a and\n *     b.\n * @memberOf module:twgl/v3\n */\nfunction divide(a, b, dst) {\n  dst = dst || new VecType(3);\n\n  dst[0] = a[0] / b[0];\n  dst[1] = a[1] / b[1];\n  dst[2] = a[2] / b[2];\n\n  return dst;\n}\n\nexport {\n  add,\n  copy,\n  create,\n  cross,\n  distance,\n  distanceSq,\n  divide,\n  divScalar,\n  dot,\n  lerp,\n  lerpV,\n  length,\n  lengthSq,\n  max,\n  min,\n  mulScalar,\n  multiply,\n  negate,\n  normalize,\n  setDefaultType,\n  subtract,\n};\n\n","/*\n * Copyright 2019 Gregg Tavares\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is 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\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n * DEALINGS IN THE SOFTWARE.\n */\n\nimport * as programs from './programs.js';\n\n/**\n * vertex array object related functions\n *\n * You should generally not need to use these functions. They are provided\n * for those cases where you're doing something out of the ordinary\n * and you need lower level access.\n *\n * For backward compatibility they are available at both `twgl.attributes` and `twgl`\n * itself\n *\n * See {@link module:twgl} for core functions\n *\n * @module twgl/vertexArrays\n */\n\nconst ELEMENT_ARRAY_BUFFER           = 0x8893;\n\n/**\n * @typedef {Object} VertexArrayInfo\n * @property {number} numElements The number of elements to pass to `gl.drawArrays` or `gl.drawElements`.\n * @property {number} [elementType] The type of indices `UNSIGNED_BYTE`, `UNSIGNED_SHORT` etc..\n * @property {WebGLVertexArrayObject} [vertexArrayObject] a vertex array object\n * @memberOf module:twgl\n */\n\n/**\n * Creates a VertexArrayInfo from a BufferInfo and one or more ProgramInfos\n *\n * This can be passed to {@link module:twgl.setBuffersAndAttributes} and to\n * {@link module:twgl:drawBufferInfo}.\n *\n * > **IMPORTANT:** Vertex Array Objects are **not** a direct analog for a BufferInfo. Vertex Array Objects\n *   assign buffers to specific attributes at creation time. That means they can only be used with programs\n *   who's attributes use the same attribute locations for the same purposes.\n *\n * > Bind your attribute locations by passing an array of attribute names to {@link module:twgl.createProgramInfo}\n *   or use WebGL 2's GLSL ES 3's `layout(location = <num>)` to make sure locations match.\n *\n * also\n *\n * > **IMPORTANT:** After calling twgl.setBuffersAndAttribute with a BufferInfo that uses a Vertex Array Object\n *   that Vertex Array Object will be bound. That means **ANY MANIPULATION OF ELEMENT_ARRAY_BUFFER or ATTRIBUTES**\n *   will affect the Vertex Array Object state.\n *\n * > Call `gl.bindVertexArray(null)` to get back manipulating the global attributes and ELEMENT_ARRAY_BUFFER.\n *\n * @param {WebGLRenderingContext} gl A WebGLRenderingContext\n * @param {module:twgl.ProgramInfo|module:twgl.ProgramInfo[]} programInfo a programInfo or array of programInfos\n * @param {module:twgl.BufferInfo} bufferInfo BufferInfo as returned from createBufferInfoFromArrays etc...\n *\n *    You need to make sure every attribute that will be used is bound. So for example assume shader 1\n *    uses attributes A, B, C and shader 2 uses attributes A, B, D. If you only pass in the programInfo\n *    for shader 1 then only attributes A, B, and C will have their attributes set because TWGL doesn't\n *    now attribute D's location.\n *\n *    So, you can pass in both shader 1 and shader 2's programInfo\n *\n * @return {module:twgl.VertexArrayInfo} The created VertexArrayInfo\n *\n * @memberOf module:twgl/vertexArrays\n */\nfunction createVertexArrayInfo(gl, programInfos, bufferInfo) {\n  const vao = gl.createVertexArray();\n  gl.bindVertexArray(vao);\n  if (!programInfos.length) {\n    programInfos = [programInfos];\n  }\n  programInfos.forEach(function(programInfo) {\n    programs.setBuffersAndAttributes(gl, programInfo, bufferInfo);\n  });\n  gl.bindVertexArray(null);\n  return {\n    numElements: bufferInfo.numElements,\n    elementType: bufferInfo.elementType,\n    vertexArrayObject: vao,\n  };\n}\n\n/**\n * Creates a vertex array object and then sets the attributes on it\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext to use.\n * @param {Object.<string, function>} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.<string, module:twgl.AttribInfo>} attribs AttribInfos mapped by attribute name.\n * @param {WebGLBuffer} [indices] an optional ELEMENT_ARRAY_BUFFER of indices\n * @memberOf module:twgl/vertexArrays\n */\nfunction createVAOAndSetAttributes(gl, setters, attribs, indices) {\n  const vao = gl.createVertexArray();\n  gl.bindVertexArray(vao);\n  programs.setAttributes(setters, attribs);\n  if (indices) {\n    gl.bindBuffer(ELEMENT_ARRAY_BUFFER, indices);\n  }\n  // We unbind this because otherwise any change to ELEMENT_ARRAY_BUFFER\n  // like when creating buffers for other stuff will mess up this VAO's binding\n  gl.bindVertexArray(null);\n  return vao;\n}\n\n/**\n * Creates a vertex array object and then sets the attributes\n * on it\n *\n * @param {WebGLRenderingContext} gl The WebGLRenderingContext\n *        to use.\n * @param {Object.<string, function>| module:twgl.ProgramInfo} programInfo as returned from createProgramInfo or Attribute setters as returned from createAttributeSetters\n * @param {module:twgl.BufferInfo} bufferInfo BufferInfo as returned from createBufferInfoFromArrays etc...\n * @param {WebGLBuffer} [indices] an optional ELEMENT_ARRAY_BUFFER of indices\n * @memberOf module:twgl/vertexArrays\n */\nfunction createVAOFromBufferInfo(gl, programInfo, bufferInfo) {\n  return createVAOAndSetAttributes(gl, programInfo.attribSetters || programInfo, bufferInfo.attribs, bufferInfo.indices);\n}\n\nexport {\n  createVertexArrayInfo,\n  createVAOAndSetAttributes,\n  createVAOFromBufferInfo,\n};\n\n"],"sourceRoot":""}