wonder-image 2.1.2-alpha.2 → 2.1.2-alpha.21

package/dist/lib/swiperjs/swiper-plugin.js.LICENSE.txt

@@ -1,1174 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-/*
- * A fast javascript implementation of simplex noise by Jonas Wagner
-
-Based on a speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
-Which is based on example code by Stefan Gustavson (stegu@itn.liu.se).
-With Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
-Better rank ordering method by Stefan Gustavson in 2012.
-
- Copyright (c) 2022 Jonas Wagner
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- */
-
-/* glsl */
-
-/*#__PURE__*/
-
-/**
- * Adds two vec3's
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {vec3} out
- */
-
-/**
- * Builds a random permutation table.
- * This is exported only for (internal) testing purposes.
- * Do not rely on this export.
- * @private
- */
-
-/**
- * Calculates a 3x3 matrix from the given quaternion
- *
- * @param {mat3} out mat3 receiving operation result
- * @param {quat} q Quaternion to create matrix from
- *
- * @returns {mat3} out
- */
-
-/**
- * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
- *
- * @param {mat3} out mat3 receiving operation result
- * @param {mat4} a Mat4 to derive the normal matrix from
- *
- * @returns {mat3} out
- */
-
-/**
- * Calculates a 4x4 matrix from the given quaternion
- *
- * @param {mat4} out mat4 receiving operation result
- * @param {quat} q Quaternion to create matrix from
- *
- * @returns {mat4} out
- */
-
-/**
- * Calculates the conjugate of a quat
- * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
- *
- * @param {quat} out the receiving quaternion
- * @param {quat} a quat to calculate conjugate of
- * @returns {quat} out
- */
-
-/**
- * Calculates the determinant of a mat4
- *
- * @param {mat4} a the source matrix
- * @returns {Number} determinant of a
- */
-
-/**
- * Calculates the dot product of two vec3's
- *
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {Number} dot product of a and b
- */
-
-/**
- * Calculates the dot product of two vec4's
- *
- * @param {vec4} a the first operand
- * @param {vec4} b the second operand
- * @returns {Number} dot product of a and b
- */
-
-/**
- * Calculates the euclidian distance between two vec3's
- *
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {Number} distance between a and b
- */
-
-/**
- * Calculates the inverse of a quat
- *
- * @param {quat} out the receiving quaternion
- * @param {quat} a quat to calculate inverse of
- * @returns {quat} out
- */
-
-/**
- * Calculates the length of a vec3
- *
- * @param {vec3} a vector to calculate length of
- * @returns {Number} length of a
- */
-
-/**
- * Calculates the squared euclidian distance between two vec3's
- *
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {Number} squared distance between a and b
- */
-
-/**
- * Calculates the squared length of a vec3
- *
- * @param {vec3} a vector to calculate squared length of
- * @returns {Number} squared length of a
- */
-
-/**
- * Computes the cross product of two vec3's
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {vec3} out
- */
-
-/**
- * Copies the upper-left 3x3 values into the given mat3.
- *
- * @param {mat3} out the receiving 3x3 matrix
- * @param {mat4} a   the source 4x4 matrix
- * @returns {mat3} out
- */
-
-/**
- * Copy the values from one mat3 to another
- *
- * @param {mat3} out the receiving matrix
- * @param {mat3} a the source matrix
- * @returns {mat3} out
- */
-
-/**
- * Copy the values from one mat4 to another
- *
- * @param {mat4} out the receiving matrix
- * @param {mat4} a the source matrix
- * @returns {mat4} out
- */
-
-/**
- * Copy the values from one quat to another
- *
- * @param {quat} out the receiving quaternion
- * @param {quat} a the source quaternion
- * @returns {quat} out
- * @function
- */
-
-/**
- * Copy the values from one vec3 to another
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the source vector
- * @returns {vec3} out
- */
-
-/**
- * Copy the values from one vec4 to another
- *
- * @param {vec4} out the receiving vector
- * @param {vec4} a the source vector
- * @returns {vec4} out
- */
-
-/**
- * Creates a 2D noise function
- * @param random the random function that will be used to build the permutation table
- * @returns {NoiseFunction2D}
- */
-
-/**
- * Creates a matrix from a quaternion rotation, vector translation and vector scale
- * This is equivalent to (but much faster than):
- *
- *     mat4.identity(dest);
- *     mat4.translate(dest, vec);
- *     let quatMat = mat4.create();
- *     quat4.toMat4(quat, quatMat);
- *     mat4.multiply(dest, quatMat);
- *     mat4.scale(dest, scale)
- *
- * @param {mat4} out mat4 receiving operation result
- * @param {quat4} q Rotation quaternion
- * @param {vec3} v Translation vector
- * @param {vec3} s Scaling vector
- * @returns {mat4} out
- */
-
-/**
- * Creates a quaternion from the given 3x3 rotation matrix.
- *
- * NOTE: The resultant quaternion is not normalized, so you should be sure
- * to renormalize the quaternion yourself where necessary.
- *
- * @param {quat} out the receiving quaternion
- * @param {mat3} m rotation matrix
- * @returns {quat} out
- * @function
- */
-
-/**
- * Creates a quaternion from the given euler angle x, y, z.
- *
- * @param {quat} out the receiving quaternion
- * @param {vec3} euler Angles to rotate around each axis in degrees.
- * @param {String} order detailing order of operations. Default 'XYZ'.
- * @returns {quat} out
- * @function
- */
-
-/**
- * Divides two vec3's
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {vec3} out
- */
-
-/**
- * Generates a matrix that makes something look at something else.
- *
- * @param {mat4} out mat4 frustum matrix will be written into
- * @param {vec3} eye Position of the viewer
- * @param {vec3} target Point the viewer is looking at
- * @param {vec3} up vec3 pointing up
- * @returns {mat4} out
- */
-
-/**
- * Generates a orthogonal projection matrix with the given bounds
- *
- * @param {mat4} out mat4 frustum matrix will be written into
- * @param {number} left Left bound of the frustum
- * @param {number} right Right bound of the frustum
- * @param {number} bottom Bottom bound of the frustum
- * @param {number} top Top bound of the frustum
- * @param {number} near Near bound of the frustum
- * @param {number} far Far bound of the frustum
- * @returns {mat4} out
- */
-
-/**
- * Generates a perspective projection matrix with the given bounds
- *
- * @param {mat4} out mat4 frustum matrix will be written into
- * @param {number} fovy Vertical field of view in radians
- * @param {number} aspect Aspect ratio. typically viewport width/height
- * @param {number} near Near bound of the frustum
- * @param {number} far Far bound of the frustum
- * @returns {mat4} out
- */
-
-/**
- * Get the angle between two 3D vectors
- * @param {vec3} a The first operand
- * @param {vec3} b The second operand
- * @returns {Number} The angle in radians
- */
-
-/**
- * Inverts a mat3
- *
- * @param {mat3} out the receiving matrix
- * @param {mat3} a the source matrix
- * @returns {mat3} out
- */
-
-/**
- * Inverts a mat4
- *
- * @param {mat4} out the receiving matrix
- * @param {mat4} a the source matrix
- * @returns {mat4} out
- */
-
-/**
- * Multiplies two mat3's
- *
- * @param {mat3} out the receiving matrix
- * @param {mat3} a the first operand
- * @param {mat3} b the second operand
- * @returns {mat3} out
- */
-
-/**
- * Multiplies two mat4s
- *
- * @param {mat4} out the receiving matrix
- * @param {mat4} a the first operand
- * @param {mat4} b the second operand
- * @returns {mat4} out
- */
-
-/**
- * Multiplies two quats
- *
- * @param {quat} out the receiving quaternion
- * @param {quat} a the first operand
- * @param {quat} b the second operand
- * @returns {quat} out
- */
-
-/**
- * Multiplies two vec3's
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {vec3} out
- */
-
-/**
- * Negates the components of a vec3
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a vector to negate
- * @returns {vec3} out
- */
-
-/**
- * Normalize a vec3
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a vector to normalize
- * @returns {vec3} out
- */
-
-/**
- * Normalize a vec4
- *
- * @param {vec4} out the receiving vector
- * @param {vec4} a vector to normalize
- * @returns {vec4} out
- */
-
-/**
- * Performs a linear interpolation between two vec3's
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @param {Number} t interpolation amount between the two inputs
- * @returns {vec3} out
- */
-
-/**
- * Performs a spherical linear interpolation between two quat
- *
- * @param {quat} out the receiving quaternion
- * @param {quat} a the first operand
- * @param {quat} b the second operand
- * @param {Number} t interpolation amount between the two inputs
- * @returns {quat} out
- */
-
-/**
- * Returns a quaternion representing the rotational component
- *  of a transformation matrix. If a matrix is built with
- *  fromRotationTranslation, the returned quaternion will be the
- *  same as the quaternion originally supplied.
- * @param {quat} out Quaternion to receive the rotation component
- * @param {mat4} mat Matrix to be decomposed (input)
- * @return {quat} out
- */
-
-/**
- * Returns the inverse of the components of a vec3
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a vector to invert
- * @returns {vec3} out
- */
-
-/**
- * Returns the scaling factor component of a transformation
- *  matrix. If a matrix is built with fromRotationTranslationScale
- *  with a normalized Quaternion paramter, the returned vector will be
- *  the same as the scaling vector
- *  originally supplied.
- * @param  {vec3} out Vector to receive scaling factor component
- * @param  {mat4} mat Matrix to be decomposed (input)
- * @return {vec3} out
- */
-
-/**
- * Returns the translation vector component of a transformation
- *  matrix. If a matrix is built with fromRotationTranslation,
- *  the returned vector will be the same as the translation vector
- *  originally supplied.
- * @param  {vec3} out Vector to receive translation component
- * @param  {mat4} mat Matrix to be decomposed (input)
- * @return {vec3} out
- */
-
-/**
- * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
- *
- * @param {vec3} a The first vector.
- * @param {vec3} b The second vector.
- * @returns {Boolean} True if the vectors are equal, false otherwise.
- */
-
-/**
- * Rotates a mat3 by the given angle
- *
- * @param {mat3} out the receiving matrix
- * @param {mat3} a the matrix to rotate
- * @param {Number} rad the angle to rotate the matrix by
- * @returns {mat3} out
- */
-
-/**
- * Rotates a mat4 by the given angle around the given axis
- *
- * @param {mat4} out the receiving matrix
- * @param {mat4} a the matrix to rotate
- * @param {Number} rad the angle to rotate the matrix by
- * @param {vec3} axis the axis to rotate around
- * @returns {mat4} out
- */
-
-/**
- * Rotates a quaternion by the given angle about the X axis
- *
- * @param {quat} out quat receiving operation result
- * @param {quat} a quat to rotate
- * @param {number} rad angle (in radians) to rotate
- * @returns {quat} out
- */
-
-/**
- * Rotates a quaternion by the given angle about the Y axis
- *
- * @param {quat} out quat receiving operation result
- * @param {quat} a quat to rotate
- * @param {number} rad angle (in radians) to rotate
- * @returns {quat} out
- */
-
-/**
- * Rotates a quaternion by the given angle about the Z axis
- *
- * @param {quat} out quat receiving operation result
- * @param {quat} a quat to rotate
- * @param {number} rad angle (in radians) to rotate
- * @returns {quat} out
- */
-
-/**
- * Same as above but doesn't apply translation.
- * Useful for rays.
- */
-
-/**
- * Scales a vec3 by a scalar number
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the vector to scale
- * @param {Number} b amount to scale the vector by
- * @returns {vec3} out
- */
-
-/**
- * Scales a vec4 by a scalar number
- *
- * @param {vec4} out the receiving vector
- * @param {vec4} a the vector to scale
- * @param {Number} b amount to scale the vector by
- * @returns {vec4} out
- */
-
-/**
- * Scales the mat3 by the dimensions in the given vec2
- *
- * @param {mat3} out the receiving matrix
- * @param {mat3} a the matrix to rotate
- * @param {vec2} v the vec2 to scale the matrix by
- * @returns {mat3} out
- **/
-
-/**
- * Scales the mat4 by the dimensions in the given vec3 not using vectorization
- *
- * @param {mat4} out the receiving matrix
- * @param {mat4} a the matrix to scale
- * @param {vec3} v the vec3 to scale the matrix by
- * @returns {mat4} out
- **/
-
-/**
- * Set a mat3 to the identity matrix
- *
- * @param {mat3} out the receiving matrix
- * @returns {mat3} out
- */
-
-/**
- * Set a mat4 to the identity matrix
- *
- * @param {mat4} out the receiving matrix
- * @returns {mat4} out
- */
-
-/**
- * Set a quat to the identity quaternion
- *
- * @param {quat} out the receiving quaternion
- * @returns {quat} out
- */
-
-/**
- * Set the components of a mat3 to the given values
- *
- * @param {mat3} out the receiving matrix
- * @returns {mat3} out
- */
-
-/**
- * Set the components of a mat4 to the given values
- *
- * @param {mat4} out the receiving matrix
- * @returns {mat4} out
- */
-
-/**
- * Set the components of a quat to the given values
- *
- * @param {quat} out the receiving quaternion
- * @param {Number} x X component
- * @param {Number} y Y component
- * @param {Number} z Z component
- * @param {Number} w W component
- * @returns {quat} out
- * @function
- */
-
-/**
- * Set the components of a vec3 to the given values
- *
- * @param {vec3} out the receiving vector
- * @param {Number} x X component
- * @param {Number} y Y component
- * @param {Number} z Z component
- * @returns {vec3} out
- */
-
-/**
- * Set the components of a vec4 to the given values
- *
- * @param {vec4} out the receiving vector
- * @param {Number} x X component
- * @param {Number} y Y component
- * @param {Number} z Z component
- * @param {Number} w W component
- * @returns {vec4} out
- */
-
-/**
- * Sets a quat from the given angle and rotation axis,
- * then returns it.
- *
- * @param {quat} out the receiving quaternion
- * @param {vec3} axis the axis around which to rotate
- * @param {Number} rad the angle in radians
- * @returns {quat} out
- **/
-
-/**
- * Subtracts vector b from vector a
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the first operand
- * @param {vec3} b the second operand
- * @returns {vec3} out
- */
-
-/**
- * Transforms the vec3 with a mat3.
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the vector to transform
- * @param {mat3} m the 3x3 matrix to transform with
- * @returns {vec3} out
- */
-
-/**
- * Transforms the vec3 with a mat4.
- * 4th vector component is implicitly '1'
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the vector to transform
- * @param {mat4} m matrix to transform with
- * @returns {vec3} out
- */
-
-/**
- * Transforms the vec3 with a quat
- *
- * @param {vec3} out the receiving vector
- * @param {vec3} a the vector to transform
- * @param {quat} q quaternion to transform with
- * @returns {vec3} out
- */
-
-/**
- * Translate a mat3 by the given vector
- *
- * @param {mat3} out the receiving matrix
- * @param {mat3} a the matrix to translate
- * @param {vec2} v vector to translate by
- * @returns {mat3} out
- */
-
-/**
- * Translate a mat4 by the given vector
- *
- * @param {mat4} out the receiving matrix
- * @param {mat4} a the matrix to translate
- * @param {vec3} v vector to translate by
- * @returns {mat4} out
- */
-
-/**
- * UI Initiative Carousel Slider
- *
- * Infinite 3D carousel slider
- *
- * https://uiinitiative.com
- *
- * Copyright 2023 UI Initiative
- *
- * Released under the UI Initiative Regular License
- *
- * December 27, 2023
- */
-
-/**
- * UI Initiative Material You Slider
- *
- * Material You Carousel made with Swiper
- *
- * https://uiinitiative.com
- *
- * Copyright 2024 UI Initiative
- *
- * Released under the UI Initiative Regular License
- *
- * April 29, 2024
- */
-
-/**
- * UI Initiative Shutters Slider
- *
- * Infinite 3D carousel slider
- *
- * https://uiinitiative.com
- *
- * Copyright 2023 UI Initiative
- *
- * Released under the UI Initiative Regular License
- *
- * October 25, 2023
- */
-
-/**
- * UI Initiative Slicer Slider
- *
- * Images slicer slider
- *
- * https://uiinitiative.com
- *
- * Copyright 2023 UI Initiative
- *
- * Released under the UI Initiative Regular License
- *
- * October 25, 2023
- *
- */
-
-/**
- * UI Initiative Swiper GL
- *
- * Stunning WebGL image transitions
- *
- * https://uiinitiative.com
- *
- * Copyright 2024 UI Initiative
- *
- * Released under the UI Initiative Regular License
- *
- * April 25, 2024
- */
-
-/************************************************************************/
-
-/******/
-
-/***/
-
-// 
-
-//    http://jsperf.com/quaternion-slerp-implementations
-
-//  ... so we can do a linear interpolation
-
-// "from" and "to" quaternions are very close
-
-// +x
-
-// +y
-
-// +z (far)
-
-// -x
-
-// -y
-
-// -z (near)
-
-// ./node_modules/color.js/dist/color.esm.js
-
-// ./src/build/lib/swiperjs/effect-carousel.esm.js
-
-// ./src/build/lib/swiperjs/effect-material.esm.js
-
-// ./src/build/lib/swiperjs/effect-shutters.esm.js
-
-// ./src/build/lib/swiperjs/effect-slicer.esm.js
-
-// ./src/export/lib/swiperjs/swiper-plugin.js
-
-// ./src/vendor/swiperjs/swiper-gl.esm.js
-
-// 1/(4w)
-
-// 2w
-
-// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
-
-// ACTIVE SLIDES
-
-// Add contributions from each corner to get the final noise value.
-
-// Add empty matrix uniforms to program if unset
-
-// Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
-
-// Alias for state store to avoid redundant calls for global state
-
-// Already bound to active texture unit
-
-// Attach renderer to gl so that all classes have access to internal state functions
-
-// Attempt WebGL2 unless forced to 1, if not supported fallback to WebGL1
-
-// Avoid gl call if program already in use
-
-// Avoid redundant uniform commands
-
-// BOOL
-
-// BOOL_VEC2
-
-// BOOL_VEC3
-
-// BOOL_VEC4
-
-// Bind indices if geometry indexed
-
-// CENTERED/ACTIVE SLIDES
-
-// Calculate the contribution from the three corners
-
-// Calculate the determinant
-
-// Callback for when data is pushed to GPU
-
-// Can't use 'length' as Array.prototype uses it
-
-// Check for IE =< 8
-
-// Check if any attributes need updating
-
-// Check if module is in cache
-
-// Check if texture needs to be updated
-
-// Compressed texture
-
-// Construct the elements of the rotation matrix
-
-// Create a new module (and put it into the cache)
-
-// Create method aliases using extension (WebGL1) or native if available (WebGL2)
-
-// Data texture
-
-// Determine which simplex we are in.
-
-// Ensure depth buffer writing is enabled so it can be cleared
-
-// Execute the module function
-
-// FLOAT
-
-// FLOAT_MAT2
-
-// FLOAT_MAT3
-
-// FLOAT_MAT4
-
-// FLOAT_VEC2
-
-// FLOAT_VEC3
-
-// FLOAT_VEC4
-
-// For WebGL1, if not a power of 2, turn off mips, set wrapping to clamp to edge and minFilter to linear
-
-// For cube maps
-
-// For firefox, need to set back to 0 if non-instanced drawn after instanced. Else won't render
-
-// For instanced attributes, divisor needs to be set.
-
-// For matrix attributes, buffer needs to be defined per column
-
-// For structs, get the specific property instead of the entire object
-
-// For texture arrays, set uniform as an array of texture units instead of just one
-
-// For the 2D case, the simplex shape is an equilateral triangle.
-
-// Get active attribute locations
-
-// Get active uniform locations
-
-// Get visible
-
-// Hairy factor for 2D
-
-// INT
-
-// INT_VEC2
-
-// INT_VEC3
-
-// INT_VEC4
-
-// If geometry missing a required shader attribute
-
-// If no position attribute, treat as frustumCulled false
-
-// If the source and destination differ, copy the unchanged last row
-
-// Ignore special built-in inputs. eg gl_VertexID, gl_InstanceID
-
-// Initialise extra format types
-
-// Link all attributes to program using gl.vertexAttribPointer
-
-// Make sure that texture is bound to its texture unit
-
-// NOT CENTERED SLIDES
-
-// Noise contributions from the three corners
-
-// Not automatic - devs to use these methods manually
-
-// Offsets for middle corner in (x,y) unskewed coords
-
-// Offsets for second (middle) corner of simplex in (i,j) coords
-
-// Only calculate z-depth if renderOrder unset and depthTest is true
-
-// Override sorting to force an order
-
-// Perform rotation-specific matrix multiplication
-
-// Project 3D coordinate to 2D point
-
-// Push data to buffer
-
-// Quaternion math
-
-// Regular texture
-
-// Remove shader once linked
-
-// Return null if extension not supported
-
-// Return the exports of the module
-
-// Return true in callback to stop traversing children
-
-// SAMPLER_2D
-
-// SAMPLER_CUBE
-
-// SLIDES BEFORE ACTIVE SLIDE / PREVIOUS
-
-// Set only the active uniforms found in the shader
-
-// Set options
-
-// Set the matrix uniforms
-
-// Skew the input space to determine which simplex cell we're in
-
-// Split into the 3 render groups
-
-// State store to avoid redundant calls for per-texture state
-
-// Store device parameters
-
-// Store one VAO per program attribute locations order
-
-// Store program state
-
-// Swiper JS Plugin
-
-// TODO: Handle context loss https://www.khronos.org/webgl/wiki/HandlingContextLost
-
-// TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
-
-// TODO: check size of position (eg triangle with Vec2)
-
-// TODO: currently unused, remove?
-
-// TODO: delete texture
-
-// TODO: need? encoding = linearEncoding
-
-// TODO: sampler Cube
-
-// TODO: support non-compressed mipmaps uploads
-
-// TODO: upload empty texture if null ? maybe not
-
-// TODO: upload identity matrix if null ?
-
-// TODO: use texSubImage2D for updates (video or when loaded)
-
-// The module cache
-
-// The require function
-
-// The result is scaled to return values in the interval [-1,1].
-
-// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
-
-// Uint32Array
-
-// Unbind current VAO so that new buffers don't get added to active mesh
-
-// Unproject 2D point to 3D coordinate
-
-// Update cached array values
-
-// Update camera separately, in case not in scene graph
-
-// Update geometry counts. If indexed, ignore regular attributes
-
-// Upload empty pixel for each side while no image to avoid errors while image or video loading
-
-// Upload empty pixel if no image to avoid errors while image or video loading
-
-// Use orthographic if left/right set, else default to perspective camera
-
-// Use position buffer, or min/max if available
-
-// Used to skip frustum culling
-
-// [ https://uiinitiative.com/catalog/carousel-slider ]
-
-// [ https://uiinitiative.com/catalog/material-you-slider ]
-
-// [ https://uiinitiative.com/catalog/shaders-slider ]
-
-// [ https://uiinitiative.com/catalog/shutters-slider ]
-
-// [ https://uiinitiative.com/catalog/slicer-slider ]
-
-// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
-
-// adjust signs (if necessary)
-
-// article "Quaternion Calculus and Fast Animation".
-
-// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
-
-// attribute params
-
-// benchmarks:
-
-// benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed
-
-// bind supplied render target and update viewport
-
-// c = (3-sqrt(3))/6
-
-// cache of typed arrays used to flatten uniform arrays
-
-// calc cosine
-
-// calculate coefficients
-
-// calculate final values
-
-// clone array to store as cache
-
-// compile fragment shader and log errors
-
-// compile program and log errors
-
-// compile vertex shader and log errors
-
-// create the buffers
-
-// current to large
-
-// current to zero
-
-// depthTest false
-
-// determine if faces need to be flipped - when mesh scaled negatively
-
-// eslint-disable-next-line
-
-// eye and target are in the same position
-
-// fetch extension once only
-
-// first triangle
-
-// get supplied uniform
-
-// gl state stores to avoid redundant calls on methods used internally
-
-// gl.clearColor( r, g, b, a );
-
-// gl.clearStencil( stencil );
-
-// gl.colorMask( colorMask, colorMask, colorMask, colorMask );
-
-// gl.stencilFunc( stencilFunc, stencilRef, stencilMask );
-
-// gl.stencilMask( stencilMask );
-
-// gl.stencilOp( stencilFail, stencilZFail, stencilZPass );
-
-// if (attr.min) return [...attr.min, ...attr.max];
-
-// if webgl2 function supported, return func bound to gl context
-
-// if(!isFinite(x) || !isFinite(y)) return 0;
-
-// image intentionally left null for RenderTarget
-
-// initialise size values
-
-// large to zero
-
-// let translateAdd = 0;
-
-// make sure no render target bound so draws to canvas
-
-// mat2
-
-// mat3
-
-// mat4
-
-// n0 = t0 * t0 * (grad2[gi0] * x0 + grad2[gi0 + 1] * y0); // (x,y) of grad3 used for 2D gradient
-
-// n1 = t1 * t1 * (grad2[gi1] * x1 + grad2[gi1 + 1] * y1);
-
-// n2 = t2 * t2 * (grad2[gi2] * x2 + grad2[gi2 + 1] * y2);
-
-// no module.id needed
-
-// no module.loaded needed
-
-// precalculating this yields a little ~3% performance improvement.
-
-// return extension if no function requested
-
-// second triangle
-
-// set active texture unit to perform texture functions
-
-// set default blendFunc if transparent flagged
-
-// side: DoubleSide,
-
-// sign =1
-
-// small to large: 0.35 -> 0.65
-
-// split uniforms' names to separate array and struct declarations
-
-// standard case (slerp)
-
-// store requested extensions
-
-// up and z are parallel
-
-// update z-depth
-
-// updates all scene graph matrices
-
-// upper triangle, YX order: (0,0)->(0,1)->(1,1)
-
-// used for RenderTargets or Data Textures
-
-// used for sorting
-
-// webpackBootstrap
-
-// zero to current
-
-// zero to small: 0 -> 0.35
-
-// |w| <= 1/2
-
-// |w| > 1/2, may as well choose w > 1/2
-
-//TODO: evaluate use of glm_invsqrt here?