powerups.module.js.map

{"version":3,"file":"powerups.module.js","sources":["../powerups/WebGLText.tsx","../powerups/WebGLImage.tsx","../powerups/ParallaxScrollScene.tsx","../../node_modules/vecn/src/index.js","../powerups/StickyScrollScene.tsx","../../node_modules/@14islands/lerp/index.js","../../node_modules/lerp/index.js"],"sourcesContent":["import React, { useMemo, useEffect, ReactNode, MutableRefObject } from 'react'\nimport { Color, Material } from 'three'\nimport { useThree } from '@react-three/fiber'\nimport { Text } from '@react-three/drei'\n\nimport { useScrollRig } from '@14islands/r3f-scroll-rig'\n\n/**\n * Returns a WebGL Troika text mesh styled as the source DOM element\n */\n\ninterface WebGLTextProps {\n  el: MutableRefObject<HTMLElement>\n  children?: ReactNode\n  material?: Material\n  scale?: any\n  font?: string\n  fontOffsetY?: number\n  fontOffsetX?: number\n  overrideEmissive?: boolean\n  color?: string\n}\n\nexport const WebGLText = ({\n  el,\n  children,\n  material,\n  scale,\n  font,\n  fontOffsetY = 0,\n  fontOffsetX = 0,\n  overrideEmissive = false,\n  color,\n  ...props\n}: WebGLTextProps) => {\n  const { size } = useThree()\n  const { scaleMultiplier } = useScrollRig()\n\n  const { textColor, fontSize, textAlign, lineHeight, letterSpacing } = useMemo(() => {\n    if (!el.current) return {}\n    const cs = window.getComputedStyle(el.current)\n\n    // get color from parent if set to transparent\n    let textColor = color || cs.color\n    if (!color && cs.color === 'rgba(0, 0, 0, 0)' && el.current.parentElement) {\n      textColor = window.getComputedStyle(el.current.parentElement).color\n    }\n\n    // font size relative letter spacing\n    const letterSpacing = (parseFloat(cs.letterSpacing) || 0) / parseFloat(cs.fontSize)\n    const lineHeight = (parseFloat(cs.lineHeight) || 0) / parseFloat(cs.fontSize)\n\n    return {\n      letterSpacing,\n      lineHeight,\n      textColor,\n      fontSize: parseFloat(cs.fontSize) * scaleMultiplier,\n      textAlign: cs.textAlign,\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [el, size, scale, color, scaleMultiplier]) // recalc on resize\n\n  useEffect(() => {\n    if (material && overrideEmissive) {\n      // @ts-ignore\n      material.emissive = color\n    }\n  }, [material, color, overrideEmissive])\n\n  let xOffset = 0\n  if (textAlign === 'left' || textAlign === 'start') {\n    xOffset = scale[0] * -0.5\n  } else if (textAlign === 'right' || textAlign === 'end') {\n    xOffset = scale[0] * 0.5\n  }\n\n  const yOffset = scale ? scale[1] * 0.5 : size.height * 0.5\n\n  return (\n    <Text\n      fontSize={fontSize}\n      maxWidth={scale ? scale[0] : size.width}\n      lineHeight={lineHeight}\n      // @ts-ignore\n      textAlign={textAlign}\n      letterSpacing={letterSpacing}\n      overflowWrap=\"break-word\"\n      font={font}\n      color={textColor}\n      // @ts-ignore\n      anchorX={textAlign}\n      anchorY=\"top\" // so text moves down if row breaks\n      // @ts-ignore\n      position={[xOffset + fontSize * fontOffsetX, yOffset + fontSize * fontOffsetY, 0]} // font specific\n      material={material}\n      {...props}\n    >\n      {children}\n    </Text>\n  )\n}\n","import React, {\n  useRef,\n  useMemo,\n  useEffect,\n  forwardRef,\n  MutableRefObject,\n  ForwardedRef,\n  useImperativeHandle,\n} from 'react'\nimport { Color, Vector2, ShaderMaterial, Mesh, ShaderMaterialParameters } from 'three'\nimport { useFrame, useThree } from '@react-three/fiber'\n\nimport { useScrollRig, useImageAsTexture, useScrollbar } from '@14islands/r3f-scroll-rig'\n\ninterface WebGLImageProps {\n  el: MutableRefObject<HTMLImageElement>\n  scale?: any\n  scrollState?: any\n  vertexShader?: string\n  fragmentShader?: string\n  invalidateFrameLoop: boolean\n  widthSegments?: number\n  heightSegments?: number\n}\n\nexport const WebGLImage = forwardRef(\n  (\n    {\n      el,\n      scale,\n      scrollState,\n      vertexShader,\n      fragmentShader,\n      invalidateFrameLoop = false,\n      widthSegments = 128,\n      heightSegments = 128,\n      ...props\n    }: WebGLImageProps,\n    ref: ForwardedRef<Mesh>\n  ) => {\n    const material = useRef<ShaderMaterial>(null!)\n    const mesh = useRef<Mesh>(null!)\n    useImperativeHandle(ref, () => mesh.current)\n\n    const { invalidate, gl, size } = useThree()\n    const pixelRatio = useThree((s) => s.viewport.dpr)\n    const { scroll } = useScrollbar()\n    const { scaleMultiplier } = useScrollRig()\n\n    const texture = useImageAsTexture(el)\n\n    const uniforms = useMemo(() => {\n      return {\n        u_color: { value: new Color('black') },\n        u_time: { value: 0 },\n        u_pixelRatio: { value: pixelRatio },\n        u_progress: { value: 0 },\n        u_visibility: { value: 0 },\n        u_viewport: { value: 0 },\n        u_velocity: { value: 0 }, // scroll speed\n        u_res: { value: new Vector2() }, // screen dimensions\n        u_rect: { value: new Vector2() }, // DOM el dimensions\n        u_size: { value: new Vector2() }, // Texture dimensions\n        u_texture: { value: null },\n        u_loaded: { value: false },\n        u_scaleMultiplier: { value: scaleMultiplier },\n      }\n    }, [pixelRatio])\n\n    // Fade in when texture loaded\n    useEffect(() => {\n      if (!texture) return\n      if (!material.current) return\n      material.current.uniforms.u_texture.value = texture\n      material.current.uniforms.u_size.value.set(texture.image.width, texture.image.height)\n      material.current.uniforms.u_loaded.value = true\n    }, [texture, gl])\n\n    useEffect(() => {\n      if (!material.current) return\n      material.current.uniforms.u_res.value.set(size.width, size.height)\n      material.current.uniforms.u_rect.value.set(scale?.[0], scale?.[1])\n    }, [size, scale])\n\n    useFrame((_, delta) => {\n      if (!scrollState.inViewport || !mesh.current || !material.current) return\n\n      if (!material.current.uniforms.u_loaded.value) return\n\n      material.current.uniforms.u_time.value += delta\n\n      // update scale while animating too\n      material.current.uniforms.u_rect.value.set(mesh.current.scale.x, mesh.current.scale.y)\n\n      // px velocity\n      material.current.uniforms.u_velocity.value = scroll.velocity\n\n      // percent of total visible distance that was scrolled (0 = just outside bottom of screen, 1 = just outside top of screen)\n      material.current.uniforms.u_progress.value = scrollState.progress\n\n      // percent of item height in view\n      material.current.uniforms.u_visibility.value = scrollState.visibility\n      // percent of window height scrolled since visible\n      material.current.uniforms.u_viewport.value = scrollState.viewport\n\n      if (invalidateFrameLoop) invalidate()\n    })\n\n    const args = useMemo(\n      () => [\n        {\n          vertexShader,\n          fragmentShader,\n        },\n      ],\n      [vertexShader, fragmentShader]\n    )\n\n    return (\n      <>\n        <mesh ref={mesh} {...props}>\n          <planeGeometry attach=\"geometry\" args={[1, 1, widthSegments, heightSegments]} />\n          <shaderMaterial\n            ref={material}\n            args={args as [ShaderMaterialParameters]}\n            transparent={true}\n            uniforms={uniforms}\n          />\n        </mesh>\n      </>\n    )\n  }\n)\n","import React, { useRef } from 'react'\nimport { useFrame, useThree } from '@react-three/fiber'\nimport { Mesh } from 'three'\n\nimport { ScrollScene, useScrollRig } from '@14islands/r3f-scroll-rig'\n\n// Parallax group inside ScrollScene\nconst ParallaxGroup = ({ children, scrollState, parallax }: any) => {\n  const mesh = useRef<Mesh>(null!)\n  const size = useThree((s) => s.size)\n  const { scaleMultiplier } = useScrollRig()\n\n  useFrame(() => {\n    if (!scrollState.inViewport) return\n    const parallaxProgress = scrollState.progress * 2 - 1\n    mesh.current.position.y = parallax * parallaxProgress * scaleMultiplier * size.height\n  })\n\n  return <mesh ref={mesh}>{children}</mesh>\n}\n\n/* Speed=1 is no parallax */\nexport const ParallaxScrollScene = ({ children, speed = 1, ...props }: any) => {\n  const extraMargin = 50 // add 50vh extra margin to avoid aggressive clipping\n  const parallaxAmount = speed - 1\n  return (\n    // @ts-ignore\n    <ScrollScene scissor={false} inViewportMargin={`${Math.max(0, 1 - 0.5) * 200 + extraMargin}%`} {...props}>\n      {(props) => (\n        <ParallaxGroup parallax={parallaxAmount} {...props}>\n          {children(props)}\n        </ParallaxGroup>\n      )}\n    </ScrollScene>\n  )\n}\n","/**\n * An object for memoizing vecType functions.\n * @type {Object}\n * @private\n */\nlet vecTypes = (function () {\n  const handler = {\n    get: function (obj, prop) {\n      if (!obj.hasOwnProperty(prop)) {\n        obj[prop] = getVecType(prop)\n      }\n      return obj[prop]\n    }\n  }\n\n  return new Proxy({}, handler)\n})()\n\n/**\n * A class for fixed-size vectors of numbers.\n * @extends Array\n */\nclass vecn extends Array {\n  /**\n   * Creates a vecn of the specified dimension. This should never be called\n   * by the user (as if this were an abstract class).\n   * @param {number} dimension The dimension of this vector.\n   * @param {number[]} [args=[]] The numbers to be put in the vector.\n   */\n  constructor (dimension, args) {\n    args = flattenOuter(args)\n\n    if (!args.every((x) => type(x) === 'Number')) {\n      throw new TypeError('All arguments must be numbers.')\n    }\n    if (args.length > 1 && args.length !== dimension) {\n      throw new Error('Argument list must be empty, have a single number, or have a length equal to the dimension.')\n    }\n\n    if (args.length === 0) {\n      args = [0]\n    }\n    if (args.length === 1 && type(args[0]) === 'Number') {\n      args = Array(dimension).fill(args[0])\n    }\n\n    if (dimension > 1) {\n      super(...args)\n    } else {\n      super(1)\n      this[0] = args[0]\n    }\n\n    Reflect.defineProperty(this, 'pop', {\n      value: undefined,\n      enumerable: false\n    })\n    Reflect.defineProperty(this, 'push', {\n      value: undefined,\n      enumerable: false\n    })\n    Reflect.defineProperty(this, 'shift', {\n      value: undefined,\n      enumerable: false\n    })\n    Reflect.defineProperty(this, 'unshift', {\n      value: undefined,\n      enumerable: false\n    })\n  }\n\n  /**\n   * The L2 norm (Euclidian norm) of the vector.\n   * @type {number}\n   */\n  get magnitude () {\n    return this.pnorm(2)\n  }\n\n  // --------------------------------------------------------------------------\n  //   Arithmetic\n\n  /**\n   * Returns a vector where this is divided by v componentwise. If v is\n   * a single number, the vector is scaled by 1/v.\n   * @param {number|number[]} v The value to multiply with.\n   *\n   * @returns {vecn} A new vector with the divided components.\n   */\n  div (v) {\n    checkCompatibility(v, this.dim, true)\n    if (type(v) === 'Number') {\n      v = (new Array(this.dim)).fill(v)\n    }\n\n    let result = []\n    for (let i = 0; i < this.length; ++i) {\n      result[i] = this[i] / v[i]\n    }\n    return vecTypes[this.dim](result)\n  }\n\n  /**\n   * Returns a vector where v is subtracted from the components of this\n   * vector. If v is a single number, it is subtracted to each component. If v\n   * is a vector, the vectors are combined componentwise.\n   * @param {number|number[]} v The value to subtract from this vector.\n   *\n   * @returns {vecn} A new vector with the combined components.\n   */\n  minus (v) {\n    checkCompatibility(v, this.dim, true)\n    if (type(v) === 'Number') {\n      v = (new Array(this.dim)).fill(v)\n    }\n\n    let result = []\n    for (let i = 0; i < this.dim; ++i) {\n      result[i] = this[i] - v[i]\n    }\n    return vecTypes[this.dim](result)\n  }\n\n  /**\n   * Negates each element in this vector.\n   * @returns {vecn} A new vector where all elements are negated.\n   */\n  neg () {\n    return vecTypes[this.dim](this.times(-1))\n  }\n\n  /**\n   * Returns a vector where v is added to the components of this vector. If v\n   * is a single number, it is added to each component. If v is a vector, the\n   * vectors are added componentwise.\n   * @param {number|number[]} v The value to add to this vector.\n   *\n   * @returns {vecn} A new vector with the summed components.\n   */\n  plus (v) {\n    checkCompatibility(v, this.dim, true)\n    if (type(v) === 'Number') {\n      v = (new Array(this.dim)).fill(v)\n    }\n\n    let result = []\n    for (let i = 0; i < this.dim; ++i) {\n      result[i] = this[i] + v[i]\n    }\n    return vecTypes[this.dim](result)\n  }\n\n  /**\n   * Returns a vector where each component of this was raised to a power p.\n   * @param {number} p The power to raise each component by.\n   *\n   * @returns {vecn} A new vector with the exponentiated components.\n   */\n  pow (p) {\n    let result = []\n    for (let i = 0; i < this.dim; ++i) {\n      result[i] = Math.pow(this[i], p)\n    }\n    return vecTypes[this.dim](result)\n  }\n\n  /**\n   * Returns a vector where v and this are multiplied componentwise. If v is\n   * a single number, the vector is scaled by v.\n   * @param {number|number[]} v The value to multiply with.\n   *\n   * @returns {vecn} A new vector with the multiplied components.\n   */\n  times (v) {\n    checkCompatibility(v, this.dim, true)\n    if (type(v) === 'Number') {\n      v = (new Array(this.dim)).fill(v)\n    }\n\n    let result = []\n    for (let i = 0; i < this.dim; ++i) {\n      result[i] = this[i] * v[i]\n    }\n    return vecTypes[this.dim](result)\n  }\n\n  // --------------------------------------------------------------------------\n  //   Vector Operations\n\n  /**\n   * Dot product of two vectors.\n   * @param {number[]} v The vector to dot with this one.\n   *\n   * @returns {number} The dot product between this and v.\n   */\n  dot (v) {\n    checkCompatibility(v, this.dim)\n\n    let result = 0\n    for (let i = 0; i < this.dim; ++i) {\n      result += this[i] * v[i]\n    }\n    return result\n  }\n\n  /**\n   * Scales this vector to a magnitude of 1.\n   *\n   * @returns {vecn} A new vector with scaled components.\n   */\n  normalize () {\n    return this.div(this.magnitude)\n  }\n\n  /**\n   * Evaluates the p-norm (or lp-norm) of this vector.\n   * @param {number} p The p-value to evaluate.\n   *\n   * @returns {number} The norm of this vector.\n   */\n  pnorm (p) {\n    let result = 0\n    for (let i = 0; i < this.dim; ++i) {\n      result += Math.pow(Math.abs(this[i]), p)\n    }\n    return Math.pow(result, 1 / p)\n  }\n\n  /**\n   * Reflects this vector across the provided vector. The normal can be imagined\n   * as a surface normal or as describing a hyperpalane.\n   * @param {number[]} normal A vector describing the hyperplane to reflect off of.\n   *\n   * @returns {vecn} The reflected vector.\n   */\n  reflect (normal) {\n    const n = normal.normalize()\n    return this.minus(n.times(2 * this.dot(n)))\n  }\n\n  // --------------------------------------------------------------------------\n  //   Extras\n\n  /**\n   * Finds the indices of the max value in this vector.\n   *\n   * @returns {number[]} An array of indices corresponding to the max values.\n   */\n  argmax () {\n    const maxVal = this.max()\n    return this.reduce((acc, x, i) => x === maxVal ? acc.concat([i]) : acc, [])\n  }\n\n  /**\n   * Finds the indices of the min value in this vector.\n   *\n   * @returns {number[]} An array of indices corresponding to the min values.\n   */\n  argmin () {\n    const minVal = this.min()\n    return this.reduce((acc, x, i) => x === minVal ? acc.concat([i]) : acc, [])\n  }\n\n  /**\n   * Creates a new vector from the provided indices of this one. Basically\n   * equivalent to swizzling.\n   * @param {number[]} indices The indices to select into a new vector.\n   *\n   * @returns {vecn} A new vector from the provided indices.\n   */\n  choose (indices) {\n    if (!Array.isArray(indices)) {\n      throw new TypeError('Argument must be a list of indices.')\n    }\n    if (!indices.every((i) => i < this.dim && isIndex(i.toString()))) {\n      throw new RangeError('All elements of argument must be valid indices.')\n    }\n\n    let v = []\n    indices.forEach((i) => v.push(this[i]))\n    return vecTypes[v.length](v)\n  }\n\n  /**\n   * Creates a duplicate of this vector. Same as passing this vector through\n   * the factory that created it.\n   *\n   * @returns {vecn} A deep copy of this vector.\n   */\n  copy () {\n    return vecTypes[this.dim](this)\n  }\n\n  /**\n   * Returns whether every element in each vector is equal.\n   * @param {number[]} v A vector to test against.\n   *\n   * @returns {boolean} True if both vectors have the same dimension and values.\n   */\n  equals (v) {\n    return v.length === this.dim && v.every((x, i) => this[i] === x)\n  }\n\n  /**\n   * Returns whether every element in each vector is approximately equal.\n   * @param {number[]} v A vector to test against.\n   * @param {number} epsilon The largest meaningful difference between two values.\n   *\n   * @returns {boolean} True if both vectors have the same dimension and the\n   * distance between each number is less than epsilon.\n   */\n  approximatelyEquals (v, epsilon = 0.00000001) {\n    return v.length === this.dim && v.every((x, i) => Math.abs(this[i] - x) < epsilon)\n  }\n\n  /**\n   * Returns the max value of this vector.\n   *\n   * @returns {number} The max value of this vector.\n   */\n  max () {\n    return Math.max(...this)\n  }\n\n  /**\n   * Returns the min value of this vector.\n   *\n   * @returns {number} The min value of this vector.\n   */\n  min () {\n    return Math.min(...this)\n  }\n\n  /**\n   * Sums the components of this vector.\n   *\n   * @returns {number} The sum of the components of this vector.\n   */\n  sum () {\n    return this.reduce((acc, x) => acc + x, 0)\n  }\n\n  /**\n   * Converts this vector into an Array.\n   *\n   * @returns {number[]} An array of the contents of this vector.\n   */\n  toArray () {\n    return Array.from(this)\n  }\n\n  // --------------------------------------------------------------------------\n  //   Array Overrides\n\n  /**\n   * Same as Array.prototype.concat, but return value is of a new vecType.\n   *\n   * @returns {vecn}\n   */\n  concat (...args) {\n    const result = super.concat.apply(this.toArray(), args)\n    return vecTypes[result.length](result)\n  }\n\n  /**\n   * Same as Array.prototype.filter, but returns an Array if the result has 0\n   * entries.\n   *\n   * @returns {vecn|number[]}\n   */\n  filter (...args) {\n    const result = super.filter.apply(this.toArray(), args)\n    if (result.length > 0) {\n      return vecTypes[result.length](result)\n    }\n    return result\n  }\n\n  /**\n   * Same as Array.prototype.map, but returns an Array if the result contains\n   * non-numbers.\n   *\n   * @returns {vecn|Array}\n   */\n  map (...args) {\n    const result = super.map(...args)\n    if (result.every((x) => type(x) === 'Number')) {\n      return result\n    }\n    return result.toArray()\n  }\n\n  /**\n   * Same as Array.prototype.slice, but returns an Array if the result has 0\n   * entries.\n   */\n  slice (...args) {\n    const result = super.slice.apply(this.toArray(), args)\n    if (result.length > 0) {\n      return vecTypes[result.length](result)\n    }\n    return result\n  }\n\n  /**\n   * A restrictive version of the Array.prototype.splice that requires all\n   * removed elements to be replaced.\n   */\n  splice (...args) {\n    let test = this.toArray()\n    test.splice(...args)\n\n    if (test.length !== this.dim) {\n      throw new Error('All removed elements must be replaced.')\n    }\n    if (!test.every((x) => type(x) === 'Number')) {\n      throw new TypeError('All elements must be numbers.')\n    }\n\n    test.forEach((x, i) => { this[i] = x })\n  }\n\n  toString () {\n    return this.reduce((s, x, i) => {\n      return s + x + (i === this.dim - 1 ? ' ' : ', ')\n    }, '[ ') + ']'\n  }\n}\n\n// --------------------------------------------------------------------------\n//   General Tools\n\n/**\n * Adds an arbitrary number of vectors together. All vectors must be of the same\n * dimension.\n * @param {...vecn} vecs Vectors to add together.\n *\n * @returns {vecn} The sum of all the provided vectors.\n */\nfunction add (...vecs) {\n  const dim = vecs[0].dim\n  if (!vecs.every((v) => v.dim === dim)) {\n    throw new TypeError('All vectors must have the same dimension.')\n  }\n  return vecs.reduce((acc, v) => acc.plus(v), vecTypes[dim]())\n}\n\n/**\n * The validator to be used in the proxy for all vec objects. Catches swizzling\n * properties, makes sure assignment only works for indices, and disallows\n * non-numerical assignments. Used in getVecType.\n * @constant\n * @type {Object}\n * @private\n */\nconst validator = {\n  set: function (obj, prop, value) {\n    if (prop === 'length') {\n      return false\n    }\n    if (isIndex(prop)) {\n      if (Number(prop) >= obj.dim) {\n        throw new RangeError('Vector may not have more elements than dimension.')\n      } else if (type(value) !== 'Number') {\n        throw new TypeError('Vectors may only contain numbers.')\n      } else {\n        obj[prop] = value\n        return true\n      }\n    }\n\n    const swizzleSymbolMap = getSwizzleSymbolMap(prop.toString())\n    if (obj.dim <= 4 && swizzleSymbolMap) {\n      swizzleSet(obj, prop.toString(), swizzleSymbolMap, value)\n      return true\n    }\n\n    return false\n  },\n  get: function (obj, prop) {\n    const swizzleSymbolMap = getSwizzleSymbolMap(prop.toString())\n    if (obj.dim <= 4 && swizzleSymbolMap) {\n      return swizzleGet(obj, prop, swizzleSymbolMap)\n    }\n\n    return obj[prop]\n  }\n}\n\n/**\n * Returns a factory function for vectors of the specified dimension.\n * @param {number} dim The dimension of the new vector type.\n *\n * @returns {Function} A factory (not a constructor) for creating new vecs.\n */\nfunction getVecType (dim) {\n  dim = Number(dim)\n\n  if (!(dim in vecTypes)) {\n    if (isNaN(dim)) throw new TypeError('Dimension must be coercible to a number.')\n    if (dim <= 0) throw new RangeError('Dimension must be positive.')\n    if (!Number.isInteger(dim)) throw new RangeError('Dimension must be positive.')\n\n    // Doing a little bit of exploiting ES6 to dynamically name the class\n    let classname = 'vec' + dim\n    let VecType = ({[classname]: class extends vecn {\n      constructor (...args) {\n        if (args.length === 1 && args[0] instanceof vecn) {\n          if (args[0].dim > dim) {\n            throw new TypeError('Cannot demote vectors.')\n          }\n          args = promoteArrayDimension(args[0].toArray(), dim)\n        }\n        super(dim, args)\n        Reflect.defineProperty(this, 'dim', {\n          value: dim,\n          writable: false,\n          enumerable: false\n        })\n      }\n    }})[classname]\n\n    let factory = function factory (...args) {\n      let target = new VecType(...args)\n      Object.preventExtensions(target)\n      return new Proxy(target, validator)\n    }\n    vecTypes[dim] = factory\n  }\n\n  return vecTypes[dim]\n}\n\n/**\n * The correct function for determining whether an object is a vecn.\n * @param {*} v The object in question.\n *\n * @returns {boolean} True if the object is an instance of vecn.\n */\nfunction isVec (v) {\n  return v instanceof vecn\n}\n\n/**\n * Linearly interpolates between two vectors.\n * @param {vecn} v1 The starting vector.\n * @param {vecn} v2 The ending vector.\n * @param {number} t The interpolant, which is clamped to the inteval [0, 1].\n *\n * @returns {vecn} The interpolated vector.\n */\nfunction lerp (v1, v2, t) {\n  if (v1.dim !== v2.dim) throw new TypeError('Vectors must have the same dimension.')\n  t = t < 0 ? 0 : (t > 1 ? 1 : t)\n  return v1.plus(v2.minus(v1).times(t))\n}\n\n/**\n * Multiplies an arbitrary number of vectors together. All vectors must be of the same\n * dimension.\n * @param {...vecn} vecs Vectors to multiply together.\n *\n * @returns {vecn} The product of all the provided vectors.\n */\nfunction multiply (...vecs) {\n  const dim = vecs[0].dim\n  if (!vecs.every((v) => v.dim === dim)) throw new TypeError('All vectors must have the same dimension.')\n  return vecs.reduce((acc, v) => acc.times(v), vecTypes[dim](1))\n}\n\n/**\n * Spherically interpolates between two vectors.\n * @param {vecn} v1 The starting vector.\n * @param {vecn} v2 The ending vector.\n * @param {number} t The interpolant, which is clamped to the inteval [0, 1].\n *\n * @returns {vecn} The interpolated vector.\n */\nfunction slerp (v1, v2, t) {\n  if (v1.dim !== v2.dim) throw new TypeError('Vectors must have the same dimension.')\n\n  t = t < 0 ? 0 : (t > 1 ? 1 : t)\n  let dot = v1.normalize().dot(v2.normalize())\n  dot = dot < -1 ? -1 : (dot > 1 ? 1 : dot)\n  const theta = Math.acos(dot) * t\n  const relative = v2.minus(v1.times(dot)).normalize()\n  const magnitude = v1.magnitude + ((v2.magnitude - v1.magnitude) * t)\n  return v1.times(Math.cos(theta)).plus(relative.times(Math.sin(theta)))\n    .normalize().times(magnitude)\n}\n\n// --------------------------------------------------------------------------\n//   Swizzling\n\n/**\n * The index corresponding to common names for indexing vectors.\n * @constant\n * @type {Object}\n * @private\n */\nconst namedIndices = [\n  {x: 0, y: 1, z: 2, w: 3},\n  {r: 0, g: 1, b: 2, a: 3},\n  {s: 0, t: 1, p: 2, q: 3}\n]\n\n/**\n * Gets the set of symbols corresponding to indices used for swizzling.\n * @private\n * @param {string} s The string used as a property to swizzle.\n *\n * @returns {Object} A map from characters to indices.\n */\nfunction getSwizzleSymbolMap (s) {\n  return namedIndices.find((map) => {\n    return s.split('').every((c) => c in map)\n  })\n}\n\n/**\n * Creates a new vector from the named indices given by swizzling.\n * @private\n * @param {vecn} v The vector to pull data from. The dimension is assumed to be\n * 2, 3, or 4, but this isn't enforced here.\n * @param {string} s The property being used to swizzle (e.g. 'xxy' or 'z').\n * @param {Object} set A map from characters to indices (assumed to be valid).\n *\n * @returns {undefined|number|vecn} Either undefined (if s isn't a valid swizzle\n * string), a number (if s has a length of 1), or a vecn where the values have\n * been rearranged according to the order given in s.\n */\nfunction swizzleGet (v, s, set) {\n  const newDim = s.length\n\n  if (newDim === 1) {\n    return v[set[s]]\n  }\n\n  let values = s.split('').reduce((acc, x) => {\n    let i = set[x]\n    return acc && i < v.dim ? acc.concat([v[i]]) : undefined\n  }, [])\n  return values ? new vecTypes[newDim](...values) : undefined\n}\n\n/**\n * Assigns the indexed values in v to the values in newVals in the order they\n * are described in in s.\n * @private\n * @param {vecn} v The starting vector.\n * @param {string} s The property being used to swizzle (e.g. 'xyz' or 'xz').\n * @param {Object} map A map from characters to indices (assumed to be valid).\n * @param {number|number[]} newVals The right hand side of the assignment\n *\n * @returns {vecn} A copy of v with the correct elements replaced.\n */\nfunction swizzleSet (v, s, map, newVals) {\n  if (s.length === 1) {\n    if (type(newVals) !== 'Number') {\n      throw new TypeError('Must set to a number')\n    }\n    v[map[s]] = newVals\n    return\n  }\n\n  if (!Array.isArray(newVals)) throw new TypeError('Right-hand side must be an array.')\n  if (s.length !== newVals.length) throw new TypeError('Right-hand side must have matching length.')\n  if (!newVals.every((item) => type(item) === 'Number')) throw new TypeError('All new values must be numbers.')\n\n  if (s.split('').some((c) => map[c] >= v.dim)) {\n    return\n  }\n\n  let valid = true\n  for (let i = 0, unique = {}; i < s.length; ++i) {\n    if (unique.hasOwnProperty(s[i])) {\n      valid = false\n      break\n    }\n    unique[s[i]] = true\n  }\n  if (!valid) throw new SyntaxError('Swizzle assignment does not allow symbols to be repeated.')\n\n  s.split('').map((c) => map[c]).forEach((index, i) => { v[index] = newVals[i] })\n}\n\n// --------------------------------------------------------------------------\n//   Helpers\n\n/**\n * Checks whether something is valid to do vector operations with and throws\n * a TypeError if not.\n * @private\n * @param {*} o An object to check.\n * @param {number} dim The dimension to check against.\n * @param {boolean} [numberValid=false] Whether scalars are compatible for the operation.\n */\nfunction checkCompatibility (o, dim, numberValid = false) {\n  if (numberValid && type(o) === 'Number') {\n    return\n  } else if (o.length && o.length === dim) {\n    return\n  }\n  throw new TypeError(`Invalid argument. Input must have matching dimension${numberValid ? 'or be a scalar' : ''}.`)\n}\n\n/**\n * Removes outer arrays and returns a reference to the innermost array. For\n * example, [[1, 2]] becomes [1, 2]. [[[['a'], true]]] becomes [['a'], true].\n * @private\n * @param {Array} arr The array to flatten.\n *\n * @returns {Array} A reference to the innermost array in arr.\n */\nfunction flattenOuter (arr) {\n  if (!(arr instanceof Array) || arr.length !== 1) {\n    return arr\n  }\n  if (arr[0] instanceof Array) {\n    return flattenOuter(arr[0])\n  }\n  return arr\n}\n\n/**\n * Checks whether a provided string can be used as a valid index into an array.\n * @private\n * @param {string} n A string representation of the number in question.\n *\n * @returns {boolean} True if n can be used to index an array.\n */\nfunction isIndex (n) {\n  return !isNaN(n) &&\n         Number(n).toString() === n &&\n         Number.isInteger(Number(n)) &&\n         Number(n) >= 0\n}\n\n/**\n * Lengthens an exsting array and fills new entries with 0 (does not mutate).\n * @private\n * @param {Array} arr The source array.\n * @param {number} dim The dimension of the new array.\n *\n * @returns {Array} A new array with length dim and arr as a prefix.\n */\nfunction promoteArrayDimension (arr, dim) {\n  return [...Array(dim)].map((_, i) => i < arr.length ? arr[i] : 0)\n}\n\n/**\n * Returns a string representing the type of an object. Similar to typeof, but\n * better with wrapped primitives, null, Array, etc...\n * @private\n * @param {*} obj The object to check the type of.\n *\n * @returns {string} A capitalized string describing the perceived type (i.e. 'Number', 'Array', etc...)\n */\nfunction type (obj) {\n  return Object.prototype.toString.call(obj).slice(8, -1)\n}\n\nmodule.exports = {\n  getVecType,\n  isVec,\n  vec2: vecTypes[2],\n  vec3: vecTypes[3],\n  vec4: vecTypes[4],\n\n  add,\n  multiply,\n  lerp,\n  slerp\n}\n","import React, { useRef, useMemo } from 'react'\nimport { useFrame, useThree } from '@react-three/fiber'\nimport { Group } from 'three'\nimport vecn from 'vecn'\n// @ts-ignore\nimport lerp from '@14islands/lerp'\n\nimport { ScrollScene, useScrollRig } from '@14islands/r3f-scroll-rig'\n\n// Sticky mesh that covers full viewport size\nconst StickyChild = ({\n  children,\n  childTop,\n  childBottom,\n  scrollState,\n  parentScale,\n  childScale,\n  scaleMultiplier,\n  priority,\n  stickyLerp = 1.0,\n  offsetTop = 0,\n}: any) => {\n  const group = useRef<Group>(null!)\n  const size = useThree((s) => s.size)\n\n  useFrame((_, delta) => {\n    if (!scrollState.inViewport) return\n\n    const topOffset = (childTop - offsetTop) / size.height\n    const bottomOffset = (childBottom / parentScale[1]) * scaleMultiplier\n\n    //  move to top of sticky area\n    const yTop = parentScale[1] * 0.5 - childScale[1] * 0.5 - offsetTop * scaleMultiplier\n    const yBottom = -parentScale[1] * 0.5 + childScale[1] * 0.5\n    const ySticky =\n      -childTop * scaleMultiplier +\n      yTop -\n      (scrollState.viewport - 1) * size.height * scaleMultiplier +\n      offsetTop * scaleMultiplier\n\n    let y = group.current.position.y\n\n    // enter\n    if (scrollState.viewport + topOffset < 1) {\n      y = yTop\n    }\n    // sticky\n    else if (scrollState.visibility - bottomOffset < 1) {\n      y = ySticky\n    }\n    // exit\n    else {\n      y = yBottom\n    }\n\n    group.current.position.y = lerp(group.current.position.y, y, stickyLerp, delta)\n  }, priority) // must happen after ScrollScene's useFrame to be buttery\n\n  return <group ref={group}>{children}</group>\n}\n\nconst renderAsSticky = (\n  children: any,\n  size: any,\n  childStyle: any,\n  parentStyle: any,\n  scaleMultiplier: number,\n  { stickyLerp, fillViewport }: any\n) => {\n  return ({ scale, ...props }: any) => {\n    let childScale = vecn.vec3(parseFloat(childStyle.width), parseFloat(childStyle.height), 1)\n    let childTop = parseFloat(childStyle.top)\n    let childBottom = size.height - childTop - childScale[1]\n\n    if (fillViewport) {\n      childScale = vecn.vec3(size.width, size.height, 1)\n      childTop = 0\n      childBottom = 0\n    }\n\n    const offsetTop = parseFloat(parentStyle.top)\n\n    return (\n      // @ts-ignore\n      <StickyChild\n        offsetTop={offsetTop}\n        parentScale={scale}\n        childScale={childScale.times(scaleMultiplier)}\n        stickyLerp={stickyLerp}\n        childTop={childTop}\n        childBottom={childBottom}\n        scaleMultiplier={scaleMultiplier}\n        {...props}\n      >\n        {children({\n          scale: childScale.times(scaleMultiplier),\n          parentScale: scale,\n          ...props,\n        })}\n      </StickyChild>\n    )\n  }\n}\n\nexport const StickyScrollScene = ({ children, track, stickyLerp, fillViewport, ...props }: any) => {\n  const size = useThree((s) => s.size)\n  const { scaleMultiplier } = useScrollRig()\n\n  const internalRef = useRef(track.current)\n\n  // if tracked element is position:sticky, track the parent instead\n  // we want to track the progress of the entire sticky area\n  const [childStyle, parentStyle] = useMemo(() => {\n    const style = getComputedStyle(track.current)\n\n    let parentStyle\n    if (style.position === 'sticky') {\n      internalRef.current = track.current.parentElement\n\n      // make sure parent is relative/absolute so we get accurante offsetTop\n      parentStyle = getComputedStyle(internalRef.current)\n      if (parentStyle.position === 'static') {\n        console.error(\n          'StickyScrollScene: parent of position:sticky needs to be position:relative or position:absolute (currently set to position:static)'\n        )\n      }\n    } else {\n      console.error('StickyScrollScene: tracked element is not position:sticky')\n    }\n    return [style, parentStyle]\n  }, [track, size])\n\n  return (\n    <ScrollScene track={internalRef} {...props}>\n      {renderAsSticky(children, size, childStyle, parentStyle, scaleMultiplier, {\n        stickyLerp,\n        fillViewport,\n      })}\n    </ScrollScene>\n  )\n}\n","const _lerp = require('lerp')\n\n/**\n * Drop-in replacement of standard lerp with optional frame delta and target fps\n * to maintain constant animation speed at various fps\n * \n * Based on http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/\n * \n * @param {number} source Current value\n * @param {number} target Value to lerp towards\n * @param {number} rate Interpolation rate\n * @param {number} frameDelta Optional frame delta time in seconds. Should be 1/60 for a steady 60fps.\n * @param {number} targetFps Optional, target is 60 by default\n * @returns {number} interpolated value\n */\n\nfunction lerp(source, target, rate, frameDelta, targetFps = 60){\n  \n  // return normal lerp if no delta was passed\n  if (typeof frameDelta === 'undefined') {\n    return _lerp(source, target, rate)\n  }\n\n  const relativeDelta = frameDelta / (1 / targetFps)\n  const smoothing = 1 - rate\n  return _lerp(source, target, 1 - Math.pow(smoothing, relativeDelta));\n}\n\nmodule.exports = lerp","function lerp(v0, v1, t) {\n    return v0*(1-t)+v1*t\n}\nmodule.exports = lerp"],"names":["_excluded","WebGLText","_ref","el","children","material","scale","font","_ref$fontOffsetY","fontOffsetY","_ref$fontOffsetX","fontOffsetX","_ref$overrideEmissive","overrideEmissive","color","props","_objectWithoutPropertiesLoose","size","useThree","scaleMultiplier","useScrollRig","_useMemo","useMemo","current","cs","window","getComputedStyle","textColor","parentElement","letterSpacing","parseFloat","fontSize","lineHeight","textAlign","useEffect","emissive","xOffset","React","createElement","Text","_extends","maxWidth","width","overflowWrap","anchorX","anchorY","position","height","WebGLImage","forwardRef","ref","scrollState","vertexShader","fragmentShader","_ref$invalidateFrameL","invalidateFrameLoop","_ref$widthSegments","widthSegments","_ref$heightSegments","heightSegments","useRef","mesh","useImperativeHandle","_useThree","invalidate","gl","pixelRatio","s","viewport","dpr","scroll","useScrollbar","texture","useImageAsTexture","uniforms","u_color","value","Color","u_time","u_pixelRatio","u_progress","u_visibility","u_viewport","u_velocity","u_res","Vector2","u_rect","u_size","u_texture","u_loaded","u_scaleMultiplier","set","image","useFrame","_","delta","inViewport","x","y","velocity","progress","visibility","args","Fragment","attach","transparent","ParallaxGroup","parallax","ParallaxScrollScene","_ref2","_ref2$speed","speed","parallaxAmount","ScrollScene","scissor","inViewportMargin","Math","max","vecTypes","Proxy","get","obj","prop","hasOwnProperty","getVecType","vecn","Array","constructor","dimension","flattenOuter","every","type","TypeError","length","Error","fill","super","this","Reflect","defineProperty","undefined","enumerable","magnitude","pnorm","div","v","checkCompatibility","dim","result","i","minus","neg","times","plus","pow","p","dot","normalize","abs","reflect","normal","n","argmax","maxVal","reduce","acc","concat","argmin","minVal","min","choose","indices","isArray","isIndex","toString","RangeError","forEach","push","copy","equals","approximatelyEquals","epsilon","sum","toArray","from","apply","filter","map","slice","splice","test","validator","Number","swizzleSymbolMap","getSwizzleSymbolMap","newVals","item","split","some","c","valid","unique","SyntaxError","index","swizzleSet","newDim","values","swizzleGet","isNaN","isInteger","classname","VecType","arr","promoteArrayDimension","writable","target","Object","preventExtensions","namedIndices","z","w","r","g","b","a","t","q","find","o","numberValid","prototype","call","src","isVec","vec2","vec3","vec4","add","vecs","multiply","lerp","v1","v2","slerp","theta","acos","relative","cos","sin","StickyChild","childTop","childBottom","parentScale","childScale","priority","_ref$stickyLerp","stickyLerp","_ref$offsetTop","offsetTop","group","yTop","source","rate","frameDelta","targetFps","StickyScrollScene","_ref4","track","fillViewport","_excluded2","internalRef","parentStyle","style","console","error","childStyle","_ref3","top","renderAsSticky"],"mappings":"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"}