diff --git a/dist/4.x/twgl-full.d.ts b/dist/4.x/twgl-full.d.ts index cc594f7..03996c8 100644 --- a/dist/4.x/twgl-full.d.ts +++ b/dist/4.x/twgl-full.d.ts @@ -63,7 +63,7 @@ export type DrawObject = { count?: number; instanceCount?: number; }; -export type AttachmentOptions = { +export type AttachmentOptions = TextureOptions & { attach?: number; format?: number; type?: number; diff --git a/dist/4.x/twgl-full.js b/dist/4.x/twgl-full.js index 06c7068..e3715bc 100644 --- a/dist/4.x/twgl-full.js +++ b/dist/4.x/twgl-full.js @@ -1,5 +1,5 @@ /*! - * @license twgl.js 4.13.0 Copyright (c) 2015, Gregg Tavares All Rights Reserved. + * @license twgl.js 4.13.1 Copyright (c) 2015, Gregg Tavares All Rights Reserved. * Available via the MIT license. * see: http://github.com/greggman/twgl.js for details */ @@ -1192,6 +1192,7 @@ var LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line * If provided will attach this Object. This allows you to share * attachments across framebuffers. * @memberOf module:twgl + * @mixes module:twgl.TextureOptions */ var defaultAttachments = [{ @@ -5460,6 +5461,7 @@ function loadShader(gl, shaderSource, shaderType, opt_errorCallback) { function getProgramOptions(opt_attribs, opt_locations, opt_errorCallback) { var transformFeedbackVaryings; + var transformFeedbackMode; if (typeof opt_locations === 'function') { opt_errorCallback = opt_locations; @@ -5480,11 +5482,13 @@ function getProgramOptions(opt_attribs, opt_locations, opt_errorCallback) { opt_errorCallback = opt.errorCallback; opt_attribs = opt.attribLocations; transformFeedbackVaryings = opt.transformFeedbackVaryings; + transformFeedbackMode = opt.transformFeedbackMode; } var options = { errorCallback: opt_errorCallback || error, - transformFeedbackVaryings: transformFeedbackVaryings + transformFeedbackVaryings: transformFeedbackVaryings, + transformFeedbackMode: transformFeedbackMode }; if (opt_attribs) { diff --git a/dist/4.x/twgl-full.js.map b/dist/4.x/twgl-full.js.map index 033c83b..db257af 100644 --- a/dist/4.x/twgl-full.js.map +++ b/dist/4.x/twgl-full.js.map @@ -1 +1 @@ -{"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":["gl","undefined","defaults","attribPrefix","setAttributePrefix","prefix","setDefaults","newDefaults","helper","copyExistingProperties","setBufferFromTypedArray","type","buffer","array","drawType","bindBuffer","bufferData","STATIC_DRAW","createBufferFromTypedArray","typedArray","isBuffer","ARRAY_BUFFER","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","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","positionKeys","getNumElementsFromNonIndexedArrays","key","ii","numElements","getNumElementsFromAttributes","getBufferParameter","BUFFER_SIZE","bytesPerValue","totalElements","createBufferInfoFromArrays","srcBufferInfo","newAttribs","bufferInfo","assign","indices","newIndices","ELEMENT_ARRAY_BUFFER","elementType","createBufferFromArray","createBuffersFromArrays","buffers","drawBufferInfo","count","instanceCount","TRIANGLES","drawElementsInstanced","drawElements","drawArraysInstanced","drawArrays","drawObjectList","objectsToDraw","lastUsedProgramInfo","lastUsedBufferInfo","object","active","programInfo","vertexArrayInfo","bindBuffers","useProgram","program","vertexArrayObject","bindVertexArray","programs","setBuffersAndAttributes","setUniforms","uniforms","DEPTH_COMPONENT","RGBA","RGBA4","RGB5_A1","RGB565","DEPTH_COMPONENT16","STENCIL_INDEX","STENCIL_INDEX8","DEPTH_STENCIL","COLOR_ATTACHMENT0","DEPTH_ATTACHMENT","STENCIL_ATTACHMENT","DEPTH_STENCIL_ATTACHMENT","REPEAT","CLAMP_TO_EDGE","MIRRORED_REPEAT","NEAREST","LINEAR","NEAREST_MIPMAP_NEAREST","LINEAR_MIPMAP_NEAREST","NEAREST_MIPMAP_LINEAR","LINEAR_MIPMAP_LINEAR","defaultAttachments","format","min","wrap","attachmentsByFormat","getAttachmentPointForFormat","renderbufferFormats","isRenderbufferFormat","createFramebufferInfo","attachments","width","height","target","FRAMEBUFFER","fb","createFramebuffer","bindFramebuffer","drawingBufferWidth","drawingBufferHeight","colorAttachmentCount","framebufferInfo","framebuffer","attachmentOptions","attachment","attachmentPoint","createRenderbuffer","bindRenderbuffer","RENDERBUFFER","renderbufferStorage","textureOptions","auto","minMag","mag","wrapS","wrapT","textures","createTexture","isRenderbuffer","framebufferRenderbuffer","isTexture","layer","framebufferTextureLayer","level","framebufferTexture2D","texTarget","TEXTURE_2D","push","resizeFramebufferInfo","ndx","resizeTexture","bindFramebufferInfo","viewport","copyNamedProperties","names","src","dst","hasOwnProperty","error","console","warn","t","WebGLRenderbuffer","isShader","WebGLShader","WebGLTexture","isSampler","WebGLSampler","MatType","tempV3a","tempV3b","tempV3c","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","lookAt","eye","up","xAxis","yAxis","zAxis","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","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","TEXTURE0","bindTexture","bindSampler","samplerArraySetter","units","Int32Array","index","setter","arraySetter","Uint32Array","floatAttribSetter","disableVertexAttribArray","vertexAttrib4fv","vertexAttrib3fv","vertexAttrib2fv","vertexAttrib1fv","enableVertexAttribArray","vertexAttribPointer","vertexAttribDivisor","intAttribSetter","vertexAttrib4iv","vertexAttribIPointer","uintAttribSetter","vertexAttrib4uiv","matAttribSetter","typeInfo","defaultSize","rowOffset","attrTypeMap","addLineNumbers","lineOffset","split","map","line","join","spaceRE","loadShader","shaderSource","shaderType","opt_errorCallback","errFn","shader","createShader","replace","compileShader","compiled","getShaderParameter","COMPILE_STATUS","lastError","getShaderInfoLog","deleteShader","getProgramOptions","opt_attribs","opt_locations","transformFeedbackVaryings","errorCallback","opt","attribLocations","defaultShaderType","getShaderTypeFromScriptType","scriptType","FRAGMENT_SHADER","VERTEX_SHADER","deleteShaders","shaders","createProgram","progOptions","realShaders","newShaders","elem","text","attachShader","bindAttribLocation","varyings","transformFeedbackMode","SEPARATE_ATTRIBS","linkProgram","linked","getProgramParameter","LINK_STATUS","getProgramInfoLog","deleteProgram","createShaderFromScript","scriptId","opt_shaderType","shaderScript","createProgramFromScripts","shaderScriptIds","createProgramFromSources","shaderSources","isBuiltIn","startsWith","createUniformSetters","textureUnit","createUniformSetter","uniformInfo","getUniformLocation","substr","toString","uniformSetters","numUniforms","ACTIVE_UNIFORMS","getActiveUniform","createTransformFeedbackInfo","numVaryings","TRANSFORM_FEEDBACK_VARYINGS","varying","getTransformFeedbackVarying","bindTransformFeedbackInfo","transformFeedbackInfo","buf","bindBufferRange","TRANSFORM_FEEDBACK_BUFFER","bindBufferBase","createTransformFeedback","tf","bindTransformFeedback","TRANSFORM_FEEDBACK","createUniformBlockSpecFromProgram","uniformData","uniformIndices","pair","pname","getActiveUniforms","blockSpecs","numUniformBlocks","ACTIVE_UNIFORM_BLOCKS","getActiveUniformBlockName","blockSpec","usedByVertexShader","getActiveUniformBlockParameter","UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER","usedByFragmentShader","UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER","UNIFORM_BLOCK_DATA_SIZE","UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES","used","arraySuffixRE","createUniformBlockInfoFromProgram","uniformBlockSpec","blockName","ArrayBuffer","uniformBufferIndex","UNIFORM_BUFFER","uniformBlockBinding","uniformNdx","asFloat","createUniformBlockInfo","bindUniformBlock","uniformBlockInfo","bufferBindIndex","byteLength","setUniformBlock","DYNAMIC_DRAW","setBlockUniforms","values","set","setters","actualSetters","numArgs","aNdx","createAttributeSetters","attribSetters","numAttribs","ACTIVE_ATTRIBUTES","getActiveAttrib","getAttribLocation","setAttributes","createProgramInfoFromProgram","createProgramInfo","good","source","script","textureColor","crossOrigin","s_ctx","getShared2DContext","createElement","getContext","ALPHA","RGB","LUMINANCE","LUMINANCE_ALPHA","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","DEPTH_COMPONENT24","DEPTH_COMPONENT32F","DEPTH32F_STENCIL8","DEPTH24_STENCIL8","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","internalFormat","textureFormat","colorRenderable","textureFilterable","bytesPerElement","bytesPerElementMap","getBytesPerElementForInternalFormat","getFormatAndTypeForInternalFormat","isPowerOf2","canGenerateMipmap","canFilter","getNumComponentsForFormat","getTextureTypeForArrayType","defaultType","guessDimensions","setDefaultTextureColor","lastPackState","savePackState","colorspaceConversion","getParameter","UNPACK_COLORSPACE_CONVERSION_WEBGL","pixelStorei","premultiplyAlpha","UNPACK_PREMULTIPLY_ALPHA_WEBGL","flipY","UNPACK_FLIP_Y_WEBGL","restorePackState","saveSkipState","unpackAlignment","UNPACK_ALIGNMENT","unpackRowLength","UNPACK_ROW_LENGTH","unpackImageHeight","UNPACK_IMAGE_HEIGHT","unpackSkipPixels","UNPACK_SKIP_PIXELS","unpackSkipRows","UNPACK_SKIP_ROWS","unpackSkipImages","UNPACK_SKIP_IMAGES","restoreSkipState","setTextureSamplerParameters","parameteriFn","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","TEXTURE_WRAP_R","wrapR","minLod","TEXTURE_MIN_LOD","maxLod","TEXTURE_MAX_LOD","baseLevel","TEXTURE_BASE_LEVEL","maxLevel","TEXTURE_MAX_LEVEL","setTextureParameters","tex","texParameteri","setSamplerParameters","samplerParameteri","createSampler","createSamplers","samplerOptions","samplers","make1Pixel","setTextureFilteringForSize","generateMipmap","filtering","shouldAutomaticallySetTextureFilteringForSize","getCubeFaceOrder","cubeFaceOrder","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","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","msg","addEventListener","ImageBitmap","err","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","glEnumToString","dimensions","cbrt","elementsPerElement","faceSize","subarray","setEmptyTexture","isAsyncSrc","createTextures","numDownloading","images","callCallbackIfReady","onLoadFn","addExtensionsToContext","setAttributeDefaults_","setTextureDefaults_","prefixRE","addExtensionToContext","extensionName","ext","getExtension","enums","fnSuffix","exec","enumSuffix","isFunc","suffix","endsWith","substring","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\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 || gl.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 || gl.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.} 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.} 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(gl.ARRAY_BUFFER, buffer);\n gl.bufferData(gl.ARRAY_BUFFER, numBytes, array.drawType || gl.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(gl.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(gl.ARRAY_BUFFER, attribInfo.buffer);\n gl.bufferSubData(gl.ARRAY_BUFFER, offset, array);\n } else {\n setBufferFromTypedArray(gl, gl.ARRAY_BUFFER, attribInfo.buffer, array, attribInfo.drawType);\n }\n}\n\nfunction getBytesPerValueForGLType(gl, type) {\n if (type === gl.BYTE) return 1; // eslint-disable-line\n if (type === gl.UNSIGNED_BYTE) return 1; // eslint-disable-line\n if (type === gl.SHORT) return 2; // eslint-disable-line\n if (type === gl.UNSIGNED_SHORT) return 2; // eslint-disable-line\n if (type === gl.INT) return 4; // eslint-disable-line\n if (type === gl.UNSIGNED_INT) return 4; // eslint-disable-line\n if (type === gl.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(gl.ARRAY_BUFFER, attrib.buffer);\n const numBytes = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);\n gl.bindBuffer(gl.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.} [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, gl.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\" ? gl.ELEMENT_ARRAY_BUFFER : gl.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} 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\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 ? gl.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 ? gl.UNSIGNED_SHORT : bufferInfo.elementType, offset, instanceCount);\n } else {\n gl.drawElements(type, numElements, elementType === undefined ? gl.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} 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 ? gl.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.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 UNSIGNED_BYTE = 0x1401;\n\n/* PixelFormat */\nconst DEPTH_COMPONENT = 0x1902;\nconst RGBA = 0x1908;\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 REPEAT = 0x2901; // eslint-disable-line\nconst CLAMP_TO_EDGE = 0x812F;\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\nconst LINEAR = 0x2601;\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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} [attach] 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 {WebGLObject} [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 */\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;\n\nfunction getAttachmentPointForFormat(format) {\n return attachmentsByFormat[format];\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 {WebGLObject[]} attachments The created attachments in the same order as passed in to {@link module:twgl.createFramebufferInfo}.\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 = gl.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 = getAttachmentPointForFormat(format);\n if (!attachmentPoint) {\n attachmentPoint = COLOR_ATTACHMENT0 + colorAttachmentCount++;\n }\n if (!attachment) {\n if (isRenderbufferFormat(format)) {\n attachment = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.LINEAR;\n textureOptions.mag = textureOptions.mag || textureOptions.minMag || gl.LINEAR;\n textureOptions.wrapS = textureOptions.wrapS || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n textureOptions.wrapT = textureOptions.wrapT || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n }\n attachment = textures.createTexture(gl, textureOptions);\n }\n }\n if (helper.isRenderbuffer(gl, attachment)) {\n gl.framebufferRenderbuffer(target, attachmentPoint, gl.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.texTarget || gl.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(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.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.} src the source\n * @param {Object.} 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\nlet tempV3a;\nlet tempV3b;\nlet tempV3c;\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\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 const xAxis = tempV3a || v3.create();\n const yAxis = tempV3b || v3.create();\n const zAxis = tempV3c || 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.} vertices The indexed vertices to deindex\n * @return {Object.} 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.} vertices The deindexed vertices who's normals to flatten\n * @return {Object.} 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.} arrays The vertices to reorient\n * @param {module:twgl/m4.Mat4} matrix matrix to reorient by.\n * @return {Object.} 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.} 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.} 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.} 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.} 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.} 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.} 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.}\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.} 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.} 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.} 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.} 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, 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 normals.push(\n (yy < 0 || yy > verticalSubdivisions) ? 0 : (sin * cosSlant),\n (yy < 0) ? -1 : (yy > verticalSubdivisions ? 1 : sinSlant),\n (yy < 0 || yy > verticalSubdivisions) ? 0 : (cos * cosSlant));\n texcoords.push((ii / radialSubdivisions), 1 - v);\n }\n }\n\n for (let yy = 0; yy < verticalSubdivisions + extra; ++yy) { // eslint-disable-line\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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} vertices Vertices as returned from one of the createXXXVertices functions.\n * @param {module:twgl/primitives.RandomVerticesOptions} [options] options.\n * @return {Object.} 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 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(gl.TEXTURE0 + unit);\n gl.bindTexture(bindPoint, texture);\n gl.bindSampler(unit, sampler);\n } : function(texture) {\n gl.uniform1i(location, unit);\n gl.activeTexture(gl.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(gl.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(gl.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, };\ntypeMap[FLOAT_VEC3] = { Type: Float32Array, size: 12, setter: floatVec3Setter, };\ntypeMap[FLOAT_VEC4] = { Type: Float32Array, size: 16, setter: floatVec4Setter, };\ntypeMap[INT] = { Type: Int32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[INT_VEC2] = { Type: Int32Array, size: 8, setter: intVec2Setter, };\ntypeMap[INT_VEC3] = { Type: Int32Array, size: 12, setter: intVec3Setter, };\ntypeMap[INT_VEC4] = { Type: Int32Array, size: 16, setter: intVec4Setter, };\ntypeMap[UNSIGNED_INT] = { Type: Uint32Array, size: 4, setter: uintSetter, arraySetter: uintArraySetter, };\ntypeMap[UNSIGNED_INT_VEC2] = { Type: Uint32Array, size: 8, setter: uintVec2Setter, };\ntypeMap[UNSIGNED_INT_VEC3] = { Type: Uint32Array, size: 12, setter: uintVec3Setter, };\ntypeMap[UNSIGNED_INT_VEC4] = { Type: Uint32Array, size: 16, setter: uintVec4Setter, };\ntypeMap[BOOL] = { Type: Uint32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[BOOL_VEC2] = { Type: Uint32Array, size: 8, setter: intVec2Setter, };\ntypeMap[BOOL_VEC3] = { Type: Uint32Array, size: 12, setter: intVec3Setter, };\ntypeMap[BOOL_VEC4] = { Type: Uint32Array, size: 16, setter: intVec4Setter, };\ntypeMap[FLOAT_MAT2] = { Type: Float32Array, size: 16, setter: floatMat2Setter, };\ntypeMap[FLOAT_MAT3] = { Type: Float32Array, size: 36, setter: floatMat3Setter, };\ntypeMap[FLOAT_MAT4] = { Type: Float32Array, size: 64, setter: floatMat4Setter, };\ntypeMap[FLOAT_MAT2x3] = { Type: Float32Array, size: 24, setter: floatMat23Setter, };\ntypeMap[FLOAT_MAT2x4] = { Type: Float32Array, size: 32, setter: floatMat24Setter, };\ntypeMap[FLOAT_MAT3x2] = { Type: Float32Array, size: 24, setter: floatMat32Setter, };\ntypeMap[FLOAT_MAT3x4] = { Type: Float32Array, size: 48, setter: floatMat34Setter, };\ntypeMap[FLOAT_MAT4x2] = { Type: Float32Array, size: 32, setter: floatMat42Setter, };\ntypeMap[FLOAT_MAT4x3] = { Type: Float32Array, size: 48, setter: floatMat43Setter, };\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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n const numComponents = b.size || b.numComponents || defaultSize;\n const size = numComponents / count;\n const type = b.type || gl.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\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\nfunction addLineNumbers(src, lineOffset) {\n lineOffset = lineOffset || 0;\n ++lineOffset;\n\n return src.split(\"\\n\").map(function(line, ndx) {\n return (ndx + lineOffset) + \": \" + line;\n }).join(\"\\n\");\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 // \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, gl.COMPILE_STATUS);\n if (!compiled) {\n // Something went wrong during compilation; get the error\n const lastError = gl.getShaderInfoLog(shader);\n errFn(addLineNumbers(shaderSource, lineOffset) + \"\\n*** Error compiling shader: \" + 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.} [attribLocations] a attribute name to location map\n * @property {(module:twgl.BufferInfo|Object.|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 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 }\n\n const options = {\n errorCallback: opt_errorCallback || error,\n transformFeedbackVaryings: transformFeedbackVaryings,\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 gl.FRAGMENT_SHADER;\n } else if (scriptType.indexOf(\"vert\") >= 0) {\n return gl.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 || gl.SEPARATE_ATTRIBS);\n }\n gl.linkProgram(program);\n\n // Check the link status\n const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n if (!linked) {\n // something went wrong with the link\n const lastError = gl.getProgramInfoLog(program);\n progOptions.errorCallback(\"Error 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\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.} 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) {\n const location = gl.getUniformLocation(program, uniformInfo.name);\n const isArray = (uniformInfo.size > 1 && uniformInfo.name.substr(-3) === \"[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 numUniforms = gl.getProgramParameter(program, gl.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.substr(-3) === \"[0]\") {\n name = name.substr(0, name.length - 3);\n }\n const setter = createUniformSetter(program, uniformInfo);\n uniformSetters[name] = setter;\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}\n * @memberOf module:twgl\n */\nfunction createTransformFeedbackInfo(gl, program) {\n const info = {};\n const numVaryings = gl.getProgramParameter(program, gl.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)} transformFeedbackInfo A ProgramInfo or TransformFeedbackInfo.\n * @param {(module:twgl.BufferInfo|Object)} [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(gl.TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer, buf.offset, buf.size);\n } else {\n gl.bindBufferBase(gl.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)} [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(gl.TRANSFORM_FEEDBACK, tf);\n gl.useProgram(programInfo.program);\n bindTransformFeedbackInfo(gl, programInfo, bufferInfo);\n gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);\n return tf;\n}\n\n/**\n * @typedef {Object} UniformData\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. 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, gl.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 if (isBuiltIn(uniformInfo)) {\n break;\n }\n // REMOVE [0]?\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, gl.ACTIVE_UNIFORM_BLOCKS);\n for (let ii = 0; ii < numUniformBlocks; ++ii) {\n const name = gl.getActiveUniformBlockName(program, ii);\n const blockSpec = {\n index: ii,\n usedByVertexShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n usedByFragmentShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n size: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_DATA_SIZE),\n uniformIndices: gl.getActiveUniformBlockParameter(program, ii, gl.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\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.} 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 * @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(gl.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 blockSpec.uniformIndices.forEach(function(uniformNdx) {\n const data = uniformData[uniformNdx];\n const typeInfo = typeMap[data.type];\n const Type = typeInfo.Type;\n const length = data.size * typeInfo.size;\n let name = data.name;\n if (name.substr(0, prefix.length) === prefix) {\n name = name.substr(prefix.length);\n }\n uniforms[name] = new Type(array, data.offset, length / Type.BYTES_PER_ELEMENT);\n });\n return {\n name: blockName,\n array: array,\n asFloat: new Float32Array(array), // for debugging\n buffer: buffer,\n uniforms: uniforms,\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(gl.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(gl.UNIFORM_BUFFER, uniformBlockInfo.array, gl.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.} 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 * Any name that doesn't match will be ignored\n * @memberOf module:twgl/programs\n */\nfunction setBlockUniforms(uniformBlockInfo, values) {\n const uniforms = uniformBlockInfo.uniforms;\n for (const name in values) {\n const array = uniforms[name];\n if (array) {\n const value = values[name];\n if (value.length) {\n array.set(value);\n } else {\n array[0] = value;\n }\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.)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n * `createUniformSetters`.\n * @param {Object.} 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 * @memberOf module:twgl/programs\n */\nfunction setUniforms(setters, values) { // eslint-disable-line\n const actualSetters = setters.uniformSetters || setters;\n const numArgs = arguments.length;\n for (let aNdx = 1; aNdx < numArgs; ++aNdx) {\n const values = arguments[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 * 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.} 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, gl.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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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.)} 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(gl.ELEMENT_ARRAY_BUFFER, buffers.indices);\n }\n }\n}\n\n/**\n * @typedef {Object} ProgramInfo\n * @property {WebGLProgram} program A shader program\n * @property {Object} uniformSetters object of setters as returned from createUniformSetters,\n * @property {Object} attribSetters object of setters as returned from createAttribSetters,\n * @property {module:twgl.UniformBlockSpec} [uniformBlockSpace] a uniform block spec for making UniformBlockInfos with createUniformBlockInfo etc..\n * @property {Object} [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: program,\n uniformSetters: uniformSetters,\n attribSetters: 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 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?\nlet s_ctx;\nfunction 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// 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 */\nconst REPEAT = 0x2901; // eslint-disable-line\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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.} 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\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 /*, type */) {\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 /*, type */) {\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 || gl.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 === gl.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// NOTE: While querying GL is considered slow it's not remotely as slow\n// as uploading a texture. On top of that you're unlikely to call this in\n// a perf critical loop. Even if upload a texture every frame that's unlikely\n// to be more than 1 or 2 textures a frame. In other words, the benefits of\n// making the API easy to use outweigh any supposed perf benefits\n//\n// Also note I get that having one global of these is bad practice.\n// As long as it's used correctly it means no garbage which probably\n// doesn't matter when dealing with textures but old habits die hard.\nconst lastPackState = {};\n\n/**\n * Saves 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 savePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n lastPackState.colorspaceConversion = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, options.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n lastPackState.premultiplyAlpha = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, options.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n lastPackState.flipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, options.flipY);\n }\n}\n\n/**\n * Restores any packing state that was 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 restorePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, lastPackState.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, lastPackState.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, lastPackState.flipY);\n }\n}\n\n/**\n * Saves state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction saveSkipState(gl) {\n lastPackState.unpackAlignment = gl.getParameter(gl.UNPACK_ALIGNMENT);\n if (utils.isWebGL2(gl)) {\n lastPackState.unpackRowLength = gl.getParameter(gl.UNPACK_ROW_LENGTH);\n lastPackState.unpackImageHeight = gl.getParameter(gl.UNPACK_IMAGE_HEIGHT);\n lastPackState.unpackSkipPixels = gl.getParameter(gl.UNPACK_SKIP_PIXELS);\n lastPackState.unpackSkipRows = gl.getParameter(gl.UNPACK_SKIP_ROWS);\n lastPackState.unpackSkipImages = gl.getParameter(gl.UNPACK_SKIP_IMAGES);\n }\n}\n\n/**\n * Restores state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction restoreSkipState(gl) {\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, lastPackState.unpackAlignment);\n if (utils.isWebGL2(gl)) {\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, lastPackState.unpackRowLength);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, lastPackState.unpackImageHeight);\n gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, lastPackState.unpackSkipPixels);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, lastPackState.unpackSkipRows);\n gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, lastPackState.unpackSkipImages);\n }\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, gl.TEXTURE_MIN_FILTER, options.minMag);\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.minMag);\n }\n if (options.min) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_FILTER, options.min);\n }\n if (options.mag) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.mag);\n }\n if (options.wrap) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrap);\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrap);\n if (target === gl.TEXTURE_3D || helper.isSampler(gl, target)) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrap);\n }\n }\n if (options.wrapR) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrapR);\n }\n if (options.wrapS) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrapS);\n }\n if (options.wrapT) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrapT);\n }\n if (options.minLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_LOD, options.minLod);\n }\n if (options.maxLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAX_LOD, options.maxLod);\n }\n if (options.baseLevel) {\n parameteriFn.call(gl, target, gl.TEXTURE_BASE_LEVEL, options.baseLevel);\n }\n if (options.maxLevel) {\n parameteriFn.call(gl, target, gl.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 || gl.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.} options A object of TextureOptions one per sampler.\n * @return {Object.} 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 * @param {number} [type] The type parameter for texImage2D etc..\n * @memberOf module:twgl/textures\n */\nfunction setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type) {\n options = options || defaults.textureOptions;\n internalFormat = internalFormat || gl.RGBA;\n type = type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n width = width || options.width;\n height = height || options.height;\n gl.bindTexture(target, tex);\n if (canGenerateMipmap(gl, width, height, internalFormat, type)) {\n gl.generateMipmap(target);\n } else {\n const filtering = canFilter(internalFormat, type) ? gl.LINEAR : gl.NEAREST;\n gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 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}\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 || gl.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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n gl.bindTexture(target, tex);\n if (target === gl.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 savePackState(gl, options);\n gl.bindTexture(target, tex);\n gl.texImage2D(f.face, level, internalFormat, format, type, imageBitmap);\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\n }\n });\n });\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, element.width);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0);\n gl.pixelStorei(gl.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(gl.UNPACK_SKIP_PIXELS, srcX);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, srcY);\n gl.texSubImage3D(target, level, 0, 0, d, smallest, smallest, 1, format, type, element);\n }\n restoreSkipState(gl);\n } else {\n gl.texImage2D(target, level, internalFormat, format, type, element);\n }\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.TEXTURE_2D_ARRAY) {\n gl.texImage3D(target, 0, gl.RGBA, 1, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n } else {\n gl.texImage2D(target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.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.} textures the created textures by name. Same as returned by {@link module:twgl.createTextures}.\n * @param {Object.} 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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n if (target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D_ARRAY;\n if (target !== gl.TEXTURE_3D && target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.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 || gl.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 === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, options.unpackAlignment || 1);\n savePackState(gl, options);\n if (target === gl.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 === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n restoreSkipState(gl);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n if (target === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, options.width, options.height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n}\n\n/**\n * Creates a texture based on the options passed in.\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 || gl.TEXTURE_2D;\n let width = options.width || 1;\n let height = options.height || 1;\n const internalFormat = options.internalFormat || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n let type = options.type || formatType.type;\n gl.bindTexture(target, tex);\n if (target === gl.TEXTURE_CUBE_MAP) {\n // this should have been the default for cubemaps :(\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 type = dimensions.type;\n } else if (Array.isArray(src) && (typeof (src[0]) === 'string' || isTexImageSource(src[0]))) {\n if (target === gl.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 } else {\n throw \"unsupported src type\";\n }\n } else {\n setEmptyTexture(gl, tex, options);\n }\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, width, height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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.} 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.} 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] || (\"0x\" + value.toString(16));\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\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 = )` 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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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(gl.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.| 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":""} \ No newline at end of file +{"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":["gl","undefined","defaults","attribPrefix","setAttributePrefix","prefix","setDefaults","newDefaults","helper","copyExistingProperties","setBufferFromTypedArray","type","buffer","array","drawType","bindBuffer","bufferData","STATIC_DRAW","createBufferFromTypedArray","typedArray","isBuffer","ARRAY_BUFFER","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","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","positionKeys","getNumElementsFromNonIndexedArrays","key","ii","numElements","getNumElementsFromAttributes","getBufferParameter","BUFFER_SIZE","bytesPerValue","totalElements","createBufferInfoFromArrays","srcBufferInfo","newAttribs","bufferInfo","assign","indices","newIndices","ELEMENT_ARRAY_BUFFER","elementType","createBufferFromArray","createBuffersFromArrays","buffers","drawBufferInfo","count","instanceCount","TRIANGLES","drawElementsInstanced","drawElements","drawArraysInstanced","drawArrays","drawObjectList","objectsToDraw","lastUsedProgramInfo","lastUsedBufferInfo","object","active","programInfo","vertexArrayInfo","bindBuffers","useProgram","program","vertexArrayObject","bindVertexArray","programs","setBuffersAndAttributes","setUniforms","uniforms","DEPTH_COMPONENT","RGBA","RGBA4","RGB5_A1","RGB565","DEPTH_COMPONENT16","STENCIL_INDEX","STENCIL_INDEX8","DEPTH_STENCIL","COLOR_ATTACHMENT0","DEPTH_ATTACHMENT","STENCIL_ATTACHMENT","DEPTH_STENCIL_ATTACHMENT","REPEAT","CLAMP_TO_EDGE","MIRRORED_REPEAT","NEAREST","LINEAR","NEAREST_MIPMAP_NEAREST","LINEAR_MIPMAP_NEAREST","NEAREST_MIPMAP_LINEAR","LINEAR_MIPMAP_LINEAR","defaultAttachments","format","min","wrap","attachmentsByFormat","getAttachmentPointForFormat","renderbufferFormats","isRenderbufferFormat","createFramebufferInfo","attachments","width","height","target","FRAMEBUFFER","fb","createFramebuffer","bindFramebuffer","drawingBufferWidth","drawingBufferHeight","colorAttachmentCount","framebufferInfo","framebuffer","attachmentOptions","attachment","attachmentPoint","createRenderbuffer","bindRenderbuffer","RENDERBUFFER","renderbufferStorage","textureOptions","auto","minMag","mag","wrapS","wrapT","textures","createTexture","isRenderbuffer","framebufferRenderbuffer","isTexture","layer","framebufferTextureLayer","level","framebufferTexture2D","texTarget","TEXTURE_2D","push","resizeFramebufferInfo","ndx","resizeTexture","bindFramebufferInfo","viewport","copyNamedProperties","names","src","dst","hasOwnProperty","error","console","warn","t","WebGLRenderbuffer","isShader","WebGLShader","WebGLTexture","isSampler","WebGLSampler","MatType","tempV3a","tempV3b","tempV3c","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","lookAt","eye","up","xAxis","yAxis","zAxis","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","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","TEXTURE0","bindTexture","bindSampler","samplerArraySetter","units","Int32Array","index","setter","arraySetter","Uint32Array","floatAttribSetter","disableVertexAttribArray","vertexAttrib4fv","vertexAttrib3fv","vertexAttrib2fv","vertexAttrib1fv","enableVertexAttribArray","vertexAttribPointer","vertexAttribDivisor","intAttribSetter","vertexAttrib4iv","vertexAttribIPointer","uintAttribSetter","vertexAttrib4uiv","matAttribSetter","typeInfo","defaultSize","rowOffset","attrTypeMap","addLineNumbers","lineOffset","split","map","line","join","spaceRE","loadShader","shaderSource","shaderType","opt_errorCallback","errFn","shader","createShader","replace","compileShader","compiled","getShaderParameter","COMPILE_STATUS","lastError","getShaderInfoLog","deleteShader","getProgramOptions","opt_attribs","opt_locations","transformFeedbackVaryings","transformFeedbackMode","errorCallback","opt","attribLocations","defaultShaderType","getShaderTypeFromScriptType","scriptType","FRAGMENT_SHADER","VERTEX_SHADER","deleteShaders","shaders","createProgram","progOptions","realShaders","newShaders","elem","text","attachShader","bindAttribLocation","varyings","SEPARATE_ATTRIBS","linkProgram","linked","getProgramParameter","LINK_STATUS","getProgramInfoLog","deleteProgram","createShaderFromScript","scriptId","opt_shaderType","shaderScript","createProgramFromScripts","shaderScriptIds","createProgramFromSources","shaderSources","isBuiltIn","startsWith","createUniformSetters","textureUnit","createUniformSetter","uniformInfo","getUniformLocation","substr","toString","uniformSetters","numUniforms","ACTIVE_UNIFORMS","getActiveUniform","createTransformFeedbackInfo","numVaryings","TRANSFORM_FEEDBACK_VARYINGS","varying","getTransformFeedbackVarying","bindTransformFeedbackInfo","transformFeedbackInfo","buf","bindBufferRange","TRANSFORM_FEEDBACK_BUFFER","bindBufferBase","createTransformFeedback","tf","bindTransformFeedback","TRANSFORM_FEEDBACK","createUniformBlockSpecFromProgram","uniformData","uniformIndices","pair","pname","getActiveUniforms","blockSpecs","numUniformBlocks","ACTIVE_UNIFORM_BLOCKS","getActiveUniformBlockName","blockSpec","usedByVertexShader","getActiveUniformBlockParameter","UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER","usedByFragmentShader","UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER","UNIFORM_BLOCK_DATA_SIZE","UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES","used","arraySuffixRE","createUniformBlockInfoFromProgram","uniformBlockSpec","blockName","ArrayBuffer","uniformBufferIndex","UNIFORM_BUFFER","uniformBlockBinding","uniformNdx","asFloat","createUniformBlockInfo","bindUniformBlock","uniformBlockInfo","bufferBindIndex","byteLength","setUniformBlock","DYNAMIC_DRAW","setBlockUniforms","values","set","setters","actualSetters","numArgs","aNdx","createAttributeSetters","attribSetters","numAttribs","ACTIVE_ATTRIBUTES","getActiveAttrib","getAttribLocation","setAttributes","createProgramInfoFromProgram","createProgramInfo","good","source","script","textureColor","crossOrigin","s_ctx","getShared2DContext","createElement","getContext","ALPHA","RGB","LUMINANCE","LUMINANCE_ALPHA","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","DEPTH_COMPONENT24","DEPTH_COMPONENT32F","DEPTH32F_STENCIL8","DEPTH24_STENCIL8","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","internalFormat","textureFormat","colorRenderable","textureFilterable","bytesPerElement","bytesPerElementMap","getBytesPerElementForInternalFormat","getFormatAndTypeForInternalFormat","isPowerOf2","canGenerateMipmap","canFilter","getNumComponentsForFormat","getTextureTypeForArrayType","defaultType","guessDimensions","setDefaultTextureColor","lastPackState","savePackState","colorspaceConversion","getParameter","UNPACK_COLORSPACE_CONVERSION_WEBGL","pixelStorei","premultiplyAlpha","UNPACK_PREMULTIPLY_ALPHA_WEBGL","flipY","UNPACK_FLIP_Y_WEBGL","restorePackState","saveSkipState","unpackAlignment","UNPACK_ALIGNMENT","unpackRowLength","UNPACK_ROW_LENGTH","unpackImageHeight","UNPACK_IMAGE_HEIGHT","unpackSkipPixels","UNPACK_SKIP_PIXELS","unpackSkipRows","UNPACK_SKIP_ROWS","unpackSkipImages","UNPACK_SKIP_IMAGES","restoreSkipState","setTextureSamplerParameters","parameteriFn","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","TEXTURE_WRAP_R","wrapR","minLod","TEXTURE_MIN_LOD","maxLod","TEXTURE_MAX_LOD","baseLevel","TEXTURE_BASE_LEVEL","maxLevel","TEXTURE_MAX_LEVEL","setTextureParameters","tex","texParameteri","setSamplerParameters","samplerParameteri","createSampler","createSamplers","samplerOptions","samplers","make1Pixel","setTextureFilteringForSize","generateMipmap","filtering","shouldAutomaticallySetTextureFilteringForSize","getCubeFaceOrder","cubeFaceOrder","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","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","msg","addEventListener","ImageBitmap","err","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","glEnumToString","dimensions","cbrt","elementsPerElement","faceSize","subarray","setEmptyTexture","isAsyncSrc","createTextures","numDownloading","images","callCallbackIfReady","onLoadFn","addExtensionsToContext","setAttributeDefaults_","setTextureDefaults_","prefixRE","addExtensionToContext","extensionName","ext","getExtension","enums","fnSuffix","exec","enumSuffix","isFunc","suffix","endsWith","substring","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\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 || gl.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 || gl.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.} 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.} 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(gl.ARRAY_BUFFER, buffer);\n gl.bufferData(gl.ARRAY_BUFFER, numBytes, array.drawType || gl.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(gl.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(gl.ARRAY_BUFFER, attribInfo.buffer);\n gl.bufferSubData(gl.ARRAY_BUFFER, offset, array);\n } else {\n setBufferFromTypedArray(gl, gl.ARRAY_BUFFER, attribInfo.buffer, array, attribInfo.drawType);\n }\n}\n\nfunction getBytesPerValueForGLType(gl, type) {\n if (type === gl.BYTE) return 1; // eslint-disable-line\n if (type === gl.UNSIGNED_BYTE) return 1; // eslint-disable-line\n if (type === gl.SHORT) return 2; // eslint-disable-line\n if (type === gl.UNSIGNED_SHORT) return 2; // eslint-disable-line\n if (type === gl.INT) return 4; // eslint-disable-line\n if (type === gl.UNSIGNED_INT) return 4; // eslint-disable-line\n if (type === gl.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(gl.ARRAY_BUFFER, attrib.buffer);\n const numBytes = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);\n gl.bindBuffer(gl.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.} [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, gl.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\" ? gl.ELEMENT_ARRAY_BUFFER : gl.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} 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\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 ? gl.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 ? gl.UNSIGNED_SHORT : bufferInfo.elementType, offset, instanceCount);\n } else {\n gl.drawElements(type, numElements, elementType === undefined ? gl.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} 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 ? gl.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.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 UNSIGNED_BYTE = 0x1401;\n\n/* PixelFormat */\nconst DEPTH_COMPONENT = 0x1902;\nconst RGBA = 0x1908;\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 REPEAT = 0x2901; // eslint-disable-line\nconst CLAMP_TO_EDGE = 0x812F;\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\nconst LINEAR = 0x2601;\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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} [attach] 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 {WebGLObject} [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;\n\nfunction getAttachmentPointForFormat(format) {\n return attachmentsByFormat[format];\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 {WebGLObject[]} attachments The created attachments in the same order as passed in to {@link module:twgl.createFramebufferInfo}.\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 = gl.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 = getAttachmentPointForFormat(format);\n if (!attachmentPoint) {\n attachmentPoint = COLOR_ATTACHMENT0 + colorAttachmentCount++;\n }\n if (!attachment) {\n if (isRenderbufferFormat(format)) {\n attachment = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.LINEAR;\n textureOptions.mag = textureOptions.mag || textureOptions.minMag || gl.LINEAR;\n textureOptions.wrapS = textureOptions.wrapS || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n textureOptions.wrapT = textureOptions.wrapT || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n }\n attachment = textures.createTexture(gl, textureOptions);\n }\n }\n if (helper.isRenderbuffer(gl, attachment)) {\n gl.framebufferRenderbuffer(target, attachmentPoint, gl.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.texTarget || gl.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(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.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.} src the source\n * @param {Object.} 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\nlet tempV3a;\nlet tempV3b;\nlet tempV3c;\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\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 const xAxis = tempV3a || v3.create();\n const yAxis = tempV3b || v3.create();\n const zAxis = tempV3c || 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.} vertices The indexed vertices to deindex\n * @return {Object.} 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.} vertices The deindexed vertices who's normals to flatten\n * @return {Object.} 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.} arrays The vertices to reorient\n * @param {module:twgl/m4.Mat4} matrix matrix to reorient by.\n * @return {Object.} 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.} 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.} 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.} 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.} 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.} 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.} 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.}\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.} 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.} 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.} 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.} 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, 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 normals.push(\n (yy < 0 || yy > verticalSubdivisions) ? 0 : (sin * cosSlant),\n (yy < 0) ? -1 : (yy > verticalSubdivisions ? 1 : sinSlant),\n (yy < 0 || yy > verticalSubdivisions) ? 0 : (cos * cosSlant));\n texcoords.push((ii / radialSubdivisions), 1 - v);\n }\n }\n\n for (let yy = 0; yy < verticalSubdivisions + extra; ++yy) { // eslint-disable-line\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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} 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.} vertices Vertices as returned from one of the createXXXVertices functions.\n * @param {module:twgl/primitives.RandomVerticesOptions} [options] options.\n * @return {Object.} 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 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(gl.TEXTURE0 + unit);\n gl.bindTexture(bindPoint, texture);\n gl.bindSampler(unit, sampler);\n } : function(texture) {\n gl.uniform1i(location, unit);\n gl.activeTexture(gl.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(gl.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(gl.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, };\ntypeMap[FLOAT_VEC3] = { Type: Float32Array, size: 12, setter: floatVec3Setter, };\ntypeMap[FLOAT_VEC4] = { Type: Float32Array, size: 16, setter: floatVec4Setter, };\ntypeMap[INT] = { Type: Int32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[INT_VEC2] = { Type: Int32Array, size: 8, setter: intVec2Setter, };\ntypeMap[INT_VEC3] = { Type: Int32Array, size: 12, setter: intVec3Setter, };\ntypeMap[INT_VEC4] = { Type: Int32Array, size: 16, setter: intVec4Setter, };\ntypeMap[UNSIGNED_INT] = { Type: Uint32Array, size: 4, setter: uintSetter, arraySetter: uintArraySetter, };\ntypeMap[UNSIGNED_INT_VEC2] = { Type: Uint32Array, size: 8, setter: uintVec2Setter, };\ntypeMap[UNSIGNED_INT_VEC3] = { Type: Uint32Array, size: 12, setter: uintVec3Setter, };\ntypeMap[UNSIGNED_INT_VEC4] = { Type: Uint32Array, size: 16, setter: uintVec4Setter, };\ntypeMap[BOOL] = { Type: Uint32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[BOOL_VEC2] = { Type: Uint32Array, size: 8, setter: intVec2Setter, };\ntypeMap[BOOL_VEC3] = { Type: Uint32Array, size: 12, setter: intVec3Setter, };\ntypeMap[BOOL_VEC4] = { Type: Uint32Array, size: 16, setter: intVec4Setter, };\ntypeMap[FLOAT_MAT2] = { Type: Float32Array, size: 16, setter: floatMat2Setter, };\ntypeMap[FLOAT_MAT3] = { Type: Float32Array, size: 36, setter: floatMat3Setter, };\ntypeMap[FLOAT_MAT4] = { Type: Float32Array, size: 64, setter: floatMat4Setter, };\ntypeMap[FLOAT_MAT2x3] = { Type: Float32Array, size: 24, setter: floatMat23Setter, };\ntypeMap[FLOAT_MAT2x4] = { Type: Float32Array, size: 32, setter: floatMat24Setter, };\ntypeMap[FLOAT_MAT3x2] = { Type: Float32Array, size: 24, setter: floatMat32Setter, };\ntypeMap[FLOAT_MAT3x4] = { Type: Float32Array, size: 48, setter: floatMat34Setter, };\ntypeMap[FLOAT_MAT4x2] = { Type: Float32Array, size: 32, setter: floatMat42Setter, };\ntypeMap[FLOAT_MAT4x3] = { Type: Float32Array, size: 48, setter: floatMat43Setter, };\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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n const numComponents = b.size || b.numComponents || defaultSize;\n const size = numComponents / count;\n const type = b.type || gl.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\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\nfunction addLineNumbers(src, lineOffset) {\n lineOffset = lineOffset || 0;\n ++lineOffset;\n\n return src.split(\"\\n\").map(function(line, ndx) {\n return (ndx + lineOffset) + \": \" + line;\n }).join(\"\\n\");\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 // \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, gl.COMPILE_STATUS);\n if (!compiled) {\n // Something went wrong during compilation; get the error\n const lastError = gl.getShaderInfoLog(shader);\n errFn(addLineNumbers(shaderSource, lineOffset) + \"\\n*** Error compiling shader: \" + 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.} [attribLocations] a attribute name to location map\n * @property {(module:twgl.BufferInfo|Object.|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 gl.FRAGMENT_SHADER;\n } else if (scriptType.indexOf(\"vert\") >= 0) {\n return gl.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 || gl.SEPARATE_ATTRIBS);\n }\n gl.linkProgram(program);\n\n // Check the link status\n const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n if (!linked) {\n // something went wrong with the link\n const lastError = gl.getProgramInfoLog(program);\n progOptions.errorCallback(\"Error 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\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.} 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) {\n const location = gl.getUniformLocation(program, uniformInfo.name);\n const isArray = (uniformInfo.size > 1 && uniformInfo.name.substr(-3) === \"[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 numUniforms = gl.getProgramParameter(program, gl.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.substr(-3) === \"[0]\") {\n name = name.substr(0, name.length - 3);\n }\n const setter = createUniformSetter(program, uniformInfo);\n uniformSetters[name] = setter;\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}\n * @memberOf module:twgl\n */\nfunction createTransformFeedbackInfo(gl, program) {\n const info = {};\n const numVaryings = gl.getProgramParameter(program, gl.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)} transformFeedbackInfo A ProgramInfo or TransformFeedbackInfo.\n * @param {(module:twgl.BufferInfo|Object)} [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(gl.TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer, buf.offset, buf.size);\n } else {\n gl.bindBufferBase(gl.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)} [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(gl.TRANSFORM_FEEDBACK, tf);\n gl.useProgram(programInfo.program);\n bindTransformFeedbackInfo(gl, programInfo, bufferInfo);\n gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);\n return tf;\n}\n\n/**\n * @typedef {Object} UniformData\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. 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, gl.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 if (isBuiltIn(uniformInfo)) {\n break;\n }\n // REMOVE [0]?\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, gl.ACTIVE_UNIFORM_BLOCKS);\n for (let ii = 0; ii < numUniformBlocks; ++ii) {\n const name = gl.getActiveUniformBlockName(program, ii);\n const blockSpec = {\n index: ii,\n usedByVertexShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n usedByFragmentShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n size: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_DATA_SIZE),\n uniformIndices: gl.getActiveUniformBlockParameter(program, ii, gl.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\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.} 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 * @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(gl.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 blockSpec.uniformIndices.forEach(function(uniformNdx) {\n const data = uniformData[uniformNdx];\n const typeInfo = typeMap[data.type];\n const Type = typeInfo.Type;\n const length = data.size * typeInfo.size;\n let name = data.name;\n if (name.substr(0, prefix.length) === prefix) {\n name = name.substr(prefix.length);\n }\n uniforms[name] = new Type(array, data.offset, length / Type.BYTES_PER_ELEMENT);\n });\n return {\n name: blockName,\n array: array,\n asFloat: new Float32Array(array), // for debugging\n buffer: buffer,\n uniforms: uniforms,\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(gl.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(gl.UNIFORM_BUFFER, uniformBlockInfo.array, gl.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.} 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 * Any name that doesn't match will be ignored\n * @memberOf module:twgl/programs\n */\nfunction setBlockUniforms(uniformBlockInfo, values) {\n const uniforms = uniformBlockInfo.uniforms;\n for (const name in values) {\n const array = uniforms[name];\n if (array) {\n const value = values[name];\n if (value.length) {\n array.set(value);\n } else {\n array[0] = value;\n }\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.)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n * `createUniformSetters`.\n * @param {Object.} 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 * @memberOf module:twgl/programs\n */\nfunction setUniforms(setters, values) { // eslint-disable-line\n const actualSetters = setters.uniformSetters || setters;\n const numArgs = arguments.length;\n for (let aNdx = 1; aNdx < numArgs; ++aNdx) {\n const values = arguments[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 * 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.} 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, gl.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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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.)} 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(gl.ELEMENT_ARRAY_BUFFER, buffers.indices);\n }\n }\n}\n\n/**\n * @typedef {Object} ProgramInfo\n * @property {WebGLProgram} program A shader program\n * @property {Object} uniformSetters object of setters as returned from createUniformSetters,\n * @property {Object} attribSetters object of setters as returned from createAttribSetters,\n * @property {module:twgl.UniformBlockSpec} [uniformBlockSpace] a uniform block spec for making UniformBlockInfos with createUniformBlockInfo etc..\n * @property {Object} [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: program,\n uniformSetters: uniformSetters,\n attribSetters: 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 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?\nlet s_ctx;\nfunction 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// 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 */\nconst REPEAT = 0x2901; // eslint-disable-line\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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.} 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\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 /*, type */) {\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 /*, type */) {\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 || gl.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 === gl.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// NOTE: While querying GL is considered slow it's not remotely as slow\n// as uploading a texture. On top of that you're unlikely to call this in\n// a perf critical loop. Even if upload a texture every frame that's unlikely\n// to be more than 1 or 2 textures a frame. In other words, the benefits of\n// making the API easy to use outweigh any supposed perf benefits\n//\n// Also note I get that having one global of these is bad practice.\n// As long as it's used correctly it means no garbage which probably\n// doesn't matter when dealing with textures but old habits die hard.\nconst lastPackState = {};\n\n/**\n * Saves 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 savePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n lastPackState.colorspaceConversion = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, options.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n lastPackState.premultiplyAlpha = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, options.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n lastPackState.flipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, options.flipY);\n }\n}\n\n/**\n * Restores any packing state that was 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 restorePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, lastPackState.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, lastPackState.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, lastPackState.flipY);\n }\n}\n\n/**\n * Saves state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction saveSkipState(gl) {\n lastPackState.unpackAlignment = gl.getParameter(gl.UNPACK_ALIGNMENT);\n if (utils.isWebGL2(gl)) {\n lastPackState.unpackRowLength = gl.getParameter(gl.UNPACK_ROW_LENGTH);\n lastPackState.unpackImageHeight = gl.getParameter(gl.UNPACK_IMAGE_HEIGHT);\n lastPackState.unpackSkipPixels = gl.getParameter(gl.UNPACK_SKIP_PIXELS);\n lastPackState.unpackSkipRows = gl.getParameter(gl.UNPACK_SKIP_ROWS);\n lastPackState.unpackSkipImages = gl.getParameter(gl.UNPACK_SKIP_IMAGES);\n }\n}\n\n/**\n * Restores state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction restoreSkipState(gl) {\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, lastPackState.unpackAlignment);\n if (utils.isWebGL2(gl)) {\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, lastPackState.unpackRowLength);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, lastPackState.unpackImageHeight);\n gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, lastPackState.unpackSkipPixels);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, lastPackState.unpackSkipRows);\n gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, lastPackState.unpackSkipImages);\n }\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, gl.TEXTURE_MIN_FILTER, options.minMag);\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.minMag);\n }\n if (options.min) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_FILTER, options.min);\n }\n if (options.mag) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.mag);\n }\n if (options.wrap) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrap);\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrap);\n if (target === gl.TEXTURE_3D || helper.isSampler(gl, target)) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrap);\n }\n }\n if (options.wrapR) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrapR);\n }\n if (options.wrapS) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrapS);\n }\n if (options.wrapT) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrapT);\n }\n if (options.minLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_LOD, options.minLod);\n }\n if (options.maxLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAX_LOD, options.maxLod);\n }\n if (options.baseLevel) {\n parameteriFn.call(gl, target, gl.TEXTURE_BASE_LEVEL, options.baseLevel);\n }\n if (options.maxLevel) {\n parameteriFn.call(gl, target, gl.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 || gl.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.} options A object of TextureOptions one per sampler.\n * @return {Object.} 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 * @param {number} [type] The type parameter for texImage2D etc..\n * @memberOf module:twgl/textures\n */\nfunction setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type) {\n options = options || defaults.textureOptions;\n internalFormat = internalFormat || gl.RGBA;\n type = type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n width = width || options.width;\n height = height || options.height;\n gl.bindTexture(target, tex);\n if (canGenerateMipmap(gl, width, height, internalFormat, type)) {\n gl.generateMipmap(target);\n } else {\n const filtering = canFilter(internalFormat, type) ? gl.LINEAR : gl.NEAREST;\n gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 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}\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 || gl.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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n gl.bindTexture(target, tex);\n if (target === gl.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 savePackState(gl, options);\n gl.bindTexture(target, tex);\n gl.texImage2D(f.face, level, internalFormat, format, type, imageBitmap);\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\n }\n });\n });\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, element.width);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0);\n gl.pixelStorei(gl.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(gl.UNPACK_SKIP_PIXELS, srcX);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, srcY);\n gl.texSubImage3D(target, level, 0, 0, d, smallest, smallest, 1, format, type, element);\n }\n restoreSkipState(gl);\n } else {\n gl.texImage2D(target, level, internalFormat, format, type, element);\n }\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.TEXTURE_2D_ARRAY) {\n gl.texImage3D(target, 0, gl.RGBA, 1, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n } else {\n gl.texImage2D(target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.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.} textures the created textures by name. Same as returned by {@link module:twgl.createTextures}.\n * @param {Object.} 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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n if (target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D_ARRAY;\n if (target !== gl.TEXTURE_3D && target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.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 || gl.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 === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, options.unpackAlignment || 1);\n savePackState(gl, options);\n if (target === gl.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 === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n restoreSkipState(gl);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n if (target === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, options.width, options.height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n}\n\n/**\n * Creates a texture based on the options passed in.\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 || gl.TEXTURE_2D;\n let width = options.width || 1;\n let height = options.height || 1;\n const internalFormat = options.internalFormat || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n let type = options.type || formatType.type;\n gl.bindTexture(target, tex);\n if (target === gl.TEXTURE_CUBE_MAP) {\n // this should have been the default for cubemaps :(\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 type = dimensions.type;\n } else if (Array.isArray(src) && (typeof (src[0]) === 'string' || isTexImageSource(src[0]))) {\n if (target === gl.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 } else {\n throw \"unsupported src type\";\n }\n } else {\n setEmptyTexture(gl, tex, options);\n }\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, width, height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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.} 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.} 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] || (\"0x\" + value.toString(16));\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\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 = )` 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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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(gl.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.| 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":""} \ No newline at end of file diff --git a/dist/4.x/twgl-full.min.js b/dist/4.x/twgl-full.min.js index fae4e20..435b0cb 100644 --- a/dist/4.x/twgl-full.min.js +++ b/dist/4.x/twgl-full.min.js @@ -1,6 +1,6 @@ /*! - * @license twgl.js 4.13.0 Copyright (c) 2015, Gregg Tavares All Rights Reserved. + * @license twgl.js 4.13.1 Copyright (c) 2015, Gregg Tavares All Rights Reserved. * Available via the MIT license. * see: http://github.com/greggman/twgl.js for details */ -!function(e,r){"object"==typeof exports&&"object"==typeof module?module.exports=r():"function"==typeof define&&define.amd?define([],r):"object"==typeof exports?exports.twgl=r():e.twgl=r()}("undefined"!=typeof self?self:this,(function(){return function(e){var r={};function t(n){if(r[n])return r[n].exports;var o=r[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,t),o.l=!0,o.exports}return t.m=e,t.c=r,t.d=function(e,r,n){t.o(e,r)||Object.defineProperty(e,r,{enumerable:!0,get:n})},t.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},t.t=function(e,r){if(1&r&&(e=t(e)),8&r)return e;if(4&r&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(t.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&r&&"string"!=typeof e)for(var o in e)t.d(n,o,function(r){return e[r]}.bind(null,o));return n},t.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(r,"a",r),r},t.o=function(e,r){return Object.prototype.hasOwnProperty.call(e,r)},t.p="",t(t.s=8)}([function(e,r,t){"use strict";r.__esModule=!0,r.copyExistingProperties=function(e,r){Object.keys(r).forEach((function(t){r.hasOwnProperty(t)&&e.hasOwnProperty(t)&&(r[t]=e[t])}))},r.copyNamedProperties=function(e,r,t){e.forEach((function(e){var n=r[e];void 0!==n&&(t[e]=n)}))},r.error=function(){var e;(e=console).error.apply(e,arguments)},r.warn=function(){var e;(e=console).warn.apply(e,arguments)},r.isBuffer=function(e,r){return"undefined"!=typeof WebGLBuffer&&r instanceof WebGLBuffer},r.isRenderbuffer=function(e,r){return"undefined"!=typeof WebGLRenderbuffer&&r instanceof WebGLRenderbuffer},r.isShader=function(e,r){return"undefined"!=typeof WebGLShader&&r instanceof WebGLShader},r.isTexture=function(e,r){return"undefined"!=typeof WebGLTexture&&r instanceof WebGLTexture},r.isSampler=function(e,r){return"undefined"!=typeof WebGLSampler&&r instanceof WebGLSampler}},function(e,r,t){"use strict";r.__esModule=!0,r.getGLTypeForTypedArray=function(e){if(e instanceof Int8Array)return n;if(e instanceof Uint8Array)return o;if(e instanceof Uint8ClampedArray)return o;if(e instanceof Int16Array)return u;if(e instanceof Uint16Array)return i;if(e instanceof Int32Array)return a;if(e instanceof Uint32Array)return f;if(e instanceof Float32Array)return c;throw new Error("unsupported typed array type")},r.getGLTypeForTypedArrayType=function(e){if(e===Int8Array)return n;if(e===Uint8Array)return o;if(e===Uint8ClampedArray)return o;if(e===Int16Array)return u;if(e===Uint16Array)return i;if(e===Int32Array)return a;if(e===Uint32Array)return f;if(e===Float32Array)return c;throw new Error("unsupported typed array type")},r.getTypedArrayTypeForGLType=function(e){var r=l[e];if(!r)throw new Error("unknown gl type");return r},r.isArrayBuffer=void 0;var n=5120,o=5121,u=5122,i=5123,a=5124,f=5125,c=5126,l={},s=l;s[n]=Int8Array,s[o]=Uint8Array,s[u]=Int16Array,s[i]=Uint16Array,s[a]=Int32Array,s[f]=Uint32Array,s[c]=Float32Array,s[32819]=Uint16Array,s[32820]=Uint16Array,s[33635]=Uint16Array,s[5131]=Uint16Array,s[33640]=Uint32Array,s[35899]=Uint32Array,s[35902]=Uint32Array,s[36269]=Uint32Array,s[34042]=Uint32Array;var v="undefined"!=typeof SharedArrayBuffer?function(e){return e&&e.buffer&&(e.buffer instanceof ArrayBuffer||e.buffer instanceof SharedArrayBuffer)}:function(e){return e&&e.buffer&&e.buffer instanceof ArrayBuffer};r.isArrayBuffer=v},function(e,r,t){"use strict";r.__esModule=!0,r.add=function(e,r,t){return(t=t||new n(3))[0]=e[0]+r[0],t[1]=e[1]+r[1],t[2]=e[2]+r[2],t},r.copy=function(e,r){return(r=r||new n(3))[0]=e[0],r[1]=e[1],r[2]=e[2],r},r.create=function(e,r,t){var o=new n(3);e&&(o[0]=e);r&&(o[1]=r);t&&(o[2]=t);return o},r.cross=function(e,r,t){t=t||new n(3);var o=e[2]*r[0]-e[0]*r[2],u=e[0]*r[1]-e[1]*r[0];return t[0]=e[1]*r[2]-e[2]*r[1],t[1]=o,t[2]=u,t},r.distance=function(e,r){var t=e[0]-r[0],n=e[1]-r[1],o=e[2]-r[2];return Math.sqrt(t*t+n*n+o*o)},r.distanceSq=function(e,r){var t=e[0]-r[0],n=e[1]-r[1],o=e[2]-r[2];return t*t+n*n+o*o},r.divide=function(e,r,t){return(t=t||new n(3))[0]=e[0]/r[0],t[1]=e[1]/r[1],t[2]=e[2]/r[2],t},r.divScalar=function(e,r,t){return(t=t||new n(3))[0]=e[0]/r,t[1]=e[1]/r,t[2]=e[2]/r,t},r.dot=function(e,r){return e[0]*r[0]+e[1]*r[1]+e[2]*r[2]},r.lerp=function(e,r,t,o){return(o=o||new n(3))[0]=e[0]+t*(r[0]-e[0]),o[1]=e[1]+t*(r[1]-e[1]),o[2]=e[2]+t*(r[2]-e[2]),o},r.lerpV=function(e,r,t,o){return(o=o||new n(3))[0]=e[0]+t[0]*(r[0]-e[0]),o[1]=e[1]+t[1]*(r[1]-e[1]),o[2]=e[2]+t[2]*(r[2]-e[2]),o},r.length=function(e){return Math.sqrt(e[0]*e[0]+e[1]*e[1]+e[2]*e[2])},r.lengthSq=function(e){return e[0]*e[0]+e[1]*e[1]+e[2]*e[2]},r.max=function(e,r,t){return(t=t||new n(3))[0]=Math.max(e[0],r[0]),t[1]=Math.max(e[1],r[1]),t[2]=Math.max(e[2],r[2]),t},r.min=function(e,r,t){return(t=t||new n(3))[0]=Math.min(e[0],r[0]),t[1]=Math.min(e[1],r[1]),t[2]=Math.min(e[2],r[2]),t},r.mulScalar=function(e,r,t){return(t=t||new n(3))[0]=e[0]*r,t[1]=e[1]*r,t[2]=e[2]*r,t},r.multiply=function(e,r,t){return(t=t||new n(3))[0]=e[0]*r[0],t[1]=e[1]*r[1],t[2]=e[2]*r[2],t},r.negate=function(e,r){return(r=r||new n(3))[0]=-e[0],r[1]=-e[1],r[2]=-e[2],r},r.normalize=function(e,r){r=r||new n(3);var t=e[0]*e[0]+e[1]*e[1]+e[2]*e[2],o=Math.sqrt(t);o>1e-5?(r[0]=e[0]/o,r[1]=e[1]/o,r[2]=e[2]/o):(r[0]=0,r[1]=0,r[2]=0);return r},r.setDefaultType=function(e){var r=n;return n=e,r},r.subtract=function(e,r,t){return(t=t||new n(3))[0]=e[0]-r[0],t[1]=e[1]-r[1],t[2]=e[2]-r[2],t};var n=Float32Array},function(e,r,t){"use strict";r.__esModule=!0,r.isWebGL1=function(e){return!e.texStorage2D},r.isWebGL2=function(e){return!!e.texStorage2D},r.glEnumToString=void 0;var n,o,u=(n={},o={},function(e,r){return function(e){var r=e.constructor.name;if(!n[r]){for(var t in e)if("number"==typeof e[t]){var u=o[e[t]];o[e[t]]=u?"".concat(u," | ").concat(t):t}n[r]=!0}}(e),o[r]||"0x"+r.toString(16)});r.glEnumToString=u},function(e,r,t){"use strict";r.__esModule=!0,r.createAttributeSetters=G,r.createProgram=T,r.createProgramFromScripts=function(e,r,t,n,o){for(var u=j(t,n,o),i=[],a=0;a=0?e.FRAGMENT_SHADER:r.indexOf("vert")>=0?e.VERTEX_SHADER:void 0}function R(e,r){r.forEach((function(r){e.deleteShader(r)}))}function T(e,r,t,n,u){for(var i=j(t,n,u),a=[],f=[],l=0;l1&&"[0]"===n.name.substr(-3),a=n.type,f=l[a];if(!f)throw new Error("unknown type: 0x".concat(a.toString(16)));if(f.bindPoint){var c=t;t+=n.size,o=i?f.arraySetter(e,a,c,u,n.size):f.setter(e,a,c,u,n.size)}else o=f.arraySetter&&i?f.arraySetter(e,u):f.setter(e,u);return o.location=u,o}for(var o={},u=e.getProgramParameter(r,e.ACTIVE_UNIFORMS),i=0;i0)throw new Error("numComponents ".concat(u," not correct for length ").concat(o));return i}(r);return t},r.createBufferFromArray=w,r.createBufferFromTypedArray=c,r.createBufferInfoFromArrays=function(e,r,t){var o=p(e,r),u=Object.assign({},t||{});u.attribs=Object.assign({},t?t.attribs:{},o);var i=r.indices;if(i){var f=m(i,"indices");u.indices=c(e,f,e.ELEMENT_ARRAY_BUFFER),u.numElements=f.length,u.elementType=n.getGLTypeForTypedArray(f)}else u.numElements||(u.numElements=function(e,r){var t,n;for(n=0;n0)throw new Error("Can not guess numComponents for attribute '".concat(e,"'. Tried ").concat(t," but ").concat(r," values is not evenly divisible by ").concat(t,". You should specify it."));return t}function d(e,r){return e.numComponents||e.size||y(r,s(e).length)}function m(e,r){if(n.isArrayBuffer(e))return e;if(n.isArrayBuffer(e.data))return e.data;Array.isArray(e)&&(e={data:e});var t=e.type;return t||(t=l(r)?Uint16Array:Float32Array),new t(e.data)}function p(e,r){var t={};return Object.keys(r).forEach((function(o){if(!l(o)){var u=r[o],i=u.attrib||u.name||u.attribName||a.attribPrefix+o;if(u.value){if(!Array.isArray(u.value)&&!n.isArrayBuffer(u.value))throw new Error("array.value is not array or typedarray");t[i]={value:u.value}}else{var f,s,v,b;if(u.buffer&&u.buffer instanceof WebGLBuffer)f=u.buffer,b=u.numComponents||u.size,s=u.type,v=u.normalize;else if("number"==typeof u||"number"==typeof u.data){var p=u.data||u,x=u.type||Float32Array,w=p*x.BYTES_PER_ELEMENT;s=n.getGLTypeForTypedArrayType(x),v=void 0!==u.normalize?u.normalize:(F=x)===Int8Array||F===Uint8Array,b=u.numComponents||u.size||y(o,p),f=e.createBuffer(),e.bindBuffer(e.ARRAY_BUFFER,f),e.bufferData(e.ARRAY_BUFFER,w,u.drawType||e.STATIC_DRAW)}else{var h=m(u,o);f=c(e,h,void 0,u.drawType),s=n.getGLTypeForTypedArray(h),v=void 0!==u.normalize?u.normalize:function(e){return e instanceof Int8Array||e instanceof Uint8Array}(h),b=d(u,o)}t[i]={buffer:f,numComponents:b,type:s,normalize:v,stride:u.stride||0,offset:u.offset||0,divisor:void 0===u.divisor?void 0:u.divisor,drawType:u.drawType}}}var F})),e.bindBuffer(e.ARRAY_BUFFER,null),t}var x=["position","positions","a_position"];function w(e,r,t){var n="indices"===t?e.ELEMENT_ARRAY_BUFFER:e.ARRAY_BUFFER;return c(e,m(r,t),n)}},function(e,r,t){"use strict";r.__esModule=!0,r.setTextureDefaults_=function(e){u.copyExistingProperties(e,c),e.textureColor&&Qe(e.textureColor)},r.createSampler=fr,r.createSamplers=function(e,r){var t={};return Object.keys(r).forEach((function(n){t[n]=fr(e,r[n])})),t},r.setSamplerParameters=ar,r.createTexture=Or,r.setEmptyTexture=Ar,r.setTextureFromArray=Er,r.loadTextureFromUrl=wr,r.setTextureFromElement=br,r.setTextureFilteringForSize=cr,r.setTextureParameters=ir,r.setDefaultTextureColor=Qe,r.createTextures=function(e,r,t){t=t||yr;var n=0,o=[],u={},i={};function a(){0===n&&setTimeout((function(){t(o.length?o:void 0,u,i)}),0)}return Object.keys(r).forEach((function(t){var f,c,l=r[t];("string"==typeof(c=l.src)||Array.isArray(c)&&"string"==typeof c[0])&&(f=function(e,r,u){i[t]=u,--n,e&&o.push(e),a()},++n),u[t]=Or(e,l,f)})),a(),u},r.resizeTexture=function(e,r,t,n,o,u){n=n||t.width,o=o||t.height,u=u||t.depth;var i=t.target||e.TEXTURE_2D;e.bindTexture(i,r);var a,f=t.level||0,c=t.internalFormat||t.format||e.RGBA,s=Ve(c),v=t.format||s.format,b=t.src;a=b&&(l(b)||Array.isArray(b)&&"number"==typeof b[0])?t.type||$e(e,b,s.type):t.type||s.type;if(i===e.TEXTURE_CUBE_MAP)for(var y=0;y<6;++y)e.texImage2D(e.TEXTURE_CUBE_MAP_POSITIVE_X+y,f,c,n,o,0,v,a,null);else i===e.TEXTURE_3D||i===e.TEXTURE_2D_ARRAY?e.texImage3D(i,f,c,n,o,u,0,v,a,null):e.texImage2D(i,f,c,n,o,0,v,a,null)},r.canGenerateMipmap=Ke,r.canFilter=Ze,r.getNumComponentsForFormat=function(e){var r=De[e];if(!r)throw"unknown format: "+e;return r.u},r.getBytesPerElementForInternalFormat=qe,r.getFormatAndTypeForInternalFormat=Ve;var n=a(t(3)),o=a(t(1)),u=a(t(0));function i(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return i=function(){return e},e}function a(e){if(e&&e.__esModule)return e;var r=i();if(r&&r.has(e))return r.get(e);var t={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var o in e)if(Object.prototype.hasOwnProperty.call(e,o)){var u=n?Object.getOwnPropertyDescriptor(e,o):null;u&&(u.get||u.set)?Object.defineProperty(t,o,u):t[o]=e[o]}}return t.default=e,r&&r.set(e,t),t}var f,c={textureColor:new Uint8Array([128,192,255,255]),textureOptions:{},crossOrigin:void 0},l=o.isArrayBuffer;function s(){return f=f||("undefined"!=typeof document&&document.createElement?document.createElement("canvas").getContext("2d"):null)}var v,b=6406,y=6407,d=6408,m=6409,p=6410,x=6402,w=34041,h=33321,F=36756,E=33325,A=33326,O=33330,_=33329,j=33338,M=33337,P=33340,R=33339,T=33323,g=36757,z=33327,U=33328,C=33336,S=33335,k=33332,W=33331,I=33334,B=33333,L=32849,G=35905,X=36194,D=36758,N=35898,H=35901,q=34843,V=34837,Y=36221,K=36239,Z=36215,$=36233,J=36209,Q=36227,ee=32856,re=35907,te=36759,ne=32855,oe=32854,ue=32857,ie=34842,ae=34836,fe=36220,ce=36238,le=36975,se=36214,ve=36232,be=36226,ye=36208,de=33189,me=33190,pe=36012,xe=36013,we=35056,he=5120,Fe=5121,Ee=5122,Ae=5123,Oe=5124,_e=5125,je=5126,Me=32819,Pe=32820,Re=33635,Te=5131,ge=36193,ze=33640,Ue=35899,Ce=35902,Se=36269,ke=34042,We=33319,Ie=33320,Be=6403,Le=36244,Ge=36248,Xe=36249,De={},Ne=De;function He(e){if(!v){var r={};r[b]={v:b,h:!0,F:!0,A:[1,2,2,4],type:[Fe,Te,ge,je]},r[m]={v:m,h:!0,F:!0,A:[1,2,2,4],type:[Fe,Te,ge,je]},r[p]={v:p,h:!0,F:!0,A:[2,4,4,8],type:[Fe,Te,ge,je]},r[y]={v:y,h:!0,F:!0,A:[3,6,6,12,2],type:[Fe,Te,ge,je,Re]},r[d]={v:d,h:!0,F:!0,A:[4,8,8,16,2,2],type:[Fe,Te,ge,je,Me,Pe]},r[h]={v:Be,h:!0,F:!0,A:[1],type:[Fe]},r[F]={v:Be,h:!1,F:!0,A:[1],type:[he]},r[E]={v:Be,h:!1,F:!0,A:[4,2],type:[je,Te]},r[A]={v:Be,h:!1,F:!1,A:[4],type:[je]},r[O]={v:Le,h:!0,F:!1,A:[1],type:[Fe]},r[_]={v:Le,h:!0,F:!1,A:[1],type:[he]},r[k]={v:Le,h:!0,F:!1,A:[2],type:[Ae]},r[W]={v:Le,h:!0,F:!1,A:[2],type:[Ee]},r[I]={v:Le,h:!0,F:!1,A:[4],type:[_e]},r[B]={v:Le,h:!0,F:!1,A:[4],type:[Oe]},r[T]={v:We,h:!0,F:!0,A:[2],type:[Fe]},r[g]={v:We,h:!1,F:!0,A:[2],type:[he]},r[z]={v:We,h:!1,F:!0,A:[8,4],type:[je,Te]},r[U]={v:We,h:!1,F:!1,A:[8],type:[je]},r[C]={v:Ie,h:!0,F:!1,A:[2],type:[Fe]},r[S]={v:Ie,h:!0,F:!1,A:[2],type:[he]},r[j]={v:Ie,h:!0,F:!1,A:[4],type:[Ae]},r[M]={v:Ie,h:!0,F:!1,A:[4],type:[Ee]},r[P]={v:Ie,h:!0,F:!1,A:[8],type:[_e]},r[R]={v:Ie,h:!0,F:!1,A:[8],type:[Oe]},r[L]={v:y,h:!0,F:!0,A:[3],type:[Fe]},r[G]={v:y,h:!1,F:!0,A:[3],type:[Fe]},r[X]={v:y,h:!0,F:!0,A:[3,2],type:[Fe,Re]},r[D]={v:y,h:!1,F:!0,A:[3],type:[he]},r[N]={v:y,h:!1,F:!0,A:[12,6,4],type:[je,Te,Ue]},r[H]={v:y,h:!1,F:!0,A:[12,6,4],type:[je,Te,Ce]},r[q]={v:y,h:!1,F:!0,A:[12,6],type:[je,Te]},r[V]={v:y,h:!1,F:!1,A:[12],type:[je]},r[Y]={v:Ge,h:!1,F:!1,A:[3],type:[Fe]},r[K]={v:Ge,h:!1,F:!1,A:[3],type:[he]},r[Z]={v:Ge,h:!1,F:!1,A:[6],type:[Ae]},r[$]={v:Ge,h:!1,F:!1,A:[6],type:[Ee]},r[J]={v:Ge,h:!1,F:!1,A:[12],type:[_e]},r[Q]={v:Ge,h:!1,F:!1,A:[12],type:[Oe]},r[ee]={v:d,h:!0,F:!0,A:[4],type:[Fe]},r[re]={v:d,h:!0,F:!0,A:[4],type:[Fe]},r[te]={v:d,h:!1,F:!0,A:[4],type:[he]},r[ne]={v:d,h:!0,F:!0,A:[4,2,4],type:[Fe,Pe,ze]},r[oe]={v:d,h:!0,F:!0,A:[4,2],type:[Fe,Me]},r[ue]={v:d,h:!0,F:!0,A:[4],type:[ze]},r[ie]={v:d,h:!1,F:!0,A:[16,8],type:[je,Te]},r[ae]={v:d,h:!1,F:!1,A:[16],type:[je]},r[fe]={v:Xe,h:!0,F:!1,A:[4],type:[Fe]},r[ce]={v:Xe,h:!0,F:!1,A:[4],type:[he]},r[le]={v:Xe,h:!0,F:!1,A:[4],type:[ze]},r[se]={v:Xe,h:!0,F:!1,A:[8],type:[Ae]},r[ve]={v:Xe,h:!0,F:!1,A:[8],type:[Ee]},r[be]={v:Xe,h:!0,F:!1,A:[16],type:[Oe]},r[ye]={v:Xe,h:!0,F:!1,A:[16],type:[_e]},r[de]={v:x,h:!0,F:!1,A:[2,4],type:[Ae,_e]},r[me]={v:x,h:!0,F:!1,A:[4],type:[_e]},r[pe]={v:x,h:!0,F:!1,A:[4],type:[je]},r[we]={v:w,h:!0,F:!1,A:[4],type:[ke]},r[xe]={v:w,h:!0,F:!1,A:[4],type:[Se]},Object.keys(r).forEach((function(e){var t=r[e];t.bytesPerElementMap={},t.A.forEach((function(e,r){var n=t.type[r];t.bytesPerElementMap[n]=e}))})),v=r}return v[e]}function qe(e,r){var t=He(e);if(!t)throw"unknown internal format";var n=t.bytesPerElementMap[r];if(void 0===n)throw"unknown internal format";return n}function Ve(e){var r=He(e);if(!r)throw"unknown internal format";return{format:r.v,type:r.type[0]}}function Ye(e){return 0==(e&e-1)}function Ke(e,r,t,o){if(!n.isWebGL2(e))return Ye(r)&&Ye(t);var u=He(o);if(!u)throw"unknown internal format";return u.h&&u.F}function Ze(e){var r=He(e);if(!r)throw"unknown internal format";return r.F}function $e(e,r,t){return l(r)?o.getGLTypeForTypedArray(r):t||e.UNSIGNED_BYTE}function Je(e,r,t,n,o){if(o%1!=0)throw"can't guess dimensions";if(t||n){if(n){if(!t&&(t=o/n)%1)throw"can't guess dimensions"}else if((n=o/t)%1)throw"can't guess dimensions"}else{var u=Math.sqrt(o/(r===e.TEXTURE_CUBE_MAP?6:1));u%1==0?(t=u,n=u):(t=o,n=1)}return{width:t,height:n}}function Qe(e){c.textureColor=new Uint8Array([255*e[0],255*e[1],255*e[2],255*e[3]])}Ne[b]={u:1},Ne[m]={u:1},Ne[p]={u:2},Ne[y]={u:3},Ne[d]={u:4},Ne[Be]={u:1},Ne[Le]={u:1},Ne[We]={u:2},Ne[Ie]={u:2},Ne[y]={u:3},Ne[Ge]={u:3},Ne[d]={u:4},Ne[Xe]={u:4},Ne[x]={u:1},Ne[w]={u:2};var er={};function rr(e,r){void 0!==r.colorspaceConversion&&(er.colorspaceConversion=e.getParameter(e.UNPACK_COLORSPACE_CONVERSION_WEBGL),e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL,r.colorspaceConversion)),void 0!==r.premultiplyAlpha&&(er.premultiplyAlpha=e.getParameter(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL),e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,r.premultiplyAlpha)),void 0!==r.flipY&&(er.flipY=e.getParameter(e.UNPACK_FLIP_Y_WEBGL),e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL,r.flipY))}function tr(e,r){void 0!==r.colorspaceConversion&&e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL,er.colorspaceConversion),void 0!==r.premultiplyAlpha&&e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,er.premultiplyAlpha),void 0!==r.flipY&&e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL,er.flipY)}function nr(e){er.unpackAlignment=e.getParameter(e.UNPACK_ALIGNMENT),n.isWebGL2(e)&&(er.unpackRowLength=e.getParameter(e.UNPACK_ROW_LENGTH),er.unpackImageHeight=e.getParameter(e.UNPACK_IMAGE_HEIGHT),er.unpackSkipPixels=e.getParameter(e.UNPACK_SKIP_PIXELS),er.unpackSkipRows=e.getParameter(e.UNPACK_SKIP_ROWS),er.unpackSkipImages=e.getParameter(e.UNPACK_SKIP_IMAGES))}function or(e){e.pixelStorei(e.UNPACK_ALIGNMENT,er.unpackAlignment),n.isWebGL2(e)&&(e.pixelStorei(e.UNPACK_ROW_LENGTH,er.unpackRowLength),e.pixelStorei(e.UNPACK_IMAGE_HEIGHT,er.unpackImageHeight),e.pixelStorei(e.UNPACK_SKIP_PIXELS,er.unpackSkipPixels),e.pixelStorei(e.UNPACK_SKIP_ROWS,er.unpackSkipRows),e.pixelStorei(e.UNPACK_SKIP_IMAGES,er.unpackSkipImages))}function ur(e,r,t,n){n.minMag&&(t.call(e,r,e.TEXTURE_MIN_FILTER,n.minMag),t.call(e,r,e.TEXTURE_MAG_FILTER,n.minMag)),n.min&&t.call(e,r,e.TEXTURE_MIN_FILTER,n.min),n.mag&&t.call(e,r,e.TEXTURE_MAG_FILTER,n.mag),n.wrap&&(t.call(e,r,e.TEXTURE_WRAP_S,n.wrap),t.call(e,r,e.TEXTURE_WRAP_T,n.wrap),(r===e.TEXTURE_3D||u.isSampler(e,r))&&t.call(e,r,e.TEXTURE_WRAP_R,n.wrap)),n.wrapR&&t.call(e,r,e.TEXTURE_WRAP_R,n.wrapR),n.wrapS&&t.call(e,r,e.TEXTURE_WRAP_S,n.wrapS),n.wrapT&&t.call(e,r,e.TEXTURE_WRAP_T,n.wrapT),n.minLod&&t.call(e,r,e.TEXTURE_MIN_LOD,n.minLod),n.maxLod&&t.call(e,r,e.TEXTURE_MAX_LOD,n.maxLod),n.baseLevel&&t.call(e,r,e.TEXTURE_BASE_LEVEL,n.baseLevel),n.maxLevel&&t.call(e,r,e.TEXTURE_MAX_LEVEL,n.maxLevel)}function ir(e,r,t){var n=t.target||e.TEXTURE_2D;e.bindTexture(n,r),ur(e,n,e.texParameteri,t)}function ar(e,r,t){ur(e,r,e.samplerParameteri,t)}function fr(e,r){var t=e.createSampler();return ar(e,t,r),t}function cr(e,r,t,n,o,u,i){t=t||c.textureOptions,u=u||e.RGBA,i=i||e.UNSIGNED_BYTE;var a=t.target||e.TEXTURE_2D;if(n=n||t.width,o=o||t.height,e.bindTexture(a,r),Ke(e,n,o,u))e.generateMipmap(a);else{var f=Ze(u)?e.LINEAR:e.NEAREST;e.texParameteri(a,e.TEXTURE_MIN_FILTER,f),e.texParameteri(a,e.TEXTURE_MAG_FILTER,f),e.texParameteri(a,e.TEXTURE_WRAP_S,e.CLAMP_TO_EDGE),e.texParameteri(a,e.TEXTURE_WRAP_T,e.CLAMP_TO_EDGE)}}function lr(e){return!0===e.auto||void 0===e.auto&&void 0===e.level}function sr(e,r){return(r=r||{}).cubeFaceOrder||[e.TEXTURE_CUBE_MAP_POSITIVE_X,e.TEXTURE_CUBE_MAP_NEGATIVE_X,e.TEXTURE_CUBE_MAP_POSITIVE_Y,e.TEXTURE_CUBE_MAP_NEGATIVE_Y,e.TEXTURE_CUBE_MAP_POSITIVE_Z,e.TEXTURE_CUBE_MAP_NEGATIVE_Z]}function vr(e,r){var t=sr(e,r).map((function(e,r){return{face:e,ndx:r}}));return t.sort((function(e,r){return e.face-r.face})),t}function br(e,r,t,n){var o=(n=n||c.textureOptions).target||e.TEXTURE_2D,u=n.level||0,i=t.width,a=t.height,f=n.internalFormat||n.format||e.RGBA,l=Ve(f),v=n.format||l.format,b=n.type||l.type;if(rr(e,n),e.bindTexture(o,r),o===e.TEXTURE_CUBE_MAP){var y,d,m=t.width,p=t.height;if(m/6===p)y=p,d=[0,0,1,0,2,0,3,0,4,0,5,0];else if(p/6===m)y=m,d=[0,0,0,1,0,2,0,3,0,4,0,5];else if(m/3==p/2)y=m/3,d=[0,0,1,0,2,0,0,1,1,1,2,1];else{if(m/2!=p/3)throw"can't figure out cube map from element: "+(t.src?t.src:t.nodeName);y=m/2,d=[0,0,1,0,0,1,1,1,0,2,1,2]}var x=s();x?(x.canvas.width=y,x.canvas.height=y,i=y,a=y,vr(e,n).forEach((function(r){var n=d[2*r.ndx+0]*y,o=d[2*r.ndx+1]*y;x.drawImage(t,n,o,y,y,0,0,y,y),e.texImage2D(r.face,u,f,v,b,x.canvas)})),x.canvas.width=1,x.canvas.height=1):"undefined"!=typeof createImageBitmap&&(i=y,a=y,vr(e,n).forEach((function(c){var l=d[2*c.ndx+0]*y,s=d[2*c.ndx+1]*y;e.texImage2D(c.face,u,f,y,y,0,v,b,null),createImageBitmap(t,l,s,y,y,{premultiplyAlpha:"none",colorSpaceConversion:"none"}).then((function(t){rr(e,n),e.bindTexture(o,r),e.texImage2D(c.face,u,f,v,b,t),tr(e,n),lr(n)&&cr(e,r,n,i,a,f,b)}))})))}else if(o===e.TEXTURE_3D||o===e.TEXTURE_2D_ARRAY){var w=Math.min(t.width,t.height),h=Math.max(t.width,t.height),F=h/w;if(F%1!=0)throw"can not compute 3D dimensions of element";var E=t.width===h?1:0,A=t.height===h?1:0;nr(e),e.pixelStorei(e.UNPACK_ALIGNMENT,1),e.pixelStorei(e.UNPACK_ROW_LENGTH,t.width),e.pixelStorei(e.UNPACK_IMAGE_HEIGHT,0),e.pixelStorei(e.UNPACK_SKIP_IMAGES,0),e.texImage3D(o,u,f,w,w,w,0,v,b,null);for(var O=0;O=0?w(n,r):t.indexOf("tan")>=0||t.indexOf("binorm")>=0?p(n,r):t.indexOf("norm")>=0&&x(n,r)})),e}function F(e,r,t){return e=e||2,{position:{numComponents:2,data:[(r=r||0)+-1*(e*=.5),(t=t||0)+-1*e,r+1*e,t+-1*e,r+-1*e,t+1*e,r+1*e,t+1*e]},normal:[0,0,1,0,0,1,0,0,1,0,0,1],texcoord:[0,0,1,0,0,1,1,1],indices:[0,1,2,2,1,3]}}function E(e,r,t,n,o){e=e||1,r=r||1,t=t||1,n=n||1,o=o||i.identity();for(var u=(t+1)*(n+1),a=b(3,u),f=b(3,u),c=b(2,u),l=0;l<=n;l++)for(var s=0;s<=t;s++){var v=s/t,y=l/n;a.push(e*v-.5*e,0,r*y-.5*r),f.push(0,1,0),c.push(v,y)}for(var d=t+1,m=b(3,t*n*2,Uint16Array),p=0;p 0");n=n||0,u=u||0;for(var a=(o=o||Math.PI)-n,f=(i=i||2*Math.PI)-u,c=(r+1)*(t+1),l=b(3,c),s=b(3,c),v=b(2,c),y=0;y<=t;y++)for(var d=0;d<=r;d++){var m=d/r,p=y/t,x=f*m+u,w=a*p+n,h=Math.sin(x),F=Math.cos(x),E=Math.sin(w),A=F*E,O=Math.cos(w),_=h*E;l.push(e*A,e*O,e*_),s.push(A,O,_),v.push(1-m,p)}for(var j=r+1,M=b(3,r*t*2,Uint16Array),P=0;Po?(A=t,E=1,O=r):O=e+F/o*(r-e),-2!==F&&F!==o+2||(O=0,E=0),A-=t/2;for(var _=0;_o?0:j*x,F<0?-1:F>o?1:w,F<0||F>o?0:M*x),y.push(_/n,1-E)}}for(var P=0;P 0");var f=2,c=(i=i||1)-(u=u||0),l=2*(o+1)*(2+f),s=b(3,l),v=b(3,l),y=b(2,l);function d(e,r,t){return e+(r-e)*t}function m(r,t,i,l,b,m){for(var p=0;p<=o;p++){var x=t/(f-1),w=p/o,h=2*(x-.5),F=(u+w*c)*Math.PI,E=Math.sin(F),A=Math.cos(F),O=d(e,r,E),_=h*n,j=A*e,M=E*O;s.push(_,j,M);var P=a.add(a.multiply([0,E,A],i),l);v.push(P),y.push(x*b+m,w)}}for(var p=0;p0&&m!==r){var h=l+(m+1),F=l+m,E=l+m-v,A=l+(m+1)-v;c.push(h,F,E),c.push(h,E,A)}}l+=r+1}return{position:i,normal:a,texcoord:f,indices:c}}function U(e){return function(r){var t=e.apply(this,Array.prototype.slice.call(arguments,1));return n.createBuffersFromArrays(r,t)}}function C(e){return function(r){var t=e.apply(null,Array.prototype.slice.call(arguments,1));return n.createBufferInfoFromArrays(r,t)}}var S=["numComponents","size","type","normalize","stride","offset","attrib","name","attribName"];function k(e,r,t,n){n=n||0;for(var o=e.length,u=0;u1e-5?(r[0]=e[0]/o,r[1]=e[1]/o,r[2]=e[2]/o):(r[0]=0,r[1]=0,r[2]=0);return r},r.setDefaultType=function(e){var r=n;return n=e,r},r.subtract=function(e,r,t){return(t=t||new n(3))[0]=e[0]-r[0],t[1]=e[1]-r[1],t[2]=e[2]-r[2],t};var n=Float32Array},function(e,r,t){"use strict";r.__esModule=!0,r.isWebGL1=function(e){return!e.texStorage2D},r.isWebGL2=function(e){return!!e.texStorage2D},r.glEnumToString=void 0;var n,o,u=(n={},o={},function(e,r){return function(e){var r=e.constructor.name;if(!n[r]){for(var t in e)if("number"==typeof e[t]){var u=o[e[t]];o[e[t]]=u?"".concat(u," | ").concat(t):t}n[r]=!0}}(e),o[r]||"0x"+r.toString(16)});r.glEnumToString=u},function(e,r,t){"use strict";r.__esModule=!0,r.createAttributeSetters=G,r.createProgram=T,r.createProgramFromScripts=function(e,r,t,n,o){for(var u=j(t,n,o),i=[],a=0;a=0?e.FRAGMENT_SHADER:r.indexOf("vert")>=0?e.VERTEX_SHADER:void 0}function R(e,r){r.forEach((function(r){e.deleteShader(r)}))}function T(e,r,t,n,u){for(var i=j(t,n,u),a=[],f=[],l=0;l1&&"[0]"===n.name.substr(-3),a=n.type,f=l[a];if(!f)throw new Error("unknown type: 0x".concat(a.toString(16)));if(f.bindPoint){var c=t;t+=n.size,o=i?f.arraySetter(e,a,c,u,n.size):f.setter(e,a,c,u,n.size)}else o=f.arraySetter&&i?f.arraySetter(e,u):f.setter(e,u);return o.location=u,o}for(var o={},u=e.getProgramParameter(r,e.ACTIVE_UNIFORMS),i=0;i0)throw new Error("numComponents ".concat(u," not correct for length ").concat(o));return i}(r);return t},r.createBufferFromArray=w,r.createBufferFromTypedArray=c,r.createBufferInfoFromArrays=function(e,r,t){var o=p(e,r),u=Object.assign({},t||{});u.attribs=Object.assign({},t?t.attribs:{},o);var i=r.indices;if(i){var f=m(i,"indices");u.indices=c(e,f,e.ELEMENT_ARRAY_BUFFER),u.numElements=f.length,u.elementType=n.getGLTypeForTypedArray(f)}else u.numElements||(u.numElements=function(e,r){var t,n;for(n=0;n0)throw new Error("Can not guess numComponents for attribute '".concat(e,"'. Tried ").concat(t," but ").concat(r," values is not evenly divisible by ").concat(t,". You should specify it."));return t}function d(e,r){return e.numComponents||e.size||y(r,s(e).length)}function m(e,r){if(n.isArrayBuffer(e))return e;if(n.isArrayBuffer(e.data))return e.data;Array.isArray(e)&&(e={data:e});var t=e.type;return t||(t=l(r)?Uint16Array:Float32Array),new t(e.data)}function p(e,r){var t={};return Object.keys(r).forEach((function(o){if(!l(o)){var u=r[o],i=u.attrib||u.name||u.attribName||a.attribPrefix+o;if(u.value){if(!Array.isArray(u.value)&&!n.isArrayBuffer(u.value))throw new Error("array.value is not array or typedarray");t[i]={value:u.value}}else{var f,s,v,b;if(u.buffer&&u.buffer instanceof WebGLBuffer)f=u.buffer,b=u.numComponents||u.size,s=u.type,v=u.normalize;else if("number"==typeof u||"number"==typeof u.data){var p=u.data||u,x=u.type||Float32Array,w=p*x.BYTES_PER_ELEMENT;s=n.getGLTypeForTypedArrayType(x),v=void 0!==u.normalize?u.normalize:(F=x)===Int8Array||F===Uint8Array,b=u.numComponents||u.size||y(o,p),f=e.createBuffer(),e.bindBuffer(e.ARRAY_BUFFER,f),e.bufferData(e.ARRAY_BUFFER,w,u.drawType||e.STATIC_DRAW)}else{var h=m(u,o);f=c(e,h,void 0,u.drawType),s=n.getGLTypeForTypedArray(h),v=void 0!==u.normalize?u.normalize:function(e){return e instanceof Int8Array||e instanceof Uint8Array}(h),b=d(u,o)}t[i]={buffer:f,numComponents:b,type:s,normalize:v,stride:u.stride||0,offset:u.offset||0,divisor:void 0===u.divisor?void 0:u.divisor,drawType:u.drawType}}}var F})),e.bindBuffer(e.ARRAY_BUFFER,null),t}var x=["position","positions","a_position"];function w(e,r,t){var n="indices"===t?e.ELEMENT_ARRAY_BUFFER:e.ARRAY_BUFFER;return c(e,m(r,t),n)}},function(e,r,t){"use strict";r.__esModule=!0,r.setTextureDefaults_=function(e){u.copyExistingProperties(e,c),e.textureColor&&Qe(e.textureColor)},r.createSampler=fr,r.createSamplers=function(e,r){var t={};return Object.keys(r).forEach((function(n){t[n]=fr(e,r[n])})),t},r.setSamplerParameters=ar,r.createTexture=Or,r.setEmptyTexture=Ar,r.setTextureFromArray=Er,r.loadTextureFromUrl=wr,r.setTextureFromElement=br,r.setTextureFilteringForSize=cr,r.setTextureParameters=ir,r.setDefaultTextureColor=Qe,r.createTextures=function(e,r,t){t=t||yr;var n=0,o=[],u={},i={};function a(){0===n&&setTimeout((function(){t(o.length?o:void 0,u,i)}),0)}return Object.keys(r).forEach((function(t){var f,c,l=r[t];("string"==typeof(c=l.src)||Array.isArray(c)&&"string"==typeof c[0])&&(f=function(e,r,u){i[t]=u,--n,e&&o.push(e),a()},++n),u[t]=Or(e,l,f)})),a(),u},r.resizeTexture=function(e,r,t,n,o,u){n=n||t.width,o=o||t.height,u=u||t.depth;var i=t.target||e.TEXTURE_2D;e.bindTexture(i,r);var a,f=t.level||0,c=t.internalFormat||t.format||e.RGBA,s=Ve(c),v=t.format||s.format,b=t.src;a=b&&(l(b)||Array.isArray(b)&&"number"==typeof b[0])?t.type||$e(e,b,s.type):t.type||s.type;if(i===e.TEXTURE_CUBE_MAP)for(var y=0;y<6;++y)e.texImage2D(e.TEXTURE_CUBE_MAP_POSITIVE_X+y,f,c,n,o,0,v,a,null);else i===e.TEXTURE_3D||i===e.TEXTURE_2D_ARRAY?e.texImage3D(i,f,c,n,o,u,0,v,a,null):e.texImage2D(i,f,c,n,o,0,v,a,null)},r.canGenerateMipmap=Ke,r.canFilter=Ze,r.getNumComponentsForFormat=function(e){var r=De[e];if(!r)throw"unknown format: "+e;return r.u},r.getBytesPerElementForInternalFormat=qe,r.getFormatAndTypeForInternalFormat=Ve;var n=a(t(3)),o=a(t(1)),u=a(t(0));function i(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return i=function(){return e},e}function a(e){if(e&&e.__esModule)return e;var r=i();if(r&&r.has(e))return r.get(e);var t={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var o in e)if(Object.prototype.hasOwnProperty.call(e,o)){var u=n?Object.getOwnPropertyDescriptor(e,o):null;u&&(u.get||u.set)?Object.defineProperty(t,o,u):t[o]=e[o]}}return t.default=e,r&&r.set(e,t),t}var f,c={textureColor:new Uint8Array([128,192,255,255]),textureOptions:{},crossOrigin:void 0},l=o.isArrayBuffer;function s(){return f=f||("undefined"!=typeof document&&document.createElement?document.createElement("canvas").getContext("2d"):null)}var v,b=6406,y=6407,d=6408,m=6409,p=6410,x=6402,w=34041,h=33321,F=36756,E=33325,A=33326,O=33330,_=33329,j=33338,M=33337,P=33340,R=33339,T=33323,g=36757,z=33327,U=33328,C=33336,S=33335,k=33332,W=33331,I=33334,B=33333,L=32849,G=35905,X=36194,D=36758,N=35898,H=35901,q=34843,V=34837,Y=36221,K=36239,Z=36215,$=36233,J=36209,Q=36227,ee=32856,re=35907,te=36759,ne=32855,oe=32854,ue=32857,ie=34842,ae=34836,fe=36220,ce=36238,le=36975,se=36214,ve=36232,be=36226,ye=36208,de=33189,me=33190,pe=36012,xe=36013,we=35056,he=5120,Fe=5121,Ee=5122,Ae=5123,Oe=5124,_e=5125,je=5126,Me=32819,Pe=32820,Re=33635,Te=5131,ge=36193,ze=33640,Ue=35899,Ce=35902,Se=36269,ke=34042,We=33319,Ie=33320,Be=6403,Le=36244,Ge=36248,Xe=36249,De={},Ne=De;function He(e){if(!v){var r={};r[b]={v:b,h:!0,F:!0,A:[1,2,2,4],type:[Fe,Te,ge,je]},r[m]={v:m,h:!0,F:!0,A:[1,2,2,4],type:[Fe,Te,ge,je]},r[p]={v:p,h:!0,F:!0,A:[2,4,4,8],type:[Fe,Te,ge,je]},r[y]={v:y,h:!0,F:!0,A:[3,6,6,12,2],type:[Fe,Te,ge,je,Re]},r[d]={v:d,h:!0,F:!0,A:[4,8,8,16,2,2],type:[Fe,Te,ge,je,Me,Pe]},r[h]={v:Be,h:!0,F:!0,A:[1],type:[Fe]},r[F]={v:Be,h:!1,F:!0,A:[1],type:[he]},r[E]={v:Be,h:!1,F:!0,A:[4,2],type:[je,Te]},r[A]={v:Be,h:!1,F:!1,A:[4],type:[je]},r[O]={v:Le,h:!0,F:!1,A:[1],type:[Fe]},r[_]={v:Le,h:!0,F:!1,A:[1],type:[he]},r[k]={v:Le,h:!0,F:!1,A:[2],type:[Ae]},r[W]={v:Le,h:!0,F:!1,A:[2],type:[Ee]},r[I]={v:Le,h:!0,F:!1,A:[4],type:[_e]},r[B]={v:Le,h:!0,F:!1,A:[4],type:[Oe]},r[T]={v:We,h:!0,F:!0,A:[2],type:[Fe]},r[g]={v:We,h:!1,F:!0,A:[2],type:[he]},r[z]={v:We,h:!1,F:!0,A:[8,4],type:[je,Te]},r[U]={v:We,h:!1,F:!1,A:[8],type:[je]},r[C]={v:Ie,h:!0,F:!1,A:[2],type:[Fe]},r[S]={v:Ie,h:!0,F:!1,A:[2],type:[he]},r[j]={v:Ie,h:!0,F:!1,A:[4],type:[Ae]},r[M]={v:Ie,h:!0,F:!1,A:[4],type:[Ee]},r[P]={v:Ie,h:!0,F:!1,A:[8],type:[_e]},r[R]={v:Ie,h:!0,F:!1,A:[8],type:[Oe]},r[L]={v:y,h:!0,F:!0,A:[3],type:[Fe]},r[G]={v:y,h:!1,F:!0,A:[3],type:[Fe]},r[X]={v:y,h:!0,F:!0,A:[3,2],type:[Fe,Re]},r[D]={v:y,h:!1,F:!0,A:[3],type:[he]},r[N]={v:y,h:!1,F:!0,A:[12,6,4],type:[je,Te,Ue]},r[H]={v:y,h:!1,F:!0,A:[12,6,4],type:[je,Te,Ce]},r[q]={v:y,h:!1,F:!0,A:[12,6],type:[je,Te]},r[V]={v:y,h:!1,F:!1,A:[12],type:[je]},r[Y]={v:Ge,h:!1,F:!1,A:[3],type:[Fe]},r[K]={v:Ge,h:!1,F:!1,A:[3],type:[he]},r[Z]={v:Ge,h:!1,F:!1,A:[6],type:[Ae]},r[$]={v:Ge,h:!1,F:!1,A:[6],type:[Ee]},r[J]={v:Ge,h:!1,F:!1,A:[12],type:[_e]},r[Q]={v:Ge,h:!1,F:!1,A:[12],type:[Oe]},r[ee]={v:d,h:!0,F:!0,A:[4],type:[Fe]},r[re]={v:d,h:!0,F:!0,A:[4],type:[Fe]},r[te]={v:d,h:!1,F:!0,A:[4],type:[he]},r[ne]={v:d,h:!0,F:!0,A:[4,2,4],type:[Fe,Pe,ze]},r[oe]={v:d,h:!0,F:!0,A:[4,2],type:[Fe,Me]},r[ue]={v:d,h:!0,F:!0,A:[4],type:[ze]},r[ie]={v:d,h:!1,F:!0,A:[16,8],type:[je,Te]},r[ae]={v:d,h:!1,F:!1,A:[16],type:[je]},r[fe]={v:Xe,h:!0,F:!1,A:[4],type:[Fe]},r[ce]={v:Xe,h:!0,F:!1,A:[4],type:[he]},r[le]={v:Xe,h:!0,F:!1,A:[4],type:[ze]},r[se]={v:Xe,h:!0,F:!1,A:[8],type:[Ae]},r[ve]={v:Xe,h:!0,F:!1,A:[8],type:[Ee]},r[be]={v:Xe,h:!0,F:!1,A:[16],type:[Oe]},r[ye]={v:Xe,h:!0,F:!1,A:[16],type:[_e]},r[de]={v:x,h:!0,F:!1,A:[2,4],type:[Ae,_e]},r[me]={v:x,h:!0,F:!1,A:[4],type:[_e]},r[pe]={v:x,h:!0,F:!1,A:[4],type:[je]},r[we]={v:w,h:!0,F:!1,A:[4],type:[ke]},r[xe]={v:w,h:!0,F:!1,A:[4],type:[Se]},Object.keys(r).forEach((function(e){var t=r[e];t.bytesPerElementMap={},t.A.forEach((function(e,r){var n=t.type[r];t.bytesPerElementMap[n]=e}))})),v=r}return v[e]}function qe(e,r){var t=He(e);if(!t)throw"unknown internal format";var n=t.bytesPerElementMap[r];if(void 0===n)throw"unknown internal format";return n}function Ve(e){var r=He(e);if(!r)throw"unknown internal format";return{format:r.v,type:r.type[0]}}function Ye(e){return 0==(e&e-1)}function Ke(e,r,t,o){if(!n.isWebGL2(e))return Ye(r)&&Ye(t);var u=He(o);if(!u)throw"unknown internal format";return u.h&&u.F}function Ze(e){var r=He(e);if(!r)throw"unknown internal format";return r.F}function $e(e,r,t){return l(r)?o.getGLTypeForTypedArray(r):t||e.UNSIGNED_BYTE}function Je(e,r,t,n,o){if(o%1!=0)throw"can't guess dimensions";if(t||n){if(n){if(!t&&(t=o/n)%1)throw"can't guess dimensions"}else if((n=o/t)%1)throw"can't guess dimensions"}else{var u=Math.sqrt(o/(r===e.TEXTURE_CUBE_MAP?6:1));u%1==0?(t=u,n=u):(t=o,n=1)}return{width:t,height:n}}function Qe(e){c.textureColor=new Uint8Array([255*e[0],255*e[1],255*e[2],255*e[3]])}Ne[b]={u:1},Ne[m]={u:1},Ne[p]={u:2},Ne[y]={u:3},Ne[d]={u:4},Ne[Be]={u:1},Ne[Le]={u:1},Ne[We]={u:2},Ne[Ie]={u:2},Ne[y]={u:3},Ne[Ge]={u:3},Ne[d]={u:4},Ne[Xe]={u:4},Ne[x]={u:1},Ne[w]={u:2};var er={};function rr(e,r){void 0!==r.colorspaceConversion&&(er.colorspaceConversion=e.getParameter(e.UNPACK_COLORSPACE_CONVERSION_WEBGL),e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL,r.colorspaceConversion)),void 0!==r.premultiplyAlpha&&(er.premultiplyAlpha=e.getParameter(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL),e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,r.premultiplyAlpha)),void 0!==r.flipY&&(er.flipY=e.getParameter(e.UNPACK_FLIP_Y_WEBGL),e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL,r.flipY))}function tr(e,r){void 0!==r.colorspaceConversion&&e.pixelStorei(e.UNPACK_COLORSPACE_CONVERSION_WEBGL,er.colorspaceConversion),void 0!==r.premultiplyAlpha&&e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,er.premultiplyAlpha),void 0!==r.flipY&&e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL,er.flipY)}function nr(e){er.unpackAlignment=e.getParameter(e.UNPACK_ALIGNMENT),n.isWebGL2(e)&&(er.unpackRowLength=e.getParameter(e.UNPACK_ROW_LENGTH),er.unpackImageHeight=e.getParameter(e.UNPACK_IMAGE_HEIGHT),er.unpackSkipPixels=e.getParameter(e.UNPACK_SKIP_PIXELS),er.unpackSkipRows=e.getParameter(e.UNPACK_SKIP_ROWS),er.unpackSkipImages=e.getParameter(e.UNPACK_SKIP_IMAGES))}function or(e){e.pixelStorei(e.UNPACK_ALIGNMENT,er.unpackAlignment),n.isWebGL2(e)&&(e.pixelStorei(e.UNPACK_ROW_LENGTH,er.unpackRowLength),e.pixelStorei(e.UNPACK_IMAGE_HEIGHT,er.unpackImageHeight),e.pixelStorei(e.UNPACK_SKIP_PIXELS,er.unpackSkipPixels),e.pixelStorei(e.UNPACK_SKIP_ROWS,er.unpackSkipRows),e.pixelStorei(e.UNPACK_SKIP_IMAGES,er.unpackSkipImages))}function ur(e,r,t,n){n.minMag&&(t.call(e,r,e.TEXTURE_MIN_FILTER,n.minMag),t.call(e,r,e.TEXTURE_MAG_FILTER,n.minMag)),n.min&&t.call(e,r,e.TEXTURE_MIN_FILTER,n.min),n.mag&&t.call(e,r,e.TEXTURE_MAG_FILTER,n.mag),n.wrap&&(t.call(e,r,e.TEXTURE_WRAP_S,n.wrap),t.call(e,r,e.TEXTURE_WRAP_T,n.wrap),(r===e.TEXTURE_3D||u.isSampler(e,r))&&t.call(e,r,e.TEXTURE_WRAP_R,n.wrap)),n.wrapR&&t.call(e,r,e.TEXTURE_WRAP_R,n.wrapR),n.wrapS&&t.call(e,r,e.TEXTURE_WRAP_S,n.wrapS),n.wrapT&&t.call(e,r,e.TEXTURE_WRAP_T,n.wrapT),n.minLod&&t.call(e,r,e.TEXTURE_MIN_LOD,n.minLod),n.maxLod&&t.call(e,r,e.TEXTURE_MAX_LOD,n.maxLod),n.baseLevel&&t.call(e,r,e.TEXTURE_BASE_LEVEL,n.baseLevel),n.maxLevel&&t.call(e,r,e.TEXTURE_MAX_LEVEL,n.maxLevel)}function ir(e,r,t){var n=t.target||e.TEXTURE_2D;e.bindTexture(n,r),ur(e,n,e.texParameteri,t)}function ar(e,r,t){ur(e,r,e.samplerParameteri,t)}function fr(e,r){var t=e.createSampler();return ar(e,t,r),t}function cr(e,r,t,n,o,u,i){t=t||c.textureOptions,u=u||e.RGBA,i=i||e.UNSIGNED_BYTE;var a=t.target||e.TEXTURE_2D;if(n=n||t.width,o=o||t.height,e.bindTexture(a,r),Ke(e,n,o,u))e.generateMipmap(a);else{var f=Ze(u)?e.LINEAR:e.NEAREST;e.texParameteri(a,e.TEXTURE_MIN_FILTER,f),e.texParameteri(a,e.TEXTURE_MAG_FILTER,f),e.texParameteri(a,e.TEXTURE_WRAP_S,e.CLAMP_TO_EDGE),e.texParameteri(a,e.TEXTURE_WRAP_T,e.CLAMP_TO_EDGE)}}function lr(e){return!0===e.auto||void 0===e.auto&&void 0===e.level}function sr(e,r){return(r=r||{}).cubeFaceOrder||[e.TEXTURE_CUBE_MAP_POSITIVE_X,e.TEXTURE_CUBE_MAP_NEGATIVE_X,e.TEXTURE_CUBE_MAP_POSITIVE_Y,e.TEXTURE_CUBE_MAP_NEGATIVE_Y,e.TEXTURE_CUBE_MAP_POSITIVE_Z,e.TEXTURE_CUBE_MAP_NEGATIVE_Z]}function vr(e,r){var t=sr(e,r).map((function(e,r){return{face:e,ndx:r}}));return t.sort((function(e,r){return e.face-r.face})),t}function br(e,r,t,n){var o=(n=n||c.textureOptions).target||e.TEXTURE_2D,u=n.level||0,i=t.width,a=t.height,f=n.internalFormat||n.format||e.RGBA,l=Ve(f),v=n.format||l.format,b=n.type||l.type;if(rr(e,n),e.bindTexture(o,r),o===e.TEXTURE_CUBE_MAP){var y,d,m=t.width,p=t.height;if(m/6===p)y=p,d=[0,0,1,0,2,0,3,0,4,0,5,0];else if(p/6===m)y=m,d=[0,0,0,1,0,2,0,3,0,4,0,5];else if(m/3==p/2)y=m/3,d=[0,0,1,0,2,0,0,1,1,1,2,1];else{if(m/2!=p/3)throw"can't figure out cube map from element: "+(t.src?t.src:t.nodeName);y=m/2,d=[0,0,1,0,0,1,1,1,0,2,1,2]}var x=s();x?(x.canvas.width=y,x.canvas.height=y,i=y,a=y,vr(e,n).forEach((function(r){var n=d[2*r.ndx+0]*y,o=d[2*r.ndx+1]*y;x.drawImage(t,n,o,y,y,0,0,y,y),e.texImage2D(r.face,u,f,v,b,x.canvas)})),x.canvas.width=1,x.canvas.height=1):"undefined"!=typeof createImageBitmap&&(i=y,a=y,vr(e,n).forEach((function(c){var l=d[2*c.ndx+0]*y,s=d[2*c.ndx+1]*y;e.texImage2D(c.face,u,f,y,y,0,v,b,null),createImageBitmap(t,l,s,y,y,{premultiplyAlpha:"none",colorSpaceConversion:"none"}).then((function(t){rr(e,n),e.bindTexture(o,r),e.texImage2D(c.face,u,f,v,b,t),tr(e,n),lr(n)&&cr(e,r,n,i,a,f,b)}))})))}else if(o===e.TEXTURE_3D||o===e.TEXTURE_2D_ARRAY){var w=Math.min(t.width,t.height),h=Math.max(t.width,t.height),F=h/w;if(F%1!=0)throw"can not compute 3D dimensions of element";var E=t.width===h?1:0,A=t.height===h?1:0;nr(e),e.pixelStorei(e.UNPACK_ALIGNMENT,1),e.pixelStorei(e.UNPACK_ROW_LENGTH,t.width),e.pixelStorei(e.UNPACK_IMAGE_HEIGHT,0),e.pixelStorei(e.UNPACK_SKIP_IMAGES,0),e.texImage3D(o,u,f,w,w,w,0,v,b,null);for(var O=0;O=0?w(n,r):t.indexOf("tan")>=0||t.indexOf("binorm")>=0?p(n,r):t.indexOf("norm")>=0&&x(n,r)})),e}function F(e,r,t){return e=e||2,{position:{numComponents:2,data:[(r=r||0)+-1*(e*=.5),(t=t||0)+-1*e,r+1*e,t+-1*e,r+-1*e,t+1*e,r+1*e,t+1*e]},normal:[0,0,1,0,0,1,0,0,1,0,0,1],texcoord:[0,0,1,0,0,1,1,1],indices:[0,1,2,2,1,3]}}function E(e,r,t,n,o){e=e||1,r=r||1,t=t||1,n=n||1,o=o||i.identity();for(var u=(t+1)*(n+1),a=b(3,u),f=b(3,u),c=b(2,u),l=0;l<=n;l++)for(var s=0;s<=t;s++){var v=s/t,y=l/n;a.push(e*v-.5*e,0,r*y-.5*r),f.push(0,1,0),c.push(v,y)}for(var d=t+1,m=b(3,t*n*2,Uint16Array),p=0;p 0");n=n||0,u=u||0;for(var a=(o=o||Math.PI)-n,f=(i=i||2*Math.PI)-u,c=(r+1)*(t+1),l=b(3,c),s=b(3,c),v=b(2,c),y=0;y<=t;y++)for(var d=0;d<=r;d++){var m=d/r,p=y/t,x=f*m+u,w=a*p+n,h=Math.sin(x),F=Math.cos(x),E=Math.sin(w),A=F*E,O=Math.cos(w),_=h*E;l.push(e*A,e*O,e*_),s.push(A,O,_),v.push(1-m,p)}for(var j=r+1,M=b(3,r*t*2,Uint16Array),P=0;Po?(A=t,E=1,O=r):O=e+F/o*(r-e),-2!==F&&F!==o+2||(O=0,E=0),A-=t/2;for(var _=0;_o?0:j*x,F<0?-1:F>o?1:w,F<0||F>o?0:M*x),y.push(_/n,1-E)}}for(var P=0;P 0");var f=2,c=(i=i||1)-(u=u||0),l=2*(o+1)*(2+f),s=b(3,l),v=b(3,l),y=b(2,l);function d(e,r,t){return e+(r-e)*t}function m(r,t,i,l,b,m){for(var p=0;p<=o;p++){var x=t/(f-1),w=p/o,h=2*(x-.5),F=(u+w*c)*Math.PI,E=Math.sin(F),A=Math.cos(F),O=d(e,r,E),_=h*n,j=A*e,M=E*O;s.push(_,j,M);var P=a.add(a.multiply([0,E,A],i),l);v.push(P),y.push(x*b+m,w)}}for(var p=0;p0&&m!==r){var h=l+(m+1),F=l+m,E=l+m-v,A=l+(m+1)-v;c.push(h,F,E),c.push(h,E,A)}}l+=r+1}return{position:i,normal:a,texcoord:f,indices:c}}function U(e){return function(r){var t=e.apply(this,Array.prototype.slice.call(arguments,1));return n.createBuffersFromArrays(r,t)}}function C(e){return function(r){var t=e.apply(null,Array.prototype.slice.call(arguments,1));return n.createBufferInfoFromArrays(r,t)}}var S=["numComponents","size","type","normalize","stride","offset","attrib","name","attribName"];function k(e,r,t,n){n=n||0;for(var o=e.length,u=0;u 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.} 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.} 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(gl.ARRAY_BUFFER, buffer);\n gl.bufferData(gl.ARRAY_BUFFER, numBytes, array.drawType || gl.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(gl.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(gl.ARRAY_BUFFER, attribInfo.buffer);\n gl.bufferSubData(gl.ARRAY_BUFFER, offset, array);\n } else {\n setBufferFromTypedArray(gl, gl.ARRAY_BUFFER, attribInfo.buffer, array, attribInfo.drawType);\n }\n}\n\nfunction getBytesPerValueForGLType(gl, type) {\n if (type === gl.BYTE) return 1; // eslint-disable-line\n if (type === gl.UNSIGNED_BYTE) return 1; // eslint-disable-line\n if (type === gl.SHORT) return 2; // eslint-disable-line\n if (type === gl.UNSIGNED_SHORT) return 2; // eslint-disable-line\n if (type === gl.INT) return 4; // eslint-disable-line\n if (type === gl.UNSIGNED_INT) return 4; // eslint-disable-line\n if (type === gl.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(gl.ARRAY_BUFFER, attrib.buffer);\n const numBytes = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);\n gl.bindBuffer(gl.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.} [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, gl.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\" ? gl.ELEMENT_ARRAY_BUFFER : gl.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} 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\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 ? gl.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 ? gl.UNSIGNED_SHORT : bufferInfo.elementType, offset, instanceCount);\n } else {\n gl.drawElements(type, numElements, elementType === undefined ? gl.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} 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 ? gl.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.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 UNSIGNED_BYTE = 0x1401;\n\n/* PixelFormat */\nconst DEPTH_COMPONENT = 0x1902;\nconst RGBA = 0x1908;\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 REPEAT = 0x2901; // eslint-disable-line\nconst CLAMP_TO_EDGE = 0x812F;\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\nconst LINEAR = 0x2601;\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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} [attach] 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 {WebGLObject} [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 */\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;\n\nfunction getAttachmentPointForFormat(format) {\n return attachmentsByFormat[format];\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 {WebGLObject[]} attachments The created attachments in the same order as passed in to {@link module:twgl.createFramebufferInfo}.\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 = gl.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 = getAttachmentPointForFormat(format);\n if (!attachmentPoint) {\n attachmentPoint = COLOR_ATTACHMENT0 + colorAttachmentCount++;\n }\n if (!attachment) {\n if (isRenderbufferFormat(format)) {\n attachment = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.LINEAR;\n textureOptions.mag = textureOptions.mag || textureOptions.minMag || gl.LINEAR;\n textureOptions.wrapS = textureOptions.wrapS || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n textureOptions.wrapT = textureOptions.wrapT || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n }\n attachment = textures.createTexture(gl, textureOptions);\n }\n }\n if (helper.isRenderbuffer(gl, attachment)) {\n gl.framebufferRenderbuffer(target, attachmentPoint, gl.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.texTarget || gl.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(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.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.} src the source\n * @param {Object.} 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 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 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(gl.TEXTURE0 + unit);\n gl.bindTexture(bindPoint, texture);\n gl.bindSampler(unit, sampler);\n } : function(texture) {\n gl.uniform1i(location, unit);\n gl.activeTexture(gl.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(gl.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(gl.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, };\ntypeMap[FLOAT_VEC3] = { Type: Float32Array, size: 12, setter: floatVec3Setter, };\ntypeMap[FLOAT_VEC4] = { Type: Float32Array, size: 16, setter: floatVec4Setter, };\ntypeMap[INT] = { Type: Int32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[INT_VEC2] = { Type: Int32Array, size: 8, setter: intVec2Setter, };\ntypeMap[INT_VEC3] = { Type: Int32Array, size: 12, setter: intVec3Setter, };\ntypeMap[INT_VEC4] = { Type: Int32Array, size: 16, setter: intVec4Setter, };\ntypeMap[UNSIGNED_INT] = { Type: Uint32Array, size: 4, setter: uintSetter, arraySetter: uintArraySetter, };\ntypeMap[UNSIGNED_INT_VEC2] = { Type: Uint32Array, size: 8, setter: uintVec2Setter, };\ntypeMap[UNSIGNED_INT_VEC3] = { Type: Uint32Array, size: 12, setter: uintVec3Setter, };\ntypeMap[UNSIGNED_INT_VEC4] = { Type: Uint32Array, size: 16, setter: uintVec4Setter, };\ntypeMap[BOOL] = { Type: Uint32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[BOOL_VEC2] = { Type: Uint32Array, size: 8, setter: intVec2Setter, };\ntypeMap[BOOL_VEC3] = { Type: Uint32Array, size: 12, setter: intVec3Setter, };\ntypeMap[BOOL_VEC4] = { Type: Uint32Array, size: 16, setter: intVec4Setter, };\ntypeMap[FLOAT_MAT2] = { Type: Float32Array, size: 16, setter: floatMat2Setter, };\ntypeMap[FLOAT_MAT3] = { Type: Float32Array, size: 36, setter: floatMat3Setter, };\ntypeMap[FLOAT_MAT4] = { Type: Float32Array, size: 64, setter: floatMat4Setter, };\ntypeMap[FLOAT_MAT2x3] = { Type: Float32Array, size: 24, setter: floatMat23Setter, };\ntypeMap[FLOAT_MAT2x4] = { Type: Float32Array, size: 32, setter: floatMat24Setter, };\ntypeMap[FLOAT_MAT3x2] = { Type: Float32Array, size: 24, setter: floatMat32Setter, };\ntypeMap[FLOAT_MAT3x4] = { Type: Float32Array, size: 48, setter: floatMat34Setter, };\ntypeMap[FLOAT_MAT4x2] = { Type: Float32Array, size: 32, setter: floatMat42Setter, };\ntypeMap[FLOAT_MAT4x3] = { Type: Float32Array, size: 48, setter: floatMat43Setter, };\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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n const numComponents = b.size || b.numComponents || defaultSize;\n const size = numComponents / count;\n const type = b.type || gl.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\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\nfunction addLineNumbers(src, lineOffset) {\n lineOffset = lineOffset || 0;\n ++lineOffset;\n\n return src.split(\"\\n\").map(function(line, ndx) {\n return (ndx + lineOffset) + \": \" + line;\n }).join(\"\\n\");\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 // \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, gl.COMPILE_STATUS);\n if (!compiled) {\n // Something went wrong during compilation; get the error\n const lastError = gl.getShaderInfoLog(shader);\n errFn(addLineNumbers(shaderSource, lineOffset) + \"\\n*** Error compiling shader: \" + 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.} [attribLocations] a attribute name to location map\n * @property {(module:twgl.BufferInfo|Object.|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 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 }\n\n const options = {\n errorCallback: opt_errorCallback || error,\n transformFeedbackVaryings: transformFeedbackVaryings,\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 gl.FRAGMENT_SHADER;\n } else if (scriptType.indexOf(\"vert\") >= 0) {\n return gl.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 || gl.SEPARATE_ATTRIBS);\n }\n gl.linkProgram(program);\n\n // Check the link status\n const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n if (!linked) {\n // something went wrong with the link\n const lastError = gl.getProgramInfoLog(program);\n progOptions.errorCallback(\"Error 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\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.} 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) {\n const location = gl.getUniformLocation(program, uniformInfo.name);\n const isArray = (uniformInfo.size > 1 && uniformInfo.name.substr(-3) === \"[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 numUniforms = gl.getProgramParameter(program, gl.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.substr(-3) === \"[0]\") {\n name = name.substr(0, name.length - 3);\n }\n const setter = createUniformSetter(program, uniformInfo);\n uniformSetters[name] = setter;\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}\n * @memberOf module:twgl\n */\nfunction createTransformFeedbackInfo(gl, program) {\n const info = {};\n const numVaryings = gl.getProgramParameter(program, gl.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)} transformFeedbackInfo A ProgramInfo or TransformFeedbackInfo.\n * @param {(module:twgl.BufferInfo|Object)} [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(gl.TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer, buf.offset, buf.size);\n } else {\n gl.bindBufferBase(gl.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)} [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(gl.TRANSFORM_FEEDBACK, tf);\n gl.useProgram(programInfo.program);\n bindTransformFeedbackInfo(gl, programInfo, bufferInfo);\n gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);\n return tf;\n}\n\n/**\n * @typedef {Object} UniformData\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. 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, gl.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 if (isBuiltIn(uniformInfo)) {\n break;\n }\n // REMOVE [0]?\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, gl.ACTIVE_UNIFORM_BLOCKS);\n for (let ii = 0; ii < numUniformBlocks; ++ii) {\n const name = gl.getActiveUniformBlockName(program, ii);\n const blockSpec = {\n index: ii,\n usedByVertexShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n usedByFragmentShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n size: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_DATA_SIZE),\n uniformIndices: gl.getActiveUniformBlockParameter(program, ii, gl.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\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.} 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 * @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(gl.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 blockSpec.uniformIndices.forEach(function(uniformNdx) {\n const data = uniformData[uniformNdx];\n const typeInfo = typeMap[data.type];\n const Type = typeInfo.Type;\n const length = data.size * typeInfo.size;\n let name = data.name;\n if (name.substr(0, prefix.length) === prefix) {\n name = name.substr(prefix.length);\n }\n uniforms[name] = new Type(array, data.offset, length / Type.BYTES_PER_ELEMENT);\n });\n return {\n name: blockName,\n array: array,\n asFloat: new Float32Array(array), // for debugging\n buffer: buffer,\n uniforms: uniforms,\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(gl.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(gl.UNIFORM_BUFFER, uniformBlockInfo.array, gl.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.} 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 * Any name that doesn't match will be ignored\n * @memberOf module:twgl/programs\n */\nfunction setBlockUniforms(uniformBlockInfo, values) {\n const uniforms = uniformBlockInfo.uniforms;\n for (const name in values) {\n const array = uniforms[name];\n if (array) {\n const value = values[name];\n if (value.length) {\n array.set(value);\n } else {\n array[0] = value;\n }\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.)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n * `createUniformSetters`.\n * @param {Object.} 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 * @memberOf module:twgl/programs\n */\nfunction setUniforms(setters, values) { // eslint-disable-line\n const actualSetters = setters.uniformSetters || setters;\n const numArgs = arguments.length;\n for (let aNdx = 1; aNdx < numArgs; ++aNdx) {\n const values = arguments[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 * 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.} 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, gl.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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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.)} 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(gl.ELEMENT_ARRAY_BUFFER, buffers.indices);\n }\n }\n}\n\n/**\n * @typedef {Object} ProgramInfo\n * @property {WebGLProgram} program A shader program\n * @property {Object} uniformSetters object of setters as returned from createUniformSetters,\n * @property {Object} attribSetters object of setters as returned from createAttribSetters,\n * @property {module:twgl.UniformBlockSpec} [uniformBlockSpace] a uniform block spec for making UniformBlockInfos with createUniformBlockInfo etc..\n * @property {Object} [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: program,\n uniformSetters: uniformSetters,\n attribSetters: 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 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?\nlet s_ctx;\nfunction 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// 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 */\nconst REPEAT = 0x2901; // eslint-disable-line\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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.} 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\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 /*, type */) {\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 /*, type */) {\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 || gl.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 === gl.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// NOTE: While querying GL is considered slow it's not remotely as slow\n// as uploading a texture. On top of that you're unlikely to call this in\n// a perf critical loop. Even if upload a texture every frame that's unlikely\n// to be more than 1 or 2 textures a frame. In other words, the benefits of\n// making the API easy to use outweigh any supposed perf benefits\n//\n// Also note I get that having one global of these is bad practice.\n// As long as it's used correctly it means no garbage which probably\n// doesn't matter when dealing with textures but old habits die hard.\nconst lastPackState = {};\n\n/**\n * Saves 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 savePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n lastPackState.colorspaceConversion = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, options.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n lastPackState.premultiplyAlpha = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, options.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n lastPackState.flipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, options.flipY);\n }\n}\n\n/**\n * Restores any packing state that was 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 restorePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, lastPackState.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, lastPackState.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, lastPackState.flipY);\n }\n}\n\n/**\n * Saves state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction saveSkipState(gl) {\n lastPackState.unpackAlignment = gl.getParameter(gl.UNPACK_ALIGNMENT);\n if (utils.isWebGL2(gl)) {\n lastPackState.unpackRowLength = gl.getParameter(gl.UNPACK_ROW_LENGTH);\n lastPackState.unpackImageHeight = gl.getParameter(gl.UNPACK_IMAGE_HEIGHT);\n lastPackState.unpackSkipPixels = gl.getParameter(gl.UNPACK_SKIP_PIXELS);\n lastPackState.unpackSkipRows = gl.getParameter(gl.UNPACK_SKIP_ROWS);\n lastPackState.unpackSkipImages = gl.getParameter(gl.UNPACK_SKIP_IMAGES);\n }\n}\n\n/**\n * Restores state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction restoreSkipState(gl) {\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, lastPackState.unpackAlignment);\n if (utils.isWebGL2(gl)) {\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, lastPackState.unpackRowLength);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, lastPackState.unpackImageHeight);\n gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, lastPackState.unpackSkipPixels);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, lastPackState.unpackSkipRows);\n gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, lastPackState.unpackSkipImages);\n }\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, gl.TEXTURE_MIN_FILTER, options.minMag);\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.minMag);\n }\n if (options.min) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_FILTER, options.min);\n }\n if (options.mag) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.mag);\n }\n if (options.wrap) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrap);\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrap);\n if (target === gl.TEXTURE_3D || helper.isSampler(gl, target)) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrap);\n }\n }\n if (options.wrapR) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrapR);\n }\n if (options.wrapS) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrapS);\n }\n if (options.wrapT) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrapT);\n }\n if (options.minLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_LOD, options.minLod);\n }\n if (options.maxLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAX_LOD, options.maxLod);\n }\n if (options.baseLevel) {\n parameteriFn.call(gl, target, gl.TEXTURE_BASE_LEVEL, options.baseLevel);\n }\n if (options.maxLevel) {\n parameteriFn.call(gl, target, gl.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 || gl.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.} options A object of TextureOptions one per sampler.\n * @return {Object.} 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 * @param {number} [type] The type parameter for texImage2D etc..\n * @memberOf module:twgl/textures\n */\nfunction setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type) {\n options = options || defaults.textureOptions;\n internalFormat = internalFormat || gl.RGBA;\n type = type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n width = width || options.width;\n height = height || options.height;\n gl.bindTexture(target, tex);\n if (canGenerateMipmap(gl, width, height, internalFormat, type)) {\n gl.generateMipmap(target);\n } else {\n const filtering = canFilter(internalFormat, type) ? gl.LINEAR : gl.NEAREST;\n gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 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}\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 || gl.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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n gl.bindTexture(target, tex);\n if (target === gl.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 savePackState(gl, options);\n gl.bindTexture(target, tex);\n gl.texImage2D(f.face, level, internalFormat, format, type, imageBitmap);\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\n }\n });\n });\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, element.width);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0);\n gl.pixelStorei(gl.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(gl.UNPACK_SKIP_PIXELS, srcX);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, srcY);\n gl.texSubImage3D(target, level, 0, 0, d, smallest, smallest, 1, format, type, element);\n }\n restoreSkipState(gl);\n } else {\n gl.texImage2D(target, level, internalFormat, format, type, element);\n }\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.TEXTURE_2D_ARRAY) {\n gl.texImage3D(target, 0, gl.RGBA, 1, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n } else {\n gl.texImage2D(target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.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.} textures the created textures by name. Same as returned by {@link module:twgl.createTextures}.\n * @param {Object.} 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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n if (target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D_ARRAY;\n if (target !== gl.TEXTURE_3D && target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.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 || gl.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 === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, options.unpackAlignment || 1);\n savePackState(gl, options);\n if (target === gl.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 === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n restoreSkipState(gl);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n if (target === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, options.width, options.height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n}\n\n/**\n * Creates a texture based on the options passed in.\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 || gl.TEXTURE_2D;\n let width = options.width || 1;\n let height = options.height || 1;\n const internalFormat = options.internalFormat || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n let type = options.type || formatType.type;\n gl.bindTexture(target, tex);\n if (target === gl.TEXTURE_CUBE_MAP) {\n // this should have been the default for cubemaps :(\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 type = dimensions.type;\n } else if (Array.isArray(src) && (typeof (src[0]) === 'string' || isTexImageSource(src[0]))) {\n if (target === gl.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 } else {\n throw \"unsupported src type\";\n }\n } else {\n setEmptyTexture(gl, tex, options);\n }\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, width, height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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.} 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.} 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","export * from './twgl.js';\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] || (\"0x\" + value.toString(16));\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\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\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 = )` 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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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(gl.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.| 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":""} \ No newline at end of file +{"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/programs.js","webpack://twgl/./src/textures.js","webpack://twgl/./src/twgl-base.js","webpack://twgl/./src/twgl.js","webpack://twgl/./src/typedarrays.js","webpack://twgl/./src/utils.js","webpack://twgl/./src/vertex-arrays.js"],"names":["gl","undefined","defaults","attribPrefix","setAttributePrefix","prefix","setDefaults","newDefaults","helper","copyExistingProperties","setBufferFromTypedArray","type","buffer","array","drawType","bindBuffer","bufferData","STATIC_DRAW","createBufferFromTypedArray","typedArray","isBuffer","ARRAY_BUFFER","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","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","positionKeys","getNumElementsFromNonIndexedArrays","key","ii","numElements","getNumElementsFromAttributes","getBufferParameter","BUFFER_SIZE","bytesPerValue","totalElements","createBufferInfoFromArrays","srcBufferInfo","newAttribs","bufferInfo","assign","indices","newIndices","ELEMENT_ARRAY_BUFFER","elementType","createBufferFromArray","createBuffersFromArrays","buffers","drawBufferInfo","count","instanceCount","TRIANGLES","drawElementsInstanced","drawElements","drawArraysInstanced","drawArrays","drawObjectList","objectsToDraw","lastUsedProgramInfo","lastUsedBufferInfo","object","active","programInfo","vertexArrayInfo","bindBuffers","useProgram","program","vertexArrayObject","bindVertexArray","programs","setBuffersAndAttributes","setUniforms","uniforms","DEPTH_COMPONENT","RGBA","RGBA4","RGB5_A1","RGB565","DEPTH_COMPONENT16","STENCIL_INDEX","STENCIL_INDEX8","DEPTH_STENCIL","COLOR_ATTACHMENT0","DEPTH_ATTACHMENT","STENCIL_ATTACHMENT","DEPTH_STENCIL_ATTACHMENT","REPEAT","CLAMP_TO_EDGE","MIRRORED_REPEAT","NEAREST","LINEAR","NEAREST_MIPMAP_NEAREST","LINEAR_MIPMAP_NEAREST","NEAREST_MIPMAP_LINEAR","LINEAR_MIPMAP_LINEAR","defaultAttachments","format","min","wrap","attachmentsByFormat","getAttachmentPointForFormat","renderbufferFormats","isRenderbufferFormat","createFramebufferInfo","attachments","width","height","target","FRAMEBUFFER","fb","createFramebuffer","bindFramebuffer","drawingBufferWidth","drawingBufferHeight","colorAttachmentCount","framebufferInfo","framebuffer","attachmentOptions","attachment","attachmentPoint","createRenderbuffer","bindRenderbuffer","RENDERBUFFER","renderbufferStorage","textureOptions","auto","minMag","mag","wrapS","wrapT","textures","createTexture","isRenderbuffer","framebufferRenderbuffer","isTexture","layer","framebufferTextureLayer","level","framebufferTexture2D","texTarget","TEXTURE_2D","push","resizeFramebufferInfo","ndx","resizeTexture","bindFramebufferInfo","viewport","copyNamedProperties","names","src","dst","hasOwnProperty","error","console","warn","t","WebGLRenderbuffer","isShader","WebGLShader","WebGLTexture","isSampler","WebGLSampler","getElementById","id","document","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","v","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","TEXTURE0","bindTexture","bindSampler","samplerArraySetter","units","Int32Array","index","setter","arraySetter","Uint32Array","floatAttribSetter","b","disableVertexAttribArray","vertexAttrib4fv","vertexAttrib3fv","vertexAttrib2fv","vertexAttrib1fv","enableVertexAttribArray","vertexAttribPointer","vertexAttribDivisor","intAttribSetter","vertexAttrib4iv","vertexAttribIPointer","uintAttribSetter","vertexAttrib4uiv","matAttribSetter","typeInfo","defaultSize","rowOffset","i","attrTypeMap","addLineNumbers","lineOffset","split","map","line","join","spaceRE","loadShader","shaderSource","shaderType","opt_errorCallback","errFn","shader","createShader","replace","compileShader","compiled","getShaderParameter","COMPILE_STATUS","lastError","getShaderInfoLog","deleteShader","getProgramOptions","opt_attribs","opt_locations","transformFeedbackVaryings","transformFeedbackMode","errorCallback","opt","attribLocations","options","defaultShaderType","getShaderTypeFromScriptType","scriptType","indexOf","FRAGMENT_SHADER","VERTEX_SHADER","deleteShaders","shaders","createProgram","progOptions","realShaders","newShaders","elem","text","attachShader","bindAttribLocation","varyings","SEPARATE_ATTRIBS","linkProgram","linked","getProgramParameter","LINK_STATUS","getProgramInfoLog","deleteProgram","createShaderFromScript","scriptId","opt_shaderType","shaderScript","createProgramFromScripts","shaderScriptIds","createProgramFromSources","shaderSources","isBuiltIn","info","startsWith","createUniformSetters","textureUnit","createUniformSetter","uniformInfo","getUniformLocation","substr","toString","uniformSetters","numUniforms","ACTIVE_UNIFORMS","getActiveUniform","createTransformFeedbackInfo","numVaryings","TRANSFORM_FEEDBACK_VARYINGS","varying","getTransformFeedbackVarying","bindTransformFeedbackInfo","transformFeedbackInfo","buf","bindBufferRange","TRANSFORM_FEEDBACK_BUFFER","bindBufferBase","createTransformFeedback","tf","bindTransformFeedback","TRANSFORM_FEEDBACK","createUniformBlockSpecFromProgram","uniformData","uniformIndices","pair","pname","getActiveUniforms","blockSpecs","numUniformBlocks","ACTIVE_UNIFORM_BLOCKS","getActiveUniformBlockName","blockSpec","usedByVertexShader","getActiveUniformBlockParameter","UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER","usedByFragmentShader","UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER","UNIFORM_BLOCK_DATA_SIZE","UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES","used","arraySuffixRE","createUniformBlockInfoFromProgram","uniformBlockSpec","blockName","ArrayBuffer","uniformBufferIndex","UNIFORM_BUFFER","uniformBlockBinding","uniformNdx","asFloat","createUniformBlockInfo","bindUniformBlock","uniformBlockInfo","bufferBindIndex","byteLength","setUniformBlock","DYNAMIC_DRAW","setBlockUniforms","values","set","setters","actualSetters","numArgs","arguments","aNdx","createAttributeSetters","attribSetters","numAttribs","ACTIVE_ATTRIBUTES","getActiveAttrib","getAttribLocation","setAttributes","createProgramInfoFromProgram","createProgramInfo","good","source","script","textureColor","crossOrigin","s_ctx","getShared2DContext","createElement","getContext","ALPHA","RGB","LUMINANCE","LUMINANCE_ALPHA","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","DEPTH_COMPONENT24","DEPTH_COMPONENT32F","DEPTH32F_STENCIL8","DEPTH24_STENCIL8","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","f","numColorComponents","s_textureInternalFormatInfo","getTextureInternalFormatInfo","internalFormat","textureFormat","colorRenderable","textureFilterable","bytesPerElement","bytesPerElementMap","getBytesPerElementForInternalFormat","getFormatAndTypeForInternalFormat","isPowerOf2","canGenerateMipmap","canFilter","getNumComponentsForFormat","getTextureTypeForArrayType","defaultType","guessDimensions","Math","sqrt","setDefaultTextureColor","color","lastPackState","savePackState","colorspaceConversion","getParameter","UNPACK_COLORSPACE_CONVERSION_WEBGL","pixelStorei","premultiplyAlpha","UNPACK_PREMULTIPLY_ALPHA_WEBGL","flipY","UNPACK_FLIP_Y_WEBGL","restorePackState","saveSkipState","unpackAlignment","UNPACK_ALIGNMENT","unpackRowLength","UNPACK_ROW_LENGTH","unpackImageHeight","UNPACK_IMAGE_HEIGHT","unpackSkipPixels","UNPACK_SKIP_PIXELS","unpackSkipRows","UNPACK_SKIP_ROWS","unpackSkipImages","UNPACK_SKIP_IMAGES","restoreSkipState","setTextureSamplerParameters","parameteriFn","call","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","TEXTURE_WRAP_R","wrapR","minLod","TEXTURE_MIN_LOD","maxLod","TEXTURE_MAX_LOD","baseLevel","TEXTURE_BASE_LEVEL","maxLevel","TEXTURE_MAX_LEVEL","setTextureParameters","tex","texParameteri","setSamplerParameters","samplerParameteri","createSampler","createSamplers","samplerOptions","samplers","make1Pixel","setTextureFilteringForSize","generateMipmap","filtering","shouldAutomaticallySetTextureFilteringForSize","getCubeFaceOrder","cubeFaceOrder","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","getCubeFacesWithNdx","faces","facesWithNdx","face","sort","a","setTextureFromElement","element","formatType","imgWidth","imgHeight","slices","nodeName","ctx","canvas","xOffset","yOffset","drawImage","texImage2D","createImageBitmap","colorSpaceConversion","then","imageBitmap","smallest","largest","max","depth","xMult","yMult","texImage3D","d","srcX","srcY","texSubImage3D","noop","urlIsSameOrigin","url","href","hostname","port","protocol","localOrigin","URL","origin","urlOrigin","setToAnonymousIfUndefinedAndURLIsNotSameOrigin","loadImage","callback","img","Image","clearEventHandlers","removeEventListener","onError","onLoad","msg","addEventListener","ImageBitmap","err","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","slice","s","setTextureFromArray","getTypedArrayTypeForGLType","Uint8ClampedArray","glEnumToString","dimensions","cbrt","elementsPerElement","faceSize","subarray","setEmptyTexture","isAsyncSrc","createTextures","numDownloading","images","callCallbackIfReady","onLoadFn","addExtensionsToContext","attributes","setAttributeDefaults_","setTextureDefaults_","prefixRE","addExtensionToContext","extensionName","ext","getExtension","enums","fnSuffix","exec","enumSuffix","isFunc","suffix","endsWith","substring","origFn","apply","constructor","supportedExtensions","create3DContext","context","getWebGLContext","createContext","resizeCanvasToDisplaySize","multiplier","clientWidth","clientHeight","glTypeToTypedArray","tt","Int16Array","CTOR","SharedArrayBuffer","isArrayBufferOrSharedArrayBuffer","texStorage2D","isWebGL1","haveEnumsForType","addEnums","existing","createVertexArrayInfo","programInfos","vao","createVertexArray","createVAOAndSetAttributes","createVAOFromBufferInfo"],"mappings":"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","file":"twgl.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-base.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\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 || gl.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 || gl.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.} 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.} 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(gl.ARRAY_BUFFER, buffer);\n gl.bufferData(gl.ARRAY_BUFFER, numBytes, array.drawType || gl.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(gl.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(gl.ARRAY_BUFFER, attribInfo.buffer);\n gl.bufferSubData(gl.ARRAY_BUFFER, offset, array);\n } else {\n setBufferFromTypedArray(gl, gl.ARRAY_BUFFER, attribInfo.buffer, array, attribInfo.drawType);\n }\n}\n\nfunction getBytesPerValueForGLType(gl, type) {\n if (type === gl.BYTE) return 1; // eslint-disable-line\n if (type === gl.UNSIGNED_BYTE) return 1; // eslint-disable-line\n if (type === gl.SHORT) return 2; // eslint-disable-line\n if (type === gl.UNSIGNED_SHORT) return 2; // eslint-disable-line\n if (type === gl.INT) return 4; // eslint-disable-line\n if (type === gl.UNSIGNED_INT) return 4; // eslint-disable-line\n if (type === gl.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(gl.ARRAY_BUFFER, attrib.buffer);\n const numBytes = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);\n gl.bindBuffer(gl.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.} [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, gl.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\" ? gl.ELEMENT_ARRAY_BUFFER : gl.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} 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\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 ? gl.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 ? gl.UNSIGNED_SHORT : bufferInfo.elementType, offset, instanceCount);\n } else {\n gl.drawElements(type, numElements, elementType === undefined ? gl.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} 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 ? gl.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.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 UNSIGNED_BYTE = 0x1401;\n\n/* PixelFormat */\nconst DEPTH_COMPONENT = 0x1902;\nconst RGBA = 0x1908;\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 REPEAT = 0x2901; // eslint-disable-line\nconst CLAMP_TO_EDGE = 0x812F;\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\nconst LINEAR = 0x2601;\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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} [attach] 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 {WebGLObject} [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;\n\nfunction getAttachmentPointForFormat(format) {\n return attachmentsByFormat[format];\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 {WebGLObject[]} attachments The created attachments in the same order as passed in to {@link module:twgl.createFramebufferInfo}.\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 = gl.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 = getAttachmentPointForFormat(format);\n if (!attachmentPoint) {\n attachmentPoint = COLOR_ATTACHMENT0 + colorAttachmentCount++;\n }\n if (!attachment) {\n if (isRenderbufferFormat(format)) {\n attachment = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.LINEAR;\n textureOptions.mag = textureOptions.mag || textureOptions.minMag || gl.LINEAR;\n textureOptions.wrapS = textureOptions.wrapS || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n textureOptions.wrapT = textureOptions.wrapT || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n }\n attachment = textures.createTexture(gl, textureOptions);\n }\n }\n if (helper.isRenderbuffer(gl, attachment)) {\n gl.framebufferRenderbuffer(target, attachmentPoint, gl.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.texTarget || gl.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(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.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.} src the source\n * @param {Object.} 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 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 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(gl.TEXTURE0 + unit);\n gl.bindTexture(bindPoint, texture);\n gl.bindSampler(unit, sampler);\n } : function(texture) {\n gl.uniform1i(location, unit);\n gl.activeTexture(gl.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(gl.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(gl.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, };\ntypeMap[FLOAT_VEC3] = { Type: Float32Array, size: 12, setter: floatVec3Setter, };\ntypeMap[FLOAT_VEC4] = { Type: Float32Array, size: 16, setter: floatVec4Setter, };\ntypeMap[INT] = { Type: Int32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[INT_VEC2] = { Type: Int32Array, size: 8, setter: intVec2Setter, };\ntypeMap[INT_VEC3] = { Type: Int32Array, size: 12, setter: intVec3Setter, };\ntypeMap[INT_VEC4] = { Type: Int32Array, size: 16, setter: intVec4Setter, };\ntypeMap[UNSIGNED_INT] = { Type: Uint32Array, size: 4, setter: uintSetter, arraySetter: uintArraySetter, };\ntypeMap[UNSIGNED_INT_VEC2] = { Type: Uint32Array, size: 8, setter: uintVec2Setter, };\ntypeMap[UNSIGNED_INT_VEC3] = { Type: Uint32Array, size: 12, setter: uintVec3Setter, };\ntypeMap[UNSIGNED_INT_VEC4] = { Type: Uint32Array, size: 16, setter: uintVec4Setter, };\ntypeMap[BOOL] = { Type: Uint32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[BOOL_VEC2] = { Type: Uint32Array, size: 8, setter: intVec2Setter, };\ntypeMap[BOOL_VEC3] = { Type: Uint32Array, size: 12, setter: intVec3Setter, };\ntypeMap[BOOL_VEC4] = { Type: Uint32Array, size: 16, setter: intVec4Setter, };\ntypeMap[FLOAT_MAT2] = { Type: Float32Array, size: 16, setter: floatMat2Setter, };\ntypeMap[FLOAT_MAT3] = { Type: Float32Array, size: 36, setter: floatMat3Setter, };\ntypeMap[FLOAT_MAT4] = { Type: Float32Array, size: 64, setter: floatMat4Setter, };\ntypeMap[FLOAT_MAT2x3] = { Type: Float32Array, size: 24, setter: floatMat23Setter, };\ntypeMap[FLOAT_MAT2x4] = { Type: Float32Array, size: 32, setter: floatMat24Setter, };\ntypeMap[FLOAT_MAT3x2] = { Type: Float32Array, size: 24, setter: floatMat32Setter, };\ntypeMap[FLOAT_MAT3x4] = { Type: Float32Array, size: 48, setter: floatMat34Setter, };\ntypeMap[FLOAT_MAT4x2] = { Type: Float32Array, size: 32, setter: floatMat42Setter, };\ntypeMap[FLOAT_MAT4x3] = { Type: Float32Array, size: 48, setter: floatMat43Setter, };\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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n const numComponents = b.size || b.numComponents || defaultSize;\n const size = numComponents / count;\n const type = b.type || gl.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\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\nfunction addLineNumbers(src, lineOffset) {\n lineOffset = lineOffset || 0;\n ++lineOffset;\n\n return src.split(\"\\n\").map(function(line, ndx) {\n return (ndx + lineOffset) + \": \" + line;\n }).join(\"\\n\");\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 // \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, gl.COMPILE_STATUS);\n if (!compiled) {\n // Something went wrong during compilation; get the error\n const lastError = gl.getShaderInfoLog(shader);\n errFn(addLineNumbers(shaderSource, lineOffset) + \"\\n*** Error compiling shader: \" + 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.} [attribLocations] a attribute name to location map\n * @property {(module:twgl.BufferInfo|Object.|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 gl.FRAGMENT_SHADER;\n } else if (scriptType.indexOf(\"vert\") >= 0) {\n return gl.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 || gl.SEPARATE_ATTRIBS);\n }\n gl.linkProgram(program);\n\n // Check the link status\n const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n if (!linked) {\n // something went wrong with the link\n const lastError = gl.getProgramInfoLog(program);\n progOptions.errorCallback(\"Error 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\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.} 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) {\n const location = gl.getUniformLocation(program, uniformInfo.name);\n const isArray = (uniformInfo.size > 1 && uniformInfo.name.substr(-3) === \"[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 numUniforms = gl.getProgramParameter(program, gl.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.substr(-3) === \"[0]\") {\n name = name.substr(0, name.length - 3);\n }\n const setter = createUniformSetter(program, uniformInfo);\n uniformSetters[name] = setter;\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}\n * @memberOf module:twgl\n */\nfunction createTransformFeedbackInfo(gl, program) {\n const info = {};\n const numVaryings = gl.getProgramParameter(program, gl.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)} transformFeedbackInfo A ProgramInfo or TransformFeedbackInfo.\n * @param {(module:twgl.BufferInfo|Object)} [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(gl.TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer, buf.offset, buf.size);\n } else {\n gl.bindBufferBase(gl.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)} [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(gl.TRANSFORM_FEEDBACK, tf);\n gl.useProgram(programInfo.program);\n bindTransformFeedbackInfo(gl, programInfo, bufferInfo);\n gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);\n return tf;\n}\n\n/**\n * @typedef {Object} UniformData\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. 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, gl.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 if (isBuiltIn(uniformInfo)) {\n break;\n }\n // REMOVE [0]?\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, gl.ACTIVE_UNIFORM_BLOCKS);\n for (let ii = 0; ii < numUniformBlocks; ++ii) {\n const name = gl.getActiveUniformBlockName(program, ii);\n const blockSpec = {\n index: ii,\n usedByVertexShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n usedByFragmentShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n size: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_DATA_SIZE),\n uniformIndices: gl.getActiveUniformBlockParameter(program, ii, gl.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\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.} 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 * @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(gl.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 blockSpec.uniformIndices.forEach(function(uniformNdx) {\n const data = uniformData[uniformNdx];\n const typeInfo = typeMap[data.type];\n const Type = typeInfo.Type;\n const length = data.size * typeInfo.size;\n let name = data.name;\n if (name.substr(0, prefix.length) === prefix) {\n name = name.substr(prefix.length);\n }\n uniforms[name] = new Type(array, data.offset, length / Type.BYTES_PER_ELEMENT);\n });\n return {\n name: blockName,\n array: array,\n asFloat: new Float32Array(array), // for debugging\n buffer: buffer,\n uniforms: uniforms,\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(gl.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(gl.UNIFORM_BUFFER, uniformBlockInfo.array, gl.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.} 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 * Any name that doesn't match will be ignored\n * @memberOf module:twgl/programs\n */\nfunction setBlockUniforms(uniformBlockInfo, values) {\n const uniforms = uniformBlockInfo.uniforms;\n for (const name in values) {\n const array = uniforms[name];\n if (array) {\n const value = values[name];\n if (value.length) {\n array.set(value);\n } else {\n array[0] = value;\n }\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.)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n * `createUniformSetters`.\n * @param {Object.} 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 * @memberOf module:twgl/programs\n */\nfunction setUniforms(setters, values) { // eslint-disable-line\n const actualSetters = setters.uniformSetters || setters;\n const numArgs = arguments.length;\n for (let aNdx = 1; aNdx < numArgs; ++aNdx) {\n const values = arguments[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 * 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.} 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, gl.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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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.)} 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(gl.ELEMENT_ARRAY_BUFFER, buffers.indices);\n }\n }\n}\n\n/**\n * @typedef {Object} ProgramInfo\n * @property {WebGLProgram} program A shader program\n * @property {Object} uniformSetters object of setters as returned from createUniformSetters,\n * @property {Object} attribSetters object of setters as returned from createAttribSetters,\n * @property {module:twgl.UniformBlockSpec} [uniformBlockSpace] a uniform block spec for making UniformBlockInfos with createUniformBlockInfo etc..\n * @property {Object} [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: program,\n uniformSetters: uniformSetters,\n attribSetters: 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 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?\nlet s_ctx;\nfunction 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// 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 */\nconst REPEAT = 0x2901; // eslint-disable-line\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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.} 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\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 /*, type */) {\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 /*, type */) {\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 || gl.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 === gl.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// NOTE: While querying GL is considered slow it's not remotely as slow\n// as uploading a texture. On top of that you're unlikely to call this in\n// a perf critical loop. Even if upload a texture every frame that's unlikely\n// to be more than 1 or 2 textures a frame. In other words, the benefits of\n// making the API easy to use outweigh any supposed perf benefits\n//\n// Also note I get that having one global of these is bad practice.\n// As long as it's used correctly it means no garbage which probably\n// doesn't matter when dealing with textures but old habits die hard.\nconst lastPackState = {};\n\n/**\n * Saves 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 savePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n lastPackState.colorspaceConversion = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, options.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n lastPackState.premultiplyAlpha = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, options.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n lastPackState.flipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, options.flipY);\n }\n}\n\n/**\n * Restores any packing state that was 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 restorePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, lastPackState.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, lastPackState.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, lastPackState.flipY);\n }\n}\n\n/**\n * Saves state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction saveSkipState(gl) {\n lastPackState.unpackAlignment = gl.getParameter(gl.UNPACK_ALIGNMENT);\n if (utils.isWebGL2(gl)) {\n lastPackState.unpackRowLength = gl.getParameter(gl.UNPACK_ROW_LENGTH);\n lastPackState.unpackImageHeight = gl.getParameter(gl.UNPACK_IMAGE_HEIGHT);\n lastPackState.unpackSkipPixels = gl.getParameter(gl.UNPACK_SKIP_PIXELS);\n lastPackState.unpackSkipRows = gl.getParameter(gl.UNPACK_SKIP_ROWS);\n lastPackState.unpackSkipImages = gl.getParameter(gl.UNPACK_SKIP_IMAGES);\n }\n}\n\n/**\n * Restores state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction restoreSkipState(gl) {\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, lastPackState.unpackAlignment);\n if (utils.isWebGL2(gl)) {\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, lastPackState.unpackRowLength);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, lastPackState.unpackImageHeight);\n gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, lastPackState.unpackSkipPixels);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, lastPackState.unpackSkipRows);\n gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, lastPackState.unpackSkipImages);\n }\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, gl.TEXTURE_MIN_FILTER, options.minMag);\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.minMag);\n }\n if (options.min) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_FILTER, options.min);\n }\n if (options.mag) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.mag);\n }\n if (options.wrap) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrap);\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrap);\n if (target === gl.TEXTURE_3D || helper.isSampler(gl, target)) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrap);\n }\n }\n if (options.wrapR) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrapR);\n }\n if (options.wrapS) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrapS);\n }\n if (options.wrapT) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrapT);\n }\n if (options.minLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_LOD, options.minLod);\n }\n if (options.maxLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAX_LOD, options.maxLod);\n }\n if (options.baseLevel) {\n parameteriFn.call(gl, target, gl.TEXTURE_BASE_LEVEL, options.baseLevel);\n }\n if (options.maxLevel) {\n parameteriFn.call(gl, target, gl.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 || gl.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.} options A object of TextureOptions one per sampler.\n * @return {Object.} 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 * @param {number} [type] The type parameter for texImage2D etc..\n * @memberOf module:twgl/textures\n */\nfunction setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type) {\n options = options || defaults.textureOptions;\n internalFormat = internalFormat || gl.RGBA;\n type = type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n width = width || options.width;\n height = height || options.height;\n gl.bindTexture(target, tex);\n if (canGenerateMipmap(gl, width, height, internalFormat, type)) {\n gl.generateMipmap(target);\n } else {\n const filtering = canFilter(internalFormat, type) ? gl.LINEAR : gl.NEAREST;\n gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 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}\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 || gl.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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n gl.bindTexture(target, tex);\n if (target === gl.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 savePackState(gl, options);\n gl.bindTexture(target, tex);\n gl.texImage2D(f.face, level, internalFormat, format, type, imageBitmap);\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\n }\n });\n });\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, element.width);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0);\n gl.pixelStorei(gl.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(gl.UNPACK_SKIP_PIXELS, srcX);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, srcY);\n gl.texSubImage3D(target, level, 0, 0, d, smallest, smallest, 1, format, type, element);\n }\n restoreSkipState(gl);\n } else {\n gl.texImage2D(target, level, internalFormat, format, type, element);\n }\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.TEXTURE_2D_ARRAY) {\n gl.texImage3D(target, 0, gl.RGBA, 1, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n } else {\n gl.texImage2D(target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.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.} textures the created textures by name. Same as returned by {@link module:twgl.createTextures}.\n * @param {Object.} 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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n if (target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D_ARRAY;\n if (target !== gl.TEXTURE_3D && target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.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 || gl.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 === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, options.unpackAlignment || 1);\n savePackState(gl, options);\n if (target === gl.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 === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n restoreSkipState(gl);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n if (target === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, options.width, options.height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n}\n\n/**\n * Creates a texture based on the options passed in.\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 || gl.TEXTURE_2D;\n let width = options.width || 1;\n let height = options.height || 1;\n const internalFormat = options.internalFormat || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n let type = options.type || formatType.type;\n gl.bindTexture(target, tex);\n if (target === gl.TEXTURE_CUBE_MAP) {\n // this should have been the default for cubemaps :(\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 type = dimensions.type;\n } else if (Array.isArray(src) && (typeof (src[0]) === 'string' || isTexImageSource(src[0]))) {\n if (target === gl.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 } else {\n throw \"unsupported src type\";\n }\n } else {\n setEmptyTexture(gl, tex, options);\n }\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, width, height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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.} 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.} 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","export * from './twgl.js';\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] || (\"0x\" + value.toString(16));\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\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\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 = )` 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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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(gl.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.| 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":""} \ No newline at end of file diff --git a/dist/4.x/twgl.min.js b/dist/4.x/twgl.min.js index 9ea9454..61dcfd5 100644 --- a/dist/4.x/twgl.min.js +++ b/dist/4.x/twgl.min.js @@ -1,6 +1,6 @@ /*! - * @license twgl.js 4.13.0 Copyright (c) 2015, Gregg Tavares All Rights Reserved. + * @license twgl.js 4.13.1 Copyright (c) 2015, Gregg Tavares All Rights Reserved. * Available via the MIT license. * see: http://github.com/greggman/twgl.js for details */ -!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.twgl=t():e.twgl=t()}("undefined"!=typeof self?self:this,(function(){return function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=5)}([function(e,t,r){"use strict";t.__esModule=!0,t.copyExistingProperties=function(e,t){Object.keys(t).forEach((function(r){t.hasOwnProperty(r)&&e.hasOwnProperty(r)&&(t[r]=e[r])}))},t.copyNamedProperties=function(e,t,r){e.forEach((function(e){var n=t[e];void 0!==n&&(r[e]=n)}))},t.error=function(){var e;(e=console).error.apply(e,arguments)},t.warn=function(){var e;(e=console).warn.apply(e,arguments)},t.isBuffer=function(e,t){return"undefined"!=typeof WebGLBuffer&&t instanceof WebGLBuffer},t.isRenderbuffer=function(e,t){return"undefined"!=typeof WebGLRenderbuffer&&t instanceof WebGLRenderbuffer},t.isShader=function(e,t){return"undefined"!=typeof WebGLShader&&t instanceof WebGLShader},t.isTexture=function(e,t){return"undefined"!=typeof WebGLTexture&&t instanceof WebGLTexture},t.isSampler=function(e,t){return"undefined"!=typeof WebGLSampler&&t instanceof WebGLSampler}},function(e,t,r){"use strict";t.__esModule=!0,t.getGLTypeForTypedArray=function(e){if(e instanceof Int8Array)return n;if(e instanceof Uint8Array)return o;if(e instanceof Uint8ClampedArray)return o;if(e instanceof Int16Array)return u;if(e instanceof Uint16Array)return i;if(e instanceof Int32Array)return a;if(e instanceof Uint32Array)return f;if(e instanceof Float32Array)return l;throw new Error("unsupported typed array type")},t.getGLTypeForTypedArrayType=function(e){if(e===Int8Array)return n;if(e===Uint8Array)return o;if(e===Uint8ClampedArray)return o;if(e===Int16Array)return u;if(e===Uint16Array)return i;if(e===Int32Array)return a;if(e===Uint32Array)return f;if(e===Float32Array)return l;throw new Error("unsupported typed array type")},t.getTypedArrayTypeForGLType=function(e){var t=c[e];if(!t)throw new Error("unknown gl type");return t},t.isArrayBuffer=void 0;var n=5120,o=5121,u=5122,i=5123,a=5124,f=5125,l=5126,c={},s=c;s[n]=Int8Array,s[o]=Uint8Array,s[u]=Int16Array,s[i]=Uint16Array,s[a]=Int32Array,s[f]=Uint32Array,s[l]=Float32Array,s[32819]=Uint16Array,s[32820]=Uint16Array,s[33635]=Uint16Array,s[5131]=Uint16Array,s[33640]=Uint32Array,s[35899]=Uint32Array,s[35902]=Uint32Array,s[36269]=Uint32Array,s[34042]=Uint32Array;var y="undefined"!=typeof SharedArrayBuffer?function(e){return e&&e.buffer&&(e.buffer instanceof ArrayBuffer||e.buffer instanceof SharedArrayBuffer)}:function(e){return e&&e.buffer&&e.buffer instanceof ArrayBuffer};t.isArrayBuffer=y},function(e,t,r){"use strict";t.__esModule=!0,t.isWebGL1=function(e){return!e.texStorage2D},t.isWebGL2=function(e){return!!e.texStorage2D},t.glEnumToString=void 0;var n,o,u=(n={},o={},function(e,t){return function(e){var t=e.constructor.name;if(!n[t]){for(var r in e)if("number"==typeof e[r]){var u=o[e[r]];o[e[r]]=u?"".concat(u," | ").concat(r):r}n[t]=!0}}(e),o[t]||"0x"+t.toString(16)});t.glEnumToString=u},function(e,t,r){"use strict";t.__esModule=!0,t.createAttributeSetters=G,t.createProgram=z,t.createProgramFromScripts=function(e,t,r,n,o){for(var u=j(r,n,o),i=[],a=0;a=0?e.FRAGMENT_SHADER:t.indexOf("vert")>=0?e.VERTEX_SHADER:void 0}function T(e,t){t.forEach((function(t){e.deleteShader(t)}))}function z(e,t,r,n,u){for(var i=j(r,n,u),a=[],f=[],c=0;c1&&"[0]"===n.name.substr(-3),a=n.type,f=c[a];if(!f)throw new Error("unknown type: 0x".concat(a.toString(16)));if(f.bindPoint){var l=r;r+=n.size,o=i?f.arraySetter(e,a,l,u,n.size):f.setter(e,a,l,u,n.size)}else o=f.arraySetter&&i?f.arraySetter(e,u):f.setter(e,u);return o.location=u,o}for(var o={},u=e.getProgramParameter(t,e.ACTIVE_UNIFORMS),i=0;i0)throw new Error("numComponents ".concat(u," not correct for length ").concat(o));return i}(t);return r},t.createBufferFromArray=F,t.createBufferFromTypedArray=l,t.createBufferInfoFromArrays=function(e,t,r){var o=p(e,t),u=Object.assign({},r||{});u.attribs=Object.assign({},r?r.attribs:{},o);var i=t.indices;if(i){var f=d(i,"indices");u.indices=l(e,f,e.ELEMENT_ARRAY_BUFFER),u.numElements=f.length,u.elementType=n.getGLTypeForTypedArray(f)}else u.numElements||(u.numElements=function(e,t){var r,n;for(n=0;n0)throw new Error("Can not guess numComponents for attribute '".concat(e,"'. Tried ").concat(r," but ").concat(t," values is not evenly divisible by ").concat(r,". You should specify it."));return r}function m(e,t){return e.numComponents||e.size||v(t,s(e).length)}function d(e,t){if(n.isArrayBuffer(e))return e;if(n.isArrayBuffer(e.data))return e.data;Array.isArray(e)&&(e={data:e});var r=e.type;return r||(r=c(t)?Uint16Array:Float32Array),new r(e.data)}function p(e,t){var r={};return Object.keys(t).forEach((function(o){if(!c(o)){var u=t[o],i=u.attrib||u.name||u.attribName||a.attribPrefix+o;if(u.value){if(!Array.isArray(u.value)&&!n.isArrayBuffer(u.value))throw new Error("array.value is not array or typedarray");r[i]={value:u.value}}else{var f,s,y,b;if(u.buffer&&u.buffer instanceof WebGLBuffer)f=u.buffer,b=u.numComponents||u.size,s=u.type,y=u.normalize;else if("number"==typeof u||"number"==typeof u.data){var p=u.data||u,x=u.type||Float32Array,F=p*x.BYTES_PER_ELEMENT;s=n.getGLTypeForTypedArrayType(x),y=void 0!==u.normalize?u.normalize:(_=x)===Int8Array||_===Uint8Array,b=u.numComponents||u.size||v(o,p),f=e.createBuffer(),e.bindBuffer(e.ARRAY_BUFFER,f),e.bufferData(e.ARRAY_BUFFER,F,u.drawType||e.STATIC_DRAW)}else{var E=d(u,o);f=l(e,E,void 0,u.drawType),s=n.getGLTypeForTypedArray(E),y=void 0!==u.normalize?u.normalize:function(e){return e instanceof Int8Array||e instanceof Uint8Array}(E),b=m(u,o)}r[i]={buffer:f,numComponents:b,type:s,normalize:y,stride:u.stride||0,offset:u.offset||0,divisor:void 0===u.divisor?void 0:u.divisor,drawType:u.drawType}}}var _})),e.bindBuffer(e.ARRAY_BUFFER,null),r}var x=["position","positions","a_position"];function F(e,t,r){var n="indices"===r?e.ELEMENT_ARRAY_BUFFER:e.ARRAY_BUFFER;return l(e,d(t,r),n)}},function(e,t,r){"use strict";t.__esModule=!0,t.drawBufferInfo=u,t.drawObjectList=function(e,t){var r=null,o=null;t.forEach((function(t){if(!1!==t.active){var i=t.programInfo,a=t.vertexArrayInfo||t.bufferInfo,f=!1,l=void 0===t.type?e.TRIANGLES:t.type;i!==r&&(r=i,e.useProgram(i.program),f=!0),(f||a!==o)&&(o&&o.vertexArrayObject&&!a.vertexArrayObject&&e.bindVertexArray(null),o=a,n.setBuffersAndAttributes(e,i,a)),n.setUniforms(i,t.uniforms),u(e,a,l,t.count,t.offset,t.instanceCount)}})),o.vertexArrayObject&&e.bindVertexArray(null)};var n=function(e){if(e&&e.__esModule)return e;var t=o();if(t&&t.has(e))return t.get(e);var r={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if(Object.prototype.hasOwnProperty.call(e,u)){var i=n?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(r,u,i):r[u]=e[u]}}r.default=e,t&&t.set(e,r);return r}(r(3));function o(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return o=function(){return e},e}function u(e,t,r,n,o,u){r=void 0===r?e.TRIANGLES:r;var i=t.indices,a=t.elementType,f=void 0===n?t.numElements:n;o=void 0===o?0:o,a||i?void 0!==u?e.drawElementsInstanced(r,f,void 0===a?e.UNSIGNED_SHORT:t.elementType,o,u):e.drawElements(r,f,void 0===a?e.UNSIGNED_SHORT:t.elementType,o):void 0!==u?e.drawArraysInstanced(r,o,f,u):e.drawArrays(r,o,f)}},function(e,t,r){"use strict";t.__esModule=!0,t.bindFramebufferInfo=function(e,t,r){r=r||e.FRAMEBUFFER,t?(e.bindFramebuffer(r,t.framebuffer),e.viewport(0,0,t.width,t.height)):(e.bindFramebuffer(r,null),e.viewport(0,0,e.drawingBufferWidth,e.drawingBufferHeight))},t.createFramebufferInfo=function(e,t,r,u){var i=e.FRAMEBUFFER,s=e.createFramebuffer();e.bindFramebuffer(i,s),r=r||e.drawingBufferWidth,u=u||e.drawingBufferHeight;var y=0,b={framebuffer:s,attachments:[],width:r,height:u};return(t=t||f).forEach((function(t){var f=t.attachment,s=t.format,v=function(e){return l[e]}(s);if(v||(v=a+y++),!f)if(function(e){return c[e]}(s))f=e.createRenderbuffer(),e.bindRenderbuffer(e.RENDERBUFFER,f),e.renderbufferStorage(e.RENDERBUFFER,s,r,u);else{var m=Object.assign({},t);m.width=r,m.height=u,void 0===m.auto&&(m.auto=!1,m.min=m.min||m.minMag||e.LINEAR,m.mag=m.mag||m.minMag||e.LINEAR,m.wrapS=m.wrapS||m.wrap||e.CLAMP_TO_EDGE,m.wrapT=m.wrapT||m.wrap||e.CLAMP_TO_EDGE),f=n.createTexture(e,m)}if(o.isRenderbuffer(e,f))e.framebufferRenderbuffer(i,v,e.RENDERBUFFER,f);else{if(!o.isTexture(e,f))throw new Error("unknown attachment type");void 0!==t.layer?e.framebufferTextureLayer(i,v,f,t.level||0,t.layer):e.framebufferTexture2D(i,v,t.texTarget||e.TEXTURE_2D,f,t.level||0)}b.attachments.push(f)})),b},t.resizeFramebufferInfo=function(e,t,r,u,i){u=u||e.drawingBufferWidth,i=i||e.drawingBufferHeight,t.width=u,t.height=i,(r=r||f).forEach((function(r,a){var f=t.attachments[a],l=r.format;if(o.isRenderbuffer(e,f))e.bindRenderbuffer(e.RENDERBUFFER,f),e.renderbufferStorage(e.RENDERBUFFER,l,u,i);else{if(!o.isTexture(e,f))throw new Error("unknown attachment type");n.resizeTexture(e,f,r,u,i)}}))};var n=i(r(4)),o=i(r(0));function u(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return u=function(){return e},e}function i(e){if(e&&e.__esModule)return e;var t=u();if(t&&t.has(e))return t.get(e);var r={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var o in e)if(Object.prototype.hasOwnProperty.call(e,o)){var i=n?Object.getOwnPropertyDescriptor(e,o):null;i&&(i.get||i.set)?Object.defineProperty(r,o,i):r[o]=e[o]}}return r.default=e,t&&t.set(e,r),r}var a=36064,f=[{format:6408,type:5121,min:9729,wrap:33071},{format:34041}],l={};l[34041]=33306,l[6401]=36128,l[36168]=36128,l[6402]=36096,l[33189]=36096;var c={};c[32854]=!0,c[32855]=!0,c[36194]=!0,c[34041]=!0,c[33189]=!0,c[6401]=!0,c[36168]=!0},function(e,t,r){"use strict";t.__esModule=!0,t.createVertexArrayInfo=function(e,t,r){var o=e.createVertexArray();e.bindVertexArray(o),t.length||(t=[t]);return t.forEach((function(t){n.setBuffersAndAttributes(e,t,r)})),e.bindVertexArray(null),{numElements:r.numElements,elementType:r.elementType,vertexArrayObject:o}},t.createVAOAndSetAttributes=u,t.createVAOFromBufferInfo=function(e,t,r){return u(e,t.attribSetters||t,r.attribs,r.indices)};var n=function(e){if(e&&e.__esModule)return e;var t=o();if(t&&t.has(e))return t.get(e);var r={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if(Object.prototype.hasOwnProperty.call(e,u)){var i=n?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(r,u,i):r[u]=e[u]}}r.default=e,t&&t.set(e,r);return r}(r(3));function o(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return o=function(){return e},e}function u(e,t,r,o){var u=e.createVertexArray();return e.bindVertexArray(u),n.setAttributes(t,r),o&&e.bindBuffer(e.ELEMENT_ARRAY_BUFFER,o),e.bindVertexArray(null),u}}])})); \ No newline at end of file +!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.twgl=t():e.twgl=t()}("undefined"!=typeof self?self:this,(function(){return function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=5)}([function(e,t,r){"use strict";t.__esModule=!0,t.copyExistingProperties=function(e,t){Object.keys(t).forEach((function(r){t.hasOwnProperty(r)&&e.hasOwnProperty(r)&&(t[r]=e[r])}))},t.copyNamedProperties=function(e,t,r){e.forEach((function(e){var n=t[e];void 0!==n&&(r[e]=n)}))},t.error=function(){var e;(e=console).error.apply(e,arguments)},t.warn=function(){var e;(e=console).warn.apply(e,arguments)},t.isBuffer=function(e,t){return"undefined"!=typeof WebGLBuffer&&t instanceof WebGLBuffer},t.isRenderbuffer=function(e,t){return"undefined"!=typeof WebGLRenderbuffer&&t instanceof WebGLRenderbuffer},t.isShader=function(e,t){return"undefined"!=typeof WebGLShader&&t instanceof WebGLShader},t.isTexture=function(e,t){return"undefined"!=typeof WebGLTexture&&t instanceof WebGLTexture},t.isSampler=function(e,t){return"undefined"!=typeof WebGLSampler&&t instanceof WebGLSampler}},function(e,t,r){"use strict";t.__esModule=!0,t.getGLTypeForTypedArray=function(e){if(e instanceof Int8Array)return n;if(e instanceof Uint8Array)return o;if(e instanceof Uint8ClampedArray)return o;if(e instanceof Int16Array)return u;if(e instanceof Uint16Array)return i;if(e instanceof Int32Array)return a;if(e instanceof Uint32Array)return f;if(e instanceof Float32Array)return l;throw new Error("unsupported typed array type")},t.getGLTypeForTypedArrayType=function(e){if(e===Int8Array)return n;if(e===Uint8Array)return o;if(e===Uint8ClampedArray)return o;if(e===Int16Array)return u;if(e===Uint16Array)return i;if(e===Int32Array)return a;if(e===Uint32Array)return f;if(e===Float32Array)return l;throw new Error("unsupported typed array type")},t.getTypedArrayTypeForGLType=function(e){var t=c[e];if(!t)throw new Error("unknown gl type");return t},t.isArrayBuffer=void 0;var n=5120,o=5121,u=5122,i=5123,a=5124,f=5125,l=5126,c={},s=c;s[n]=Int8Array,s[o]=Uint8Array,s[u]=Int16Array,s[i]=Uint16Array,s[a]=Int32Array,s[f]=Uint32Array,s[l]=Float32Array,s[32819]=Uint16Array,s[32820]=Uint16Array,s[33635]=Uint16Array,s[5131]=Uint16Array,s[33640]=Uint32Array,s[35899]=Uint32Array,s[35902]=Uint32Array,s[36269]=Uint32Array,s[34042]=Uint32Array;var y="undefined"!=typeof SharedArrayBuffer?function(e){return e&&e.buffer&&(e.buffer instanceof ArrayBuffer||e.buffer instanceof SharedArrayBuffer)}:function(e){return e&&e.buffer&&e.buffer instanceof ArrayBuffer};t.isArrayBuffer=y},function(e,t,r){"use strict";t.__esModule=!0,t.isWebGL1=function(e){return!e.texStorage2D},t.isWebGL2=function(e){return!!e.texStorage2D},t.glEnumToString=void 0;var n,o,u=(n={},o={},function(e,t){return function(e){var t=e.constructor.name;if(!n[t]){for(var r in e)if("number"==typeof e[r]){var u=o[e[r]];o[e[r]]=u?"".concat(u," | ").concat(r):r}n[t]=!0}}(e),o[t]||"0x"+t.toString(16)});t.glEnumToString=u},function(e,t,r){"use strict";t.__esModule=!0,t.createAttributeSetters=G,t.createProgram=z,t.createProgramFromScripts=function(e,t,r,n,o){for(var u=j(r,n,o),i=[],a=0;a=0?e.FRAGMENT_SHADER:t.indexOf("vert")>=0?e.VERTEX_SHADER:void 0}function T(e,t){t.forEach((function(t){e.deleteShader(t)}))}function z(e,t,r,n,u){for(var i=j(r,n,u),a=[],f=[],c=0;c1&&"[0]"===n.name.substr(-3),a=n.type,f=c[a];if(!f)throw new Error("unknown type: 0x".concat(a.toString(16)));if(f.bindPoint){var l=r;r+=n.size,o=i?f.arraySetter(e,a,l,u,n.size):f.setter(e,a,l,u,n.size)}else o=f.arraySetter&&i?f.arraySetter(e,u):f.setter(e,u);return o.location=u,o}for(var o={},u=e.getProgramParameter(t,e.ACTIVE_UNIFORMS),i=0;i0)throw new Error("numComponents ".concat(u," not correct for length ").concat(o));return i}(t);return r},t.createBufferFromArray=F,t.createBufferFromTypedArray=l,t.createBufferInfoFromArrays=function(e,t,r){var o=p(e,t),u=Object.assign({},r||{});u.attribs=Object.assign({},r?r.attribs:{},o);var i=t.indices;if(i){var f=d(i,"indices");u.indices=l(e,f,e.ELEMENT_ARRAY_BUFFER),u.numElements=f.length,u.elementType=n.getGLTypeForTypedArray(f)}else u.numElements||(u.numElements=function(e,t){var r,n;for(n=0;n0)throw new Error("Can not guess numComponents for attribute '".concat(e,"'. Tried ").concat(r," but ").concat(t," values is not evenly divisible by ").concat(r,". You should specify it."));return r}function m(e,t){return e.numComponents||e.size||v(t,s(e).length)}function d(e,t){if(n.isArrayBuffer(e))return e;if(n.isArrayBuffer(e.data))return e.data;Array.isArray(e)&&(e={data:e});var r=e.type;return r||(r=c(t)?Uint16Array:Float32Array),new r(e.data)}function p(e,t){var r={};return Object.keys(t).forEach((function(o){if(!c(o)){var u=t[o],i=u.attrib||u.name||u.attribName||a.attribPrefix+o;if(u.value){if(!Array.isArray(u.value)&&!n.isArrayBuffer(u.value))throw new Error("array.value is not array or typedarray");r[i]={value:u.value}}else{var f,s,y,b;if(u.buffer&&u.buffer instanceof WebGLBuffer)f=u.buffer,b=u.numComponents||u.size,s=u.type,y=u.normalize;else if("number"==typeof u||"number"==typeof u.data){var p=u.data||u,x=u.type||Float32Array,F=p*x.BYTES_PER_ELEMENT;s=n.getGLTypeForTypedArrayType(x),y=void 0!==u.normalize?u.normalize:(_=x)===Int8Array||_===Uint8Array,b=u.numComponents||u.size||v(o,p),f=e.createBuffer(),e.bindBuffer(e.ARRAY_BUFFER,f),e.bufferData(e.ARRAY_BUFFER,F,u.drawType||e.STATIC_DRAW)}else{var E=d(u,o);f=l(e,E,void 0,u.drawType),s=n.getGLTypeForTypedArray(E),y=void 0!==u.normalize?u.normalize:function(e){return e instanceof Int8Array||e instanceof Uint8Array}(E),b=m(u,o)}r[i]={buffer:f,numComponents:b,type:s,normalize:y,stride:u.stride||0,offset:u.offset||0,divisor:void 0===u.divisor?void 0:u.divisor,drawType:u.drawType}}}var _})),e.bindBuffer(e.ARRAY_BUFFER,null),r}var x=["position","positions","a_position"];function F(e,t,r){var n="indices"===r?e.ELEMENT_ARRAY_BUFFER:e.ARRAY_BUFFER;return l(e,d(t,r),n)}},function(e,t,r){"use strict";t.__esModule=!0,t.drawBufferInfo=u,t.drawObjectList=function(e,t){var r=null,o=null;t.forEach((function(t){if(!1!==t.active){var i=t.programInfo,a=t.vertexArrayInfo||t.bufferInfo,f=!1,l=void 0===t.type?e.TRIANGLES:t.type;i!==r&&(r=i,e.useProgram(i.program),f=!0),(f||a!==o)&&(o&&o.vertexArrayObject&&!a.vertexArrayObject&&e.bindVertexArray(null),o=a,n.setBuffersAndAttributes(e,i,a)),n.setUniforms(i,t.uniforms),u(e,a,l,t.count,t.offset,t.instanceCount)}})),o.vertexArrayObject&&e.bindVertexArray(null)};var n=function(e){if(e&&e.__esModule)return e;var t=o();if(t&&t.has(e))return t.get(e);var r={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if(Object.prototype.hasOwnProperty.call(e,u)){var i=n?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(r,u,i):r[u]=e[u]}}r.default=e,t&&t.set(e,r);return r}(r(3));function o(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return o=function(){return e},e}function u(e,t,r,n,o,u){r=void 0===r?e.TRIANGLES:r;var i=t.indices,a=t.elementType,f=void 0===n?t.numElements:n;o=void 0===o?0:o,a||i?void 0!==u?e.drawElementsInstanced(r,f,void 0===a?e.UNSIGNED_SHORT:t.elementType,o,u):e.drawElements(r,f,void 0===a?e.UNSIGNED_SHORT:t.elementType,o):void 0!==u?e.drawArraysInstanced(r,o,f,u):e.drawArrays(r,o,f)}},function(e,t,r){"use strict";t.__esModule=!0,t.bindFramebufferInfo=function(e,t,r){r=r||e.FRAMEBUFFER,t?(e.bindFramebuffer(r,t.framebuffer),e.viewport(0,0,t.width,t.height)):(e.bindFramebuffer(r,null),e.viewport(0,0,e.drawingBufferWidth,e.drawingBufferHeight))},t.createFramebufferInfo=function(e,t,r,u){var i=e.FRAMEBUFFER,s=e.createFramebuffer();e.bindFramebuffer(i,s),r=r||e.drawingBufferWidth,u=u||e.drawingBufferHeight;var y=0,b={framebuffer:s,attachments:[],width:r,height:u};return(t=t||f).forEach((function(t){var f=t.attachment,s=t.format,v=function(e){return l[e]}(s);if(v||(v=a+y++),!f)if(function(e){return c[e]}(s))f=e.createRenderbuffer(),e.bindRenderbuffer(e.RENDERBUFFER,f),e.renderbufferStorage(e.RENDERBUFFER,s,r,u);else{var m=Object.assign({},t);m.width=r,m.height=u,void 0===m.auto&&(m.auto=!1,m.min=m.min||m.minMag||e.LINEAR,m.mag=m.mag||m.minMag||e.LINEAR,m.wrapS=m.wrapS||m.wrap||e.CLAMP_TO_EDGE,m.wrapT=m.wrapT||m.wrap||e.CLAMP_TO_EDGE),f=n.createTexture(e,m)}if(o.isRenderbuffer(e,f))e.framebufferRenderbuffer(i,v,e.RENDERBUFFER,f);else{if(!o.isTexture(e,f))throw new Error("unknown attachment type");void 0!==t.layer?e.framebufferTextureLayer(i,v,f,t.level||0,t.layer):e.framebufferTexture2D(i,v,t.texTarget||e.TEXTURE_2D,f,t.level||0)}b.attachments.push(f)})),b},t.resizeFramebufferInfo=function(e,t,r,u,i){u=u||e.drawingBufferWidth,i=i||e.drawingBufferHeight,t.width=u,t.height=i,(r=r||f).forEach((function(r,a){var f=t.attachments[a],l=r.format;if(o.isRenderbuffer(e,f))e.bindRenderbuffer(e.RENDERBUFFER,f),e.renderbufferStorage(e.RENDERBUFFER,l,u,i);else{if(!o.isTexture(e,f))throw new Error("unknown attachment type");n.resizeTexture(e,f,r,u,i)}}))};var n=i(r(4)),o=i(r(0));function u(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return u=function(){return e},e}function i(e){if(e&&e.__esModule)return e;var t=u();if(t&&t.has(e))return t.get(e);var r={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var o in e)if(Object.prototype.hasOwnProperty.call(e,o)){var i=n?Object.getOwnPropertyDescriptor(e,o):null;i&&(i.get||i.set)?Object.defineProperty(r,o,i):r[o]=e[o]}}return r.default=e,t&&t.set(e,r),r}var a=36064,f=[{format:6408,type:5121,min:9729,wrap:33071},{format:34041}],l={};l[34041]=33306,l[6401]=36128,l[36168]=36128,l[6402]=36096,l[33189]=36096;var c={};c[32854]=!0,c[32855]=!0,c[36194]=!0,c[34041]=!0,c[33189]=!0,c[6401]=!0,c[36168]=!0},function(e,t,r){"use strict";t.__esModule=!0,t.createVertexArrayInfo=function(e,t,r){var o=e.createVertexArray();e.bindVertexArray(o),t.length||(t=[t]);return t.forEach((function(t){n.setBuffersAndAttributes(e,t,r)})),e.bindVertexArray(null),{numElements:r.numElements,elementType:r.elementType,vertexArrayObject:o}},t.createVAOAndSetAttributes=u,t.createVAOFromBufferInfo=function(e,t,r){return u(e,t.attribSetters||t,r.attribs,r.indices)};var n=function(e){if(e&&e.__esModule)return e;var t=o();if(t&&t.has(e))return t.get(e);var r={};if(null!=e){var n=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if(Object.prototype.hasOwnProperty.call(e,u)){var i=n?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(r,u,i):r[u]=e[u]}}r.default=e,t&&t.set(e,r);return r}(r(3));function o(){if("function"!=typeof WeakMap)return null;var e=new WeakMap;return o=function(){return e},e}function u(e,t,r,o){var u=e.createVertexArray();return e.bindVertexArray(u),n.setAttributes(t,r),o&&e.bindBuffer(e.ELEMENT_ARRAY_BUFFER,o),e.bindVertexArray(null),u}}])})); \ No newline at end of file diff --git a/docs/module-twgl.html b/docs/module-twgl.html index ecfab9e..044b259 100644 --- a/docs/module-twgl.html +++ b/docs/module-twgl.html @@ -7461,6 +7461,14 @@ attachments across framebuffers.

+
Mixes In:
+ +
+ diff --git a/examples/js/browserified-example.js b/examples/js/browserified-example.js index 408a242..0b9b366 100644 --- a/examples/js/browserified-example.js +++ b/examples/js/browserified-example.js @@ -22,7 +22,7 @@ chroma.brewer=brewer={OrRd:["#fff7ec","#fee8c8","#fdd49e","#fdbb84","#fc8d59","#ef6548","#d7301f","#b30000","#7f0000"],PuBu:["#fff7fb","#ece7f2","#d0d1e6","#a6bddb","#74a9cf","#3690c0","#0570b0","#045a8d","#023858"],BuPu:["#f7fcfd","#e0ecf4","#bfd3e6","#9ebcda","#8c96c6","#8c6bb1","#88419d","#810f7c","#4d004b"],Oranges:["#fff5eb","#fee6ce","#fdd0a2","#fdae6b","#fd8d3c","#f16913","#d94801","#a63603","#7f2704"],BuGn:["#f7fcfd","#e5f5f9","#ccece6","#99d8c9","#66c2a4","#41ae76","#238b45","#006d2c","#00441b"],YlOrBr:["#ffffe5","#fff7bc","#fee391","#fec44f","#fe9929","#ec7014","#cc4c02","#993404","#662506"],YlGn:["#ffffe5","#f7fcb9","#d9f0a3","#addd8e","#78c679","#41ab5d","#238443","#006837","#004529"],Reds:["#fff5f0","#fee0d2","#fcbba1","#fc9272","#fb6a4a","#ef3b2c","#cb181d","#a50f15","#67000d"],RdPu:["#fff7f3","#fde0dd","#fcc5c0","#fa9fb5","#f768a1","#dd3497","#ae017e","#7a0177","#49006a"],Greens:["#f7fcf5","#e5f5e0","#c7e9c0","#a1d99b","#74c476","#41ab5d","#238b45","#006d2c","#00441b"],YlGnBu:["#ffffd9","#edf8b1","#c7e9b4","#7fcdbb","#41b6c4","#1d91c0","#225ea8","#253494","#081d58"],Purples:["#fcfbfd","#efedf5","#dadaeb","#bcbddc","#9e9ac8","#807dba","#6a51a3","#54278f","#3f007d"],GnBu:["#f7fcf0","#e0f3db","#ccebc5","#a8ddb5","#7bccc4","#4eb3d3","#2b8cbe","#0868ac","#084081"],Greys:["#ffffff","#f0f0f0","#d9d9d9","#bdbdbd","#969696","#737373","#525252","#252525","#000000"],YlOrRd:["#ffffcc","#ffeda0","#fed976","#feb24c","#fd8d3c","#fc4e2a","#e31a1c","#bd0026","#800026"],PuRd:["#f7f4f9","#e7e1ef","#d4b9da","#c994c7","#df65b0","#e7298a","#ce1256","#980043","#67001f"],Blues:["#f7fbff","#deebf7","#c6dbef","#9ecae1","#6baed6","#4292c6","#2171b5","#08519c","#08306b"],PuBuGn:["#fff7fb","#ece2f0","#d0d1e6","#a6bddb","#67a9cf","#3690c0","#02818a","#016c59","#014636"],Spectral:["#9e0142","#d53e4f","#f46d43","#fdae61","#fee08b","#ffffbf","#e6f598","#abdda4","#66c2a5","#3288bd","#5e4fa2"],RdYlGn:["#a50026","#d73027","#f46d43","#fdae61","#fee08b","#ffffbf","#d9ef8b","#a6d96a","#66bd63","#1a9850","#006837"],RdBu:["#67001f","#b2182b","#d6604d","#f4a582","#fddbc7","#f7f7f7","#d1e5f0","#92c5de","#4393c3","#2166ac","#053061"],PiYG:["#8e0152","#c51b7d","#de77ae","#f1b6da","#fde0ef","#f7f7f7","#e6f5d0","#b8e186","#7fbc41","#4d9221","#276419"],PRGn:["#40004b","#762a83","#9970ab","#c2a5cf","#e7d4e8","#f7f7f7","#d9f0d3","#a6dba0","#5aae61","#1b7837","#00441b"],RdYlBu:["#a50026","#d73027","#f46d43","#fdae61","#fee090","#ffffbf","#e0f3f8","#abd9e9","#74add1","#4575b4","#313695"],BrBG:["#543005","#8c510a","#bf812d","#dfc27d","#f6e8c3","#f5f5f5","#c7eae5","#80cdc1","#35978f","#01665e","#003c30"],RdGy:["#67001f","#b2182b","#d6604d","#f4a582","#fddbc7","#ffffff","#e0e0e0","#bababa","#878787","#4d4d4d","#1a1a1a"],PuOr:["#7f3b08","#b35806","#e08214","#fdb863","#fee0b6","#f7f7f7","#d8daeb","#b2abd2","#8073ac","#542788","#2d004b"],Set2:["#66c2a5","#fc8d62","#8da0cb","#e78ac3","#a6d854","#ffd92f","#e5c494","#b3b3b3"],Accent:["#7fc97f","#beaed4","#fdc086","#ffff99","#386cb0","#f0027f","#bf5b17","#666666"],Set1:["#e41a1c","#377eb8","#4daf4a","#984ea3","#ff7f00","#ffff33","#a65628","#f781bf","#999999"],Set3:["#8dd3c7","#ffffb3","#bebada","#fb8072","#80b1d3","#fdb462","#b3de69","#fccde5","#d9d9d9","#bc80bd","#ccebc5","#ffed6f"],Dark2:["#1b9e77","#d95f02","#7570b3","#e7298a","#66a61e","#e6ab02","#a6761d","#666666"],Paired:["#a6cee3","#1f78b4","#b2df8a","#33a02c","#fb9a99","#e31a1c","#fdbf6f","#ff7f00","#cab2d6","#6a3d9a","#ffff99","#b15928"],Pastel2:["#b3e2cd","#fdcdac","#cbd5e8","#f4cae4","#e6f5c9","#fff2ae","#f1e2cc","#cccccc"],Pastel1:["#fbb4ae","#b3cde3","#ccebc5","#decbe4","#fed9a6","#ffffcc","#e5d8bd","#fddaec","#f2f2f2"]};chroma.colors=colors={indigo:"#4b0082",gold:"#ffd700",hotpink:"#ff69b4",firebrick:"#b22222",indianred:"#cd5c5c",yellow:"#ffff00",mistyrose:"#ffe4e1",darkolivegreen:"#556b2f",olive:"#808000",darkseagreen:"#8fbc8f",pink:"#ffc0cb",tomato:"#ff6347",lightcoral:"#f08080",orangered:"#ff4500",navajowhite:"#ffdead",lime:"#00ff00",palegreen:"#98fb98",darkslategrey:"#2f4f4f",greenyellow:"#adff2f",burlywood:"#deb887",seashell:"#fff5ee",mediumspringgreen:"#00fa9a",fuchsia:"#ff00ff",papayawhip:"#ffefd5",blanchedalmond:"#ffebcd",chartreuse:"#7fff00",dimgray:"#696969",black:"#000000",peachpuff:"#ffdab9",springgreen:"#00ff7f",aquamarine:"#7fffd4",white:"#ffffff",orange:"#ffa500",lightsalmon:"#ffa07a",darkslategray:"#2f4f4f",brown:"#a52a2a",ivory:"#fffff0",dodgerblue:"#1e90ff",peru:"#cd853f",lawngreen:"#7cfc00",chocolate:"#d2691e",crimson:"#dc143c",forestgreen:"#228b22",darkgrey:"#a9a9a9",lightseagreen:"#20b2aa",cyan:"#00ffff",mintcream:"#f5fffa",silver:"#c0c0c0",antiquewhite:"#faebd7",mediumorchid:"#ba55d3",skyblue:"#87ceeb",gray:"#808080",darkturquoise:"#00ced1",goldenrod:"#daa520",darkgreen:"#006400",floralwhite:"#fffaf0",darkviolet:"#9400d3",darkgray:"#a9a9a9",moccasin:"#ffe4b5",saddlebrown:"#8b4513",grey:"#808080",darkslateblue:"#483d8b",lightskyblue:"#87cefa",lightpink:"#ffb6c1",mediumvioletred:"#c71585",slategrey:"#708090",red:"#ff0000",deeppink:"#ff1493",limegreen:"#32cd32",darkmagenta:"#8b008b",palegoldenrod:"#eee8aa",plum:"#dda0dd",turquoise:"#40e0d0",lightgrey:"#d3d3d3",lightgoldenrodyellow:"#fafad2",darkgoldenrod:"#b8860b",lavender:"#e6e6fa",maroon:"#800000",yellowgreen:"#9acd32",sandybrown:"#f4a460",thistle:"#d8bfd8",violet:"#ee82ee",navy:"#000080",magenta:"#ff00ff",dimgrey:"#696969",tan:"#d2b48c",rosybrown:"#bc8f8f",olivedrab:"#6b8e23",blue:"#0000ff",lightblue:"#add8e6",ghostwhite:"#f8f8ff",honeydew:"#f0fff0",cornflowerblue:"#6495ed",slateblue:"#6a5acd",linen:"#faf0e6",darkblue:"#00008b",powderblue:"#b0e0e6",seagreen:"#2e8b57",darkkhaki:"#bdb76b",snow:"#fffafa",sienna:"#a0522d",mediumblue:"#0000cd",royalblue:"#4169e1",lightcyan:"#e0ffff",green:"#008000",mediumpurple:"#9370db",midnightblue:"#191970",cornsilk:"#fff8dc",paleturquoise:"#afeeee",bisque:"#ffe4c4",slategray:"#708090",darkcyan:"#008b8b",khaki:"#f0e68c",wheat:"#f5deb3",teal:"#008080",darkorchid:"#9932cc",deepskyblue:"#00bfff",salmon:"#fa8072",darkred:"#8b0000",steelblue:"#4682b4",palevioletred:"#db7093",lightslategray:"#778899",aliceblue:"#f0f8ff",lightslategrey:"#778899",lightgreen:"#90ee90",orchid:"#da70d6",gainsboro:"#dcdcdc",mediumseagreen:"#3cb371",lightgray:"#d3d3d3",mediumturquoise:"#48d1cc",lemonchiffon:"#fffacd",cadetblue:"#5f9ea0",lightyellow:"#ffffe0",lavenderblush:"#fff0f5",coral:"#ff7f50",purple:"#800080",aqua:"#00ffff",whitesmoke:"#f5f5f5",mediumslateblue:"#7b68ee",darkorange:"#ff8c00",mediumaquamarine:"#66cdaa",darksalmon:"#e9967a",beige:"#f5f5dc",blueviolet:"#8a2be2",azure:"#f0ffff",lightsteelblue:"#b0c4de",oldlace:"#fdf5e6"};type=function(){var classToType,name,_i,_len,_ref1;classToType={};_ref1="Boolean Number String Function Array Date RegExp Undefined Null".split(" ");for(_i=0,_len=_ref1.length;_i<_len;_i++){name=_ref1[_i];classToType["[object "+name+"]"]=name.toLowerCase()}return function(obj){var strType;strType=Object.prototype.toString.call(obj);return classToType[strType]||"object"}}();limit=function(x,min,max){if(min==null){min=0}if(max==null){max=1}if(xmax){x=max}return x};unpack=function(args){if(args.length>=3){return args}else{return args[0]}};TWOPI=Math.PI*2;PITHIRD=Math.PI/3;cos=Math.cos;bezier=function(colors){var I,I0,I1,c,lab0,lab1,lab2,lab3,_ref1,_ref2,_ref3;colors=function(){var _i,_len,_results;_results=[];for(_i=0,_len=colors.length;_i<_len;_i++){c=colors[_i];_results.push(chroma(c))}return _results}();if(colors.length===2){_ref1=function(){var _i,_len,_results;_results=[];for(_i=0,_len=colors.length;_i<_len;_i++){c=colors[_i];_results.push(c.lab())}return _results}(),lab0=_ref1[0],lab1=_ref1[1];I=function(t){var i,lab;lab=function(){var _i,_results;_results=[];for(i=_i=0;_i<=2;i=++_i){_results.push(lab0[i]+t*(lab1[i]-lab0[i]))}return _results}();return chroma.lab.apply(chroma,lab)}}else if(colors.length===3){_ref2=function(){var _i,_len,_results;_results=[];for(_i=0,_len=colors.length;_i<_len;_i++){c=colors[_i];_results.push(c.lab())}return _results}(),lab0=_ref2[0],lab1=_ref2[1],lab2=_ref2[2];I=function(t){var i,lab;lab=function(){var _i,_results;_results=[];for(i=_i=0;_i<=2;i=++_i){_results.push((1-t)*(1-t)*lab0[i]+2*(1-t)*t*lab1[i]+t*t*lab2[i])}return _results}();return chroma.lab.apply(chroma,lab)}}else if(colors.length===4){_ref3=function(){var _i,_len,_results;_results=[];for(_i=0,_len=colors.length;_i<_len;_i++){c=colors[_i];_results.push(c.lab())}return _results}(),lab0=_ref3[0],lab1=_ref3[1],lab2=_ref3[2],lab3=_ref3[3];I=function(t){var i,lab;lab=function(){var _i,_results;_results=[];for(i=_i=0;_i<=2;i=++_i){_results.push((1-t)*(1-t)*(1-t)*lab0[i]+3*(1-t)*(1-t)*t*lab1[i]+3*(1-t)*t*t*lab2[i]+t*t*t*lab3[i])}return _results}();return chroma.lab.apply(chroma,lab)}}else if(colors.length===5){I0=bezier(colors.slice(0,3));I1=bezier(colors.slice(2,5));I=function(t){if(t<.5){return I0(t*2)}else{return I1((t-.5)*2)}}}return I};chroma.interpolate.bezier=bezier}.call(this); },{}],2:[function(require,module,exports){ /*! - * @license twgl.js 4.13.0 Copyright (c) 2015, Gregg Tavares All Rights Reserved. + * @license twgl.js 4.13.1 Copyright (c) 2015, Gregg Tavares All Rights Reserved. * Available via the MIT license. * see: http://github.com/greggman/twgl.js for details */ @@ -1215,6 +1215,7 @@ var LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line * If provided will attach this Object. This allows you to share * attachments across framebuffers. * @memberOf module:twgl + * @mixes module:twgl.TextureOptions */ var defaultAttachments = [{ @@ -5483,6 +5484,7 @@ function loadShader(gl, shaderSource, shaderType, opt_errorCallback) { function getProgramOptions(opt_attribs, opt_locations, opt_errorCallback) { var transformFeedbackVaryings; + var transformFeedbackMode; if (typeof opt_locations === 'function') { opt_errorCallback = opt_locations; @@ -5503,11 +5505,13 @@ function getProgramOptions(opt_attribs, opt_locations, opt_errorCallback) { opt_errorCallback = opt.errorCallback; opt_attribs = opt.attribLocations; transformFeedbackVaryings = opt.transformFeedbackVaryings; + transformFeedbackMode = opt.transformFeedbackMode; } var options = { errorCallback: opt_errorCallback || error, - transformFeedbackVaryings: transformFeedbackVaryings + transformFeedbackVaryings: transformFeedbackVaryings, + transformFeedbackMode: transformFeedbackMode }; if (opt_attribs) { diff --git a/index.html b/index.html index 3032568..3683978 100644 --- a/index.html +++ b/index.html @@ -1,7 +1,7 @@ diff --git a/npm/base/dist/4.x/twgl.js b/npm/base/dist/4.x/twgl.js index 098c06b..55243cd 100644 --- a/npm/base/dist/4.x/twgl.js +++ b/npm/base/dist/4.x/twgl.js @@ -1,5 +1,5 @@ /*! - * @license twgl.js 4.13.0 Copyright (c) 2015, Gregg Tavares All Rights Reserved. + * @license twgl.js 4.13.1 Copyright (c) 2015, Gregg Tavares All Rights Reserved. * Available via the MIT license. * see: http://github.com/greggman/twgl.js for details */ @@ -1192,6 +1192,7 @@ var LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line * If provided will attach this Object. This allows you to share * attachments across framebuffers. * @memberOf module:twgl + * @mixes module:twgl.TextureOptions */ var defaultAttachments = [{ @@ -2400,6 +2401,7 @@ function loadShader(gl, shaderSource, shaderType, opt_errorCallback) { function getProgramOptions(opt_attribs, opt_locations, opt_errorCallback) { var transformFeedbackVaryings; + var transformFeedbackMode; if (typeof opt_locations === 'function') { opt_errorCallback = opt_locations; @@ -2420,11 +2422,13 @@ function getProgramOptions(opt_attribs, opt_locations, opt_errorCallback) { opt_errorCallback = opt.errorCallback; opt_attribs = opt.attribLocations; transformFeedbackVaryings = opt.transformFeedbackVaryings; + transformFeedbackMode = opt.transformFeedbackMode; } var options = { errorCallback: opt_errorCallback || error, - transformFeedbackVaryings: transformFeedbackVaryings + transformFeedbackVaryings: transformFeedbackVaryings, + transformFeedbackMode: transformFeedbackMode }; if (opt_attribs) { diff --git a/npm/base/dist/4.x/twgl.js.map b/npm/base/dist/4.x/twgl.js.map index 95e6cc1..ad754f1 100644 --- a/npm/base/dist/4.x/twgl.js.map +++ b/npm/base/dist/4.x/twgl.js.map @@ -1 +1 @@ -{"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/programs.js","webpack://twgl/./src/textures.js","webpack://twgl/./src/twgl-base.js","webpack://twgl/./src/twgl.js","webpack://twgl/./src/typedarrays.js","webpack://twgl/./src/utils.js","webpack://twgl/./src/vertex-arrays.js"],"names":["gl","undefined","defaults","attribPrefix","setAttributePrefix","prefix","setDefaults","newDefaults","helper","copyExistingProperties","setBufferFromTypedArray","type","buffer","array","drawType","bindBuffer","bufferData","STATIC_DRAW","createBufferFromTypedArray","typedArray","isBuffer","ARRAY_BUFFER","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","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","positionKeys","getNumElementsFromNonIndexedArrays","key","ii","numElements","getNumElementsFromAttributes","getBufferParameter","BUFFER_SIZE","bytesPerValue","totalElements","createBufferInfoFromArrays","srcBufferInfo","newAttribs","bufferInfo","assign","indices","newIndices","ELEMENT_ARRAY_BUFFER","elementType","createBufferFromArray","createBuffersFromArrays","buffers","drawBufferInfo","count","instanceCount","TRIANGLES","drawElementsInstanced","drawElements","drawArraysInstanced","drawArrays","drawObjectList","objectsToDraw","lastUsedProgramInfo","lastUsedBufferInfo","object","active","programInfo","vertexArrayInfo","bindBuffers","useProgram","program","vertexArrayObject","bindVertexArray","programs","setBuffersAndAttributes","setUniforms","uniforms","DEPTH_COMPONENT","RGBA","RGBA4","RGB5_A1","RGB565","DEPTH_COMPONENT16","STENCIL_INDEX","STENCIL_INDEX8","DEPTH_STENCIL","COLOR_ATTACHMENT0","DEPTH_ATTACHMENT","STENCIL_ATTACHMENT","DEPTH_STENCIL_ATTACHMENT","REPEAT","CLAMP_TO_EDGE","MIRRORED_REPEAT","NEAREST","LINEAR","NEAREST_MIPMAP_NEAREST","LINEAR_MIPMAP_NEAREST","NEAREST_MIPMAP_LINEAR","LINEAR_MIPMAP_LINEAR","defaultAttachments","format","min","wrap","attachmentsByFormat","getAttachmentPointForFormat","renderbufferFormats","isRenderbufferFormat","createFramebufferInfo","attachments","width","height","target","FRAMEBUFFER","fb","createFramebuffer","bindFramebuffer","drawingBufferWidth","drawingBufferHeight","colorAttachmentCount","framebufferInfo","framebuffer","attachmentOptions","attachment","attachmentPoint","createRenderbuffer","bindRenderbuffer","RENDERBUFFER","renderbufferStorage","textureOptions","auto","minMag","mag","wrapS","wrapT","textures","createTexture","isRenderbuffer","framebufferRenderbuffer","isTexture","layer","framebufferTextureLayer","level","framebufferTexture2D","texTarget","TEXTURE_2D","push","resizeFramebufferInfo","ndx","resizeTexture","bindFramebufferInfo","viewport","copyNamedProperties","names","src","dst","hasOwnProperty","error","console","warn","t","WebGLRenderbuffer","isShader","WebGLShader","WebGLTexture","isSampler","WebGLSampler","getElementById","id","document","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","v","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","TEXTURE0","bindTexture","bindSampler","samplerArraySetter","units","Int32Array","index","setter","arraySetter","Uint32Array","floatAttribSetter","b","disableVertexAttribArray","vertexAttrib4fv","vertexAttrib3fv","vertexAttrib2fv","vertexAttrib1fv","enableVertexAttribArray","vertexAttribPointer","vertexAttribDivisor","intAttribSetter","vertexAttrib4iv","vertexAttribIPointer","uintAttribSetter","vertexAttrib4uiv","matAttribSetter","typeInfo","defaultSize","rowOffset","i","attrTypeMap","addLineNumbers","lineOffset","split","map","line","join","spaceRE","loadShader","shaderSource","shaderType","opt_errorCallback","errFn","shader","createShader","replace","compileShader","compiled","getShaderParameter","COMPILE_STATUS","lastError","getShaderInfoLog","deleteShader","getProgramOptions","opt_attribs","opt_locations","transformFeedbackVaryings","errorCallback","opt","attribLocations","options","defaultShaderType","getShaderTypeFromScriptType","scriptType","indexOf","FRAGMENT_SHADER","VERTEX_SHADER","deleteShaders","shaders","createProgram","progOptions","realShaders","newShaders","elem","text","attachShader","bindAttribLocation","varyings","transformFeedbackMode","SEPARATE_ATTRIBS","linkProgram","linked","getProgramParameter","LINK_STATUS","getProgramInfoLog","deleteProgram","createShaderFromScript","scriptId","opt_shaderType","shaderScript","createProgramFromScripts","shaderScriptIds","createProgramFromSources","shaderSources","isBuiltIn","info","startsWith","createUniformSetters","textureUnit","createUniformSetter","uniformInfo","getUniformLocation","substr","toString","uniformSetters","numUniforms","ACTIVE_UNIFORMS","getActiveUniform","createTransformFeedbackInfo","numVaryings","TRANSFORM_FEEDBACK_VARYINGS","varying","getTransformFeedbackVarying","bindTransformFeedbackInfo","transformFeedbackInfo","buf","bindBufferRange","TRANSFORM_FEEDBACK_BUFFER","bindBufferBase","createTransformFeedback","tf","bindTransformFeedback","TRANSFORM_FEEDBACK","createUniformBlockSpecFromProgram","uniformData","uniformIndices","pair","pname","getActiveUniforms","blockSpecs","numUniformBlocks","ACTIVE_UNIFORM_BLOCKS","getActiveUniformBlockName","blockSpec","usedByVertexShader","getActiveUniformBlockParameter","UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER","usedByFragmentShader","UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER","UNIFORM_BLOCK_DATA_SIZE","UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES","used","arraySuffixRE","createUniformBlockInfoFromProgram","uniformBlockSpec","blockName","ArrayBuffer","uniformBufferIndex","UNIFORM_BUFFER","uniformBlockBinding","uniformNdx","asFloat","createUniformBlockInfo","bindUniformBlock","uniformBlockInfo","bufferBindIndex","byteLength","setUniformBlock","DYNAMIC_DRAW","setBlockUniforms","values","set","setters","actualSetters","numArgs","arguments","aNdx","createAttributeSetters","attribSetters","numAttribs","ACTIVE_ATTRIBUTES","getActiveAttrib","getAttribLocation","setAttributes","createProgramInfoFromProgram","createProgramInfo","good","source","script","textureColor","crossOrigin","s_ctx","getShared2DContext","createElement","getContext","ALPHA","RGB","LUMINANCE","LUMINANCE_ALPHA","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","DEPTH_COMPONENT24","DEPTH_COMPONENT32F","DEPTH32F_STENCIL8","DEPTH24_STENCIL8","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","f","numColorComponents","s_textureInternalFormatInfo","getTextureInternalFormatInfo","internalFormat","textureFormat","colorRenderable","textureFilterable","bytesPerElement","bytesPerElementMap","getBytesPerElementForInternalFormat","getFormatAndTypeForInternalFormat","isPowerOf2","canGenerateMipmap","canFilter","getNumComponentsForFormat","getTextureTypeForArrayType","defaultType","guessDimensions","Math","sqrt","setDefaultTextureColor","color","lastPackState","savePackState","colorspaceConversion","getParameter","UNPACK_COLORSPACE_CONVERSION_WEBGL","pixelStorei","premultiplyAlpha","UNPACK_PREMULTIPLY_ALPHA_WEBGL","flipY","UNPACK_FLIP_Y_WEBGL","restorePackState","saveSkipState","unpackAlignment","UNPACK_ALIGNMENT","unpackRowLength","UNPACK_ROW_LENGTH","unpackImageHeight","UNPACK_IMAGE_HEIGHT","unpackSkipPixels","UNPACK_SKIP_PIXELS","unpackSkipRows","UNPACK_SKIP_ROWS","unpackSkipImages","UNPACK_SKIP_IMAGES","restoreSkipState","setTextureSamplerParameters","parameteriFn","call","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","TEXTURE_WRAP_R","wrapR","minLod","TEXTURE_MIN_LOD","maxLod","TEXTURE_MAX_LOD","baseLevel","TEXTURE_BASE_LEVEL","maxLevel","TEXTURE_MAX_LEVEL","setTextureParameters","tex","texParameteri","setSamplerParameters","samplerParameteri","createSampler","createSamplers","samplerOptions","samplers","make1Pixel","setTextureFilteringForSize","generateMipmap","filtering","shouldAutomaticallySetTextureFilteringForSize","getCubeFaceOrder","cubeFaceOrder","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","getCubeFacesWithNdx","faces","facesWithNdx","face","sort","a","setTextureFromElement","element","formatType","imgWidth","imgHeight","slices","nodeName","ctx","canvas","xOffset","yOffset","drawImage","texImage2D","createImageBitmap","colorSpaceConversion","then","imageBitmap","smallest","largest","max","depth","xMult","yMult","texImage3D","d","srcX","srcY","texSubImage3D","noop","urlIsSameOrigin","url","href","hostname","port","protocol","localOrigin","URL","origin","urlOrigin","setToAnonymousIfUndefinedAndURLIsNotSameOrigin","loadImage","callback","img","Image","clearEventHandlers","removeEventListener","onError","onLoad","msg","addEventListener","ImageBitmap","err","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","slice","s","setTextureFromArray","getTypedArrayTypeForGLType","Uint8ClampedArray","glEnumToString","dimensions","cbrt","elementsPerElement","faceSize","subarray","setEmptyTexture","isAsyncSrc","createTextures","numDownloading","images","callCallbackIfReady","onLoadFn","addExtensionsToContext","attributes","setAttributeDefaults_","setTextureDefaults_","prefixRE","addExtensionToContext","extensionName","ext","getExtension","enums","fnSuffix","exec","enumSuffix","isFunc","suffix","endsWith","substring","origFn","apply","constructor","supportedExtensions","create3DContext","context","getWebGLContext","createContext","resizeCanvasToDisplaySize","multiplier","clientWidth","clientHeight","glTypeToTypedArray","tt","Int16Array","CTOR","SharedArrayBuffer","isArrayBufferOrSharedArrayBuffer","texStorage2D","isWebGL1","haveEnumsForType","addEnums","existing","createVertexArrayInfo","programInfos","vao","createVertexArray","createVAOAndSetAttributes","createVAOFromBufferInfo"],"mappings":"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","file":"twgl.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-base.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\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 || gl.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 || gl.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.} 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.} 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(gl.ARRAY_BUFFER, buffer);\n gl.bufferData(gl.ARRAY_BUFFER, numBytes, array.drawType || gl.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(gl.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(gl.ARRAY_BUFFER, attribInfo.buffer);\n gl.bufferSubData(gl.ARRAY_BUFFER, offset, array);\n } else {\n setBufferFromTypedArray(gl, gl.ARRAY_BUFFER, attribInfo.buffer, array, attribInfo.drawType);\n }\n}\n\nfunction getBytesPerValueForGLType(gl, type) {\n if (type === gl.BYTE) return 1; // eslint-disable-line\n if (type === gl.UNSIGNED_BYTE) return 1; // eslint-disable-line\n if (type === gl.SHORT) return 2; // eslint-disable-line\n if (type === gl.UNSIGNED_SHORT) return 2; // eslint-disable-line\n if (type === gl.INT) return 4; // eslint-disable-line\n if (type === gl.UNSIGNED_INT) return 4; // eslint-disable-line\n if (type === gl.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(gl.ARRAY_BUFFER, attrib.buffer);\n const numBytes = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);\n gl.bindBuffer(gl.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.} [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, gl.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\" ? gl.ELEMENT_ARRAY_BUFFER : gl.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} 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\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 ? gl.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 ? gl.UNSIGNED_SHORT : bufferInfo.elementType, offset, instanceCount);\n } else {\n gl.drawElements(type, numElements, elementType === undefined ? gl.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} 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 ? gl.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.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 UNSIGNED_BYTE = 0x1401;\n\n/* PixelFormat */\nconst DEPTH_COMPONENT = 0x1902;\nconst RGBA = 0x1908;\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 REPEAT = 0x2901; // eslint-disable-line\nconst CLAMP_TO_EDGE = 0x812F;\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\nconst LINEAR = 0x2601;\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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} [attach] 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 {WebGLObject} [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 */\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;\n\nfunction getAttachmentPointForFormat(format) {\n return attachmentsByFormat[format];\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 {WebGLObject[]} attachments The created attachments in the same order as passed in to {@link module:twgl.createFramebufferInfo}.\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 = gl.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 = getAttachmentPointForFormat(format);\n if (!attachmentPoint) {\n attachmentPoint = COLOR_ATTACHMENT0 + colorAttachmentCount++;\n }\n if (!attachment) {\n if (isRenderbufferFormat(format)) {\n attachment = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.LINEAR;\n textureOptions.mag = textureOptions.mag || textureOptions.minMag || gl.LINEAR;\n textureOptions.wrapS = textureOptions.wrapS || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n textureOptions.wrapT = textureOptions.wrapT || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n }\n attachment = textures.createTexture(gl, textureOptions);\n }\n }\n if (helper.isRenderbuffer(gl, attachment)) {\n gl.framebufferRenderbuffer(target, attachmentPoint, gl.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.texTarget || gl.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(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.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.} src the source\n * @param {Object.} 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 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 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(gl.TEXTURE0 + unit);\n gl.bindTexture(bindPoint, texture);\n gl.bindSampler(unit, sampler);\n } : function(texture) {\n gl.uniform1i(location, unit);\n gl.activeTexture(gl.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(gl.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(gl.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, };\ntypeMap[FLOAT_VEC3] = { Type: Float32Array, size: 12, setter: floatVec3Setter, };\ntypeMap[FLOAT_VEC4] = { Type: Float32Array, size: 16, setter: floatVec4Setter, };\ntypeMap[INT] = { Type: Int32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[INT_VEC2] = { Type: Int32Array, size: 8, setter: intVec2Setter, };\ntypeMap[INT_VEC3] = { Type: Int32Array, size: 12, setter: intVec3Setter, };\ntypeMap[INT_VEC4] = { Type: Int32Array, size: 16, setter: intVec4Setter, };\ntypeMap[UNSIGNED_INT] = { Type: Uint32Array, size: 4, setter: uintSetter, arraySetter: uintArraySetter, };\ntypeMap[UNSIGNED_INT_VEC2] = { Type: Uint32Array, size: 8, setter: uintVec2Setter, };\ntypeMap[UNSIGNED_INT_VEC3] = { Type: Uint32Array, size: 12, setter: uintVec3Setter, };\ntypeMap[UNSIGNED_INT_VEC4] = { Type: Uint32Array, size: 16, setter: uintVec4Setter, };\ntypeMap[BOOL] = { Type: Uint32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[BOOL_VEC2] = { Type: Uint32Array, size: 8, setter: intVec2Setter, };\ntypeMap[BOOL_VEC3] = { Type: Uint32Array, size: 12, setter: intVec3Setter, };\ntypeMap[BOOL_VEC4] = { Type: Uint32Array, size: 16, setter: intVec4Setter, };\ntypeMap[FLOAT_MAT2] = { Type: Float32Array, size: 16, setter: floatMat2Setter, };\ntypeMap[FLOAT_MAT3] = { Type: Float32Array, size: 36, setter: floatMat3Setter, };\ntypeMap[FLOAT_MAT4] = { Type: Float32Array, size: 64, setter: floatMat4Setter, };\ntypeMap[FLOAT_MAT2x3] = { Type: Float32Array, size: 24, setter: floatMat23Setter, };\ntypeMap[FLOAT_MAT2x4] = { Type: Float32Array, size: 32, setter: floatMat24Setter, };\ntypeMap[FLOAT_MAT3x2] = { Type: Float32Array, size: 24, setter: floatMat32Setter, };\ntypeMap[FLOAT_MAT3x4] = { Type: Float32Array, size: 48, setter: floatMat34Setter, };\ntypeMap[FLOAT_MAT4x2] = { Type: Float32Array, size: 32, setter: floatMat42Setter, };\ntypeMap[FLOAT_MAT4x3] = { Type: Float32Array, size: 48, setter: floatMat43Setter, };\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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n const numComponents = b.size || b.numComponents || defaultSize;\n const size = numComponents / count;\n const type = b.type || gl.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\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\nfunction addLineNumbers(src, lineOffset) {\n lineOffset = lineOffset || 0;\n ++lineOffset;\n\n return src.split(\"\\n\").map(function(line, ndx) {\n return (ndx + lineOffset) + \": \" + line;\n }).join(\"\\n\");\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 // \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, gl.COMPILE_STATUS);\n if (!compiled) {\n // Something went wrong during compilation; get the error\n const lastError = gl.getShaderInfoLog(shader);\n errFn(addLineNumbers(shaderSource, lineOffset) + \"\\n*** Error compiling shader: \" + 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.} [attribLocations] a attribute name to location map\n * @property {(module:twgl.BufferInfo|Object.|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 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 }\n\n const options = {\n errorCallback: opt_errorCallback || error,\n transformFeedbackVaryings: transformFeedbackVaryings,\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 gl.FRAGMENT_SHADER;\n } else if (scriptType.indexOf(\"vert\") >= 0) {\n return gl.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 || gl.SEPARATE_ATTRIBS);\n }\n gl.linkProgram(program);\n\n // Check the link status\n const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n if (!linked) {\n // something went wrong with the link\n const lastError = gl.getProgramInfoLog(program);\n progOptions.errorCallback(\"Error 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\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.} 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) {\n const location = gl.getUniformLocation(program, uniformInfo.name);\n const isArray = (uniformInfo.size > 1 && uniformInfo.name.substr(-3) === \"[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 numUniforms = gl.getProgramParameter(program, gl.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.substr(-3) === \"[0]\") {\n name = name.substr(0, name.length - 3);\n }\n const setter = createUniformSetter(program, uniformInfo);\n uniformSetters[name] = setter;\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}\n * @memberOf module:twgl\n */\nfunction createTransformFeedbackInfo(gl, program) {\n const info = {};\n const numVaryings = gl.getProgramParameter(program, gl.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)} transformFeedbackInfo A ProgramInfo or TransformFeedbackInfo.\n * @param {(module:twgl.BufferInfo|Object)} [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(gl.TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer, buf.offset, buf.size);\n } else {\n gl.bindBufferBase(gl.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)} [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(gl.TRANSFORM_FEEDBACK, tf);\n gl.useProgram(programInfo.program);\n bindTransformFeedbackInfo(gl, programInfo, bufferInfo);\n gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);\n return tf;\n}\n\n/**\n * @typedef {Object} UniformData\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. 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, gl.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 if (isBuiltIn(uniformInfo)) {\n break;\n }\n // REMOVE [0]?\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, gl.ACTIVE_UNIFORM_BLOCKS);\n for (let ii = 0; ii < numUniformBlocks; ++ii) {\n const name = gl.getActiveUniformBlockName(program, ii);\n const blockSpec = {\n index: ii,\n usedByVertexShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n usedByFragmentShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n size: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_DATA_SIZE),\n uniformIndices: gl.getActiveUniformBlockParameter(program, ii, gl.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\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.} 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 * @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(gl.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 blockSpec.uniformIndices.forEach(function(uniformNdx) {\n const data = uniformData[uniformNdx];\n const typeInfo = typeMap[data.type];\n const Type = typeInfo.Type;\n const length = data.size * typeInfo.size;\n let name = data.name;\n if (name.substr(0, prefix.length) === prefix) {\n name = name.substr(prefix.length);\n }\n uniforms[name] = new Type(array, data.offset, length / Type.BYTES_PER_ELEMENT);\n });\n return {\n name: blockName,\n array: array,\n asFloat: new Float32Array(array), // for debugging\n buffer: buffer,\n uniforms: uniforms,\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(gl.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(gl.UNIFORM_BUFFER, uniformBlockInfo.array, gl.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.} 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 * Any name that doesn't match will be ignored\n * @memberOf module:twgl/programs\n */\nfunction setBlockUniforms(uniformBlockInfo, values) {\n const uniforms = uniformBlockInfo.uniforms;\n for (const name in values) {\n const array = uniforms[name];\n if (array) {\n const value = values[name];\n if (value.length) {\n array.set(value);\n } else {\n array[0] = value;\n }\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.)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n * `createUniformSetters`.\n * @param {Object.} 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 * @memberOf module:twgl/programs\n */\nfunction setUniforms(setters, values) { // eslint-disable-line\n const actualSetters = setters.uniformSetters || setters;\n const numArgs = arguments.length;\n for (let aNdx = 1; aNdx < numArgs; ++aNdx) {\n const values = arguments[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 * 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.} 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, gl.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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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.)} 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(gl.ELEMENT_ARRAY_BUFFER, buffers.indices);\n }\n }\n}\n\n/**\n * @typedef {Object} ProgramInfo\n * @property {WebGLProgram} program A shader program\n * @property {Object} uniformSetters object of setters as returned from createUniformSetters,\n * @property {Object} attribSetters object of setters as returned from createAttribSetters,\n * @property {module:twgl.UniformBlockSpec} [uniformBlockSpace] a uniform block spec for making UniformBlockInfos with createUniformBlockInfo etc..\n * @property {Object} [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: program,\n uniformSetters: uniformSetters,\n attribSetters: 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 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?\nlet s_ctx;\nfunction 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// 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 */\nconst REPEAT = 0x2901; // eslint-disable-line\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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.} 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\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 /*, type */) {\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 /*, type */) {\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 || gl.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 === gl.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// NOTE: While querying GL is considered slow it's not remotely as slow\n// as uploading a texture. On top of that you're unlikely to call this in\n// a perf critical loop. Even if upload a texture every frame that's unlikely\n// to be more than 1 or 2 textures a frame. In other words, the benefits of\n// making the API easy to use outweigh any supposed perf benefits\n//\n// Also note I get that having one global of these is bad practice.\n// As long as it's used correctly it means no garbage which probably\n// doesn't matter when dealing with textures but old habits die hard.\nconst lastPackState = {};\n\n/**\n * Saves 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 savePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n lastPackState.colorspaceConversion = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, options.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n lastPackState.premultiplyAlpha = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, options.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n lastPackState.flipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, options.flipY);\n }\n}\n\n/**\n * Restores any packing state that was 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 restorePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, lastPackState.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, lastPackState.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, lastPackState.flipY);\n }\n}\n\n/**\n * Saves state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction saveSkipState(gl) {\n lastPackState.unpackAlignment = gl.getParameter(gl.UNPACK_ALIGNMENT);\n if (utils.isWebGL2(gl)) {\n lastPackState.unpackRowLength = gl.getParameter(gl.UNPACK_ROW_LENGTH);\n lastPackState.unpackImageHeight = gl.getParameter(gl.UNPACK_IMAGE_HEIGHT);\n lastPackState.unpackSkipPixels = gl.getParameter(gl.UNPACK_SKIP_PIXELS);\n lastPackState.unpackSkipRows = gl.getParameter(gl.UNPACK_SKIP_ROWS);\n lastPackState.unpackSkipImages = gl.getParameter(gl.UNPACK_SKIP_IMAGES);\n }\n}\n\n/**\n * Restores state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction restoreSkipState(gl) {\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, lastPackState.unpackAlignment);\n if (utils.isWebGL2(gl)) {\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, lastPackState.unpackRowLength);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, lastPackState.unpackImageHeight);\n gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, lastPackState.unpackSkipPixels);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, lastPackState.unpackSkipRows);\n gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, lastPackState.unpackSkipImages);\n }\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, gl.TEXTURE_MIN_FILTER, options.minMag);\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.minMag);\n }\n if (options.min) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_FILTER, options.min);\n }\n if (options.mag) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.mag);\n }\n if (options.wrap) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrap);\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrap);\n if (target === gl.TEXTURE_3D || helper.isSampler(gl, target)) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrap);\n }\n }\n if (options.wrapR) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrapR);\n }\n if (options.wrapS) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrapS);\n }\n if (options.wrapT) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrapT);\n }\n if (options.minLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_LOD, options.minLod);\n }\n if (options.maxLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAX_LOD, options.maxLod);\n }\n if (options.baseLevel) {\n parameteriFn.call(gl, target, gl.TEXTURE_BASE_LEVEL, options.baseLevel);\n }\n if (options.maxLevel) {\n parameteriFn.call(gl, target, gl.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 || gl.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.} options A object of TextureOptions one per sampler.\n * @return {Object.} 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 * @param {number} [type] The type parameter for texImage2D etc..\n * @memberOf module:twgl/textures\n */\nfunction setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type) {\n options = options || defaults.textureOptions;\n internalFormat = internalFormat || gl.RGBA;\n type = type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n width = width || options.width;\n height = height || options.height;\n gl.bindTexture(target, tex);\n if (canGenerateMipmap(gl, width, height, internalFormat, type)) {\n gl.generateMipmap(target);\n } else {\n const filtering = canFilter(internalFormat, type) ? gl.LINEAR : gl.NEAREST;\n gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 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}\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 || gl.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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n gl.bindTexture(target, tex);\n if (target === gl.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 savePackState(gl, options);\n gl.bindTexture(target, tex);\n gl.texImage2D(f.face, level, internalFormat, format, type, imageBitmap);\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\n }\n });\n });\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, element.width);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0);\n gl.pixelStorei(gl.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(gl.UNPACK_SKIP_PIXELS, srcX);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, srcY);\n gl.texSubImage3D(target, level, 0, 0, d, smallest, smallest, 1, format, type, element);\n }\n restoreSkipState(gl);\n } else {\n gl.texImage2D(target, level, internalFormat, format, type, element);\n }\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.TEXTURE_2D_ARRAY) {\n gl.texImage3D(target, 0, gl.RGBA, 1, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n } else {\n gl.texImage2D(target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.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.} textures the created textures by name. Same as returned by {@link module:twgl.createTextures}.\n * @param {Object.} 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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n if (target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D_ARRAY;\n if (target !== gl.TEXTURE_3D && target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.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 || gl.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 === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, options.unpackAlignment || 1);\n savePackState(gl, options);\n if (target === gl.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 === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n restoreSkipState(gl);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n if (target === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, options.width, options.height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n}\n\n/**\n * Creates a texture based on the options passed in.\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 || gl.TEXTURE_2D;\n let width = options.width || 1;\n let height = options.height || 1;\n const internalFormat = options.internalFormat || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n let type = options.type || formatType.type;\n gl.bindTexture(target, tex);\n if (target === gl.TEXTURE_CUBE_MAP) {\n // this should have been the default for cubemaps :(\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 type = dimensions.type;\n } else if (Array.isArray(src) && (typeof (src[0]) === 'string' || isTexImageSource(src[0]))) {\n if (target === gl.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 } else {\n throw \"unsupported src type\";\n }\n } else {\n setEmptyTexture(gl, tex, options);\n }\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, width, height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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.} 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.} 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","export * from './twgl.js';\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] || (\"0x\" + value.toString(16));\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\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\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 = )` 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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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(gl.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.| 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":""} \ No newline at end of file +{"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/programs.js","webpack://twgl/./src/textures.js","webpack://twgl/./src/twgl-base.js","webpack://twgl/./src/twgl.js","webpack://twgl/./src/typedarrays.js","webpack://twgl/./src/utils.js","webpack://twgl/./src/vertex-arrays.js"],"names":["gl","undefined","defaults","attribPrefix","setAttributePrefix","prefix","setDefaults","newDefaults","helper","copyExistingProperties","setBufferFromTypedArray","type","buffer","array","drawType","bindBuffer","bufferData","STATIC_DRAW","createBufferFromTypedArray","typedArray","isBuffer","ARRAY_BUFFER","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","BYTE","UNSIGNED_BYTE","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","positionKeys","getNumElementsFromNonIndexedArrays","key","ii","numElements","getNumElementsFromAttributes","getBufferParameter","BUFFER_SIZE","bytesPerValue","totalElements","createBufferInfoFromArrays","srcBufferInfo","newAttribs","bufferInfo","assign","indices","newIndices","ELEMENT_ARRAY_BUFFER","elementType","createBufferFromArray","createBuffersFromArrays","buffers","drawBufferInfo","count","instanceCount","TRIANGLES","drawElementsInstanced","drawElements","drawArraysInstanced","drawArrays","drawObjectList","objectsToDraw","lastUsedProgramInfo","lastUsedBufferInfo","object","active","programInfo","vertexArrayInfo","bindBuffers","useProgram","program","vertexArrayObject","bindVertexArray","programs","setBuffersAndAttributes","setUniforms","uniforms","DEPTH_COMPONENT","RGBA","RGBA4","RGB5_A1","RGB565","DEPTH_COMPONENT16","STENCIL_INDEX","STENCIL_INDEX8","DEPTH_STENCIL","COLOR_ATTACHMENT0","DEPTH_ATTACHMENT","STENCIL_ATTACHMENT","DEPTH_STENCIL_ATTACHMENT","REPEAT","CLAMP_TO_EDGE","MIRRORED_REPEAT","NEAREST","LINEAR","NEAREST_MIPMAP_NEAREST","LINEAR_MIPMAP_NEAREST","NEAREST_MIPMAP_LINEAR","LINEAR_MIPMAP_LINEAR","defaultAttachments","format","min","wrap","attachmentsByFormat","getAttachmentPointForFormat","renderbufferFormats","isRenderbufferFormat","createFramebufferInfo","attachments","width","height","target","FRAMEBUFFER","fb","createFramebuffer","bindFramebuffer","drawingBufferWidth","drawingBufferHeight","colorAttachmentCount","framebufferInfo","framebuffer","attachmentOptions","attachment","attachmentPoint","createRenderbuffer","bindRenderbuffer","RENDERBUFFER","renderbufferStorage","textureOptions","auto","minMag","mag","wrapS","wrapT","textures","createTexture","isRenderbuffer","framebufferRenderbuffer","isTexture","layer","framebufferTextureLayer","level","framebufferTexture2D","texTarget","TEXTURE_2D","push","resizeFramebufferInfo","ndx","resizeTexture","bindFramebufferInfo","viewport","copyNamedProperties","names","src","dst","hasOwnProperty","error","console","warn","t","WebGLRenderbuffer","isShader","WebGLShader","WebGLTexture","isSampler","WebGLSampler","getElementById","id","document","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","v","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","TEXTURE0","bindTexture","bindSampler","samplerArraySetter","units","Int32Array","index","setter","arraySetter","Uint32Array","floatAttribSetter","b","disableVertexAttribArray","vertexAttrib4fv","vertexAttrib3fv","vertexAttrib2fv","vertexAttrib1fv","enableVertexAttribArray","vertexAttribPointer","vertexAttribDivisor","intAttribSetter","vertexAttrib4iv","vertexAttribIPointer","uintAttribSetter","vertexAttrib4uiv","matAttribSetter","typeInfo","defaultSize","rowOffset","i","attrTypeMap","addLineNumbers","lineOffset","split","map","line","join","spaceRE","loadShader","shaderSource","shaderType","opt_errorCallback","errFn","shader","createShader","replace","compileShader","compiled","getShaderParameter","COMPILE_STATUS","lastError","getShaderInfoLog","deleteShader","getProgramOptions","opt_attribs","opt_locations","transformFeedbackVaryings","transformFeedbackMode","errorCallback","opt","attribLocations","options","defaultShaderType","getShaderTypeFromScriptType","scriptType","indexOf","FRAGMENT_SHADER","VERTEX_SHADER","deleteShaders","shaders","createProgram","progOptions","realShaders","newShaders","elem","text","attachShader","bindAttribLocation","varyings","SEPARATE_ATTRIBS","linkProgram","linked","getProgramParameter","LINK_STATUS","getProgramInfoLog","deleteProgram","createShaderFromScript","scriptId","opt_shaderType","shaderScript","createProgramFromScripts","shaderScriptIds","createProgramFromSources","shaderSources","isBuiltIn","info","startsWith","createUniformSetters","textureUnit","createUniformSetter","uniformInfo","getUniformLocation","substr","toString","uniformSetters","numUniforms","ACTIVE_UNIFORMS","getActiveUniform","createTransformFeedbackInfo","numVaryings","TRANSFORM_FEEDBACK_VARYINGS","varying","getTransformFeedbackVarying","bindTransformFeedbackInfo","transformFeedbackInfo","buf","bindBufferRange","TRANSFORM_FEEDBACK_BUFFER","bindBufferBase","createTransformFeedback","tf","bindTransformFeedback","TRANSFORM_FEEDBACK","createUniformBlockSpecFromProgram","uniformData","uniformIndices","pair","pname","getActiveUniforms","blockSpecs","numUniformBlocks","ACTIVE_UNIFORM_BLOCKS","getActiveUniformBlockName","blockSpec","usedByVertexShader","getActiveUniformBlockParameter","UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER","usedByFragmentShader","UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER","UNIFORM_BLOCK_DATA_SIZE","UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES","used","arraySuffixRE","createUniformBlockInfoFromProgram","uniformBlockSpec","blockName","ArrayBuffer","uniformBufferIndex","UNIFORM_BUFFER","uniformBlockBinding","uniformNdx","asFloat","createUniformBlockInfo","bindUniformBlock","uniformBlockInfo","bufferBindIndex","byteLength","setUniformBlock","DYNAMIC_DRAW","setBlockUniforms","values","set","setters","actualSetters","numArgs","arguments","aNdx","createAttributeSetters","attribSetters","numAttribs","ACTIVE_ATTRIBUTES","getActiveAttrib","getAttribLocation","setAttributes","createProgramInfoFromProgram","createProgramInfo","good","source","script","textureColor","crossOrigin","s_ctx","getShared2DContext","createElement","getContext","ALPHA","RGB","LUMINANCE","LUMINANCE_ALPHA","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","DEPTH_COMPONENT24","DEPTH_COMPONENT32F","DEPTH32F_STENCIL8","DEPTH24_STENCIL8","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","f","numColorComponents","s_textureInternalFormatInfo","getTextureInternalFormatInfo","internalFormat","textureFormat","colorRenderable","textureFilterable","bytesPerElement","bytesPerElementMap","getBytesPerElementForInternalFormat","getFormatAndTypeForInternalFormat","isPowerOf2","canGenerateMipmap","canFilter","getNumComponentsForFormat","getTextureTypeForArrayType","defaultType","guessDimensions","Math","sqrt","setDefaultTextureColor","color","lastPackState","savePackState","colorspaceConversion","getParameter","UNPACK_COLORSPACE_CONVERSION_WEBGL","pixelStorei","premultiplyAlpha","UNPACK_PREMULTIPLY_ALPHA_WEBGL","flipY","UNPACK_FLIP_Y_WEBGL","restorePackState","saveSkipState","unpackAlignment","UNPACK_ALIGNMENT","unpackRowLength","UNPACK_ROW_LENGTH","unpackImageHeight","UNPACK_IMAGE_HEIGHT","unpackSkipPixels","UNPACK_SKIP_PIXELS","unpackSkipRows","UNPACK_SKIP_ROWS","unpackSkipImages","UNPACK_SKIP_IMAGES","restoreSkipState","setTextureSamplerParameters","parameteriFn","call","TEXTURE_MIN_FILTER","TEXTURE_MAG_FILTER","TEXTURE_WRAP_S","TEXTURE_WRAP_T","TEXTURE_WRAP_R","wrapR","minLod","TEXTURE_MIN_LOD","maxLod","TEXTURE_MAX_LOD","baseLevel","TEXTURE_BASE_LEVEL","maxLevel","TEXTURE_MAX_LEVEL","setTextureParameters","tex","texParameteri","setSamplerParameters","samplerParameteri","createSampler","createSamplers","samplerOptions","samplers","make1Pixel","setTextureFilteringForSize","generateMipmap","filtering","shouldAutomaticallySetTextureFilteringForSize","getCubeFaceOrder","cubeFaceOrder","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","getCubeFacesWithNdx","faces","facesWithNdx","face","sort","a","setTextureFromElement","element","formatType","imgWidth","imgHeight","slices","nodeName","ctx","canvas","xOffset","yOffset","drawImage","texImage2D","createImageBitmap","colorSpaceConversion","then","imageBitmap","smallest","largest","max","depth","xMult","yMult","texImage3D","d","srcX","srcY","texSubImage3D","noop","urlIsSameOrigin","url","href","hostname","port","protocol","localOrigin","URL","origin","urlOrigin","setToAnonymousIfUndefinedAndURLIsNotSameOrigin","loadImage","callback","img","Image","clearEventHandlers","removeEventListener","onError","onLoad","msg","addEventListener","ImageBitmap","err","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","slice","s","setTextureFromArray","getTypedArrayTypeForGLType","Uint8ClampedArray","glEnumToString","dimensions","cbrt","elementsPerElement","faceSize","subarray","setEmptyTexture","isAsyncSrc","createTextures","numDownloading","images","callCallbackIfReady","onLoadFn","addExtensionsToContext","attributes","setAttributeDefaults_","setTextureDefaults_","prefixRE","addExtensionToContext","extensionName","ext","getExtension","enums","fnSuffix","exec","enumSuffix","isFunc","suffix","endsWith","substring","origFn","apply","constructor","supportedExtensions","create3DContext","context","getWebGLContext","createContext","resizeCanvasToDisplaySize","multiplier","clientWidth","clientHeight","glTypeToTypedArray","tt","Int16Array","CTOR","SharedArrayBuffer","isArrayBufferOrSharedArrayBuffer","texStorage2D","isWebGL1","haveEnumsForType","addEnums","existing","createVertexArrayInfo","programInfos","vao","createVertexArray","createVAOAndSetAttributes","createVAOFromBufferInfo"],"mappings":"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","file":"twgl.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-base.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\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 || gl.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 || gl.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.} 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.} 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(gl.ARRAY_BUFFER, buffer);\n gl.bufferData(gl.ARRAY_BUFFER, numBytes, array.drawType || gl.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(gl.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(gl.ARRAY_BUFFER, attribInfo.buffer);\n gl.bufferSubData(gl.ARRAY_BUFFER, offset, array);\n } else {\n setBufferFromTypedArray(gl, gl.ARRAY_BUFFER, attribInfo.buffer, array, attribInfo.drawType);\n }\n}\n\nfunction getBytesPerValueForGLType(gl, type) {\n if (type === gl.BYTE) return 1; // eslint-disable-line\n if (type === gl.UNSIGNED_BYTE) return 1; // eslint-disable-line\n if (type === gl.SHORT) return 2; // eslint-disable-line\n if (type === gl.UNSIGNED_SHORT) return 2; // eslint-disable-line\n if (type === gl.INT) return 4; // eslint-disable-line\n if (type === gl.UNSIGNED_INT) return 4; // eslint-disable-line\n if (type === gl.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(gl.ARRAY_BUFFER, attrib.buffer);\n const numBytes = gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE);\n gl.bindBuffer(gl.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.} [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, gl.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\" ? gl.ELEMENT_ARRAY_BUFFER : gl.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} 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\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 ? gl.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 ? gl.UNSIGNED_SHORT : bufferInfo.elementType, offset, instanceCount);\n } else {\n gl.drawElements(type, numElements, elementType === undefined ? gl.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} 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 ? gl.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.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 UNSIGNED_BYTE = 0x1401;\n\n/* PixelFormat */\nconst DEPTH_COMPONENT = 0x1902;\nconst RGBA = 0x1908;\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 REPEAT = 0x2901; // eslint-disable-line\nconst CLAMP_TO_EDGE = 0x812F;\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\nconst LINEAR = 0x2601;\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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} [attach] 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 {WebGLObject} [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;\n\nfunction getAttachmentPointForFormat(format) {\n return attachmentsByFormat[format];\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 {WebGLObject[]} attachments The created attachments in the same order as passed in to {@link module:twgl.createFramebufferInfo}.\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 = gl.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 = getAttachmentPointForFormat(format);\n if (!attachmentPoint) {\n attachmentPoint = COLOR_ATTACHMENT0 + colorAttachmentCount++;\n }\n if (!attachment) {\n if (isRenderbufferFormat(format)) {\n attachment = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.LINEAR;\n textureOptions.mag = textureOptions.mag || textureOptions.minMag || gl.LINEAR;\n textureOptions.wrapS = textureOptions.wrapS || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n textureOptions.wrapT = textureOptions.wrapT || textureOptions.wrap || gl.CLAMP_TO_EDGE;\n }\n attachment = textures.createTexture(gl, textureOptions);\n }\n }\n if (helper.isRenderbuffer(gl, attachment)) {\n gl.framebufferRenderbuffer(target, attachmentPoint, gl.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.texTarget || gl.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(gl.RENDERBUFFER, attachment);\n gl.renderbufferStorage(gl.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 || gl.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.} src the source\n * @param {Object.} 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 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 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(gl.TEXTURE0 + unit);\n gl.bindTexture(bindPoint, texture);\n gl.bindSampler(unit, sampler);\n } : function(texture) {\n gl.uniform1i(location, unit);\n gl.activeTexture(gl.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(gl.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(gl.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, };\ntypeMap[FLOAT_VEC3] = { Type: Float32Array, size: 12, setter: floatVec3Setter, };\ntypeMap[FLOAT_VEC4] = { Type: Float32Array, size: 16, setter: floatVec4Setter, };\ntypeMap[INT] = { Type: Int32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[INT_VEC2] = { Type: Int32Array, size: 8, setter: intVec2Setter, };\ntypeMap[INT_VEC3] = { Type: Int32Array, size: 12, setter: intVec3Setter, };\ntypeMap[INT_VEC4] = { Type: Int32Array, size: 16, setter: intVec4Setter, };\ntypeMap[UNSIGNED_INT] = { Type: Uint32Array, size: 4, setter: uintSetter, arraySetter: uintArraySetter, };\ntypeMap[UNSIGNED_INT_VEC2] = { Type: Uint32Array, size: 8, setter: uintVec2Setter, };\ntypeMap[UNSIGNED_INT_VEC3] = { Type: Uint32Array, size: 12, setter: uintVec3Setter, };\ntypeMap[UNSIGNED_INT_VEC4] = { Type: Uint32Array, size: 16, setter: uintVec4Setter, };\ntypeMap[BOOL] = { Type: Uint32Array, size: 4, setter: intSetter, arraySetter: intArraySetter, };\ntypeMap[BOOL_VEC2] = { Type: Uint32Array, size: 8, setter: intVec2Setter, };\ntypeMap[BOOL_VEC3] = { Type: Uint32Array, size: 12, setter: intVec3Setter, };\ntypeMap[BOOL_VEC4] = { Type: Uint32Array, size: 16, setter: intVec4Setter, };\ntypeMap[FLOAT_MAT2] = { Type: Float32Array, size: 16, setter: floatMat2Setter, };\ntypeMap[FLOAT_MAT3] = { Type: Float32Array, size: 36, setter: floatMat3Setter, };\ntypeMap[FLOAT_MAT4] = { Type: Float32Array, size: 64, setter: floatMat4Setter, };\ntypeMap[FLOAT_MAT2x3] = { Type: Float32Array, size: 24, setter: floatMat23Setter, };\ntypeMap[FLOAT_MAT2x4] = { Type: Float32Array, size: 32, setter: floatMat24Setter, };\ntypeMap[FLOAT_MAT3x2] = { Type: Float32Array, size: 24, setter: floatMat32Setter, };\ntypeMap[FLOAT_MAT3x4] = { Type: Float32Array, size: 48, setter: floatMat34Setter, };\ntypeMap[FLOAT_MAT4x2] = { Type: Float32Array, size: 32, setter: floatMat42Setter, };\ntypeMap[FLOAT_MAT4x3] = { Type: Float32Array, size: 48, setter: floatMat43Setter, };\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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n gl.enableVertexAttribArray(index);\n gl.vertexAttribIPointer(\n index, b.numComponents || b.size, b.type || gl.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(gl.ARRAY_BUFFER, b.buffer);\n const numComponents = b.size || b.numComponents || defaultSize;\n const size = numComponents / count;\n const type = b.type || gl.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\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\nfunction addLineNumbers(src, lineOffset) {\n lineOffset = lineOffset || 0;\n ++lineOffset;\n\n return src.split(\"\\n\").map(function(line, ndx) {\n return (ndx + lineOffset) + \": \" + line;\n }).join(\"\\n\");\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 // \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, gl.COMPILE_STATUS);\n if (!compiled) {\n // Something went wrong during compilation; get the error\n const lastError = gl.getShaderInfoLog(shader);\n errFn(addLineNumbers(shaderSource, lineOffset) + \"\\n*** Error compiling shader: \" + 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.} [attribLocations] a attribute name to location map\n * @property {(module:twgl.BufferInfo|Object.|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 gl.FRAGMENT_SHADER;\n } else if (scriptType.indexOf(\"vert\") >= 0) {\n return gl.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 || gl.SEPARATE_ATTRIBS);\n }\n gl.linkProgram(program);\n\n // Check the link status\n const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n if (!linked) {\n // something went wrong with the link\n const lastError = gl.getProgramInfoLog(program);\n progOptions.errorCallback(\"Error 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\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.} 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) {\n const location = gl.getUniformLocation(program, uniformInfo.name);\n const isArray = (uniformInfo.size > 1 && uniformInfo.name.substr(-3) === \"[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 numUniforms = gl.getProgramParameter(program, gl.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.substr(-3) === \"[0]\") {\n name = name.substr(0, name.length - 3);\n }\n const setter = createUniformSetter(program, uniformInfo);\n uniformSetters[name] = setter;\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}\n * @memberOf module:twgl\n */\nfunction createTransformFeedbackInfo(gl, program) {\n const info = {};\n const numVaryings = gl.getProgramParameter(program, gl.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)} transformFeedbackInfo A ProgramInfo or TransformFeedbackInfo.\n * @param {(module:twgl.BufferInfo|Object)} [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(gl.TRANSFORM_FEEDBACK_BUFFER, varying.index, buf.buffer, buf.offset, buf.size);\n } else {\n gl.bindBufferBase(gl.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)} [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(gl.TRANSFORM_FEEDBACK, tf);\n gl.useProgram(programInfo.program);\n bindTransformFeedbackInfo(gl, programInfo, bufferInfo);\n gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);\n return tf;\n}\n\n/**\n * @typedef {Object} UniformData\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. 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, gl.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 if (isBuiltIn(uniformInfo)) {\n break;\n }\n // REMOVE [0]?\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, gl.ACTIVE_UNIFORM_BLOCKS);\n for (let ii = 0; ii < numUniformBlocks; ++ii) {\n const name = gl.getActiveUniformBlockName(program, ii);\n const blockSpec = {\n index: ii,\n usedByVertexShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),\n usedByFragmentShader: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER),\n size: gl.getActiveUniformBlockParameter(program, ii, gl.UNIFORM_BLOCK_DATA_SIZE),\n uniformIndices: gl.getActiveUniformBlockParameter(program, ii, gl.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\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.} 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 * @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(gl.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 blockSpec.uniformIndices.forEach(function(uniformNdx) {\n const data = uniformData[uniformNdx];\n const typeInfo = typeMap[data.type];\n const Type = typeInfo.Type;\n const length = data.size * typeInfo.size;\n let name = data.name;\n if (name.substr(0, prefix.length) === prefix) {\n name = name.substr(prefix.length);\n }\n uniforms[name] = new Type(array, data.offset, length / Type.BYTES_PER_ELEMENT);\n });\n return {\n name: blockName,\n array: array,\n asFloat: new Float32Array(array), // for debugging\n buffer: buffer,\n uniforms: uniforms,\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(gl.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(gl.UNIFORM_BUFFER, uniformBlockInfo.array, gl.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.} 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 * Any name that doesn't match will be ignored\n * @memberOf module:twgl/programs\n */\nfunction setBlockUniforms(uniformBlockInfo, values) {\n const uniforms = uniformBlockInfo.uniforms;\n for (const name in values) {\n const array = uniforms[name];\n if (array) {\n const value = values[name];\n if (value.length) {\n array.set(value);\n } else {\n array[0] = value;\n }\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.)} setters a `ProgramInfo` as returned from `createProgramInfo` or the setters returned from\n * `createUniformSetters`.\n * @param {Object.} 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 * @memberOf module:twgl/programs\n */\nfunction setUniforms(setters, values) { // eslint-disable-line\n const actualSetters = setters.uniformSetters || setters;\n const numArgs = arguments.length;\n for (let aNdx = 1; aNdx < numArgs; ++aNdx) {\n const values = arguments[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 * 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.} 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, gl.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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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.)} 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(gl.ELEMENT_ARRAY_BUFFER, buffers.indices);\n }\n }\n}\n\n/**\n * @typedef {Object} ProgramInfo\n * @property {WebGLProgram} program A shader program\n * @property {Object} uniformSetters object of setters as returned from createUniformSetters,\n * @property {Object} attribSetters object of setters as returned from createAttribSetters,\n * @property {module:twgl.UniformBlockSpec} [uniformBlockSpace] a uniform block spec for making UniformBlockInfos with createUniformBlockInfo etc..\n * @property {Object} [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: program,\n uniformSetters: uniformSetters,\n attribSetters: 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 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?\nlet s_ctx;\nfunction 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// 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 */\nconst REPEAT = 0x2901; // eslint-disable-line\nconst MIRRORED_REPEAT = 0x8370; // eslint-disable-line\n\n/* TextureMagFilter */\nconst NEAREST = 0x2600; // eslint-disable-line\n\n/* TextureMinFilter */\nconst NEAREST_MIPMAP_NEAREST = 0x2700; // eslint-disable-line\nconst LINEAR_MIPMAP_NEAREST = 0x2701; // eslint-disable-line\nconst NEAREST_MIPMAP_LINEAR = 0x2702; // eslint-disable-line\nconst LINEAR_MIPMAP_LINEAR = 0x2703; // eslint-disable-line\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.} 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\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 /*, type */) {\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 /*, type */) {\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 || gl.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 === gl.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// NOTE: While querying GL is considered slow it's not remotely as slow\n// as uploading a texture. On top of that you're unlikely to call this in\n// a perf critical loop. Even if upload a texture every frame that's unlikely\n// to be more than 1 or 2 textures a frame. In other words, the benefits of\n// making the API easy to use outweigh any supposed perf benefits\n//\n// Also note I get that having one global of these is bad practice.\n// As long as it's used correctly it means no garbage which probably\n// doesn't matter when dealing with textures but old habits die hard.\nconst lastPackState = {};\n\n/**\n * Saves 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 savePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n lastPackState.colorspaceConversion = gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, options.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n lastPackState.premultiplyAlpha = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, options.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n lastPackState.flipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, options.flipY);\n }\n}\n\n/**\n * Restores any packing state that was 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 restorePackState(gl, options) {\n if (options.colorspaceConversion !== undefined) {\n gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, lastPackState.colorspaceConversion);\n }\n if (options.premultiplyAlpha !== undefined) {\n gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, lastPackState.premultiplyAlpha);\n }\n if (options.flipY !== undefined) {\n gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, lastPackState.flipY);\n }\n}\n\n/**\n * Saves state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction saveSkipState(gl) {\n lastPackState.unpackAlignment = gl.getParameter(gl.UNPACK_ALIGNMENT);\n if (utils.isWebGL2(gl)) {\n lastPackState.unpackRowLength = gl.getParameter(gl.UNPACK_ROW_LENGTH);\n lastPackState.unpackImageHeight = gl.getParameter(gl.UNPACK_IMAGE_HEIGHT);\n lastPackState.unpackSkipPixels = gl.getParameter(gl.UNPACK_SKIP_PIXELS);\n lastPackState.unpackSkipRows = gl.getParameter(gl.UNPACK_SKIP_ROWS);\n lastPackState.unpackSkipImages = gl.getParameter(gl.UNPACK_SKIP_IMAGES);\n }\n}\n\n/**\n * Restores state related to data size\n * @param {WebGLRenderingContext} gl the WebGLRenderingContext\n * @private\n */\nfunction restoreSkipState(gl) {\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, lastPackState.unpackAlignment);\n if (utils.isWebGL2(gl)) {\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, lastPackState.unpackRowLength);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, lastPackState.unpackImageHeight);\n gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, lastPackState.unpackSkipPixels);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, lastPackState.unpackSkipRows);\n gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, lastPackState.unpackSkipImages);\n }\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, gl.TEXTURE_MIN_FILTER, options.minMag);\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.minMag);\n }\n if (options.min) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_FILTER, options.min);\n }\n if (options.mag) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAG_FILTER, options.mag);\n }\n if (options.wrap) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrap);\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrap);\n if (target === gl.TEXTURE_3D || helper.isSampler(gl, target)) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrap);\n }\n }\n if (options.wrapR) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_R, options.wrapR);\n }\n if (options.wrapS) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_S, options.wrapS);\n }\n if (options.wrapT) {\n parameteriFn.call(gl, target, gl.TEXTURE_WRAP_T, options.wrapT);\n }\n if (options.minLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MIN_LOD, options.minLod);\n }\n if (options.maxLod) {\n parameteriFn.call(gl, target, gl.TEXTURE_MAX_LOD, options.maxLod);\n }\n if (options.baseLevel) {\n parameteriFn.call(gl, target, gl.TEXTURE_BASE_LEVEL, options.baseLevel);\n }\n if (options.maxLevel) {\n parameteriFn.call(gl, target, gl.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 || gl.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.} options A object of TextureOptions one per sampler.\n * @return {Object.} 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 * @param {number} [type] The type parameter for texImage2D etc..\n * @memberOf module:twgl/textures\n */\nfunction setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type) {\n options = options || defaults.textureOptions;\n internalFormat = internalFormat || gl.RGBA;\n type = type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n width = width || options.width;\n height = height || options.height;\n gl.bindTexture(target, tex);\n if (canGenerateMipmap(gl, width, height, internalFormat, type)) {\n gl.generateMipmap(target);\n } else {\n const filtering = canFilter(internalFormat, type) ? gl.LINEAR : gl.NEAREST;\n gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filtering);\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 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}\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 || gl.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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n gl.bindTexture(target, tex);\n if (target === gl.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 savePackState(gl, options);\n gl.bindTexture(target, tex);\n gl.texImage2D(f.face, level, internalFormat, format, type, imageBitmap);\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\n }\n });\n });\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n gl.pixelStorei(gl.UNPACK_ROW_LENGTH, element.width);\n gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0);\n gl.pixelStorei(gl.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(gl.UNPACK_SKIP_PIXELS, srcX);\n gl.pixelStorei(gl.UNPACK_SKIP_ROWS, srcY);\n gl.texSubImage3D(target, level, 0, 0, d, smallest, smallest, 1, format, type, element);\n }\n restoreSkipState(gl);\n } else {\n gl.texImage2D(target, level, internalFormat, format, type, element);\n }\n restorePackState(gl, options);\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.TEXTURE_2D_ARRAY) {\n gl.texImage3D(target, 0, gl.RGBA, 1, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);\n } else {\n gl.texImage2D(target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.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.} textures the created textures by name. Same as returned by {@link module:twgl.createTextures}.\n * @param {Object.} 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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D;\n if (target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || gl.UNSIGNED_BYTE;\n const target = options.target || gl.TEXTURE_2D_ARRAY;\n if (target !== gl.TEXTURE_3D && target !== gl.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 savePackState(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 restorePackState(gl, options);\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 || gl.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 || gl.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 === gl.TEXTURE_3D || target === gl.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 saveSkipState(gl);\n gl.pixelStorei(gl.UNPACK_ALIGNMENT, options.unpackAlignment || 1);\n savePackState(gl, options);\n if (target === gl.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 === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n restoreSkipState(gl);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n const format = options.format || formatType.format;\n const type = options.type || formatType.type;\n savePackState(gl, options);\n if (target === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, options.width, options.height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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 restorePackState(gl, options);\n}\n\n/**\n * Creates a texture based on the options passed in.\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 || gl.TEXTURE_2D;\n let width = options.width || 1;\n let height = options.height || 1;\n const internalFormat = options.internalFormat || gl.RGBA;\n const formatType = getFormatAndTypeForInternalFormat(internalFormat);\n let type = options.type || formatType.type;\n gl.bindTexture(target, tex);\n if (target === gl.TEXTURE_CUBE_MAP) {\n // this should have been the default for cubemaps :(\n gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.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 type = dimensions.type;\n } else if (Array.isArray(src) && (typeof (src[0]) === 'string' || isTexImageSource(src[0]))) {\n if (target === gl.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 } else {\n throw \"unsupported src type\";\n }\n } else {\n setEmptyTexture(gl, tex, options);\n }\n if (shouldAutomaticallySetTextureFilteringForSize(options)) {\n setTextureFilteringForSize(gl, tex, options, width, height, internalFormat, type);\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 || gl.TEXTURE_2D;\n gl.bindTexture(target, tex);\n const level = options.level || 0;\n const internalFormat = options.internalFormat || options.format || gl.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 === gl.TEXTURE_CUBE_MAP) {\n for (let ii = 0; ii < 6; ++ii) {\n gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + ii, level, internalFormat, width, height, 0, format, type, null);\n }\n } else if (target === gl.TEXTURE_3D || target === gl.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.} 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.} 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","export * from './twgl.js';\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] || (\"0x\" + value.toString(16));\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\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\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 = )` 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.} setters Attribute setters as returned from createAttributeSetters\n * @param {Object.} 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(gl.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.| 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":""} \ No newline at end of file diff --git a/npm/base/package.json b/npm/base/package.json index 8f1b201..7b8cf6c 100644 --- a/npm/base/package.json +++ b/npm/base/package.json @@ -1,6 +1,6 @@ { "name": "twgl-base.js", - "version": "4.13.0", + "version": "4.13.1", "description": "A Tiny WebGL helper library", "main": "dist/4.x/twgl.js", "types": "dist/4.x/twgl-full.d.ts",