;(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined'
    ? factory(exports)
    : typeof define === 'function' && define.amd
      ? define(['exports'], factory)
      : factory((global.THREE = {}))
})(this, function (exports) {
  'use strict'

  // Polyfills

  if (Number.EPSILON === undefined) {
    Number.EPSILON = Math.pow(2, -52)
  }

  if (Number.isInteger === undefined) {
    // Missing in IE
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger

    Number.isInteger = function (value) {
      return typeof value === 'number' && isFinite(value) && Math.floor(value) === value
    }
  }

  //

  if (Math.sign === undefined) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign

    Math.sign = function (x) {
      return x < 0 ? -1 : x > 0 ? 1 : +x
    }
  }

  if ('name' in Function.prototype === false) {
    // Missing in IE
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name

    Object.defineProperty(Function.prototype, 'name', {
      get: function () {
        return this.toString().match(/^\s*function\s*([^\(\s]*)/)[1]
      }
    })
  }

  if (Object.assign === undefined) {
    // Missing in IE
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign

    ;(function () {
      Object.assign = function (target) {
        if (target === undefined || target === null) {
          throw new TypeError('Cannot convert undefined or null to object')
        }

        var output = Object(target)

        for (var index = 1; index < arguments.length; index++) {
          var source = arguments[index]

          if (source !== undefined && source !== null) {
            for (var nextKey in source) {
              if (Object.prototype.hasOwnProperty.call(source, nextKey)) {
                output[nextKey] = source[nextKey]
              }
            }
          }
        }

        return output
      }
    })()
  }

  /**
   * https://github.com/mrdoob/eventdispatcher.js/
   */

  function EventDispatcher() {}

  Object.assign(EventDispatcher.prototype, {
    addEventListener: function (type, listener) {
      if (this._listeners === undefined) this._listeners = {}

      var listeners = this._listeners

      if (listeners[type] === undefined) {
        listeners[type] = []
      }

      if (listeners[type].indexOf(listener) === -1) {
        listeners[type].push(listener)
      }
    },

    hasEventListener: function (type, listener) {
      if (this._listeners === undefined) return false

      var listeners = this._listeners

      return listeners[type] !== undefined && listeners[type].indexOf(listener) !== -1
    },

    removeEventListener: function (type, listener) {
      if (this._listeners === undefined) return

      var listeners = this._listeners
      var listenerArray = listeners[type]

      if (listenerArray !== undefined) {
        var index = listenerArray.indexOf(listener)

        if (index !== -1) {
          listenerArray.splice(index, 1)
        }
      }
    },

    dispatchEvent: function (event) {
      if (this._listeners === undefined) return

      var listeners = this._listeners
      var listenerArray = listeners[event.type]

      if (listenerArray !== undefined) {
        event.target = this

        var array = listenerArray.slice(0)

        for (var i = 0, l = array.length; i < l; i++) {
          array[i].call(this, event)
        }
      }
    }
  })

  var REVISION = '90'
  var MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 }
  var CullFaceNone = 0
  var CullFaceBack = 1
  var CullFaceFront = 2
  var CullFaceFrontBack = 3
  var FrontFaceDirectionCW = 0
  var FrontFaceDirectionCCW = 1
  var BasicShadowMap = 0
  var PCFShadowMap = 1
  var PCFSoftShadowMap = 2
  var FrontSide = 0
  var BackSide = 1
  var DoubleSide = 2
  var FlatShading = 1
  var SmoothShading = 2
  var NoColors = 0
  var FaceColors = 1
  var VertexColors = 2
  var NoBlending = 0
  var NormalBlending = 1
  var AdditiveBlending = 2
  var SubtractiveBlending = 3
  var MultiplyBlending = 4
  var CustomBlending = 5
  var AddEquation = 100
  var SubtractEquation = 101
  var ReverseSubtractEquation = 102
  var MinEquation = 103
  var MaxEquation = 104
  var ZeroFactor = 200
  var OneFactor = 201
  var SrcColorFactor = 202
  var OneMinusSrcColorFactor = 203
  var SrcAlphaFactor = 204
  var OneMinusSrcAlphaFactor = 205
  var DstAlphaFactor = 206
  var OneMinusDstAlphaFactor = 207
  var DstColorFactor = 208
  var OneMinusDstColorFactor = 209
  var SrcAlphaSaturateFactor = 210
  var NeverDepth = 0
  var AlwaysDepth = 1
  var LessDepth = 2
  var LessEqualDepth = 3
  var EqualDepth = 4
  var GreaterEqualDepth = 5
  var GreaterDepth = 6
  var NotEqualDepth = 7
  var MultiplyOperation = 0
  var MixOperation = 1
  var AddOperation = 2
  var NoToneMapping = 0
  var LinearToneMapping = 1
  var ReinhardToneMapping = 2
  var Uncharted2ToneMapping = 3
  var CineonToneMapping = 4
  var UVMapping = 300
  var CubeReflectionMapping = 301
  var CubeRefractionMapping = 302
  var EquirectangularReflectionMapping = 303
  var EquirectangularRefractionMapping = 304
  var SphericalReflectionMapping = 305
  var CubeUVReflectionMapping = 306
  var CubeUVRefractionMapping = 307
  var RepeatWrapping = 1000
  var ClampToEdgeWrapping = 1001
  var MirroredRepeatWrapping = 1002
  var NearestFilter = 1003
  var NearestMipMapNearestFilter = 1004
  var NearestMipMapLinearFilter = 1005
  var LinearFilter = 1006
  var LinearMipMapNearestFilter = 1007
  var LinearMipMapLinearFilter = 1008
  var UnsignedByteType = 1009
  var ByteType = 1010
  var ShortType = 1011
  var UnsignedShortType = 1012
  var IntType = 1013
  var UnsignedIntType = 1014
  var FloatType = 1015
  var HalfFloatType = 1016
  var UnsignedShort4444Type = 1017
  var UnsignedShort5551Type = 1018
  var UnsignedShort565Type = 1019
  var UnsignedInt248Type = 1020
  var AlphaFormat = 1021
  var RGBFormat = 1022
  var RGBAFormat = 1023
  var LuminanceFormat = 1024
  var LuminanceAlphaFormat = 1025
  var RGBEFormat = RGBAFormat
  var DepthFormat = 1026
  var DepthStencilFormat = 1027
  var RGB_S3TC_DXT1_Format = 33776
  var RGBA_S3TC_DXT1_Format = 33777
  var RGBA_S3TC_DXT3_Format = 33778
  var RGBA_S3TC_DXT5_Format = 33779
  var RGB_PVRTC_4BPPV1_Format = 35840
  var RGB_PVRTC_2BPPV1_Format = 35841
  var RGBA_PVRTC_4BPPV1_Format = 35842
  var RGBA_PVRTC_2BPPV1_Format = 35843
  var RGB_ETC1_Format = 36196
  var RGBA_ASTC_4x4_Format = 37808
  var RGBA_ASTC_5x4_Format = 37809
  var RGBA_ASTC_5x5_Format = 37810
  var RGBA_ASTC_6x5_Format = 37811
  var RGBA_ASTC_6x6_Format = 37812
  var RGBA_ASTC_8x5_Format = 37813
  var RGBA_ASTC_8x6_Format = 37814
  var RGBA_ASTC_8x8_Format = 37815
  var RGBA_ASTC_10x5_Format = 37816
  var RGBA_ASTC_10x6_Format = 37817
  var RGBA_ASTC_10x8_Format = 37818
  var RGBA_ASTC_10x10_Format = 37819
  var RGBA_ASTC_12x10_Format = 37820
  var RGBA_ASTC_12x12_Format = 37821
  var LoopOnce = 2200
  var LoopRepeat = 2201
  var LoopPingPong = 2202
  var InterpolateDiscrete = 2300
  var InterpolateLinear = 2301
  var InterpolateSmooth = 2302
  var ZeroCurvatureEnding = 2400
  var ZeroSlopeEnding = 2401
  var WrapAroundEnding = 2402
  var TrianglesDrawMode = 0
  var TriangleStripDrawMode = 1
  var TriangleFanDrawMode = 2
  var LinearEncoding = 3000
  var sRGBEncoding = 3001
  var GammaEncoding = 3007
  var RGBEEncoding = 3002
  var LogLuvEncoding = 3003
  var RGBM7Encoding = 3004
  var RGBM16Encoding = 3005
  var RGBDEncoding = 3006
  var BasicDepthPacking = 3200
  var RGBADepthPacking = 3201

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   */

  var _Math = {
    DEG2RAD: Math.PI / 180,
    RAD2DEG: 180 / Math.PI,

    generateUUID: (function () {
      // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136

      var lut = []

      for (var i = 0; i < 256; i++) {
        lut[i] = (i < 16 ? '0' : '') + i.toString(16).toUpperCase()
      }

      return function generateUUID() {
        var d0 = (Math.random() * 0xffffffff) | 0
        var d1 = (Math.random() * 0xffffffff) | 0
        var d2 = (Math.random() * 0xffffffff) | 0
        var d3 = (Math.random() * 0xffffffff) | 0
        return (
          lut[d0 & 0xff] +
          lut[(d0 >> 8) & 0xff] +
          lut[(d0 >> 16) & 0xff] +
          lut[(d0 >> 24) & 0xff] +
          '-' +
          lut[d1 & 0xff] +
          lut[(d1 >> 8) & 0xff] +
          '-' +
          lut[((d1 >> 16) & 0x0f) | 0x40] +
          lut[(d1 >> 24) & 0xff] +
          '-' +
          lut[(d2 & 0x3f) | 0x80] +
          lut[(d2 >> 8) & 0xff] +
          '-' +
          lut[(d2 >> 16) & 0xff] +
          lut[(d2 >> 24) & 0xff] +
          lut[d3 & 0xff] +
          lut[(d3 >> 8) & 0xff] +
          lut[(d3 >> 16) & 0xff] +
          lut[(d3 >> 24) & 0xff]
        )
      }
    })(),

    clamp: function (value, min, max) {
      return Math.max(min, Math.min(max, value))
    },

    // compute euclidian modulo of m % n
    // https://en.wikipedia.org/wiki/Modulo_operation

    euclideanModulo: function (n, m) {
      return ((n % m) + m) % m
    },

    // Linear mapping from range <a1, a2> to range <b1, b2>

    mapLinear: function (x, a1, a2, b1, b2) {
      return b1 + ((x - a1) * (b2 - b1)) / (a2 - a1)
    },

    // https://en.wikipedia.org/wiki/Linear_interpolation

    lerp: function (x, y, t) {
      return (1 - t) * x + t * y
    },

    // http://en.wikipedia.org/wiki/Smoothstep

    smoothstep: function (x, min, max) {
      if (x <= min) return 0
      if (x >= max) return 1

      x = (x - min) / (max - min)

      return x * x * (3 - 2 * x)
    },

    smootherstep: function (x, min, max) {
      if (x <= min) return 0
      if (x >= max) return 1

      x = (x - min) / (max - min)

      return x * x * x * (x * (x * 6 - 15) + 10)
    },

    // Random integer from <low, high> interval

    randInt: function (low, high) {
      return low + Math.floor(Math.random() * (high - low + 1))
    },

    // Random float from <low, high> interval

    randFloat: function (low, high) {
      return low + Math.random() * (high - low)
    },

    // Random float from <-range/2, range/2> interval

    randFloatSpread: function (range) {
      return range * (0.5 - Math.random())
    },

    degToRad: function (degrees) {
      return degrees * _Math.DEG2RAD
    },

    radToDeg: function (radians) {
      return radians * _Math.RAD2DEG
    },

    isPowerOfTwo: function (value) {
      return (value & (value - 1)) === 0 && value !== 0
    },

    ceilPowerOfTwo: function (value) {
      return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2))
    },

    floorPowerOfTwo: function (value) {
      return Math.pow(2, Math.floor(Math.log(value) / Math.LN2))
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author philogb / http://blog.thejit.org/
   * @author egraether / http://egraether.com/
   * @author zz85 / http://www.lab4games.net/zz85/blog
   */

  function Vector2(x, y) {
    this.x = x || 0
    this.y = y || 0
  }

  Object.defineProperties(Vector2.prototype, {
    width: {
      get: function () {
        return this.x
      },

      set: function (value) {
        this.x = value
      }
    },

    height: {
      get: function () {
        return this.y
      },

      set: function (value) {
        this.y = value
      }
    }
  })

  Object.assign(Vector2.prototype, {
    isVector2: true,

    set: function (x, y) {
      this.x = x
      this.y = y

      return this
    },

    setScalar: function (scalar) {
      this.x = scalar
      this.y = scalar

      return this
    },

    setX: function (x) {
      this.x = x

      return this
    },

    setY: function (y) {
      this.y = y

      return this
    },

    setComponent: function (index, value) {
      switch (index) {
        case 0:
          this.x = value
          break
        case 1:
          this.y = value
          break
        default:
          throw new Error('index is out of range: ' + index)
      }

      return this
    },

    getComponent: function (index) {
      switch (index) {
        case 0:
          return this.x
        case 1:
          return this.y
        default:
          throw new Error('index is out of range: ' + index)
      }
    },

    clone: function () {
      return new this.constructor(this.x, this.y)
    },

    copy: function (v) {
      this.x = v.x
      this.y = v.y

      return this
    },

    add: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.'
        )
        return this.addVectors(v, w)
      }

      this.x += v.x
      this.y += v.y

      return this
    },

    addScalar: function (s) {
      this.x += s
      this.y += s

      return this
    },

    addVectors: function (a, b) {
      this.x = a.x + b.x
      this.y = a.y + b.y

      return this
    },

    addScaledVector: function (v, s) {
      this.x += v.x * s
      this.y += v.y * s

      return this
    },

    sub: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.'
        )
        return this.subVectors(v, w)
      }

      this.x -= v.x
      this.y -= v.y

      return this
    },

    subScalar: function (s) {
      this.x -= s
      this.y -= s

      return this
    },

    subVectors: function (a, b) {
      this.x = a.x - b.x
      this.y = a.y - b.y

      return this
    },

    multiply: function (v) {
      this.x *= v.x
      this.y *= v.y

      return this
    },

    multiplyScalar: function (scalar) {
      this.x *= scalar
      this.y *= scalar

      return this
    },

    divide: function (v) {
      this.x /= v.x
      this.y /= v.y

      return this
    },

    divideScalar: function (scalar) {
      return this.multiplyScalar(1 / scalar)
    },

    applyMatrix3: function (m) {
      var x = this.x,
        y = this.y
      var e = m.elements

      this.x = e[0] * x + e[3] * y + e[6]
      this.y = e[1] * x + e[4] * y + e[7]

      return this
    },

    min: function (v) {
      this.x = Math.min(this.x, v.x)
      this.y = Math.min(this.y, v.y)

      return this
    },

    max: function (v) {
      this.x = Math.max(this.x, v.x)
      this.y = Math.max(this.y, v.y)

      return this
    },

    clamp: function (min, max) {
      // assumes min < max, componentwise

      this.x = Math.max(min.x, Math.min(max.x, this.x))
      this.y = Math.max(min.y, Math.min(max.y, this.y))

      return this
    },

    clampScalar: (function () {
      var min = new Vector2()
      var max = new Vector2()

      return function clampScalar(minVal, maxVal) {
        min.set(minVal, minVal)
        max.set(maxVal, maxVal)

        return this.clamp(min, max)
      }
    })(),

    clampLength: function (min, max) {
      var length = this.length()

      return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)))
    },

    floor: function () {
      this.x = Math.floor(this.x)
      this.y = Math.floor(this.y)

      return this
    },

    ceil: function () {
      this.x = Math.ceil(this.x)
      this.y = Math.ceil(this.y)

      return this
    },

    round: function () {
      this.x = Math.round(this.x)
      this.y = Math.round(this.y)

      return this
    },

    roundToZero: function () {
      this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x)
      this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y)

      return this
    },

    negate: function () {
      this.x = -this.x
      this.y = -this.y

      return this
    },

    dot: function (v) {
      return this.x * v.x + this.y * v.y
    },

    lengthSq: function () {
      return this.x * this.x + this.y * this.y
    },

    length: function () {
      return Math.sqrt(this.x * this.x + this.y * this.y)
    },

    manhattanLength: function () {
      return Math.abs(this.x) + Math.abs(this.y)
    },

    normalize: function () {
      return this.divideScalar(this.length() || 1)
    },

    angle: function () {
      // computes the angle in radians with respect to the positive x-axis

      var angle = Math.atan2(this.y, this.x)

      if (angle < 0) angle += 2 * Math.PI

      return angle
    },

    distanceTo: function (v) {
      return Math.sqrt(this.distanceToSquared(v))
    },

    distanceToSquared: function (v) {
      var dx = this.x - v.x,
        dy = this.y - v.y
      return dx * dx + dy * dy
    },

    manhattanDistanceTo: function (v) {
      return Math.abs(this.x - v.x) + Math.abs(this.y - v.y)
    },

    setLength: function (length) {
      return this.normalize().multiplyScalar(length)
    },

    lerp: function (v, alpha) {
      this.x += (v.x - this.x) * alpha
      this.y += (v.y - this.y) * alpha

      return this
    },

    lerpVectors: function (v1, v2, alpha) {
      return this.subVectors(v2, v1).multiplyScalar(alpha).add(v1)
    },

    equals: function (v) {
      return v.x === this.x && v.y === this.y
    },

    fromArray: function (array, offset) {
      if (offset === undefined) offset = 0

      this.x = array[offset]
      this.y = array[offset + 1]

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      array[offset] = this.x
      array[offset + 1] = this.y

      return array
    },

    fromBufferAttribute: function (attribute, index, offset) {
      if (offset !== undefined) {
        console.warn('THREE.Vector2: offset has been removed from .fromBufferAttribute().')
      }

      this.x = attribute.getX(index)
      this.y = attribute.getY(index)

      return this
    },

    rotateAround: function (center, angle) {
      var c = Math.cos(angle),
        s = Math.sin(angle)

      var x = this.x - center.x
      var y = this.y - center.y

      this.x = x * c - y * s + center.x
      this.y = x * s + y * c + center.y

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author supereggbert / http://www.paulbrunt.co.uk/
   * @author philogb / http://blog.thejit.org/
   * @author jordi_ros / http://plattsoft.com
   * @author D1plo1d / http://github.com/D1plo1d
   * @author alteredq / http://alteredqualia.com/
   * @author mikael emtinger / http://gomo.se/
   * @author timknip / http://www.floorplanner.com/
   * @author bhouston / http://clara.io
   * @author WestLangley / http://github.com/WestLangley
   */

  function Matrix4() {
    this.elements = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]

    if (arguments.length > 0) {
      console.error('THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.')
    }
  }

  Object.assign(Matrix4.prototype, {
    isMatrix4: true,

    set: function (n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
      var te = this.elements

      te[0] = n11
      te[4] = n12
      te[8] = n13
      te[12] = n14
      te[1] = n21
      te[5] = n22
      te[9] = n23
      te[13] = n24
      te[2] = n31
      te[6] = n32
      te[10] = n33
      te[14] = n34
      te[3] = n41
      te[7] = n42
      te[11] = n43
      te[15] = n44

      return this
    },

    identity: function () {
      this.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)

      return this
    },

    clone: function () {
      return new Matrix4().fromArray(this.elements)
    },

    copy: function (m) {
      var te = this.elements
      var me = m.elements

      te[0] = me[0]
      te[1] = me[1]
      te[2] = me[2]
      te[3] = me[3]
      te[4] = me[4]
      te[5] = me[5]
      te[6] = me[6]
      te[7] = me[7]
      te[8] = me[8]
      te[9] = me[9]
      te[10] = me[10]
      te[11] = me[11]
      te[12] = me[12]
      te[13] = me[13]
      te[14] = me[14]
      te[15] = me[15]

      return this
    },

    copyPosition: function (m) {
      var te = this.elements,
        me = m.elements

      te[12] = me[12]
      te[13] = me[13]
      te[14] = me[14]

      return this
    },

    extractBasis: function (xAxis, yAxis, zAxis) {
      xAxis.setFromMatrixColumn(this, 0)
      yAxis.setFromMatrixColumn(this, 1)
      zAxis.setFromMatrixColumn(this, 2)

      return this
    },

    makeBasis: function (xAxis, yAxis, zAxis) {
      this.set(
        xAxis.x,
        yAxis.x,
        zAxis.x,
        0,
        xAxis.y,
        yAxis.y,
        zAxis.y,
        0,
        xAxis.z,
        yAxis.z,
        zAxis.z,
        0,
        0,
        0,
        0,
        1
      )

      return this
    },

    extractRotation: (function () {
      var v1 = new Vector3()

      return function extractRotation(m) {
        var te = this.elements
        var me = m.elements

        var scaleX = 1 / v1.setFromMatrixColumn(m, 0).length()
        var scaleY = 1 / v1.setFromMatrixColumn(m, 1).length()
        var scaleZ = 1 / v1.setFromMatrixColumn(m, 2).length()

        te[0] = me[0] * scaleX
        te[1] = me[1] * scaleX
        te[2] = me[2] * scaleX

        te[4] = me[4] * scaleY
        te[5] = me[5] * scaleY
        te[6] = me[6] * scaleY

        te[8] = me[8] * scaleZ
        te[9] = me[9] * scaleZ
        te[10] = me[10] * scaleZ

        return this
      }
    })(),

    makeRotationFromEuler: function (euler) {
      if (!(euler && euler.isEuler)) {
        console.error(
          'THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.'
        )
      }

      var te = this.elements

      var x = euler.x,
        y = euler.y,
        z = euler.z
      var a = Math.cos(x),
        b = Math.sin(x)
      var c = Math.cos(y),
        d = Math.sin(y)
      var e = Math.cos(z),
        f = Math.sin(z)

      if (euler.order === 'XYZ') {
        var ae = a * e,
          af = a * f,
          be = b * e,
          bf = b * f

        te[0] = c * e
        te[4] = -c * f
        te[8] = d

        te[1] = af + be * d
        te[5] = ae - bf * d
        te[9] = -b * c

        te[2] = bf - ae * d
        te[6] = be + af * d
        te[10] = a * c
      } else if (euler.order === 'YXZ') {
        var ce = c * e,
          cf = c * f,
          de = d * e,
          df = d * f

        te[0] = ce + df * b
        te[4] = de * b - cf
        te[8] = a * d

        te[1] = a * f
        te[5] = a * e
        te[9] = -b

        te[2] = cf * b - de
        te[6] = df + ce * b
        te[10] = a * c
      } else if (euler.order === 'ZXY') {
        var ce = c * e,
          cf = c * f,
          de = d * e,
          df = d * f

        te[0] = ce - df * b
        te[4] = -a * f
        te[8] = de + cf * b

        te[1] = cf + de * b
        te[5] = a * e
        te[9] = df - ce * b

        te[2] = -a * d
        te[6] = b
        te[10] = a * c
      } else if (euler.order === 'ZYX') {
        var ae = a * e,
          af = a * f,
          be = b * e,
          bf = b * f

        te[0] = c * e
        te[4] = be * d - af
        te[8] = ae * d + bf

        te[1] = c * f
        te[5] = bf * d + ae
        te[9] = af * d - be

        te[2] = -d
        te[6] = b * c
        te[10] = a * c
      } else if (euler.order === 'YZX') {
        var ac = a * c,
          ad = a * d,
          bc = b * c,
          bd = b * d

        te[0] = c * e
        te[4] = bd - ac * f
        te[8] = bc * f + ad

        te[1] = f
        te[5] = a * e
        te[9] = -b * e

        te[2] = -d * e
        te[6] = ad * f + bc
        te[10] = ac - bd * f
      } else if (euler.order === 'XZY') {
        var ac = a * c,
          ad = a * d,
          bc = b * c,
          bd = b * d

        te[0] = c * e
        te[4] = -f
        te[8] = d * e

        te[1] = ac * f + bd
        te[5] = a * e
        te[9] = ad * f - bc

        te[2] = bc * f - ad
        te[6] = b * e
        te[10] = bd * f + ac
      }

      // last column
      te[3] = 0
      te[7] = 0
      te[11] = 0

      // bottom row
      te[12] = 0
      te[13] = 0
      te[14] = 0
      te[15] = 1

      return this
    },

    makeRotationFromQuaternion: function (q) {
      var te = this.elements

      var x = q._x,
        y = q._y,
        z = q._z,
        w = q._w
      var x2 = x + x,
        y2 = y + y,
        z2 = z + z
      var xx = x * x2,
        xy = x * y2,
        xz = x * z2
      var yy = y * y2,
        yz = y * z2,
        zz = z * z2
      var wx = w * x2,
        wy = w * y2,
        wz = w * z2

      te[0] = 1 - (yy + zz)
      te[4] = xy - wz
      te[8] = xz + wy

      te[1] = xy + wz
      te[5] = 1 - (xx + zz)
      te[9] = yz - wx

      te[2] = xz - wy
      te[6] = yz + wx
      te[10] = 1 - (xx + yy)

      // last column
      te[3] = 0
      te[7] = 0
      te[11] = 0

      // bottom row
      te[12] = 0
      te[13] = 0
      te[14] = 0
      te[15] = 1

      return this
    },

    lookAt: (function () {
      var x = new Vector3()
      var y = new Vector3()
      var z = new Vector3()

      return function lookAt(eye, target, up) {
        var te = this.elements

        z.subVectors(eye, target)

        if (z.lengthSq() === 0) {
          // eye and target are in the same position

          z.z = 1
        }

        z.normalize()
        x.crossVectors(up, z)

        if (x.lengthSq() === 0) {
          // up and z are parallel

          if (Math.abs(up.z) === 1) {
            z.x += 0.0001
          } else {
            z.z += 0.0001
          }

          z.normalize()
          x.crossVectors(up, z)
        }

        x.normalize()
        y.crossVectors(z, x)

        te[0] = x.x
        te[4] = y.x
        te[8] = z.x
        te[1] = x.y
        te[5] = y.y
        te[9] = z.y
        te[2] = x.z
        te[6] = y.z
        te[10] = z.z

        return this
      }
    })(),

    multiply: function (m, n) {
      if (n !== undefined) {
        console.warn(
          'THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.'
        )
        return this.multiplyMatrices(m, n)
      }

      return this.multiplyMatrices(this, m)
    },

    premultiply: function (m) {
      return this.multiplyMatrices(m, this)
    },

    multiplyMatrices: function (a, b) {
      var ae = a.elements
      var be = b.elements
      var te = this.elements

      var a11 = ae[0],
        a12 = ae[4],
        a13 = ae[8],
        a14 = ae[12]
      var a21 = ae[1],
        a22 = ae[5],
        a23 = ae[9],
        a24 = ae[13]
      var a31 = ae[2],
        a32 = ae[6],
        a33 = ae[10],
        a34 = ae[14]
      var a41 = ae[3],
        a42 = ae[7],
        a43 = ae[11],
        a44 = ae[15]

      var b11 = be[0],
        b12 = be[4],
        b13 = be[8],
        b14 = be[12]
      var b21 = be[1],
        b22 = be[5],
        b23 = be[9],
        b24 = be[13]
      var b31 = be[2],
        b32 = be[6],
        b33 = be[10],
        b34 = be[14]
      var b41 = be[3],
        b42 = be[7],
        b43 = be[11],
        b44 = be[15]

      te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41
      te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42
      te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43
      te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44

      te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41
      te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42
      te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43
      te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44

      te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41
      te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42
      te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43
      te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44

      te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41
      te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42
      te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43
      te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44

      return this
    },

    multiplyScalar: function (s) {
      var te = this.elements

      te[0] *= s
      te[4] *= s
      te[8] *= s
      te[12] *= s
      te[1] *= s
      te[5] *= s
      te[9] *= s
      te[13] *= s
      te[2] *= s
      te[6] *= s
      te[10] *= s
      te[14] *= s
      te[3] *= s
      te[7] *= s
      te[11] *= s
      te[15] *= s

      return this
    },

    applyToBufferAttribute: (function () {
      var v1 = new Vector3()

      return function applyToBufferAttribute(attribute) {
        for (var i = 0, l = attribute.count; i < l; i++) {
          v1.x = attribute.getX(i)
          v1.y = attribute.getY(i)
          v1.z = attribute.getZ(i)

          v1.applyMatrix4(this)

          attribute.setXYZ(i, v1.x, v1.y, v1.z)
        }

        return attribute
      }
    })(),

    determinant: function () {
      var te = this.elements

      var n11 = te[0],
        n12 = te[4],
        n13 = te[8],
        n14 = te[12]
      var n21 = te[1],
        n22 = te[5],
        n23 = te[9],
        n24 = te[13]
      var n31 = te[2],
        n32 = te[6],
        n33 = te[10],
        n34 = te[14]
      var n41 = te[3],
        n42 = te[7],
        n43 = te[11],
        n44 = te[15]

      //TODO: make this more efficient
      //( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )

      return (
        n41 *
          (+n14 * n23 * n32 -
            n13 * n24 * n32 -
            n14 * n22 * n33 +
            n12 * n24 * n33 +
            n13 * n22 * n34 -
            n12 * n23 * n34) +
        n42 *
          (+n11 * n23 * n34 -
            n11 * n24 * n33 +
            n14 * n21 * n33 -
            n13 * n21 * n34 +
            n13 * n24 * n31 -
            n14 * n23 * n31) +
        n43 *
          (+n11 * n24 * n32 -
            n11 * n22 * n34 -
            n14 * n21 * n32 +
            n12 * n21 * n34 +
            n14 * n22 * n31 -
            n12 * n24 * n31) +
        n44 *
          (-n13 * n22 * n31 -
            n11 * n23 * n32 +
            n11 * n22 * n33 +
            n13 * n21 * n32 -
            n12 * n21 * n33 +
            n12 * n23 * n31)
      )
    },

    transpose: function () {
      var te = this.elements
      var tmp

      tmp = te[1]
      te[1] = te[4]
      te[4] = tmp
      tmp = te[2]
      te[2] = te[8]
      te[8] = tmp
      tmp = te[6]
      te[6] = te[9]
      te[9] = tmp

      tmp = te[3]
      te[3] = te[12]
      te[12] = tmp
      tmp = te[7]
      te[7] = te[13]
      te[13] = tmp
      tmp = te[11]
      te[11] = te[14]
      te[14] = tmp

      return this
    },

    setPosition: function (v) {
      var te = this.elements

      te[12] = v.x
      te[13] = v.y
      te[14] = v.z

      return this
    },

    getInverse: function (m, throwOnDegenerate) {
      // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
      var te = this.elements,
        me = m.elements,
        n11 = me[0],
        n21 = me[1],
        n31 = me[2],
        n41 = me[3],
        n12 = me[4],
        n22 = me[5],
        n32 = me[6],
        n42 = me[7],
        n13 = me[8],
        n23 = me[9],
        n33 = me[10],
        n43 = me[11],
        n14 = me[12],
        n24 = me[13],
        n34 = me[14],
        n44 = me[15],
        t11 =
          n23 * n34 * n42 -
          n24 * n33 * n42 +
          n24 * n32 * n43 -
          n22 * n34 * n43 -
          n23 * n32 * n44 +
          n22 * n33 * n44,
        t12 =
          n14 * n33 * n42 -
          n13 * n34 * n42 -
          n14 * n32 * n43 +
          n12 * n34 * n43 +
          n13 * n32 * n44 -
          n12 * n33 * n44,
        t13 =
          n13 * n24 * n42 -
          n14 * n23 * n42 +
          n14 * n22 * n43 -
          n12 * n24 * n43 -
          n13 * n22 * n44 +
          n12 * n23 * n44,
        t14 =
          n14 * n23 * n32 -
          n13 * n24 * n32 -
          n14 * n22 * n33 +
          n12 * n24 * n33 +
          n13 * n22 * n34 -
          n12 * n23 * n34

      var det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14

      if (det === 0) {
        var msg = "THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0"

        if (throwOnDegenerate === true) {
          throw new Error(msg)
        } else {
          console.warn(msg)
        }

        return this.identity()
      }

      var detInv = 1 / det

      te[0] = t11 * detInv
      te[1] =
        (n24 * n33 * n41 -
          n23 * n34 * n41 -
          n24 * n31 * n43 +
          n21 * n34 * n43 +
          n23 * n31 * n44 -
          n21 * n33 * n44) *
        detInv
      te[2] =
        (n22 * n34 * n41 -
          n24 * n32 * n41 +
          n24 * n31 * n42 -
          n21 * n34 * n42 -
          n22 * n31 * n44 +
          n21 * n32 * n44) *
        detInv
      te[3] =
        (n23 * n32 * n41 -
          n22 * n33 * n41 -
          n23 * n31 * n42 +
          n21 * n33 * n42 +
          n22 * n31 * n43 -
          n21 * n32 * n43) *
        detInv

      te[4] = t12 * detInv
      te[5] =
        (n13 * n34 * n41 -
          n14 * n33 * n41 +
          n14 * n31 * n43 -
          n11 * n34 * n43 -
          n13 * n31 * n44 +
          n11 * n33 * n44) *
        detInv
      te[6] =
        (n14 * n32 * n41 -
          n12 * n34 * n41 -
          n14 * n31 * n42 +
          n11 * n34 * n42 +
          n12 * n31 * n44 -
          n11 * n32 * n44) *
        detInv
      te[7] =
        (n12 * n33 * n41 -
          n13 * n32 * n41 +
          n13 * n31 * n42 -
          n11 * n33 * n42 -
          n12 * n31 * n43 +
          n11 * n32 * n43) *
        detInv

      te[8] = t13 * detInv
      te[9] =
        (n14 * n23 * n41 -
          n13 * n24 * n41 -
          n14 * n21 * n43 +
          n11 * n24 * n43 +
          n13 * n21 * n44 -
          n11 * n23 * n44) *
        detInv
      te[10] =
        (n12 * n24 * n41 -
          n14 * n22 * n41 +
          n14 * n21 * n42 -
          n11 * n24 * n42 -
          n12 * n21 * n44 +
          n11 * n22 * n44) *
        detInv
      te[11] =
        (n13 * n22 * n41 -
          n12 * n23 * n41 -
          n13 * n21 * n42 +
          n11 * n23 * n42 +
          n12 * n21 * n43 -
          n11 * n22 * n43) *
        detInv

      te[12] = t14 * detInv
      te[13] =
        (n13 * n24 * n31 -
          n14 * n23 * n31 +
          n14 * n21 * n33 -
          n11 * n24 * n33 -
          n13 * n21 * n34 +
          n11 * n23 * n34) *
        detInv
      te[14] =
        (n14 * n22 * n31 -
          n12 * n24 * n31 -
          n14 * n21 * n32 +
          n11 * n24 * n32 +
          n12 * n21 * n34 -
          n11 * n22 * n34) *
        detInv
      te[15] =
        (n12 * n23 * n31 -
          n13 * n22 * n31 +
          n13 * n21 * n32 -
          n11 * n23 * n32 -
          n12 * n21 * n33 +
          n11 * n22 * n33) *
        detInv

      return this
    },

    scale: function (v) {
      var te = this.elements
      var x = v.x,
        y = v.y,
        z = v.z

      te[0] *= x
      te[4] *= y
      te[8] *= z
      te[1] *= x
      te[5] *= y
      te[9] *= z
      te[2] *= x
      te[6] *= y
      te[10] *= z
      te[3] *= x
      te[7] *= y
      te[11] *= z

      return this
    },

    getMaxScaleOnAxis: function () {
      var te = this.elements

      var scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2]
      var scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6]
      var scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10]

      return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq))
    },

    makeTranslation: function (x, y, z) {
      this.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1)

      return this
    },

    makeRotationX: function (theta) {
      var c = Math.cos(theta),
        s = Math.sin(theta)

      this.set(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1)

      return this
    },

    makeRotationY: function (theta) {
      var c = Math.cos(theta),
        s = Math.sin(theta)

      this.set(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1)

      return this
    },

    makeRotationZ: function (theta) {
      var c = Math.cos(theta),
        s = Math.sin(theta)

      this.set(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)

      return this
    },

    makeRotationAxis: function (axis, angle) {
      // Based on http://www.gamedev.net/reference/articles/article1199.asp

      var c = Math.cos(angle)
      var s = Math.sin(angle)
      var t = 1 - c
      var x = axis.x,
        y = axis.y,
        z = axis.z
      var tx = t * x,
        ty = t * y

      this.set(
        tx * x + c,
        tx * y - s * z,
        tx * z + s * y,
        0,
        tx * y + s * z,
        ty * y + c,
        ty * z - s * x,
        0,
        tx * z - s * y,
        ty * z + s * x,
        t * z * z + c,
        0,
        0,
        0,
        0,
        1
      )

      return this
    },

    makeScale: function (x, y, z) {
      this.set(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1)

      return this
    },

    makeShear: function (x, y, z) {
      this.set(1, y, z, 0, x, 1, z, 0, x, y, 1, 0, 0, 0, 0, 1)

      return this
    },

    compose: function (position, quaternion, scale) {
      this.makeRotationFromQuaternion(quaternion)
      this.scale(scale)
      this.setPosition(position)

      return this
    },

    decompose: (function () {
      var vector = new Vector3()
      var matrix = new Matrix4()

      return function decompose(position, quaternion, scale) {
        var te = this.elements

        var sx = vector.set(te[0], te[1], te[2]).length()
        var sy = vector.set(te[4], te[5], te[6]).length()
        var sz = vector.set(te[8], te[9], te[10]).length()

        // if determine is negative, we need to invert one scale
        var det = this.determinant()
        if (det < 0) sx = -sx

        position.x = te[12]
        position.y = te[13]
        position.z = te[14]

        // scale the rotation part
        matrix.copy(this)

        var invSX = 1 / sx
        var invSY = 1 / sy
        var invSZ = 1 / sz

        matrix.elements[0] *= invSX
        matrix.elements[1] *= invSX
        matrix.elements[2] *= invSX

        matrix.elements[4] *= invSY
        matrix.elements[5] *= invSY
        matrix.elements[6] *= invSY

        matrix.elements[8] *= invSZ
        matrix.elements[9] *= invSZ
        matrix.elements[10] *= invSZ

        quaternion.setFromRotationMatrix(matrix)

        scale.x = sx
        scale.y = sy
        scale.z = sz

        return this
      }
    })(),

    makePerspective: function (left, right, top, bottom, near, far) {
      if (far === undefined) {
        console.warn(
          'THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.'
        )
      }

      var te = this.elements
      var x = (2 * near) / (right - left)
      var y = (2 * near) / (top - bottom)

      var a = (right + left) / (right - left)
      var b = (top + bottom) / (top - bottom)
      var c = -(far + near) / (far - near)
      var d = (-2 * far * near) / (far - near)

      te[0] = x
      te[4] = 0
      te[8] = a
      te[12] = 0
      te[1] = 0
      te[5] = y
      te[9] = b
      te[13] = 0
      te[2] = 0
      te[6] = 0
      te[10] = c
      te[14] = d
      te[3] = 0
      te[7] = 0
      te[11] = -1
      te[15] = 0

      return this
    },

    makeOrthographic: function (left, right, top, bottom, near, far) {
      var te = this.elements
      var w = 1.0 / (right - left)
      var h = 1.0 / (top - bottom)
      var p = 1.0 / (far - near)

      var x = (right + left) * w
      var y = (top + bottom) * h
      var z = (far + near) * p

      te[0] = 2 * w
      te[4] = 0
      te[8] = 0
      te[12] = -x
      te[1] = 0
      te[5] = 2 * h
      te[9] = 0
      te[13] = -y
      te[2] = 0
      te[6] = 0
      te[10] = -2 * p
      te[14] = -z
      te[3] = 0
      te[7] = 0
      te[11] = 0
      te[15] = 1

      return this
    },

    equals: function (matrix) {
      var te = this.elements
      var me = matrix.elements

      for (var i = 0; i < 16; i++) {
        if (te[i] !== me[i]) return false
      }

      return true
    },

    fromArray: function (array, offset) {
      if (offset === undefined) offset = 0

      for (var i = 0; i < 16; i++) {
        this.elements[i] = array[i + offset]
      }

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      var te = this.elements

      array[offset] = te[0]
      array[offset + 1] = te[1]
      array[offset + 2] = te[2]
      array[offset + 3] = te[3]

      array[offset + 4] = te[4]
      array[offset + 5] = te[5]
      array[offset + 6] = te[6]
      array[offset + 7] = te[7]

      array[offset + 8] = te[8]
      array[offset + 9] = te[9]
      array[offset + 10] = te[10]
      array[offset + 11] = te[11]

      array[offset + 12] = te[12]
      array[offset + 13] = te[13]
      array[offset + 14] = te[14]
      array[offset + 15] = te[15]

      return array
    }
  })

  /**
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   * @author WestLangley / http://github.com/WestLangley
   * @author bhouston / http://clara.io
   */

  function Quaternion(x, y, z, w) {
    this._x = x || 0
    this._y = y || 0
    this._z = z || 0
    this._w = w !== undefined ? w : 1
  }

  Object.assign(Quaternion, {
    slerp: function (qa, qb, qm, t) {
      return qm.copy(qa).slerp(qb, t)
    },

    slerpFlat: function (dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
      // fuzz-free, array-based Quaternion SLERP operation

      var x0 = src0[srcOffset0 + 0],
        y0 = src0[srcOffset0 + 1],
        z0 = src0[srcOffset0 + 2],
        w0 = src0[srcOffset0 + 3],
        x1 = src1[srcOffset1 + 0],
        y1 = src1[srcOffset1 + 1],
        z1 = src1[srcOffset1 + 2],
        w1 = src1[srcOffset1 + 3]

      if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
        var s = 1 - t,
          cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
          dir = cos >= 0 ? 1 : -1,
          sqrSin = 1 - cos * cos

        // Skip the Slerp for tiny steps to avoid numeric problems:
        if (sqrSin > Number.EPSILON) {
          var sin = Math.sqrt(sqrSin),
            len = Math.atan2(sin, cos * dir)

          s = Math.sin(s * len) / sin
          t = Math.sin(t * len) / sin
        }

        var tDir = t * dir

        x0 = x0 * s + x1 * tDir
        y0 = y0 * s + y1 * tDir
        z0 = z0 * s + z1 * tDir
        w0 = w0 * s + w1 * tDir

        // Normalize in case we just did a lerp:
        if (s === 1 - t) {
          var f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0)

          x0 *= f
          y0 *= f
          z0 *= f
          w0 *= f
        }
      }

      dst[dstOffset] = x0
      dst[dstOffset + 1] = y0
      dst[dstOffset + 2] = z0
      dst[dstOffset + 3] = w0
    }
  })

  Object.defineProperties(Quaternion.prototype, {
    x: {
      get: function () {
        return this._x
      },

      set: function (value) {
        this._x = value
        this.onChangeCallback()
      }
    },

    y: {
      get: function () {
        return this._y
      },

      set: function (value) {
        this._y = value
        this.onChangeCallback()
      }
    },

    z: {
      get: function () {
        return this._z
      },

      set: function (value) {
        this._z = value
        this.onChangeCallback()
      }
    },

    w: {
      get: function () {
        return this._w
      },

      set: function (value) {
        this._w = value
        this.onChangeCallback()
      }
    }
  })

  Object.assign(Quaternion.prototype, {
    set: function (x, y, z, w) {
      this._x = x
      this._y = y
      this._z = z
      this._w = w

      this.onChangeCallback()

      return this
    },

    clone: function () {
      return new this.constructor(this._x, this._y, this._z, this._w)
    },

    copy: function (quaternion) {
      this._x = quaternion.x
      this._y = quaternion.y
      this._z = quaternion.z
      this._w = quaternion.w

      this.onChangeCallback()

      return this
    },

    setFromEuler: function (euler, update) {
      if (!(euler && euler.isEuler)) {
        throw new Error(
          'THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.'
        )
      }

      var x = euler._x,
        y = euler._y,
        z = euler._z,
        order = euler.order

      // http://www.mathworks.com/matlabcentral/fileexchange/
      // 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
      //	content/SpinCalc.m

      var cos = Math.cos
      var sin = Math.sin

      var c1 = cos(x / 2)
      var c2 = cos(y / 2)
      var c3 = cos(z / 2)

      var s1 = sin(x / 2)
      var s2 = sin(y / 2)
      var s3 = sin(z / 2)

      if (order === 'XYZ') {
        this._x = s1 * c2 * c3 + c1 * s2 * s3
        this._y = c1 * s2 * c3 - s1 * c2 * s3
        this._z = c1 * c2 * s3 + s1 * s2 * c3
        this._w = c1 * c2 * c3 - s1 * s2 * s3
      } else if (order === 'YXZ') {
        this._x = s1 * c2 * c3 + c1 * s2 * s3
        this._y = c1 * s2 * c3 - s1 * c2 * s3
        this._z = c1 * c2 * s3 - s1 * s2 * c3
        this._w = c1 * c2 * c3 + s1 * s2 * s3
      } else if (order === 'ZXY') {
        this._x = s1 * c2 * c3 - c1 * s2 * s3
        this._y = c1 * s2 * c3 + s1 * c2 * s3
        this._z = c1 * c2 * s3 + s1 * s2 * c3
        this._w = c1 * c2 * c3 - s1 * s2 * s3
      } else if (order === 'ZYX') {
        this._x = s1 * c2 * c3 - c1 * s2 * s3
        this._y = c1 * s2 * c3 + s1 * c2 * s3
        this._z = c1 * c2 * s3 - s1 * s2 * c3
        this._w = c1 * c2 * c3 + s1 * s2 * s3
      } else if (order === 'YZX') {
        this._x = s1 * c2 * c3 + c1 * s2 * s3
        this._y = c1 * s2 * c3 + s1 * c2 * s3
        this._z = c1 * c2 * s3 - s1 * s2 * c3
        this._w = c1 * c2 * c3 - s1 * s2 * s3
      } else if (order === 'XZY') {
        this._x = s1 * c2 * c3 - c1 * s2 * s3
        this._y = c1 * s2 * c3 - s1 * c2 * s3
        this._z = c1 * c2 * s3 + s1 * s2 * c3
        this._w = c1 * c2 * c3 + s1 * s2 * s3
      }

      if (update !== false) this.onChangeCallback()

      return this
    },

    setFromAxisAngle: function (axis, angle) {
      // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm

      // assumes axis is normalized

      var halfAngle = angle / 2,
        s = Math.sin(halfAngle)

      this._x = axis.x * s
      this._y = axis.y * s
      this._z = axis.z * s
      this._w = Math.cos(halfAngle)

      this.onChangeCallback()

      return this
    },

    setFromRotationMatrix: function (m) {
      // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm

      // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

      var te = m.elements,
        m11 = te[0],
        m12 = te[4],
        m13 = te[8],
        m21 = te[1],
        m22 = te[5],
        m23 = te[9],
        m31 = te[2],
        m32 = te[6],
        m33 = te[10],
        trace = m11 + m22 + m33,
        s

      if (trace > 0) {
        s = 0.5 / Math.sqrt(trace + 1.0)

        this._w = 0.25 / s
        this._x = (m32 - m23) * s
        this._y = (m13 - m31) * s
        this._z = (m21 - m12) * s
      } else if (m11 > m22 && m11 > m33) {
        s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33)

        this._w = (m32 - m23) / s
        this._x = 0.25 * s
        this._y = (m12 + m21) / s
        this._z = (m13 + m31) / s
      } else if (m22 > m33) {
        s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33)

        this._w = (m13 - m31) / s
        this._x = (m12 + m21) / s
        this._y = 0.25 * s
        this._z = (m23 + m32) / s
      } else {
        s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22)

        this._w = (m21 - m12) / s
        this._x = (m13 + m31) / s
        this._y = (m23 + m32) / s
        this._z = 0.25 * s
      }

      this.onChangeCallback()

      return this
    },

    setFromUnitVectors: (function () {
      // assumes direction vectors vFrom and vTo are normalized

      var v1 = new Vector3()
      var r

      var EPS = 0.000001

      return function setFromUnitVectors(vFrom, vTo) {
        if (v1 === undefined) v1 = new Vector3()

        r = vFrom.dot(vTo) + 1

        if (r < EPS) {
          r = 0

          if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
            v1.set(-vFrom.y, vFrom.x, 0)
          } else {
            v1.set(0, -vFrom.z, vFrom.y)
          }
        } else {
          v1.crossVectors(vFrom, vTo)
        }

        this._x = v1.x
        this._y = v1.y
        this._z = v1.z
        this._w = r

        return this.normalize()
      }
    })(),

    inverse: function () {
      // quaternion is assumed to have unit length

      return this.conjugate()
    },

    conjugate: function () {
      this._x *= -1
      this._y *= -1
      this._z *= -1

      this.onChangeCallback()

      return this
    },

    dot: function (v) {
      return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w
    },

    lengthSq: function () {
      return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w
    },

    length: function () {
      return Math.sqrt(
        this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w
      )
    },

    normalize: function () {
      var l = this.length()

      if (l === 0) {
        this._x = 0
        this._y = 0
        this._z = 0
        this._w = 1
      } else {
        l = 1 / l

        this._x = this._x * l
        this._y = this._y * l
        this._z = this._z * l
        this._w = this._w * l
      }

      this.onChangeCallback()

      return this
    },

    multiply: function (q, p) {
      if (p !== undefined) {
        console.warn(
          'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.'
        )
        return this.multiplyQuaternions(q, p)
      }

      return this.multiplyQuaternions(this, q)
    },

    premultiply: function (q) {
      return this.multiplyQuaternions(q, this)
    },

    multiplyQuaternions: function (a, b) {
      // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm

      var qax = a._x,
        qay = a._y,
        qaz = a._z,
        qaw = a._w
      var qbx = b._x,
        qby = b._y,
        qbz = b._z,
        qbw = b._w

      this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby
      this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz
      this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx
      this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz

      this.onChangeCallback()

      return this
    },

    slerp: function (qb, t) {
      if (t === 0) return this
      if (t === 1) return this.copy(qb)

      var x = this._x,
        y = this._y,
        z = this._z,
        w = this._w

      // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/

      var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z

      if (cosHalfTheta < 0) {
        this._w = -qb._w
        this._x = -qb._x
        this._y = -qb._y
        this._z = -qb._z

        cosHalfTheta = -cosHalfTheta
      } else {
        this.copy(qb)
      }

      if (cosHalfTheta >= 1.0) {
        this._w = w
        this._x = x
        this._y = y
        this._z = z

        return this
      }

      var sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta)

      if (Math.abs(sinHalfTheta) < 0.001) {
        this._w = 0.5 * (w + this._w)
        this._x = 0.5 * (x + this._x)
        this._y = 0.5 * (y + this._y)
        this._z = 0.5 * (z + this._z)

        return this
      }

      var halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta)
      var ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta,
        ratioB = Math.sin(t * halfTheta) / sinHalfTheta

      this._w = w * ratioA + this._w * ratioB
      this._x = x * ratioA + this._x * ratioB
      this._y = y * ratioA + this._y * ratioB
      this._z = z * ratioA + this._z * ratioB

      this.onChangeCallback()

      return this
    },

    equals: function (quaternion) {
      return (
        quaternion._x === this._x &&
        quaternion._y === this._y &&
        quaternion._z === this._z &&
        quaternion._w === this._w
      )
    },

    fromArray: function (array, offset) {
      if (offset === undefined) offset = 0

      this._x = array[offset]
      this._y = array[offset + 1]
      this._z = array[offset + 2]
      this._w = array[offset + 3]

      this.onChangeCallback()

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      array[offset] = this._x
      array[offset + 1] = this._y
      array[offset + 2] = this._z
      array[offset + 3] = this._w

      return array
    },

    onChange: function (callback) {
      this.onChangeCallback = callback

      return this
    },

    onChangeCallback: function () {}
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author kile / http://kile.stravaganza.org/
   * @author philogb / http://blog.thejit.org/
   * @author mikael emtinger / http://gomo.se/
   * @author egraether / http://egraether.com/
   * @author WestLangley / http://github.com/WestLangley
   */

  function Vector3(x, y, z) {
    this.x = x || 0
    this.y = y || 0
    this.z = z || 0
  }

  Object.assign(Vector3.prototype, {
    isVector3: true,

    set: function (x, y, z) {
      this.x = x
      this.y = y
      this.z = z

      return this
    },

    setScalar: function (scalar) {
      this.x = scalar
      this.y = scalar
      this.z = scalar

      return this
    },

    setX: function (x) {
      this.x = x

      return this
    },

    setY: function (y) {
      this.y = y

      return this
    },

    setZ: function (z) {
      this.z = z

      return this
    },

    setComponent: function (index, value) {
      switch (index) {
        case 0:
          this.x = value
          break
        case 1:
          this.y = value
          break
        case 2:
          this.z = value
          break
        default:
          throw new Error('index is out of range: ' + index)
      }

      return this
    },

    getComponent: function (index) {
      switch (index) {
        case 0:
          return this.x
        case 1:
          return this.y
        case 2:
          return this.z
        default:
          throw new Error('index is out of range: ' + index)
      }
    },

    clone: function () {
      return new this.constructor(this.x, this.y, this.z)
    },

    copy: function (v) {
      this.x = v.x
      this.y = v.y
      this.z = v.z

      return this
    },

    add: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.'
        )
        return this.addVectors(v, w)
      }

      this.x += v.x
      this.y += v.y
      this.z += v.z

      return this
    },

    addScalar: function (s) {
      this.x += s
      this.y += s
      this.z += s

      return this
    },

    addVectors: function (a, b) {
      this.x = a.x + b.x
      this.y = a.y + b.y
      this.z = a.z + b.z

      return this
    },

    addScaledVector: function (v, s) {
      this.x += v.x * s
      this.y += v.y * s
      this.z += v.z * s

      return this
    },

    sub: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.'
        )
        return this.subVectors(v, w)
      }

      this.x -= v.x
      this.y -= v.y
      this.z -= v.z

      return this
    },

    subScalar: function (s) {
      this.x -= s
      this.y -= s
      this.z -= s

      return this
    },

    subVectors: function (a, b) {
      this.x = a.x - b.x
      this.y = a.y - b.y
      this.z = a.z - b.z

      return this
    },

    multiply: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.'
        )
        return this.multiplyVectors(v, w)
      }

      this.x *= v.x
      this.y *= v.y
      this.z *= v.z

      return this
    },

    multiplyScalar: function (scalar) {
      this.x *= scalar
      this.y *= scalar
      this.z *= scalar

      return this
    },

    multiplyVectors: function (a, b) {
      this.x = a.x * b.x
      this.y = a.y * b.y
      this.z = a.z * b.z

      return this
    },

    applyEuler: (function () {
      var quaternion = new Quaternion()

      return function applyEuler(euler) {
        if (!(euler && euler.isEuler)) {
          console.error(
            'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.'
          )
        }

        return this.applyQuaternion(quaternion.setFromEuler(euler))
      }
    })(),

    applyAxisAngle: (function () {
      var quaternion = new Quaternion()

      return function applyAxisAngle(axis, angle) {
        return this.applyQuaternion(quaternion.setFromAxisAngle(axis, angle))
      }
    })(),

    applyMatrix3: function (m) {
      var x = this.x,
        y = this.y,
        z = this.z
      var e = m.elements

      this.x = e[0] * x + e[3] * y + e[6] * z
      this.y = e[1] * x + e[4] * y + e[7] * z
      this.z = e[2] * x + e[5] * y + e[8] * z

      return this
    },

    applyMatrix4: function (m) {
      var x = this.x,
        y = this.y,
        z = this.z
      var e = m.elements

      var w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15])

      this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w
      this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w
      this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w

      return this
    },

    applyQuaternion: function (q) {
      var x = this.x,
        y = this.y,
        z = this.z
      var qx = q.x,
        qy = q.y,
        qz = q.z,
        qw = q.w

      // calculate quat * vector

      var ix = qw * x + qy * z - qz * y
      var iy = qw * y + qz * x - qx * z
      var iz = qw * z + qx * y - qy * x
      var iw = -qx * x - qy * y - qz * z

      // calculate result * inverse quat

      this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy
      this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz
      this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx

      return this
    },

    project: (function () {
      var matrix = new Matrix4()

      return function project(camera) {
        matrix.multiplyMatrices(camera.projectionMatrix, matrix.getInverse(camera.matrixWorld))
        return this.applyMatrix4(matrix)
      }
    })(),

    unproject: (function () {
      var matrix = new Matrix4()

      return function unproject(camera) {
        matrix.multiplyMatrices(camera.matrixWorld, matrix.getInverse(camera.projectionMatrix))
        return this.applyMatrix4(matrix)
      }
    })(),

    transformDirection: function (m) {
      // input: THREE.Matrix4 affine matrix
      // vector interpreted as a direction

      var x = this.x,
        y = this.y,
        z = this.z
      var e = m.elements

      this.x = e[0] * x + e[4] * y + e[8] * z
      this.y = e[1] * x + e[5] * y + e[9] * z
      this.z = e[2] * x + e[6] * y + e[10] * z

      return this.normalize()
    },

    divide: function (v) {
      this.x /= v.x
      this.y /= v.y
      this.z /= v.z

      return this
    },

    divideScalar: function (scalar) {
      return this.multiplyScalar(1 / scalar)
    },

    min: function (v) {
      this.x = Math.min(this.x, v.x)
      this.y = Math.min(this.y, v.y)
      this.z = Math.min(this.z, v.z)

      return this
    },

    max: function (v) {
      this.x = Math.max(this.x, v.x)
      this.y = Math.max(this.y, v.y)
      this.z = Math.max(this.z, v.z)

      return this
    },

    clamp: function (min, max) {
      // assumes min < max, componentwise

      this.x = Math.max(min.x, Math.min(max.x, this.x))
      this.y = Math.max(min.y, Math.min(max.y, this.y))
      this.z = Math.max(min.z, Math.min(max.z, this.z))

      return this
    },

    clampScalar: (function () {
      var min = new Vector3()
      var max = new Vector3()

      return function clampScalar(minVal, maxVal) {
        min.set(minVal, minVal, minVal)
        max.set(maxVal, maxVal, maxVal)

        return this.clamp(min, max)
      }
    })(),

    clampLength: function (min, max) {
      var length = this.length()

      return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)))
    },

    floor: function () {
      this.x = Math.floor(this.x)
      this.y = Math.floor(this.y)
      this.z = Math.floor(this.z)

      return this
    },

    ceil: function () {
      this.x = Math.ceil(this.x)
      this.y = Math.ceil(this.y)
      this.z = Math.ceil(this.z)

      return this
    },

    round: function () {
      this.x = Math.round(this.x)
      this.y = Math.round(this.y)
      this.z = Math.round(this.z)

      return this
    },

    roundToZero: function () {
      this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x)
      this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y)
      this.z = this.z < 0 ? Math.ceil(this.z) : Math.floor(this.z)

      return this
    },

    negate: function () {
      this.x = -this.x
      this.y = -this.y
      this.z = -this.z

      return this
    },

    dot: function (v) {
      return this.x * v.x + this.y * v.y + this.z * v.z
    },

    // TODO lengthSquared?

    lengthSq: function () {
      return this.x * this.x + this.y * this.y + this.z * this.z
    },

    length: function () {
      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z)
    },

    manhattanLength: function () {
      return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z)
    },

    normalize: function () {
      return this.divideScalar(this.length() || 1)
    },

    setLength: function (length) {
      return this.normalize().multiplyScalar(length)
    },

    lerp: function (v, alpha) {
      this.x += (v.x - this.x) * alpha
      this.y += (v.y - this.y) * alpha
      this.z += (v.z - this.z) * alpha

      return this
    },

    lerpVectors: function (v1, v2, alpha) {
      return this.subVectors(v2, v1).multiplyScalar(alpha).add(v1)
    },

    cross: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.'
        )
        return this.crossVectors(v, w)
      }

      return this.crossVectors(this, v)
    },

    crossVectors: function (a, b) {
      var ax = a.x,
        ay = a.y,
        az = a.z
      var bx = b.x,
        by = b.y,
        bz = b.z

      this.x = ay * bz - az * by
      this.y = az * bx - ax * bz
      this.z = ax * by - ay * bx

      return this
    },

    projectOnVector: function (vector) {
      var scalar = vector.dot(this) / vector.lengthSq()

      return this.copy(vector).multiplyScalar(scalar)
    },

    projectOnPlane: (function () {
      var v1 = new Vector3()

      return function projectOnPlane(planeNormal) {
        v1.copy(this).projectOnVector(planeNormal)

        return this.sub(v1)
      }
    })(),

    reflect: (function () {
      // reflect incident vector off plane orthogonal to normal
      // normal is assumed to have unit length

      var v1 = new Vector3()

      return function reflect(normal) {
        return this.sub(v1.copy(normal).multiplyScalar(2 * this.dot(normal)))
      }
    })(),

    angleTo: function (v) {
      var theta = this.dot(v) / Math.sqrt(this.lengthSq() * v.lengthSq())

      // clamp, to handle numerical problems

      return Math.acos(_Math.clamp(theta, -1, 1))
    },

    distanceTo: function (v) {
      return Math.sqrt(this.distanceToSquared(v))
    },

    distanceToSquared: function (v) {
      var dx = this.x - v.x,
        dy = this.y - v.y,
        dz = this.z - v.z

      return dx * dx + dy * dy + dz * dz
    },

    manhattanDistanceTo: function (v) {
      return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z)
    },

    setFromSpherical: function (s) {
      var sinPhiRadius = Math.sin(s.phi) * s.radius

      this.x = sinPhiRadius * Math.sin(s.theta)
      this.y = Math.cos(s.phi) * s.radius
      this.z = sinPhiRadius * Math.cos(s.theta)

      return this
    },

    setFromCylindrical: function (c) {
      this.x = c.radius * Math.sin(c.theta)
      this.y = c.y
      this.z = c.radius * Math.cos(c.theta)

      return this
    },

    setFromMatrixPosition: function (m) {
      var e = m.elements

      this.x = e[12]
      this.y = e[13]
      this.z = e[14]

      return this
    },

    setFromMatrixScale: function (m) {
      var sx = this.setFromMatrixColumn(m, 0).length()
      var sy = this.setFromMatrixColumn(m, 1).length()
      var sz = this.setFromMatrixColumn(m, 2).length()

      this.x = sx
      this.y = sy
      this.z = sz

      return this
    },

    setFromMatrixColumn: function (m, index) {
      return this.fromArray(m.elements, index * 4)
    },

    equals: function (v) {
      return v.x === this.x && v.y === this.y && v.z === this.z
    },

    fromArray: function (array, offset) {
      if (offset === undefined) offset = 0

      this.x = array[offset]
      this.y = array[offset + 1]
      this.z = array[offset + 2]

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      array[offset] = this.x
      array[offset + 1] = this.y
      array[offset + 2] = this.z

      return array
    },

    fromBufferAttribute: function (attribute, index, offset) {
      if (offset !== undefined) {
        console.warn('THREE.Vector3: offset has been removed from .fromBufferAttribute().')
      }

      this.x = attribute.getX(index)
      this.y = attribute.getY(index)
      this.z = attribute.getZ(index)

      return this
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author WestLangley / http://github.com/WestLangley
   * @author bhouston / http://clara.io
   * @author tschw
   */

  function Matrix3() {
    this.elements = [1, 0, 0, 0, 1, 0, 0, 0, 1]

    if (arguments.length > 0) {
      console.error('THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.')
    }
  }

  Object.assign(Matrix3.prototype, {
    isMatrix3: true,

    set: function (n11, n12, n13, n21, n22, n23, n31, n32, n33) {
      var te = this.elements

      te[0] = n11
      te[1] = n21
      te[2] = n31
      te[3] = n12
      te[4] = n22
      te[5] = n32
      te[6] = n13
      te[7] = n23
      te[8] = n33

      return this
    },

    identity: function () {
      this.set(1, 0, 0, 0, 1, 0, 0, 0, 1)

      return this
    },

    clone: function () {
      return new this.constructor().fromArray(this.elements)
    },

    copy: function (m) {
      var te = this.elements
      var me = m.elements

      te[0] = me[0]
      te[1] = me[1]
      te[2] = me[2]
      te[3] = me[3]
      te[4] = me[4]
      te[5] = me[5]
      te[6] = me[6]
      te[7] = me[7]
      te[8] = me[8]

      return this
    },

    setFromMatrix4: function (m) {
      var me = m.elements

      this.set(me[0], me[4], me[8], me[1], me[5], me[9], me[2], me[6], me[10])

      return this
    },

    applyToBufferAttribute: (function () {
      var v1 = new Vector3()

      return function applyToBufferAttribute(attribute) {
        for (var i = 0, l = attribute.count; i < l; i++) {
          v1.x = attribute.getX(i)
          v1.y = attribute.getY(i)
          v1.z = attribute.getZ(i)

          v1.applyMatrix3(this)

          attribute.setXYZ(i, v1.x, v1.y, v1.z)
        }

        return attribute
      }
    })(),

    multiply: function (m) {
      return this.multiplyMatrices(this, m)
    },

    premultiply: function (m) {
      return this.multiplyMatrices(m, this)
    },

    multiplyMatrices: function (a, b) {
      var ae = a.elements
      var be = b.elements
      var te = this.elements

      var a11 = ae[0],
        a12 = ae[3],
        a13 = ae[6]
      var a21 = ae[1],
        a22 = ae[4],
        a23 = ae[7]
      var a31 = ae[2],
        a32 = ae[5],
        a33 = ae[8]

      var b11 = be[0],
        b12 = be[3],
        b13 = be[6]
      var b21 = be[1],
        b22 = be[4],
        b23 = be[7]
      var b31 = be[2],
        b32 = be[5],
        b33 = be[8]

      te[0] = a11 * b11 + a12 * b21 + a13 * b31
      te[3] = a11 * b12 + a12 * b22 + a13 * b32
      te[6] = a11 * b13 + a12 * b23 + a13 * b33

      te[1] = a21 * b11 + a22 * b21 + a23 * b31
      te[4] = a21 * b12 + a22 * b22 + a23 * b32
      te[7] = a21 * b13 + a22 * b23 + a23 * b33

      te[2] = a31 * b11 + a32 * b21 + a33 * b31
      te[5] = a31 * b12 + a32 * b22 + a33 * b32
      te[8] = a31 * b13 + a32 * b23 + a33 * b33

      return this
    },

    multiplyScalar: function (s) {
      var te = this.elements

      te[0] *= s
      te[3] *= s
      te[6] *= s
      te[1] *= s
      te[4] *= s
      te[7] *= s
      te[2] *= s
      te[5] *= s
      te[8] *= s

      return this
    },

    determinant: function () {
      var te = this.elements

      var a = te[0],
        b = te[1],
        c = te[2],
        d = te[3],
        e = te[4],
        f = te[5],
        g = te[6],
        h = te[7],
        i = te[8]

      return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g
    },

    getInverse: function (matrix, throwOnDegenerate) {
      if (matrix && matrix.isMatrix4) {
        console.error('THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument.')
      }

      var me = matrix.elements,
        te = this.elements,
        n11 = me[0],
        n21 = me[1],
        n31 = me[2],
        n12 = me[3],
        n22 = me[4],
        n32 = me[5],
        n13 = me[6],
        n23 = me[7],
        n33 = me[8],
        t11 = n33 * n22 - n32 * n23,
        t12 = n32 * n13 - n33 * n12,
        t13 = n23 * n12 - n22 * n13,
        det = n11 * t11 + n21 * t12 + n31 * t13

      if (det === 0) {
        var msg = "THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0"

        if (throwOnDegenerate === true) {
          throw new Error(msg)
        } else {
          console.warn(msg)
        }

        return this.identity()
      }

      var detInv = 1 / det

      te[0] = t11 * detInv
      te[1] = (n31 * n23 - n33 * n21) * detInv
      te[2] = (n32 * n21 - n31 * n22) * detInv

      te[3] = t12 * detInv
      te[4] = (n33 * n11 - n31 * n13) * detInv
      te[5] = (n31 * n12 - n32 * n11) * detInv

      te[6] = t13 * detInv
      te[7] = (n21 * n13 - n23 * n11) * detInv
      te[8] = (n22 * n11 - n21 * n12) * detInv

      return this
    },

    transpose: function () {
      var tmp,
        m = this.elements

      tmp = m[1]
      m[1] = m[3]
      m[3] = tmp
      tmp = m[2]
      m[2] = m[6]
      m[6] = tmp
      tmp = m[5]
      m[5] = m[7]
      m[7] = tmp

      return this
    },

    getNormalMatrix: function (matrix4) {
      return this.setFromMatrix4(matrix4).getInverse(this).transpose()
    },

    transposeIntoArray: function (r) {
      var m = this.elements

      r[0] = m[0]
      r[1] = m[3]
      r[2] = m[6]
      r[3] = m[1]
      r[4] = m[4]
      r[5] = m[7]
      r[6] = m[2]
      r[7] = m[5]
      r[8] = m[8]

      return this
    },

    setUvTransform: function (tx, ty, sx, sy, rotation, cx, cy) {
      var c = Math.cos(rotation)
      var s = Math.sin(rotation)

      this.set(
        sx * c,
        sx * s,
        -sx * (c * cx + s * cy) + cx + tx,
        -sy * s,
        sy * c,
        -sy * (-s * cx + c * cy) + cy + ty,
        0,
        0,
        1
      )
    },

    scale: function (sx, sy) {
      var te = this.elements

      te[0] *= sx
      te[3] *= sx
      te[6] *= sx
      te[1] *= sy
      te[4] *= sy
      te[7] *= sy

      return this
    },

    rotate: function (theta) {
      var c = Math.cos(theta)
      var s = Math.sin(theta)

      var te = this.elements

      var a11 = te[0],
        a12 = te[3],
        a13 = te[6]
      var a21 = te[1],
        a22 = te[4],
        a23 = te[7]

      te[0] = c * a11 + s * a21
      te[3] = c * a12 + s * a22
      te[6] = c * a13 + s * a23

      te[1] = -s * a11 + c * a21
      te[4] = -s * a12 + c * a22
      te[7] = -s * a13 + c * a23

      return this
    },

    translate: function (tx, ty) {
      var te = this.elements

      te[0] += tx * te[2]
      te[3] += tx * te[5]
      te[6] += tx * te[8]
      te[1] += ty * te[2]
      te[4] += ty * te[5]
      te[7] += ty * te[8]

      return this
    },

    equals: function (matrix) {
      var te = this.elements
      var me = matrix.elements

      for (var i = 0; i < 9; i++) {
        if (te[i] !== me[i]) return false
      }

      return true
    },

    fromArray: function (array, offset) {
      if (offset === undefined) offset = 0

      for (var i = 0; i < 9; i++) {
        this.elements[i] = array[i + offset]
      }

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      var te = this.elements

      array[offset] = te[0]
      array[offset + 1] = te[1]
      array[offset + 2] = te[2]

      array[offset + 3] = te[3]
      array[offset + 4] = te[4]
      array[offset + 5] = te[5]

      array[offset + 6] = te[6]
      array[offset + 7] = te[7]
      array[offset + 8] = te[8]

      return array
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   * @author szimek / https://github.com/szimek/
   */

  var textureId = 0

  function Texture(
    image,
    mapping,
    wrapS,
    wrapT,
    magFilter,
    minFilter,
    format,
    type,
    anisotropy,
    encoding
  ) {
    Object.defineProperty(this, 'id', { value: textureId++ })

    this.uuid = _Math.generateUUID()

    this.name = ''

    this.image = image !== undefined ? image : Texture.DEFAULT_IMAGE
    this.mipmaps = []

    this.mapping = mapping !== undefined ? mapping : Texture.DEFAULT_MAPPING

    this.wrapS = wrapS !== undefined ? wrapS : ClampToEdgeWrapping
    this.wrapT = wrapT !== undefined ? wrapT : ClampToEdgeWrapping

    this.magFilter = magFilter !== undefined ? magFilter : LinearFilter
    this.minFilter = minFilter !== undefined ? minFilter : LinearMipMapLinearFilter

    this.anisotropy = anisotropy !== undefined ? anisotropy : 1

    this.format = format !== undefined ? format : RGBAFormat
    this.type = type !== undefined ? type : UnsignedByteType

    this.offset = new Vector2(0, 0)
    this.repeat = new Vector2(1, 1)
    this.center = new Vector2(0, 0)
    this.rotation = 0

    this.matrixAutoUpdate = true
    this.matrix = new Matrix3()

    this.generateMipmaps = true
    this.premultiplyAlpha = false
    this.flipY = true
    this.unpackAlignment = 4 // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)

    // Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
    //
    // Also changing the encoding after already used by a Material will not automatically make the Material
    // update.  You need to explicitly call Material.needsUpdate to trigger it to recompile.
    this.encoding = encoding !== undefined ? encoding : LinearEncoding

    this.version = 0
    this.onUpdate = null
  }

  Texture.DEFAULT_IMAGE = undefined
  Texture.DEFAULT_MAPPING = UVMapping

  Texture.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Texture,

    isTexture: true,

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (source) {
      this.name = source.name

      this.image = source.image
      this.mipmaps = source.mipmaps.slice(0)

      this.mapping = source.mapping

      this.wrapS = source.wrapS
      this.wrapT = source.wrapT

      this.magFilter = source.magFilter
      this.minFilter = source.minFilter

      this.anisotropy = source.anisotropy

      this.format = source.format
      this.type = source.type

      this.offset.copy(source.offset)
      this.repeat.copy(source.repeat)
      this.center.copy(source.center)
      this.rotation = source.rotation

      this.matrixAutoUpdate = source.matrixAutoUpdate
      this.matrix.copy(source.matrix)

      this.generateMipmaps = source.generateMipmaps
      this.premultiplyAlpha = source.premultiplyAlpha
      this.flipY = source.flipY
      this.unpackAlignment = source.unpackAlignment
      this.encoding = source.encoding

      return this
    },

    toJSON: function (meta) {
      var isRootObject = meta === undefined || typeof meta === 'string'

      if (!isRootObject && meta.textures[this.uuid] !== undefined) {
        return meta.textures[this.uuid]
      }

      function getDataURL(image) {
        var canvas

        if (image instanceof HTMLCanvasElement) {
          canvas = image
        } else {
          canvas = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')
          canvas.width = image.width
          canvas.height = image.height

          var context = canvas.getContext('2d')

          if (image instanceof ImageData) {
            context.putImageData(image, 0, 0)
          } else {
            context.drawImage(image, 0, 0, image.width, image.height)
          }
        }

        if (canvas.width > 2048 || canvas.height > 2048) {
          return canvas.toDataURL('image/jpeg', 0.6)
        } else {
          return canvas.toDataURL('image/png')
        }
      }

      var output = {
        metadata: {
          version: 4.5,
          type: 'Texture',
          generator: 'Texture.toJSON'
        },

        uuid: this.uuid,
        name: this.name,

        mapping: this.mapping,

        repeat: [this.repeat.x, this.repeat.y],
        offset: [this.offset.x, this.offset.y],
        center: [this.center.x, this.center.y],
        rotation: this.rotation,

        wrap: [this.wrapS, this.wrapT],

        minFilter: this.minFilter,
        magFilter: this.magFilter,
        anisotropy: this.anisotropy,

        flipY: this.flipY
      }

      if (this.image !== undefined) {
        // TODO: Move to THREE.Image

        var image = this.image

        if (image.uuid === undefined) {
          image.uuid = _Math.generateUUID() // UGH
        }

        if (!isRootObject && meta.images[image.uuid] === undefined) {
          meta.images[image.uuid] = {
            uuid: image.uuid,
            url: getDataURL(image)
          }
        }

        output.image = image.uuid
      }

      if (!isRootObject) {
        meta.textures[this.uuid] = output
      }

      return output
    },

    dispose: function () {
      this.dispatchEvent({ type: 'dispose' })
    },

    transformUv: function (uv) {
      if (this.mapping !== UVMapping) return

      uv.applyMatrix3(this.matrix)

      if (uv.x < 0 || uv.x > 1) {
        switch (this.wrapS) {
          case RepeatWrapping:
            uv.x = uv.x - Math.floor(uv.x)
            break

          case ClampToEdgeWrapping:
            uv.x = uv.x < 0 ? 0 : 1
            break

          case MirroredRepeatWrapping:
            if (Math.abs(Math.floor(uv.x) % 2) === 1) {
              uv.x = Math.ceil(uv.x) - uv.x
            } else {
              uv.x = uv.x - Math.floor(uv.x)
            }
            break
        }
      }

      if (uv.y < 0 || uv.y > 1) {
        switch (this.wrapT) {
          case RepeatWrapping:
            uv.y = uv.y - Math.floor(uv.y)
            break

          case ClampToEdgeWrapping:
            uv.y = uv.y < 0 ? 0 : 1
            break

          case MirroredRepeatWrapping:
            if (Math.abs(Math.floor(uv.y) % 2) === 1) {
              uv.y = Math.ceil(uv.y) - uv.y
            } else {
              uv.y = uv.y - Math.floor(uv.y)
            }
            break
        }
      }

      if (this.flipY) {
        uv.y = 1 - uv.y
      }
    }
  })

  Object.defineProperty(Texture.prototype, 'needsUpdate', {
    set: function (value) {
      if (value === true) this.version++
    }
  })

  /**
   * @author supereggbert / http://www.paulbrunt.co.uk/
   * @author philogb / http://blog.thejit.org/
   * @author mikael emtinger / http://gomo.se/
   * @author egraether / http://egraether.com/
   * @author WestLangley / http://github.com/WestLangley
   */

  function Vector4(x, y, z, w) {
    this.x = x || 0
    this.y = y || 0
    this.z = z || 0
    this.w = w !== undefined ? w : 1
  }

  Object.assign(Vector4.prototype, {
    isVector4: true,

    set: function (x, y, z, w) {
      this.x = x
      this.y = y
      this.z = z
      this.w = w

      return this
    },

    setScalar: function (scalar) {
      this.x = scalar
      this.y = scalar
      this.z = scalar
      this.w = scalar

      return this
    },

    setX: function (x) {
      this.x = x

      return this
    },

    setY: function (y) {
      this.y = y

      return this
    },

    setZ: function (z) {
      this.z = z

      return this
    },

    setW: function (w) {
      this.w = w

      return this
    },

    setComponent: function (index, value) {
      switch (index) {
        case 0:
          this.x = value
          break
        case 1:
          this.y = value
          break
        case 2:
          this.z = value
          break
        case 3:
          this.w = value
          break
        default:
          throw new Error('index is out of range: ' + index)
      }

      return this
    },

    getComponent: function (index) {
      switch (index) {
        case 0:
          return this.x
        case 1:
          return this.y
        case 2:
          return this.z
        case 3:
          return this.w
        default:
          throw new Error('index is out of range: ' + index)
      }
    },

    clone: function () {
      return new this.constructor(this.x, this.y, this.z, this.w)
    },

    copy: function (v) {
      this.x = v.x
      this.y = v.y
      this.z = v.z
      this.w = v.w !== undefined ? v.w : 1

      return this
    },

    add: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.'
        )
        return this.addVectors(v, w)
      }

      this.x += v.x
      this.y += v.y
      this.z += v.z
      this.w += v.w

      return this
    },

    addScalar: function (s) {
      this.x += s
      this.y += s
      this.z += s
      this.w += s

      return this
    },

    addVectors: function (a, b) {
      this.x = a.x + b.x
      this.y = a.y + b.y
      this.z = a.z + b.z
      this.w = a.w + b.w

      return this
    },

    addScaledVector: function (v, s) {
      this.x += v.x * s
      this.y += v.y * s
      this.z += v.z * s
      this.w += v.w * s

      return this
    },

    sub: function (v, w) {
      if (w !== undefined) {
        console.warn(
          'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.'
        )
        return this.subVectors(v, w)
      }

      this.x -= v.x
      this.y -= v.y
      this.z -= v.z
      this.w -= v.w

      return this
    },

    subScalar: function (s) {
      this.x -= s
      this.y -= s
      this.z -= s
      this.w -= s

      return this
    },

    subVectors: function (a, b) {
      this.x = a.x - b.x
      this.y = a.y - b.y
      this.z = a.z - b.z
      this.w = a.w - b.w

      return this
    },

    multiplyScalar: function (scalar) {
      this.x *= scalar
      this.y *= scalar
      this.z *= scalar
      this.w *= scalar

      return this
    },

    applyMatrix4: function (m) {
      var x = this.x,
        y = this.y,
        z = this.z,
        w = this.w
      var e = m.elements

      this.x = e[0] * x + e[4] * y + e[8] * z + e[12] * w
      this.y = e[1] * x + e[5] * y + e[9] * z + e[13] * w
      this.z = e[2] * x + e[6] * y + e[10] * z + e[14] * w
      this.w = e[3] * x + e[7] * y + e[11] * z + e[15] * w

      return this
    },

    divideScalar: function (scalar) {
      return this.multiplyScalar(1 / scalar)
    },

    setAxisAngleFromQuaternion: function (q) {
      // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm

      // q is assumed to be normalized

      this.w = 2 * Math.acos(q.w)

      var s = Math.sqrt(1 - q.w * q.w)

      if (s < 0.0001) {
        this.x = 1
        this.y = 0
        this.z = 0
      } else {
        this.x = q.x / s
        this.y = q.y / s
        this.z = q.z / s
      }

      return this
    },

    setAxisAngleFromRotationMatrix: function (m) {
      // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm

      // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

      var angle,
        x,
        y,
        z, // variables for result
        epsilon = 0.01, // margin to allow for rounding errors
        epsilon2 = 0.1, // margin to distinguish between 0 and 180 degrees
        te = m.elements,
        m11 = te[0],
        m12 = te[4],
        m13 = te[8],
        m21 = te[1],
        m22 = te[5],
        m23 = te[9],
        m31 = te[2],
        m32 = te[6],
        m33 = te[10]

      if (
        Math.abs(m12 - m21) < epsilon &&
        Math.abs(m13 - m31) < epsilon &&
        Math.abs(m23 - m32) < epsilon
      ) {
        // singularity found
        // first check for identity matrix which must have +1 for all terms
        // in leading diagonal and zero in other terms

        if (
          Math.abs(m12 + m21) < epsilon2 &&
          Math.abs(m13 + m31) < epsilon2 &&
          Math.abs(m23 + m32) < epsilon2 &&
          Math.abs(m11 + m22 + m33 - 3) < epsilon2
        ) {
          // this singularity is identity matrix so angle = 0

          this.set(1, 0, 0, 0)

          return this // zero angle, arbitrary axis
        }

        // otherwise this singularity is angle = 180

        angle = Math.PI

        var xx = (m11 + 1) / 2
        var yy = (m22 + 1) / 2
        var zz = (m33 + 1) / 2
        var xy = (m12 + m21) / 4
        var xz = (m13 + m31) / 4
        var yz = (m23 + m32) / 4

        if (xx > yy && xx > zz) {
          // m11 is the largest diagonal term

          if (xx < epsilon) {
            x = 0
            y = 0.707106781
            z = 0.707106781
          } else {
            x = Math.sqrt(xx)
            y = xy / x
            z = xz / x
          }
        } else if (yy > zz) {
          // m22 is the largest diagonal term

          if (yy < epsilon) {
            x = 0.707106781
            y = 0
            z = 0.707106781
          } else {
            y = Math.sqrt(yy)
            x = xy / y
            z = yz / y
          }
        } else {
          // m33 is the largest diagonal term so base result on this

          if (zz < epsilon) {
            x = 0.707106781
            y = 0.707106781
            z = 0
          } else {
            z = Math.sqrt(zz)
            x = xz / z
            y = yz / z
          }
        }

        this.set(x, y, z, angle)

        return this // return 180 deg rotation
      }

      // as we have reached here there are no singularities so we can handle normally

      var s = Math.sqrt(
        (m32 - m23) * (m32 - m23) + (m13 - m31) * (m13 - m31) + (m21 - m12) * (m21 - m12)
      ) // used to normalize

      if (Math.abs(s) < 0.001) s = 1

      // prevent divide by zero, should not happen if matrix is orthogonal and should be
      // caught by singularity test above, but I've left it in just in case

      this.x = (m32 - m23) / s
      this.y = (m13 - m31) / s
      this.z = (m21 - m12) / s
      this.w = Math.acos((m11 + m22 + m33 - 1) / 2)

      return this
    },

    min: function (v) {
      this.x = Math.min(this.x, v.x)
      this.y = Math.min(this.y, v.y)
      this.z = Math.min(this.z, v.z)
      this.w = Math.min(this.w, v.w)

      return this
    },

    max: function (v) {
      this.x = Math.max(this.x, v.x)
      this.y = Math.max(this.y, v.y)
      this.z = Math.max(this.z, v.z)
      this.w = Math.max(this.w, v.w)

      return this
    },

    clamp: function (min, max) {
      // assumes min < max, componentwise

      this.x = Math.max(min.x, Math.min(max.x, this.x))
      this.y = Math.max(min.y, Math.min(max.y, this.y))
      this.z = Math.max(min.z, Math.min(max.z, this.z))
      this.w = Math.max(min.w, Math.min(max.w, this.w))

      return this
    },

    clampScalar: (function () {
      var min, max

      return function clampScalar(minVal, maxVal) {
        if (min === undefined) {
          min = new Vector4()
          max = new Vector4()
        }

        min.set(minVal, minVal, minVal, minVal)
        max.set(maxVal, maxVal, maxVal, maxVal)

        return this.clamp(min, max)
      }
    })(),

    clampLength: function (min, max) {
      var length = this.length()

      return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)))
    },

    floor: function () {
      this.x = Math.floor(this.x)
      this.y = Math.floor(this.y)
      this.z = Math.floor(this.z)
      this.w = Math.floor(this.w)

      return this
    },

    ceil: function () {
      this.x = Math.ceil(this.x)
      this.y = Math.ceil(this.y)
      this.z = Math.ceil(this.z)
      this.w = Math.ceil(this.w)

      return this
    },

    round: function () {
      this.x = Math.round(this.x)
      this.y = Math.round(this.y)
      this.z = Math.round(this.z)
      this.w = Math.round(this.w)

      return this
    },

    roundToZero: function () {
      this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x)
      this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y)
      this.z = this.z < 0 ? Math.ceil(this.z) : Math.floor(this.z)
      this.w = this.w < 0 ? Math.ceil(this.w) : Math.floor(this.w)

      return this
    },

    negate: function () {
      this.x = -this.x
      this.y = -this.y
      this.z = -this.z
      this.w = -this.w

      return this
    },

    dot: function (v) {
      return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w
    },

    lengthSq: function () {
      return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w
    },

    length: function () {
      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w)
    },

    manhattanLength: function () {
      return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z) + Math.abs(this.w)
    },

    normalize: function () {
      return this.divideScalar(this.length() || 1)
    },

    setLength: function (length) {
      return this.normalize().multiplyScalar(length)
    },

    lerp: function (v, alpha) {
      this.x += (v.x - this.x) * alpha
      this.y += (v.y - this.y) * alpha
      this.z += (v.z - this.z) * alpha
      this.w += (v.w - this.w) * alpha

      return this
    },

    lerpVectors: function (v1, v2, alpha) {
      return this.subVectors(v2, v1).multiplyScalar(alpha).add(v1)
    },

    equals: function (v) {
      return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w
    },

    fromArray: function (array, offset) {
      if (offset === undefined) offset = 0

      this.x = array[offset]
      this.y = array[offset + 1]
      this.z = array[offset + 2]
      this.w = array[offset + 3]

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      array[offset] = this.x
      array[offset + 1] = this.y
      array[offset + 2] = this.z
      array[offset + 3] = this.w

      return array
    },

    fromBufferAttribute: function (attribute, index, offset) {
      if (offset !== undefined) {
        console.warn('THREE.Vector4: offset has been removed from .fromBufferAttribute().')
      }

      this.x = attribute.getX(index)
      this.y = attribute.getY(index)
      this.z = attribute.getZ(index)
      this.w = attribute.getW(index)

      return this
    }
  })

  /**
   * @author szimek / https://github.com/szimek/
   * @author alteredq / http://alteredqualia.com/
   * @author Marius Kintel / https://github.com/kintel
   */

  /*
	 In options, we can specify:
	 * Texture parameters for an auto-generated target texture
	 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
	*/
  function WebGLRenderTarget(width, height, options) {
    this.uuid = _Math.generateUUID()

    this.width = width
    this.height = height

    this.scissor = new Vector4(0, 0, width, height)
    this.scissorTest = false

    this.viewport = new Vector4(0, 0, width, height)

    options = options || {}

    if (options.minFilter === undefined) options.minFilter = LinearFilter

    this.texture = new Texture(
      undefined,
      undefined,
      options.wrapS,
      options.wrapT,
      options.magFilter,
      options.minFilter,
      options.format,
      options.type,
      options.anisotropy,
      options.encoding
    )

    this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true
    this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true
    this.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null
  }

  WebGLRenderTarget.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: WebGLRenderTarget,

    isWebGLRenderTarget: true,

    setSize: function (width, height) {
      if (this.width !== width || this.height !== height) {
        this.width = width
        this.height = height

        this.dispose()
      }

      this.viewport.set(0, 0, width, height)
      this.scissor.set(0, 0, width, height)
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (source) {
      this.width = source.width
      this.height = source.height

      this.viewport.copy(source.viewport)

      this.texture = source.texture.clone()

      this.depthBuffer = source.depthBuffer
      this.stencilBuffer = source.stencilBuffer
      this.depthTexture = source.depthTexture

      return this
    },

    dispose: function () {
      this.dispatchEvent({ type: 'dispose' })
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com
   */

  function WebGLRenderTargetCube(width, height, options) {
    WebGLRenderTarget.call(this, width, height, options)

    this.activeCubeFace = 0 // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5
    this.activeMipMapLevel = 0
  }

  WebGLRenderTargetCube.prototype = Object.create(WebGLRenderTarget.prototype)
  WebGLRenderTargetCube.prototype.constructor = WebGLRenderTargetCube

  WebGLRenderTargetCube.prototype.isWebGLRenderTargetCube = true

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function DataTexture(
    data,
    width,
    height,
    format,
    type,
    mapping,
    wrapS,
    wrapT,
    magFilter,
    minFilter,
    anisotropy,
    encoding
  ) {
    Texture.call(
      this,
      null,
      mapping,
      wrapS,
      wrapT,
      magFilter,
      minFilter,
      format,
      type,
      anisotropy,
      encoding
    )

    this.image = { data: data, width: width, height: height }

    this.magFilter = magFilter !== undefined ? magFilter : NearestFilter
    this.minFilter = minFilter !== undefined ? minFilter : NearestFilter

    this.generateMipmaps = false
    this.flipY = false
    this.unpackAlignment = 1
  }

  DataTexture.prototype = Object.create(Texture.prototype)
  DataTexture.prototype.constructor = DataTexture

  DataTexture.prototype.isDataTexture = true

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function CubeTexture(
    images,
    mapping,
    wrapS,
    wrapT,
    magFilter,
    minFilter,
    format,
    type,
    anisotropy,
    encoding
  ) {
    images = images !== undefined ? images : []
    mapping = mapping !== undefined ? mapping : CubeReflectionMapping

    Texture.call(
      this,
      images,
      mapping,
      wrapS,
      wrapT,
      magFilter,
      minFilter,
      format,
      type,
      anisotropy,
      encoding
    )

    this.flipY = false
  }

  CubeTexture.prototype = Object.create(Texture.prototype)
  CubeTexture.prototype.constructor = CubeTexture

  CubeTexture.prototype.isCubeTexture = true

  Object.defineProperty(CubeTexture.prototype, 'images', {
    get: function () {
      return this.image
    },

    set: function (value) {
      this.image = value
    }
  })

  /**
   * @author tschw
   *
   * Uniforms of a program.
   * Those form a tree structure with a special top-level container for the root,
   * which you get by calling 'new WebGLUniforms( gl, program, renderer )'.
   *
   *
   * Properties of inner nodes including the top-level container:
   *
   * .seq - array of nested uniforms
   * .map - nested uniforms by name
   *
   *
   * Methods of all nodes except the top-level container:
   *
   * .setValue( gl, value, [renderer] )
   *
   * 		uploads a uniform value(s)
   *  	the 'renderer' parameter is needed for sampler uniforms
   *
   *
   * Static methods of the top-level container (renderer factorizations):
   *
   * .upload( gl, seq, values, renderer )
   *
   * 		sets uniforms in 'seq' to 'values[id].value'
   *
   * .seqWithValue( seq, values ) : filteredSeq
   *
   * 		filters 'seq' entries with corresponding entry in values
   *
   *
   * Methods of the top-level container (renderer factorizations):
   *
   * .setValue( gl, name, value )
   *
   * 		sets uniform with  name 'name' to 'value'
   *
   * .set( gl, obj, prop )
   *
   * 		sets uniform from object and property with same name than uniform
   *
   * .setOptional( gl, obj, prop )
   *
   * 		like .set for an optional property of the object
   *
   */

  var emptyTexture = new Texture()
  var emptyCubeTexture = new CubeTexture()

  // --- Base for inner nodes (including the root) ---

  function UniformContainer() {
    this.seq = []
    this.map = {}
  }

  // --- Utilities ---

  // Array Caches (provide typed arrays for temporary by size)

  var arrayCacheF32 = []
  var arrayCacheI32 = []

  // Float32Array caches used for uploading Matrix uniforms

  var mat4array = new Float32Array(16)
  var mat3array = new Float32Array(9)

  // Flattening for arrays of vectors and matrices

  function flatten(array, nBlocks, blockSize) {
    var firstElem = array[0]

    if (firstElem <= 0 || firstElem > 0) return array
    // unoptimized: ! isNaN( firstElem )
    // see http://jacksondunstan.com/articles/983

    var n = nBlocks * blockSize,
      r = arrayCacheF32[n]

    if (r === undefined) {
      r = new Float32Array(n)
      arrayCacheF32[n] = r
    }

    if (nBlocks !== 0) {
      firstElem.toArray(r, 0)

      for (var i = 1, offset = 0; i !== nBlocks; ++i) {
        offset += blockSize
        array[i].toArray(r, offset)
      }
    }

    return r
  }

  // Texture unit allocation

  function allocTexUnits(renderer, n) {
    var r = arrayCacheI32[n]

    if (r === undefined) {
      r = new Int32Array(n)
      arrayCacheI32[n] = r
    }

    for (var i = 0; i !== n; ++i) r[i] = renderer.allocTextureUnit()

    return r
  }

  // --- Setters ---

  // Note: Defining these methods externally, because they come in a bunch
  // and this way their names minify.

  // Single scalar

  function setValue1f(gl, v) {
    gl.uniform1f(this.addr, v)
  }

  function setValue1i(gl, v) {
    gl.uniform1i(this.addr, v)
  }

  // Single float vector (from flat array or THREE.VectorN)

  function setValue2fv(gl, v) {
    if (v.x === undefined) {
      gl.uniform2fv(this.addr, v)
    } else {
      gl.uniform2f(this.addr, v.x, v.y)
    }
  }

  function setValue3fv(gl, v) {
    if (v.x !== undefined) {
      gl.uniform3f(this.addr, v.x, v.y, v.z)
    } else if (v.r !== undefined) {
      gl.uniform3f(this.addr, v.r, v.g, v.b)
    } else {
      gl.uniform3fv(this.addr, v)
    }
  }

  function setValue4fv(gl, v) {
    if (v.x === undefined) {
      gl.uniform4fv(this.addr, v)
    } else {
      gl.uniform4f(this.addr, v.x, v.y, v.z, v.w)
    }
  }

  // Single matrix (from flat array or MatrixN)

  function setValue2fm(gl, v) {
    gl.uniformMatrix2fv(this.addr, false, v.elements || v)
  }

  function setValue3fm(gl, v) {
    if (v.elements === undefined) {
      gl.uniformMatrix3fv(this.addr, false, v)
    } else {
      mat3array.set(v.elements)
      gl.uniformMatrix3fv(this.addr, false, mat3array)
    }
  }

  function setValue4fm(gl, v) {
    if (v.elements === undefined) {
      gl.uniformMatrix4fv(this.addr, false, v)
    } else {
      mat4array.set(v.elements)
      gl.uniformMatrix4fv(this.addr, false, mat4array)
    }
  }

  // Single texture (2D / Cube)

  function setValueT1(gl, v, renderer) {
    var unit = renderer.allocTextureUnit()
    gl.uniform1i(this.addr, unit)
    renderer.setTexture2D(v || emptyTexture, unit)
  }

  function setValueT6(gl, v, renderer) {
    var unit = renderer.allocTextureUnit()
    gl.uniform1i(this.addr, unit)
    renderer.setTextureCube(v || emptyCubeTexture, unit)
  }

  // Integer / Boolean vectors or arrays thereof (always flat arrays)

  function setValue2iv(gl, v) {
    gl.uniform2iv(this.addr, v)
  }

  function setValue3iv(gl, v) {
    gl.uniform3iv(this.addr, v)
  }

  function setValue4iv(gl, v) {
    gl.uniform4iv(this.addr, v)
  }

  // Helper to pick the right setter for the singular case

  function getSingularSetter(type) {
    switch (type) {
      case 0x1406:
        return setValue1f // FLOAT
      case 0x8b50:
        return setValue2fv // _VEC2
      case 0x8b51:
        return setValue3fv // _VEC3
      case 0x8b52:
        return setValue4fv // _VEC4

      case 0x8b5a:
        return setValue2fm // _MAT2
      case 0x8b5b:
        return setValue3fm // _MAT3
      case 0x8b5c:
        return setValue4fm // _MAT4

      case 0x8b5e:
      case 0x8d66:
        return setValueT1 // SAMPLER_2D, SAMPLER_EXTERNAL_OES
      case 0x8b60:
        return setValueT6 // SAMPLER_CUBE

      case 0x1404:
      case 0x8b56:
        return setValue1i // INT, BOOL
      case 0x8b53:
      case 0x8b57:
        return setValue2iv // _VEC2
      case 0x8b54:
      case 0x8b58:
        return setValue3iv // _VEC3
      case 0x8b55:
      case 0x8b59:
        return setValue4iv // _VEC4
    }
  }

  // Array of scalars

  function setValue1fv(gl, v) {
    gl.uniform1fv(this.addr, v)
  }
  function setValue1iv(gl, v) {
    gl.uniform1iv(this.addr, v)
  }

  // Array of vectors (flat or from THREE classes)

  function setValueV2a(gl, v) {
    gl.uniform2fv(this.addr, flatten(v, this.size, 2))
  }

  function setValueV3a(gl, v) {
    gl.uniform3fv(this.addr, flatten(v, this.size, 3))
  }

  function setValueV4a(gl, v) {
    gl.uniform4fv(this.addr, flatten(v, this.size, 4))
  }

  // Array of matrices (flat or from THREE clases)

  function setValueM2a(gl, v) {
    gl.uniformMatrix2fv(this.addr, false, flatten(v, this.size, 4))
  }

  function setValueM3a(gl, v) {
    gl.uniformMatrix3fv(this.addr, false, flatten(v, this.size, 9))
  }

  function setValueM4a(gl, v) {
    gl.uniformMatrix4fv(this.addr, false, flatten(v, this.size, 16))
  }

  // Array of textures (2D / Cube)

  function setValueT1a(gl, v, renderer) {
    var n = v.length,
      units = allocTexUnits(renderer, n)

    gl.uniform1iv(this.addr, units)

    for (var i = 0; i !== n; ++i) {
      renderer.setTexture2D(v[i] || emptyTexture, units[i])
    }
  }

  function setValueT6a(gl, v, renderer) {
    var n = v.length,
      units = allocTexUnits(renderer, n)

    gl.uniform1iv(this.addr, units)

    for (var i = 0; i !== n; ++i) {
      renderer.setTextureCube(v[i] || emptyCubeTexture, units[i])
    }
  }

  // Helper to pick the right setter for a pure (bottom-level) array

  function getPureArraySetter(type) {
    switch (type) {
      case 0x1406:
        return setValue1fv // FLOAT
      case 0x8b50:
        return setValueV2a // _VEC2
      case 0x8b51:
        return setValueV3a // _VEC3
      case 0x8b52:
        return setValueV4a // _VEC4

      case 0x8b5a:
        return setValueM2a // _MAT2
      case 0x8b5b:
        return setValueM3a // _MAT3
      case 0x8b5c:
        return setValueM4a // _MAT4

      case 0x8b5e:
        return setValueT1a // SAMPLER_2D
      case 0x8b60:
        return setValueT6a // SAMPLER_CUBE

      case 0x1404:
      case 0x8b56:
        return setValue1iv // INT, BOOL
      case 0x8b53:
      case 0x8b57:
        return setValue2iv // _VEC2
      case 0x8b54:
      case 0x8b58:
        return setValue3iv // _VEC3
      case 0x8b55:
      case 0x8b59:
        return setValue4iv // _VEC4
    }
  }

  // --- Uniform Classes ---

  function SingleUniform(id, activeInfo, addr) {
    this.id = id
    this.addr = addr
    this.setValue = getSingularSetter(activeInfo.type)

    // this.path = activeInfo.name; // DEBUG
  }

  function PureArrayUniform(id, activeInfo, addr) {
    this.id = id
    this.addr = addr
    this.size = activeInfo.size
    this.setValue = getPureArraySetter(activeInfo.type)

    // this.path = activeInfo.name; // DEBUG
  }

  function StructuredUniform(id) {
    this.id = id

    UniformContainer.call(this) // mix-in
  }

  StructuredUniform.prototype.setValue = function (gl, value) {
    // Note: Don't need an extra 'renderer' parameter, since samplers
    // are not allowed in structured uniforms.

    var seq = this.seq

    for (var i = 0, n = seq.length; i !== n; ++i) {
      var u = seq[i]
      u.setValue(gl, value[u.id])
    }
  }

  // --- Top-level ---

  // Parser - builds up the property tree from the path strings

  var RePathPart = /([\w\d_]+)(\])?(\[|\.)?/g

  // extracts
  // 	- the identifier (member name or array index)
  //  - followed by an optional right bracket (found when array index)
  //  - followed by an optional left bracket or dot (type of subscript)
  //
  // Note: These portions can be read in a non-overlapping fashion and
  // allow straightforward parsing of the hierarchy that WebGL encodes
  // in the uniform names.

  function addUniform(container, uniformObject) {
    container.seq.push(uniformObject)
    container.map[uniformObject.id] = uniformObject
  }

  function parseUniform(activeInfo, addr, container) {
    var path = activeInfo.name,
      pathLength = path.length

    // reset RegExp object, because of the early exit of a previous run
    RePathPart.lastIndex = 0

    for (;;) {
      var match = RePathPart.exec(path),
        matchEnd = RePathPart.lastIndex,
        id = match[1],
        idIsIndex = match[2] === ']',
        subscript = match[3]

      if (idIsIndex) id = id | 0 // convert to integer

      if (subscript === undefined || (subscript === '[' && matchEnd + 2 === pathLength)) {
        // bare name or "pure" bottom-level array "[0]" suffix

        addUniform(
          container,
          subscript === undefined
            ? new SingleUniform(id, activeInfo, addr)
            : new PureArrayUniform(id, activeInfo, addr)
        )

        break
      } else {
        // step into inner node / create it in case it doesn't exist

        var map = container.map,
          next = map[id]

        if (next === undefined) {
          next = new StructuredUniform(id)
          addUniform(container, next)
        }

        container = next
      }
    }
  }

  // Root Container

  function WebGLUniforms(gl, program, renderer) {
    UniformContainer.call(this)

    this.renderer = renderer

    var n = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS)

    for (var i = 0; i < n; ++i) {
      var info = gl.getActiveUniform(program, i),
        path = info.name,
        addr = gl.getUniformLocation(program, path)

      parseUniform(info, addr, this)
    }
  }

  WebGLUniforms.prototype.setValue = function (gl, name, value) {
    var u = this.map[name]

    if (u !== undefined) u.setValue(gl, value, this.renderer)
  }

  WebGLUniforms.prototype.setOptional = function (gl, object, name) {
    var v = object[name]

    if (v !== undefined) this.setValue(gl, name, v)
  }

  // Static interface

  WebGLUniforms.upload = function (gl, seq, values, renderer) {
    for (var i = 0, n = seq.length; i !== n; ++i) {
      var u = seq[i],
        v = values[u.id]

      if (v.needsUpdate !== false) {
        // note: always updating when .needsUpdate is undefined
        u.setValue(gl, v.value, renderer)
      }
    }
  }

  WebGLUniforms.seqWithValue = function (seq, values) {
    var r = []

    for (var i = 0, n = seq.length; i !== n; ++i) {
      var u = seq[i]
      if (u.id in values) r.push(u)
    }

    return r
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  var ColorKeywords = {
    aliceblue: 0xf0f8ff,
    antiquewhite: 0xfaebd7,
    aqua: 0x00ffff,
    aquamarine: 0x7fffd4,
    azure: 0xf0ffff,
    beige: 0xf5f5dc,
    bisque: 0xffe4c4,
    black: 0x000000,
    blanchedalmond: 0xffebcd,
    blue: 0x0000ff,
    blueviolet: 0x8a2be2,
    brown: 0xa52a2a,
    burlywood: 0xdeb887,
    cadetblue: 0x5f9ea0,
    chartreuse: 0x7fff00,
    chocolate: 0xd2691e,
    coral: 0xff7f50,
    cornflowerblue: 0x6495ed,
    cornsilk: 0xfff8dc,
    crimson: 0xdc143c,
    cyan: 0x00ffff,
    darkblue: 0x00008b,
    darkcyan: 0x008b8b,
    darkgoldenrod: 0xb8860b,
    darkgray: 0xa9a9a9,
    darkgreen: 0x006400,
    darkgrey: 0xa9a9a9,
    darkkhaki: 0xbdb76b,
    darkmagenta: 0x8b008b,
    darkolivegreen: 0x556b2f,
    darkorange: 0xff8c00,
    darkorchid: 0x9932cc,
    darkred: 0x8b0000,
    darksalmon: 0xe9967a,
    darkseagreen: 0x8fbc8f,
    darkslateblue: 0x483d8b,
    darkslategray: 0x2f4f4f,
    darkslategrey: 0x2f4f4f,
    darkturquoise: 0x00ced1,
    darkviolet: 0x9400d3,
    deeppink: 0xff1493,
    deepskyblue: 0x00bfff,
    dimgray: 0x696969,
    dimgrey: 0x696969,
    dodgerblue: 0x1e90ff,
    firebrick: 0xb22222,
    floralwhite: 0xfffaf0,
    forestgreen: 0x228b22,
    fuchsia: 0xff00ff,
    gainsboro: 0xdcdcdc,
    ghostwhite: 0xf8f8ff,
    gold: 0xffd700,
    goldenrod: 0xdaa520,
    gray: 0x808080,
    green: 0x008000,
    greenyellow: 0xadff2f,
    grey: 0x808080,
    honeydew: 0xf0fff0,
    hotpink: 0xff69b4,
    indianred: 0xcd5c5c,
    indigo: 0x4b0082,
    ivory: 0xfffff0,
    khaki: 0xf0e68c,
    lavender: 0xe6e6fa,
    lavenderblush: 0xfff0f5,
    lawngreen: 0x7cfc00,
    lemonchiffon: 0xfffacd,
    lightblue: 0xadd8e6,
    lightcoral: 0xf08080,
    lightcyan: 0xe0ffff,
    lightgoldenrodyellow: 0xfafad2,
    lightgray: 0xd3d3d3,
    lightgreen: 0x90ee90,
    lightgrey: 0xd3d3d3,
    lightpink: 0xffb6c1,
    lightsalmon: 0xffa07a,
    lightseagreen: 0x20b2aa,
    lightskyblue: 0x87cefa,
    lightslategray: 0x778899,
    lightslategrey: 0x778899,
    lightsteelblue: 0xb0c4de,
    lightyellow: 0xffffe0,
    lime: 0x00ff00,
    limegreen: 0x32cd32,
    linen: 0xfaf0e6,
    magenta: 0xff00ff,
    maroon: 0x800000,
    mediumaquamarine: 0x66cdaa,
    mediumblue: 0x0000cd,
    mediumorchid: 0xba55d3,
    mediumpurple: 0x9370db,
    mediumseagreen: 0x3cb371,
    mediumslateblue: 0x7b68ee,
    mediumspringgreen: 0x00fa9a,
    mediumturquoise: 0x48d1cc,
    mediumvioletred: 0xc71585,
    midnightblue: 0x191970,
    mintcream: 0xf5fffa,
    mistyrose: 0xffe4e1,
    moccasin: 0xffe4b5,
    navajowhite: 0xffdead,
    navy: 0x000080,
    oldlace: 0xfdf5e6,
    olive: 0x808000,
    olivedrab: 0x6b8e23,
    orange: 0xffa500,
    orangered: 0xff4500,
    orchid: 0xda70d6,
    palegoldenrod: 0xeee8aa,
    palegreen: 0x98fb98,
    paleturquoise: 0xafeeee,
    palevioletred: 0xdb7093,
    papayawhip: 0xffefd5,
    peachpuff: 0xffdab9,
    peru: 0xcd853f,
    pink: 0xffc0cb,
    plum: 0xdda0dd,
    powderblue: 0xb0e0e6,
    purple: 0x800080,
    rebeccapurple: 0x663399,
    red: 0xff0000,
    rosybrown: 0xbc8f8f,
    royalblue: 0x4169e1,
    saddlebrown: 0x8b4513,
    salmon: 0xfa8072,
    sandybrown: 0xf4a460,
    seagreen: 0x2e8b57,
    seashell: 0xfff5ee,
    sienna: 0xa0522d,
    silver: 0xc0c0c0,
    skyblue: 0x87ceeb,
    slateblue: 0x6a5acd,
    slategray: 0x708090,
    slategrey: 0x708090,
    snow: 0xfffafa,
    springgreen: 0x00ff7f,
    steelblue: 0x4682b4,
    tan: 0xd2b48c,
    teal: 0x008080,
    thistle: 0xd8bfd8,
    tomato: 0xff6347,
    turquoise: 0x40e0d0,
    violet: 0xee82ee,
    wheat: 0xf5deb3,
    white: 0xffffff,
    whitesmoke: 0xf5f5f5,
    yellow: 0xffff00,
    yellowgreen: 0x9acd32
  }

  function Color(r, g, b) {
    if (g === undefined && b === undefined) {
      // r is THREE.Color, hex or string
      return this.set(r)
    }

    return this.setRGB(r, g, b)
  }

  Object.assign(Color.prototype, {
    isColor: true,

    r: 1,
    g: 1,
    b: 1,

    set: function (value) {
      if (value && value.isColor) {
        this.copy(value)
      } else if (typeof value === 'number') {
        this.setHex(value)
      } else if (typeof value === 'string') {
        this.setStyle(value)
      }

      return this
    },

    setScalar: function (scalar) {
      this.r = scalar
      this.g = scalar
      this.b = scalar

      return this
    },

    setHex: function (hex) {
      hex = Math.floor(hex)

      this.r = ((hex >> 16) & 255) / 255
      this.g = ((hex >> 8) & 255) / 255
      this.b = (hex & 255) / 255

      return this
    },

    setRGB: function (r, g, b) {
      this.r = r
      this.g = g
      this.b = b

      return this
    },

    setHSL: (function () {
      function hue2rgb(p, q, t) {
        if (t < 0) t += 1
        if (t > 1) t -= 1
        if (t < 1 / 6) return p + (q - p) * 6 * t
        if (t < 1 / 2) return q
        if (t < 2 / 3) return p + (q - p) * 6 * (2 / 3 - t)
        return p
      }

      return function setHSL(h, s, l) {
        // h,s,l ranges are in 0.0 - 1.0
        h = _Math.euclideanModulo(h, 1)
        s = _Math.clamp(s, 0, 1)
        l = _Math.clamp(l, 0, 1)

        if (s === 0) {
          this.r = this.g = this.b = l
        } else {
          var p = l <= 0.5 ? l * (1 + s) : l + s - l * s
          var q = 2 * l - p

          this.r = hue2rgb(q, p, h + 1 / 3)
          this.g = hue2rgb(q, p, h)
          this.b = hue2rgb(q, p, h - 1 / 3)
        }

        return this
      }
    })(),

    setStyle: function (style) {
      function handleAlpha(string) {
        if (string === undefined) return

        if (parseFloat(string) < 1) {
          console.warn('THREE.Color: Alpha component of ' + style + ' will be ignored.')
        }
      }

      var m

      if ((m = /^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec(style))) {
        // rgb / hsl

        var color
        var name = m[1]
        var components = m[2]

        switch (name) {
          case 'rgb':
          case 'rgba':
            if (
              (color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(
                components
              ))
            ) {
              // rgb(255,0,0) rgba(255,0,0,0.5)
              this.r = Math.min(255, parseInt(color[1], 10)) / 255
              this.g = Math.min(255, parseInt(color[2], 10)) / 255
              this.b = Math.min(255, parseInt(color[3], 10)) / 255

              handleAlpha(color[5])

              return this
            }

            if (
              (color = /^(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(
                components
              ))
            ) {
              // rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
              this.r = Math.min(100, parseInt(color[1], 10)) / 100
              this.g = Math.min(100, parseInt(color[2], 10)) / 100
              this.b = Math.min(100, parseInt(color[3], 10)) / 100

              handleAlpha(color[5])

              return this
            }

            break

          case 'hsl':
          case 'hsla':
            if (
              (color =
                /^([0-9]*\.?[0-9]+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(
                  components
                ))
            ) {
              // hsl(120,50%,50%) hsla(120,50%,50%,0.5)
              var h = parseFloat(color[1]) / 360
              var s = parseInt(color[2], 10) / 100
              var l = parseInt(color[3], 10) / 100

              handleAlpha(color[5])

              return this.setHSL(h, s, l)
            }

            break
        }
      } else if ((m = /^\#([A-Fa-f0-9]+)$/.exec(style))) {
        // hex color

        var hex = m[1]
        var size = hex.length

        if (size === 3) {
          // #ff0
          this.r = parseInt(hex.charAt(0) + hex.charAt(0), 16) / 255
          this.g = parseInt(hex.charAt(1) + hex.charAt(1), 16) / 255
          this.b = parseInt(hex.charAt(2) + hex.charAt(2), 16) / 255

          return this
        } else if (size === 6) {
          // #ff0000
          this.r = parseInt(hex.charAt(0) + hex.charAt(1), 16) / 255
          this.g = parseInt(hex.charAt(2) + hex.charAt(3), 16) / 255
          this.b = parseInt(hex.charAt(4) + hex.charAt(5), 16) / 255

          return this
        }
      }

      if (style && style.length > 0) {
        // color keywords
        var hex = ColorKeywords[style]

        if (hex !== undefined) {
          // red
          this.setHex(hex)
        } else {
          // unknown color
          console.warn('THREE.Color: Unknown color ' + style)
        }
      }

      return this
    },

    clone: function () {
      return new this.constructor(this.r, this.g, this.b)
    },

    copy: function (color) {
      this.r = color.r
      this.g = color.g
      this.b = color.b

      return this
    },

    copyGammaToLinear: function (color, gammaFactor) {
      if (gammaFactor === undefined) gammaFactor = 2.0

      this.r = Math.pow(color.r, gammaFactor)
      this.g = Math.pow(color.g, gammaFactor)
      this.b = Math.pow(color.b, gammaFactor)

      return this
    },

    copyLinearToGamma: function (color, gammaFactor) {
      if (gammaFactor === undefined) gammaFactor = 2.0

      var safeInverse = gammaFactor > 0 ? 1.0 / gammaFactor : 1.0

      this.r = Math.pow(color.r, safeInverse)
      this.g = Math.pow(color.g, safeInverse)
      this.b = Math.pow(color.b, safeInverse)

      return this
    },

    convertGammaToLinear: function () {
      var r = this.r,
        g = this.g,
        b = this.b

      this.r = r * r
      this.g = g * g
      this.b = b * b

      return this
    },

    convertLinearToGamma: function () {
      this.r = Math.sqrt(this.r)
      this.g = Math.sqrt(this.g)
      this.b = Math.sqrt(this.b)

      return this
    },

    getHex: function () {
      return ((this.r * 255) << 16) ^ ((this.g * 255) << 8) ^ ((this.b * 255) << 0)
    },

    getHexString: function () {
      return ('000000' + this.getHex().toString(16)).slice(-6)
    },

    getHSL: function (optionalTarget) {
      // h,s,l ranges are in 0.0 - 1.0

      var hsl = optionalTarget || { h: 0, s: 0, l: 0 }

      var r = this.r,
        g = this.g,
        b = this.b

      var max = Math.max(r, g, b)
      var min = Math.min(r, g, b)

      var hue, saturation
      var lightness = (min + max) / 2.0

      if (min === max) {
        hue = 0
        saturation = 0
      } else {
        var delta = max - min

        saturation = lightness <= 0.5 ? delta / (max + min) : delta / (2 - max - min)

        switch (max) {
          case r:
            hue = (g - b) / delta + (g < b ? 6 : 0)
            break
          case g:
            hue = (b - r) / delta + 2
            break
          case b:
            hue = (r - g) / delta + 4
            break
        }

        hue /= 6
      }

      hsl.h = hue
      hsl.s = saturation
      hsl.l = lightness

      return hsl
    },

    getStyle: function () {
      return (
        'rgb(' +
        ((this.r * 255) | 0) +
        ',' +
        ((this.g * 255) | 0) +
        ',' +
        ((this.b * 255) | 0) +
        ')'
      )
    },

    offsetHSL: function (h, s, l) {
      var hsl = this.getHSL()

      hsl.h += h
      hsl.s += s
      hsl.l += l

      this.setHSL(hsl.h, hsl.s, hsl.l)

      return this
    },

    add: function (color) {
      this.r += color.r
      this.g += color.g
      this.b += color.b

      return this
    },

    addColors: function (color1, color2) {
      this.r = color1.r + color2.r
      this.g = color1.g + color2.g
      this.b = color1.b + color2.b

      return this
    },

    addScalar: function (s) {
      this.r += s
      this.g += s
      this.b += s

      return this
    },

    sub: function (color) {
      this.r = Math.max(0, this.r - color.r)
      this.g = Math.max(0, this.g - color.g)
      this.b = Math.max(0, this.b - color.b)

      return this
    },

    multiply: function (color) {
      this.r *= color.r
      this.g *= color.g
      this.b *= color.b

      return this
    },

    multiplyScalar: function (s) {
      this.r *= s
      this.g *= s
      this.b *= s

      return this
    },

    lerp: function (color, alpha) {
      this.r += (color.r - this.r) * alpha
      this.g += (color.g - this.g) * alpha
      this.b += (color.b - this.b) * alpha

      return this
    },

    equals: function (c) {
      return c.r === this.r && c.g === this.g && c.b === this.b
    },

    fromArray: function (array, offset) {
      if (offset === undefined) offset = 0

      this.r = array[offset]
      this.g = array[offset + 1]
      this.b = array[offset + 2]

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      array[offset] = this.r
      array[offset + 1] = this.g
      array[offset + 2] = this.b

      return array
    },

    toJSON: function () {
      return this.getHex()
    }
  })

  /**
   * Uniforms library for shared webgl shaders
   */

  var UniformsLib = {
    common: {
      diffuse: { value: new Color(0xeeeeee) },
      opacity: { value: 1.0 },

      map: { value: null },
      uvTransform: { value: new Matrix3() },

      alphaMap: { value: null }
    },

    specularmap: {
      specularMap: { value: null }
    },

    envmap: {
      envMap: { value: null },
      flipEnvMap: { value: -1 },
      reflectivity: { value: 1.0 },
      refractionRatio: { value: 0.98 }
    },

    aomap: {
      aoMap: { value: null },
      aoMapIntensity: { value: 1 }
    },

    lightmap: {
      lightMap: { value: null },
      lightMapIntensity: { value: 1 }
    },

    emissivemap: {
      emissiveMap: { value: null }
    },

    bumpmap: {
      bumpMap: { value: null },
      bumpScale: { value: 1 }
    },

    normalmap: {
      normalMap: { value: null },
      normalScale: { value: new Vector2(1, 1) }
    },

    displacementmap: {
      displacementMap: { value: null },
      displacementScale: { value: 1 },
      displacementBias: { value: 0 }
    },

    roughnessmap: {
      roughnessMap: { value: null }
    },

    metalnessmap: {
      metalnessMap: { value: null }
    },

    gradientmap: {
      gradientMap: { value: null }
    },

    fog: {
      fogDensity: { value: 0.00025 },
      fogNear: { value: 1 },
      fogFar: { value: 2000 },
      fogColor: { value: new Color(0xffffff) }
    },

    lights: {
      ambientLightColor: { value: [] },

      directionalLights: {
        value: [],
        properties: {
          direction: {},
          color: {},

          shadow: {},
          shadowBias: {},
          shadowRadius: {},
          shadowMapSize: {}
        }
      },

      directionalShadowMap: { value: [] },
      directionalShadowMatrix: { value: [] },

      spotLights: {
        value: [],
        properties: {
          color: {},
          position: {},
          direction: {},
          distance: {},
          coneCos: {},
          penumbraCos: {},
          decay: {},

          shadow: {},
          shadowBias: {},
          shadowRadius: {},
          shadowMapSize: {}
        }
      },

      spotShadowMap: { value: [] },
      spotShadowMatrix: { value: [] },

      pointLights: {
        value: [],
        properties: {
          color: {},
          position: {},
          decay: {},
          distance: {},

          shadow: {},
          shadowBias: {},
          shadowRadius: {},
          shadowMapSize: {},
          shadowCameraNear: {},
          shadowCameraFar: {}
        }
      },

      pointShadowMap: { value: [] },
      pointShadowMatrix: { value: [] },

      hemisphereLights: {
        value: [],
        properties: {
          direction: {},
          skyColor: {},
          groundColor: {}
        }
      },

      // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src
      rectAreaLights: {
        value: [],
        properties: {
          color: {},
          position: {},
          width: {},
          height: {}
        }
      }
    },

    points: {
      diffuse: { value: new Color(0xeeeeee) },
      opacity: { value: 1.0 },
      size: { value: 1.0 },
      scale: { value: 1.0 },
      map: { value: null },
      uvTransform: { value: new Matrix3() }
    }
  }

  /**
   * Uniform Utilities
   */

  var UniformsUtils = {
    merge: function (uniforms) {
      var merged = {}

      for (var u = 0; u < uniforms.length; u++) {
        var tmp = this.clone(uniforms[u])

        for (var p in tmp) {
          merged[p] = tmp[p]
        }
      }

      return merged
    },

    clone: function (uniforms_src) {
      var uniforms_dst = {}

      for (var u in uniforms_src) {
        uniforms_dst[u] = {}

        for (var p in uniforms_src[u]) {
          var parameter_src = uniforms_src[u][p]

          if (
            parameter_src &&
            (parameter_src.isColor ||
              parameter_src.isMatrix3 ||
              parameter_src.isMatrix4 ||
              parameter_src.isVector2 ||
              parameter_src.isVector3 ||
              parameter_src.isVector4 ||
              parameter_src.isTexture)
          ) {
            uniforms_dst[u][p] = parameter_src.clone()
          } else if (Array.isArray(parameter_src)) {
            uniforms_dst[u][p] = parameter_src.slice()
          } else {
            uniforms_dst[u][p] = parameter_src
          }
        }
      }

      return uniforms_dst
    }
  }

  var alphamap_fragment =
    '#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif\n'

  var alphamap_pars_fragment = '#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif\n'

  var alphatest_fragment =
    '#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif\n'

  var aomap_fragment =
    '#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n\t#endif\n#endif\n'

  var aomap_pars_fragment =
    '#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif'

  var begin_vertex = '\nvec3 transformed = vec3( position );\n'

  var beginnormal_vertex = '\nvec3 objectNormal = vec3( normal );\n'

  var bsdfs =
    'float punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\tif( decayExponent > 0.0 ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tfloat maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\treturn distanceFalloff * maxDistanceCutoffFactor;\n#else\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n#endif\n\t}\n\treturn 1.0;\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE  = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS  = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nvec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;\n\treturn specularColor * AB.x + AB.y;\n}\nfloat G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n'

  var bumpmap_pars_fragment =
    '#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 );\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif\n'

  var clipping_planes_fragment =
    '#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vViewPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\tif ( clipped ) discard;\n\t#endif\n#endif\n'

  var clipping_planes_pars_fragment =
    '#if NUM_CLIPPING_PLANES > 0\n\t#if ! defined( PHYSICAL ) && ! defined( PHONG )\n\t\tvarying vec3 vViewPosition;\n\t#endif\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif\n'

  var clipping_planes_pars_vertex =
    '#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n\tvarying vec3 vViewPosition;\n#endif\n'

  var clipping_planes_vertex =
    '#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n'

  var color_fragment = '#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif'

  var color_pars_fragment = '#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif\n'

  var color_pars_vertex = '#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif'

  var color_vertex = '#ifdef USE_COLOR\n\tvColor.xyz = color.xyz;\n#endif'

  var common =
    '#define PI 3.14159265359\n#define PI2 6.28318530718\n#define PI_HALF 1.5707963267949\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\n#define LOG2 1.442695\n#define EPSILON 1e-6\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#define whiteCompliment(a) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract(sin(sn) * c);\n}\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance = dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}\n'

  var cube_uv_reflection_fragment =
    '#ifdef ENVMAP_TYPE_CUBE_UV\n#define cubeUV_textureSize (1024.0)\nint getFaceFromDirection(vec3 direction) {\n\tvec3 absDirection = abs(direction);\n\tint face = -1;\n\tif( absDirection.x > absDirection.z ) {\n\t\tif(absDirection.x > absDirection.y )\n\t\t\tface = direction.x > 0.0 ? 0 : 3;\n\t\telse\n\t\t\tface = direction.y > 0.0 ? 1 : 4;\n\t}\n\telse {\n\t\tif(absDirection.z > absDirection.y )\n\t\t\tface = direction.z > 0.0 ? 2 : 5;\n\t\telse\n\t\t\tface = direction.y > 0.0 ? 1 : 4;\n\t}\n\treturn face;\n}\n#define cubeUV_maxLods1  (log2(cubeUV_textureSize*0.25) - 1.0)\n#define cubeUV_rangeClamp (exp2((6.0 - 1.0) * 2.0))\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\n\tfloat scale = exp2(cubeUV_maxLods1 - roughnessLevel);\n\tfloat dxRoughness = dFdx(roughness);\n\tfloat dyRoughness = dFdy(roughness);\n\tvec3 dx = dFdx( vec * scale * dxRoughness );\n\tvec3 dy = dFdy( vec * scale * dyRoughness );\n\tfloat d = max( dot( dx, dx ), dot( dy, dy ) );\n\td = clamp(d, 1.0, cubeUV_rangeClamp);\n\tfloat mipLevel = 0.5 * log2(d);\n\treturn vec2(floor(mipLevel), fract(mipLevel));\n}\n#define cubeUV_maxLods2 (log2(cubeUV_textureSize*0.25) - 2.0)\n#define cubeUV_rcpTextureSize (1.0 / cubeUV_textureSize)\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\n\tmipLevel = roughnessLevel > cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\n\tfloat a = 16.0 * cubeUV_rcpTextureSize;\n\tvec2 exp2_packed = exp2( vec2( roughnessLevel, mipLevel ) );\n\tvec2 rcp_exp2_packed = vec2( 1.0 ) / exp2_packed;\n\tfloat powScale = exp2_packed.x * exp2_packed.y;\n\tfloat scale = rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\n\tfloat mipOffset = 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\n\tbool bRes = mipLevel == 0.0;\n\tscale =  bRes && (scale < a) ? a : scale;\n\tvec3 r;\n\tvec2 offset;\n\tint face = getFaceFromDirection(direction);\n\tfloat rcpPowScale = 1.0 / powScale;\n\tif( face == 0) {\n\t\tr = vec3(direction.x, -direction.z, direction.y);\n\t\toffset = vec2(0.0+mipOffset,0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 1) {\n\t\tr = vec3(direction.y, direction.x, direction.z);\n\t\toffset = vec2(scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 2) {\n\t\tr = vec3(direction.z, direction.x, direction.y);\n\t\toffset = vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 3) {\n\t\tr = vec3(direction.x, direction.z, direction.y);\n\t\toffset = vec2(0.0+mipOffset,0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse if( face == 4) {\n\t\tr = vec3(direction.y, direction.x, -direction.z);\n\t\toffset = vec2(scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse {\n\t\tr = vec3(direction.z, -direction.x, direction.y);\n\t\toffset = vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\tr = normalize(r);\n\tfloat texelOffset = 0.5 * cubeUV_rcpTextureSize;\n\tvec2 s = ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\n\tvec2 base = offset + vec2( texelOffset );\n\treturn base + s * ( scale - 2.0 * texelOffset );\n}\n#define cubeUV_maxLods3 (log2(cubeUV_textureSize*0.25) - 3.0)\nvec4 textureCubeUV(vec3 reflectedDirection, float roughness ) {\n\tfloat roughnessVal = roughness* cubeUV_maxLods3;\n\tfloat r1 = floor(roughnessVal);\n\tfloat r2 = r1 + 1.0;\n\tfloat t = fract(roughnessVal);\n\tvec2 mipInfo = MipLevelInfo(reflectedDirection, r1, roughness);\n\tfloat s = mipInfo.y;\n\tfloat level0 = mipInfo.x;\n\tfloat level1 = level0 + 1.0;\n\tlevel1 = level1 > 5.0 ? 5.0 : level1;\n\tlevel0 += min( floor( s + 0.5 ), 5.0 );\n\tvec2 uv_10 = getCubeUV(reflectedDirection, r1, level0);\n\tvec4 color10 = envMapTexelToLinear(texture2D(envMap, uv_10));\n\tvec2 uv_20 = getCubeUV(reflectedDirection, r2, level0);\n\tvec4 color20 = envMapTexelToLinear(texture2D(envMap, uv_20));\n\tvec4 result = mix(color10, color20, t);\n\treturn vec4(result.rgb, 1.0);\n}\n#endif\n'

  var defaultnormal_vertex =
    'vec3 transformedNormal = normalMatrix * objectNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n'

  var displacementmap_pars_vertex =
    '#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif\n'

  var displacementmap_vertex =
    '#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif\n'

  var emissivemap_fragment =
    '#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif\n'

  var emissivemap_pars_fragment =
    '#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif\n'

  var encodings_fragment = '  gl_FragColor = linearToOutputTexel( gl_FragColor );\n'

  var encodings_pars_fragment =
    '\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent = max( max( value.r, value.g ), value.b );\n\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.xyz * value.w * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\n\tfloat M      = clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM            = ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\n\tfloat D      = max( maxRange / maxRGB, 1.0 );\n\tD            = min( floor( D ) / 255.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value )  {\n\tvec3 Xp_Y_XYZp = value.rgb * cLogLuvM;\n\tXp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));\n\tvec4 vResult;\n\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w = fract(Le);\n\tvResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le = value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);\n\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;\n\treturn vec4( max(vRGB, 0.0), 1.0 );\n}\n'

  var envmap_fragment =
    '#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\tvec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\tvec2 sampleUV;\n\t\treflectVec = normalize( reflectVec );\n\t\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\tvec4 envColor = texture2D( envMap, sampleUV );\n\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\treflectVec = normalize( reflectVec );\n\t\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );\n\t\tvec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\tenvColor = envMapTexelToLinear( envColor );\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif\n'

  var envmap_pars_fragment =
    '#if defined( USE_ENVMAP ) || defined( PHYSICAL )\n\tuniform float reflectivity;\n\tuniform float envMapIntensity;\n#endif\n#ifdef USE_ENVMAP\n\t#if ! defined( PHYSICAL ) && ( defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) )\n\t\tvarying vec3 vWorldPosition;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\tuniform float flipEnvMap;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( PHYSICAL )\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif\n'

  var envmap_pars_vertex =
    '#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif\n'

  var envmap_vertex =
    '#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif\n'

  var fog_vertex = '\n#ifdef USE_FOG\nfogDepth = -mvPosition.z;\n#endif'

  var fog_pars_vertex = '#ifdef USE_FOG\n  varying float fogDepth;\n#endif\n'

  var fog_fragment =
    '#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 ) );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif\n'

  var fog_pars_fragment =
    '#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif\n'

  var gradientmap_pars_fragment =
    '#ifdef TOON\n\tuniform sampler2D gradientMap;\n\tvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\t\tfloat dotNL = dot( normal, lightDirection );\n\t\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t\t#ifdef USE_GRADIENTMAP\n\t\t\treturn texture2D( gradientMap, coord ).rgb;\n\t\t#else\n\t\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t\t#endif\n\t}\n#endif\n'

  var lightmap_fragment =
    '#ifdef USE_LIGHTMAP\n\treflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif\n'

  var lightmap_pars_fragment =
    '#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif'

  var lights_lambert_vertex =
    'vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvLightFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n#endif\n'

  var lights_pars =
    'uniform vec3 ambientLightColor;\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color = directionalLight.color;\n\t\tdirectLight.direction = directionalLight.direction;\n\t\tdirectLight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t\tfloat shadowCameraNear;\n\t\tfloat shadowCameraFar;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tdirectLight.color = pointLight.color;\n\t\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tfloat angleCos = dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos > spotLight.coneCos ) {\n\t\t\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color = spotLight.color;\n\t\t\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible = true;\n\t\t} else {\n\t\t\tdirectLight.color = vec3( 0.0 );\n\t\t\tdirectLight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n\t\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *= PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif\n#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\tvec4 envMapColor = textureCubeUV( queryVec, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor = vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar = float( maxMIPLevel );\n\t\tfloat desiredMIPLevel = maxMIPLevelScalar + 0.79248 - 0.5 * log2( pow2( blinnShininessExponent ) + 1.0 );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );\n\t\t#endif\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\tvec4 envMapColor = textureCubeUV(queryReflectVec, BlinnExponentToGGXRoughness(blinnShininessExponent));\n\t\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\t\tvec2 sampleUV;\n\t\t\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\t\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\t\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif\n'

  var lights_phong_fragment =
    'BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;\n'

  var lights_phong_pars_fragment =
    'varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3\tdiffuseColor;\n\tvec3\tspecularColor;\n\tfloat\tspecularShininess;\n\tfloat\tspecularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\t#ifdef TOON\n\t\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#else\n\t\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\t\tvec3 irradiance = dotNL * directLight.color;\n\t#endif\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)\n'

  var lights_physical_fragment =
    'PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\n#ifdef STANDARD\n\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.clearCoat = saturate( clearCoat );\tmaterial.clearCoatRoughness = clamp( clearCoatRoughness, 0.04, 1.0 );\n#endif\n'

  var lights_physical_pars_fragment =
    'struct PhysicalMaterial {\n\tvec3\tdiffuseColor;\n\tfloat\tspecularRoughness;\n\tvec3\tspecularColor;\n\t#ifndef STANDARD\n\t\tfloat clearCoat;\n\t\tfloat clearCoatRoughness;\n\t#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearCoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos - halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos + halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos + halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos - halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\t#ifndef STANDARD\n\t\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\n\t#else\n\t\tfloat clearCoatDHR = 0.0;\n\t#endif\n\treflectedLight.directSpecular += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );\n\treflectedLight.directDiffuse += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\t#ifndef STANDARD\n\t\treflectedLight.directSpecular += irradiance * material.clearCoat * BRDF_Specular_GGX( directLight, geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness );\n\t#endif\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 clearCoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t#ifndef STANDARD\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\tfloat dotNL = dotNV;\n\t\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\n\t#else\n\t\tfloat clearCoatDHR = 0.0;\n\t#endif\n\treflectedLight.indirectSpecular += ( 1.0 - clearCoatDHR ) * radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );\n\t#ifndef STANDARD\n\t\treflectedLight.indirectSpecular += clearCoatRadiance * material.clearCoat * BRDF_Specular_GGX_Environment( geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness );\n\t#endif\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\n#define Material_BlinnShininessExponent( material )   GGXRoughnessToBlinnExponent( material.specularRoughness )\n#define Material_ClearCoat_BlinnShininessExponent( material )   GGXRoughnessToBlinnExponent( material.clearCoatRoughness )\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}\n'

  var lights_template =
    '\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = normalize( vViewPosition );\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#ifdef USE_SHADOWMAP\n\t\tdirectLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#ifdef USE_SHADOWMAP\n\t\tdirectLight.color *= all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#ifdef USE_SHADOWMAP\n\t\tdirectLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t#ifdef USE_LIGHTMAP\n\t\tvec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( PHYSICAL ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tirradiance += getLightProbeIndirectIrradiance( geometry, 8 );\n\t#endif\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tvec3 radiance = getLightProbeIndirectRadiance( geometry, Material_BlinnShininessExponent( material ), 8 );\n\t#ifndef STANDARD\n\t\tvec3 clearCoatRadiance = getLightProbeIndirectRadiance( geometry, Material_ClearCoat_BlinnShininessExponent( material ), 8 );\n\t#else\n\t\tvec3 clearCoatRadiance = vec3( 0.0 );\n\t#endif\n\tRE_IndirectSpecular( radiance, clearCoatRadiance, geometry, material, reflectedLight );\n#endif\n'

  var logdepthbuf_fragment =
    '#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif'

  var logdepthbuf_pars_fragment =
    '#ifdef USE_LOGDEPTHBUF\n\tuniform float logDepthBufFC;\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t#endif\n#endif\n'

  var logdepthbuf_pars_vertex =
    '#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t#endif\n\tuniform float logDepthBufFC;\n#endif'

  var logdepthbuf_vertex =
    '#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t#else\n\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\tgl_Position.z *= gl_Position.w;\n\t#endif\n#endif\n'

  var map_fragment =
    '#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif\n'

  var map_pars_fragment = '#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n'

  var map_particle_fragment =
    '#ifdef USE_MAP\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\tvec4 mapTexel = texture2D( map, uv );\n\tdiffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n'

  var map_particle_pars_fragment =
    '#ifdef USE_MAP\n\tuniform mat3 uvTransform;\n\tuniform sampler2D map;\n#endif\n'

  var metalnessmap_fragment =
    'float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif\n'

  var metalnessmap_pars_fragment =
    '#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif'

  var morphnormal_vertex =
    '#ifdef USE_MORPHNORMALS\n\tobjectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n\tobjectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n\tobjectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n\tobjectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif\n'

  var morphtarget_pars_vertex =
    '#ifdef USE_MORPHTARGETS\n\t#ifndef USE_MORPHNORMALS\n\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif'

  var morphtarget_vertex =
    '#ifdef USE_MORPHTARGETS\n\ttransformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n\ttransformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n\ttransformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n\ttransformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\ttransformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n\ttransformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n\ttransformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n\ttransformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n\t#endif\n#endif\n'

  var normal_fragment =
    '#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n#endif\n#ifdef USE_NORMALMAP\n\tnormal = perturbNormal2Arb( -vViewPosition, normal );\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif\n'

  var normalmap_pars_fragment =
    '#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tvec3 S = normalize( q0 * st1.t - q1 * st0.t );\n\t\tvec3 T = normalize( -q0 * st1.s + q1 * st0.s );\n\t\tvec3 N = normalize( surf_norm );\n\t\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy = normalScale * mapN.xy;\n\t\tmat3 tsn = mat3( S, T, N );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif\n'

  var packing =
    'vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256.,  256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}\n'

  var premultiplied_alpha_fragment =
    '#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif\n'

  var project_vertex =
    'vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\ngl_Position = projectionMatrix * mvPosition;\n'

  var dithering_fragment =
    '#if defined( DITHERING )\n  gl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif\n'

  var dithering_pars_fragment =
    '#if defined( DITHERING )\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif\n'

  var roughnessmap_fragment =
    'float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif\n'

  var roughnessmap_pars_fragment =
    '#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif'

  var shadowmap_pars_fragment =
    '#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHTS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHTS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHTS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tfloat texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n\t\tconst vec2 offset = vec2( 0.0, 1.0 );\n\t\tvec2 texelSize = vec2( 1.0 ) / size;\n\t\tvec2 centroidUV = floor( uv * size + 0.5 ) / size;\n\t\tfloat lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n\t\tfloat lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n\t\tfloat rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n\t\tfloat rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n\t\tvec2 f = fract( uv * size + 0.5 );\n\t\tfloat a = mix( lb, lt, f.y );\n\t\tfloat b = mix( rb, rt, f.y );\n\t\tfloat c = mix( a, b, f.x );\n\t\treturn c;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tshadow = (\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn shadow;\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif\n'

  var shadowmap_pars_vertex =
    '#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHTS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHTS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHTS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n\t#endif\n#endif\n'

  var shadowmap_vertex =
    '#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n#endif\n'

  var shadowmask_pars_fragment =
    'float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tshadow *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tshadow *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tshadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#endif\n\t#endif\n\treturn shadow;\n}\n'

  var skinbase_vertex =
    '#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif'

  var skinning_pars_vertex =
    '#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif\n'

  var skinning_vertex =
    '#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif\n'

  var skinnormal_vertex =
    '#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n#endif\n'

  var specularmap_fragment =
    'float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif'

  var specularmap_pars_fragment = '#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif'

  var tonemapping_fragment =
    '#if defined( TONE_MAPPING )\n  gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif\n'

  var tonemapping_pars_fragment =
    '#ifndef saturate\n\t#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nuniform float toneMappingWhitePoint;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\nvec3 Uncharted2ToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\n'

  var uv_pars_fragment =
    '#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n\tvarying vec2 vUv;\n#endif'

  var uv_pars_vertex =
    '#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif\n'

  var uv_vertex =
    '#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif'

  var uv2_pars_fragment =
    '#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif'

  var uv2_pars_vertex =
    '#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n#endif'

  var uv2_vertex = '#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = uv2;\n#endif'

  var worldpos_vertex =
    '#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\n#endif\n'

  var cube_frag =
    'uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldPosition;\nvoid main() {\n\tgl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );\n\tgl_FragColor.a *= opacity;\n}\n'

  var cube_vert =
    'varying vec3 vWorldPosition;\n#include <common>\nvoid main() {\n\tvWorldPosition = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}\n'

  var depth_frag =
    '#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( gl_FragCoord.z );\n\t#endif\n}\n'

  var depth_vert =
    '#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n}\n'

  var distanceRGBA_frag =
    '#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}\n'

  var distanceRGBA_vert =
    '#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}\n'

  var equirect_frag =
    'uniform sampler2D tEquirect;\nvarying vec3 vWorldPosition;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldPosition );\n\tvec2 sampleUV;\n\tsampleUV.y = asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\tsampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n}\n'

  var equirect_vert =
    'varying vec3 vWorldPosition;\n#include <common>\nvoid main() {\n\tvWorldPosition = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}\n'

  var linedashed_frag =
    'uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}\n'

  var linedashed_vert =
    'uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\tvLineDistance = scale * lineDistance;\n\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}\n'

  var meshbasic_frag =
    'uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\treflectedLight.indirectDiffuse += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}\n'

  var meshbasic_vert =
    '#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_ENVMAP\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}\n'

  var meshlambert_frag =
    'uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\treflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n'

  var meshlambert_vert =
    '#define LAMBERT\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n'

  var meshphong_frag =
    '#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_template>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n'

  var meshphong_vert =
    '#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n'

  var meshphysical_frag =
    '#define PHYSICAL\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifndef STANDARD\n\tuniform float clearCoat;\n\tuniform float clearCoatRoughness;\n#endif\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <lights_pars>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_template>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n'

  var meshphysical_vert =
    '#define PHYSICAL\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n'

  var normal_frag =
    '#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\nvoid main() {\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}\n'

  var normal_vert =
    '#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}\n'

  var points_frag =
    'uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}\n'

  var points_vert =
    'uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#ifdef USE_SIZEATTENUATION\n\t\tgl_PointSize = size * ( scale / - mvPosition.z );\n\t#else\n\t\tgl_PointSize = size;\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n'

  var shadow_frag =
    'uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <fog_fragment>\n}\n'

  var shadow_vert =
    '#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n'

  var ShaderChunk = {
    alphamap_fragment: alphamap_fragment,
    alphamap_pars_fragment: alphamap_pars_fragment,
    alphatest_fragment: alphatest_fragment,
    aomap_fragment: aomap_fragment,
    aomap_pars_fragment: aomap_pars_fragment,
    begin_vertex: begin_vertex,
    beginnormal_vertex: beginnormal_vertex,
    bsdfs: bsdfs,
    bumpmap_pars_fragment: bumpmap_pars_fragment,
    clipping_planes_fragment: clipping_planes_fragment,
    clipping_planes_pars_fragment: clipping_planes_pars_fragment,
    clipping_planes_pars_vertex: clipping_planes_pars_vertex,
    clipping_planes_vertex: clipping_planes_vertex,
    color_fragment: color_fragment,
    color_pars_fragment: color_pars_fragment,
    color_pars_vertex: color_pars_vertex,
    color_vertex: color_vertex,
    common: common,
    cube_uv_reflection_fragment: cube_uv_reflection_fragment,
    defaultnormal_vertex: defaultnormal_vertex,
    displacementmap_pars_vertex: displacementmap_pars_vertex,
    displacementmap_vertex: displacementmap_vertex,
    emissivemap_fragment: emissivemap_fragment,
    emissivemap_pars_fragment: emissivemap_pars_fragment,
    encodings_fragment: encodings_fragment,
    encodings_pars_fragment: encodings_pars_fragment,
    envmap_fragment: envmap_fragment,
    envmap_pars_fragment: envmap_pars_fragment,
    envmap_pars_vertex: envmap_pars_vertex,
    envmap_vertex: envmap_vertex,
    fog_vertex: fog_vertex,
    fog_pars_vertex: fog_pars_vertex,
    fog_fragment: fog_fragment,
    fog_pars_fragment: fog_pars_fragment,
    gradientmap_pars_fragment: gradientmap_pars_fragment,
    lightmap_fragment: lightmap_fragment,
    lightmap_pars_fragment: lightmap_pars_fragment,
    lights_lambert_vertex: lights_lambert_vertex,
    lights_pars: lights_pars,
    lights_phong_fragment: lights_phong_fragment,
    lights_phong_pars_fragment: lights_phong_pars_fragment,
    lights_physical_fragment: lights_physical_fragment,
    lights_physical_pars_fragment: lights_physical_pars_fragment,
    lights_template: lights_template,
    logdepthbuf_fragment: logdepthbuf_fragment,
    logdepthbuf_pars_fragment: logdepthbuf_pars_fragment,
    logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
    logdepthbuf_vertex: logdepthbuf_vertex,
    map_fragment: map_fragment,
    map_pars_fragment: map_pars_fragment,
    map_particle_fragment: map_particle_fragment,
    map_particle_pars_fragment: map_particle_pars_fragment,
    metalnessmap_fragment: metalnessmap_fragment,
    metalnessmap_pars_fragment: metalnessmap_pars_fragment,
    morphnormal_vertex: morphnormal_vertex,
    morphtarget_pars_vertex: morphtarget_pars_vertex,
    morphtarget_vertex: morphtarget_vertex,
    normal_fragment: normal_fragment,
    normalmap_pars_fragment: normalmap_pars_fragment,
    packing: packing,
    premultiplied_alpha_fragment: premultiplied_alpha_fragment,
    project_vertex: project_vertex,
    dithering_fragment: dithering_fragment,
    dithering_pars_fragment: dithering_pars_fragment,
    roughnessmap_fragment: roughnessmap_fragment,
    roughnessmap_pars_fragment: roughnessmap_pars_fragment,
    shadowmap_pars_fragment: shadowmap_pars_fragment,
    shadowmap_pars_vertex: shadowmap_pars_vertex,
    shadowmap_vertex: shadowmap_vertex,
    shadowmask_pars_fragment: shadowmask_pars_fragment,
    skinbase_vertex: skinbase_vertex,
    skinning_pars_vertex: skinning_pars_vertex,
    skinning_vertex: skinning_vertex,
    skinnormal_vertex: skinnormal_vertex,
    specularmap_fragment: specularmap_fragment,
    specularmap_pars_fragment: specularmap_pars_fragment,
    tonemapping_fragment: tonemapping_fragment,
    tonemapping_pars_fragment: tonemapping_pars_fragment,
    uv_pars_fragment: uv_pars_fragment,
    uv_pars_vertex: uv_pars_vertex,
    uv_vertex: uv_vertex,
    uv2_pars_fragment: uv2_pars_fragment,
    uv2_pars_vertex: uv2_pars_vertex,
    uv2_vertex: uv2_vertex,
    worldpos_vertex: worldpos_vertex,

    cube_frag: cube_frag,
    cube_vert: cube_vert,
    depth_frag: depth_frag,
    depth_vert: depth_vert,
    distanceRGBA_frag: distanceRGBA_frag,
    distanceRGBA_vert: distanceRGBA_vert,
    equirect_frag: equirect_frag,
    equirect_vert: equirect_vert,
    linedashed_frag: linedashed_frag,
    linedashed_vert: linedashed_vert,
    meshbasic_frag: meshbasic_frag,
    meshbasic_vert: meshbasic_vert,
    meshlambert_frag: meshlambert_frag,
    meshlambert_vert: meshlambert_vert,
    meshphong_frag: meshphong_frag,
    meshphong_vert: meshphong_vert,
    meshphysical_frag: meshphysical_frag,
    meshphysical_vert: meshphysical_vert,
    normal_frag: normal_frag,
    normal_vert: normal_vert,
    points_frag: points_frag,
    points_vert: points_vert,
    shadow_frag: shadow_frag,
    shadow_vert: shadow_vert
  }

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   * @author mikael emtinger / http://gomo.se/
   */

  var ShaderLib = {
    basic: {
      uniforms: UniformsUtils.merge([
        UniformsLib.common,
        UniformsLib.specularmap,
        UniformsLib.envmap,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.fog
      ]),

      vertexShader: ShaderChunk.meshbasic_vert,
      fragmentShader: ShaderChunk.meshbasic_frag
    },

    lambert: {
      uniforms: UniformsUtils.merge([
        UniformsLib.common,
        UniformsLib.specularmap,
        UniformsLib.envmap,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.emissivemap,
        UniformsLib.fog,
        UniformsLib.lights,
        {
          emissive: { value: new Color(0x000000) }
        }
      ]),

      vertexShader: ShaderChunk.meshlambert_vert,
      fragmentShader: ShaderChunk.meshlambert_frag
    },

    phong: {
      uniforms: UniformsUtils.merge([
        UniformsLib.common,
        UniformsLib.specularmap,
        UniformsLib.envmap,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.emissivemap,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        UniformsLib.gradientmap,
        UniformsLib.fog,
        UniformsLib.lights,
        {
          emissive: { value: new Color(0x000000) },
          specular: { value: new Color(0x111111) },
          shininess: { value: 30 }
        }
      ]),

      vertexShader: ShaderChunk.meshphong_vert,
      fragmentShader: ShaderChunk.meshphong_frag
    },

    standard: {
      uniforms: UniformsUtils.merge([
        UniformsLib.common,
        UniformsLib.envmap,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.emissivemap,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        UniformsLib.roughnessmap,
        UniformsLib.metalnessmap,
        UniformsLib.fog,
        UniformsLib.lights,
        {
          emissive: { value: new Color(0x000000) },
          roughness: { value: 0.5 },
          metalness: { value: 0.5 },
          envMapIntensity: { value: 1 } // temporary
        }
      ]),

      vertexShader: ShaderChunk.meshphysical_vert,
      fragmentShader: ShaderChunk.meshphysical_frag
    },

    points: {
      uniforms: UniformsUtils.merge([UniformsLib.points, UniformsLib.fog]),

      vertexShader: ShaderChunk.points_vert,
      fragmentShader: ShaderChunk.points_frag
    },

    dashed: {
      uniforms: UniformsUtils.merge([
        UniformsLib.common,
        UniformsLib.fog,
        {
          scale: { value: 1 },
          dashSize: { value: 1 },
          totalSize: { value: 2 }
        }
      ]),

      vertexShader: ShaderChunk.linedashed_vert,
      fragmentShader: ShaderChunk.linedashed_frag
    },

    depth: {
      uniforms: UniformsUtils.merge([UniformsLib.common, UniformsLib.displacementmap]),

      vertexShader: ShaderChunk.depth_vert,
      fragmentShader: ShaderChunk.depth_frag
    },

    normal: {
      uniforms: UniformsUtils.merge([
        UniformsLib.common,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        {
          opacity: { value: 1.0 }
        }
      ]),

      vertexShader: ShaderChunk.normal_vert,
      fragmentShader: ShaderChunk.normal_frag
    },

    /* -------------------------------------------------------------------------
		//	Cube map shader
		 ------------------------------------------------------------------------- */

    cube: {
      uniforms: {
        tCube: { value: null },
        tFlip: { value: -1 },
        opacity: { value: 1.0 }
      },

      vertexShader: ShaderChunk.cube_vert,
      fragmentShader: ShaderChunk.cube_frag
    },

    equirect: {
      uniforms: {
        tEquirect: { value: null }
      },

      vertexShader: ShaderChunk.equirect_vert,
      fragmentShader: ShaderChunk.equirect_frag
    },

    distanceRGBA: {
      uniforms: UniformsUtils.merge([
        UniformsLib.common,
        UniformsLib.displacementmap,
        {
          referencePosition: { value: new Vector3() },
          nearDistance: { value: 1 },
          farDistance: { value: 1000 }
        }
      ]),

      vertexShader: ShaderChunk.distanceRGBA_vert,
      fragmentShader: ShaderChunk.distanceRGBA_frag
    },

    shadow: {
      uniforms: UniformsUtils.merge([
        UniformsLib.lights,
        UniformsLib.fog,
        {
          color: { value: new Color(0x00000) },
          opacity: { value: 1.0 }
        }
      ]),

      vertexShader: ShaderChunk.shadow_vert,
      fragmentShader: ShaderChunk.shadow_frag
    }
  }

  ShaderLib.physical = {
    uniforms: UniformsUtils.merge([
      ShaderLib.standard.uniforms,
      {
        clearCoat: { value: 0 },
        clearCoatRoughness: { value: 0 }
      }
    ]),

    vertexShader: ShaderChunk.meshphysical_vert,
    fragmentShader: ShaderChunk.meshphysical_frag
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function CanvasTexture(
    canvas,
    mapping,
    wrapS,
    wrapT,
    magFilter,
    minFilter,
    format,
    type,
    anisotropy
  ) {
    Texture.call(
      this,
      canvas,
      mapping,
      wrapS,
      wrapT,
      magFilter,
      minFilter,
      format,
      type,
      anisotropy
    )

    this.needsUpdate = true
  }

  CanvasTexture.prototype = Object.create(Texture.prototype)
  CanvasTexture.prototype.constructor = CanvasTexture

  /**
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   */

  function WebGLSpriteRenderer(renderer, gl, state, textures, capabilities) {
    var vertexBuffer, elementBuffer
    var program, attributes, uniforms

    var texture

    // decompose matrixWorld

    var spritePosition = new Vector3()
    var spriteRotation = new Quaternion()
    var spriteScale = new Vector3()

    function init() {
      var vertices = new Float32Array([
        -0.5, -0.5, 0, 0, 0.5, -0.5, 1, 0, 0.5, 0.5, 1, 1, -0.5, 0.5, 0, 1
      ])

      var faces = new Uint16Array([0, 1, 2, 0, 2, 3])

      vertexBuffer = gl.createBuffer()
      elementBuffer = gl.createBuffer()

      gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer)
      gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW)

      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer)
      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW)

      program = createProgram()

      attributes = {
        position: gl.getAttribLocation(program, 'position'),
        uv: gl.getAttribLocation(program, 'uv')
      }

      uniforms = {
        uvOffset: gl.getUniformLocation(program, 'uvOffset'),
        uvScale: gl.getUniformLocation(program, 'uvScale'),

        rotation: gl.getUniformLocation(program, 'rotation'),
        center: gl.getUniformLocation(program, 'center'),
        scale: gl.getUniformLocation(program, 'scale'),

        color: gl.getUniformLocation(program, 'color'),
        map: gl.getUniformLocation(program, 'map'),
        opacity: gl.getUniformLocation(program, 'opacity'),

        modelViewMatrix: gl.getUniformLocation(program, 'modelViewMatrix'),
        projectionMatrix: gl.getUniformLocation(program, 'projectionMatrix'),

        fogType: gl.getUniformLocation(program, 'fogType'),
        fogDensity: gl.getUniformLocation(program, 'fogDensity'),
        fogNear: gl.getUniformLocation(program, 'fogNear'),
        fogFar: gl.getUniformLocation(program, 'fogFar'),
        fogColor: gl.getUniformLocation(program, 'fogColor'),
        fogDepth: gl.getUniformLocation(program, 'fogDepth'),

        alphaTest: gl.getUniformLocation(program, 'alphaTest')
      }

      var canvas = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')
      canvas.width = 8
      canvas.height = 8

      var context = canvas.getContext('2d')
      context.fillStyle = 'white'
      context.fillRect(0, 0, 8, 8)

      texture = new CanvasTexture(canvas)
    }

    this.render = function (sprites, scene, camera) {
      if (sprites.length === 0) return

      // setup gl

      if (program === undefined) {
        init()
      }

      state.useProgram(program)

      state.initAttributes()
      state.enableAttribute(attributes.position)
      state.enableAttribute(attributes.uv)
      state.disableUnusedAttributes()

      state.disable(gl.CULL_FACE)
      state.enable(gl.BLEND)

      gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer)
      gl.vertexAttribPointer(attributes.position, 2, gl.FLOAT, false, 2 * 8, 0)
      gl.vertexAttribPointer(attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8)

      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer)

      gl.uniformMatrix4fv(uniforms.projectionMatrix, false, camera.projectionMatrix.elements)

      state.activeTexture(gl.TEXTURE0)
      gl.uniform1i(uniforms.map, 0)

      var oldFogType = 0
      var sceneFogType = 0
      var fog = scene.fog

      if (fog) {
        gl.uniform3f(uniforms.fogColor, fog.color.r, fog.color.g, fog.color.b)

        if (fog.isFog) {
          gl.uniform1f(uniforms.fogNear, fog.near)
          gl.uniform1f(uniforms.fogFar, fog.far)

          gl.uniform1i(uniforms.fogType, 1)
          oldFogType = 1
          sceneFogType = 1
        } else if (fog.isFogExp2) {
          gl.uniform1f(uniforms.fogDensity, fog.density)

          gl.uniform1i(uniforms.fogType, 2)
          oldFogType = 2
          sceneFogType = 2
        }
      } else {
        gl.uniform1i(uniforms.fogType, 0)
        oldFogType = 0
        sceneFogType = 0
      }

      // update positions and sort

      for (var i = 0, l = sprites.length; i < l; i++) {
        var sprite = sprites[i]

        sprite.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, sprite.matrixWorld)
        sprite.z = -sprite.modelViewMatrix.elements[14]
      }

      sprites.sort(painterSortStable)

      // render all sprites

      var scale = []
      var center = []

      for (var i = 0, l = sprites.length; i < l; i++) {
        var sprite = sprites[i]
        var material = sprite.material

        if (material.visible === false) continue

        sprite.onBeforeRender(renderer, scene, camera, undefined, material, undefined)

        gl.uniform1f(uniforms.alphaTest, material.alphaTest)
        gl.uniformMatrix4fv(uniforms.modelViewMatrix, false, sprite.modelViewMatrix.elements)

        sprite.matrixWorld.decompose(spritePosition, spriteRotation, spriteScale)

        scale[0] = spriteScale.x
        scale[1] = spriteScale.y

        center[0] = sprite.center.x - 0.5
        center[1] = sprite.center.y - 0.5

        var fogType = 0

        if (scene.fog && material.fog) {
          fogType = sceneFogType
        }

        if (oldFogType !== fogType) {
          gl.uniform1i(uniforms.fogType, fogType)
          oldFogType = fogType
        }

        if (material.map !== null) {
          gl.uniform2f(uniforms.uvOffset, material.map.offset.x, material.map.offset.y)
          gl.uniform2f(uniforms.uvScale, material.map.repeat.x, material.map.repeat.y)
        } else {
          gl.uniform2f(uniforms.uvOffset, 0, 0)
          gl.uniform2f(uniforms.uvScale, 1, 1)
        }

        gl.uniform1f(uniforms.opacity, material.opacity)
        gl.uniform3f(uniforms.color, material.color.r, material.color.g, material.color.b)

        gl.uniform1f(uniforms.rotation, material.rotation)
        gl.uniform2fv(uniforms.center, center)
        gl.uniform2fv(uniforms.scale, scale)

        state.setBlending(
          material.blending,
          material.blendEquation,
          material.blendSrc,
          material.blendDst,
          material.blendEquationAlpha,
          material.blendSrcAlpha,
          material.blendDstAlpha,
          material.premultipliedAlpha
        )
        state.buffers.depth.setTest(material.depthTest)
        state.buffers.depth.setMask(material.depthWrite)
        state.buffers.color.setMask(material.colorWrite)

        textures.setTexture2D(material.map || texture, 0)

        gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0)

        sprite.onAfterRender(renderer, scene, camera, undefined, material, undefined)
      }

      // restore gl

      state.enable(gl.CULL_FACE)

      state.reset()
    }

    function createProgram() {
      var program = gl.createProgram()

      var vertexShader = gl.createShader(gl.VERTEX_SHADER)
      var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER)

      gl.shaderSource(
        vertexShader,
        [
          'precision ' + capabilities.precision + ' float;',

          '#define SHADER_NAME ' + 'SpriteMaterial',

          'uniform mat4 modelViewMatrix;',
          'uniform mat4 projectionMatrix;',
          'uniform float rotation;',
          'uniform vec2 center;',
          'uniform vec2 scale;',
          'uniform vec2 uvOffset;',
          'uniform vec2 uvScale;',

          'attribute vec2 position;',
          'attribute vec2 uv;',

          'varying vec2 vUV;',
          'varying float fogDepth;',

          'void main() {',

          '	vUV = uvOffset + uv * uvScale;',

          '	vec2 alignedPosition = ( position - center ) * scale;',

          '	vec2 rotatedPosition;',
          '	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;',
          '	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;',

          '	vec4 mvPosition;',

          '	mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );',
          '	mvPosition.xy += rotatedPosition;',

          '	gl_Position = projectionMatrix * mvPosition;',

          '	fogDepth = - mvPosition.z;',

          '}'
        ].join('\n')
      )

      gl.shaderSource(
        fragmentShader,
        [
          'precision ' + capabilities.precision + ' float;',

          '#define SHADER_NAME ' + 'SpriteMaterial',

          'uniform vec3 color;',
          'uniform sampler2D map;',
          'uniform float opacity;',

          'uniform int fogType;',
          'uniform vec3 fogColor;',
          'uniform float fogDensity;',
          'uniform float fogNear;',
          'uniform float fogFar;',
          'uniform float alphaTest;',

          'varying vec2 vUV;',
          'varying float fogDepth;',

          'void main() {',

          '	vec4 texture = texture2D( map, vUV );',

          '	gl_FragColor = vec4( color * texture.xyz, texture.a * opacity );',

          '	if ( gl_FragColor.a < alphaTest ) discard;',

          '	if ( fogType > 0 ) {',

          '		float fogFactor = 0.0;',

          '		if ( fogType == 1 ) {',

          '			fogFactor = smoothstep( fogNear, fogFar, fogDepth );',

          '		} else {',

          '			const float LOG2 = 1.442695;',
          '			fogFactor = exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 );',
          '			fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );',

          '		}',

          '		gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );',

          '	}',

          '}'
        ].join('\n')
      )

      gl.compileShader(vertexShader)
      gl.compileShader(fragmentShader)

      gl.attachShader(program, vertexShader)
      gl.attachShader(program, fragmentShader)

      gl.linkProgram(program)

      return program
    }

    function painterSortStable(a, b) {
      if (a.renderOrder !== b.renderOrder) {
        return a.renderOrder - b.renderOrder
      } else if (a.z !== b.z) {
        return b.z - a.z
      } else {
        return b.id - a.id
      }
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   */

  var materialId = 0

  function Material() {
    Object.defineProperty(this, 'id', { value: materialId++ })

    this.uuid = _Math.generateUUID()

    this.name = ''
    this.type = 'Material'

    this.fog = true
    this.lights = true

    this.blending = NormalBlending
    this.side = FrontSide
    this.flatShading = false
    this.vertexColors = NoColors // THREE.NoColors, THREE.VertexColors, THREE.FaceColors

    this.opacity = 1
    this.transparent = false

    this.blendSrc = SrcAlphaFactor
    this.blendDst = OneMinusSrcAlphaFactor
    this.blendEquation = AddEquation
    this.blendSrcAlpha = null
    this.blendDstAlpha = null
    this.blendEquationAlpha = null

    this.depthFunc = LessEqualDepth
    this.depthTest = true
    this.depthWrite = true

    this.clippingPlanes = null
    this.clipIntersection = false
    this.clipShadows = false

    this.shadowSide = null

    this.colorWrite = true

    this.precision = null // override the renderer's default precision for this material

    this.polygonOffset = false
    this.polygonOffsetFactor = 0
    this.polygonOffsetUnits = 0

    this.dithering = false

    this.alphaTest = 0
    this.premultipliedAlpha = false

    this.overdraw = 0 // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer

    this.visible = true

    this.userData = {}

    this.needsUpdate = true
  }

  Material.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Material,

    isMaterial: true,

    onBeforeCompile: function () {},

    setValues: function (values) {
      if (values === undefined) return

      for (var key in values) {
        var newValue = values[key]

        if (newValue === undefined) {
          console.warn("THREE.Material: '" + key + "' parameter is undefined.")
          continue
        }

        // for backward compatability if shading is set in the constructor
        if (key === 'shading') {
          console.warn(
            'THREE.' +
              this.type +
              ': .shading has been removed. Use the boolean .flatShading instead.'
          )
          this.flatShading = newValue === FlatShading ? true : false
          continue
        }

        var currentValue = this[key]

        if (currentValue === undefined) {
          console.warn('THREE.' + this.type + ": '" + key + "' is not a property of this material.")
          continue
        }

        if (currentValue && currentValue.isColor) {
          currentValue.set(newValue)
        } else if (currentValue && currentValue.isVector3 && newValue && newValue.isVector3) {
          currentValue.copy(newValue)
        } else if (key === 'overdraw') {
          // ensure overdraw is backwards-compatible with legacy boolean type
          this[key] = Number(newValue)
        } else {
          this[key] = newValue
        }
      }
    },

    toJSON: function (meta) {
      var isRoot = meta === undefined || typeof meta === 'string'

      if (isRoot) {
        meta = {
          textures: {},
          images: {}
        }
      }

      var data = {
        metadata: {
          version: 4.5,
          type: 'Material',
          generator: 'Material.toJSON'
        }
      }

      // standard Material serialization
      data.uuid = this.uuid
      data.type = this.type

      if (this.name !== '') data.name = this.name

      if (this.color && this.color.isColor) data.color = this.color.getHex()

      if (this.roughness !== undefined) data.roughness = this.roughness
      if (this.metalness !== undefined) data.metalness = this.metalness

      if (this.emissive && this.emissive.isColor) data.emissive = this.emissive.getHex()
      if (this.emissiveIntensity !== 1) data.emissiveIntensity = this.emissiveIntensity

      if (this.specular && this.specular.isColor) data.specular = this.specular.getHex()
      if (this.shininess !== undefined) data.shininess = this.shininess
      if (this.clearCoat !== undefined) data.clearCoat = this.clearCoat
      if (this.clearCoatRoughness !== undefined) data.clearCoatRoughness = this.clearCoatRoughness

      if (this.map && this.map.isTexture) data.map = this.map.toJSON(meta).uuid
      if (this.alphaMap && this.alphaMap.isTexture) data.alphaMap = this.alphaMap.toJSON(meta).uuid
      if (this.lightMap && this.lightMap.isTexture) data.lightMap = this.lightMap.toJSON(meta).uuid
      if (this.bumpMap && this.bumpMap.isTexture) {
        data.bumpMap = this.bumpMap.toJSON(meta).uuid
        data.bumpScale = this.bumpScale
      }
      if (this.normalMap && this.normalMap.isTexture) {
        data.normalMap = this.normalMap.toJSON(meta).uuid
        data.normalScale = this.normalScale.toArray()
      }
      if (this.displacementMap && this.displacementMap.isTexture) {
        data.displacementMap = this.displacementMap.toJSON(meta).uuid
        data.displacementScale = this.displacementScale
        data.displacementBias = this.displacementBias
      }
      if (this.roughnessMap && this.roughnessMap.isTexture)
        data.roughnessMap = this.roughnessMap.toJSON(meta).uuid
      if (this.metalnessMap && this.metalnessMap.isTexture)
        data.metalnessMap = this.metalnessMap.toJSON(meta).uuid

      if (this.emissiveMap && this.emissiveMap.isTexture)
        data.emissiveMap = this.emissiveMap.toJSON(meta).uuid
      if (this.specularMap && this.specularMap.isTexture)
        data.specularMap = this.specularMap.toJSON(meta).uuid

      if (this.envMap && this.envMap.isTexture) {
        data.envMap = this.envMap.toJSON(meta).uuid
        data.reflectivity = this.reflectivity // Scale behind envMap
      }

      if (this.gradientMap && this.gradientMap.isTexture) {
        data.gradientMap = this.gradientMap.toJSON(meta).uuid
      }

      if (this.size !== undefined) data.size = this.size
      if (this.sizeAttenuation !== undefined) data.sizeAttenuation = this.sizeAttenuation

      if (this.blending !== NormalBlending) data.blending = this.blending
      if (this.flatShading === true) data.flatShading = this.flatShading
      if (this.side !== FrontSide) data.side = this.side
      if (this.vertexColors !== NoColors) data.vertexColors = this.vertexColors

      if (this.opacity < 1) data.opacity = this.opacity
      if (this.transparent === true) data.transparent = this.transparent

      data.depthFunc = this.depthFunc
      data.depthTest = this.depthTest
      data.depthWrite = this.depthWrite

      // rotation (SpriteMaterial)
      if (this.rotation !== 0) data.rotation = this.rotation

      if (this.linewidth !== 1) data.linewidth = this.linewidth
      if (this.dashSize !== undefined) data.dashSize = this.dashSize
      if (this.gapSize !== undefined) data.gapSize = this.gapSize
      if (this.scale !== undefined) data.scale = this.scale

      if (this.dithering === true) data.dithering = true

      if (this.alphaTest > 0) data.alphaTest = this.alphaTest
      if (this.premultipliedAlpha === true) data.premultipliedAlpha = this.premultipliedAlpha

      if (this.wireframe === true) data.wireframe = this.wireframe
      if (this.wireframeLinewidth > 1) data.wireframeLinewidth = this.wireframeLinewidth
      if (this.wireframeLinecap !== 'round') data.wireframeLinecap = this.wireframeLinecap
      if (this.wireframeLinejoin !== 'round') data.wireframeLinejoin = this.wireframeLinejoin

      if (this.morphTargets === true) data.morphTargets = true
      if (this.skinning === true) data.skinning = true

      if (this.visible === false) data.visible = false
      if (JSON.stringify(this.userData) !== '{}') data.userData = this.userData

      // TODO: Copied from Object3D.toJSON

      function extractFromCache(cache) {
        var values = []

        for (var key in cache) {
          var data = cache[key]
          delete data.metadata
          values.push(data)
        }

        return values
      }

      if (isRoot) {
        var textures = extractFromCache(meta.textures)
        var images = extractFromCache(meta.images)

        if (textures.length > 0) data.textures = textures
        if (images.length > 0) data.images = images
      }

      return data
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (source) {
      this.name = source.name

      this.fog = source.fog
      this.lights = source.lights

      this.blending = source.blending
      this.side = source.side
      this.flatShading = source.flatShading
      this.vertexColors = source.vertexColors

      this.opacity = source.opacity
      this.transparent = source.transparent

      this.blendSrc = source.blendSrc
      this.blendDst = source.blendDst
      this.blendEquation = source.blendEquation
      this.blendSrcAlpha = source.blendSrcAlpha
      this.blendDstAlpha = source.blendDstAlpha
      this.blendEquationAlpha = source.blendEquationAlpha

      this.depthFunc = source.depthFunc
      this.depthTest = source.depthTest
      this.depthWrite = source.depthWrite

      this.colorWrite = source.colorWrite

      this.precision = source.precision

      this.polygonOffset = source.polygonOffset
      this.polygonOffsetFactor = source.polygonOffsetFactor
      this.polygonOffsetUnits = source.polygonOffsetUnits

      this.dithering = source.dithering

      this.alphaTest = source.alphaTest
      this.premultipliedAlpha = source.premultipliedAlpha

      this.overdraw = source.overdraw

      this.visible = source.visible
      this.userData = JSON.parse(JSON.stringify(source.userData))

      this.clipShadows = source.clipShadows
      this.clipIntersection = source.clipIntersection

      var srcPlanes = source.clippingPlanes,
        dstPlanes = null

      if (srcPlanes !== null) {
        var n = srcPlanes.length
        dstPlanes = new Array(n)

        for (var i = 0; i !== n; ++i) dstPlanes[i] = srcPlanes[i].clone()
      }

      this.clippingPlanes = dstPlanes

      this.shadowSide = source.shadowSide

      return this
    },

    dispose: function () {
      this.dispatchEvent({ type: 'dispose' })
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   * @author bhouston / https://clara.io
   * @author WestLangley / http://github.com/WestLangley
   *
   * parameters = {
   *
   *  opacity: <float>,
   *
   *  map: new THREE.Texture( <Image> ),
   *
   *  alphaMap: new THREE.Texture( <Image> ),
   *
   *  displacementMap: new THREE.Texture( <Image> ),
   *  displacementScale: <float>,
   *  displacementBias: <float>,
   *
   *  wireframe: <boolean>,
   *  wireframeLinewidth: <float>
   * }
   */

  function MeshDepthMaterial(parameters) {
    Material.call(this)

    this.type = 'MeshDepthMaterial'

    this.depthPacking = BasicDepthPacking

    this.skinning = false
    this.morphTargets = false

    this.map = null

    this.alphaMap = null

    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0

    this.wireframe = false
    this.wireframeLinewidth = 1

    this.fog = false
    this.lights = false

    this.setValues(parameters)
  }

  MeshDepthMaterial.prototype = Object.create(Material.prototype)
  MeshDepthMaterial.prototype.constructor = MeshDepthMaterial

  MeshDepthMaterial.prototype.isMeshDepthMaterial = true

  MeshDepthMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.depthPacking = source.depthPacking

    this.skinning = source.skinning
    this.morphTargets = source.morphTargets

    this.map = source.map

    this.alphaMap = source.alphaMap

    this.displacementMap = source.displacementMap
    this.displacementScale = source.displacementScale
    this.displacementBias = source.displacementBias

    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth

    return this
  }

  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   * parameters = {
   *
   *  referencePosition: <float>,
   *  nearDistance: <float>,
   *  farDistance: <float>,
   *
   *  skinning: <bool>,
   *  morphTargets: <bool>,
   *
   *  map: new THREE.Texture( <Image> ),
   *
   *  alphaMap: new THREE.Texture( <Image> ),
   *
   *  displacementMap: new THREE.Texture( <Image> ),
   *  displacementScale: <float>,
   *  displacementBias: <float>
   *
   * }
   */

  function MeshDistanceMaterial(parameters) {
    Material.call(this)

    this.type = 'MeshDistanceMaterial'

    this.referencePosition = new Vector3()
    this.nearDistance = 1
    this.farDistance = 1000

    this.skinning = false
    this.morphTargets = false

    this.map = null

    this.alphaMap = null

    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0

    this.fog = false
    this.lights = false

    this.setValues(parameters)
  }

  MeshDistanceMaterial.prototype = Object.create(Material.prototype)
  MeshDistanceMaterial.prototype.constructor = MeshDistanceMaterial

  MeshDistanceMaterial.prototype.isMeshDistanceMaterial = true

  MeshDistanceMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.referencePosition.copy(source.referencePosition)
    this.nearDistance = source.nearDistance
    this.farDistance = source.farDistance

    this.skinning = source.skinning
    this.morphTargets = source.morphTargets

    this.map = source.map

    this.alphaMap = source.alphaMap

    this.displacementMap = source.displacementMap
    this.displacementScale = source.displacementScale
    this.displacementBias = source.displacementBias

    return this
  }

  /**
   * @author bhouston / http://clara.io
   * @author WestLangley / http://github.com/WestLangley
   */

  function Box3(min, max) {
    this.min = min !== undefined ? min : new Vector3(+Infinity, +Infinity, +Infinity)
    this.max = max !== undefined ? max : new Vector3(-Infinity, -Infinity, -Infinity)
  }

  Object.assign(Box3.prototype, {
    isBox3: true,

    set: function (min, max) {
      this.min.copy(min)
      this.max.copy(max)

      return this
    },

    setFromArray: function (array) {
      var minX = +Infinity
      var minY = +Infinity
      var minZ = +Infinity

      var maxX = -Infinity
      var maxY = -Infinity
      var maxZ = -Infinity

      for (var i = 0, l = array.length; i < l; i += 3) {
        var x = array[i]
        var y = array[i + 1]
        var z = array[i + 2]

        if (x < minX) minX = x
        if (y < minY) minY = y
        if (z < minZ) minZ = z

        if (x > maxX) maxX = x
        if (y > maxY) maxY = y
        if (z > maxZ) maxZ = z
      }

      this.min.set(minX, minY, minZ)
      this.max.set(maxX, maxY, maxZ)

      return this
    },

    setFromBufferAttribute: function (attribute) {
      var minX = +Infinity
      var minY = +Infinity
      var minZ = +Infinity

      var maxX = -Infinity
      var maxY = -Infinity
      var maxZ = -Infinity

      for (var i = 0, l = attribute.count; i < l; i++) {
        var x = attribute.getX(i)
        var y = attribute.getY(i)
        var z = attribute.getZ(i)

        if (x < minX) minX = x
        if (y < minY) minY = y
        if (z < minZ) minZ = z

        if (x > maxX) maxX = x
        if (y > maxY) maxY = y
        if (z > maxZ) maxZ = z
      }

      this.min.set(minX, minY, minZ)
      this.max.set(maxX, maxY, maxZ)

      return this
    },

    setFromPoints: function (points) {
      this.makeEmpty()

      for (var i = 0, il = points.length; i < il; i++) {
        this.expandByPoint(points[i])
      }

      return this
    },

    setFromCenterAndSize: (function () {
      var v1 = new Vector3()

      return function setFromCenterAndSize(center, size) {
        var halfSize = v1.copy(size).multiplyScalar(0.5)

        this.min.copy(center).sub(halfSize)
        this.max.copy(center).add(halfSize)

        return this
      }
    })(),

    setFromObject: function (object) {
      this.makeEmpty()

      return this.expandByObject(object)
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (box) {
      this.min.copy(box.min)
      this.max.copy(box.max)

      return this
    },

    makeEmpty: function () {
      this.min.x = this.min.y = this.min.z = +Infinity
      this.max.x = this.max.y = this.max.z = -Infinity

      return this
    },

    isEmpty: function () {
      // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes

      return this.max.x < this.min.x || this.max.y < this.min.y || this.max.z < this.min.z
    },

    getCenter: function (optionalTarget) {
      var result = optionalTarget || new Vector3()
      return this.isEmpty()
        ? result.set(0, 0, 0)
        : result.addVectors(this.min, this.max).multiplyScalar(0.5)
    },

    getSize: function (optionalTarget) {
      var result = optionalTarget || new Vector3()
      return this.isEmpty() ? result.set(0, 0, 0) : result.subVectors(this.max, this.min)
    },

    expandByPoint: function (point) {
      this.min.min(point)
      this.max.max(point)

      return this
    },

    expandByVector: function (vector) {
      this.min.sub(vector)
      this.max.add(vector)

      return this
    },

    expandByScalar: function (scalar) {
      this.min.addScalar(-scalar)
      this.max.addScalar(scalar)

      return this
    },

    expandByObject: (function () {
      // Computes the world-axis-aligned bounding box of an object (including its children),
      // accounting for both the object's, and children's, world transforms

      var scope, i, l

      var v1 = new Vector3()

      function traverse(node) {
        var geometry = node.geometry

        if (geometry !== undefined) {
          if (geometry.isGeometry) {
            var vertices = geometry.vertices

            for (i = 0, l = vertices.length; i < l; i++) {
              v1.copy(vertices[i])
              v1.applyMatrix4(node.matrixWorld)

              scope.expandByPoint(v1)
            }
          } else if (geometry.isBufferGeometry) {
            var attribute = geometry.attributes.position

            if (attribute !== undefined) {
              for (i = 0, l = attribute.count; i < l; i++) {
                v1.fromBufferAttribute(attribute, i).applyMatrix4(node.matrixWorld)

                scope.expandByPoint(v1)
              }
            }
          }
        }
      }

      return function expandByObject(object) {
        scope = this

        object.updateMatrixWorld(true)

        object.traverse(traverse)

        return this
      }
    })(),

    containsPoint: function (point) {
      return point.x < this.min.x ||
        point.x > this.max.x ||
        point.y < this.min.y ||
        point.y > this.max.y ||
        point.z < this.min.z ||
        point.z > this.max.z
        ? false
        : true
    },

    containsBox: function (box) {
      return (
        this.min.x <= box.min.x &&
        box.max.x <= this.max.x &&
        this.min.y <= box.min.y &&
        box.max.y <= this.max.y &&
        this.min.z <= box.min.z &&
        box.max.z <= this.max.z
      )
    },

    getParameter: function (point, optionalTarget) {
      // This can potentially have a divide by zero if the box
      // has a size dimension of 0.

      var result = optionalTarget || new Vector3()

      return result.set(
        (point.x - this.min.x) / (this.max.x - this.min.x),
        (point.y - this.min.y) / (this.max.y - this.min.y),
        (point.z - this.min.z) / (this.max.z - this.min.z)
      )
    },

    intersectsBox: function (box) {
      // using 6 splitting planes to rule out intersections.
      return box.max.x < this.min.x ||
        box.min.x > this.max.x ||
        box.max.y < this.min.y ||
        box.min.y > this.max.y ||
        box.max.z < this.min.z ||
        box.min.z > this.max.z
        ? false
        : true
    },

    intersectsSphere: (function () {
      var closestPoint = new Vector3()

      return function intersectsSphere(sphere) {
        // Find the point on the AABB closest to the sphere center.
        this.clampPoint(sphere.center, closestPoint)

        // If that point is inside the sphere, the AABB and sphere intersect.
        return closestPoint.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius
      }
    })(),

    intersectsPlane: function (plane) {
      // We compute the minimum and maximum dot product values. If those values
      // are on the same side (back or front) of the plane, then there is no intersection.

      var min, max

      if (plane.normal.x > 0) {
        min = plane.normal.x * this.min.x
        max = plane.normal.x * this.max.x
      } else {
        min = plane.normal.x * this.max.x
        max = plane.normal.x * this.min.x
      }

      if (plane.normal.y > 0) {
        min += plane.normal.y * this.min.y
        max += plane.normal.y * this.max.y
      } else {
        min += plane.normal.y * this.max.y
        max += plane.normal.y * this.min.y
      }

      if (plane.normal.z > 0) {
        min += plane.normal.z * this.min.z
        max += plane.normal.z * this.max.z
      } else {
        min += plane.normal.z * this.max.z
        max += plane.normal.z * this.min.z
      }

      return min <= plane.constant && max >= plane.constant
    },

    intersectsTriangle: (function () {
      // triangle centered vertices
      var v0 = new Vector3()
      var v1 = new Vector3()
      var v2 = new Vector3()

      // triangle edge vectors
      var f0 = new Vector3()
      var f1 = new Vector3()
      var f2 = new Vector3()

      var testAxis = new Vector3()

      var center = new Vector3()
      var extents = new Vector3()

      var triangleNormal = new Vector3()

      function satForAxes(axes) {
        var i, j

        for (i = 0, j = axes.length - 3; i <= j; i += 3) {
          testAxis.fromArray(axes, i)
          // project the aabb onto the seperating axis
          var r =
            extents.x * Math.abs(testAxis.x) +
            extents.y * Math.abs(testAxis.y) +
            extents.z * Math.abs(testAxis.z)
          // project all 3 vertices of the triangle onto the seperating axis
          var p0 = v0.dot(testAxis)
          var p1 = v1.dot(testAxis)
          var p2 = v2.dot(testAxis)
          // actual test, basically see if either of the most extreme of the triangle points intersects r
          if (Math.max(-Math.max(p0, p1, p2), Math.min(p0, p1, p2)) > r) {
            // points of the projected triangle are outside the projected half-length of the aabb
            // the axis is seperating and we can exit
            return false
          }
        }

        return true
      }

      return function intersectsTriangle(triangle) {
        if (this.isEmpty()) {
          return false
        }

        // compute box center and extents
        this.getCenter(center)
        extents.subVectors(this.max, center)

        // translate triangle to aabb origin
        v0.subVectors(triangle.a, center)
        v1.subVectors(triangle.b, center)
        v2.subVectors(triangle.c, center)

        // compute edge vectors for triangle
        f0.subVectors(v1, v0)
        f1.subVectors(v2, v1)
        f2.subVectors(v0, v2)

        // test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
        // make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
        // axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
        var axes = [
          0,
          -f0.z,
          f0.y,
          0,
          -f1.z,
          f1.y,
          0,
          -f2.z,
          f2.y,
          f0.z,
          0,
          -f0.x,
          f1.z,
          0,
          -f1.x,
          f2.z,
          0,
          -f2.x,
          -f0.y,
          f0.x,
          0,
          -f1.y,
          f1.x,
          0,
          -f2.y,
          f2.x,
          0
        ]
        if (!satForAxes(axes)) {
          return false
        }

        // test 3 face normals from the aabb
        axes = [1, 0, 0, 0, 1, 0, 0, 0, 1]
        if (!satForAxes(axes)) {
          return false
        }

        // finally testing the face normal of the triangle
        // use already existing triangle edge vectors here
        triangleNormal.crossVectors(f0, f1)
        axes = [triangleNormal.x, triangleNormal.y, triangleNormal.z]
        return satForAxes(axes)
      }
    })(),

    clampPoint: function (point, optionalTarget) {
      var result = optionalTarget || new Vector3()
      return result.copy(point).clamp(this.min, this.max)
    },

    distanceToPoint: (function () {
      var v1 = new Vector3()

      return function distanceToPoint(point) {
        var clampedPoint = v1.copy(point).clamp(this.min, this.max)
        return clampedPoint.sub(point).length()
      }
    })(),

    getBoundingSphere: (function () {
      var v1 = new Vector3()

      return function getBoundingSphere(optionalTarget) {
        var result = optionalTarget || new Sphere()

        this.getCenter(result.center)

        result.radius = this.getSize(v1).length() * 0.5

        return result
      }
    })(),

    intersect: function (box) {
      this.min.max(box.min)
      this.max.min(box.max)

      // ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
      if (this.isEmpty()) this.makeEmpty()

      return this
    },

    union: function (box) {
      this.min.min(box.min)
      this.max.max(box.max)

      return this
    },

    applyMatrix4: (function () {
      var points = [
        new Vector3(),
        new Vector3(),
        new Vector3(),
        new Vector3(),
        new Vector3(),
        new Vector3(),
        new Vector3(),
        new Vector3()
      ]

      return function applyMatrix4(matrix) {
        // transform of empty box is an empty box.
        if (this.isEmpty()) return this

        // NOTE: I am using a binary pattern to specify all 2^3 combinations below
        points[0].set(this.min.x, this.min.y, this.min.z).applyMatrix4(matrix) // 000
        points[1].set(this.min.x, this.min.y, this.max.z).applyMatrix4(matrix) // 001
        points[2].set(this.min.x, this.max.y, this.min.z).applyMatrix4(matrix) // 010
        points[3].set(this.min.x, this.max.y, this.max.z).applyMatrix4(matrix) // 011
        points[4].set(this.max.x, this.min.y, this.min.z).applyMatrix4(matrix) // 100
        points[5].set(this.max.x, this.min.y, this.max.z).applyMatrix4(matrix) // 101
        points[6].set(this.max.x, this.max.y, this.min.z).applyMatrix4(matrix) // 110
        points[7].set(this.max.x, this.max.y, this.max.z).applyMatrix4(matrix) // 111

        this.setFromPoints(points)

        return this
      }
    })(),

    translate: function (offset) {
      this.min.add(offset)
      this.max.add(offset)

      return this
    },

    equals: function (box) {
      return box.min.equals(this.min) && box.max.equals(this.max)
    }
  })

  /**
   * @author bhouston / http://clara.io
   * @author mrdoob / http://mrdoob.com/
   */

  function Sphere(center, radius) {
    this.center = center !== undefined ? center : new Vector3()
    this.radius = radius !== undefined ? radius : 0
  }

  Object.assign(Sphere.prototype, {
    set: function (center, radius) {
      this.center.copy(center)
      this.radius = radius

      return this
    },

    setFromPoints: (function () {
      var box = new Box3()

      return function setFromPoints(points, optionalCenter) {
        var center = this.center

        if (optionalCenter !== undefined) {
          center.copy(optionalCenter)
        } else {
          box.setFromPoints(points).getCenter(center)
        }

        var maxRadiusSq = 0

        for (var i = 0, il = points.length; i < il; i++) {
          maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(points[i]))
        }

        this.radius = Math.sqrt(maxRadiusSq)

        return this
      }
    })(),

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (sphere) {
      this.center.copy(sphere.center)
      this.radius = sphere.radius

      return this
    },

    empty: function () {
      return this.radius <= 0
    },

    containsPoint: function (point) {
      return point.distanceToSquared(this.center) <= this.radius * this.radius
    },

    distanceToPoint: function (point) {
      return point.distanceTo(this.center) - this.radius
    },

    intersectsSphere: function (sphere) {
      var radiusSum = this.radius + sphere.radius

      return sphere.center.distanceToSquared(this.center) <= radiusSum * radiusSum
    },

    intersectsBox: function (box) {
      return box.intersectsSphere(this)
    },

    intersectsPlane: function (plane) {
      return Math.abs(plane.distanceToPoint(this.center)) <= this.radius
    },

    clampPoint: function (point, optionalTarget) {
      var deltaLengthSq = this.center.distanceToSquared(point)

      var result = optionalTarget || new Vector3()

      result.copy(point)

      if (deltaLengthSq > this.radius * this.radius) {
        result.sub(this.center).normalize()
        result.multiplyScalar(this.radius).add(this.center)
      }

      return result
    },

    getBoundingBox: function (optionalTarget) {
      var box = optionalTarget || new Box3()

      box.set(this.center, this.center)
      box.expandByScalar(this.radius)

      return box
    },

    applyMatrix4: function (matrix) {
      this.center.applyMatrix4(matrix)
      this.radius = this.radius * matrix.getMaxScaleOnAxis()

      return this
    },

    translate: function (offset) {
      this.center.add(offset)

      return this
    },

    equals: function (sphere) {
      return sphere.center.equals(this.center) && sphere.radius === this.radius
    }
  })

  /**
   * @author bhouston / http://clara.io
   */

  function Plane(normal, constant) {
    // normal is assumed to be normalized

    this.normal = normal !== undefined ? normal : new Vector3(1, 0, 0)
    this.constant = constant !== undefined ? constant : 0
  }

  Object.assign(Plane.prototype, {
    set: function (normal, constant) {
      this.normal.copy(normal)
      this.constant = constant

      return this
    },

    setComponents: function (x, y, z, w) {
      this.normal.set(x, y, z)
      this.constant = w

      return this
    },

    setFromNormalAndCoplanarPoint: function (normal, point) {
      this.normal.copy(normal)
      this.constant = -point.dot(this.normal)

      return this
    },

    setFromCoplanarPoints: (function () {
      var v1 = new Vector3()
      var v2 = new Vector3()

      return function setFromCoplanarPoints(a, b, c) {
        var normal = v1.subVectors(c, b).cross(v2.subVectors(a, b)).normalize()

        // Q: should an error be thrown if normal is zero (e.g. degenerate plane)?

        this.setFromNormalAndCoplanarPoint(normal, a)

        return this
      }
    })(),

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (plane) {
      this.normal.copy(plane.normal)
      this.constant = plane.constant

      return this
    },

    normalize: function () {
      // Note: will lead to a divide by zero if the plane is invalid.

      var inverseNormalLength = 1.0 / this.normal.length()
      this.normal.multiplyScalar(inverseNormalLength)
      this.constant *= inverseNormalLength

      return this
    },

    negate: function () {
      this.constant *= -1
      this.normal.negate()

      return this
    },

    distanceToPoint: function (point) {
      return this.normal.dot(point) + this.constant
    },

    distanceToSphere: function (sphere) {
      return this.distanceToPoint(sphere.center) - sphere.radius
    },

    projectPoint: function (point, optionalTarget) {
      var result = optionalTarget || new Vector3()

      return result.copy(this.normal).multiplyScalar(-this.distanceToPoint(point)).add(point)
    },

    intersectLine: (function () {
      var v1 = new Vector3()

      return function intersectLine(line, optionalTarget) {
        var result = optionalTarget || new Vector3()

        var direction = line.delta(v1)

        var denominator = this.normal.dot(direction)

        if (denominator === 0) {
          // line is coplanar, return origin
          if (this.distanceToPoint(line.start) === 0) {
            return result.copy(line.start)
          }

          // Unsure if this is the correct method to handle this case.
          return undefined
        }

        var t = -(line.start.dot(this.normal) + this.constant) / denominator

        if (t < 0 || t > 1) {
          return undefined
        }

        return result.copy(direction).multiplyScalar(t).add(line.start)
      }
    })(),

    intersectsLine: function (line) {
      // Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.

      var startSign = this.distanceToPoint(line.start)
      var endSign = this.distanceToPoint(line.end)

      return (startSign < 0 && endSign > 0) || (endSign < 0 && startSign > 0)
    },

    intersectsBox: function (box) {
      return box.intersectsPlane(this)
    },

    intersectsSphere: function (sphere) {
      return sphere.intersectsPlane(this)
    },

    coplanarPoint: function (optionalTarget) {
      var result = optionalTarget || new Vector3()

      return result.copy(this.normal).multiplyScalar(-this.constant)
    },

    applyMatrix4: (function () {
      var v1 = new Vector3()
      var m1 = new Matrix3()

      return function applyMatrix4(matrix, optionalNormalMatrix) {
        var normalMatrix = optionalNormalMatrix || m1.getNormalMatrix(matrix)

        var referencePoint = this.coplanarPoint(v1).applyMatrix4(matrix)

        var normal = this.normal.applyMatrix3(normalMatrix).normalize()

        this.constant = -referencePoint.dot(normal)

        return this
      }
    })(),

    translate: function (offset) {
      this.constant -= offset.dot(this.normal)

      return this
    },

    equals: function (plane) {
      return plane.normal.equals(this.normal) && plane.constant === this.constant
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   * @author bhouston / http://clara.io
   */

  function Frustum(p0, p1, p2, p3, p4, p5) {
    this.planes = [
      p0 !== undefined ? p0 : new Plane(),
      p1 !== undefined ? p1 : new Plane(),
      p2 !== undefined ? p2 : new Plane(),
      p3 !== undefined ? p3 : new Plane(),
      p4 !== undefined ? p4 : new Plane(),
      p5 !== undefined ? p5 : new Plane()
    ]
  }

  Object.assign(Frustum.prototype, {
    set: function (p0, p1, p2, p3, p4, p5) {
      var planes = this.planes

      planes[0].copy(p0)
      planes[1].copy(p1)
      planes[2].copy(p2)
      planes[3].copy(p3)
      planes[4].copy(p4)
      planes[5].copy(p5)

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (frustum) {
      var planes = this.planes

      for (var i = 0; i < 6; i++) {
        planes[i].copy(frustum.planes[i])
      }

      return this
    },

    setFromMatrix: function (m) {
      var planes = this.planes
      var me = m.elements
      var me0 = me[0],
        me1 = me[1],
        me2 = me[2],
        me3 = me[3]
      var me4 = me[4],
        me5 = me[5],
        me6 = me[6],
        me7 = me[7]
      var me8 = me[8],
        me9 = me[9],
        me10 = me[10],
        me11 = me[11]
      var me12 = me[12],
        me13 = me[13],
        me14 = me[14],
        me15 = me[15]

      planes[0].setComponents(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize()
      planes[1].setComponents(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize()
      planes[2].setComponents(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize()
      planes[3].setComponents(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize()
      planes[4].setComponents(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize()
      planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize()

      return this
    },

    intersectsObject: (function () {
      var sphere = new Sphere()

      return function intersectsObject(object) {
        var geometry = object.geometry

        if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

        sphere.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld)

        return this.intersectsSphere(sphere)
      }
    })(),

    intersectsSprite: (function () {
      var sphere = new Sphere()

      return function intersectsSprite(sprite) {
        sphere.center.set(0, 0, 0)
        sphere.radius = 0.7071067811865476
        sphere.applyMatrix4(sprite.matrixWorld)

        return this.intersectsSphere(sphere)
      }
    })(),

    intersectsSphere: function (sphere) {
      var planes = this.planes
      var center = sphere.center
      var negRadius = -sphere.radius

      for (var i = 0; i < 6; i++) {
        var distance = planes[i].distanceToPoint(center)

        if (distance < negRadius) {
          return false
        }
      }

      return true
    },

    intersectsBox: (function () {
      var p1 = new Vector3(),
        p2 = new Vector3()

      return function intersectsBox(box) {
        var planes = this.planes

        for (var i = 0; i < 6; i++) {
          var plane = planes[i]

          p1.x = plane.normal.x > 0 ? box.min.x : box.max.x
          p2.x = plane.normal.x > 0 ? box.max.x : box.min.x
          p1.y = plane.normal.y > 0 ? box.min.y : box.max.y
          p2.y = plane.normal.y > 0 ? box.max.y : box.min.y
          p1.z = plane.normal.z > 0 ? box.min.z : box.max.z
          p2.z = plane.normal.z > 0 ? box.max.z : box.min.z

          var d1 = plane.distanceToPoint(p1)
          var d2 = plane.distanceToPoint(p2)

          // if both outside plane, no intersection

          if (d1 < 0 && d2 < 0) {
            return false
          }
        }

        return true
      }
    })(),

    containsPoint: function (point) {
      var planes = this.planes

      for (var i = 0; i < 6; i++) {
        if (planes[i].distanceToPoint(point) < 0) {
          return false
        }
      }

      return true
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLShadowMap(_renderer, _objects, maxTextureSize) {
    var _frustum = new Frustum(),
      _projScreenMatrix = new Matrix4(),
      _shadowMapSize = new Vector2(),
      _maxShadowMapSize = new Vector2(maxTextureSize, maxTextureSize),
      _lookTarget = new Vector3(),
      _lightPositionWorld = new Vector3(),
      _MorphingFlag = 1,
      _SkinningFlag = 2,
      _NumberOfMaterialVariants = (_MorphingFlag | _SkinningFlag) + 1,
      _depthMaterials = new Array(_NumberOfMaterialVariants),
      _distanceMaterials = new Array(_NumberOfMaterialVariants),
      _materialCache = {}

    var shadowSide = { 0: BackSide, 1: FrontSide, 2: DoubleSide }

    var cubeDirections = [
      new Vector3(1, 0, 0),
      new Vector3(-1, 0, 0),
      new Vector3(0, 0, 1),
      new Vector3(0, 0, -1),
      new Vector3(0, 1, 0),
      new Vector3(0, -1, 0)
    ]

    var cubeUps = [
      new Vector3(0, 1, 0),
      new Vector3(0, 1, 0),
      new Vector3(0, 1, 0),
      new Vector3(0, 1, 0),
      new Vector3(0, 0, 1),
      new Vector3(0, 0, -1)
    ]

    var cube2DViewPorts = [
      new Vector4(),
      new Vector4(),
      new Vector4(),
      new Vector4(),
      new Vector4(),
      new Vector4()
    ]

    // init

    for (var i = 0; i !== _NumberOfMaterialVariants; ++i) {
      var useMorphing = (i & _MorphingFlag) !== 0
      var useSkinning = (i & _SkinningFlag) !== 0

      var depthMaterial = new MeshDepthMaterial({
        depthPacking: RGBADepthPacking,

        morphTargets: useMorphing,
        skinning: useSkinning
      })

      _depthMaterials[i] = depthMaterial

      //

      var distanceMaterial = new MeshDistanceMaterial({
        morphTargets: useMorphing,
        skinning: useSkinning
      })

      _distanceMaterials[i] = distanceMaterial
    }

    //

    var scope = this

    this.enabled = false

    this.autoUpdate = true
    this.needsUpdate = false

    this.type = PCFShadowMap

    this.render = function (lights, scene, camera) {
      if (scope.enabled === false) return
      if (scope.autoUpdate === false && scope.needsUpdate === false) return

      if (lights.length === 0) return

      // TODO Clean up (needed in case of contextlost)
      var _gl = _renderer.context
      var _state = _renderer.state

      // Set GL state for depth map.
      _state.disable(_gl.BLEND)
      _state.buffers.color.setClear(1, 1, 1, 1)
      _state.buffers.depth.setTest(true)
      _state.setScissorTest(false)

      // render depth map

      var faceCount

      for (var i = 0, il = lights.length; i < il; i++) {
        var light = lights[i]
        var shadow = light.shadow
        var isPointLight = light && light.isPointLight

        if (shadow === undefined) {
          console.warn('THREE.WebGLShadowMap:', light, 'has no shadow.')
          continue
        }

        var shadowCamera = shadow.camera

        _shadowMapSize.copy(shadow.mapSize)
        _shadowMapSize.min(_maxShadowMapSize)

        if (isPointLight) {
          var vpWidth = _shadowMapSize.x
          var vpHeight = _shadowMapSize.y

          // These viewports map a cube-map onto a 2D texture with the
          // following orientation:
          //
          //  xzXZ
          //   y Y
          //
          // X - Positive x direction
          // x - Negative x direction
          // Y - Positive y direction
          // y - Negative y direction
          // Z - Positive z direction
          // z - Negative z direction

          // positive X
          cube2DViewPorts[0].set(vpWidth * 2, vpHeight, vpWidth, vpHeight)
          // negative X
          cube2DViewPorts[1].set(0, vpHeight, vpWidth, vpHeight)
          // positive Z
          cube2DViewPorts[2].set(vpWidth * 3, vpHeight, vpWidth, vpHeight)
          // negative Z
          cube2DViewPorts[3].set(vpWidth, vpHeight, vpWidth, vpHeight)
          // positive Y
          cube2DViewPorts[4].set(vpWidth * 3, 0, vpWidth, vpHeight)
          // negative Y
          cube2DViewPorts[5].set(vpWidth, 0, vpWidth, vpHeight)

          _shadowMapSize.x *= 4.0
          _shadowMapSize.y *= 2.0
        }

        if (shadow.map === null) {
          var pars = { minFilter: NearestFilter, magFilter: NearestFilter, format: RGBAFormat }

          shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars)
          shadow.map.texture.name = light.name + '.shadowMap'

          shadowCamera.updateProjectionMatrix()
        }

        if (shadow.isSpotLightShadow) {
          shadow.update(light)
        }

        var shadowMap = shadow.map
        var shadowMatrix = shadow.matrix

        _lightPositionWorld.setFromMatrixPosition(light.matrixWorld)
        shadowCamera.position.copy(_lightPositionWorld)

        if (isPointLight) {
          faceCount = 6

          // for point lights we set the shadow matrix to be a translation-only matrix
          // equal to inverse of the light's position

          shadowMatrix.makeTranslation(
            -_lightPositionWorld.x,
            -_lightPositionWorld.y,
            -_lightPositionWorld.z
          )
        } else {
          faceCount = 1

          _lookTarget.setFromMatrixPosition(light.target.matrixWorld)
          shadowCamera.lookAt(_lookTarget)
          shadowCamera.updateMatrixWorld()

          // compute shadow matrix

          shadowMatrix.set(
            0.5,
            0.0,
            0.0,
            0.5,
            0.0,
            0.5,
            0.0,
            0.5,
            0.0,
            0.0,
            0.5,
            0.5,
            0.0,
            0.0,
            0.0,
            1.0
          )

          shadowMatrix.multiply(shadowCamera.projectionMatrix)
          shadowMatrix.multiply(shadowCamera.matrixWorldInverse)
        }

        _renderer.setRenderTarget(shadowMap)
        _renderer.clear()

        // render shadow map for each cube face (if omni-directional) or
        // run a single pass if not

        for (var face = 0; face < faceCount; face++) {
          if (isPointLight) {
            _lookTarget.copy(shadowCamera.position)
            _lookTarget.add(cubeDirections[face])
            shadowCamera.up.copy(cubeUps[face])
            shadowCamera.lookAt(_lookTarget)
            shadowCamera.updateMatrixWorld()

            var vpDimensions = cube2DViewPorts[face]
            _state.viewport(vpDimensions)
          }

          // update camera matrices and frustum

          _projScreenMatrix.multiplyMatrices(
            shadowCamera.projectionMatrix,
            shadowCamera.matrixWorldInverse
          )
          _frustum.setFromMatrix(_projScreenMatrix)

          // set object matrices & frustum culling

          renderObject(scene, camera, shadowCamera, isPointLight)
        }
      }

      scope.needsUpdate = false
    }

    function getDepthMaterial(
      object,
      material,
      isPointLight,
      lightPositionWorld,
      shadowCameraNear,
      shadowCameraFar
    ) {
      var geometry = object.geometry

      var result = null

      var materialVariants = _depthMaterials
      var customMaterial = object.customDepthMaterial

      if (isPointLight) {
        materialVariants = _distanceMaterials
        customMaterial = object.customDistanceMaterial
      }

      if (!customMaterial) {
        var useMorphing = false

        if (material.morphTargets) {
          if (geometry && geometry.isBufferGeometry) {
            useMorphing =
              geometry.morphAttributes &&
              geometry.morphAttributes.position &&
              geometry.morphAttributes.position.length > 0
          } else if (geometry && geometry.isGeometry) {
            useMorphing = geometry.morphTargets && geometry.morphTargets.length > 0
          }
        }

        if (object.isSkinnedMesh && material.skinning === false) {
          console.warn(
            'THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:',
            object
          )
        }

        var useSkinning = object.isSkinnedMesh && material.skinning

        var variantIndex = 0

        if (useMorphing) variantIndex |= _MorphingFlag
        if (useSkinning) variantIndex |= _SkinningFlag

        result = materialVariants[variantIndex]
      } else {
        result = customMaterial
      }

      if (
        _renderer.localClippingEnabled &&
        material.clipShadows === true &&
        material.clippingPlanes.length !== 0
      ) {
        // in this case we need a unique material instance reflecting the
        // appropriate state

        var keyA = result.uuid,
          keyB = material.uuid

        var materialsForVariant = _materialCache[keyA]

        if (materialsForVariant === undefined) {
          materialsForVariant = {}
          _materialCache[keyA] = materialsForVariant
        }

        var cachedMaterial = materialsForVariant[keyB]

        if (cachedMaterial === undefined) {
          cachedMaterial = result.clone()
          materialsForVariant[keyB] = cachedMaterial
        }

        result = cachedMaterial
      }

      result.visible = material.visible
      result.wireframe = material.wireframe

      result.side = material.shadowSide != null ? material.shadowSide : shadowSide[material.side]

      result.clipShadows = material.clipShadows
      result.clippingPlanes = material.clippingPlanes
      result.clipIntersection = material.clipIntersection

      result.wireframeLinewidth = material.wireframeLinewidth
      result.linewidth = material.linewidth

      if (isPointLight && result.isMeshDistanceMaterial) {
        result.referencePosition.copy(lightPositionWorld)
        result.nearDistance = shadowCameraNear
        result.farDistance = shadowCameraFar
      }

      return result
    }

    function renderObject(object, camera, shadowCamera, isPointLight) {
      if (object.visible === false) return

      var visible = object.layers.test(camera.layers)

      if (visible && (object.isMesh || object.isLine || object.isPoints)) {
        if (object.castShadow && (!object.frustumCulled || _frustum.intersectsObject(object))) {
          object.modelViewMatrix.multiplyMatrices(
            shadowCamera.matrixWorldInverse,
            object.matrixWorld
          )

          var geometry = _objects.update(object)
          var material = object.material

          if (Array.isArray(material)) {
            var groups = geometry.groups

            for (var k = 0, kl = groups.length; k < kl; k++) {
              var group = groups[k]
              var groupMaterial = material[group.materialIndex]

              if (groupMaterial && groupMaterial.visible) {
                var depthMaterial = getDepthMaterial(
                  object,
                  groupMaterial,
                  isPointLight,
                  _lightPositionWorld,
                  shadowCamera.near,
                  shadowCamera.far
                )
                _renderer.renderBufferDirect(
                  shadowCamera,
                  null,
                  geometry,
                  depthMaterial,
                  object,
                  group
                )
              }
            }
          } else if (material.visible) {
            var depthMaterial = getDepthMaterial(
              object,
              material,
              isPointLight,
              _lightPositionWorld,
              shadowCamera.near,
              shadowCamera.far
            )
            _renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, null)
          }
        }
      }

      var children = object.children

      for (var i = 0, l = children.length; i < l; i++) {
        renderObject(children[i], camera, shadowCamera, isPointLight)
      }
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLAttributes(gl) {
    var buffers = {}

    function createBuffer(attribute, bufferType) {
      var array = attribute.array
      var usage = attribute.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW

      var buffer = gl.createBuffer()

      gl.bindBuffer(bufferType, buffer)
      gl.bufferData(bufferType, array, usage)

      attribute.onUploadCallback()

      var type = gl.FLOAT

      if (array instanceof Float32Array) {
        type = gl.FLOAT
      } else if (array instanceof Float64Array) {
        console.warn('THREE.WebGLAttributes: Unsupported data buffer format: Float64Array.')
      } else if (array instanceof Uint16Array) {
        type = gl.UNSIGNED_SHORT
      } else if (array instanceof Int16Array) {
        type = gl.SHORT
      } else if (array instanceof Uint32Array) {
        type = gl.UNSIGNED_INT
      } else if (array instanceof Int32Array) {
        type = gl.INT
      } else if (array instanceof Int8Array) {
        type = gl.BYTE
      } else if (array instanceof Uint8Array) {
        type = gl.UNSIGNED_BYTE
      }

      return {
        buffer: buffer,
        type: type,
        bytesPerElement: array.BYTES_PER_ELEMENT,
        version: attribute.version
      }
    }

    function updateBuffer(buffer, attribute, bufferType) {
      var array = attribute.array
      var updateRange = attribute.updateRange

      gl.bindBuffer(bufferType, buffer)

      if (attribute.dynamic === false) {
        gl.bufferData(bufferType, array, gl.STATIC_DRAW)
      } else if (updateRange.count === -1) {
        // Not using update ranges

        gl.bufferSubData(bufferType, 0, array)
      } else if (updateRange.count === 0) {
        console.error(
          'THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually.'
        )
      } else {
        gl.bufferSubData(
          bufferType,
          updateRange.offset * array.BYTES_PER_ELEMENT,
          array.subarray(updateRange.offset, updateRange.offset + updateRange.count)
        )

        updateRange.count = -1 // reset range
      }
    }

    //

    function get(attribute) {
      if (attribute.isInterleavedBufferAttribute) attribute = attribute.data

      return buffers[attribute.uuid]
    }

    function remove(attribute) {
      if (attribute.isInterleavedBufferAttribute) attribute = attribute.data

      var data = buffers[attribute.uuid]

      if (data) {
        gl.deleteBuffer(data.buffer)

        delete buffers[attribute.uuid]
      }
    }

    function update(attribute, bufferType) {
      if (attribute.isInterleavedBufferAttribute) attribute = attribute.data

      var data = buffers[attribute.uuid]

      if (data === undefined) {
        buffers[attribute.uuid] = createBuffer(attribute, bufferType)
      } else if (data.version < attribute.version) {
        updateBuffer(data.buffer, attribute, bufferType)

        data.version = attribute.version
      }
    }

    return {
      get: get,
      remove: remove,
      update: update
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author WestLangley / http://github.com/WestLangley
   * @author bhouston / http://clara.io
   */

  function Euler(x, y, z, order) {
    this._x = x || 0
    this._y = y || 0
    this._z = z || 0
    this._order = order || Euler.DefaultOrder
  }

  Euler.RotationOrders = ['XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX']

  Euler.DefaultOrder = 'XYZ'

  Object.defineProperties(Euler.prototype, {
    x: {
      get: function () {
        return this._x
      },

      set: function (value) {
        this._x = value
        this.onChangeCallback()
      }
    },

    y: {
      get: function () {
        return this._y
      },

      set: function (value) {
        this._y = value
        this.onChangeCallback()
      }
    },

    z: {
      get: function () {
        return this._z
      },

      set: function (value) {
        this._z = value
        this.onChangeCallback()
      }
    },

    order: {
      get: function () {
        return this._order
      },

      set: function (value) {
        this._order = value
        this.onChangeCallback()
      }
    }
  })

  Object.assign(Euler.prototype, {
    isEuler: true,

    set: function (x, y, z, order) {
      this._x = x
      this._y = y
      this._z = z
      this._order = order || this._order

      this.onChangeCallback()

      return this
    },

    clone: function () {
      return new this.constructor(this._x, this._y, this._z, this._order)
    },

    copy: function (euler) {
      this._x = euler._x
      this._y = euler._y
      this._z = euler._z
      this._order = euler._order

      this.onChangeCallback()

      return this
    },

    setFromRotationMatrix: function (m, order, update) {
      var clamp = _Math.clamp

      // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

      var te = m.elements
      var m11 = te[0],
        m12 = te[4],
        m13 = te[8]
      var m21 = te[1],
        m22 = te[5],
        m23 = te[9]
      var m31 = te[2],
        m32 = te[6],
        m33 = te[10]

      order = order || this._order

      if (order === 'XYZ') {
        this._y = Math.asin(clamp(m13, -1, 1))

        if (Math.abs(m13) < 0.99999) {
          this._x = Math.atan2(-m23, m33)
          this._z = Math.atan2(-m12, m11)
        } else {
          this._x = Math.atan2(m32, m22)
          this._z = 0
        }
      } else if (order === 'YXZ') {
        this._x = Math.asin(-clamp(m23, -1, 1))

        if (Math.abs(m23) < 0.99999) {
          this._y = Math.atan2(m13, m33)
          this._z = Math.atan2(m21, m22)
        } else {
          this._y = Math.atan2(-m31, m11)
          this._z = 0
        }
      } else if (order === 'ZXY') {
        this._x = Math.asin(clamp(m32, -1, 1))

        if (Math.abs(m32) < 0.99999) {
          this._y = Math.atan2(-m31, m33)
          this._z = Math.atan2(-m12, m22)
        } else {
          this._y = 0
          this._z = Math.atan2(m21, m11)
        }
      } else if (order === 'ZYX') {
        this._y = Math.asin(-clamp(m31, -1, 1))

        if (Math.abs(m31) < 0.99999) {
          this._x = Math.atan2(m32, m33)
          this._z = Math.atan2(m21, m11)
        } else {
          this._x = 0
          this._z = Math.atan2(-m12, m22)
        }
      } else if (order === 'YZX') {
        this._z = Math.asin(clamp(m21, -1, 1))

        if (Math.abs(m21) < 0.99999) {
          this._x = Math.atan2(-m23, m22)
          this._y = Math.atan2(-m31, m11)
        } else {
          this._x = 0
          this._y = Math.atan2(m13, m33)
        }
      } else if (order === 'XZY') {
        this._z = Math.asin(-clamp(m12, -1, 1))

        if (Math.abs(m12) < 0.99999) {
          this._x = Math.atan2(m32, m22)
          this._y = Math.atan2(m13, m11)
        } else {
          this._x = Math.atan2(-m23, m33)
          this._y = 0
        }
      } else {
        console.warn('THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order)
      }

      this._order = order

      if (update !== false) this.onChangeCallback()

      return this
    },

    setFromQuaternion: (function () {
      var matrix = new Matrix4()

      return function setFromQuaternion(q, order, update) {
        matrix.makeRotationFromQuaternion(q)

        return this.setFromRotationMatrix(matrix, order, update)
      }
    })(),

    setFromVector3: function (v, order) {
      return this.set(v.x, v.y, v.z, order || this._order)
    },

    reorder: (function () {
      // WARNING: this discards revolution information -bhouston

      var q = new Quaternion()

      return function reorder(newOrder) {
        q.setFromEuler(this)

        return this.setFromQuaternion(q, newOrder)
      }
    })(),

    equals: function (euler) {
      return (
        euler._x === this._x &&
        euler._y === this._y &&
        euler._z === this._z &&
        euler._order === this._order
      )
    },

    fromArray: function (array) {
      this._x = array[0]
      this._y = array[1]
      this._z = array[2]
      if (array[3] !== undefined) this._order = array[3]

      this.onChangeCallback()

      return this
    },

    toArray: function (array, offset) {
      if (array === undefined) array = []
      if (offset === undefined) offset = 0

      array[offset] = this._x
      array[offset + 1] = this._y
      array[offset + 2] = this._z
      array[offset + 3] = this._order

      return array
    },

    toVector3: function (optionalResult) {
      if (optionalResult) {
        return optionalResult.set(this._x, this._y, this._z)
      } else {
        return new Vector3(this._x, this._y, this._z)
      }
    },

    onChange: function (callback) {
      this.onChangeCallback = callback

      return this
    },

    onChangeCallback: function () {}
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function Layers() {
    this.mask = 1 | 0
  }

  Object.assign(Layers.prototype, {
    set: function (channel) {
      this.mask = (1 << channel) | 0
    },

    enable: function (channel) {
      this.mask |= (1 << channel) | 0
    },

    toggle: function (channel) {
      this.mask ^= (1 << channel) | 0
    },

    disable: function (channel) {
      this.mask &= ~((1 << channel) | 0)
    },

    test: function (layers) {
      return (this.mask & layers.mask) !== 0
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   * @author WestLangley / http://github.com/WestLangley
   * @author elephantatwork / www.elephantatwork.ch
   */

  var object3DId = 0

  function Object3D() {
    Object.defineProperty(this, 'id', { value: object3DId++ })

    this.uuid = _Math.generateUUID()

    this.name = ''
    this.type = 'Object3D'

    this.parent = null
    this.children = []

    this.up = Object3D.DefaultUp.clone()

    var position = new Vector3()
    var rotation = new Euler()
    var quaternion = new Quaternion()
    var scale = new Vector3(1, 1, 1)

    function onRotationChange() {
      quaternion.setFromEuler(rotation, false)
    }

    function onQuaternionChange() {
      rotation.setFromQuaternion(quaternion, undefined, false)
    }

    rotation.onChange(onRotationChange)
    quaternion.onChange(onQuaternionChange)

    Object.defineProperties(this, {
      position: {
        enumerable: true,
        value: position
      },
      rotation: {
        enumerable: true,
        value: rotation
      },
      quaternion: {
        enumerable: true,
        value: quaternion
      },
      scale: {
        enumerable: true,
        value: scale
      },
      modelViewMatrix: {
        value: new Matrix4()
      },
      normalMatrix: {
        value: new Matrix3()
      }
    })

    this.matrix = new Matrix4()
    this.matrixWorld = new Matrix4()

    this.matrixAutoUpdate = Object3D.DefaultMatrixAutoUpdate
    this.matrixWorldNeedsUpdate = false

    this.layers = new Layers()
    this.visible = true

    this.castShadow = false
    this.receiveShadow = false

    this.frustumCulled = true
    this.renderOrder = 0

    this.userData = {}
  }

  Object3D.DefaultUp = new Vector3(0, 1, 0)
  Object3D.DefaultMatrixAutoUpdate = true

  Object3D.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Object3D,

    isObject3D: true,

    onBeforeRender: function () {},
    onAfterRender: function () {},

    applyMatrix: function (matrix) {
      this.matrix.multiplyMatrices(matrix, this.matrix)

      this.matrix.decompose(this.position, this.quaternion, this.scale)
    },

    applyQuaternion: function (q) {
      this.quaternion.premultiply(q)

      return this
    },

    setRotationFromAxisAngle: function (axis, angle) {
      // assumes axis is normalized

      this.quaternion.setFromAxisAngle(axis, angle)
    },

    setRotationFromEuler: function (euler) {
      this.quaternion.setFromEuler(euler, true)
    },

    setRotationFromMatrix: function (m) {
      // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

      this.quaternion.setFromRotationMatrix(m)
    },

    setRotationFromQuaternion: function (q) {
      // assumes q is normalized

      this.quaternion.copy(q)
    },

    rotateOnAxis: (function () {
      // rotate object on axis in object space
      // axis is assumed to be normalized

      var q1 = new Quaternion()

      return function rotateOnAxis(axis, angle) {
        q1.setFromAxisAngle(axis, angle)

        this.quaternion.multiply(q1)

        return this
      }
    })(),

    rotateOnWorldAxis: (function () {
      // rotate object on axis in world space
      // axis is assumed to be normalized
      // method assumes no rotated parent

      var q1 = new Quaternion()

      return function rotateOnWorldAxis(axis, angle) {
        q1.setFromAxisAngle(axis, angle)

        this.quaternion.premultiply(q1)

        return this
      }
    })(),

    rotateX: (function () {
      var v1 = new Vector3(1, 0, 0)

      return function rotateX(angle) {
        return this.rotateOnAxis(v1, angle)
      }
    })(),

    rotateY: (function () {
      var v1 = new Vector3(0, 1, 0)

      return function rotateY(angle) {
        return this.rotateOnAxis(v1, angle)
      }
    })(),

    rotateZ: (function () {
      var v1 = new Vector3(0, 0, 1)

      return function rotateZ(angle) {
        return this.rotateOnAxis(v1, angle)
      }
    })(),

    translateOnAxis: (function () {
      // translate object by distance along axis in object space
      // axis is assumed to be normalized

      var v1 = new Vector3()

      return function translateOnAxis(axis, distance) {
        v1.copy(axis).applyQuaternion(this.quaternion)

        this.position.add(v1.multiplyScalar(distance))

        return this
      }
    })(),

    translateX: (function () {
      var v1 = new Vector3(1, 0, 0)

      return function translateX(distance) {
        return this.translateOnAxis(v1, distance)
      }
    })(),

    translateY: (function () {
      var v1 = new Vector3(0, 1, 0)

      return function translateY(distance) {
        return this.translateOnAxis(v1, distance)
      }
    })(),

    translateZ: (function () {
      var v1 = new Vector3(0, 0, 1)

      return function translateZ(distance) {
        return this.translateOnAxis(v1, distance)
      }
    })(),

    localToWorld: function (vector) {
      return vector.applyMatrix4(this.matrixWorld)
    },

    worldToLocal: (function () {
      var m1 = new Matrix4()

      return function worldToLocal(vector) {
        return vector.applyMatrix4(m1.getInverse(this.matrixWorld))
      }
    })(),

    lookAt: (function () {
      // This method does not support objects with rotated and/or translated parent(s)

      var m1 = new Matrix4()
      var vector = new Vector3()

      return function lookAt(x, y, z) {
        if (x.isVector3) {
          vector.copy(x)
        } else {
          vector.set(x, y, z)
        }

        if (this.isCamera) {
          m1.lookAt(this.position, vector, this.up)
        } else {
          m1.lookAt(vector, this.position, this.up)
        }

        this.quaternion.setFromRotationMatrix(m1)
      }
    })(),

    add: function (object) {
      if (arguments.length > 1) {
        for (var i = 0; i < arguments.length; i++) {
          this.add(arguments[i])
        }

        return this
      }

      if (object === this) {
        console.error("THREE.Object3D.add: object can't be added as a child of itself.", object)
        return this
      }

      if (object && object.isObject3D) {
        if (object.parent !== null) {
          object.parent.remove(object)
        }

        object.parent = this
        object.dispatchEvent({ type: 'added' })

        this.children.push(object)
      } else {
        console.error('THREE.Object3D.add: object not an instance of THREE.Object3D.', object)
      }

      return this
    },

    remove: function (object) {
      if (arguments.length > 1) {
        for (var i = 0; i < arguments.length; i++) {
          this.remove(arguments[i])
        }

        return this
      }

      var index = this.children.indexOf(object)

      if (index !== -1) {
        object.parent = null

        object.dispatchEvent({ type: 'removed' })

        this.children.splice(index, 1)
      }

      return this
    },

    getObjectById: function (id) {
      return this.getObjectByProperty('id', id)
    },

    getObjectByName: function (name) {
      return this.getObjectByProperty('name', name)
    },

    getObjectByProperty: function (name, value) {
      if (this[name] === value) return this

      for (var i = 0, l = this.children.length; i < l; i++) {
        var child = this.children[i]
        var object = child.getObjectByProperty(name, value)

        if (object !== undefined) {
          return object
        }
      }

      return undefined
    },

    getWorldPosition: function (optionalTarget) {
      var result = optionalTarget || new Vector3()

      this.updateMatrixWorld(true)

      return result.setFromMatrixPosition(this.matrixWorld)
    },

    getWorldQuaternion: (function () {
      var position = new Vector3()
      var scale = new Vector3()

      return function getWorldQuaternion(optionalTarget) {
        var result = optionalTarget || new Quaternion()

        this.updateMatrixWorld(true)

        this.matrixWorld.decompose(position, result, scale)

        return result
      }
    })(),

    getWorldRotation: (function () {
      var quaternion = new Quaternion()

      return function getWorldRotation(optionalTarget) {
        var result = optionalTarget || new Euler()

        this.getWorldQuaternion(quaternion)

        return result.setFromQuaternion(quaternion, this.rotation.order, false)
      }
    })(),

    getWorldScale: (function () {
      var position = new Vector3()
      var quaternion = new Quaternion()

      return function getWorldScale(optionalTarget) {
        var result = optionalTarget || new Vector3()

        this.updateMatrixWorld(true)

        this.matrixWorld.decompose(position, quaternion, result)

        return result
      }
    })(),

    getWorldDirection: (function () {
      var quaternion = new Quaternion()

      return function getWorldDirection(optionalTarget) {
        var result = optionalTarget || new Vector3()

        this.getWorldQuaternion(quaternion)

        return result.set(0, 0, 1).applyQuaternion(quaternion)
      }
    })(),

    raycast: function () {},

    traverse: function (callback) {
      callback(this)

      var children = this.children

      for (var i = 0, l = children.length; i < l; i++) {
        children[i].traverse(callback)
      }
    },

    traverseVisible: function (callback) {
      if (this.visible === false) return

      callback(this)

      var children = this.children

      for (var i = 0, l = children.length; i < l; i++) {
        children[i].traverseVisible(callback)
      }
    },

    traverseAncestors: function (callback) {
      var parent = this.parent

      if (parent !== null) {
        callback(parent)

        parent.traverseAncestors(callback)
      }
    },

    updateMatrix: function () {
      this.matrix.compose(this.position, this.quaternion, this.scale)

      this.matrixWorldNeedsUpdate = true
    },

    updateMatrixWorld: function (force) {
      if (this.matrixAutoUpdate) this.updateMatrix()

      if (this.matrixWorldNeedsUpdate || force) {
        if (this.parent === null) {
          this.matrixWorld.copy(this.matrix)
        } else {
          this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix)
        }

        this.matrixWorldNeedsUpdate = false

        force = true
      }

      // update children

      var children = this.children

      for (var i = 0, l = children.length; i < l; i++) {
        children[i].updateMatrixWorld(force)
      }
    },

    toJSON: function (meta) {
      // meta is a string when called from JSON.stringify
      var isRootObject = meta === undefined || typeof meta === 'string'

      var output = {}

      // meta is a hash used to collect geometries, materials.
      // not providing it implies that this is the root object
      // being serialized.
      if (isRootObject) {
        // initialize meta obj
        meta = {
          geometries: {},
          materials: {},
          textures: {},
          images: {},
          shapes: {}
        }

        output.metadata = {
          version: 4.5,
          type: 'Object',
          generator: 'Object3D.toJSON'
        }
      }

      // standard Object3D serialization

      var object = {}

      object.uuid = this.uuid
      object.type = this.type

      if (this.name !== '') object.name = this.name
      if (this.castShadow === true) object.castShadow = true
      if (this.receiveShadow === true) object.receiveShadow = true
      if (this.visible === false) object.visible = false
      if (JSON.stringify(this.userData) !== '{}') object.userData = this.userData

      object.matrix = this.matrix.toArray()

      //

      function serialize(library, element) {
        if (library[element.uuid] === undefined) {
          library[element.uuid] = element.toJSON(meta)
        }

        return element.uuid
      }

      if (this.geometry !== undefined) {
        object.geometry = serialize(meta.geometries, this.geometry)

        var parameters = this.geometry.parameters

        if (parameters !== undefined && parameters.shapes !== undefined) {
          var shapes = parameters.shapes

          if (Array.isArray(shapes)) {
            for (var i = 0, l = shapes.length; i < l; i++) {
              var shape = shapes[i]

              serialize(meta.shapes, shape)
            }
          } else {
            serialize(meta.shapes, shapes)
          }
        }
      }

      if (this.material !== undefined) {
        if (Array.isArray(this.material)) {
          var uuids = []

          for (var i = 0, l = this.material.length; i < l; i++) {
            uuids.push(serialize(meta.materials, this.material[i]))
          }

          object.material = uuids
        } else {
          object.material = serialize(meta.materials, this.material)
        }
      }

      //

      if (this.children.length > 0) {
        object.children = []

        for (var i = 0; i < this.children.length; i++) {
          object.children.push(this.children[i].toJSON(meta).object)
        }
      }

      if (isRootObject) {
        var geometries = extractFromCache(meta.geometries)
        var materials = extractFromCache(meta.materials)
        var textures = extractFromCache(meta.textures)
        var images = extractFromCache(meta.images)
        var shapes = extractFromCache(meta.shapes)

        if (geometries.length > 0) output.geometries = geometries
        if (materials.length > 0) output.materials = materials
        if (textures.length > 0) output.textures = textures
        if (images.length > 0) output.images = images
        if (shapes.length > 0) output.shapes = shapes
      }

      output.object = object

      return output

      // extract data from the cache hash
      // remove metadata on each item
      // and return as array
      function extractFromCache(cache) {
        var values = []
        for (var key in cache) {
          var data = cache[key]
          delete data.metadata
          values.push(data)
        }
        return values
      }
    },

    clone: function (recursive) {
      return new this.constructor().copy(this, recursive)
    },

    copy: function (source, recursive) {
      if (recursive === undefined) recursive = true

      this.name = source.name

      this.up.copy(source.up)

      this.position.copy(source.position)
      this.quaternion.copy(source.quaternion)
      this.scale.copy(source.scale)

      this.matrix.copy(source.matrix)
      this.matrixWorld.copy(source.matrixWorld)

      this.matrixAutoUpdate = source.matrixAutoUpdate
      this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate

      this.layers.mask = source.layers.mask
      this.visible = source.visible

      this.castShadow = source.castShadow
      this.receiveShadow = source.receiveShadow

      this.frustumCulled = source.frustumCulled
      this.renderOrder = source.renderOrder

      this.userData = JSON.parse(JSON.stringify(source.userData))

      if (recursive === true) {
        for (var i = 0; i < source.children.length; i++) {
          var child = source.children[i]
          this.add(child.clone())
        }
      }

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author mikael emtinger / http://gomo.se/
   * @author WestLangley / http://github.com/WestLangley
   */

  function Camera() {
    Object3D.call(this)

    this.type = 'Camera'

    this.matrixWorldInverse = new Matrix4()
    this.projectionMatrix = new Matrix4()
  }

  Camera.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Camera,

    isCamera: true,

    copy: function (source, recursive) {
      Object3D.prototype.copy.call(this, source, recursive)

      this.matrixWorldInverse.copy(source.matrixWorldInverse)
      this.projectionMatrix.copy(source.projectionMatrix)

      return this
    },

    getWorldDirection: (function () {
      var quaternion = new Quaternion()

      return function getWorldDirection(optionalTarget) {
        var result = optionalTarget || new Vector3()

        this.getWorldQuaternion(quaternion)

        return result.set(0, 0, -1).applyQuaternion(quaternion)
      }
    })(),

    updateMatrixWorld: function (force) {
      Object3D.prototype.updateMatrixWorld.call(this, force)

      this.matrixWorldInverse.getInverse(this.matrixWorld)
    },

    clone: function () {
      return new this.constructor().copy(this)
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author arose / http://github.com/arose
   */

  function OrthographicCamera(left, right, top, bottom, near, far) {
    Camera.call(this)

    this.type = 'OrthographicCamera'

    this.zoom = 1
    this.view = null

    this.left = left
    this.right = right
    this.top = top
    this.bottom = bottom

    this.near = near !== undefined ? near : 0.1
    this.far = far !== undefined ? far : 2000

    this.updateProjectionMatrix()
  }

  OrthographicCamera.prototype = Object.assign(Object.create(Camera.prototype), {
    constructor: OrthographicCamera,

    isOrthographicCamera: true,

    copy: function (source, recursive) {
      Camera.prototype.copy.call(this, source, recursive)

      this.left = source.left
      this.right = source.right
      this.top = source.top
      this.bottom = source.bottom
      this.near = source.near
      this.far = source.far

      this.zoom = source.zoom
      this.view = source.view === null ? null : Object.assign({}, source.view)

      return this
    },

    setViewOffset: function (fullWidth, fullHeight, x, y, width, height) {
      if (this.view === null) {
        this.view = {
          enabled: true,
          fullWidth: 1,
          fullHeight: 1,
          offsetX: 0,
          offsetY: 0,
          width: 1,
          height: 1
        }
      }

      this.view.enabled = true
      this.view.fullWidth = fullWidth
      this.view.fullHeight = fullHeight
      this.view.offsetX = x
      this.view.offsetY = y
      this.view.width = width
      this.view.height = height

      this.updateProjectionMatrix()
    },

    clearViewOffset: function () {
      if (this.view !== null) {
        this.view.enabled = false
      }

      this.updateProjectionMatrix()
    },

    updateProjectionMatrix: function () {
      var dx = (this.right - this.left) / (2 * this.zoom)
      var dy = (this.top - this.bottom) / (2 * this.zoom)
      var cx = (this.right + this.left) / 2
      var cy = (this.top + this.bottom) / 2

      var left = cx - dx
      var right = cx + dx
      var top = cy + dy
      var bottom = cy - dy

      if (this.view !== null && this.view.enabled) {
        var zoomW = this.zoom / (this.view.width / this.view.fullWidth)
        var zoomH = this.zoom / (this.view.height / this.view.fullHeight)
        var scaleW = (this.right - this.left) / this.view.width
        var scaleH = (this.top - this.bottom) / this.view.height

        left += scaleW * (this.view.offsetX / zoomW)
        right = left + scaleW * (this.view.width / zoomW)
        top -= scaleH * (this.view.offsetY / zoomH)
        bottom = top - scaleH * (this.view.height / zoomH)
      }

      this.projectionMatrix.makeOrthographic(left, right, top, bottom, this.near, this.far)
    },

    toJSON: function (meta) {
      var data = Object3D.prototype.toJSON.call(this, meta)

      data.object.zoom = this.zoom
      data.object.left = this.left
      data.object.right = this.right
      data.object.top = this.top
      data.object.bottom = this.bottom
      data.object.near = this.near
      data.object.far = this.far

      if (this.view !== null) data.object.view = Object.assign({}, this.view)

      return data
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   */

  function Face3(a, b, c, normal, color, materialIndex) {
    this.a = a
    this.b = b
    this.c = c

    this.normal = normal && normal.isVector3 ? normal : new Vector3()
    this.vertexNormals = Array.isArray(normal) ? normal : []

    this.color = color && color.isColor ? color : new Color()
    this.vertexColors = Array.isArray(color) ? color : []

    this.materialIndex = materialIndex !== undefined ? materialIndex : 0
  }

  Object.assign(Face3.prototype, {
    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (source) {
      this.a = source.a
      this.b = source.b
      this.c = source.c

      this.normal.copy(source.normal)
      this.color.copy(source.color)

      this.materialIndex = source.materialIndex

      for (var i = 0, il = source.vertexNormals.length; i < il; i++) {
        this.vertexNormals[i] = source.vertexNormals[i].clone()
      }

      for (var i = 0, il = source.vertexColors.length; i < il; i++) {
        this.vertexColors[i] = source.vertexColors[i].clone()
      }

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author kile / http://kile.stravaganza.org/
   * @author alteredq / http://alteredqualia.com/
   * @author mikael emtinger / http://gomo.se/
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * @author bhouston / http://clara.io
   */

  var geometryId = 0 // Geometry uses even numbers as Id

  function Geometry() {
    Object.defineProperty(this, 'id', { value: (geometryId += 2) })

    this.uuid = _Math.generateUUID()

    this.name = ''
    this.type = 'Geometry'

    this.vertices = []
    this.colors = []
    this.faces = []
    this.faceVertexUvs = [[]]

    this.morphTargets = []
    this.morphNormals = []

    this.skinWeights = []
    this.skinIndices = []

    this.lineDistances = []

    this.boundingBox = null
    this.boundingSphere = null

    // update flags

    this.elementsNeedUpdate = false
    this.verticesNeedUpdate = false
    this.uvsNeedUpdate = false
    this.normalsNeedUpdate = false
    this.colorsNeedUpdate = false
    this.lineDistancesNeedUpdate = false
    this.groupsNeedUpdate = false
  }

  Geometry.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Geometry,

    isGeometry: true,

    applyMatrix: function (matrix) {
      var normalMatrix = new Matrix3().getNormalMatrix(matrix)

      for (var i = 0, il = this.vertices.length; i < il; i++) {
        var vertex = this.vertices[i]
        vertex.applyMatrix4(matrix)
      }

      for (var i = 0, il = this.faces.length; i < il; i++) {
        var face = this.faces[i]
        face.normal.applyMatrix3(normalMatrix).normalize()

        for (var j = 0, jl = face.vertexNormals.length; j < jl; j++) {
          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
        }
      }

      if (this.boundingBox !== null) {
        this.computeBoundingBox()
      }

      if (this.boundingSphere !== null) {
        this.computeBoundingSphere()
      }

      this.verticesNeedUpdate = true
      this.normalsNeedUpdate = true

      return this
    },

    rotateX: (function () {
      // rotate geometry around world x-axis

      var m1 = new Matrix4()

      return function rotateX(angle) {
        m1.makeRotationX(angle)

        this.applyMatrix(m1)

        return this
      }
    })(),

    rotateY: (function () {
      // rotate geometry around world y-axis

      var m1 = new Matrix4()

      return function rotateY(angle) {
        m1.makeRotationY(angle)

        this.applyMatrix(m1)

        return this
      }
    })(),

    rotateZ: (function () {
      // rotate geometry around world z-axis

      var m1 = new Matrix4()

      return function rotateZ(angle) {
        m1.makeRotationZ(angle)

        this.applyMatrix(m1)

        return this
      }
    })(),

    translate: (function () {
      // translate geometry

      var m1 = new Matrix4()

      return function translate(x, y, z) {
        m1.makeTranslation(x, y, z)

        this.applyMatrix(m1)

        return this
      }
    })(),

    scale: (function () {
      // scale geometry

      var m1 = new Matrix4()

      return function scale(x, y, z) {
        m1.makeScale(x, y, z)

        this.applyMatrix(m1)

        return this
      }
    })(),

    lookAt: (function () {
      var obj = new Object3D()

      return function lookAt(vector) {
        obj.lookAt(vector)

        obj.updateMatrix()

        this.applyMatrix(obj.matrix)
      }
    })(),

    fromBufferGeometry: function (geometry) {
      var scope = this

      var indices = geometry.index !== null ? geometry.index.array : undefined
      var attributes = geometry.attributes

      var positions = attributes.position.array
      var normals = attributes.normal !== undefined ? attributes.normal.array : undefined
      var colors = attributes.color !== undefined ? attributes.color.array : undefined
      var uvs = attributes.uv !== undefined ? attributes.uv.array : undefined
      var uvs2 = attributes.uv2 !== undefined ? attributes.uv2.array : undefined

      if (uvs2 !== undefined) this.faceVertexUvs[1] = []

      var tempNormals = []
      var tempUVs = []
      var tempUVs2 = []

      for (var i = 0, j = 0; i < positions.length; i += 3, j += 2) {
        scope.vertices.push(new Vector3(positions[i], positions[i + 1], positions[i + 2]))

        if (normals !== undefined) {
          tempNormals.push(new Vector3(normals[i], normals[i + 1], normals[i + 2]))
        }

        if (colors !== undefined) {
          scope.colors.push(new Color(colors[i], colors[i + 1], colors[i + 2]))
        }

        if (uvs !== undefined) {
          tempUVs.push(new Vector2(uvs[j], uvs[j + 1]))
        }

        if (uvs2 !== undefined) {
          tempUVs2.push(new Vector2(uvs2[j], uvs2[j + 1]))
        }
      }

      function addFace(a, b, c, materialIndex) {
        var vertexNormals =
          normals !== undefined
            ? [tempNormals[a].clone(), tempNormals[b].clone(), tempNormals[c].clone()]
            : []
        var vertexColors =
          colors !== undefined
            ? [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
            : []

        var face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)

        scope.faces.push(face)

        if (uvs !== undefined) {
          scope.faceVertexUvs[0].push([tempUVs[a].clone(), tempUVs[b].clone(), tempUVs[c].clone()])
        }

        if (uvs2 !== undefined) {
          scope.faceVertexUvs[1].push([
            tempUVs2[a].clone(),
            tempUVs2[b].clone(),
            tempUVs2[c].clone()
          ])
        }
      }

      var groups = geometry.groups

      if (groups.length > 0) {
        for (var i = 0; i < groups.length; i++) {
          var group = groups[i]

          var start = group.start
          var count = group.count

          for (var j = start, jl = start + count; j < jl; j += 3) {
            if (indices !== undefined) {
              addFace(indices[j], indices[j + 1], indices[j + 2], group.materialIndex)
            } else {
              addFace(j, j + 1, j + 2, group.materialIndex)
            }
          }
        }
      } else {
        if (indices !== undefined) {
          for (var i = 0; i < indices.length; i += 3) {
            addFace(indices[i], indices[i + 1], indices[i + 2])
          }
        } else {
          for (var i = 0; i < positions.length / 3; i += 3) {
            addFace(i, i + 1, i + 2)
          }
        }
      }

      this.computeFaceNormals()

      if (geometry.boundingBox !== null) {
        this.boundingBox = geometry.boundingBox.clone()
      }

      if (geometry.boundingSphere !== null) {
        this.boundingSphere = geometry.boundingSphere.clone()
      }

      return this
    },

    center: function () {
      this.computeBoundingBox()

      var offset = this.boundingBox.getCenter().negate()

      this.translate(offset.x, offset.y, offset.z)

      return offset
    },

    normalize: function () {
      this.computeBoundingSphere()

      var center = this.boundingSphere.center
      var radius = this.boundingSphere.radius

      var s = radius === 0 ? 1 : 1.0 / radius

      var matrix = new Matrix4()
      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)

      this.applyMatrix(matrix)

      return this
    },

    computeFaceNormals: function () {
      var cb = new Vector3(),
        ab = new Vector3()

      for (var f = 0, fl = this.faces.length; f < fl; f++) {
        var face = this.faces[f]

        var vA = this.vertices[face.a]
        var vB = this.vertices[face.b]
        var vC = this.vertices[face.c]

        cb.subVectors(vC, vB)
        ab.subVectors(vA, vB)
        cb.cross(ab)

        cb.normalize()

        face.normal.copy(cb)
      }
    },

    computeVertexNormals: function (areaWeighted) {
      if (areaWeighted === undefined) areaWeighted = true

      var v, vl, f, fl, face, vertices

      vertices = new Array(this.vertices.length)

      for (v = 0, vl = this.vertices.length; v < vl; v++) {
        vertices[v] = new Vector3()
      }

      if (areaWeighted) {
        // vertex normals weighted by triangle areas
        // http://www.iquilezles.org/www/articles/normals/normals.htm

        var vA, vB, vC
        var cb = new Vector3(),
          ab = new Vector3()

        for (f = 0, fl = this.faces.length; f < fl; f++) {
          face = this.faces[f]

          vA = this.vertices[face.a]
          vB = this.vertices[face.b]
          vC = this.vertices[face.c]

          cb.subVectors(vC, vB)
          ab.subVectors(vA, vB)
          cb.cross(ab)

          vertices[face.a].add(cb)
          vertices[face.b].add(cb)
          vertices[face.c].add(cb)
        }
      } else {
        this.computeFaceNormals()

        for (f = 0, fl = this.faces.length; f < fl; f++) {
          face = this.faces[f]

          vertices[face.a].add(face.normal)
          vertices[face.b].add(face.normal)
          vertices[face.c].add(face.normal)
        }
      }

      for (v = 0, vl = this.vertices.length; v < vl; v++) {
        vertices[v].normalize()
      }

      for (f = 0, fl = this.faces.length; f < fl; f++) {
        face = this.faces[f]

        var vertexNormals = face.vertexNormals

        if (vertexNormals.length === 3) {
          vertexNormals[0].copy(vertices[face.a])
          vertexNormals[1].copy(vertices[face.b])
          vertexNormals[2].copy(vertices[face.c])
        } else {
          vertexNormals[0] = vertices[face.a].clone()
          vertexNormals[1] = vertices[face.b].clone()
          vertexNormals[2] = vertices[face.c].clone()
        }
      }

      if (this.faces.length > 0) {
        this.normalsNeedUpdate = true
      }
    },

    computeFlatVertexNormals: function () {
      var f, fl, face

      this.computeFaceNormals()

      for (f = 0, fl = this.faces.length; f < fl; f++) {
        face = this.faces[f]

        var vertexNormals = face.vertexNormals

        if (vertexNormals.length === 3) {
          vertexNormals[0].copy(face.normal)
          vertexNormals[1].copy(face.normal)
          vertexNormals[2].copy(face.normal)
        } else {
          vertexNormals[0] = face.normal.clone()
          vertexNormals[1] = face.normal.clone()
          vertexNormals[2] = face.normal.clone()
        }
      }

      if (this.faces.length > 0) {
        this.normalsNeedUpdate = true
      }
    },

    computeMorphNormals: function () {
      var i, il, f, fl, face

      // save original normals
      // - create temp variables on first access
      //   otherwise just copy (for faster repeated calls)

      for (f = 0, fl = this.faces.length; f < fl; f++) {
        face = this.faces[f]

        if (!face.__originalFaceNormal) {
          face.__originalFaceNormal = face.normal.clone()
        } else {
          face.__originalFaceNormal.copy(face.normal)
        }

        if (!face.__originalVertexNormals) face.__originalVertexNormals = []

        for (i = 0, il = face.vertexNormals.length; i < il; i++) {
          if (!face.__originalVertexNormals[i]) {
            face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
          } else {
            face.__originalVertexNormals[i].copy(face.vertexNormals[i])
          }
        }
      }

      // use temp geometry to compute face and vertex normals for each morph

      var tmpGeo = new Geometry()
      tmpGeo.faces = this.faces

      for (i = 0, il = this.morphTargets.length; i < il; i++) {
        // create on first access

        if (!this.morphNormals[i]) {
          this.morphNormals[i] = {}
          this.morphNormals[i].faceNormals = []
          this.morphNormals[i].vertexNormals = []

          var dstNormalsFace = this.morphNormals[i].faceNormals
          var dstNormalsVertex = this.morphNormals[i].vertexNormals

          var faceNormal, vertexNormals

          for (f = 0, fl = this.faces.length; f < fl; f++) {
            faceNormal = new Vector3()
            vertexNormals = { a: new Vector3(), b: new Vector3(), c: new Vector3() }

            dstNormalsFace.push(faceNormal)
            dstNormalsVertex.push(vertexNormals)
          }
        }

        var morphNormals = this.morphNormals[i]

        // set vertices to morph target

        tmpGeo.vertices = this.morphTargets[i].vertices

        // compute morph normals

        tmpGeo.computeFaceNormals()
        tmpGeo.computeVertexNormals()

        // store morph normals

        var faceNormal, vertexNormals

        for (f = 0, fl = this.faces.length; f < fl; f++) {
          face = this.faces[f]

          faceNormal = morphNormals.faceNormals[f]
          vertexNormals = morphNormals.vertexNormals[f]

          faceNormal.copy(face.normal)

          vertexNormals.a.copy(face.vertexNormals[0])
          vertexNormals.b.copy(face.vertexNormals[1])
          vertexNormals.c.copy(face.vertexNormals[2])
        }
      }

      // restore original normals

      for (f = 0, fl = this.faces.length; f < fl; f++) {
        face = this.faces[f]

        face.normal = face.__originalFaceNormal
        face.vertexNormals = face.__originalVertexNormals
      }
    },

    computeBoundingBox: function () {
      if (this.boundingBox === null) {
        this.boundingBox = new Box3()
      }

      this.boundingBox.setFromPoints(this.vertices)
    },

    computeBoundingSphere: function () {
      if (this.boundingSphere === null) {
        this.boundingSphere = new Sphere()
      }

      this.boundingSphere.setFromPoints(this.vertices)
    },

    merge: function (geometry, matrix, materialIndexOffset) {
      if (!(geometry && geometry.isGeometry)) {
        console.error(
          'THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.',
          geometry
        )
        return
      }

      var normalMatrix,
        vertexOffset = this.vertices.length,
        vertices1 = this.vertices,
        vertices2 = geometry.vertices,
        faces1 = this.faces,
        faces2 = geometry.faces,
        uvs1 = this.faceVertexUvs[0],
        uvs2 = geometry.faceVertexUvs[0],
        colors1 = this.colors,
        colors2 = geometry.colors

      if (materialIndexOffset === undefined) materialIndexOffset = 0

      if (matrix !== undefined) {
        normalMatrix = new Matrix3().getNormalMatrix(matrix)
      }

      // vertices

      for (var i = 0, il = vertices2.length; i < il; i++) {
        var vertex = vertices2[i]

        var vertexCopy = vertex.clone()

        if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)

        vertices1.push(vertexCopy)
      }

      // colors

      for (var i = 0, il = colors2.length; i < il; i++) {
        colors1.push(colors2[i].clone())
      }

      // faces

      for (i = 0, il = faces2.length; i < il; i++) {
        var face = faces2[i],
          faceCopy,
          normal,
          color,
          faceVertexNormals = face.vertexNormals,
          faceVertexColors = face.vertexColors

        faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
        faceCopy.normal.copy(face.normal)

        if (normalMatrix !== undefined) {
          faceCopy.normal.applyMatrix3(normalMatrix).normalize()
        }

        for (var j = 0, jl = faceVertexNormals.length; j < jl; j++) {
          normal = faceVertexNormals[j].clone()

          if (normalMatrix !== undefined) {
            normal.applyMatrix3(normalMatrix).normalize()
          }

          faceCopy.vertexNormals.push(normal)
        }

        faceCopy.color.copy(face.color)

        for (var j = 0, jl = faceVertexColors.length; j < jl; j++) {
          color = faceVertexColors[j]
          faceCopy.vertexColors.push(color.clone())
        }

        faceCopy.materialIndex = face.materialIndex + materialIndexOffset

        faces1.push(faceCopy)
      }

      // uvs

      for (i = 0, il = uvs2.length; i < il; i++) {
        var uv = uvs2[i],
          uvCopy = []

        if (uv === undefined) {
          continue
        }

        for (var j = 0, jl = uv.length; j < jl; j++) {
          uvCopy.push(uv[j].clone())
        }

        uvs1.push(uvCopy)
      }
    },

    mergeMesh: function (mesh) {
      if (!(mesh && mesh.isMesh)) {
        console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
        return
      }

      mesh.matrixAutoUpdate && mesh.updateMatrix()

      this.merge(mesh.geometry, mesh.matrix)
    },

    /*
     * Checks for duplicate vertices with hashmap.
     * Duplicated vertices are removed
     * and faces' vertices are updated.
     */

    mergeVertices: function () {
      var verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
      var unique = [],
        changes = []

      var v, key
      var precisionPoints = 4 // number of decimal points, e.g. 4 for epsilon of 0.0001
      var precision = Math.pow(10, precisionPoints)
      var i, il, face
      var indices, j, jl

      for (i = 0, il = this.vertices.length; i < il; i++) {
        v = this.vertices[i]
        key =
          Math.round(v.x * precision) +
          '_' +
          Math.round(v.y * precision) +
          '_' +
          Math.round(v.z * precision)

        if (verticesMap[key] === undefined) {
          verticesMap[key] = i
          unique.push(this.vertices[i])
          changes[i] = unique.length - 1
        } else {
          //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
          changes[i] = changes[verticesMap[key]]
        }
      }

      // if faces are completely degenerate after merging vertices, we
      // have to remove them from the geometry.
      var faceIndicesToRemove = []

      for (i = 0, il = this.faces.length; i < il; i++) {
        face = this.faces[i]

        face.a = changes[face.a]
        face.b = changes[face.b]
        face.c = changes[face.c]

        indices = [face.a, face.b, face.c]

        // if any duplicate vertices are found in a Face3
        // we have to remove the face as nothing can be saved
        for (var n = 0; n < 3; n++) {
          if (indices[n] === indices[(n + 1) % 3]) {
            faceIndicesToRemove.push(i)
            break
          }
        }
      }

      for (i = faceIndicesToRemove.length - 1; i >= 0; i--) {
        var idx = faceIndicesToRemove[i]

        this.faces.splice(idx, 1)

        for (j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
          this.faceVertexUvs[j].splice(idx, 1)
        }
      }

      // Use unique set of vertices

      var diff = this.vertices.length - unique.length
      this.vertices = unique
      return diff
    },

    setFromPoints: function (points) {
      this.vertices = []

      for (var i = 0, l = points.length; i < l; i++) {
        var point = points[i]
        this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
      }

      return this
    },

    sortFacesByMaterialIndex: function () {
      var faces = this.faces
      var length = faces.length

      // tag faces

      for (var i = 0; i < length; i++) {
        faces[i]._id = i
      }

      // sort faces

      function materialIndexSort(a, b) {
        return a.materialIndex - b.materialIndex
      }

      faces.sort(materialIndexSort)

      // sort uvs

      var uvs1 = this.faceVertexUvs[0]
      var uvs2 = this.faceVertexUvs[1]

      var newUvs1, newUvs2

      if (uvs1 && uvs1.length === length) newUvs1 = []
      if (uvs2 && uvs2.length === length) newUvs2 = []

      for (var i = 0; i < length; i++) {
        var id = faces[i]._id

        if (newUvs1) newUvs1.push(uvs1[id])
        if (newUvs2) newUvs2.push(uvs2[id])
      }

      if (newUvs1) this.faceVertexUvs[0] = newUvs1
      if (newUvs2) this.faceVertexUvs[1] = newUvs2
    },

    toJSON: function () {
      var data = {
        metadata: {
          version: 4.5,
          type: 'Geometry',
          generator: 'Geometry.toJSON'
        }
      }

      // standard Geometry serialization

      data.uuid = this.uuid
      data.type = this.type
      if (this.name !== '') data.name = this.name

      if (this.parameters !== undefined) {
        var parameters = this.parameters

        for (var key in parameters) {
          if (parameters[key] !== undefined) data[key] = parameters[key]
        }

        return data
      }

      var vertices = []

      for (var i = 0; i < this.vertices.length; i++) {
        var vertex = this.vertices[i]
        vertices.push(vertex.x, vertex.y, vertex.z)
      }

      var faces = []
      var normals = []
      var normalsHash = {}
      var colors = []
      var colorsHash = {}
      var uvs = []
      var uvsHash = {}

      for (var i = 0; i < this.faces.length; i++) {
        var face = this.faces[i]

        var hasMaterial = true
        var hasFaceUv = false // deprecated
        var hasFaceVertexUv = this.faceVertexUvs[0][i] !== undefined
        var hasFaceNormal = face.normal.length() > 0
        var hasFaceVertexNormal = face.vertexNormals.length > 0
        var hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
        var hasFaceVertexColor = face.vertexColors.length > 0

        var faceType = 0

        faceType = setBit(faceType, 0, 0) // isQuad
        faceType = setBit(faceType, 1, hasMaterial)
        faceType = setBit(faceType, 2, hasFaceUv)
        faceType = setBit(faceType, 3, hasFaceVertexUv)
        faceType = setBit(faceType, 4, hasFaceNormal)
        faceType = setBit(faceType, 5, hasFaceVertexNormal)
        faceType = setBit(faceType, 6, hasFaceColor)
        faceType = setBit(faceType, 7, hasFaceVertexColor)

        faces.push(faceType)
        faces.push(face.a, face.b, face.c)
        faces.push(face.materialIndex)

        if (hasFaceVertexUv) {
          var faceVertexUvs = this.faceVertexUvs[0][i]

          faces.push(
            getUvIndex(faceVertexUvs[0]),
            getUvIndex(faceVertexUvs[1]),
            getUvIndex(faceVertexUvs[2])
          )
        }

        if (hasFaceNormal) {
          faces.push(getNormalIndex(face.normal))
        }

        if (hasFaceVertexNormal) {
          var vertexNormals = face.vertexNormals

          faces.push(
            getNormalIndex(vertexNormals[0]),
            getNormalIndex(vertexNormals[1]),
            getNormalIndex(vertexNormals[2])
          )
        }

        if (hasFaceColor) {
          faces.push(getColorIndex(face.color))
        }

        if (hasFaceVertexColor) {
          var vertexColors = face.vertexColors

          faces.push(
            getColorIndex(vertexColors[0]),
            getColorIndex(vertexColors[1]),
            getColorIndex(vertexColors[2])
          )
        }
      }

      function setBit(value, position, enabled) {
        return enabled ? value | (1 << position) : value & ~(1 << position)
      }

      function getNormalIndex(normal) {
        var hash = normal.x.toString() + normal.y.toString() + normal.z.toString()

        if (normalsHash[hash] !== undefined) {
          return normalsHash[hash]
        }

        normalsHash[hash] = normals.length / 3
        normals.push(normal.x, normal.y, normal.z)

        return normalsHash[hash]
      }

      function getColorIndex(color) {
        var hash = color.r.toString() + color.g.toString() + color.b.toString()

        if (colorsHash[hash] !== undefined) {
          return colorsHash[hash]
        }

        colorsHash[hash] = colors.length
        colors.push(color.getHex())

        return colorsHash[hash]
      }

      function getUvIndex(uv) {
        var hash = uv.x.toString() + uv.y.toString()

        if (uvsHash[hash] !== undefined) {
          return uvsHash[hash]
        }

        uvsHash[hash] = uvs.length / 2
        uvs.push(uv.x, uv.y)

        return uvsHash[hash]
      }

      data.data = {}

      data.data.vertices = vertices
      data.data.normals = normals
      if (colors.length > 0) data.data.colors = colors
      if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility
      data.data.faces = faces

      return data
    },

    clone: function () {
      /*
			 // Handle primitives

			 var parameters = this.parameters;

			 if ( parameters !== undefined ) {

			 var values = [];

			 for ( var key in parameters ) {

			 values.push( parameters[ key ] );

			 }

			 var geometry = Object.create( this.constructor.prototype );
			 this.constructor.apply( geometry, values );
			 return geometry;

			 }

			 return new this.constructor().copy( this );
			 */

      return new Geometry().copy(this)
    },

    copy: function (source) {
      var i, il, j, jl, k, kl

      // reset

      this.vertices = []
      this.colors = []
      this.faces = []
      this.faceVertexUvs = [[]]
      this.morphTargets = []
      this.morphNormals = []
      this.skinWeights = []
      this.skinIndices = []
      this.lineDistances = []
      this.boundingBox = null
      this.boundingSphere = null

      // name

      this.name = source.name

      // vertices

      var vertices = source.vertices

      for (i = 0, il = vertices.length; i < il; i++) {
        this.vertices.push(vertices[i].clone())
      }

      // colors

      var colors = source.colors

      for (i = 0, il = colors.length; i < il; i++) {
        this.colors.push(colors[i].clone())
      }

      // faces

      var faces = source.faces

      for (i = 0, il = faces.length; i < il; i++) {
        this.faces.push(faces[i].clone())
      }

      // face vertex uvs

      for (i = 0, il = source.faceVertexUvs.length; i < il; i++) {
        var faceVertexUvs = source.faceVertexUvs[i]

        if (this.faceVertexUvs[i] === undefined) {
          this.faceVertexUvs[i] = []
        }

        for (j = 0, jl = faceVertexUvs.length; j < jl; j++) {
          var uvs = faceVertexUvs[j],
            uvsCopy = []

          for (k = 0, kl = uvs.length; k < kl; k++) {
            var uv = uvs[k]

            uvsCopy.push(uv.clone())
          }

          this.faceVertexUvs[i].push(uvsCopy)
        }
      }

      // morph targets

      var morphTargets = source.morphTargets

      for (i = 0, il = morphTargets.length; i < il; i++) {
        var morphTarget = {}
        morphTarget.name = morphTargets[i].name

        // vertices

        if (morphTargets[i].vertices !== undefined) {
          morphTarget.vertices = []

          for (j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
            morphTarget.vertices.push(morphTargets[i].vertices[j].clone())
          }
        }

        // normals

        if (morphTargets[i].normals !== undefined) {
          morphTarget.normals = []

          for (j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
            morphTarget.normals.push(morphTargets[i].normals[j].clone())
          }
        }

        this.morphTargets.push(morphTarget)
      }

      // morph normals

      var morphNormals = source.morphNormals

      for (i = 0, il = morphNormals.length; i < il; i++) {
        var morphNormal = {}

        // vertex normals

        if (morphNormals[i].vertexNormals !== undefined) {
          morphNormal.vertexNormals = []

          for (j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
            var srcVertexNormal = morphNormals[i].vertexNormals[j]
            var destVertexNormal = {}

            destVertexNormal.a = srcVertexNormal.a.clone()
            destVertexNormal.b = srcVertexNormal.b.clone()
            destVertexNormal.c = srcVertexNormal.c.clone()

            morphNormal.vertexNormals.push(destVertexNormal)
          }
        }

        // face normals

        if (morphNormals[i].faceNormals !== undefined) {
          morphNormal.faceNormals = []

          for (j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
            morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone())
          }
        }

        this.morphNormals.push(morphNormal)
      }

      // skin weights

      var skinWeights = source.skinWeights

      for (i = 0, il = skinWeights.length; i < il; i++) {
        this.skinWeights.push(skinWeights[i].clone())
      }

      // skin indices

      var skinIndices = source.skinIndices

      for (i = 0, il = skinIndices.length; i < il; i++) {
        this.skinIndices.push(skinIndices[i].clone())
      }

      // line distances

      var lineDistances = source.lineDistances

      for (i = 0, il = lineDistances.length; i < il; i++) {
        this.lineDistances.push(lineDistances[i])
      }

      // bounding box

      var boundingBox = source.boundingBox

      if (boundingBox !== null) {
        this.boundingBox = boundingBox.clone()
      }

      // bounding sphere

      var boundingSphere = source.boundingSphere

      if (boundingSphere !== null) {
        this.boundingSphere = boundingSphere.clone()
      }

      // update flags

      this.elementsNeedUpdate = source.elementsNeedUpdate
      this.verticesNeedUpdate = source.verticesNeedUpdate
      this.uvsNeedUpdate = source.uvsNeedUpdate
      this.normalsNeedUpdate = source.normalsNeedUpdate
      this.colorsNeedUpdate = source.colorsNeedUpdate
      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
      this.groupsNeedUpdate = source.groupsNeedUpdate

      return this
    },

    dispose: function () {
      this.dispatchEvent({ type: 'dispose' })
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function BufferAttribute(array, itemSize, normalized) {
    if (Array.isArray(array)) {
      throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.')
    }

    this.uuid = _Math.generateUUID()
    this.name = ''

    this.array = array
    this.itemSize = itemSize
    this.count = array !== undefined ? array.length / itemSize : 0
    this.normalized = normalized === true

    this.dynamic = false
    this.updateRange = { offset: 0, count: -1 }

    this.onUploadCallback = function () {}

    this.version = 0
  }

  Object.defineProperty(BufferAttribute.prototype, 'needsUpdate', {
    set: function (value) {
      if (value === true) this.version++
    }
  })

  Object.assign(BufferAttribute.prototype, {
    isBufferAttribute: true,

    setArray: function (array) {
      if (Array.isArray(array)) {
        throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.')
      }

      this.count = array !== undefined ? array.length / this.itemSize : 0
      this.array = array
    },

    setDynamic: function (value) {
      this.dynamic = value

      return this
    },

    copy: function (source) {
      this.array = new source.array.constructor(source.array)
      this.itemSize = source.itemSize
      this.count = source.count
      this.normalized = source.normalized

      this.dynamic = source.dynamic

      return this
    },

    copyAt: function (index1, attribute, index2) {
      index1 *= this.itemSize
      index2 *= attribute.itemSize

      for (var i = 0, l = this.itemSize; i < l; i++) {
        this.array[index1 + i] = attribute.array[index2 + i]
      }

      return this
    },

    copyArray: function (array) {
      this.array.set(array)

      return this
    },

    copyColorsArray: function (colors) {
      var array = this.array,
        offset = 0

      for (var i = 0, l = colors.length; i < l; i++) {
        var color = colors[i]

        if (color === undefined) {
          console.warn('THREE.BufferAttribute.copyColorsArray(): color is undefined', i)
          color = new Color()
        }

        array[offset++] = color.r
        array[offset++] = color.g
        array[offset++] = color.b
      }

      return this
    },

    copyIndicesArray: function (indices) {
      var array = this.array,
        offset = 0

      for (var i = 0, l = indices.length; i < l; i++) {
        var index = indices[i]

        array[offset++] = index.a
        array[offset++] = index.b
        array[offset++] = index.c
      }

      return this
    },

    copyVector2sArray: function (vectors) {
      var array = this.array,
        offset = 0

      for (var i = 0, l = vectors.length; i < l; i++) {
        var vector = vectors[i]

        if (vector === undefined) {
          console.warn('THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i)
          vector = new Vector2()
        }

        array[offset++] = vector.x
        array[offset++] = vector.y
      }

      return this
    },

    copyVector3sArray: function (vectors) {
      var array = this.array,
        offset = 0

      for (var i = 0, l = vectors.length; i < l; i++) {
        var vector = vectors[i]

        if (vector === undefined) {
          console.warn('THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i)
          vector = new Vector3()
        }

        array[offset++] = vector.x
        array[offset++] = vector.y
        array[offset++] = vector.z
      }

      return this
    },

    copyVector4sArray: function (vectors) {
      var array = this.array,
        offset = 0

      for (var i = 0, l = vectors.length; i < l; i++) {
        var vector = vectors[i]

        if (vector === undefined) {
          console.warn('THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i)
          vector = new Vector4()
        }

        array[offset++] = vector.x
        array[offset++] = vector.y
        array[offset++] = vector.z
        array[offset++] = vector.w
      }

      return this
    },

    set: function (value, offset) {
      if (offset === undefined) offset = 0

      this.array.set(value, offset)

      return this
    },

    getX: function (index) {
      return this.array[index * this.itemSize]
    },

    setX: function (index, x) {
      this.array[index * this.itemSize] = x

      return this
    },

    getY: function (index) {
      return this.array[index * this.itemSize + 1]
    },

    setY: function (index, y) {
      this.array[index * this.itemSize + 1] = y

      return this
    },

    getZ: function (index) {
      return this.array[index * this.itemSize + 2]
    },

    setZ: function (index, z) {
      this.array[index * this.itemSize + 2] = z

      return this
    },

    getW: function (index) {
      return this.array[index * this.itemSize + 3]
    },

    setW: function (index, w) {
      this.array[index * this.itemSize + 3] = w

      return this
    },

    setXY: function (index, x, y) {
      index *= this.itemSize

      this.array[index + 0] = x
      this.array[index + 1] = y

      return this
    },

    setXYZ: function (index, x, y, z) {
      index *= this.itemSize

      this.array[index + 0] = x
      this.array[index + 1] = y
      this.array[index + 2] = z

      return this
    },

    setXYZW: function (index, x, y, z, w) {
      index *= this.itemSize

      this.array[index + 0] = x
      this.array[index + 1] = y
      this.array[index + 2] = z
      this.array[index + 3] = w

      return this
    },

    onUpload: function (callback) {
      this.onUploadCallback = callback

      return this
    },

    clone: function () {
      return new this.constructor(this.array, this.itemSize).copy(this)
    }
  })

  //

  function Int8BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Int8Array(array), itemSize, normalized)
  }

  Int8BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Int8BufferAttribute.prototype.constructor = Int8BufferAttribute

  function Uint8BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint8Array(array), itemSize, normalized)
  }

  Uint8BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint8BufferAttribute.prototype.constructor = Uint8BufferAttribute

  function Uint8ClampedBufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint8ClampedArray(array), itemSize, normalized)
  }

  Uint8ClampedBufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint8ClampedBufferAttribute.prototype.constructor = Uint8ClampedBufferAttribute

  function Int16BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Int16Array(array), itemSize, normalized)
  }

  Int16BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Int16BufferAttribute.prototype.constructor = Int16BufferAttribute

  function Uint16BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint16Array(array), itemSize, normalized)
  }

  Uint16BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint16BufferAttribute.prototype.constructor = Uint16BufferAttribute

  function Int32BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Int32Array(array), itemSize, normalized)
  }

  Int32BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Int32BufferAttribute.prototype.constructor = Int32BufferAttribute

  function Uint32BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint32Array(array), itemSize, normalized)
  }

  Uint32BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint32BufferAttribute.prototype.constructor = Uint32BufferAttribute

  function Float32BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Float32Array(array), itemSize, normalized)
  }

  Float32BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Float32BufferAttribute.prototype.constructor = Float32BufferAttribute

  function Float64BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Float64Array(array), itemSize, normalized)
  }

  Float64BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Float64BufferAttribute.prototype.constructor = Float64BufferAttribute

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function DirectGeometry() {
    this.indices = []
    this.vertices = []
    this.normals = []
    this.colors = []
    this.uvs = []
    this.uvs2 = []

    this.groups = []

    this.morphTargets = {}

    this.skinWeights = []
    this.skinIndices = []

    // this.lineDistances = [];

    this.boundingBox = null
    this.boundingSphere = null

    // update flags

    this.verticesNeedUpdate = false
    this.normalsNeedUpdate = false
    this.colorsNeedUpdate = false
    this.uvsNeedUpdate = false
    this.groupsNeedUpdate = false
  }

  Object.assign(DirectGeometry.prototype, {
    computeGroups: function (geometry) {
      var group
      var groups = []
      var materialIndex = undefined

      var faces = geometry.faces

      for (var i = 0; i < faces.length; i++) {
        var face = faces[i]

        // materials

        if (face.materialIndex !== materialIndex) {
          materialIndex = face.materialIndex

          if (group !== undefined) {
            group.count = i * 3 - group.start
            groups.push(group)
          }

          group = {
            start: i * 3,
            materialIndex: materialIndex
          }
        }
      }

      if (group !== undefined) {
        group.count = i * 3 - group.start
        groups.push(group)
      }

      this.groups = groups
    },

    fromGeometry: function (geometry) {
      var faces = geometry.faces
      var vertices = geometry.vertices
      var faceVertexUvs = geometry.faceVertexUvs

      var hasFaceVertexUv = faceVertexUvs[0] && faceVertexUvs[0].length > 0
      var hasFaceVertexUv2 = faceVertexUvs[1] && faceVertexUvs[1].length > 0

      // morphs

      var morphTargets = geometry.morphTargets
      var morphTargetsLength = morphTargets.length

      var morphTargetsPosition

      if (morphTargetsLength > 0) {
        morphTargetsPosition = []

        for (var i = 0; i < morphTargetsLength; i++) {
          morphTargetsPosition[i] = []
        }

        this.morphTargets.position = morphTargetsPosition
      }

      var morphNormals = geometry.morphNormals
      var morphNormalsLength = morphNormals.length

      var morphTargetsNormal

      if (morphNormalsLength > 0) {
        morphTargetsNormal = []

        for (var i = 0; i < morphNormalsLength; i++) {
          morphTargetsNormal[i] = []
        }

        this.morphTargets.normal = morphTargetsNormal
      }

      // skins

      var skinIndices = geometry.skinIndices
      var skinWeights = geometry.skinWeights

      var hasSkinIndices = skinIndices.length === vertices.length
      var hasSkinWeights = skinWeights.length === vertices.length

      //

      for (var i = 0; i < faces.length; i++) {
        var face = faces[i]

        this.vertices.push(vertices[face.a], vertices[face.b], vertices[face.c])

        var vertexNormals = face.vertexNormals

        if (vertexNormals.length === 3) {
          this.normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2])
        } else {
          var normal = face.normal

          this.normals.push(normal, normal, normal)
        }

        var vertexColors = face.vertexColors

        if (vertexColors.length === 3) {
          this.colors.push(vertexColors[0], vertexColors[1], vertexColors[2])
        } else {
          var color = face.color

          this.colors.push(color, color, color)
        }

        if (hasFaceVertexUv === true) {
          var vertexUvs = faceVertexUvs[0][i]

          if (vertexUvs !== undefined) {
            this.uvs.push(vertexUvs[0], vertexUvs[1], vertexUvs[2])
          } else {
            console.warn('THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', i)

            this.uvs.push(new Vector2(), new Vector2(), new Vector2())
          }
        }

        if (hasFaceVertexUv2 === true) {
          var vertexUvs = faceVertexUvs[1][i]

          if (vertexUvs !== undefined) {
            this.uvs2.push(vertexUvs[0], vertexUvs[1], vertexUvs[2])
          } else {
            console.warn('THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i)

            this.uvs2.push(new Vector2(), new Vector2(), new Vector2())
          }
        }

        // morphs

        for (var j = 0; j < morphTargetsLength; j++) {
          var morphTarget = morphTargets[j].vertices

          morphTargetsPosition[j].push(
            morphTarget[face.a],
            morphTarget[face.b],
            morphTarget[face.c]
          )
        }

        for (var j = 0; j < morphNormalsLength; j++) {
          var morphNormal = morphNormals[j].vertexNormals[i]

          morphTargetsNormal[j].push(morphNormal.a, morphNormal.b, morphNormal.c)
        }

        // skins

        if (hasSkinIndices) {
          this.skinIndices.push(skinIndices[face.a], skinIndices[face.b], skinIndices[face.c])
        }

        if (hasSkinWeights) {
          this.skinWeights.push(skinWeights[face.a], skinWeights[face.b], skinWeights[face.c])
        }
      }

      this.computeGroups(geometry)

      this.verticesNeedUpdate = geometry.verticesNeedUpdate
      this.normalsNeedUpdate = geometry.normalsNeedUpdate
      this.colorsNeedUpdate = geometry.colorsNeedUpdate
      this.uvsNeedUpdate = geometry.uvsNeedUpdate
      this.groupsNeedUpdate = geometry.groupsNeedUpdate

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function arrayMax(array) {
    if (array.length === 0) return -Infinity

    var max = array[0]

    for (var i = 1, l = array.length; i < l; ++i) {
      if (array[i] > max) max = array[i]
    }

    return max
  }

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   */

  var bufferGeometryId = 1 // BufferGeometry uses odd numbers as Id

  function BufferGeometry() {
    Object.defineProperty(this, 'id', { value: (bufferGeometryId += 2) })

    this.uuid = _Math.generateUUID()

    this.name = ''
    this.type = 'BufferGeometry'

    this.index = null
    this.attributes = {}

    this.morphAttributes = {}

    this.groups = []

    this.boundingBox = null
    this.boundingSphere = null

    this.drawRange = { start: 0, count: Infinity }
  }

  BufferGeometry.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: BufferGeometry,

    isBufferGeometry: true,

    getIndex: function () {
      return this.index
    },

    setIndex: function (index) {
      if (Array.isArray(index)) {
        this.index = new (arrayMax(index) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute)(
          index,
          1
        )
      } else {
        this.index = index
      }
    },

    addAttribute: function (name, attribute) {
      if (
        !(attribute && attribute.isBufferAttribute) &&
        !(attribute && attribute.isInterleavedBufferAttribute)
      ) {
        console.warn('THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).')

        this.addAttribute(name, new BufferAttribute(arguments[1], arguments[2]))

        return
      }

      if (name === 'index') {
        console.warn('THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.')
        this.setIndex(attribute)

        return
      }

      this.attributes[name] = attribute

      return this
    },

    getAttribute: function (name) {
      return this.attributes[name]
    },

    removeAttribute: function (name) {
      delete this.attributes[name]

      return this
    },

    addGroup: function (start, count, materialIndex) {
      this.groups.push({
        start: start,
        count: count,
        materialIndex: materialIndex !== undefined ? materialIndex : 0
      })
    },

    clearGroups: function () {
      this.groups = []
    },

    setDrawRange: function (start, count) {
      this.drawRange.start = start
      this.drawRange.count = count
    },

    applyMatrix: function (matrix) {
      var position = this.attributes.position

      if (position !== undefined) {
        matrix.applyToBufferAttribute(position)
        position.needsUpdate = true
      }

      var normal = this.attributes.normal

      if (normal !== undefined) {
        var normalMatrix = new Matrix3().getNormalMatrix(matrix)

        normalMatrix.applyToBufferAttribute(normal)
        normal.needsUpdate = true
      }

      if (this.boundingBox !== null) {
        this.computeBoundingBox()
      }

      if (this.boundingSphere !== null) {
        this.computeBoundingSphere()
      }

      return this
    },

    rotateX: (function () {
      // rotate geometry around world x-axis

      var m1 = new Matrix4()

      return function rotateX(angle) {
        m1.makeRotationX(angle)

        this.applyMatrix(m1)

        return this
      }
    })(),

    rotateY: (function () {
      // rotate geometry around world y-axis

      var m1 = new Matrix4()

      return function rotateY(angle) {
        m1.makeRotationY(angle)

        this.applyMatrix(m1)

        return this
      }
    })(),

    rotateZ: (function () {
      // rotate geometry around world z-axis

      var m1 = new Matrix4()

      return function rotateZ(angle) {
        m1.makeRotationZ(angle)

        this.applyMatrix(m1)

        return this
      }
    })(),

    translate: (function () {
      // translate geometry

      var m1 = new Matrix4()

      return function translate(x, y, z) {
        m1.makeTranslation(x, y, z)

        this.applyMatrix(m1)

        return this
      }
    })(),

    scale: (function () {
      // scale geometry

      var m1 = new Matrix4()

      return function scale(x, y, z) {
        m1.makeScale(x, y, z)

        this.applyMatrix(m1)

        return this
      }
    })(),

    lookAt: (function () {
      var obj = new Object3D()

      return function lookAt(vector) {
        obj.lookAt(vector)

        obj.updateMatrix()

        this.applyMatrix(obj.matrix)
      }
    })(),

    center: function () {
      this.computeBoundingBox()

      var offset = this.boundingBox.getCenter().negate()

      this.translate(offset.x, offset.y, offset.z)

      return offset
    },

    setFromObject: function (object) {
      // console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this );

      var geometry = object.geometry

      if (object.isPoints || object.isLine) {
        var positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
        var colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)

        this.addAttribute('position', positions.copyVector3sArray(geometry.vertices))
        this.addAttribute('color', colors.copyColorsArray(geometry.colors))

        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
          var lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)

          this.addAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
        }

        if (geometry.boundingSphere !== null) {
          this.boundingSphere = geometry.boundingSphere.clone()
        }

        if (geometry.boundingBox !== null) {
          this.boundingBox = geometry.boundingBox.clone()
        }
      } else if (object.isMesh) {
        if (geometry && geometry.isGeometry) {
          this.fromGeometry(geometry)
        }
      }

      return this
    },

    setFromPoints: function (points) {
      var position = []

      for (var i = 0, l = points.length; i < l; i++) {
        var point = points[i]
        position.push(point.x, point.y, point.z || 0)
      }

      this.addAttribute('position', new Float32BufferAttribute(position, 3))

      return this
    },

    updateFromObject: function (object) {
      var geometry = object.geometry

      if (object.isMesh) {
        var direct = geometry.__directGeometry

        if (geometry.elementsNeedUpdate === true) {
          direct = undefined
          geometry.elementsNeedUpdate = false
        }

        if (direct === undefined) {
          return this.fromGeometry(geometry)
        }

        direct.verticesNeedUpdate = geometry.verticesNeedUpdate
        direct.normalsNeedUpdate = geometry.normalsNeedUpdate
        direct.colorsNeedUpdate = geometry.colorsNeedUpdate
        direct.uvsNeedUpdate = geometry.uvsNeedUpdate
        direct.groupsNeedUpdate = geometry.groupsNeedUpdate

        geometry.verticesNeedUpdate = false
        geometry.normalsNeedUpdate = false
        geometry.colorsNeedUpdate = false
        geometry.uvsNeedUpdate = false
        geometry.groupsNeedUpdate = false

        geometry = direct
      }

      var attribute

      if (geometry.verticesNeedUpdate === true) {
        attribute = this.attributes.position

        if (attribute !== undefined) {
          attribute.copyVector3sArray(geometry.vertices)
          attribute.needsUpdate = true
        }

        geometry.verticesNeedUpdate = false
      }

      if (geometry.normalsNeedUpdate === true) {
        attribute = this.attributes.normal

        if (attribute !== undefined) {
          attribute.copyVector3sArray(geometry.normals)
          attribute.needsUpdate = true
        }

        geometry.normalsNeedUpdate = false
      }

      if (geometry.colorsNeedUpdate === true) {
        attribute = this.attributes.color

        if (attribute !== undefined) {
          attribute.copyColorsArray(geometry.colors)
          attribute.needsUpdate = true
        }

        geometry.colorsNeedUpdate = false
      }

      if (geometry.uvsNeedUpdate) {
        attribute = this.attributes.uv

        if (attribute !== undefined) {
          attribute.copyVector2sArray(geometry.uvs)
          attribute.needsUpdate = true
        }

        geometry.uvsNeedUpdate = false
      }

      if (geometry.lineDistancesNeedUpdate) {
        attribute = this.attributes.lineDistance

        if (attribute !== undefined) {
          attribute.copyArray(geometry.lineDistances)
          attribute.needsUpdate = true
        }

        geometry.lineDistancesNeedUpdate = false
      }

      if (geometry.groupsNeedUpdate) {
        geometry.computeGroups(object.geometry)
        this.groups = geometry.groups

        geometry.groupsNeedUpdate = false
      }

      return this
    },

    fromGeometry: function (geometry) {
      geometry.__directGeometry = new DirectGeometry().fromGeometry(geometry)

      return this.fromDirectGeometry(geometry.__directGeometry)
    },

    fromDirectGeometry: function (geometry) {
      var positions = new Float32Array(geometry.vertices.length * 3)
      this.addAttribute(
        'position',
        new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices)
      )

      if (geometry.normals.length > 0) {
        var normals = new Float32Array(geometry.normals.length * 3)
        this.addAttribute(
          'normal',
          new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals)
        )
      }

      if (geometry.colors.length > 0) {
        var colors = new Float32Array(geometry.colors.length * 3)
        this.addAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
      }

      if (geometry.uvs.length > 0) {
        var uvs = new Float32Array(geometry.uvs.length * 2)
        this.addAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
      }

      if (geometry.uvs2.length > 0) {
        var uvs2 = new Float32Array(geometry.uvs2.length * 2)
        this.addAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
      }

      if (geometry.indices.length > 0) {
        var TypeArray = arrayMax(geometry.indices) > 65535 ? Uint32Array : Uint16Array
        var indices = new TypeArray(geometry.indices.length * 3)
        this.setIndex(new BufferAttribute(indices, 1).copyIndicesArray(geometry.indices))
      }

      // groups

      this.groups = geometry.groups

      // morphs

      for (var name in geometry.morphTargets) {
        var array = []
        var morphTargets = geometry.morphTargets[name]

        for (var i = 0, l = morphTargets.length; i < l; i++) {
          var morphTarget = morphTargets[i]

          var attribute = new Float32BufferAttribute(morphTarget.length * 3, 3)

          array.push(attribute.copyVector3sArray(morphTarget))
        }

        this.morphAttributes[name] = array
      }

      // skinning

      if (geometry.skinIndices.length > 0) {
        var skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
        this.addAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
      }

      if (geometry.skinWeights.length > 0) {
        var skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
        this.addAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
      }

      //

      if (geometry.boundingSphere !== null) {
        this.boundingSphere = geometry.boundingSphere.clone()
      }

      if (geometry.boundingBox !== null) {
        this.boundingBox = geometry.boundingBox.clone()
      }

      return this
    },

    computeBoundingBox: function () {
      if (this.boundingBox === null) {
        this.boundingBox = new Box3()
      }

      var position = this.attributes.position

      if (position !== undefined) {
        this.boundingBox.setFromBufferAttribute(position)
      } else {
        this.boundingBox.makeEmpty()
      }

      if (
        isNaN(this.boundingBox.min.x) ||
        isNaN(this.boundingBox.min.y) ||
        isNaN(this.boundingBox.min.z)
      ) {
        console.error(
          'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The "position" attribute is likely to have NaN values.',
          this
        )
      }
    },

    computeBoundingSphere: (function () {
      var box = new Box3()
      var vector = new Vector3()

      return function computeBoundingSphere() {
        if (this.boundingSphere === null) {
          this.boundingSphere = new Sphere()
        }

        var position = this.attributes.position

        if (position) {
          var center = this.boundingSphere.center

          box.setFromBufferAttribute(position)
          box.getCenter(center)

          // hoping to find a boundingSphere with a radius smaller than the
          // boundingSphere of the boundingBox: sqrt(3) smaller in the best case

          var maxRadiusSq = 0

          for (var i = 0, il = position.count; i < il; i++) {
            vector.x = position.getX(i)
            vector.y = position.getY(i)
            vector.z = position.getZ(i)
            maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector))
          }

          this.boundingSphere.radius = Math.sqrt(maxRadiusSq)

          if (isNaN(this.boundingSphere.radius)) {
            console.error(
              'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',
              this
            )
          }
        }
      }
    })(),

    computeFaceNormals: function () {
      // backwards compatibility
    },

    computeVertexNormals: function () {
      var index = this.index
      var attributes = this.attributes
      var groups = this.groups

      if (attributes.position) {
        var positions = attributes.position.array

        if (attributes.normal === undefined) {
          this.addAttribute('normal', new BufferAttribute(new Float32Array(positions.length), 3))
        } else {
          // reset existing normals to zero

          var array = attributes.normal.array

          for (var i = 0, il = array.length; i < il; i++) {
            array[i] = 0
          }
        }

        var normals = attributes.normal.array

        var vA, vB, vC
        var pA = new Vector3(),
          pB = new Vector3(),
          pC = new Vector3()
        var cb = new Vector3(),
          ab = new Vector3()

        // indexed elements

        if (index) {
          var indices = index.array

          if (groups.length === 0) {
            this.addGroup(0, indices.length)
          }

          for (var j = 0, jl = groups.length; j < jl; ++j) {
            var group = groups[j]

            var start = group.start
            var count = group.count

            for (var i = start, il = start + count; i < il; i += 3) {
              vA = indices[i + 0] * 3
              vB = indices[i + 1] * 3
              vC = indices[i + 2] * 3

              pA.fromArray(positions, vA)
              pB.fromArray(positions, vB)
              pC.fromArray(positions, vC)

              cb.subVectors(pC, pB)
              ab.subVectors(pA, pB)
              cb.cross(ab)

              normals[vA] += cb.x
              normals[vA + 1] += cb.y
              normals[vA + 2] += cb.z

              normals[vB] += cb.x
              normals[vB + 1] += cb.y
              normals[vB + 2] += cb.z

              normals[vC] += cb.x
              normals[vC + 1] += cb.y
              normals[vC + 2] += cb.z
            }
          }
        } else {
          // non-indexed elements (unconnected triangle soup)

          for (var i = 0, il = positions.length; i < il; i += 9) {
            pA.fromArray(positions, i)
            pB.fromArray(positions, i + 3)
            pC.fromArray(positions, i + 6)

            cb.subVectors(pC, pB)
            ab.subVectors(pA, pB)
            cb.cross(ab)

            normals[i] = cb.x
            normals[i + 1] = cb.y
            normals[i + 2] = cb.z

            normals[i + 3] = cb.x
            normals[i + 4] = cb.y
            normals[i + 5] = cb.z

            normals[i + 6] = cb.x
            normals[i + 7] = cb.y
            normals[i + 8] = cb.z
          }
        }

        this.normalizeNormals()

        attributes.normal.needsUpdate = true
      }
    },

    merge: function (geometry, offset) {
      if (!(geometry && geometry.isBufferGeometry)) {
        console.error(
          'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.',
          geometry
        )
        return
      }

      if (offset === undefined) offset = 0

      var attributes = this.attributes

      for (var key in attributes) {
        if (geometry.attributes[key] === undefined) continue

        var attribute1 = attributes[key]
        var attributeArray1 = attribute1.array

        var attribute2 = geometry.attributes[key]
        var attributeArray2 = attribute2.array

        var attributeSize = attribute2.itemSize

        for (var i = 0, j = attributeSize * offset; i < attributeArray2.length; i++, j++) {
          attributeArray1[j] = attributeArray2[i]
        }
      }

      return this
    },

    normalizeNormals: (function () {
      var vector = new Vector3()

      return function normalizeNormals() {
        var normals = this.attributes.normal

        for (var i = 0, il = normals.count; i < il; i++) {
          vector.x = normals.getX(i)
          vector.y = normals.getY(i)
          vector.z = normals.getZ(i)

          vector.normalize()

          normals.setXYZ(i, vector.x, vector.y, vector.z)
        }
      }
    })(),

    toNonIndexed: function () {
      if (this.index === null) {
        console.warn('THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.')
        return this
      }

      var geometry2 = new BufferGeometry()

      var indices = this.index.array
      var attributes = this.attributes

      for (var name in attributes) {
        var attribute = attributes[name]

        var array = attribute.array
        var itemSize = attribute.itemSize

        var array2 = new array.constructor(indices.length * itemSize)

        var index = 0,
          index2 = 0

        for (var i = 0, l = indices.length; i < l; i++) {
          index = indices[i] * itemSize

          for (var j = 0; j < itemSize; j++) {
            array2[index2++] = array[index++]
          }
        }

        geometry2.addAttribute(name, new BufferAttribute(array2, itemSize))
      }

      return geometry2
    },

    toJSON: function () {
      var data = {
        metadata: {
          version: 4.5,
          type: 'BufferGeometry',
          generator: 'BufferGeometry.toJSON'
        }
      }

      // standard BufferGeometry serialization

      data.uuid = this.uuid
      data.type = this.type
      if (this.name !== '') data.name = this.name

      if (this.parameters !== undefined) {
        var parameters = this.parameters

        for (var key in parameters) {
          if (parameters[key] !== undefined) data[key] = parameters[key]
        }

        return data
      }

      data.data = { attributes: {} }

      var index = this.index

      if (index !== null) {
        var array = Array.prototype.slice.call(index.array)

        data.data.index = {
          type: index.array.constructor.name,
          array: array
        }
      }

      var attributes = this.attributes

      for (var key in attributes) {
        var attribute = attributes[key]

        var array = Array.prototype.slice.call(attribute.array)

        data.data.attributes[key] = {
          itemSize: attribute.itemSize,
          type: attribute.array.constructor.name,
          array: array,
          normalized: attribute.normalized
        }
      }

      var groups = this.groups

      if (groups.length > 0) {
        data.data.groups = JSON.parse(JSON.stringify(groups))
      }

      var boundingSphere = this.boundingSphere

      if (boundingSphere !== null) {
        data.data.boundingSphere = {
          center: boundingSphere.center.toArray(),
          radius: boundingSphere.radius
        }
      }

      return data
    },

    clone: function () {
      /*
			 // Handle primitives

			 var parameters = this.parameters;

			 if ( parameters !== undefined ) {

			 var values = [];

			 for ( var key in parameters ) {

			 values.push( parameters[ key ] );

			 }

			 var geometry = Object.create( this.constructor.prototype );
			 this.constructor.apply( geometry, values );
			 return geometry;

			 }

			 return new this.constructor().copy( this );
			 */

      return new BufferGeometry().copy(this)
    },

    copy: function (source) {
      var name, i, l

      // reset

      this.index = null
      this.attributes = {}
      this.morphAttributes = {}
      this.groups = []
      this.boundingBox = null
      this.boundingSphere = null

      // name

      this.name = source.name

      // index

      var index = source.index

      if (index !== null) {
        this.setIndex(index.clone())
      }

      // attributes

      var attributes = source.attributes

      for (name in attributes) {
        var attribute = attributes[name]
        this.addAttribute(name, attribute.clone())
      }

      // morph attributes

      var morphAttributes = source.morphAttributes

      for (name in morphAttributes) {
        var array = []
        var morphAttribute = morphAttributes[name] // morphAttribute: array of Float32BufferAttributes

        for (i = 0, l = morphAttribute.length; i < l; i++) {
          array.push(morphAttribute[i].clone())
        }

        this.morphAttributes[name] = array
      }

      // groups

      var groups = source.groups

      for (i = 0, l = groups.length; i < l; i++) {
        var group = groups[i]
        this.addGroup(group.start, group.count, group.materialIndex)
      }

      // bounding box

      var boundingBox = source.boundingBox

      if (boundingBox !== null) {
        this.boundingBox = boundingBox.clone()
      }

      // bounding sphere

      var boundingSphere = source.boundingSphere

      if (boundingSphere !== null) {
        this.boundingSphere = boundingSphere.clone()
      }

      // draw range

      this.drawRange.start = source.drawRange.start
      this.drawRange.count = source.drawRange.count

      return this
    },

    dispose: function () {
      this.dispatchEvent({ type: 'dispose' })
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / https://github.com/Mugen87
   */

  // BoxGeometry

  function BoxGeometry(width, height, depth, widthSegments, heightSegments, depthSegments) {
    Geometry.call(this)

    this.type = 'BoxGeometry'

    this.parameters = {
      width: width,
      height: height,
      depth: depth,
      widthSegments: widthSegments,
      heightSegments: heightSegments,
      depthSegments: depthSegments
    }

    this.fromBufferGeometry(
      new BoxBufferGeometry(width, height, depth, widthSegments, heightSegments, depthSegments)
    )
    this.mergeVertices()
  }

  BoxGeometry.prototype = Object.create(Geometry.prototype)
  BoxGeometry.prototype.constructor = BoxGeometry

  // BoxBufferGeometry

  function BoxBufferGeometry(width, height, depth, widthSegments, heightSegments, depthSegments) {
    BufferGeometry.call(this)

    this.type = 'BoxBufferGeometry'

    this.parameters = {
      width: width,
      height: height,
      depth: depth,
      widthSegments: widthSegments,
      heightSegments: heightSegments,
      depthSegments: depthSegments
    }

    var scope = this

    width = width || 1
    height = height || 1
    depth = depth || 1

    // segments

    widthSegments = Math.floor(widthSegments) || 1
    heightSegments = Math.floor(heightSegments) || 1
    depthSegments = Math.floor(depthSegments) || 1

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // helper variables

    var numberOfVertices = 0
    var groupStart = 0

    // build each side of the box geometry

    buildPlane('z', 'y', 'x', -1, -1, depth, height, width, depthSegments, heightSegments, 0) // px
    buildPlane('z', 'y', 'x', 1, -1, depth, height, -width, depthSegments, heightSegments, 1) // nx
    buildPlane('x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2) // py
    buildPlane('x', 'z', 'y', 1, -1, width, depth, -height, widthSegments, depthSegments, 3) // ny
    buildPlane('x', 'y', 'z', 1, -1, width, height, depth, widthSegments, heightSegments, 4) // pz
    buildPlane('x', 'y', 'z', -1, -1, width, height, -depth, widthSegments, heightSegments, 5) // nz

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))

    function buildPlane(u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex) {
      var segmentWidth = width / gridX
      var segmentHeight = height / gridY

      var widthHalf = width / 2
      var heightHalf = height / 2
      var depthHalf = depth / 2

      var gridX1 = gridX + 1
      var gridY1 = gridY + 1

      var vertexCounter = 0
      var groupCount = 0

      var ix, iy

      var vector = new Vector3()

      // generate vertices, normals and uvs

      for (iy = 0; iy < gridY1; iy++) {
        var y = iy * segmentHeight - heightHalf

        for (ix = 0; ix < gridX1; ix++) {
          var x = ix * segmentWidth - widthHalf

          // set values to correct vector component

          vector[u] = x * udir
          vector[v] = y * vdir
          vector[w] = depthHalf

          // now apply vector to vertex buffer

          vertices.push(vector.x, vector.y, vector.z)

          // set values to correct vector component

          vector[u] = 0
          vector[v] = 0
          vector[w] = depth > 0 ? 1 : -1

          // now apply vector to normal buffer

          normals.push(vector.x, vector.y, vector.z)

          // uvs

          uvs.push(ix / gridX)
          uvs.push(1 - iy / gridY)

          // counters

          vertexCounter += 1
        }
      }

      // indices

      // 1. you need three indices to draw a single face
      // 2. a single segment consists of two faces
      // 3. so we need to generate six (2*3) indices per segment

      for (iy = 0; iy < gridY; iy++) {
        for (ix = 0; ix < gridX; ix++) {
          var a = numberOfVertices + ix + gridX1 * iy
          var b = numberOfVertices + ix + gridX1 * (iy + 1)
          var c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1)
          var d = numberOfVertices + (ix + 1) + gridX1 * iy

          // faces

          indices.push(a, b, d)
          indices.push(b, c, d)

          // increase counter

          groupCount += 6
        }
      }

      // add a group to the geometry. this will ensure multi material support

      scope.addGroup(groupStart, groupCount, materialIndex)

      // calculate new start value for groups

      groupStart += groupCount

      // update total number of vertices

      numberOfVertices += vertexCounter
    }
  }

  BoxBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  BoxBufferGeometry.prototype.constructor = BoxBufferGeometry

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / https://github.com/Mugen87
   */

  // PlaneGeometry

  function PlaneGeometry(width, height, widthSegments, heightSegments) {
    Geometry.call(this)

    this.type = 'PlaneGeometry'

    this.parameters = {
      width: width,
      height: height,
      widthSegments: widthSegments,
      heightSegments: heightSegments
    }

    this.fromBufferGeometry(new PlaneBufferGeometry(width, height, widthSegments, heightSegments))
    this.mergeVertices()
  }

  PlaneGeometry.prototype = Object.create(Geometry.prototype)
  PlaneGeometry.prototype.constructor = PlaneGeometry

  // PlaneBufferGeometry

  function PlaneBufferGeometry(width, height, widthSegments, heightSegments) {
    BufferGeometry.call(this)

    this.type = 'PlaneBufferGeometry'

    this.parameters = {
      width: width,
      height: height,
      widthSegments: widthSegments,
      heightSegments: heightSegments
    }

    width = width || 1
    height = height || 1

    var width_half = width / 2
    var height_half = height / 2

    var gridX = Math.floor(widthSegments) || 1
    var gridY = Math.floor(heightSegments) || 1

    var gridX1 = gridX + 1
    var gridY1 = gridY + 1

    var segment_width = width / gridX
    var segment_height = height / gridY

    var ix, iy

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // generate vertices, normals and uvs

    for (iy = 0; iy < gridY1; iy++) {
      var y = iy * segment_height - height_half

      for (ix = 0; ix < gridX1; ix++) {
        var x = ix * segment_width - width_half

        vertices.push(x, -y, 0)

        normals.push(0, 0, 1)

        uvs.push(ix / gridX)
        uvs.push(1 - iy / gridY)
      }
    }

    // indices

    for (iy = 0; iy < gridY; iy++) {
      for (ix = 0; ix < gridX; ix++) {
        var a = ix + gridX1 * iy
        var b = ix + gridX1 * (iy + 1)
        var c = ix + 1 + gridX1 * (iy + 1)
        var d = ix + 1 + gridX1 * iy

        // faces

        indices.push(a, b, d)
        indices.push(b, c, d)
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))
  }

  PlaneBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  PlaneBufferGeometry.prototype.constructor = PlaneBufferGeometry

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  color: <hex>,
   *  opacity: <float>,
   *  map: new THREE.Texture( <Image> ),
   *
   *  lightMap: new THREE.Texture( <Image> ),
   *  lightMapIntensity: <float>
   *
   *  aoMap: new THREE.Texture( <Image> ),
   *  aoMapIntensity: <float>
   *
   *  specularMap: new THREE.Texture( <Image> ),
   *
   *  alphaMap: new THREE.Texture( <Image> ),
   *
   *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
   *  combine: THREE.Multiply,
   *  reflectivity: <float>,
   *  refractionRatio: <float>,
   *
   *  depthTest: <bool>,
   *  depthWrite: <bool>,
   *
   *  wireframe: <boolean>,
   *  wireframeLinewidth: <float>,
   *
   *  skinning: <bool>,
   *  morphTargets: <bool>
   * }
   */

  function MeshBasicMaterial(parameters) {
    Material.call(this)

    this.type = 'MeshBasicMaterial'

    this.color = new Color(0xffffff) // emissive

    this.map = null

    this.lightMap = null
    this.lightMapIntensity = 1.0

    this.aoMap = null
    this.aoMapIntensity = 1.0

    this.specularMap = null

    this.alphaMap = null

    this.envMap = null
    this.combine = MultiplyOperation
    this.reflectivity = 1
    this.refractionRatio = 0.98

    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'

    this.skinning = false
    this.morphTargets = false

    this.lights = false

    this.setValues(parameters)
  }

  MeshBasicMaterial.prototype = Object.create(Material.prototype)
  MeshBasicMaterial.prototype.constructor = MeshBasicMaterial

  MeshBasicMaterial.prototype.isMeshBasicMaterial = true

  MeshBasicMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.color.copy(source.color)

    this.map = source.map

    this.lightMap = source.lightMap
    this.lightMapIntensity = source.lightMapIntensity

    this.aoMap = source.aoMap
    this.aoMapIntensity = source.aoMapIntensity

    this.specularMap = source.specularMap

    this.alphaMap = source.alphaMap

    this.envMap = source.envMap
    this.combine = source.combine
    this.reflectivity = source.reflectivity
    this.refractionRatio = source.refractionRatio

    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth
    this.wireframeLinecap = source.wireframeLinecap
    this.wireframeLinejoin = source.wireframeLinejoin

    this.skinning = source.skinning
    this.morphTargets = source.morphTargets

    return this
  }

  /**
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  defines: { "label" : "value" },
   *  uniforms: { "parameter1": { value: 1.0 }, "parameter2": { value2: 2 } },
   *
   *  fragmentShader: <string>,
   *  vertexShader: <string>,
   *
   *  wireframe: <boolean>,
   *  wireframeLinewidth: <float>,
   *
   *  lights: <bool>,
   *
   *  skinning: <bool>,
   *  morphTargets: <bool>,
   *  morphNormals: <bool>
   * }
   */

  function ShaderMaterial(parameters) {
    Material.call(this)

    this.type = 'ShaderMaterial'

    this.defines = {}
    this.uniforms = {}

    this.vertexShader =
      'void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}'
    this.fragmentShader = 'void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}'

    this.linewidth = 1

    this.wireframe = false
    this.wireframeLinewidth = 1

    this.fog = false // set to use scene fog
    this.lights = false // set to use scene lights
    this.clipping = false // set to use user-defined clipping planes

    this.skinning = false // set to use skinning attribute streams
    this.morphTargets = false // set to use morph targets
    this.morphNormals = false // set to use morph normals

    this.extensions = {
      derivatives: false, // set to use derivatives
      fragDepth: false, // set to use fragment depth values
      drawBuffers: false, // set to use draw buffers
      shaderTextureLOD: false // set to use shader texture LOD
    }

    // When rendered geometry doesn't include these attributes but the material does,
    // use these default values in WebGL. This avoids errors when buffer data is missing.
    this.defaultAttributeValues = {
      color: [1, 1, 1],
      uv: [0, 0],
      uv2: [0, 0]
    }

    this.index0AttributeName = undefined
    this.uniformsNeedUpdate = false

    if (parameters !== undefined) {
      if (parameters.attributes !== undefined) {
        console.error(
          'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.'
        )
      }

      this.setValues(parameters)
    }
  }

  ShaderMaterial.prototype = Object.create(Material.prototype)
  ShaderMaterial.prototype.constructor = ShaderMaterial

  ShaderMaterial.prototype.isShaderMaterial = true

  ShaderMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.fragmentShader = source.fragmentShader
    this.vertexShader = source.vertexShader

    this.uniforms = UniformsUtils.clone(source.uniforms)

    this.defines = source.defines

    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth

    this.lights = source.lights
    this.clipping = source.clipping

    this.skinning = source.skinning

    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals

    this.extensions = source.extensions

    return this
  }

  ShaderMaterial.prototype.toJSON = function (meta) {
    var data = Material.prototype.toJSON.call(this, meta)

    data.uniforms = this.uniforms
    data.vertexShader = this.vertexShader
    data.fragmentShader = this.fragmentShader

    return data
  }

  /**
   * @author bhouston / http://clara.io
   */

  function Ray(origin, direction) {
    this.origin = origin !== undefined ? origin : new Vector3()
    this.direction = direction !== undefined ? direction : new Vector3()
  }

  Object.assign(Ray.prototype, {
    set: function (origin, direction) {
      this.origin.copy(origin)
      this.direction.copy(direction)

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (ray) {
      this.origin.copy(ray.origin)
      this.direction.copy(ray.direction)

      return this
    },

    at: function (t, optionalTarget) {
      var result = optionalTarget || new Vector3()

      return result.copy(this.direction).multiplyScalar(t).add(this.origin)
    },

    lookAt: function (v) {
      this.direction.copy(v).sub(this.origin).normalize()

      return this
    },

    recast: (function () {
      var v1 = new Vector3()

      return function recast(t) {
        this.origin.copy(this.at(t, v1))

        return this
      }
    })(),

    closestPointToPoint: function (point, optionalTarget) {
      var result = optionalTarget || new Vector3()
      result.subVectors(point, this.origin)
      var directionDistance = result.dot(this.direction)

      if (directionDistance < 0) {
        return result.copy(this.origin)
      }

      return result.copy(this.direction).multiplyScalar(directionDistance).add(this.origin)
    },

    distanceToPoint: function (point) {
      return Math.sqrt(this.distanceSqToPoint(point))
    },

    distanceSqToPoint: (function () {
      var v1 = new Vector3()

      return function distanceSqToPoint(point) {
        var directionDistance = v1.subVectors(point, this.origin).dot(this.direction)

        // point behind the ray

        if (directionDistance < 0) {
          return this.origin.distanceToSquared(point)
        }

        v1.copy(this.direction).multiplyScalar(directionDistance).add(this.origin)

        return v1.distanceToSquared(point)
      }
    })(),

    distanceSqToSegment: (function () {
      var segCenter = new Vector3()
      var segDir = new Vector3()
      var diff = new Vector3()

      return function distanceSqToSegment(v0, v1, optionalPointOnRay, optionalPointOnSegment) {
        // from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteDistRaySegment.h
        // It returns the min distance between the ray and the segment
        // defined by v0 and v1
        // It can also set two optional targets :
        // - The closest point on the ray
        // - The closest point on the segment

        segCenter.copy(v0).add(v1).multiplyScalar(0.5)
        segDir.copy(v1).sub(v0).normalize()
        diff.copy(this.origin).sub(segCenter)

        var segExtent = v0.distanceTo(v1) * 0.5
        var a01 = -this.direction.dot(segDir)
        var b0 = diff.dot(this.direction)
        var b1 = -diff.dot(segDir)
        var c = diff.lengthSq()
        var det = Math.abs(1 - a01 * a01)
        var s0, s1, sqrDist, extDet

        if (det > 0) {
          // The ray and segment are not parallel.

          s0 = a01 * b1 - b0
          s1 = a01 * b0 - b1
          extDet = segExtent * det

          if (s0 >= 0) {
            if (s1 >= -extDet) {
              if (s1 <= extDet) {
                // region 0
                // Minimum at interior points of ray and segment.

                var invDet = 1 / det
                s0 *= invDet
                s1 *= invDet
                sqrDist = s0 * (s0 + a01 * s1 + 2 * b0) + s1 * (a01 * s0 + s1 + 2 * b1) + c
              } else {
                // region 1

                s1 = segExtent
                s0 = Math.max(0, -(a01 * s1 + b0))
                sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c
              }
            } else {
              // region 5

              s1 = -segExtent
              s0 = Math.max(0, -(a01 * s1 + b0))
              sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c
            }
          } else {
            if (s1 <= -extDet) {
              // region 4

              s0 = Math.max(0, -(-a01 * segExtent + b0))
              s1 = s0 > 0 ? -segExtent : Math.min(Math.max(-segExtent, -b1), segExtent)
              sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c
            } else if (s1 <= extDet) {
              // region 3

              s0 = 0
              s1 = Math.min(Math.max(-segExtent, -b1), segExtent)
              sqrDist = s1 * (s1 + 2 * b1) + c
            } else {
              // region 2

              s0 = Math.max(0, -(a01 * segExtent + b0))
              s1 = s0 > 0 ? segExtent : Math.min(Math.max(-segExtent, -b1), segExtent)
              sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c
            }
          }
        } else {
          // Ray and segment are parallel.

          s1 = a01 > 0 ? -segExtent : segExtent
          s0 = Math.max(0, -(a01 * s1 + b0))
          sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c
        }

        if (optionalPointOnRay) {
          optionalPointOnRay.copy(this.direction).multiplyScalar(s0).add(this.origin)
        }

        if (optionalPointOnSegment) {
          optionalPointOnSegment.copy(segDir).multiplyScalar(s1).add(segCenter)
        }

        return sqrDist
      }
    })(),

    intersectSphere: (function () {
      var v1 = new Vector3()

      return function intersectSphere(sphere, optionalTarget) {
        v1.subVectors(sphere.center, this.origin)
        var tca = v1.dot(this.direction)
        var d2 = v1.dot(v1) - tca * tca
        var radius2 = sphere.radius * sphere.radius

        if (d2 > radius2) return null

        var thc = Math.sqrt(radius2 - d2)

        // t0 = first intersect point - entrance on front of sphere
        var t0 = tca - thc

        // t1 = second intersect point - exit point on back of sphere
        var t1 = tca + thc

        // test to see if both t0 and t1 are behind the ray - if so, return null
        if (t0 < 0 && t1 < 0) return null

        // test to see if t0 is behind the ray:
        // if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
        // in order to always return an intersect point that is in front of the ray.
        if (t0 < 0) return this.at(t1, optionalTarget)

        // else t0 is in front of the ray, so return the first collision point scaled by t0
        return this.at(t0, optionalTarget)
      }
    })(),

    intersectsSphere: function (sphere) {
      return this.distanceToPoint(sphere.center) <= sphere.radius
    },

    distanceToPlane: function (plane) {
      var denominator = plane.normal.dot(this.direction)

      if (denominator === 0) {
        // line is coplanar, return origin
        if (plane.distanceToPoint(this.origin) === 0) {
          return 0
        }

        // Null is preferable to undefined since undefined means.... it is undefined

        return null
      }

      var t = -(this.origin.dot(plane.normal) + plane.constant) / denominator

      // Return if the ray never intersects the plane

      return t >= 0 ? t : null
    },

    intersectPlane: function (plane, optionalTarget) {
      var t = this.distanceToPlane(plane)

      if (t === null) {
        return null
      }

      return this.at(t, optionalTarget)
    },

    intersectsPlane: function (plane) {
      // check if the ray lies on the plane first

      var distToPoint = plane.distanceToPoint(this.origin)

      if (distToPoint === 0) {
        return true
      }

      var denominator = plane.normal.dot(this.direction)

      if (denominator * distToPoint < 0) {
        return true
      }

      // ray origin is behind the plane (and is pointing behind it)

      return false
    },

    intersectBox: function (box, optionalTarget) {
      var tmin, tmax, tymin, tymax, tzmin, tzmax

      var invdirx = 1 / this.direction.x,
        invdiry = 1 / this.direction.y,
        invdirz = 1 / this.direction.z

      var origin = this.origin

      if (invdirx >= 0) {
        tmin = (box.min.x - origin.x) * invdirx
        tmax = (box.max.x - origin.x) * invdirx
      } else {
        tmin = (box.max.x - origin.x) * invdirx
        tmax = (box.min.x - origin.x) * invdirx
      }

      if (invdiry >= 0) {
        tymin = (box.min.y - origin.y) * invdiry
        tymax = (box.max.y - origin.y) * invdiry
      } else {
        tymin = (box.max.y - origin.y) * invdiry
        tymax = (box.min.y - origin.y) * invdiry
      }

      if (tmin > tymax || tymin > tmax) return null

      // These lines also handle the case where tmin or tmax is NaN
      // (result of 0 * Infinity). x !== x returns true if x is NaN

      if (tymin > tmin || tmin !== tmin) tmin = tymin

      if (tymax < tmax || tmax !== tmax) tmax = tymax

      if (invdirz >= 0) {
        tzmin = (box.min.z - origin.z) * invdirz
        tzmax = (box.max.z - origin.z) * invdirz
      } else {
        tzmin = (box.max.z - origin.z) * invdirz
        tzmax = (box.min.z - origin.z) * invdirz
      }

      if (tmin > tzmax || tzmin > tmax) return null

      if (tzmin > tmin || tmin !== tmin) tmin = tzmin

      if (tzmax < tmax || tmax !== tmax) tmax = tzmax

      //return point closest to the ray (positive side)

      if (tmax < 0) return null

      return this.at(tmin >= 0 ? tmin : tmax, optionalTarget)
    },

    intersectsBox: (function () {
      var v = new Vector3()

      return function intersectsBox(box) {
        return this.intersectBox(box, v) !== null
      }
    })(),

    intersectTriangle: (function () {
      // Compute the offset origin, edges, and normal.
      var diff = new Vector3()
      var edge1 = new Vector3()
      var edge2 = new Vector3()
      var normal = new Vector3()

      return function intersectTriangle(a, b, c, backfaceCulling, optionalTarget) {
        // from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h

        edge1.subVectors(b, a)
        edge2.subVectors(c, a)
        normal.crossVectors(edge1, edge2)

        // Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
        // E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
        //   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
        //   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
        //   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
        var DdN = this.direction.dot(normal)
        var sign

        if (DdN > 0) {
          if (backfaceCulling) return null
          sign = 1
        } else if (DdN < 0) {
          sign = -1
          DdN = -DdN
        } else {
          return null
        }

        diff.subVectors(this.origin, a)
        var DdQxE2 = sign * this.direction.dot(edge2.crossVectors(diff, edge2))

        // b1 < 0, no intersection
        if (DdQxE2 < 0) {
          return null
        }

        var DdE1xQ = sign * this.direction.dot(edge1.cross(diff))

        // b2 < 0, no intersection
        if (DdE1xQ < 0) {
          return null
        }

        // b1+b2 > 1, no intersection
        if (DdQxE2 + DdE1xQ > DdN) {
          return null
        }

        // Line intersects triangle, check if ray does.
        var QdN = -sign * diff.dot(normal)

        // t < 0, no intersection
        if (QdN < 0) {
          return null
        }

        // Ray intersects triangle.
        return this.at(QdN / DdN, optionalTarget)
      }
    })(),

    applyMatrix4: function (matrix4) {
      this.origin.applyMatrix4(matrix4)
      this.direction.transformDirection(matrix4)

      return this
    },

    equals: function (ray) {
      return ray.origin.equals(this.origin) && ray.direction.equals(this.direction)
    }
  })

  /**
   * @author bhouston / http://clara.io
   */

  function Line3(start, end) {
    this.start = start !== undefined ? start : new Vector3()
    this.end = end !== undefined ? end : new Vector3()
  }

  Object.assign(Line3.prototype, {
    set: function (start, end) {
      this.start.copy(start)
      this.end.copy(end)

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (line) {
      this.start.copy(line.start)
      this.end.copy(line.end)

      return this
    },

    getCenter: function (optionalTarget) {
      var result = optionalTarget || new Vector3()
      return result.addVectors(this.start, this.end).multiplyScalar(0.5)
    },

    delta: function (optionalTarget) {
      var result = optionalTarget || new Vector3()
      return result.subVectors(this.end, this.start)
    },

    distanceSq: function () {
      return this.start.distanceToSquared(this.end)
    },

    distance: function () {
      return this.start.distanceTo(this.end)
    },

    at: function (t, optionalTarget) {
      var result = optionalTarget || new Vector3()

      return this.delta(result).multiplyScalar(t).add(this.start)
    },

    closestPointToPointParameter: (function () {
      var startP = new Vector3()
      var startEnd = new Vector3()

      return function closestPointToPointParameter(point, clampToLine) {
        startP.subVectors(point, this.start)
        startEnd.subVectors(this.end, this.start)

        var startEnd2 = startEnd.dot(startEnd)
        var startEnd_startP = startEnd.dot(startP)

        var t = startEnd_startP / startEnd2

        if (clampToLine) {
          t = _Math.clamp(t, 0, 1)
        }

        return t
      }
    })(),

    closestPointToPoint: function (point, clampToLine, optionalTarget) {
      var t = this.closestPointToPointParameter(point, clampToLine)

      var result = optionalTarget || new Vector3()

      return this.delta(result).multiplyScalar(t).add(this.start)
    },

    applyMatrix4: function (matrix) {
      this.start.applyMatrix4(matrix)
      this.end.applyMatrix4(matrix)

      return this
    },

    equals: function (line) {
      return line.start.equals(this.start) && line.end.equals(this.end)
    }
  })

  /**
   * @author bhouston / http://clara.io
   * @author mrdoob / http://mrdoob.com/
   */

  function Triangle(a, b, c) {
    this.a = a !== undefined ? a : new Vector3()
    this.b = b !== undefined ? b : new Vector3()
    this.c = c !== undefined ? c : new Vector3()
  }

  Object.assign(Triangle, {
    normal: (function () {
      var v0 = new Vector3()

      return function normal(a, b, c, optionalTarget) {
        var result = optionalTarget || new Vector3()

        result.subVectors(c, b)
        v0.subVectors(a, b)
        result.cross(v0)

        var resultLengthSq = result.lengthSq()
        if (resultLengthSq > 0) {
          return result.multiplyScalar(1 / Math.sqrt(resultLengthSq))
        }

        return result.set(0, 0, 0)
      }
    })(),

    // static/instance method to calculate barycentric coordinates
    // based on: http://www.blackpawn.com/texts/pointinpoly/default.html
    barycoordFromPoint: (function () {
      var v0 = new Vector3()
      var v1 = new Vector3()
      var v2 = new Vector3()

      return function barycoordFromPoint(point, a, b, c, optionalTarget) {
        v0.subVectors(c, a)
        v1.subVectors(b, a)
        v2.subVectors(point, a)

        var dot00 = v0.dot(v0)
        var dot01 = v0.dot(v1)
        var dot02 = v0.dot(v2)
        var dot11 = v1.dot(v1)
        var dot12 = v1.dot(v2)

        var denom = dot00 * dot11 - dot01 * dot01

        var result = optionalTarget || new Vector3()

        // collinear or singular triangle
        if (denom === 0) {
          // arbitrary location outside of triangle?
          // not sure if this is the best idea, maybe should be returning undefined
          return result.set(-2, -1, -1)
        }

        var invDenom = 1 / denom
        var u = (dot11 * dot02 - dot01 * dot12) * invDenom
        var v = (dot00 * dot12 - dot01 * dot02) * invDenom

        // barycentric coordinates must always sum to 1
        return result.set(1 - u - v, v, u)
      }
    })(),

    containsPoint: (function () {
      var v1 = new Vector3()

      return function containsPoint(point, a, b, c) {
        var result = Triangle.barycoordFromPoint(point, a, b, c, v1)

        return result.x >= 0 && result.y >= 0 && result.x + result.y <= 1
      }
    })()
  })

  Object.assign(Triangle.prototype, {
    set: function (a, b, c) {
      this.a.copy(a)
      this.b.copy(b)
      this.c.copy(c)

      return this
    },

    setFromPointsAndIndices: function (points, i0, i1, i2) {
      this.a.copy(points[i0])
      this.b.copy(points[i1])
      this.c.copy(points[i2])

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (triangle) {
      this.a.copy(triangle.a)
      this.b.copy(triangle.b)
      this.c.copy(triangle.c)

      return this
    },

    area: (function () {
      var v0 = new Vector3()
      var v1 = new Vector3()

      return function area() {
        v0.subVectors(this.c, this.b)
        v1.subVectors(this.a, this.b)

        return v0.cross(v1).length() * 0.5
      }
    })(),

    midpoint: function (optionalTarget) {
      var result = optionalTarget || new Vector3()
      return result
        .addVectors(this.a, this.b)
        .add(this.c)
        .multiplyScalar(1 / 3)
    },

    normal: function (optionalTarget) {
      return Triangle.normal(this.a, this.b, this.c, optionalTarget)
    },

    plane: function (optionalTarget) {
      var result = optionalTarget || new Plane()

      return result.setFromCoplanarPoints(this.a, this.b, this.c)
    },

    barycoordFromPoint: function (point, optionalTarget) {
      return Triangle.barycoordFromPoint(point, this.a, this.b, this.c, optionalTarget)
    },

    containsPoint: function (point) {
      return Triangle.containsPoint(point, this.a, this.b, this.c)
    },

    intersectsBox: function (box) {
      return box.intersectsTriangle(this)
    },

    closestPointToPoint: (function () {
      var plane = new Plane()
      var edgeList = [new Line3(), new Line3(), new Line3()]
      var projectedPoint = new Vector3()
      var closestPoint = new Vector3()

      return function closestPointToPoint(point, optionalTarget) {
        var result = optionalTarget || new Vector3()
        var minDistance = Infinity

        // project the point onto the plane of the triangle

        plane.setFromCoplanarPoints(this.a, this.b, this.c)
        plane.projectPoint(point, projectedPoint)

        // check if the projection lies within the triangle

        if (this.containsPoint(projectedPoint) === true) {
          // if so, this is the closest point

          result.copy(projectedPoint)
        } else {
          // if not, the point falls outside the triangle. the result is the closest point to the triangle's edges or vertices

          edgeList[0].set(this.a, this.b)
          edgeList[1].set(this.b, this.c)
          edgeList[2].set(this.c, this.a)

          for (var i = 0; i < edgeList.length; i++) {
            edgeList[i].closestPointToPoint(projectedPoint, true, closestPoint)

            var distance = projectedPoint.distanceToSquared(closestPoint)

            if (distance < minDistance) {
              minDistance = distance

              result.copy(closestPoint)
            }
          }
        }

        return result
      }
    })(),

    equals: function (triangle) {
      return triangle.a.equals(this.a) && triangle.b.equals(this.b) && triangle.c.equals(this.c)
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   * @author mikael emtinger / http://gomo.se/
   * @author jonobr1 / http://jonobr1.com/
   */

  function Mesh(geometry, material) {
    Object3D.call(this)

    this.type = 'Mesh'

    this.geometry = geometry !== undefined ? geometry : new BufferGeometry()
    this.material =
      material !== undefined ? material : new MeshBasicMaterial({ color: Math.random() * 0xffffff })

    this.drawMode = TrianglesDrawMode

    this.updateMorphTargets()
  }

  Mesh.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Mesh,

    isMesh: true,

    setDrawMode: function (value) {
      this.drawMode = value
    },

    copy: function (source) {
      Object3D.prototype.copy.call(this, source)

      this.drawMode = source.drawMode

      if (source.morphTargetInfluences !== undefined) {
        this.morphTargetInfluences = source.morphTargetInfluences.slice()
      }

      if (source.morphTargetDictionary !== undefined) {
        this.morphTargetDictionary = Object.assign({}, source.morphTargetDictionary)
      }

      return this
    },

    updateMorphTargets: function () {
      var geometry = this.geometry
      var m, ml, name

      if (geometry.isBufferGeometry) {
        var morphAttributes = geometry.morphAttributes
        var keys = Object.keys(morphAttributes)

        if (keys.length > 0) {
          var morphAttribute = morphAttributes[keys[0]]

          if (morphAttribute !== undefined) {
            this.morphTargetInfluences = []
            this.morphTargetDictionary = {}

            for (m = 0, ml = morphAttribute.length; m < ml; m++) {
              name = morphAttribute[m].name || String(m)

              this.morphTargetInfluences.push(0)
              this.morphTargetDictionary[name] = m
            }
          }
        }
      } else {
        var morphTargets = geometry.morphTargets

        if (morphTargets !== undefined && morphTargets.length > 0) {
          this.morphTargetInfluences = []
          this.morphTargetDictionary = {}

          for (m = 0, ml = morphTargets.length; m < ml; m++) {
            name = morphTargets[m].name || String(m)

            this.morphTargetInfluences.push(0)
            this.morphTargetDictionary[name] = m
          }
        }
      }
    },

    raycast: (function () {
      var inverseMatrix = new Matrix4()
      var ray = new Ray()
      var sphere = new Sphere()

      var vA = new Vector3()
      var vB = new Vector3()
      var vC = new Vector3()

      var tempA = new Vector3()
      var tempB = new Vector3()
      var tempC = new Vector3()

      var uvA = new Vector2()
      var uvB = new Vector2()
      var uvC = new Vector2()

      var barycoord = new Vector3()

      var intersectionPoint = new Vector3()
      var intersectionPointWorld = new Vector3()

      function uvIntersection(point, p1, p2, p3, uv1, uv2, uv3) {
        Triangle.barycoordFromPoint(point, p1, p2, p3, barycoord)

        uv1.multiplyScalar(barycoord.x)
        uv2.multiplyScalar(barycoord.y)
        uv3.multiplyScalar(barycoord.z)

        uv1.add(uv2).add(uv3)

        return uv1.clone()
      }

      function checkIntersection(object, material, raycaster, ray, pA, pB, pC, point) {
        var intersect

        if (material.side === BackSide) {
          intersect = ray.intersectTriangle(pC, pB, pA, true, point)
        } else {
          intersect = ray.intersectTriangle(pA, pB, pC, material.side !== DoubleSide, point)
        }

        if (intersect === null) return null

        intersectionPointWorld.copy(point)
        intersectionPointWorld.applyMatrix4(object.matrixWorld)

        var distance = raycaster.ray.origin.distanceTo(intersectionPointWorld)

        if (distance < raycaster.near || distance > raycaster.far) return null

        return {
          distance: distance,
          point: intersectionPointWorld.clone(),
          object: object
        }
      }

      function checkBufferGeometryIntersection(object, raycaster, ray, position, uv, a, b, c) {
        vA.fromBufferAttribute(position, a)
        vB.fromBufferAttribute(position, b)
        vC.fromBufferAttribute(position, c)

        var intersection = checkIntersection(
          object,
          object.material,
          raycaster,
          ray,
          vA,
          vB,
          vC,
          intersectionPoint
        )

        if (intersection) {
          if (uv) {
            uvA.fromBufferAttribute(uv, a)
            uvB.fromBufferAttribute(uv, b)
            uvC.fromBufferAttribute(uv, c)

            intersection.uv = uvIntersection(intersectionPoint, vA, vB, vC, uvA, uvB, uvC)
          }

          intersection.face = new Face3(a, b, c, Triangle.normal(vA, vB, vC))
          intersection.faceIndex = a
        }

        return intersection
      }

      return function raycast(raycaster, intersects) {
        var geometry = this.geometry
        var material = this.material
        var matrixWorld = this.matrixWorld

        if (material === undefined) return

        // Checking boundingSphere distance to ray

        if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

        sphere.copy(geometry.boundingSphere)
        sphere.applyMatrix4(matrixWorld)

        if (raycaster.ray.intersectsSphere(sphere) === false) return

        //

        inverseMatrix.getInverse(matrixWorld)
        ray.copy(raycaster.ray).applyMatrix4(inverseMatrix)

        // Check boundingBox before continuing

        if (geometry.boundingBox !== null) {
          if (ray.intersectsBox(geometry.boundingBox) === false) return
        }

        var intersection

        if (geometry.isBufferGeometry) {
          var a, b, c
          var index = geometry.index
          var position = geometry.attributes.position
          var uv = geometry.attributes.uv
          var i, l

          if (index !== null) {
            // indexed buffer geometry

            for (i = 0, l = index.count; i < l; i += 3) {
              a = index.getX(i)
              b = index.getX(i + 1)
              c = index.getX(i + 2)

              intersection = checkBufferGeometryIntersection(
                this,
                raycaster,
                ray,
                position,
                uv,
                a,
                b,
                c
              )

              if (intersection) {
                intersection.faceIndex = Math.floor(i / 3) // triangle number in indices buffer semantics
                intersects.push(intersection)
              }
            }
          } else if (position !== undefined) {
            // non-indexed buffer geometry

            for (i = 0, l = position.count; i < l; i += 3) {
              a = i
              b = i + 1
              c = i + 2

              intersection = checkBufferGeometryIntersection(
                this,
                raycaster,
                ray,
                position,
                uv,
                a,
                b,
                c
              )

              if (intersection) {
                intersection.index = a // triangle number in positions buffer semantics
                intersects.push(intersection)
              }
            }
          }
        } else if (geometry.isGeometry) {
          var fvA, fvB, fvC
          var isMultiMaterial = Array.isArray(material)

          var vertices = geometry.vertices
          var faces = geometry.faces
          var uvs

          var faceVertexUvs = geometry.faceVertexUvs[0]
          if (faceVertexUvs.length > 0) uvs = faceVertexUvs

          for (var f = 0, fl = faces.length; f < fl; f++) {
            var face = faces[f]
            var faceMaterial = isMultiMaterial ? material[face.materialIndex] : material

            if (faceMaterial === undefined) continue

            fvA = vertices[face.a]
            fvB = vertices[face.b]
            fvC = vertices[face.c]

            if (faceMaterial.morphTargets === true) {
              var morphTargets = geometry.morphTargets
              var morphInfluences = this.morphTargetInfluences

              vA.set(0, 0, 0)
              vB.set(0, 0, 0)
              vC.set(0, 0, 0)

              for (var t = 0, tl = morphTargets.length; t < tl; t++) {
                var influence = morphInfluences[t]

                if (influence === 0) continue

                var targets = morphTargets[t].vertices

                vA.addScaledVector(tempA.subVectors(targets[face.a], fvA), influence)
                vB.addScaledVector(tempB.subVectors(targets[face.b], fvB), influence)
                vC.addScaledVector(tempC.subVectors(targets[face.c], fvC), influence)
              }

              vA.add(fvA)
              vB.add(fvB)
              vC.add(fvC)

              fvA = vA
              fvB = vB
              fvC = vC
            }

            intersection = checkIntersection(
              this,
              faceMaterial,
              raycaster,
              ray,
              fvA,
              fvB,
              fvC,
              intersectionPoint
            )

            if (intersection) {
              if (uvs && uvs[f]) {
                var uvs_f = uvs[f]
                uvA.copy(uvs_f[0])
                uvB.copy(uvs_f[1])
                uvC.copy(uvs_f[2])

                intersection.uv = uvIntersection(intersectionPoint, fvA, fvB, fvC, uvA, uvB, uvC)
              }

              intersection.face = face
              intersection.faceIndex = f
              intersects.push(intersection)
            }
          }
        }
      }
    })(),

    clone: function () {
      return new this.constructor(this.geometry, this.material).copy(this)
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLBackground(renderer, state, geometries, premultipliedAlpha) {
    var clearColor = new Color(0x000000)
    var clearAlpha = 0

    var planeCamera, planeMesh
    var boxMesh

    function render(renderList, scene, camera, forceClear) {
      var background = scene.background

      if (background === null) {
        setClear(clearColor, clearAlpha)
      } else if (background && background.isColor) {
        setClear(background, 1)
        forceClear = true
      }

      if (renderer.autoClear || forceClear) {
        renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil)
      }

      if (background && background.isCubeTexture) {
        if (boxMesh === undefined) {
          boxMesh = new Mesh(
            new BoxBufferGeometry(1, 1, 1),
            new ShaderMaterial({
              uniforms: ShaderLib.cube.uniforms,
              vertexShader: ShaderLib.cube.vertexShader,
              fragmentShader: ShaderLib.cube.fragmentShader,
              side: BackSide,
              depthTest: true,
              depthWrite: false,
              fog: false
            })
          )

          boxMesh.geometry.removeAttribute('normal')
          boxMesh.geometry.removeAttribute('uv')

          boxMesh.onBeforeRender = function (renderer, scene, camera) {
            this.matrixWorld.copyPosition(camera.matrixWorld)
          }

          geometries.update(boxMesh.geometry)
        }

        boxMesh.material.uniforms.tCube.value = background

        renderList.push(boxMesh, boxMesh.geometry, boxMesh.material, 0, null)
      } else if (background && background.isTexture) {
        if (planeCamera === undefined) {
          planeCamera = new OrthographicCamera(-1, 1, 1, -1, 0, 1)

          planeMesh = new Mesh(
            new PlaneBufferGeometry(2, 2),
            new MeshBasicMaterial({ depthTest: false, depthWrite: false, fog: false })
          )

          geometries.update(planeMesh.geometry)
        }

        planeMesh.material.map = background

        // TODO Push this to renderList

        renderer.renderBufferDirect(
          planeCamera,
          null,
          planeMesh.geometry,
          planeMesh.material,
          planeMesh,
          null
        )
      }
    }

    function setClear(color, alpha) {
      state.buffers.color.setClear(color.r, color.g, color.b, alpha, premultipliedAlpha)
    }

    return {
      getClearColor: function () {
        return clearColor
      },
      setClearColor: function (color, alpha) {
        clearColor.set(color)
        clearAlpha = alpha !== undefined ? alpha : 1
        setClear(clearColor, clearAlpha)
      },
      getClearAlpha: function () {
        return clearAlpha
      },
      setClearAlpha: function (alpha) {
        clearAlpha = alpha
        setClear(clearColor, clearAlpha)
      },
      render: render
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function painterSortStable(a, b) {
    if (a.renderOrder !== b.renderOrder) {
      return a.renderOrder - b.renderOrder
    } else if (a.program && b.program && a.program !== b.program) {
      return a.program.id - b.program.id
    } else if (a.material.id !== b.material.id) {
      return a.material.id - b.material.id
    } else if (a.z !== b.z) {
      return a.z - b.z
    } else {
      return a.id - b.id
    }
  }

  function reversePainterSortStable(a, b) {
    if (a.renderOrder !== b.renderOrder) {
      return a.renderOrder - b.renderOrder
    }
    if (a.z !== b.z) {
      return b.z - a.z
    } else {
      return a.id - b.id
    }
  }

  function WebGLRenderList() {
    var renderItems = []
    var renderItemsIndex = 0

    var opaque = []
    var transparent = []

    function init() {
      renderItemsIndex = 0

      opaque.length = 0
      transparent.length = 0
    }

    function push(object, geometry, material, z, group) {
      var renderItem = renderItems[renderItemsIndex]

      if (renderItem === undefined) {
        renderItem = {
          id: object.id,
          object: object,
          geometry: geometry,
          material: material,
          program: material.program,
          renderOrder: object.renderOrder,
          z: z,
          group: group
        }

        renderItems[renderItemsIndex] = renderItem
      } else {
        renderItem.id = object.id
        renderItem.object = object
        renderItem.geometry = geometry
        renderItem.material = material
        renderItem.program = material.program
        renderItem.renderOrder = object.renderOrder
        renderItem.z = z
        renderItem.group = group
      }

      ;(material.transparent === true ? transparent : opaque).push(renderItem)

      renderItemsIndex++
    }

    function sort() {
      if (opaque.length > 1) opaque.sort(painterSortStable)
      if (transparent.length > 1) transparent.sort(reversePainterSortStable)
    }

    return {
      opaque: opaque,
      transparent: transparent,

      init: init,
      push: push,

      sort: sort
    }
  }

  function WebGLRenderLists() {
    var lists = {}

    function get(scene, camera) {
      var hash = scene.id + ',' + camera.id
      var list = lists[hash]

      if (list === undefined) {
        // console.log( 'THREE.WebGLRenderLists:', hash );

        list = new WebGLRenderList()
        lists[hash] = list
      }

      return list
    }

    function dispose() {
      lists = {}
    }

    return {
      get: get,
      dispose: dispose
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function absNumericalSort(a, b) {
    return Math.abs(b[1]) - Math.abs(a[1])
  }

  function WebGLMorphtargets(gl) {
    var influencesList = {}
    var morphInfluences = new Float32Array(8)

    function update(object, geometry, material, program) {
      var objectInfluences = object.morphTargetInfluences

      var length = objectInfluences.length

      var influences = influencesList[geometry.id]

      if (influences === undefined) {
        // initialise list

        influences = []

        for (var i = 0; i < length; i++) {
          influences[i] = [i, 0]
        }

        influencesList[geometry.id] = influences
      }

      var morphTargets = material.morphTargets && geometry.morphAttributes.position
      var morphNormals = material.morphNormals && geometry.morphAttributes.normal

      // Remove current morphAttributes

      for (var i = 0; i < length; i++) {
        var influence = influences[i]

        if (influence[1] !== 0) {
          if (morphTargets) geometry.removeAttribute('morphTarget' + i)
          if (morphNormals) geometry.removeAttribute('morphNormal' + i)
        }
      }

      // Collect influences

      for (var i = 0; i < length; i++) {
        var influence = influences[i]

        influence[0] = i
        influence[1] = objectInfluences[i]
      }

      influences.sort(absNumericalSort)

      // Add morphAttributes

      for (var i = 0; i < 8; i++) {
        var influence = influences[i]

        if (influence) {
          var index = influence[0]
          var value = influence[1]

          if (value) {
            if (morphTargets) geometry.addAttribute('morphTarget' + i, morphTargets[index])
            if (morphNormals) geometry.addAttribute('morphNormal' + i, morphNormals[index])

            morphInfluences[i] = value
            continue
          }
        }

        morphInfluences[i] = 0
      }

      program.getUniforms().setValue(gl, 'morphTargetInfluences', morphInfluences)
    }

    return {
      update: update
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLIndexedBufferRenderer(gl, extensions, infoRender) {
    var mode

    function setMode(value) {
      mode = value
    }

    var type, bytesPerElement

    function setIndex(value) {
      type = value.type
      bytesPerElement = value.bytesPerElement
    }

    function render(start, count) {
      gl.drawElements(mode, count, type, start * bytesPerElement)

      infoRender.calls++
      infoRender.vertices += count

      if (mode === gl.TRIANGLES) infoRender.faces += count / 3
      else if (mode === gl.POINTS) infoRender.points += count
    }

    function renderInstances(geometry, start, count) {
      var extension = extensions.get('ANGLE_instanced_arrays')

      if (extension === null) {
        console.error(
          'THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.'
        )
        return
      }

      extension.drawElementsInstancedANGLE(
        mode,
        count,
        type,
        start * bytesPerElement,
        geometry.maxInstancedCount
      )

      infoRender.calls++
      infoRender.vertices += count * geometry.maxInstancedCount

      if (mode === gl.TRIANGLES) infoRender.faces += (geometry.maxInstancedCount * count) / 3
      else if (mode === gl.POINTS) infoRender.points += geometry.maxInstancedCount * count
    }

    //

    this.setMode = setMode
    this.setIndex = setIndex
    this.render = render
    this.renderInstances = renderInstances
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLBufferRenderer(gl, extensions, infoRender) {
    var mode

    function setMode(value) {
      mode = value
    }

    function render(start, count) {
      gl.drawArrays(mode, start, count)

      infoRender.calls++
      infoRender.vertices += count

      if (mode === gl.TRIANGLES) infoRender.faces += count / 3
      else if (mode === gl.POINTS) infoRender.points += count
    }

    function renderInstances(geometry, start, count) {
      var extension = extensions.get('ANGLE_instanced_arrays')

      if (extension === null) {
        console.error(
          'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.'
        )
        return
      }

      var position = geometry.attributes.position

      if (position.isInterleavedBufferAttribute) {
        count = position.data.count

        extension.drawArraysInstancedANGLE(mode, 0, count, geometry.maxInstancedCount)
      } else {
        extension.drawArraysInstancedANGLE(mode, start, count, geometry.maxInstancedCount)
      }

      infoRender.calls++
      infoRender.vertices += count * geometry.maxInstancedCount

      if (mode === gl.TRIANGLES) infoRender.faces += (geometry.maxInstancedCount * count) / 3
      else if (mode === gl.POINTS) infoRender.points += geometry.maxInstancedCount * count
    }

    //

    this.setMode = setMode
    this.render = render
    this.renderInstances = renderInstances
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLGeometries(gl, attributes, infoMemory) {
    var geometries = {}
    var wireframeAttributes = {}

    function onGeometryDispose(event) {
      var geometry = event.target
      var buffergeometry = geometries[geometry.id]

      if (buffergeometry.index !== null) {
        attributes.remove(buffergeometry.index)
      }

      for (var name in buffergeometry.attributes) {
        attributes.remove(buffergeometry.attributes[name])
      }

      geometry.removeEventListener('dispose', onGeometryDispose)

      delete geometries[geometry.id]

      // TODO Remove duplicate code

      var attribute = wireframeAttributes[geometry.id]

      if (attribute) {
        attributes.remove(attribute)
        delete wireframeAttributes[geometry.id]
      }

      attribute = wireframeAttributes[buffergeometry.id]

      if (attribute) {
        attributes.remove(attribute)
        delete wireframeAttributes[buffergeometry.id]
      }

      //

      infoMemory.geometries--
    }

    function get(object, geometry) {
      var buffergeometry = geometries[geometry.id]

      if (buffergeometry) return buffergeometry

      geometry.addEventListener('dispose', onGeometryDispose)

      if (geometry.isBufferGeometry) {
        buffergeometry = geometry
      } else if (geometry.isGeometry) {
        if (geometry._bufferGeometry === undefined) {
          geometry._bufferGeometry = new BufferGeometry().setFromObject(object)
        }

        buffergeometry = geometry._bufferGeometry
      }

      geometries[geometry.id] = buffergeometry

      infoMemory.geometries++

      return buffergeometry
    }

    function update(geometry) {
      var index = geometry.index
      var geometryAttributes = geometry.attributes

      if (index !== null) {
        attributes.update(index, gl.ELEMENT_ARRAY_BUFFER)
      }

      for (var name in geometryAttributes) {
        attributes.update(geometryAttributes[name], gl.ARRAY_BUFFER)
      }

      // morph targets

      var morphAttributes = geometry.morphAttributes

      for (var name in morphAttributes) {
        var array = morphAttributes[name]

        for (var i = 0, l = array.length; i < l; i++) {
          attributes.update(array[i], gl.ARRAY_BUFFER)
        }
      }
    }

    function getWireframeAttribute(geometry) {
      var attribute = wireframeAttributes[geometry.id]

      if (attribute) return attribute

      var indices = []

      var geometryIndex = geometry.index
      var geometryAttributes = geometry.attributes

      // console.time( 'wireframe' );

      if (geometryIndex !== null) {
        var array = geometryIndex.array

        for (var i = 0, l = array.length; i < l; i += 3) {
          var a = array[i + 0]
          var b = array[i + 1]
          var c = array[i + 2]

          indices.push(a, b, b, c, c, a)
        }
      } else {
        var array = geometryAttributes.position.array

        for (var i = 0, l = array.length / 3 - 1; i < l; i += 3) {
          var a = i + 0
          var b = i + 1
          var c = i + 2

          indices.push(a, b, b, c, c, a)
        }
      }

      // console.timeEnd( 'wireframe' );

      attribute = new (arrayMax(indices) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute)(
        indices,
        1
      )

      attributes.update(attribute, gl.ELEMENT_ARRAY_BUFFER)

      wireframeAttributes[geometry.id] = attribute

      return attribute
    }

    return {
      get: get,
      update: update,

      getWireframeAttribute: getWireframeAttribute
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLObjects(geometries, infoRender) {
    var updateList = {}

    function update(object) {
      var frame = infoRender.frame

      var geometry = object.geometry
      var buffergeometry = geometries.get(object, geometry)

      // Update once per frame

      if (updateList[buffergeometry.id] !== frame) {
        if (geometry.isGeometry) {
          buffergeometry.updateFromObject(object)
        }

        geometries.update(buffergeometry)

        updateList[buffergeometry.id] = frame
      }

      return buffergeometry
    }

    function dispose() {
      updateList = {}
    }

    return {
      update: update,
      dispose: dispose
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function addLineNumbers(string) {
    var lines = string.split('\n')

    for (var i = 0; i < lines.length; i++) {
      lines[i] = i + 1 + ': ' + lines[i]
    }

    return lines.join('\n')
  }

  function WebGLShader(gl, type, string) {
    var shader = gl.createShader(type)

    gl.shaderSource(shader, string)
    gl.compileShader(shader)

    if (gl.getShaderParameter(shader, gl.COMPILE_STATUS) === false) {
      console.error("THREE.WebGLShader: Shader couldn't compile.")
    }

    if (gl.getShaderInfoLog(shader) !== '') {
      console.warn(
        'THREE.WebGLShader: gl.getShaderInfoLog()',
        type === gl.VERTEX_SHADER ? 'vertex' : 'fragment',
        gl.getShaderInfoLog(shader),
        addLineNumbers(string)
      )
    }

    // --enable-privileged-webgl-extension
    // console.log( type, gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );

    return shader
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  var programIdCount = 0

  function getEncodingComponents(encoding) {
    switch (encoding) {
      case LinearEncoding:
        return ['Linear', '( value )']
      case sRGBEncoding:
        return ['sRGB', '( value )']
      case RGBEEncoding:
        return ['RGBE', '( value )']
      case RGBM7Encoding:
        return ['RGBM', '( value, 7.0 )']
      case RGBM16Encoding:
        return ['RGBM', '( value, 16.0 )']
      case RGBDEncoding:
        return ['RGBD', '( value, 256.0 )']
      case GammaEncoding:
        return ['Gamma', '( value, float( GAMMA_FACTOR ) )']
      default:
        throw new Error('unsupported encoding: ' + encoding)
    }
  }

  function getTexelDecodingFunction(functionName, encoding) {
    var components = getEncodingComponents(encoding)
    return (
      'vec4 ' +
      functionName +
      '( vec4 value ) { return ' +
      components[0] +
      'ToLinear' +
      components[1] +
      '; }'
    )
  }

  function getTexelEncodingFunction(functionName, encoding) {
    var components = getEncodingComponents(encoding)
    return (
      'vec4 ' +
      functionName +
      '( vec4 value ) { return LinearTo' +
      components[0] +
      components[1] +
      '; }'
    )
  }

  function getToneMappingFunction(functionName, toneMapping) {
    var toneMappingName

    switch (toneMapping) {
      case LinearToneMapping:
        toneMappingName = 'Linear'
        break

      case ReinhardToneMapping:
        toneMappingName = 'Reinhard'
        break

      case Uncharted2ToneMapping:
        toneMappingName = 'Uncharted2'
        break

      case CineonToneMapping:
        toneMappingName = 'OptimizedCineon'
        break

      default:
        throw new Error('unsupported toneMapping: ' + toneMapping)
    }

    return (
      'vec3 ' +
      functionName +
      '( vec3 color ) { return ' +
      toneMappingName +
      'ToneMapping( color ); }'
    )
  }

  function generateExtensions(extensions, parameters, rendererExtensions) {
    extensions = extensions || {}

    var chunks = [
      extensions.derivatives ||
      parameters.envMapCubeUV ||
      parameters.bumpMap ||
      parameters.normalMap ||
      parameters.flatShading
        ? '#extension GL_OES_standard_derivatives : enable'
        : '',
      (extensions.fragDepth || parameters.logarithmicDepthBuffer) &&
      rendererExtensions.get('EXT_frag_depth')
        ? '#extension GL_EXT_frag_depth : enable'
        : '',
      extensions.drawBuffers && rendererExtensions.get('WEBGL_draw_buffers')
        ? '#extension GL_EXT_draw_buffers : require'
        : '',
      (extensions.shaderTextureLOD || parameters.envMap) &&
      rendererExtensions.get('EXT_shader_texture_lod')
        ? '#extension GL_EXT_shader_texture_lod : enable'
        : ''
    ]

    return chunks.filter(filterEmptyLine).join('\n')
  }

  function generateDefines(defines) {
    var chunks = []

    for (var name in defines) {
      var value = defines[name]

      if (value === false) continue

      chunks.push('#define ' + name + ' ' + value)
    }

    return chunks.join('\n')
  }

  function fetchAttributeLocations(gl, program) {
    var attributes = {}

    var n = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES)

    for (var i = 0; i < n; i++) {
      var info = gl.getActiveAttrib(program, i)
      var name = info.name

      // console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );

      attributes[name] = gl.getAttribLocation(program, name)
    }

    return attributes
  }

  function filterEmptyLine(string) {
    return string !== ''
  }

  function replaceLightNums(string, parameters) {
    return string
      .replace(/NUM_DIR_LIGHTS/g, parameters.numDirLights)
      .replace(/NUM_SPOT_LIGHTS/g, parameters.numSpotLights)
      .replace(/NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights)
      .replace(/NUM_POINT_LIGHTS/g, parameters.numPointLights)
      .replace(/NUM_HEMI_LIGHTS/g, parameters.numHemiLights)
  }

  function replaceClippingPlaneNums(string, parameters) {
    return string
      .replace(/NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes)
      .replace(
        /UNION_CLIPPING_PLANES/g,
        parameters.numClippingPlanes - parameters.numClipIntersection
      )
  }

  function parseIncludes(string) {
    var pattern = /^[ \t]*#include +<([\w\d.]+)>/gm

    function replace(match, include) {
      var replace = ShaderChunk[include]

      if (replace === undefined) {
        throw new Error('Can not resolve #include <' + include + '>')
      }

      return parseIncludes(replace)
    }

    return string.replace(pattern, replace)
  }

  function unrollLoops(string) {
    var pattern =
      /#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g

    function replace(match, start, end, snippet) {
      var unroll = ''

      for (var i = parseInt(start); i < parseInt(end); i++) {
        unroll += snippet.replace(/\[ i \]/g, '[ ' + i + ' ]')
      }

      return unroll
    }

    return string.replace(pattern, replace)
  }

  function WebGLProgram(renderer, extensions, code, material, shader, parameters) {
    var gl = renderer.context

    var defines = material.defines

    var vertexShader = shader.vertexShader
    var fragmentShader = shader.fragmentShader

    var shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC'

    if (parameters.shadowMapType === PCFShadowMap) {
      shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF'
    } else if (parameters.shadowMapType === PCFSoftShadowMap) {
      shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT'
    }

    var envMapTypeDefine = 'ENVMAP_TYPE_CUBE'
    var envMapModeDefine = 'ENVMAP_MODE_REFLECTION'
    var envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY'

    if (parameters.envMap) {
      switch (material.envMap.mapping) {
        case CubeReflectionMapping:
        case CubeRefractionMapping:
          envMapTypeDefine = 'ENVMAP_TYPE_CUBE'
          break

        case CubeUVReflectionMapping:
        case CubeUVRefractionMapping:
          envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV'
          break

        case EquirectangularReflectionMapping:
        case EquirectangularRefractionMapping:
          envMapTypeDefine = 'ENVMAP_TYPE_EQUIREC'
          break

        case SphericalReflectionMapping:
          envMapTypeDefine = 'ENVMAP_TYPE_SPHERE'
          break
      }

      switch (material.envMap.mapping) {
        case CubeRefractionMapping:
        case EquirectangularRefractionMapping:
          envMapModeDefine = 'ENVMAP_MODE_REFRACTION'
          break
      }

      switch (material.combine) {
        case MultiplyOperation:
          envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY'
          break

        case MixOperation:
          envMapBlendingDefine = 'ENVMAP_BLENDING_MIX'
          break

        case AddOperation:
          envMapBlendingDefine = 'ENVMAP_BLENDING_ADD'
          break
      }
    }

    var gammaFactorDefine = renderer.gammaFactor > 0 ? renderer.gammaFactor : 1.0

    // console.log( 'building new program ' );

    //

    var customExtensions = generateExtensions(material.extensions, parameters, extensions)

    var customDefines = generateDefines(defines)

    //

    var program = gl.createProgram()

    var prefixVertex, prefixFragment

    if (material.isRawShaderMaterial) {
      prefixVertex = [customDefines].filter(filterEmptyLine).join('\n')

      if (prefixVertex.length > 0) {
        prefixVertex += '\n'
      }

      prefixFragment = [customExtensions, customDefines].filter(filterEmptyLine).join('\n')

      if (prefixFragment.length > 0) {
        prefixFragment += '\n'
      }
    } else {
      prefixVertex = [
        'precision ' + parameters.precision + ' float;',
        'precision ' + parameters.precision + ' int;',

        '#define SHADER_NAME ' + shader.name,

        customDefines,

        parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',

        '#define GAMMA_FACTOR ' + gammaFactorDefine,

        '#define MAX_BONES ' + parameters.maxBones,
        parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
        parameters.useFog && parameters.fogExp ? '#define FOG_EXP2' : '',

        parameters.map ? '#define USE_MAP' : '',
        parameters.envMap ? '#define USE_ENVMAP' : '',
        parameters.envMap ? '#define ' + envMapModeDefine : '',
        parameters.lightMap ? '#define USE_LIGHTMAP' : '',
        parameters.aoMap ? '#define USE_AOMAP' : '',
        parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
        parameters.bumpMap ? '#define USE_BUMPMAP' : '',
        parameters.normalMap ? '#define USE_NORMALMAP' : '',
        parameters.displacementMap && parameters.supportsVertexTextures
          ? '#define USE_DISPLACEMENTMAP'
          : '',
        parameters.specularMap ? '#define USE_SPECULARMAP' : '',
        parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
        parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
        parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
        parameters.vertexColors ? '#define USE_COLOR' : '',

        parameters.flatShading ? '#define FLAT_SHADED' : '',

        parameters.skinning ? '#define USE_SKINNING' : '',
        parameters.useVertexTexture ? '#define BONE_TEXTURE' : '',

        parameters.morphTargets ? '#define USE_MORPHTARGETS' : '',
        parameters.morphNormals && parameters.flatShading === false
          ? '#define USE_MORPHNORMALS'
          : '',
        parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
        parameters.flipSided ? '#define FLIP_SIDED' : '',

        parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
        parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',

        parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',

        parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
        parameters.logarithmicDepthBuffer && extensions.get('EXT_frag_depth')
          ? '#define USE_LOGDEPTHBUF_EXT'
          : '',

        'uniform mat4 modelMatrix;',
        'uniform mat4 modelViewMatrix;',
        'uniform mat4 projectionMatrix;',
        'uniform mat4 viewMatrix;',
        'uniform mat3 normalMatrix;',
        'uniform vec3 cameraPosition;',

        'attribute vec3 position;',
        'attribute vec3 normal;',
        'attribute vec2 uv;',

        '#ifdef USE_COLOR',

        '	attribute vec3 color;',

        '#endif',

        '#ifdef USE_MORPHTARGETS',

        '	attribute vec3 morphTarget0;',
        '	attribute vec3 morphTarget1;',
        '	attribute vec3 morphTarget2;',
        '	attribute vec3 morphTarget3;',

        '	#ifdef USE_MORPHNORMALS',

        '		attribute vec3 morphNormal0;',
        '		attribute vec3 morphNormal1;',
        '		attribute vec3 morphNormal2;',
        '		attribute vec3 morphNormal3;',

        '	#else',

        '		attribute vec3 morphTarget4;',
        '		attribute vec3 morphTarget5;',
        '		attribute vec3 morphTarget6;',
        '		attribute vec3 morphTarget7;',

        '	#endif',

        '#endif',

        '#ifdef USE_SKINNING',

        '	attribute vec4 skinIndex;',
        '	attribute vec4 skinWeight;',

        '#endif',

        '\n'
      ]
        .filter(filterEmptyLine)
        .join('\n')

      prefixFragment = [
        customExtensions,

        'precision ' + parameters.precision + ' float;',
        'precision ' + parameters.precision + ' int;',

        '#define SHADER_NAME ' + shader.name,

        customDefines,

        parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '',

        '#define GAMMA_FACTOR ' + gammaFactorDefine,

        parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
        parameters.useFog && parameters.fogExp ? '#define FOG_EXP2' : '',

        parameters.map ? '#define USE_MAP' : '',
        parameters.envMap ? '#define USE_ENVMAP' : '',
        parameters.envMap ? '#define ' + envMapTypeDefine : '',
        parameters.envMap ? '#define ' + envMapModeDefine : '',
        parameters.envMap ? '#define ' + envMapBlendingDefine : '',
        parameters.lightMap ? '#define USE_LIGHTMAP' : '',
        parameters.aoMap ? '#define USE_AOMAP' : '',
        parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
        parameters.bumpMap ? '#define USE_BUMPMAP' : '',
        parameters.normalMap ? '#define USE_NORMALMAP' : '',
        parameters.specularMap ? '#define USE_SPECULARMAP' : '',
        parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
        parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
        parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
        parameters.vertexColors ? '#define USE_COLOR' : '',

        parameters.gradientMap ? '#define USE_GRADIENTMAP' : '',

        parameters.flatShading ? '#define FLAT_SHADED' : '',

        parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
        parameters.flipSided ? '#define FLIP_SIDED' : '',

        parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
        parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',

        parameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',

        parameters.physicallyCorrectLights ? '#define PHYSICALLY_CORRECT_LIGHTS' : '',

        parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
        parameters.logarithmicDepthBuffer && extensions.get('EXT_frag_depth')
          ? '#define USE_LOGDEPTHBUF_EXT'
          : '',

        parameters.envMap && extensions.get('EXT_shader_texture_lod')
          ? '#define TEXTURE_LOD_EXT'
          : '',

        'uniform mat4 viewMatrix;',
        'uniform vec3 cameraPosition;',

        parameters.toneMapping !== NoToneMapping ? '#define TONE_MAPPING' : '',
        parameters.toneMapping !== NoToneMapping ? ShaderChunk['tonemapping_pars_fragment'] : '', // this code is required here because it is used by the toneMapping() function defined below
        parameters.toneMapping !== NoToneMapping
          ? getToneMappingFunction('toneMapping', parameters.toneMapping)
          : '',

        parameters.dithering ? '#define DITHERING' : '',

        parameters.outputEncoding ||
        parameters.mapEncoding ||
        parameters.envMapEncoding ||
        parameters.emissiveMapEncoding
          ? ShaderChunk['encodings_pars_fragment']
          : '', // this code is required here because it is used by the various encoding/decoding function defined below
        parameters.mapEncoding
          ? getTexelDecodingFunction('mapTexelToLinear', parameters.mapEncoding)
          : '',
        parameters.envMapEncoding
          ? getTexelDecodingFunction('envMapTexelToLinear', parameters.envMapEncoding)
          : '',
        parameters.emissiveMapEncoding
          ? getTexelDecodingFunction('emissiveMapTexelToLinear', parameters.emissiveMapEncoding)
          : '',
        parameters.outputEncoding
          ? getTexelEncodingFunction('linearToOutputTexel', parameters.outputEncoding)
          : '',

        parameters.depthPacking ? '#define DEPTH_PACKING ' + material.depthPacking : '',

        '\n'
      ]
        .filter(filterEmptyLine)
        .join('\n')
    }

    vertexShader = parseIncludes(vertexShader)
    vertexShader = replaceLightNums(vertexShader, parameters)
    vertexShader = replaceClippingPlaneNums(vertexShader, parameters)

    fragmentShader = parseIncludes(fragmentShader)
    fragmentShader = replaceLightNums(fragmentShader, parameters)
    fragmentShader = replaceClippingPlaneNums(fragmentShader, parameters)

    vertexShader = unrollLoops(vertexShader)
    fragmentShader = unrollLoops(fragmentShader)

    var vertexGlsl = prefixVertex + vertexShader
    var fragmentGlsl = prefixFragment + fragmentShader

    // console.log( '*VERTEX*', vertexGlsl );
    // console.log( '*FRAGMENT*', fragmentGlsl );

    var glVertexShader = WebGLShader(gl, gl.VERTEX_SHADER, vertexGlsl)
    var glFragmentShader = WebGLShader(gl, gl.FRAGMENT_SHADER, fragmentGlsl)

    gl.attachShader(program, glVertexShader)
    gl.attachShader(program, glFragmentShader)

    // Force a particular attribute to index 0.

    if (material.index0AttributeName !== undefined) {
      gl.bindAttribLocation(program, 0, material.index0AttributeName)
    } else if (parameters.morphTargets === true) {
      // programs with morphTargets displace position out of attribute 0
      gl.bindAttribLocation(program, 0, 'position')
    }

    gl.linkProgram(program)

    var programLog = gl.getProgramInfoLog(program).trim()
    var vertexLog = gl.getShaderInfoLog(glVertexShader).trim()
    var fragmentLog = gl.getShaderInfoLog(glFragmentShader).trim()

    var runnable = true
    var haveDiagnostics = true

    // console.log( '**VERTEX**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader ) );
    // console.log( '**FRAGMENT**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader ) );

    if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {
      runnable = false

      console.error(
        'THREE.WebGLProgram: shader error: ',
        gl.getError(),
        'gl.VALIDATE_STATUS',
        gl.getProgramParameter(program, gl.VALIDATE_STATUS),
        'gl.getProgramInfoLog',
        programLog,
        vertexLog,
        fragmentLog
      )
    } else if (programLog !== '') {
      console.warn('THREE.WebGLProgram: gl.getProgramInfoLog()', programLog)
    } else if (vertexLog === '' || fragmentLog === '') {
      haveDiagnostics = false
    }

    if (haveDiagnostics) {
      this.diagnostics = {
        runnable: runnable,
        material: material,

        programLog: programLog,

        vertexShader: {
          log: vertexLog,
          prefix: prefixVertex
        },

        fragmentShader: {
          log: fragmentLog,
          prefix: prefixFragment
        }
      }
    }

    // clean up

    gl.deleteShader(glVertexShader)
    gl.deleteShader(glFragmentShader)

    // set up caching for uniform locations

    var cachedUniforms

    this.getUniforms = function () {
      if (cachedUniforms === undefined) {
        cachedUniforms = new WebGLUniforms(gl, program, renderer)
      }

      return cachedUniforms
    }

    // set up caching for attribute locations

    var cachedAttributes

    this.getAttributes = function () {
      if (cachedAttributes === undefined) {
        cachedAttributes = fetchAttributeLocations(gl, program)
      }

      return cachedAttributes
    }

    // free resource

    this.destroy = function () {
      gl.deleteProgram(program)
      this.program = undefined
    }

    // DEPRECATED

    Object.defineProperties(this, {
      uniforms: {
        get: function () {
          console.warn('THREE.WebGLProgram: .uniforms is now .getUniforms().')
          return this.getUniforms()
        }
      },

      attributes: {
        get: function () {
          console.warn('THREE.WebGLProgram: .attributes is now .getAttributes().')
          return this.getAttributes()
        }
      }
    })

    //

    this.id = programIdCount++
    this.code = code
    this.usedTimes = 1
    this.program = program
    this.vertexShader = glVertexShader
    this.fragmentShader = glFragmentShader

    return this
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLPrograms(renderer, extensions, capabilities) {
    var programs = []

    var shaderIDs = {
      MeshDepthMaterial: 'depth',
      MeshDistanceMaterial: 'distanceRGBA',
      MeshNormalMaterial: 'normal',
      MeshBasicMaterial: 'basic',
      MeshLambertMaterial: 'lambert',
      MeshPhongMaterial: 'phong',
      MeshToonMaterial: 'phong',
      MeshStandardMaterial: 'physical',
      MeshPhysicalMaterial: 'physical',
      LineBasicMaterial: 'basic',
      LineDashedMaterial: 'dashed',
      PointsMaterial: 'points',
      ShadowMaterial: 'shadow'
    }

    var parameterNames = [
      'precision',
      'supportsVertexTextures',
      'map',
      'mapEncoding',
      'envMap',
      'envMapMode',
      'envMapEncoding',
      'lightMap',
      'aoMap',
      'emissiveMap',
      'emissiveMapEncoding',
      'bumpMap',
      'normalMap',
      'displacementMap',
      'specularMap',
      'roughnessMap',
      'metalnessMap',
      'gradientMap',
      'alphaMap',
      'combine',
      'vertexColors',
      'fog',
      'useFog',
      'fogExp',
      'flatShading',
      'sizeAttenuation',
      'logarithmicDepthBuffer',
      'skinning',
      'maxBones',
      'useVertexTexture',
      'morphTargets',
      'morphNormals',
      'maxMorphTargets',
      'maxMorphNormals',
      'premultipliedAlpha',
      'numDirLights',
      'numPointLights',
      'numSpotLights',
      'numHemiLights',
      'numRectAreaLights',
      'shadowMapEnabled',
      'shadowMapType',
      'toneMapping',
      'physicallyCorrectLights',
      'alphaTest',
      'doubleSided',
      'flipSided',
      'numClippingPlanes',
      'numClipIntersection',
      'depthPacking',
      'dithering'
    ]

    function allocateBones(object) {
      var skeleton = object.skeleton
      var bones = skeleton.bones

      if (capabilities.floatVertexTextures) {
        return 1024
      } else {
        // default for when object is not specified
        // ( for example when prebuilding shader to be used with multiple objects )
        //
        //  - leave some extra space for other uniforms
        //  - limit here is ANGLE's 254 max uniform vectors
        //    (up to 54 should be safe)

        var nVertexUniforms = capabilities.maxVertexUniforms
        var nVertexMatrices = Math.floor((nVertexUniforms - 20) / 4)

        var maxBones = Math.min(nVertexMatrices, bones.length)

        if (maxBones < bones.length) {
          console.warn(
            'THREE.WebGLRenderer: Skeleton has ' +
              bones.length +
              ' bones. This GPU supports ' +
              maxBones +
              '.'
          )
          return 0
        }

        return maxBones
      }
    }

    function getTextureEncodingFromMap(map, gammaOverrideLinear) {
      var encoding

      if (!map) {
        encoding = LinearEncoding
      } else if (map.isTexture) {
        encoding = map.encoding
      } else if (map.isWebGLRenderTarget) {
        console.warn(
          "THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead."
        )
        encoding = map.texture.encoding
      }

      // add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point.
      if (encoding === LinearEncoding && gammaOverrideLinear) {
        encoding = GammaEncoding
      }

      return encoding
    }

    this.getParameters = function (
      material,
      lights,
      shadows,
      fog,
      nClipPlanes,
      nClipIntersection,
      object
    ) {
      var shaderID = shaderIDs[material.type]

      // heuristics to create shader parameters according to lights in the scene
      // (not to blow over maxLights budget)

      var maxBones = object.isSkinnedMesh ? allocateBones(object) : 0
      var precision = capabilities.precision

      if (material.precision !== null) {
        precision = capabilities.getMaxPrecision(material.precision)

        if (precision !== material.precision) {
          console.warn(
            'THREE.WebGLProgram.getParameters:',
            material.precision,
            'not supported, using',
            precision,
            'instead.'
          )
        }
      }

      var currentRenderTarget = renderer.getRenderTarget()

      var parameters = {
        shaderID: shaderID,

        precision: precision,
        supportsVertexTextures: capabilities.vertexTextures,
        outputEncoding: getTextureEncodingFromMap(
          !currentRenderTarget ? null : currentRenderTarget.texture,
          renderer.gammaOutput
        ),
        map: !!material.map,
        mapEncoding: getTextureEncodingFromMap(material.map, renderer.gammaInput),
        envMap: !!material.envMap,
        envMapMode: material.envMap && material.envMap.mapping,
        envMapEncoding: getTextureEncodingFromMap(material.envMap, renderer.gammaInput),
        envMapCubeUV:
          !!material.envMap &&
          (material.envMap.mapping === CubeUVReflectionMapping ||
            material.envMap.mapping === CubeUVRefractionMapping),
        lightMap: !!material.lightMap,
        aoMap: !!material.aoMap,
        emissiveMap: !!material.emissiveMap,
        emissiveMapEncoding: getTextureEncodingFromMap(material.emissiveMap, renderer.gammaInput),
        bumpMap: !!material.bumpMap,
        normalMap: !!material.normalMap,
        displacementMap: !!material.displacementMap,
        roughnessMap: !!material.roughnessMap,
        metalnessMap: !!material.metalnessMap,
        specularMap: !!material.specularMap,
        alphaMap: !!material.alphaMap,

        gradientMap: !!material.gradientMap,

        combine: material.combine,

        vertexColors: material.vertexColors,

        fog: !!fog,
        useFog: material.fog,
        fogExp: fog && fog.isFogExp2,

        flatShading: material.flatShading,

        sizeAttenuation: material.sizeAttenuation,
        logarithmicDepthBuffer: capabilities.logarithmicDepthBuffer,

        skinning: material.skinning && maxBones > 0,
        maxBones: maxBones,
        useVertexTexture: capabilities.floatVertexTextures,

        morphTargets: material.morphTargets,
        morphNormals: material.morphNormals,
        maxMorphTargets: renderer.maxMorphTargets,
        maxMorphNormals: renderer.maxMorphNormals,

        numDirLights: lights.directional.length,
        numPointLights: lights.point.length,
        numSpotLights: lights.spot.length,
        numRectAreaLights: lights.rectArea.length,
        numHemiLights: lights.hemi.length,

        numClippingPlanes: nClipPlanes,
        numClipIntersection: nClipIntersection,

        dithering: material.dithering,

        shadowMapEnabled: renderer.shadowMap.enabled && object.receiveShadow && shadows.length > 0,
        shadowMapType: renderer.shadowMap.type,

        toneMapping: renderer.toneMapping,
        physicallyCorrectLights: renderer.physicallyCorrectLights,

        premultipliedAlpha: material.premultipliedAlpha,

        alphaTest: material.alphaTest,
        doubleSided: material.side === DoubleSide,
        flipSided: material.side === BackSide,

        depthPacking: material.depthPacking !== undefined ? material.depthPacking : false
      }

      return parameters
    }

    this.getProgramCode = function (material, parameters) {
      var array = []

      if (parameters.shaderID) {
        array.push(parameters.shaderID)
      } else {
        array.push(material.fragmentShader)
        array.push(material.vertexShader)
      }

      if (material.defines !== undefined) {
        for (var name in material.defines) {
          array.push(name)
          array.push(material.defines[name])
        }
      }

      for (var i = 0; i < parameterNames.length; i++) {
        array.push(parameters[parameterNames[i]])
      }

      array.push(material.onBeforeCompile.toString())

      array.push(renderer.gammaOutput)

      return array.join()
    }

    this.acquireProgram = function (material, shader, parameters, code) {
      var program

      // Check if code has been already compiled
      for (var p = 0, pl = programs.length; p < pl; p++) {
        var programInfo = programs[p]

        if (programInfo.code === code) {
          program = programInfo
          ++program.usedTimes

          break
        }
      }

      if (program === undefined) {
        program = new WebGLProgram(renderer, extensions, code, material, shader, parameters)
        programs.push(program)
      }

      return program
    }

    this.releaseProgram = function (program) {
      if (--program.usedTimes === 0) {
        // Remove from unordered set
        var i = programs.indexOf(program)
        programs[i] = programs[programs.length - 1]
        programs.pop()

        // Free WebGL resources
        program.destroy()
      }
    }

    // Exposed for resource monitoring & error feedback via renderer.info:
    this.programs = programs
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLTextures(
    _gl,
    extensions,
    state,
    properties,
    capabilities,
    utils,
    infoMemory,
    infoRender
  ) {
    var _isWebGL2 =
      typeof WebGL2RenderingContext !== 'undefined' && _gl instanceof WebGL2RenderingContext
    var _videoTextures = {}
    var _canvas

    //

    function clampToMaxSize(image, maxSize) {
      if (image.width > maxSize || image.height > maxSize) {
        // Warning: Scaling through the canvas will only work with images that use
        // premultiplied alpha.

        var scale = maxSize / Math.max(image.width, image.height)

        var canvas = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')
        canvas.width = Math.floor(image.width * scale)
        canvas.height = Math.floor(image.height * scale)

        var context = canvas.getContext('2d')
        context.drawImage(image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height)

        console.warn(
          'THREE.WebGLRenderer: image is too big (' +
            image.width +
            'x' +
            image.height +
            '). Resized to ' +
            canvas.width +
            'x' +
            canvas.height,
          image
        )

        return canvas
      }

      return image
    }

    function isPowerOfTwo(image) {
      return _Math.isPowerOfTwo(image.width) && _Math.isPowerOfTwo(image.height)
    }

    function makePowerOfTwo(image) {
      if (
        image instanceof HTMLImageElement ||
        image instanceof HTMLCanvasElement ||
        image instanceof ImageBitmap
      ) {
        if (_canvas === undefined)
          _canvas = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')

        _canvas.width = _Math.floorPowerOfTwo(image.width)
        _canvas.height = _Math.floorPowerOfTwo(image.height)

        var context = _canvas.getContext('2d')
        context.drawImage(image, 0, 0, _canvas.width, _canvas.height)

        console.warn(
          'THREE.WebGLRenderer: image is not power of two (' +
            image.width +
            'x' +
            image.height +
            '). Resized to ' +
            _canvas.width +
            'x' +
            _canvas.height,
          image
        )

        return _canvas
      }

      return image
    }

    function textureNeedsPowerOfTwo(texture) {
      return (
        texture.wrapS !== ClampToEdgeWrapping ||
        texture.wrapT !== ClampToEdgeWrapping ||
        (texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter)
      )
    }

    function textureNeedsGenerateMipmaps(texture, isPowerOfTwo) {
      return (
        texture.generateMipmaps &&
        isPowerOfTwo &&
        texture.minFilter !== NearestFilter &&
        texture.minFilter !== LinearFilter
      )
    }

    // Fallback filters for non-power-of-2 textures

    function filterFallback(f) {
      if (
        f === NearestFilter ||
        f === NearestMipMapNearestFilter ||
        f === NearestMipMapLinearFilter
      ) {
        return _gl.NEAREST
      }

      return _gl.LINEAR
    }

    //

    function onTextureDispose(event) {
      var texture = event.target

      texture.removeEventListener('dispose', onTextureDispose)

      deallocateTexture(texture)

      if (texture.isVideoTexture) {
        delete _videoTextures[texture.id]
      }

      infoMemory.textures--
    }

    function onRenderTargetDispose(event) {
      var renderTarget = event.target

      renderTarget.removeEventListener('dispose', onRenderTargetDispose)

      deallocateRenderTarget(renderTarget)

      infoMemory.textures--
    }

    //

    function deallocateTexture(texture) {
      var textureProperties = properties.get(texture)

      if (texture.image && textureProperties.__image__webglTextureCube) {
        // cube texture

        _gl.deleteTexture(textureProperties.__image__webglTextureCube)
      } else {
        // 2D texture

        if (textureProperties.__webglInit === undefined) return

        _gl.deleteTexture(textureProperties.__webglTexture)
      }

      // remove all webgl properties
      properties.remove(texture)
    }

    function deallocateRenderTarget(renderTarget) {
      var renderTargetProperties = properties.get(renderTarget)
      var textureProperties = properties.get(renderTarget.texture)

      if (!renderTarget) return

      if (textureProperties.__webglTexture !== undefined) {
        _gl.deleteTexture(textureProperties.__webglTexture)
      }

      if (renderTarget.depthTexture) {
        renderTarget.depthTexture.dispose()
      }

      if (renderTarget.isWebGLRenderTargetCube) {
        for (var i = 0; i < 6; i++) {
          _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i])
          if (renderTargetProperties.__webglDepthbuffer)
            _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer[i])
        }
      } else {
        _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer)
        if (renderTargetProperties.__webglDepthbuffer)
          _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer)
      }

      properties.remove(renderTarget.texture)
      properties.remove(renderTarget)
    }

    //

    function setTexture2D(texture, slot) {
      var textureProperties = properties.get(texture)

      if (texture.isVideoTexture) updateVideoTexture(texture)

      if (texture.version > 0 && textureProperties.__version !== texture.version) {
        var image = texture.image

        if (image === undefined) {
          console.warn(
            'THREE.WebGLRenderer: Texture marked for update but image is undefined',
            texture
          )
        } else if (image.complete === false) {
          console.warn(
            'THREE.WebGLRenderer: Texture marked for update but image is incomplete',
            texture
          )
        } else {
          uploadTexture(textureProperties, texture, slot)
          return
        }
      }

      state.activeTexture(_gl.TEXTURE0 + slot)
      state.bindTexture(_gl.TEXTURE_2D, textureProperties.__webglTexture)
    }

    function setTextureCube(texture, slot) {
      var textureProperties = properties.get(texture)

      if (texture.image.length === 6) {
        if (texture.version > 0 && textureProperties.__version !== texture.version) {
          if (!textureProperties.__image__webglTextureCube) {
            texture.addEventListener('dispose', onTextureDispose)

            textureProperties.__image__webglTextureCube = _gl.createTexture()

            infoMemory.textures++
          }

          state.activeTexture(_gl.TEXTURE0 + slot)
          state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube)

          _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY)

          var isCompressed = texture && texture.isCompressedTexture
          var isDataTexture = texture.image[0] && texture.image[0].isDataTexture

          var cubeImage = []

          for (var i = 0; i < 6; i++) {
            if (!isCompressed && !isDataTexture) {
              cubeImage[i] = clampToMaxSize(texture.image[i], capabilities.maxCubemapSize)
            } else {
              cubeImage[i] = isDataTexture ? texture.image[i].image : texture.image[i]
            }
          }

          var image = cubeImage[0],
            isPowerOfTwoImage = isPowerOfTwo(image),
            glFormat = utils.convert(texture.format),
            glType = utils.convert(texture.type)

          setTextureParameters(_gl.TEXTURE_CUBE_MAP, texture, isPowerOfTwoImage)

          for (var i = 0; i < 6; i++) {
            if (!isCompressed) {
              if (isDataTexture) {
                state.texImage2D(
                  _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i,
                  0,
                  glFormat,
                  cubeImage[i].width,
                  cubeImage[i].height,
                  0,
                  glFormat,
                  glType,
                  cubeImage[i].data
                )
              } else {
                state.texImage2D(
                  _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i,
                  0,
                  glFormat,
                  glFormat,
                  glType,
                  cubeImage[i]
                )
              }
            } else {
              var mipmap,
                mipmaps = cubeImage[i].mipmaps

              for (var j = 0, jl = mipmaps.length; j < jl; j++) {
                mipmap = mipmaps[j]

                if (texture.format !== RGBAFormat && texture.format !== RGBFormat) {
                  if (state.getCompressedTextureFormats().indexOf(glFormat) > -1) {
                    state.compressedTexImage2D(
                      _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i,
                      j,
                      glFormat,
                      mipmap.width,
                      mipmap.height,
                      0,
                      mipmap.data
                    )
                  } else {
                    console.warn(
                      'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()'
                    )
                  }
                } else {
                  state.texImage2D(
                    _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i,
                    j,
                    glFormat,
                    mipmap.width,
                    mipmap.height,
                    0,
                    glFormat,
                    glType,
                    mipmap.data
                  )
                }
              }
            }
          }

          if (textureNeedsGenerateMipmaps(texture, isPowerOfTwoImage)) {
            _gl.generateMipmap(_gl.TEXTURE_CUBE_MAP)
          }

          textureProperties.__version = texture.version

          if (texture.onUpdate) texture.onUpdate(texture)
        } else {
          state.activeTexture(_gl.TEXTURE0 + slot)
          state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube)
        }
      }
    }

    function setTextureCubeDynamic(texture, slot) {
      state.activeTexture(_gl.TEXTURE0 + slot)
      state.bindTexture(_gl.TEXTURE_CUBE_MAP, properties.get(texture).__webglTexture)
    }

    function setTextureParameters(textureType, texture, isPowerOfTwoImage) {
      var extension

      if (isPowerOfTwoImage) {
        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_S, utils.convert(texture.wrapS))
        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_T, utils.convert(texture.wrapT))

        _gl.texParameteri(textureType, _gl.TEXTURE_MAG_FILTER, utils.convert(texture.magFilter))
        _gl.texParameteri(textureType, _gl.TEXTURE_MIN_FILTER, utils.convert(texture.minFilter))
      } else {
        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE)
        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE)

        if (texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping) {
          console.warn(
            'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.',
            texture
          )
        }

        _gl.texParameteri(textureType, _gl.TEXTURE_MAG_FILTER, filterFallback(texture.magFilter))
        _gl.texParameteri(textureType, _gl.TEXTURE_MIN_FILTER, filterFallback(texture.minFilter))

        if (texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter) {
          console.warn(
            'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.',
            texture
          )
        }
      }

      extension = extensions.get('EXT_texture_filter_anisotropic')

      if (extension) {
        if (texture.type === FloatType && extensions.get('OES_texture_float_linear') === null)
          return
        if (
          texture.type === HalfFloatType &&
          extensions.get('OES_texture_half_float_linear') === null
        )
          return

        if (texture.anisotropy > 1 || properties.get(texture).__currentAnisotropy) {
          _gl.texParameterf(
            textureType,
            extension.TEXTURE_MAX_ANISOTROPY_EXT,
            Math.min(texture.anisotropy, capabilities.getMaxAnisotropy())
          )
          properties.get(texture).__currentAnisotropy = texture.anisotropy
        }
      }
    }

    function uploadTexture(textureProperties, texture, slot) {
      if (textureProperties.__webglInit === undefined) {
        textureProperties.__webglInit = true

        texture.addEventListener('dispose', onTextureDispose)

        textureProperties.__webglTexture = _gl.createTexture()

        infoMemory.textures++
      }

      state.activeTexture(_gl.TEXTURE0 + slot)
      state.bindTexture(_gl.TEXTURE_2D, textureProperties.__webglTexture)

      _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY)
      _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha)
      _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, texture.unpackAlignment)

      var image = clampToMaxSize(texture.image, capabilities.maxTextureSize)

      if (textureNeedsPowerOfTwo(texture) && isPowerOfTwo(image) === false) {
        image = makePowerOfTwo(image)
      }

      var isPowerOfTwoImage = isPowerOfTwo(image),
        glFormat = utils.convert(texture.format),
        glType = utils.convert(texture.type)

      setTextureParameters(_gl.TEXTURE_2D, texture, isPowerOfTwoImage)

      var mipmap,
        mipmaps = texture.mipmaps

      if (texture.isDepthTexture) {
        // populate depth texture with dummy data

        var internalFormat = _gl.DEPTH_COMPONENT

        if (texture.type === FloatType) {
          if (!_isWebGL2) throw new Error('Float Depth Texture only supported in WebGL2.0')
          internalFormat = _gl.DEPTH_COMPONENT32F
        } else if (_isWebGL2) {
          // WebGL 2.0 requires signed internalformat for glTexImage2D
          internalFormat = _gl.DEPTH_COMPONENT16
        }

        if (texture.format === DepthFormat && internalFormat === _gl.DEPTH_COMPONENT) {
          // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
          // DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT
          // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
          if (texture.type !== UnsignedShortType && texture.type !== UnsignedIntType) {
            console.warn(
              'THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.'
            )

            texture.type = UnsignedShortType
            glType = utils.convert(texture.type)
          }
        }

        // Depth stencil textures need the DEPTH_STENCIL internal format
        // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
        if (texture.format === DepthStencilFormat) {
          internalFormat = _gl.DEPTH_STENCIL

          // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
          // DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL.
          // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
          if (texture.type !== UnsignedInt248Type) {
            console.warn(
              'THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.'
            )

            texture.type = UnsignedInt248Type
            glType = utils.convert(texture.type)
          }
        }

        state.texImage2D(
          _gl.TEXTURE_2D,
          0,
          internalFormat,
          image.width,
          image.height,
          0,
          glFormat,
          glType,
          null
        )
      } else if (texture.isDataTexture) {
        // use manually created mipmaps if available
        // if there are no manual mipmaps
        // set 0 level mipmap and then use GL to generate other mipmap levels

        if (mipmaps.length > 0 && isPowerOfTwoImage) {
          for (var i = 0, il = mipmaps.length; i < il; i++) {
            mipmap = mipmaps[i]
            state.texImage2D(
              _gl.TEXTURE_2D,
              i,
              glFormat,
              mipmap.width,
              mipmap.height,
              0,
              glFormat,
              glType,
              mipmap.data
            )
          }

          texture.generateMipmaps = false
        } else {
          state.texImage2D(
            _gl.TEXTURE_2D,
            0,
            glFormat,
            image.width,
            image.height,
            0,
            glFormat,
            glType,
            image.data
          )
        }
      } else if (texture.isCompressedTexture) {
        for (var i = 0, il = mipmaps.length; i < il; i++) {
          mipmap = mipmaps[i]

          if (texture.format !== RGBAFormat && texture.format !== RGBFormat) {
            if (state.getCompressedTextureFormats().indexOf(glFormat) > -1) {
              state.compressedTexImage2D(
                _gl.TEXTURE_2D,
                i,
                glFormat,
                mipmap.width,
                mipmap.height,
                0,
                mipmap.data
              )
            } else {
              console.warn(
                'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()'
              )
            }
          } else {
            state.texImage2D(
              _gl.TEXTURE_2D,
              i,
              glFormat,
              mipmap.width,
              mipmap.height,
              0,
              glFormat,
              glType,
              mipmap.data
            )
          }
        }
      } else {
        // regular Texture (image, video, canvas)

        // use manually created mipmaps if available
        // if there are no manual mipmaps
        // set 0 level mipmap and then use GL to generate other mipmap levels

        if (mipmaps.length > 0 && isPowerOfTwoImage) {
          for (var i = 0, il = mipmaps.length; i < il; i++) {
            mipmap = mipmaps[i]
            state.texImage2D(_gl.TEXTURE_2D, i, glFormat, glFormat, glType, mipmap)
          }

          texture.generateMipmaps = false
        } else {
          state.texImage2D(_gl.TEXTURE_2D, 0, glFormat, glFormat, glType, image)
        }
      }

      if (textureNeedsGenerateMipmaps(texture, isPowerOfTwoImage))
        _gl.generateMipmap(_gl.TEXTURE_2D)

      textureProperties.__version = texture.version

      if (texture.onUpdate) texture.onUpdate(texture)
    }

    // Render targets

    // Setup storage for target texture and bind it to correct framebuffer
    function setupFrameBufferTexture(framebuffer, renderTarget, attachment, textureTarget) {
      var glFormat = utils.convert(renderTarget.texture.format)
      var glType = utils.convert(renderTarget.texture.type)
      state.texImage2D(
        textureTarget,
        0,
        glFormat,
        renderTarget.width,
        renderTarget.height,
        0,
        glFormat,
        glType,
        null
      )
      _gl.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer)
      _gl.framebufferTexture2D(
        _gl.FRAMEBUFFER,
        attachment,
        textureTarget,
        properties.get(renderTarget.texture).__webglTexture,
        0
      )
      _gl.bindFramebuffer(_gl.FRAMEBUFFER, null)
    }

    // Setup storage for internal depth/stencil buffers and bind to correct framebuffer
    function setupRenderBufferStorage(renderbuffer, renderTarget) {
      _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer)

      if (renderTarget.depthBuffer && !renderTarget.stencilBuffer) {
        _gl.renderbufferStorage(
          _gl.RENDERBUFFER,
          _gl.DEPTH_COMPONENT16,
          renderTarget.width,
          renderTarget.height
        )
        _gl.framebufferRenderbuffer(
          _gl.FRAMEBUFFER,
          _gl.DEPTH_ATTACHMENT,
          _gl.RENDERBUFFER,
          renderbuffer
        )
      } else if (renderTarget.depthBuffer && renderTarget.stencilBuffer) {
        _gl.renderbufferStorage(
          _gl.RENDERBUFFER,
          _gl.DEPTH_STENCIL,
          renderTarget.width,
          renderTarget.height
        )
        _gl.framebufferRenderbuffer(
          _gl.FRAMEBUFFER,
          _gl.DEPTH_STENCIL_ATTACHMENT,
          _gl.RENDERBUFFER,
          renderbuffer
        )
      } else {
        // FIXME: We don't support !depth !stencil
        _gl.renderbufferStorage(
          _gl.RENDERBUFFER,
          _gl.RGBA4,
          renderTarget.width,
          renderTarget.height
        )
      }

      _gl.bindRenderbuffer(_gl.RENDERBUFFER, null)
    }

    // Setup resources for a Depth Texture for a FBO (needs an extension)
    function setupDepthTexture(framebuffer, renderTarget) {
      var isCube = renderTarget && renderTarget.isWebGLRenderTargetCube
      if (isCube) throw new Error('Depth Texture with cube render targets is not supported')

      _gl.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer)

      if (!(renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture)) {
        throw new Error('renderTarget.depthTexture must be an instance of THREE.DepthTexture')
      }

      // upload an empty depth texture with framebuffer size
      if (
        !properties.get(renderTarget.depthTexture).__webglTexture ||
        renderTarget.depthTexture.image.width !== renderTarget.width ||
        renderTarget.depthTexture.image.height !== renderTarget.height
      ) {
        renderTarget.depthTexture.image.width = renderTarget.width
        renderTarget.depthTexture.image.height = renderTarget.height
        renderTarget.depthTexture.needsUpdate = true
      }

      setTexture2D(renderTarget.depthTexture, 0)

      var webglDepthTexture = properties.get(renderTarget.depthTexture).__webglTexture

      if (renderTarget.depthTexture.format === DepthFormat) {
        _gl.framebufferTexture2D(
          _gl.FRAMEBUFFER,
          _gl.DEPTH_ATTACHMENT,
          _gl.TEXTURE_2D,
          webglDepthTexture,
          0
        )
      } else if (renderTarget.depthTexture.format === DepthStencilFormat) {
        _gl.framebufferTexture2D(
          _gl.FRAMEBUFFER,
          _gl.DEPTH_STENCIL_ATTACHMENT,
          _gl.TEXTURE_2D,
          webglDepthTexture,
          0
        )
      } else {
        throw new Error('Unknown depthTexture format')
      }
    }

    // Setup GL resources for a non-texture depth buffer
    function setupDepthRenderbuffer(renderTarget) {
      var renderTargetProperties = properties.get(renderTarget)

      var isCube = renderTarget.isWebGLRenderTargetCube === true

      if (renderTarget.depthTexture) {
        if (isCube) throw new Error('target.depthTexture not supported in Cube render targets')

        setupDepthTexture(renderTargetProperties.__webglFramebuffer, renderTarget)
      } else {
        if (isCube) {
          renderTargetProperties.__webglDepthbuffer = []

          for (var i = 0; i < 6; i++) {
            _gl.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[i])
            renderTargetProperties.__webglDepthbuffer[i] = _gl.createRenderbuffer()
            setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer[i], renderTarget)
          }
        } else {
          _gl.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer)
          renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer()
          setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer, renderTarget)
        }
      }

      _gl.bindFramebuffer(_gl.FRAMEBUFFER, null)
    }

    // Set up GL resources for the render target
    function setupRenderTarget(renderTarget) {
      var renderTargetProperties = properties.get(renderTarget)
      var textureProperties = properties.get(renderTarget.texture)

      renderTarget.addEventListener('dispose', onRenderTargetDispose)

      textureProperties.__webglTexture = _gl.createTexture()

      infoMemory.textures++

      var isCube = renderTarget.isWebGLRenderTargetCube === true
      var isTargetPowerOfTwo = isPowerOfTwo(renderTarget)

      // Setup framebuffer

      if (isCube) {
        renderTargetProperties.__webglFramebuffer = []

        for (var i = 0; i < 6; i++) {
          renderTargetProperties.__webglFramebuffer[i] = _gl.createFramebuffer()
        }
      } else {
        renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer()
      }

      // Setup color buffer

      if (isCube) {
        state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture)
        setTextureParameters(_gl.TEXTURE_CUBE_MAP, renderTarget.texture, isTargetPowerOfTwo)

        for (var i = 0; i < 6; i++) {
          setupFrameBufferTexture(
            renderTargetProperties.__webglFramebuffer[i],
            renderTarget,
            _gl.COLOR_ATTACHMENT0,
            _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i
          )
        }

        if (textureNeedsGenerateMipmaps(renderTarget.texture, isTargetPowerOfTwo))
          _gl.generateMipmap(_gl.TEXTURE_CUBE_MAP)
        state.bindTexture(_gl.TEXTURE_CUBE_MAP, null)
      } else {
        state.bindTexture(_gl.TEXTURE_2D, textureProperties.__webglTexture)
        setTextureParameters(_gl.TEXTURE_2D, renderTarget.texture, isTargetPowerOfTwo)
        setupFrameBufferTexture(
          renderTargetProperties.__webglFramebuffer,
          renderTarget,
          _gl.COLOR_ATTACHMENT0,
          _gl.TEXTURE_2D
        )

        if (textureNeedsGenerateMipmaps(renderTarget.texture, isTargetPowerOfTwo))
          _gl.generateMipmap(_gl.TEXTURE_2D)
        state.bindTexture(_gl.TEXTURE_2D, null)
      }

      // Setup depth and stencil buffers

      if (renderTarget.depthBuffer) {
        setupDepthRenderbuffer(renderTarget)
      }
    }

    function updateRenderTargetMipmap(renderTarget) {
      var texture = renderTarget.texture
      var isTargetPowerOfTwo = isPowerOfTwo(renderTarget)

      if (textureNeedsGenerateMipmaps(texture, isTargetPowerOfTwo)) {
        var target = renderTarget.isWebGLRenderTargetCube ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D
        var webglTexture = properties.get(texture).__webglTexture

        state.bindTexture(target, webglTexture)
        _gl.generateMipmap(target)
        state.bindTexture(target, null)
      }
    }

    function updateVideoTexture(texture) {
      var id = texture.id
      var frame = infoRender.frame

      // Check the last frame we updated the VideoTexture

      if (_videoTextures[id] !== frame) {
        _videoTextures[id] = frame
        texture.update()
      }
    }

    this.setTexture2D = setTexture2D
    this.setTextureCube = setTextureCube
    this.setTextureCubeDynamic = setTextureCubeDynamic
    this.setupRenderTarget = setupRenderTarget
    this.updateRenderTargetMipmap = updateRenderTargetMipmap
  }

  /**
   * @author fordacious / fordacious.github.io
   */

  function WebGLProperties() {
    var properties = {}

    function get(object) {
      var uuid = object.uuid
      var map = properties[uuid]

      if (map === undefined) {
        map = {}
        properties[uuid] = map
      }

      return map
    }

    function remove(object) {
      delete properties[object.uuid]
    }

    function update(object, key, value) {
      var uuid = object.uuid
      var map = properties[uuid]

      map[key] = value
    }

    function dispose() {
      properties = {}
    }

    return {
      get: get,
      remove: remove,
      update: update,
      dispose: dispose
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLState(gl, extensions, utils) {
    function ColorBuffer() {
      var locked = false

      var color = new Vector4()
      var currentColorMask = null
      var currentColorClear = new Vector4(0, 0, 0, 0)

      return {
        setMask: function (colorMask) {
          if (currentColorMask !== colorMask && !locked) {
            gl.colorMask(colorMask, colorMask, colorMask, colorMask)
            currentColorMask = colorMask
          }
        },

        setLocked: function (lock) {
          locked = lock
        },

        setClear: function (r, g, b, a, premultipliedAlpha) {
          if (premultipliedAlpha === true) {
            r *= a
            g *= a
            b *= a
          }

          color.set(r, g, b, a)

          if (currentColorClear.equals(color) === false) {
            gl.clearColor(r, g, b, a)
            currentColorClear.copy(color)
          }
        },

        reset: function () {
          locked = false

          currentColorMask = null
          currentColorClear.set(-1, 0, 0, 0) // set to invalid state
        }
      }
    }

    function DepthBuffer() {
      var locked = false

      var currentDepthMask = null
      var currentDepthFunc = null
      var currentDepthClear = null

      return {
        setTest: function (depthTest) {
          if (depthTest) {
            enable(gl.DEPTH_TEST)
          } else {
            disable(gl.DEPTH_TEST)
          }
        },

        setMask: function (depthMask) {
          if (currentDepthMask !== depthMask && !locked) {
            gl.depthMask(depthMask)
            currentDepthMask = depthMask
          }
        },

        setFunc: function (depthFunc) {
          if (currentDepthFunc !== depthFunc) {
            if (depthFunc) {
              switch (depthFunc) {
                case NeverDepth:
                  gl.depthFunc(gl.NEVER)
                  break

                case AlwaysDepth:
                  gl.depthFunc(gl.ALWAYS)
                  break

                case LessDepth:
                  gl.depthFunc(gl.LESS)
                  break

                case LessEqualDepth:
                  gl.depthFunc(gl.LEQUAL)
                  break

                case EqualDepth:
                  gl.depthFunc(gl.EQUAL)
                  break

                case GreaterEqualDepth:
                  gl.depthFunc(gl.GEQUAL)
                  break

                case GreaterDepth:
                  gl.depthFunc(gl.GREATER)
                  break

                case NotEqualDepth:
                  gl.depthFunc(gl.NOTEQUAL)
                  break

                default:
                  gl.depthFunc(gl.LEQUAL)
              }
            } else {
              gl.depthFunc(gl.LEQUAL)
            }

            currentDepthFunc = depthFunc
          }
        },

        setLocked: function (lock) {
          locked = lock
        },

        setClear: function (depth) {
          if (currentDepthClear !== depth) {
            gl.clearDepth(depth)
            currentDepthClear = depth
          }
        },

        reset: function () {
          locked = false

          currentDepthMask = null
          currentDepthFunc = null
          currentDepthClear = null
        }
      }
    }

    function StencilBuffer() {
      var locked = false

      var currentStencilMask = null
      var currentStencilFunc = null
      var currentStencilRef = null
      var currentStencilFuncMask = null
      var currentStencilFail = null
      var currentStencilZFail = null
      var currentStencilZPass = null
      var currentStencilClear = null

      return {
        setTest: function (stencilTest) {
          if (stencilTest) {
            enable(gl.STENCIL_TEST)
          } else {
            disable(gl.STENCIL_TEST)
          }
        },

        setMask: function (stencilMask) {
          if (currentStencilMask !== stencilMask && !locked) {
            gl.stencilMask(stencilMask)
            currentStencilMask = stencilMask
          }
        },

        setFunc: function (stencilFunc, stencilRef, stencilMask) {
          if (
            currentStencilFunc !== stencilFunc ||
            currentStencilRef !== stencilRef ||
            currentStencilFuncMask !== stencilMask
          ) {
            gl.stencilFunc(stencilFunc, stencilRef, stencilMask)

            currentStencilFunc = stencilFunc
            currentStencilRef = stencilRef
            currentStencilFuncMask = stencilMask
          }
        },

        setOp: function (stencilFail, stencilZFail, stencilZPass) {
          if (
            currentStencilFail !== stencilFail ||
            currentStencilZFail !== stencilZFail ||
            currentStencilZPass !== stencilZPass
          ) {
            gl.stencilOp(stencilFail, stencilZFail, stencilZPass)

            currentStencilFail = stencilFail
            currentStencilZFail = stencilZFail
            currentStencilZPass = stencilZPass
          }
        },

        setLocked: function (lock) {
          locked = lock
        },

        setClear: function (stencil) {
          if (currentStencilClear !== stencil) {
            gl.clearStencil(stencil)
            currentStencilClear = stencil
          }
        },

        reset: function () {
          locked = false

          currentStencilMask = null
          currentStencilFunc = null
          currentStencilRef = null
          currentStencilFuncMask = null
          currentStencilFail = null
          currentStencilZFail = null
          currentStencilZPass = null
          currentStencilClear = null
        }
      }
    }

    //

    var colorBuffer = new ColorBuffer()
    var depthBuffer = new DepthBuffer()
    var stencilBuffer = new StencilBuffer()

    var maxVertexAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS)
    var newAttributes = new Uint8Array(maxVertexAttributes)
    var enabledAttributes = new Uint8Array(maxVertexAttributes)
    var attributeDivisors = new Uint8Array(maxVertexAttributes)

    var capabilities = {}

    var compressedTextureFormats = null

    var currentProgram = null

    var currentBlending = null
    var currentBlendEquation = null
    var currentBlendSrc = null
    var currentBlendDst = null
    var currentBlendEquationAlpha = null
    var currentBlendSrcAlpha = null
    var currentBlendDstAlpha = null
    var currentPremultipledAlpha = false

    var currentFlipSided = null
    var currentCullFace = null

    var currentLineWidth = null

    var currentPolygonOffsetFactor = null
    var currentPolygonOffsetUnits = null

    var maxTextures = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS)

    var lineWidthAvailable = false
    var version = 0
    var glVersion = gl.getParameter(gl.VERSION)

    if (glVersion.indexOf('WebGL') !== -1) {
      version = parseFloat(/^WebGL\ ([0-9])/.exec(glVersion)[1])
      lineWidthAvailable = version >= 1.0
    } else if (glVersion.indexOf('OpenGL ES') !== -1) {
      version = parseFloat(/^OpenGL\ ES\ ([0-9])/.exec(glVersion)[1])
      lineWidthAvailable = version >= 2.0
    }

    var currentTextureSlot = null
    var currentBoundTextures = {}

    var currentScissor = new Vector4()
    var currentViewport = new Vector4()

    function createTexture(type, target, count) {
      var data = new Uint8Array(4) // 4 is required to match default unpack alignment of 4.
      var texture = gl.createTexture()

      gl.bindTexture(type, texture)
      gl.texParameteri(type, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
      gl.texParameteri(type, gl.TEXTURE_MAG_FILTER, gl.NEAREST)

      for (var i = 0; i < count; i++) {
        gl.texImage2D(target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data)
      }

      return texture
    }

    var emptyTextures = {}
    emptyTextures[gl.TEXTURE_2D] = createTexture(gl.TEXTURE_2D, gl.TEXTURE_2D, 1)
    emptyTextures[gl.TEXTURE_CUBE_MAP] = createTexture(
      gl.TEXTURE_CUBE_MAP,
      gl.TEXTURE_CUBE_MAP_POSITIVE_X,
      6
    )

    // init

    colorBuffer.setClear(0, 0, 0, 1)
    depthBuffer.setClear(1)
    stencilBuffer.setClear(0)

    enable(gl.DEPTH_TEST)
    depthBuffer.setFunc(LessEqualDepth)

    setFlipSided(false)
    setCullFace(CullFaceBack)
    enable(gl.CULL_FACE)

    enable(gl.BLEND)
    setBlending(NormalBlending)

    //

    function initAttributes() {
      for (var i = 0, l = newAttributes.length; i < l; i++) {
        newAttributes[i] = 0
      }
    }

    function enableAttribute(attribute) {
      newAttributes[attribute] = 1

      if (enabledAttributes[attribute] === 0) {
        gl.enableVertexAttribArray(attribute)
        enabledAttributes[attribute] = 1
      }

      if (attributeDivisors[attribute] !== 0) {
        var extension = extensions.get('ANGLE_instanced_arrays')

        extension.vertexAttribDivisorANGLE(attribute, 0)
        attributeDivisors[attribute] = 0
      }
    }

    function enableAttributeAndDivisor(attribute, meshPerAttribute) {
      newAttributes[attribute] = 1

      if (enabledAttributes[attribute] === 0) {
        gl.enableVertexAttribArray(attribute)
        enabledAttributes[attribute] = 1
      }

      if (attributeDivisors[attribute] !== meshPerAttribute) {
        var extension = extensions.get('ANGLE_instanced_arrays')

        extension.vertexAttribDivisorANGLE(attribute, meshPerAttribute)
        attributeDivisors[attribute] = meshPerAttribute
      }
    }

    function disableUnusedAttributes() {
      for (var i = 0, l = enabledAttributes.length; i !== l; ++i) {
        if (enabledAttributes[i] !== newAttributes[i]) {
          gl.disableVertexAttribArray(i)
          enabledAttributes[i] = 0
        }
      }
    }

    function enable(id) {
      if (capabilities[id] !== true) {
        gl.enable(id)
        capabilities[id] = true
      }
    }

    function disable(id) {
      if (capabilities[id] !== false) {
        gl.disable(id)
        capabilities[id] = false
      }
    }

    function getCompressedTextureFormats() {
      if (compressedTextureFormats === null) {
        compressedTextureFormats = []

        if (
          extensions.get('WEBGL_compressed_texture_pvrtc') ||
          extensions.get('WEBGL_compressed_texture_s3tc') ||
          extensions.get('WEBGL_compressed_texture_etc1') ||
          extensions.get('WEBGL_compressed_texture_astc')
        ) {
          var formats = gl.getParameter(gl.COMPRESSED_TEXTURE_FORMATS)

          for (var i = 0; i < formats.length; i++) {
            compressedTextureFormats.push(formats[i])
          }
        }
      }

      return compressedTextureFormats
    }

    function useProgram(program) {
      if (currentProgram !== program) {
        gl.useProgram(program)

        currentProgram = program

        return true
      }

      return false
    }

    function setBlending(
      blending,
      blendEquation,
      blendSrc,
      blendDst,
      blendEquationAlpha,
      blendSrcAlpha,
      blendDstAlpha,
      premultipliedAlpha
    ) {
      if (blending !== NoBlending) {
        enable(gl.BLEND)
      } else {
        disable(gl.BLEND)
      }

      if (blending !== CustomBlending) {
        if (blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha) {
          switch (blending) {
            case AdditiveBlending:
              if (premultipliedAlpha) {
                gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD)
                gl.blendFuncSeparate(gl.ONE, gl.ONE, gl.ONE, gl.ONE)
              } else {
                gl.blendEquation(gl.FUNC_ADD)
                gl.blendFunc(gl.SRC_ALPHA, gl.ONE)
              }
              break

            case SubtractiveBlending:
              if (premultipliedAlpha) {
                gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD)
                gl.blendFuncSeparate(
                  gl.ZERO,
                  gl.ZERO,
                  gl.ONE_MINUS_SRC_COLOR,
                  gl.ONE_MINUS_SRC_ALPHA
                )
              } else {
                gl.blendEquation(gl.FUNC_ADD)
                gl.blendFunc(gl.ZERO, gl.ONE_MINUS_SRC_COLOR)
              }
              break

            case MultiplyBlending:
              if (premultipliedAlpha) {
                gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD)
                gl.blendFuncSeparate(gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA)
              } else {
                gl.blendEquation(gl.FUNC_ADD)
                gl.blendFunc(gl.ZERO, gl.SRC_COLOR)
              }
              break

            default:
              if (premultipliedAlpha) {
                gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD)
                gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA)
              } else {
                gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD)
                gl.blendFuncSeparate(
                  gl.SRC_ALPHA,
                  gl.ONE_MINUS_SRC_ALPHA,
                  gl.ONE,
                  gl.ONE_MINUS_SRC_ALPHA
                )
              }
          }
        }

        currentBlendEquation = null
        currentBlendSrc = null
        currentBlendDst = null
        currentBlendEquationAlpha = null
        currentBlendSrcAlpha = null
        currentBlendDstAlpha = null
      } else {
        blendEquationAlpha = blendEquationAlpha || blendEquation
        blendSrcAlpha = blendSrcAlpha || blendSrc
        blendDstAlpha = blendDstAlpha || blendDst

        if (
          blendEquation !== currentBlendEquation ||
          blendEquationAlpha !== currentBlendEquationAlpha
        ) {
          gl.blendEquationSeparate(utils.convert(blendEquation), utils.convert(blendEquationAlpha))

          currentBlendEquation = blendEquation
          currentBlendEquationAlpha = blendEquationAlpha
        }

        if (
          blendSrc !== currentBlendSrc ||
          blendDst !== currentBlendDst ||
          blendSrcAlpha !== currentBlendSrcAlpha ||
          blendDstAlpha !== currentBlendDstAlpha
        ) {
          gl.blendFuncSeparate(
            utils.convert(blendSrc),
            utils.convert(blendDst),
            utils.convert(blendSrcAlpha),
            utils.convert(blendDstAlpha)
          )

          currentBlendSrc = blendSrc
          currentBlendDst = blendDst
          currentBlendSrcAlpha = blendSrcAlpha
          currentBlendDstAlpha = blendDstAlpha
        }
      }

      currentBlending = blending
      currentPremultipledAlpha = premultipliedAlpha
    }

    function setMaterial(material, frontFaceCW) {
      material.side === DoubleSide ? disable(gl.CULL_FACE) : enable(gl.CULL_FACE)

      var flipSided = material.side === BackSide
      if (frontFaceCW) flipSided = !flipSided

      setFlipSided(flipSided)

      material.transparent === true
        ? setBlending(
            material.blending,
            material.blendEquation,
            material.blendSrc,
            material.blendDst,
            material.blendEquationAlpha,
            material.blendSrcAlpha,
            material.blendDstAlpha,
            material.premultipliedAlpha
          )
        : setBlending(NoBlending)

      depthBuffer.setFunc(material.depthFunc)
      depthBuffer.setTest(material.depthTest)
      depthBuffer.setMask(material.depthWrite)
      colorBuffer.setMask(material.colorWrite)

      setPolygonOffset(
        material.polygonOffset,
        material.polygonOffsetFactor,
        material.polygonOffsetUnits
      )
    }

    //

    function setFlipSided(flipSided) {
      if (currentFlipSided !== flipSided) {
        if (flipSided) {
          gl.frontFace(gl.CW)
        } else {
          gl.frontFace(gl.CCW)
        }

        currentFlipSided = flipSided
      }
    }

    function setCullFace(cullFace) {
      if (cullFace !== CullFaceNone) {
        enable(gl.CULL_FACE)

        if (cullFace !== currentCullFace) {
          if (cullFace === CullFaceBack) {
            gl.cullFace(gl.BACK)
          } else if (cullFace === CullFaceFront) {
            gl.cullFace(gl.FRONT)
          } else {
            gl.cullFace(gl.FRONT_AND_BACK)
          }
        }
      } else {
        disable(gl.CULL_FACE)
      }

      currentCullFace = cullFace
    }

    function setLineWidth(width) {
      if (width !== currentLineWidth) {
        if (lineWidthAvailable) gl.lineWidth(width)

        currentLineWidth = width
      }
    }

    function setPolygonOffset(polygonOffset, factor, units) {
      if (polygonOffset) {
        enable(gl.POLYGON_OFFSET_FILL)

        if (currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units) {
          gl.polygonOffset(factor, units)

          currentPolygonOffsetFactor = factor
          currentPolygonOffsetUnits = units
        }
      } else {
        disable(gl.POLYGON_OFFSET_FILL)
      }
    }

    function setScissorTest(scissorTest) {
      if (scissorTest) {
        enable(gl.SCISSOR_TEST)
      } else {
        disable(gl.SCISSOR_TEST)
      }
    }

    // texture

    function activeTexture(webglSlot) {
      if (webglSlot === undefined) webglSlot = gl.TEXTURE0 + maxTextures - 1

      if (currentTextureSlot !== webglSlot) {
        gl.activeTexture(webglSlot)
        currentTextureSlot = webglSlot
      }
    }

    function bindTexture(webglType, webglTexture) {
      if (currentTextureSlot === null) {
        activeTexture()
      }

      var boundTexture = currentBoundTextures[currentTextureSlot]

      if (boundTexture === undefined) {
        boundTexture = { type: undefined, texture: undefined }
        currentBoundTextures[currentTextureSlot] = boundTexture
      }

      if (boundTexture.type !== webglType || boundTexture.texture !== webglTexture) {
        gl.bindTexture(webglType, webglTexture || emptyTextures[webglType])

        boundTexture.type = webglType
        boundTexture.texture = webglTexture
      }
    }

    function compressedTexImage2D() {
      try {
        gl.compressedTexImage2D.apply(gl, arguments)
      } catch (error) {
        console.error('THREE.WebGLState:', error)
      }
    }

    function texImage2D() {
      try {
        gl.texImage2D.apply(gl, arguments)
      } catch (error) {
        console.error('THREE.WebGLState:', error)
      }
    }

    //

    function scissor(scissor) {
      if (currentScissor.equals(scissor) === false) {
        gl.scissor(scissor.x, scissor.y, scissor.z, scissor.w)
        currentScissor.copy(scissor)
      }
    }

    function viewport(viewport) {
      if (currentViewport.equals(viewport) === false) {
        gl.viewport(viewport.x, viewport.y, viewport.z, viewport.w)
        currentViewport.copy(viewport)
      }
    }

    //

    function reset() {
      for (var i = 0; i < enabledAttributes.length; i++) {
        if (enabledAttributes[i] === 1) {
          gl.disableVertexAttribArray(i)
          enabledAttributes[i] = 0
        }
      }

      capabilities = {}

      compressedTextureFormats = null

      currentTextureSlot = null
      currentBoundTextures = {}

      currentProgram = null

      currentBlending = null

      currentFlipSided = null
      currentCullFace = null

      colorBuffer.reset()
      depthBuffer.reset()
      stencilBuffer.reset()
    }

    return {
      buffers: {
        color: colorBuffer,
        depth: depthBuffer,
        stencil: stencilBuffer
      },

      initAttributes: initAttributes,
      enableAttribute: enableAttribute,
      enableAttributeAndDivisor: enableAttributeAndDivisor,
      disableUnusedAttributes: disableUnusedAttributes,
      enable: enable,
      disable: disable,
      getCompressedTextureFormats: getCompressedTextureFormats,

      useProgram: useProgram,

      setBlending: setBlending,
      setMaterial: setMaterial,

      setFlipSided: setFlipSided,
      setCullFace: setCullFace,

      setLineWidth: setLineWidth,
      setPolygonOffset: setPolygonOffset,

      setScissorTest: setScissorTest,

      activeTexture: activeTexture,
      bindTexture: bindTexture,
      compressedTexImage2D: compressedTexImage2D,
      texImage2D: texImage2D,

      scissor: scissor,
      viewport: viewport,

      reset: reset
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLCapabilities(gl, extensions, parameters) {
    var maxAnisotropy

    function getMaxAnisotropy() {
      if (maxAnisotropy !== undefined) return maxAnisotropy

      var extension = extensions.get('EXT_texture_filter_anisotropic')

      if (extension !== null) {
        maxAnisotropy = gl.getParameter(extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT)
      } else {
        maxAnisotropy = 0
      }

      return maxAnisotropy
    }

    function getMaxPrecision(precision) {
      if (precision === 'highp') {
        if (
          gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT).precision > 0 &&
          gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT).precision > 0
        ) {
          return 'highp'
        }

        precision = 'mediump'
      }

      if (precision === 'mediump') {
        if (
          gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT).precision > 0 &&
          gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT).precision > 0
        ) {
          return 'mediump'
        }
      }

      return 'lowp'
    }

    var precision = parameters.precision !== undefined ? parameters.precision : 'highp'
    var maxPrecision = getMaxPrecision(precision)

    if (maxPrecision !== precision) {
      console.warn(
        'THREE.WebGLRenderer:',
        precision,
        'not supported, using',
        maxPrecision,
        'instead.'
      )
      precision = maxPrecision
    }

    var logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true

    var maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS)
    var maxVertexTextures = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS)
    var maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE)
    var maxCubemapSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE)

    var maxAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS)
    var maxVertexUniforms = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS)
    var maxVaryings = gl.getParameter(gl.MAX_VARYING_VECTORS)
    var maxFragmentUniforms = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS)

    var vertexTextures = maxVertexTextures > 0
    var floatFragmentTextures = !!extensions.get('OES_texture_float')
    var floatVertexTextures = vertexTextures && floatFragmentTextures

    return {
      getMaxAnisotropy: getMaxAnisotropy,
      getMaxPrecision: getMaxPrecision,

      precision: precision,
      logarithmicDepthBuffer: logarithmicDepthBuffer,

      maxTextures: maxTextures,
      maxVertexTextures: maxVertexTextures,
      maxTextureSize: maxTextureSize,
      maxCubemapSize: maxCubemapSize,

      maxAttributes: maxAttributes,
      maxVertexUniforms: maxVertexUniforms,
      maxVaryings: maxVaryings,
      maxFragmentUniforms: maxFragmentUniforms,

      vertexTextures: vertexTextures,
      floatFragmentTextures: floatFragmentTextures,
      floatVertexTextures: floatVertexTextures
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author greggman / http://games.greggman.com/
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * @author tschw
   */

  function PerspectiveCamera(fov, aspect, near, far) {
    Camera.call(this)

    this.type = 'PerspectiveCamera'

    this.fov = fov !== undefined ? fov : 50
    this.zoom = 1

    this.near = near !== undefined ? near : 0.1
    this.far = far !== undefined ? far : 2000
    this.focus = 10

    this.aspect = aspect !== undefined ? aspect : 1
    this.view = null

    this.filmGauge = 35 // width of the film (default in millimeters)
    this.filmOffset = 0 // horizontal film offset (same unit as gauge)

    this.updateProjectionMatrix()
  }

  PerspectiveCamera.prototype = Object.assign(Object.create(Camera.prototype), {
    constructor: PerspectiveCamera,

    isPerspectiveCamera: true,

    copy: function (source, recursive) {
      Camera.prototype.copy.call(this, source, recursive)

      this.fov = source.fov
      this.zoom = source.zoom

      this.near = source.near
      this.far = source.far
      this.focus = source.focus

      this.aspect = source.aspect
      this.view = source.view === null ? null : Object.assign({}, source.view)

      this.filmGauge = source.filmGauge
      this.filmOffset = source.filmOffset

      return this
    },

    /**
     * Sets the FOV by focal length in respect to the current .filmGauge.
     *
     * The default film gauge is 35, so that the focal length can be specified for
     * a 35mm (full frame) camera.
     *
     * Values for focal length and film gauge must have the same unit.
     */
    setFocalLength: function (focalLength) {
      // see http://www.bobatkins.com/photography/technical/field_of_view.html
      var vExtentSlope = (0.5 * this.getFilmHeight()) / focalLength

      this.fov = _Math.RAD2DEG * 2 * Math.atan(vExtentSlope)
      this.updateProjectionMatrix()
    },

    /**
     * Calculates the focal length from the current .fov and .filmGauge.
     */
    getFocalLength: function () {
      var vExtentSlope = Math.tan(_Math.DEG2RAD * 0.5 * this.fov)

      return (0.5 * this.getFilmHeight()) / vExtentSlope
    },

    getEffectiveFOV: function () {
      return _Math.RAD2DEG * 2 * Math.atan(Math.tan(_Math.DEG2RAD * 0.5 * this.fov) / this.zoom)
    },

    getFilmWidth: function () {
      // film not completely covered in portrait format (aspect < 1)
      return this.filmGauge * Math.min(this.aspect, 1)
    },

    getFilmHeight: function () {
      // film not completely covered in landscape format (aspect > 1)
      return this.filmGauge / Math.max(this.aspect, 1)
    },

    /**
     * Sets an offset in a larger frustum. This is useful for multi-window or
     * multi-monitor/multi-machine setups.
     *
     * For example, if you have 3x2 monitors and each monitor is 1920x1080 and
     * the monitors are in grid like this
     *
     *   +---+---+---+
     *   | A | B | C |
     *   +---+---+---+
     *   | D | E | F |
     *   +---+---+---+
     *
     * then for each monitor you would call it like this
     *
     *   var w = 1920;
     *   var h = 1080;
     *   var fullWidth = w * 3;
     *   var fullHeight = h * 2;
     *
     *   --A--
     *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
     *   --B--
     *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
     *   --C--
     *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
     *   --D--
     *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
     *   --E--
     *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
     *   --F--
     *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
     *
     *   Note there is no reason monitors have to be the same size or in a grid.
     */
    setViewOffset: function (fullWidth, fullHeight, x, y, width, height) {
      this.aspect = fullWidth / fullHeight

      if (this.view === null) {
        this.view = {
          enabled: true,
          fullWidth: 1,
          fullHeight: 1,
          offsetX: 0,
          offsetY: 0,
          width: 1,
          height: 1
        }
      }

      this.view.enabled = true
      this.view.fullWidth = fullWidth
      this.view.fullHeight = fullHeight
      this.view.offsetX = x
      this.view.offsetY = y
      this.view.width = width
      this.view.height = height

      this.updateProjectionMatrix()
    },

    clearViewOffset: function () {
      if (this.view !== null) {
        this.view.enabled = false
      }

      this.updateProjectionMatrix()
    },

    updateProjectionMatrix: function () {
      var near = this.near,
        top = (near * Math.tan(_Math.DEG2RAD * 0.5 * this.fov)) / this.zoom,
        height = 2 * top,
        width = this.aspect * height,
        left = -0.5 * width,
        view = this.view

      if (this.view !== null && this.view.enabled) {
        var fullWidth = view.fullWidth,
          fullHeight = view.fullHeight

        left += (view.offsetX * width) / fullWidth
        top -= (view.offsetY * height) / fullHeight
        width *= view.width / fullWidth
        height *= view.height / fullHeight
      }

      var skew = this.filmOffset
      if (skew !== 0) left += (near * skew) / this.getFilmWidth()

      this.projectionMatrix.makePerspective(left, left + width, top, top - height, near, this.far)
    },

    toJSON: function (meta) {
      var data = Object3D.prototype.toJSON.call(this, meta)

      data.object.fov = this.fov
      data.object.zoom = this.zoom

      data.object.near = this.near
      data.object.far = this.far
      data.object.focus = this.focus

      data.object.aspect = this.aspect

      if (this.view !== null) data.object.view = Object.assign({}, this.view)

      data.object.filmGauge = this.filmGauge
      data.object.filmOffset = this.filmOffset

      return data
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function ArrayCamera(array) {
    PerspectiveCamera.call(this)

    this.cameras = array || []
  }

  ArrayCamera.prototype = Object.assign(Object.create(PerspectiveCamera.prototype), {
    constructor: ArrayCamera,

    isArrayCamera: true
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebVRManager(renderer) {
    var scope = this

    var device = null
    var frameData = null

    var poseTarget = null

    var standingMatrix = new Matrix4()
    var standingMatrixInverse = new Matrix4()

    if (typeof window !== 'undefined' && 'VRFrameData' in window) {
      frameData = new window.VRFrameData()
    }

    var matrixWorldInverse = new Matrix4()

    var cameraL = new PerspectiveCamera()
    cameraL.bounds = new Vector4(0.0, 0.0, 0.5, 1.0)
    cameraL.layers.enable(1)

    var cameraR = new PerspectiveCamera()
    cameraR.bounds = new Vector4(0.5, 0.0, 0.5, 1.0)
    cameraR.layers.enable(2)

    var cameraVR = new ArrayCamera([cameraL, cameraR])
    cameraVR.layers.enable(1)
    cameraVR.layers.enable(2)

    //

    var currentSize, currentPixelRatio

    function onVRDisplayPresentChange() {
      if (device !== null && device.isPresenting) {
        var eyeParameters = device.getEyeParameters('left')
        var renderWidth = eyeParameters.renderWidth
        var renderHeight = eyeParameters.renderHeight

        currentPixelRatio = renderer.getPixelRatio()
        currentSize = renderer.getSize()

        renderer.setDrawingBufferSize(renderWidth * 2, renderHeight, 1)
      } else if (scope.enabled) {
        renderer.setDrawingBufferSize(currentSize.width, currentSize.height, currentPixelRatio)
      }
    }

    if (typeof window !== 'undefined') {
      window.addEventListener('vrdisplaypresentchange', onVRDisplayPresentChange, false)
    }

    //

    this.enabled = false
    this.userHeight = 1.6

    this.getDevice = function () {
      return device
    }

    this.setDevice = function (value) {
      if (value !== undefined) device = value
    }

    this.setPoseTarget = function (object) {
      if (object !== undefined) poseTarget = object
    }

    this.getCamera = function (camera) {
      if (device === null) return camera

      device.depthNear = camera.near
      device.depthFar = camera.far

      device.getFrameData(frameData)

      //

      var pose = frameData.pose
      var poseObject = poseTarget !== null ? poseTarget : camera

      if (pose.position !== null) {
        poseObject.position.fromArray(pose.position)
      } else {
        poseObject.position.set(0, 0, 0)
      }

      if (pose.orientation !== null) {
        poseObject.quaternion.fromArray(pose.orientation)
      }

      var stageParameters = device.stageParameters

      if (stageParameters) {
        standingMatrix.fromArray(stageParameters.sittingToStandingTransform)
      } else {
        standingMatrix.makeTranslation(0, scope.userHeight, 0)
      }

      poseObject.position.applyMatrix4(standingMatrix)
      poseObject.updateMatrixWorld()

      if (device.isPresenting === false) return camera

      //

      cameraL.near = camera.near
      cameraR.near = camera.near

      cameraL.far = camera.far
      cameraR.far = camera.far

      cameraVR.matrixWorld.copy(camera.matrixWorld)
      cameraVR.matrixWorldInverse.copy(camera.matrixWorldInverse)

      cameraL.matrixWorldInverse.fromArray(frameData.leftViewMatrix)
      cameraR.matrixWorldInverse.fromArray(frameData.rightViewMatrix)

      // TODO (mrdoob) Double check this code

      standingMatrixInverse.getInverse(standingMatrix)

      cameraL.matrixWorldInverse.multiply(standingMatrixInverse)
      cameraR.matrixWorldInverse.multiply(standingMatrixInverse)

      var parent = poseObject.parent

      if (parent !== null) {
        matrixWorldInverse.getInverse(parent.matrixWorld)

        cameraL.matrixWorldInverse.multiply(matrixWorldInverse)
        cameraR.matrixWorldInverse.multiply(matrixWorldInverse)
      }

      // envMap and Mirror needs camera.matrixWorld

      cameraL.matrixWorld.getInverse(cameraL.matrixWorldInverse)
      cameraR.matrixWorld.getInverse(cameraR.matrixWorldInverse)

      cameraL.projectionMatrix.fromArray(frameData.leftProjectionMatrix)
      cameraR.projectionMatrix.fromArray(frameData.rightProjectionMatrix)

      // HACK (mrdoob)
      // https://github.com/w3c/webvr/issues/203

      cameraVR.projectionMatrix.copy(cameraL.projectionMatrix)

      //

      var layers = device.getLayers()

      if (layers.length) {
        var layer = layers[0]

        if (layer.leftBounds !== null && layer.leftBounds.length === 4) {
          cameraL.bounds.fromArray(layer.leftBounds)
        }

        if (layer.rightBounds !== null && layer.rightBounds.length === 4) {
          cameraR.bounds.fromArray(layer.rightBounds)
        }
      }

      return cameraVR
    }

    this.getStandingMatrix = function () {
      return standingMatrix
    }

    this.submitFrame = function () {
      if (device && device.isPresenting) device.submitFrame()
    }

    this.dispose = function () {
      if (typeof window !== 'undefined') {
        window.removeEventListener('vrdisplaypresentchange', onVRDisplayPresentChange)
      }
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function WebGLExtensions(gl) {
    var extensions = {}

    return {
      get: function (name) {
        if (extensions[name] !== undefined) {
          return extensions[name]
        }

        var extension

        switch (name) {
          case 'WEBGL_depth_texture':
            extension =
              gl.getExtension('WEBGL_depth_texture') ||
              gl.getExtension('MOZ_WEBGL_depth_texture') ||
              gl.getExtension('WEBKIT_WEBGL_depth_texture')
            break

          case 'EXT_texture_filter_anisotropic':
            extension =
              gl.getExtension('EXT_texture_filter_anisotropic') ||
              gl.getExtension('MOZ_EXT_texture_filter_anisotropic') ||
              gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic')
            break

          case 'WEBGL_compressed_texture_s3tc':
            extension =
              gl.getExtension('WEBGL_compressed_texture_s3tc') ||
              gl.getExtension('MOZ_WEBGL_compressed_texture_s3tc') ||
              gl.getExtension('WEBKIT_WEBGL_compressed_texture_s3tc')
            break

          case 'WEBGL_compressed_texture_pvrtc':
            extension =
              gl.getExtension('WEBGL_compressed_texture_pvrtc') ||
              gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc')
            break

          case 'WEBGL_compressed_texture_etc1':
            extension = gl.getExtension('WEBGL_compressed_texture_etc1')
            break

          default:
            extension = gl.getExtension(name)
        }

        if (extension === null) {
          console.warn('THREE.WebGLRenderer: ' + name + ' extension not supported.')
        }

        extensions[name] = extension

        return extension
      }
    }
  }

  /**
   * @author tschw
   */

  function WebGLClipping() {
    var scope = this,
      globalState = null,
      numGlobalPlanes = 0,
      localClippingEnabled = false,
      renderingShadows = false,
      plane = new Plane(),
      viewNormalMatrix = new Matrix3(),
      uniform = { value: null, needsUpdate: false }

    this.uniform = uniform
    this.numPlanes = 0
    this.numIntersection = 0

    this.init = function (planes, enableLocalClipping, camera) {
      var enabled =
        planes.length !== 0 ||
        enableLocalClipping ||
        // enable state of previous frame - the clipping code has to
        // run another frame in order to reset the state:
        numGlobalPlanes !== 0 ||
        localClippingEnabled

      localClippingEnabled = enableLocalClipping

      globalState = projectPlanes(planes, camera, 0)
      numGlobalPlanes = planes.length

      return enabled
    }

    this.beginShadows = function () {
      renderingShadows = true
      projectPlanes(null)
    }

    this.endShadows = function () {
      renderingShadows = false
      resetGlobalState()
    }

    this.setState = function (planes, clipIntersection, clipShadows, camera, cache, fromCache) {
      if (
        !localClippingEnabled ||
        planes === null ||
        planes.length === 0 ||
        (renderingShadows && !clipShadows)
      ) {
        // there's no local clipping

        if (renderingShadows) {
          // there's no global clipping

          projectPlanes(null)
        } else {
          resetGlobalState()
        }
      } else {
        var nGlobal = renderingShadows ? 0 : numGlobalPlanes,
          lGlobal = nGlobal * 4,
          dstArray = cache.clippingState || null

        uniform.value = dstArray // ensure unique state

        dstArray = projectPlanes(planes, camera, lGlobal, fromCache)

        for (var i = 0; i !== lGlobal; ++i) {
          dstArray[i] = globalState[i]
        }

        cache.clippingState = dstArray
        this.numIntersection = clipIntersection ? this.numPlanes : 0
        this.numPlanes += nGlobal
      }
    }

    function resetGlobalState() {
      if (uniform.value !== globalState) {
        uniform.value = globalState
        uniform.needsUpdate = numGlobalPlanes > 0
      }

      scope.numPlanes = numGlobalPlanes
      scope.numIntersection = 0
    }

    function projectPlanes(planes, camera, dstOffset, skipTransform) {
      var nPlanes = planes !== null ? planes.length : 0,
        dstArray = null

      if (nPlanes !== 0) {
        dstArray = uniform.value

        if (skipTransform !== true || dstArray === null) {
          var flatSize = dstOffset + nPlanes * 4,
            viewMatrix = camera.matrixWorldInverse

          viewNormalMatrix.getNormalMatrix(viewMatrix)

          if (dstArray === null || dstArray.length < flatSize) {
            dstArray = new Float32Array(flatSize)
          }

          for (var i = 0, i4 = dstOffset; i !== nPlanes; ++i, i4 += 4) {
            plane.copy(planes[i]).applyMatrix4(viewMatrix, viewNormalMatrix)

            plane.normal.toArray(dstArray, i4)
            dstArray[i4 + 3] = plane.constant
          }
        }

        uniform.value = dstArray
        uniform.needsUpdate = true
      }

      scope.numPlanes = nPlanes

      return dstArray
    }
  }

  /**
   * @author thespite / http://www.twitter.com/thespite
   */

  function WebGLUtils(gl, extensions) {
    function convert(p) {
      var extension

      if (p === RepeatWrapping) return gl.REPEAT
      if (p === ClampToEdgeWrapping) return gl.CLAMP_TO_EDGE
      if (p === MirroredRepeatWrapping) return gl.MIRRORED_REPEAT

      if (p === NearestFilter) return gl.NEAREST
      if (p === NearestMipMapNearestFilter) return gl.NEAREST_MIPMAP_NEAREST
      if (p === NearestMipMapLinearFilter) return gl.NEAREST_MIPMAP_LINEAR

      if (p === LinearFilter) return gl.LINEAR
      if (p === LinearMipMapNearestFilter) return gl.LINEAR_MIPMAP_NEAREST
      if (p === LinearMipMapLinearFilter) return gl.LINEAR_MIPMAP_LINEAR

      if (p === UnsignedByteType) return gl.UNSIGNED_BYTE
      if (p === UnsignedShort4444Type) return gl.UNSIGNED_SHORT_4_4_4_4
      if (p === UnsignedShort5551Type) return gl.UNSIGNED_SHORT_5_5_5_1
      if (p === UnsignedShort565Type) return gl.UNSIGNED_SHORT_5_6_5

      if (p === ByteType) return gl.BYTE
      if (p === ShortType) return gl.SHORT
      if (p === UnsignedShortType) return gl.UNSIGNED_SHORT
      if (p === IntType) return gl.INT
      if (p === UnsignedIntType) return gl.UNSIGNED_INT
      if (p === FloatType) return gl.FLOAT

      if (p === HalfFloatType) {
        extension = extensions.get('OES_texture_half_float')

        if (extension !== null) return extension.HALF_FLOAT_OES
      }

      if (p === AlphaFormat) return gl.ALPHA
      if (p === RGBFormat) return gl.RGB
      if (p === RGBAFormat) return gl.RGBA
      if (p === LuminanceFormat) return gl.LUMINANCE
      if (p === LuminanceAlphaFormat) return gl.LUMINANCE_ALPHA
      if (p === DepthFormat) return gl.DEPTH_COMPONENT
      if (p === DepthStencilFormat) return gl.DEPTH_STENCIL

      if (p === AddEquation) return gl.FUNC_ADD
      if (p === SubtractEquation) return gl.FUNC_SUBTRACT
      if (p === ReverseSubtractEquation) return gl.FUNC_REVERSE_SUBTRACT

      if (p === ZeroFactor) return gl.ZERO
      if (p === OneFactor) return gl.ONE
      if (p === SrcColorFactor) return gl.SRC_COLOR
      if (p === OneMinusSrcColorFactor) return gl.ONE_MINUS_SRC_COLOR
      if (p === SrcAlphaFactor) return gl.SRC_ALPHA
      if (p === OneMinusSrcAlphaFactor) return gl.ONE_MINUS_SRC_ALPHA
      if (p === DstAlphaFactor) return gl.DST_ALPHA
      if (p === OneMinusDstAlphaFactor) return gl.ONE_MINUS_DST_ALPHA

      if (p === DstColorFactor) return gl.DST_COLOR
      if (p === OneMinusDstColorFactor) return gl.ONE_MINUS_DST_COLOR
      if (p === SrcAlphaSaturateFactor) return gl.SRC_ALPHA_SATURATE

      if (
        p === RGB_S3TC_DXT1_Format ||
        p === RGBA_S3TC_DXT1_Format ||
        p === RGBA_S3TC_DXT3_Format ||
        p === RGBA_S3TC_DXT5_Format
      ) {
        extension = extensions.get('WEBGL_compressed_texture_s3tc')

        if (extension !== null) {
          if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT
          if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT
          if (p === RGBA_S3TC_DXT3_Format) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT
          if (p === RGBA_S3TC_DXT5_Format) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT
        }
      }

      if (
        p === RGB_PVRTC_4BPPV1_Format ||
        p === RGB_PVRTC_2BPPV1_Format ||
        p === RGBA_PVRTC_4BPPV1_Format ||
        p === RGBA_PVRTC_2BPPV1_Format
      ) {
        extension = extensions.get('WEBGL_compressed_texture_pvrtc')

        if (extension !== null) {
          if (p === RGB_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
          if (p === RGB_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG
          if (p === RGBA_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
          if (p === RGBA_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
        }
      }

      if (p === RGB_ETC1_Format) {
        extension = extensions.get('WEBGL_compressed_texture_etc1')

        if (extension !== null) return extension.COMPRESSED_RGB_ETC1_WEBGL
      }

      if (
        p === RGBA_ASTC_4x4_Format ||
        p === RGBA_ASTC_5x4_Format ||
        p === RGBA_ASTC_5x5_Format ||
        p === RGBA_ASTC_6x5_Format ||
        p === RGBA_ASTC_6x6_Format ||
        p === RGBA_ASTC_8x5_Format ||
        p === RGBA_ASTC_8x6_Format ||
        p === RGBA_ASTC_8x8_Format ||
        p === RGBA_ASTC_10x5_Format ||
        p === RGBA_ASTC_10x6_Format ||
        p === RGBA_ASTC_10x8_Format ||
        p === RGBA_ASTC_10x10_Format ||
        p === RGBA_ASTC_12x10_Format ||
        p === RGBA_ASTC_12x12_Format
      ) {
        extension = extensions.get('WEBGL_compressed_texture_astc')

        if (extension !== null) {
          return p
        }
      }

      if (p === MinEquation || p === MaxEquation) {
        extension = extensions.get('EXT_blend_minmax')

        if (extension !== null) {
          if (p === MinEquation) return extension.MIN_EXT
          if (p === MaxEquation) return extension.MAX_EXT
        }
      }

      if (p === UnsignedInt248Type) {
        extension = extensions.get('WEBGL_depth_texture')

        if (extension !== null) return extension.UNSIGNED_INT_24_8_WEBGL
      }

      return 0
    }

    return { convert: convert }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function UniformsCache() {
    var lights = {}

    return {
      get: function (light) {
        if (lights[light.id] !== undefined) {
          return lights[light.id]
        }

        var uniforms

        switch (light.type) {
          case 'DirectionalLight':
            uniforms = {
              direction: new Vector3(),
              color: new Color(),

              shadow: false,
              shadowBias: 0,
              shadowRadius: 1,
              shadowMapSize: new Vector2()
            }
            break

          case 'SpotLight':
            uniforms = {
              position: new Vector3(),
              direction: new Vector3(),
              color: new Color(),
              distance: 0,
              coneCos: 0,
              penumbraCos: 0,
              decay: 0,

              shadow: false,
              shadowBias: 0,
              shadowRadius: 1,
              shadowMapSize: new Vector2()
            }
            break

          case 'PointLight':
            uniforms = {
              position: new Vector3(),
              color: new Color(),
              distance: 0,
              decay: 0,

              shadow: false,
              shadowBias: 0,
              shadowRadius: 1,
              shadowMapSize: new Vector2(),
              shadowCameraNear: 1,
              shadowCameraFar: 1000
            }
            break

          case 'HemisphereLight':
            uniforms = {
              direction: new Vector3(),
              skyColor: new Color(),
              groundColor: new Color()
            }
            break

          case 'RectAreaLight':
            uniforms = {
              color: new Color(),
              position: new Vector3(),
              halfWidth: new Vector3(),
              halfHeight: new Vector3()
              // TODO (abelnation): set RectAreaLight shadow uniforms
            }
            break
        }

        lights[light.id] = uniforms

        return uniforms
      }
    }
  }

  var count = 0

  function WebGLLights() {
    var cache = new UniformsCache()

    var state = {
      id: count++,

      hash: '',

      ambient: [0, 0, 0],
      directional: [],
      directionalShadowMap: [],
      directionalShadowMatrix: [],
      spot: [],
      spotShadowMap: [],
      spotShadowMatrix: [],
      rectArea: [],
      point: [],
      pointShadowMap: [],
      pointShadowMatrix: [],
      hemi: []
    }

    var vector3 = new Vector3()
    var matrix4 = new Matrix4()
    var matrix42 = new Matrix4()

    function setup(lights, shadows, camera) {
      var r = 0,
        g = 0,
        b = 0

      var directionalLength = 0
      var pointLength = 0
      var spotLength = 0
      var rectAreaLength = 0
      var hemiLength = 0

      var viewMatrix = camera.matrixWorldInverse

      for (var i = 0, l = lights.length; i < l; i++) {
        var light = lights[i]

        var color = light.color
        var intensity = light.intensity
        var distance = light.distance

        var shadowMap = light.shadow && light.shadow.map ? light.shadow.map.texture : null

        if (light.isAmbientLight) {
          r += color.r * intensity
          g += color.g * intensity
          b += color.b * intensity
        } else if (light.isDirectionalLight) {
          var uniforms = cache.get(light)

          uniforms.color.copy(light.color).multiplyScalar(light.intensity)
          uniforms.direction.setFromMatrixPosition(light.matrixWorld)
          vector3.setFromMatrixPosition(light.target.matrixWorld)
          uniforms.direction.sub(vector3)
          uniforms.direction.transformDirection(viewMatrix)

          uniforms.shadow = light.castShadow

          if (light.castShadow) {
            var shadow = light.shadow

            uniforms.shadowBias = shadow.bias
            uniforms.shadowRadius = shadow.radius
            uniforms.shadowMapSize = shadow.mapSize
          }

          state.directionalShadowMap[directionalLength] = shadowMap
          state.directionalShadowMatrix[directionalLength] = light.shadow.matrix
          state.directional[directionalLength] = uniforms

          directionalLength++
        } else if (light.isSpotLight) {
          var uniforms = cache.get(light)

          uniforms.position.setFromMatrixPosition(light.matrixWorld)
          uniforms.position.applyMatrix4(viewMatrix)

          uniforms.color.copy(color).multiplyScalar(intensity)
          uniforms.distance = distance

          uniforms.direction.setFromMatrixPosition(light.matrixWorld)
          vector3.setFromMatrixPosition(light.target.matrixWorld)
          uniforms.direction.sub(vector3)
          uniforms.direction.transformDirection(viewMatrix)

          uniforms.coneCos = Math.cos(light.angle)
          uniforms.penumbraCos = Math.cos(light.angle * (1 - light.penumbra))
          uniforms.decay = light.distance === 0 ? 0.0 : light.decay

          uniforms.shadow = light.castShadow

          if (light.castShadow) {
            var shadow = light.shadow

            uniforms.shadowBias = shadow.bias
            uniforms.shadowRadius = shadow.radius
            uniforms.shadowMapSize = shadow.mapSize
          }

          state.spotShadowMap[spotLength] = shadowMap
          state.spotShadowMatrix[spotLength] = light.shadow.matrix
          state.spot[spotLength] = uniforms

          spotLength++
        } else if (light.isRectAreaLight) {
          var uniforms = cache.get(light)

          // (a) intensity is the total visible light emitted
          //uniforms.color.copy( color ).multiplyScalar( intensity / ( light.width * light.height * Math.PI ) );

          // (b) intensity is the brightness of the light
          uniforms.color.copy(color).multiplyScalar(intensity)

          uniforms.position.setFromMatrixPosition(light.matrixWorld)
          uniforms.position.applyMatrix4(viewMatrix)

          // extract local rotation of light to derive width/height half vectors
          matrix42.identity()
          matrix4.copy(light.matrixWorld)
          matrix4.premultiply(viewMatrix)
          matrix42.extractRotation(matrix4)

          uniforms.halfWidth.set(light.width * 0.5, 0.0, 0.0)
          uniforms.halfHeight.set(0.0, light.height * 0.5, 0.0)

          uniforms.halfWidth.applyMatrix4(matrix42)
          uniforms.halfHeight.applyMatrix4(matrix42)

          // TODO (abelnation): RectAreaLight distance?
          // uniforms.distance = distance;

          state.rectArea[rectAreaLength] = uniforms

          rectAreaLength++
        } else if (light.isPointLight) {
          var uniforms = cache.get(light)

          uniforms.position.setFromMatrixPosition(light.matrixWorld)
          uniforms.position.applyMatrix4(viewMatrix)

          uniforms.color.copy(light.color).multiplyScalar(light.intensity)
          uniforms.distance = light.distance
          uniforms.decay = light.distance === 0 ? 0.0 : light.decay

          uniforms.shadow = light.castShadow

          if (light.castShadow) {
            var shadow = light.shadow

            uniforms.shadowBias = shadow.bias
            uniforms.shadowRadius = shadow.radius
            uniforms.shadowMapSize = shadow.mapSize
            uniforms.shadowCameraNear = shadow.camera.near
            uniforms.shadowCameraFar = shadow.camera.far
          }

          state.pointShadowMap[pointLength] = shadowMap
          state.pointShadowMatrix[pointLength] = light.shadow.matrix
          state.point[pointLength] = uniforms

          pointLength++
        } else if (light.isHemisphereLight) {
          var uniforms = cache.get(light)

          uniforms.direction.setFromMatrixPosition(light.matrixWorld)
          uniforms.direction.transformDirection(viewMatrix)
          uniforms.direction.normalize()

          uniforms.skyColor.copy(light.color).multiplyScalar(intensity)
          uniforms.groundColor.copy(light.groundColor).multiplyScalar(intensity)

          state.hemi[hemiLength] = uniforms

          hemiLength++
        }
      }

      state.ambient[0] = r
      state.ambient[1] = g
      state.ambient[2] = b

      state.directional.length = directionalLength
      state.spot.length = spotLength
      state.rectArea.length = rectAreaLength
      state.point.length = pointLength
      state.hemi.length = hemiLength

      state.hash =
        state.id +
        ',' +
        directionalLength +
        ',' +
        pointLength +
        ',' +
        spotLength +
        ',' +
        rectAreaLength +
        ',' +
        hemiLength +
        ',' +
        shadows.length
    }

    return {
      setup: setup,
      state: state
    }
  }

  /**
   * @author Mugen87 / https://github.com/Mugen87
   */

  function WebGLRenderState() {
    var lights = new WebGLLights()

    var lightsArray = []
    var shadowsArray = []
    var spritesArray = []

    function init() {
      lightsArray.length = 0
      shadowsArray.length = 0
      spritesArray.length = 0
    }

    function pushLight(light) {
      lightsArray.push(light)
    }

    function pushShadow(shadowLight) {
      shadowsArray.push(shadowLight)
    }

    function pushSprite(shadowLight) {
      spritesArray.push(shadowLight)
    }

    function setupLights(camera) {
      lights.setup(lightsArray, shadowsArray, camera)
    }

    var state = {
      lightsArray: lightsArray,
      shadowsArray: shadowsArray,
      spritesArray: spritesArray,

      lights: lights
    }

    return {
      init: init,
      state: state,
      setupLights: setupLights,

      pushLight: pushLight,
      pushShadow: pushShadow,
      pushSprite: pushSprite
    }
  }

  function WebGLRenderStates() {
    var renderStates = {}

    function get(scene, camera) {
      var hash = scene.id + ',' + camera.id

      var renderState = renderStates[hash]

      if (renderState === undefined) {
        renderState = new WebGLRenderState()
        renderStates[hash] = renderState
      }

      return renderState
    }

    function dispose() {
      renderStates = {}
    }

    return {
      get: get,
      dispose: dispose
    }
  }

  /**
   * @author supereggbert / http://www.paulbrunt.co.uk/
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   * @author szimek / https://github.com/szimek/
   * @author tschw
   */

  function WebGLRenderer(parameters) {
    console.log('THREE.WebGLRenderer', REVISION)

    parameters = parameters || {}

    var _canvas =
        parameters.canvas !== undefined
          ? parameters.canvas
          : document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas'),
      _context = parameters.context !== undefined ? parameters.context : null,
      _alpha = parameters.alpha !== undefined ? parameters.alpha : false,
      _depth = parameters.depth !== undefined ? parameters.depth : true,
      _stencil = parameters.stencil !== undefined ? parameters.stencil : true,
      _antialias = parameters.antialias !== undefined ? parameters.antialias : false,
      _premultipliedAlpha =
        parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,
      _preserveDrawingBuffer =
        parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false,
      _powerPreference =
        parameters.powerPreference !== undefined ? parameters.powerPreference : 'default'

    var currentRenderList = null
    var currentRenderState = null

    // public properties

    this.domElement = _canvas
    this.context = null

    // clearing

    this.autoClear = true
    this.autoClearColor = true
    this.autoClearDepth = true
    this.autoClearStencil = true

    // scene graph

    this.sortObjects = true

    // user-defined clipping

    this.clippingPlanes = []
    this.localClippingEnabled = false

    // physically based shading

    this.gammaFactor = 2.0 // for backwards compatibility
    this.gammaInput = false
    this.gammaOutput = false

    // physical lights

    this.physicallyCorrectLights = false

    // tone mapping

    this.toneMapping = LinearToneMapping
    this.toneMappingExposure = 1.0
    this.toneMappingWhitePoint = 1.0

    // morphs

    this.maxMorphTargets = 8
    this.maxMorphNormals = 4

    // internal properties

    var _this = this,
      _isContextLost = false,
      // internal state cache

      _currentRenderTarget = null,
      _currentFramebuffer = null,
      _currentMaterialId = -1,
      _currentGeometryProgram = '',
      _currentCamera = null,
      _currentArrayCamera = null,
      _currentViewport = new Vector4(),
      _currentScissor = new Vector4(),
      _currentScissorTest = null,
      //

      _usedTextureUnits = 0,
      //

      _width = _canvas.width,
      _height = _canvas.height,
      _pixelRatio = 1,
      _viewport = new Vector4(0, 0, _width, _height),
      _scissor = new Vector4(0, 0, _width, _height),
      _scissorTest = false,
      // frustum

      _frustum = new Frustum(),
      // clipping

      _clipping = new WebGLClipping(),
      _clippingEnabled = false,
      _localClippingEnabled = false,
      // camera matrices cache

      _projScreenMatrix = new Matrix4(),
      _vector3 = new Vector3(),
      // info

      _infoMemory = {
        geometries: 0,
        textures: 0
      },
      _infoRender = {
        frame: 0,
        calls: 0,
        vertices: 0,
        faces: 0,
        points: 0
      }

    this.info = {
      render: _infoRender,
      memory: _infoMemory,
      programs: null,
      autoReset: true,
      reset: resetInfo
    }

    function resetInfo() {
      _infoRender.frame++
      _infoRender.calls = 0
      _infoRender.vertices = 0
      _infoRender.faces = 0
      _infoRender.points = 0
    }

    function getTargetPixelRatio() {
      return _currentRenderTarget === null ? _pixelRatio : 1
    }

    // initialize

    var _gl

    try {
      var contextAttributes = {
        alpha: _alpha,
        depth: _depth,
        stencil: _stencil,
        antialias: _antialias,
        premultipliedAlpha: _premultipliedAlpha,
        preserveDrawingBuffer: _preserveDrawingBuffer,
        powerPreference: _powerPreference
      }

      // event listeners must be registered before WebGL context is created, see #12753

      _canvas.addEventListener('webglcontextlost', onContextLost, false)
      _canvas.addEventListener('webglcontextrestored', onContextRestore, false)

      _gl =
        _context ||
        _canvas.getContext('webgl', contextAttributes) ||
        _canvas.getContext('experimental-webgl', contextAttributes)

      if (_gl === null) {
        if (_canvas.getContext('webgl') !== null) {
          throw new Error('Error creating WebGL context with your selected attributes.')
        } else {
          throw new Error('Error creating WebGL context.')
        }
      }

      // Some experimental-webgl implementations do not have getShaderPrecisionFormat

      if (_gl.getShaderPrecisionFormat === undefined) {
        _gl.getShaderPrecisionFormat = function () {
          return { rangeMin: 1, rangeMax: 1, precision: 1 }
        }
      }
    } catch (error) {
      console.error('THREE.WebGLRenderer: ' + error.message)
    }

    var extensions, capabilities, state
    var properties, textures, attributes, geometries, objects
    var programCache, renderLists, renderStates

    var background, morphtargets, bufferRenderer, indexedBufferRenderer
    var spriteRenderer

    var utils

    function initGLContext() {
      extensions = new WebGLExtensions(_gl)
      extensions.get('WEBGL_depth_texture')
      extensions.get('OES_texture_float')
      extensions.get('OES_texture_float_linear')
      extensions.get('OES_texture_half_float')
      extensions.get('OES_texture_half_float_linear')
      extensions.get('OES_standard_derivatives')
      extensions.get('OES_element_index_uint')
      extensions.get('ANGLE_instanced_arrays')

      utils = new WebGLUtils(_gl, extensions)

      capabilities = new WebGLCapabilities(_gl, extensions, parameters)

      state = new WebGLState(_gl, extensions, utils)
      state.scissor(_currentScissor.copy(_scissor).multiplyScalar(_pixelRatio))
      state.viewport(_currentViewport.copy(_viewport).multiplyScalar(_pixelRatio))

      properties = new WebGLProperties()
      textures = new WebGLTextures(
        _gl,
        extensions,
        state,
        properties,
        capabilities,
        utils,
        _infoMemory,
        _infoRender
      )
      attributes = new WebGLAttributes(_gl)
      geometries = new WebGLGeometries(_gl, attributes, _infoMemory)
      objects = new WebGLObjects(geometries, _infoRender)
      morphtargets = new WebGLMorphtargets(_gl)
      programCache = new WebGLPrograms(_this, extensions, capabilities)
      renderLists = new WebGLRenderLists()
      renderStates = new WebGLRenderStates()

      background = new WebGLBackground(_this, state, geometries, _premultipliedAlpha)

      bufferRenderer = new WebGLBufferRenderer(_gl, extensions, _infoRender)
      indexedBufferRenderer = new WebGLIndexedBufferRenderer(_gl, extensions, _infoRender)

      spriteRenderer = new WebGLSpriteRenderer(_this, _gl, state, textures, capabilities)

      _this.info.programs = programCache.programs

      _this.context = _gl
      _this.capabilities = capabilities
      _this.extensions = extensions
      _this.properties = properties
      _this.renderLists = renderLists
      _this.state = state
    }

    initGLContext()

    // vr

    var vr = new WebVRManager(_this)

    this.vr = vr

    // shadow map

    var shadowMap = new WebGLShadowMap(_this, objects, capabilities.maxTextureSize)

    this.shadowMap = shadowMap

    // API

    this.getContext = function () {
      return _gl
    }

    this.getContextAttributes = function () {
      return _gl.getContextAttributes()
    }

    this.forceContextLoss = function () {
      var extension = extensions.get('WEBGL_lose_context')
      if (extension) extension.loseContext()
    }

    this.forceContextRestore = function () {
      var extension = extensions.get('WEBGL_lose_context')
      if (extension) extension.restoreContext()
    }

    this.getPixelRatio = function () {
      return _pixelRatio
    }

    this.setPixelRatio = function (value) {
      if (value === undefined) return

      _pixelRatio = value

      this.setSize(_width, _height, false)
    }

    this.getSize = function () {
      return {
        width: _width,
        height: _height
      }
    }

    this.setSize = function (width, height, updateStyle) {
      var device = vr.getDevice()

      if (device && device.isPresenting) {
        console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting.")
        return
      }

      _width = width
      _height = height

      _canvas.width = width * _pixelRatio
      _canvas.height = height * _pixelRatio

      if (updateStyle !== false) {
        _canvas.style.width = width + 'px'
        _canvas.style.height = height + 'px'
      }

      this.setViewport(0, 0, width, height)
    }

    this.getDrawingBufferSize = function () {
      return {
        width: _width * _pixelRatio,
        height: _height * _pixelRatio
      }
    }

    this.setDrawingBufferSize = function (width, height, pixelRatio) {
      _width = width
      _height = height

      _pixelRatio = pixelRatio

      _canvas.width = width * pixelRatio
      _canvas.height = height * pixelRatio

      this.setViewport(0, 0, width, height)
    }

    this.getCurrentViewport = function () {
      return _currentViewport
    }

    this.setViewport = function (x, y, width, height) {
      _viewport.set(x, _height - y - height, width, height)
      state.viewport(_currentViewport.copy(_viewport).multiplyScalar(_pixelRatio))
    }

    this.setScissor = function (x, y, width, height) {
      _scissor.set(x, _height - y - height, width, height)
      state.scissor(_currentScissor.copy(_scissor).multiplyScalar(_pixelRatio))
    }

    this.setScissorTest = function (boolean) {
      state.setScissorTest((_scissorTest = boolean))
    }

    // Clearing

    this.getClearColor = function () {
      return background.getClearColor()
    }

    this.setClearColor = function () {
      background.setClearColor.apply(background, arguments)
    }

    this.getClearAlpha = function () {
      return background.getClearAlpha()
    }

    this.setClearAlpha = function () {
      background.setClearAlpha.apply(background, arguments)
    }

    this.clear = function (color, depth, stencil) {
      var bits = 0

      if (color === undefined || color) bits |= _gl.COLOR_BUFFER_BIT
      if (depth === undefined || depth) bits |= _gl.DEPTH_BUFFER_BIT
      if (stencil === undefined || stencil) bits |= _gl.STENCIL_BUFFER_BIT

      _gl.clear(bits)
    }

    this.clearColor = function () {
      this.clear(true, false, false)
    }

    this.clearDepth = function () {
      this.clear(false, true, false)
    }

    this.clearStencil = function () {
      this.clear(false, false, true)
    }

    this.clearTarget = function (renderTarget, color, depth, stencil) {
      this.setRenderTarget(renderTarget)
      this.clear(color, depth, stencil)
    }

    //

    this.dispose = function () {
      _canvas.removeEventListener('webglcontextlost', onContextLost, false)
      _canvas.removeEventListener('webglcontextrestored', onContextRestore, false)

      renderLists.dispose()
      renderStates.dispose()
      properties.dispose()
      objects.dispose()

      vr.dispose()

      stopAnimation()
    }

    // Events

    function onContextLost(event) {
      event.preventDefault()

      console.log('THREE.WebGLRenderer: Context Lost.')

      _isContextLost = true
    }

    function onContextRestore(/* event */) {
      console.log('THREE.WebGLRenderer: Context Restored.')

      _isContextLost = false

      initGLContext()
    }

    function onMaterialDispose(event) {
      var material = event.target

      material.removeEventListener('dispose', onMaterialDispose)

      deallocateMaterial(material)
    }

    // Buffer deallocation

    function deallocateMaterial(material) {
      releaseMaterialProgramReference(material)

      properties.remove(material)
    }

    function releaseMaterialProgramReference(material) {
      var programInfo = properties.get(material).program

      material.program = undefined

      if (programInfo !== undefined) {
        programCache.releaseProgram(programInfo)
      }
    }

    // Buffer rendering

    function renderObjectImmediate(object, program, material) {
      object.render(function (object) {
        _this.renderBufferImmediate(object, program, material)
      })
    }

    this.renderBufferImmediate = function (object, program, material) {
      state.initAttributes()

      var buffers = properties.get(object)

      if (object.hasPositions && !buffers.position) buffers.position = _gl.createBuffer()
      if (object.hasNormals && !buffers.normal) buffers.normal = _gl.createBuffer()
      if (object.hasUvs && !buffers.uv) buffers.uv = _gl.createBuffer()
      if (object.hasColors && !buffers.color) buffers.color = _gl.createBuffer()

      var programAttributes = program.getAttributes()

      if (object.hasPositions) {
        _gl.bindBuffer(_gl.ARRAY_BUFFER, buffers.position)
        _gl.bufferData(_gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW)

        state.enableAttribute(programAttributes.position)
        _gl.vertexAttribPointer(programAttributes.position, 3, _gl.FLOAT, false, 0, 0)
      }

      if (object.hasNormals) {
        _gl.bindBuffer(_gl.ARRAY_BUFFER, buffers.normal)

        if (
          !material.isMeshPhongMaterial &&
          !material.isMeshStandardMaterial &&
          !material.isMeshNormalMaterial &&
          material.flatShading === true
        ) {
          for (var i = 0, l = object.count * 3; i < l; i += 9) {
            var array = object.normalArray

            var nx = (array[i + 0] + array[i + 3] + array[i + 6]) / 3
            var ny = (array[i + 1] + array[i + 4] + array[i + 7]) / 3
            var nz = (array[i + 2] + array[i + 5] + array[i + 8]) / 3

            array[i + 0] = nx
            array[i + 1] = ny
            array[i + 2] = nz

            array[i + 3] = nx
            array[i + 4] = ny
            array[i + 5] = nz

            array[i + 6] = nx
            array[i + 7] = ny
            array[i + 8] = nz
          }
        }

        _gl.bufferData(_gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW)

        state.enableAttribute(programAttributes.normal)

        _gl.vertexAttribPointer(programAttributes.normal, 3, _gl.FLOAT, false, 0, 0)
      }

      if (object.hasUvs && material.map) {
        _gl.bindBuffer(_gl.ARRAY_BUFFER, buffers.uv)
        _gl.bufferData(_gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW)

        state.enableAttribute(programAttributes.uv)

        _gl.vertexAttribPointer(programAttributes.uv, 2, _gl.FLOAT, false, 0, 0)
      }

      if (object.hasColors && material.vertexColors !== NoColors) {
        _gl.bindBuffer(_gl.ARRAY_BUFFER, buffers.color)
        _gl.bufferData(_gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW)

        state.enableAttribute(programAttributes.color)

        _gl.vertexAttribPointer(programAttributes.color, 3, _gl.FLOAT, false, 0, 0)
      }

      state.disableUnusedAttributes()

      _gl.drawArrays(_gl.TRIANGLES, 0, object.count)

      object.count = 0
    }

    this.renderBufferDirect = function (camera, fog, geometry, material, object, group) {
      var frontFaceCW = object.isMesh && object.matrixWorld.determinant() < 0

      state.setMaterial(material, frontFaceCW)

      var program = setProgram(camera, fog, material, object)
      var geometryProgram = geometry.id + '_' + program.id + '_' + (material.wireframe === true)

      var updateBuffers = false

      if (geometryProgram !== _currentGeometryProgram) {
        _currentGeometryProgram = geometryProgram
        updateBuffers = true
      }

      if (object.morphTargetInfluences) {
        morphtargets.update(object, geometry, material, program)

        updateBuffers = true
      }

      //

      var index = geometry.index
      var position = geometry.attributes.position
      var rangeFactor = 1

      if (material.wireframe === true) {
        index = geometries.getWireframeAttribute(geometry)
        rangeFactor = 2
      }

      var attribute
      var renderer = bufferRenderer

      if (index !== null) {
        attribute = attributes.get(index)

        renderer = indexedBufferRenderer
        renderer.setIndex(attribute)
      }

      if (updateBuffers) {
        setupVertexAttributes(material, program, geometry)

        if (index !== null) {
          _gl.bindBuffer(_gl.ELEMENT_ARRAY_BUFFER, attribute.buffer)
        }
      }

      //

      var dataCount = Infinity

      if (index !== null) {
        dataCount = index.count
      } else if (position !== undefined) {
        dataCount = position.count
      }

      var rangeStart = geometry.drawRange.start * rangeFactor
      var rangeCount = geometry.drawRange.count * rangeFactor

      var groupStart = group !== null ? group.start * rangeFactor : 0
      var groupCount = group !== null ? group.count * rangeFactor : Infinity

      var drawStart = Math.max(rangeStart, groupStart)
      var drawEnd = Math.min(dataCount, rangeStart + rangeCount, groupStart + groupCount) - 1

      var drawCount = Math.max(0, drawEnd - drawStart + 1)

      if (drawCount === 0) return

      //

      if (object.isMesh) {
        if (material.wireframe === true) {
          state.setLineWidth(material.wireframeLinewidth * getTargetPixelRatio())
          renderer.setMode(_gl.LINES)
        } else {
          switch (object.drawMode) {
            case TrianglesDrawMode:
              renderer.setMode(_gl.TRIANGLES)
              break

            case TriangleStripDrawMode:
              renderer.setMode(_gl.TRIANGLE_STRIP)
              break

            case TriangleFanDrawMode:
              renderer.setMode(_gl.TRIANGLE_FAN)
              break
          }
        }
      } else if (object.isLine) {
        var lineWidth = material.linewidth

        if (lineWidth === undefined) lineWidth = 1 // Not using Line*Material

        state.setLineWidth(lineWidth * getTargetPixelRatio())

        if (object.isLineSegments) {
          renderer.setMode(_gl.LINES)
        } else if (object.isLineLoop) {
          renderer.setMode(_gl.LINE_LOOP)
        } else {
          renderer.setMode(_gl.LINE_STRIP)
        }
      } else if (object.isPoints) {
        renderer.setMode(_gl.POINTS)
      }

      if (geometry && geometry.isInstancedBufferGeometry) {
        if (geometry.maxInstancedCount > 0) {
          renderer.renderInstances(geometry, drawStart, drawCount)
        }
      } else {
        renderer.render(drawStart, drawCount)
      }
    }

    function setupVertexAttributes(material, program, geometry, startIndex) {
      if (geometry && geometry.isInstancedBufferGeometry) {
        if (extensions.get('ANGLE_instanced_arrays') === null) {
          console.error(
            'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.'
          )
          return
        }
      }

      if (startIndex === undefined) startIndex = 0

      state.initAttributes()

      var geometryAttributes = geometry.attributes

      var programAttributes = program.getAttributes()

      var materialDefaultAttributeValues = material.defaultAttributeValues

      for (var name in programAttributes) {
        var programAttribute = programAttributes[name]

        if (programAttribute >= 0) {
          var geometryAttribute = geometryAttributes[name]

          if (geometryAttribute !== undefined) {
            var normalized = geometryAttribute.normalized
            var size = geometryAttribute.itemSize

            var attribute = attributes.get(geometryAttribute)

            // TODO Attribute may not be available on context restore

            if (attribute === undefined) continue

            var buffer = attribute.buffer
            var type = attribute.type
            var bytesPerElement = attribute.bytesPerElement

            if (geometryAttribute.isInterleavedBufferAttribute) {
              var data = geometryAttribute.data
              var stride = data.stride
              var offset = geometryAttribute.offset

              if (data && data.isInstancedInterleavedBuffer) {
                state.enableAttributeAndDivisor(programAttribute, data.meshPerAttribute)

                if (geometry.maxInstancedCount === undefined) {
                  geometry.maxInstancedCount = data.meshPerAttribute * data.count
                }
              } else {
                state.enableAttribute(programAttribute)
              }

              _gl.bindBuffer(_gl.ARRAY_BUFFER, buffer)
              _gl.vertexAttribPointer(
                programAttribute,
                size,
                type,
                normalized,
                stride * bytesPerElement,
                (startIndex * stride + offset) * bytesPerElement
              )
            } else {
              if (geometryAttribute.isInstancedBufferAttribute) {
                state.enableAttributeAndDivisor(
                  programAttribute,
                  geometryAttribute.meshPerAttribute
                )

                if (geometry.maxInstancedCount === undefined) {
                  geometry.maxInstancedCount =
                    geometryAttribute.meshPerAttribute * geometryAttribute.count
                }
              } else {
                state.enableAttribute(programAttribute)
              }

              _gl.bindBuffer(_gl.ARRAY_BUFFER, buffer)
              _gl.vertexAttribPointer(
                programAttribute,
                size,
                type,
                normalized,
                0,
                startIndex * size * bytesPerElement
              )
            }
          } else if (materialDefaultAttributeValues !== undefined) {
            var value = materialDefaultAttributeValues[name]

            if (value !== undefined) {
              switch (value.length) {
                case 2:
                  _gl.vertexAttrib2fv(programAttribute, value)
                  break

                case 3:
                  _gl.vertexAttrib3fv(programAttribute, value)
                  break

                case 4:
                  _gl.vertexAttrib4fv(programAttribute, value)
                  break

                default:
                  _gl.vertexAttrib1fv(programAttribute, value)
              }
            }
          }
        }
      }

      state.disableUnusedAttributes()
    }

    // Compile

    this.compile = function (scene, camera) {
      currentRenderState = renderStates.get(scene, camera)
      currentRenderState.init()

      scene.traverse(function (object) {
        if (object.isLight) {
          currentRenderState.pushLight(object)

          if (object.castShadow) {
            currentRenderState.pushShadow(object)
          }
        }
      })

      currentRenderState.setupLights(camera)

      scene.traverse(function (object) {
        if (object.material) {
          if (Array.isArray(object.material)) {
            for (var i = 0; i < object.material.length; i++) {
              initMaterial(object.material[i], scene.fog, object)
            }
          } else {
            initMaterial(object.material, scene.fog, object)
          }
        }
      })
    }

    // Animation Loop

    var isAnimating = false
    var onAnimationFrame = null

    function startAnimation() {
      if (isAnimating) return

      requestAnimationLoopFrame()

      isAnimating = true
    }

    function stopAnimation() {
      isAnimating = false
    }

    function requestAnimationLoopFrame() {
      var device = vr.getDevice()

      if (device && device.isPresenting) {
        device.requestAnimationFrame(animationLoop)
      } else {
        window.requestAnimationFrame(animationLoop)
      }
    }

    function animationLoop(time) {
      if (isAnimating === false) return

      onAnimationFrame(time)

      requestAnimationLoopFrame()
    }

    this.animate = function (callback) {
      onAnimationFrame = callback
      onAnimationFrame !== null ? startAnimation() : stopAnimation()
    }

    // Rendering

    this.render = function (scene, camera, renderTarget, forceClear) {
      if (!(camera && camera.isCamera)) {
        console.error('THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.')
        return
      }

      if (_isContextLost) return

      // reset caching for this frame

      _currentGeometryProgram = ''
      _currentMaterialId = -1
      _currentCamera = null

      // update scene graph

      if (scene.autoUpdate === true) scene.updateMatrixWorld()

      // update camera matrices and frustum

      if (camera.parent === null) camera.updateMatrixWorld()

      if (vr.enabled) {
        camera = vr.getCamera(camera)
      }

      //

      currentRenderState = renderStates.get(scene, camera)
      currentRenderState.init()

      scene.onBeforeRender(_this, scene, camera, renderTarget)

      _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse)
      _frustum.setFromMatrix(_projScreenMatrix)

      _localClippingEnabled = this.localClippingEnabled
      _clippingEnabled = _clipping.init(this.clippingPlanes, _localClippingEnabled, camera)

      currentRenderList = renderLists.get(scene, camera)
      currentRenderList.init()

      projectObject(scene, camera, _this.sortObjects)

      if (_this.sortObjects === true) {
        currentRenderList.sort()
      }

      //

      if (_clippingEnabled) _clipping.beginShadows()

      var shadowsArray = currentRenderState.state.shadowsArray

      shadowMap.render(shadowsArray, scene, camera)

      currentRenderState.setupLights(camera)

      if (_clippingEnabled) _clipping.endShadows()

      //

      if (this.info.autoReset) this.info.reset()

      if (renderTarget === undefined) {
        renderTarget = null
      }

      this.setRenderTarget(renderTarget)

      //

      background.render(currentRenderList, scene, camera, forceClear)

      // render scene

      var opaqueObjects = currentRenderList.opaque
      var transparentObjects = currentRenderList.transparent

      if (scene.overrideMaterial) {
        var overrideMaterial = scene.overrideMaterial

        if (opaqueObjects.length) renderObjects(opaqueObjects, scene, camera, overrideMaterial)
        if (transparentObjects.length)
          renderObjects(transparentObjects, scene, camera, overrideMaterial)
      } else {
        // opaque pass (front-to-back order)

        if (opaqueObjects.length) renderObjects(opaqueObjects, scene, camera)

        // transparent pass (back-to-front order)

        if (transparentObjects.length) renderObjects(transparentObjects, scene, camera)
      }

      // custom renderers

      var spritesArray = currentRenderState.state.spritesArray

      spriteRenderer.render(spritesArray, scene, camera)

      // Generate mipmap if we're using any kind of mipmap filtering

      if (renderTarget) {
        textures.updateRenderTargetMipmap(renderTarget)
      }

      // Ensure depth buffer writing is enabled so it can be cleared on next render

      state.buffers.depth.setTest(true)
      state.buffers.depth.setMask(true)
      state.buffers.color.setMask(true)

      state.setPolygonOffset(false)

      scene.onAfterRender(_this, scene, camera)

      if (vr.enabled) {
        vr.submitFrame()
      }

      // _gl.finish();

      currentRenderList = null
      currentRenderState = null
    }

    /*
		// TODO Duplicated code (Frustum)

		var _sphere = new Sphere();

		function isObjectViewable( object ) {

			var geometry = object.geometry;

			if ( geometry.boundingSphere === null )
				geometry.computeBoundingSphere();

			_sphere.copy( geometry.boundingSphere ).
			applyMatrix4( object.matrixWorld );

			return isSphereViewable( _sphere );

		}

		function isSpriteViewable( sprite ) {

			_sphere.center.set( 0, 0, 0 );
			_sphere.radius = 0.7071067811865476;
			_sphere.applyMatrix4( sprite.matrixWorld );

			return isSphereViewable( _sphere );

		}

		function isSphereViewable( sphere ) {

			if ( ! _frustum.intersectsSphere( sphere ) ) return false;

			var numPlanes = _clipping.numPlanes;

			if ( numPlanes === 0 ) return true;

			var planes = _this.clippingPlanes,

				center = sphere.center,
				negRad = - sphere.radius,
				i = 0;

			do {

				// out when deeper than radius in the negative halfspace
				if ( planes[ i ].distanceToPoint( center ) < negRad ) return false;

			} while ( ++ i !== numPlanes );

			return true;

		}
		*/

    function projectObject(object, camera, sortObjects) {
      if (object.visible === false) return

      var visible = object.layers.test(camera.layers)

      if (visible) {
        if (object.isLight) {
          currentRenderState.pushLight(object)

          if (object.castShadow) {
            currentRenderState.pushShadow(object)
          }
        } else if (object.isSprite) {
          if (!object.frustumCulled || _frustum.intersectsSprite(object)) {
            currentRenderState.pushSprite(object)
          }
        } else if (object.isImmediateRenderObject) {
          if (sortObjects) {
            _vector3.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix)
          }

          currentRenderList.push(object, null, object.material, _vector3.z, null)
        } else if (object.isMesh || object.isLine || object.isPoints) {
          if (object.isSkinnedMesh) {
            object.skeleton.update()
          }

          if (!object.frustumCulled || _frustum.intersectsObject(object)) {
            if (sortObjects) {
              _vector3.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix)
            }

            var geometry = objects.update(object)
            var material = object.material

            if (Array.isArray(material)) {
              var groups = geometry.groups

              for (var i = 0, l = groups.length; i < l; i++) {
                var group = groups[i]
                var groupMaterial = material[group.materialIndex]

                if (groupMaterial && groupMaterial.visible) {
                  currentRenderList.push(object, geometry, groupMaterial, _vector3.z, group)
                }
              }
            } else if (material.visible) {
              currentRenderList.push(object, geometry, material, _vector3.z, null)
            }
          }
        }
      }

      var children = object.children

      for (var i = 0, l = children.length; i < l; i++) {
        projectObject(children[i], camera, sortObjects)
      }
    }

    function renderObjects(renderList, scene, camera, overrideMaterial) {
      for (var i = 0, l = renderList.length; i < l; i++) {
        var renderItem = renderList[i]

        var object = renderItem.object
        var geometry = renderItem.geometry
        var material = overrideMaterial === undefined ? renderItem.material : overrideMaterial
        var group = renderItem.group

        if (camera.isArrayCamera) {
          _currentArrayCamera = camera

          var cameras = camera.cameras

          for (var j = 0, jl = cameras.length; j < jl; j++) {
            var camera2 = cameras[j]

            if (object.layers.test(camera2.layers)) {
              var bounds = camera2.bounds

              var x = bounds.x * _width
              var y = bounds.y * _height
              var width = bounds.z * _width
              var height = bounds.w * _height

              state.viewport(_currentViewport.set(x, y, width, height).multiplyScalar(_pixelRatio))

              renderObject(object, scene, camera2, geometry, material, group)
            }
          }
        } else {
          _currentArrayCamera = null

          renderObject(object, scene, camera, geometry, material, group)
        }
      }
    }

    function renderObject(object, scene, camera, geometry, material, group) {
      object.onBeforeRender(_this, scene, camera, geometry, material, group)
      currentRenderState = renderStates.get(scene, _currentArrayCamera || camera)

      object.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object.matrixWorld)
      object.normalMatrix.getNormalMatrix(object.modelViewMatrix)

      if (object.isImmediateRenderObject) {
        var frontFaceCW = object.isMesh && object.matrixWorld.determinant() < 0

        state.setMaterial(material, frontFaceCW)

        var program = setProgram(camera, scene.fog, material, object)

        _currentGeometryProgram = ''

        renderObjectImmediate(object, program, material)
      } else {
        _this.renderBufferDirect(camera, scene.fog, geometry, material, object, group)
      }

      object.onAfterRender(_this, scene, camera, geometry, material, group)
      currentRenderState = renderStates.get(scene, _currentArrayCamera || camera)
    }

    function initMaterial(material, fog, object) {
      var materialProperties = properties.get(material)

      var lights = currentRenderState.state.lights
      var shadowsArray = currentRenderState.state.shadowsArray

      var parameters = programCache.getParameters(
        material,
        lights.state,
        shadowsArray,
        fog,
        _clipping.numPlanes,
        _clipping.numIntersection,
        object
      )

      var code = programCache.getProgramCode(material, parameters)

      var program = materialProperties.program
      var programChange = true

      if (program === undefined) {
        // new material
        material.addEventListener('dispose', onMaterialDispose)
      } else if (program.code !== code) {
        // changed glsl or parameters
        releaseMaterialProgramReference(material)
      } else if (materialProperties.lightsHash !== lights.state.hash) {
        properties.update(material, 'lightsHash', lights.state.hash)
        programChange = false
      } else if (parameters.shaderID !== undefined) {
        // same glsl and uniform list
        return
      } else {
        // only rebuild uniform list
        programChange = false
      }

      if (programChange) {
        if (parameters.shaderID) {
          var shader = ShaderLib[parameters.shaderID]

          materialProperties.shader = {
            name: material.type,
            uniforms: UniformsUtils.clone(shader.uniforms),
            vertexShader: shader.vertexShader,
            fragmentShader: shader.fragmentShader
          }
        } else {
          materialProperties.shader = {
            name: material.type,
            uniforms: material.uniforms,
            vertexShader: material.vertexShader,
            fragmentShader: material.fragmentShader
          }
        }

        material.onBeforeCompile(materialProperties.shader)

        program = programCache.acquireProgram(material, materialProperties.shader, parameters, code)

        materialProperties.program = program
        material.program = program
      }

      var programAttributes = program.getAttributes()

      if (material.morphTargets) {
        material.numSupportedMorphTargets = 0

        for (var i = 0; i < _this.maxMorphTargets; i++) {
          if (programAttributes['morphTarget' + i] >= 0) {
            material.numSupportedMorphTargets++
          }
        }
      }

      if (material.morphNormals) {
        material.numSupportedMorphNormals = 0

        for (var i = 0; i < _this.maxMorphNormals; i++) {
          if (programAttributes['morphNormal' + i] >= 0) {
            material.numSupportedMorphNormals++
          }
        }
      }

      var uniforms = materialProperties.shader.uniforms

      if (
        (!material.isShaderMaterial && !material.isRawShaderMaterial) ||
        material.clipping === true
      ) {
        materialProperties.numClippingPlanes = _clipping.numPlanes
        materialProperties.numIntersection = _clipping.numIntersection
        uniforms.clippingPlanes = _clipping.uniform
      }

      materialProperties.fog = fog

      // store the light setup it was created for

      materialProperties.lightsHash = lights.state.hash

      if (material.lights) {
        // wire up the material to this renderer's lighting state

        uniforms.ambientLightColor.value = lights.state.ambient
        uniforms.directionalLights.value = lights.state.directional
        uniforms.spotLights.value = lights.state.spot
        uniforms.rectAreaLights.value = lights.state.rectArea
        uniforms.pointLights.value = lights.state.point
        uniforms.hemisphereLights.value = lights.state.hemi

        uniforms.directionalShadowMap.value = lights.state.directionalShadowMap
        uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix
        uniforms.spotShadowMap.value = lights.state.spotShadowMap
        uniforms.spotShadowMatrix.value = lights.state.spotShadowMatrix
        uniforms.pointShadowMap.value = lights.state.pointShadowMap
        uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix
        // TODO (abelnation): add area lights shadow info to uniforms
      }

      var progUniforms = materialProperties.program.getUniforms(),
        uniformsList = WebGLUniforms.seqWithValue(progUniforms.seq, uniforms)

      materialProperties.uniformsList = uniformsList
    }

    function setProgram(camera, fog, material, object) {
      _usedTextureUnits = 0

      var materialProperties = properties.get(material)
      var lights = currentRenderState.state.lights

      if (_clippingEnabled) {
        if (_localClippingEnabled || camera !== _currentCamera) {
          var useCache = camera === _currentCamera && material.id === _currentMaterialId

          // we might want to call this function with some ClippingGroup
          // object instead of the material, once it becomes feasible
          // (#8465, #8379)
          _clipping.setState(
            material.clippingPlanes,
            material.clipIntersection,
            material.clipShadows,
            camera,
            materialProperties,
            useCache
          )
        }
      }

      if (material.needsUpdate === false) {
        if (materialProperties.program === undefined) {
          material.needsUpdate = true
        } else if (material.fog && materialProperties.fog !== fog) {
          material.needsUpdate = true
        } else if (material.lights && materialProperties.lightsHash !== lights.state.hash) {
          material.needsUpdate = true
        } else if (
          materialProperties.numClippingPlanes !== undefined &&
          (materialProperties.numClippingPlanes !== _clipping.numPlanes ||
            materialProperties.numIntersection !== _clipping.numIntersection)
        ) {
          material.needsUpdate = true
        }
      }

      if (material.needsUpdate) {
        initMaterial(material, fog, object)
        material.needsUpdate = false
      }

      var refreshProgram = false
      var refreshMaterial = false
      var refreshLights = false

      var program = materialProperties.program,
        p_uniforms = program.getUniforms(),
        m_uniforms = materialProperties.shader.uniforms

      if (state.useProgram(program.program)) {
        refreshProgram = true
        refreshMaterial = true
        refreshLights = true
      }

      if (material.id !== _currentMaterialId) {
        _currentMaterialId = material.id

        refreshMaterial = true
      }

      if (refreshProgram || camera !== _currentCamera) {
        p_uniforms.setValue(_gl, 'projectionMatrix', camera.projectionMatrix)

        if (capabilities.logarithmicDepthBuffer) {
          p_uniforms.setValue(_gl, 'logDepthBufFC', 2.0 / (Math.log(camera.far + 1.0) / Math.LN2))
        }

        // Avoid unneeded uniform updates per ArrayCamera's sub-camera

        if (_currentCamera !== (_currentArrayCamera || camera)) {
          _currentCamera = _currentArrayCamera || camera

          // lighting uniforms depend on the camera so enforce an update
          // now, in case this material supports lights - or later, when
          // the next material that does gets activated:

          refreshMaterial = true // set to true on material change
          refreshLights = true // remains set until update done
        }

        // load material specific uniforms
        // (shader material also gets them for the sake of genericity)

        if (
          material.isShaderMaterial ||
          material.isMeshPhongMaterial ||
          material.isMeshStandardMaterial ||
          material.envMap
        ) {
          var uCamPos = p_uniforms.map.cameraPosition

          if (uCamPos !== undefined) {
            uCamPos.setValue(_gl, _vector3.setFromMatrixPosition(camera.matrixWorld))
          }
        }

        if (
          material.isMeshPhongMaterial ||
          material.isMeshLambertMaterial ||
          material.isMeshBasicMaterial ||
          material.isMeshStandardMaterial ||
          material.isShaderMaterial ||
          material.skinning
        ) {
          p_uniforms.setValue(_gl, 'viewMatrix', camera.matrixWorldInverse)
        }
      }

      // skinning uniforms must be set even if material didn't change
      // auto-setting of texture unit for bone texture must go before other textures
      // not sure why, but otherwise weird things happen

      if (material.skinning) {
        p_uniforms.setOptional(_gl, object, 'bindMatrix')
        p_uniforms.setOptional(_gl, object, 'bindMatrixInverse')

        var skeleton = object.skeleton

        if (skeleton) {
          var bones = skeleton.bones

          if (capabilities.floatVertexTextures) {
            if (skeleton.boneTexture === undefined) {
              // layout (1 matrix = 4 pixels)
              //      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
              //  with  8x8  pixel texture max   16 bones * 4 pixels =  (8 * 8)
              //       16x16 pixel texture max   64 bones * 4 pixels = (16 * 16)
              //       32x32 pixel texture max  256 bones * 4 pixels = (32 * 32)
              //       64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)

              var size = Math.sqrt(bones.length * 4) // 4 pixels needed for 1 matrix
              size = _Math.ceilPowerOfTwo(size)
              size = Math.max(size, 4)

              var boneMatrices = new Float32Array(size * size * 4) // 4 floats per RGBA pixel
              boneMatrices.set(skeleton.boneMatrices) // copy current values

              var boneTexture = new DataTexture(boneMatrices, size, size, RGBAFormat, FloatType)
              boneTexture.needsUpdate = true

              skeleton.boneMatrices = boneMatrices
              skeleton.boneTexture = boneTexture
              skeleton.boneTextureSize = size
            }

            p_uniforms.setValue(_gl, 'boneTexture', skeleton.boneTexture)
            p_uniforms.setValue(_gl, 'boneTextureSize', skeleton.boneTextureSize)
          } else {
            p_uniforms.setOptional(_gl, skeleton, 'boneMatrices')
          }
        }
      }

      if (refreshMaterial) {
        p_uniforms.setValue(_gl, 'toneMappingExposure', _this.toneMappingExposure)
        p_uniforms.setValue(_gl, 'toneMappingWhitePoint', _this.toneMappingWhitePoint)

        if (material.lights) {
          // the current material requires lighting info

          // note: all lighting uniforms are always set correctly
          // they simply reference the renderer's state for their
          // values
          //
          // use the current material's .needsUpdate flags to set
          // the GL state when required

          markUniformsLightsNeedsUpdate(m_uniforms, refreshLights)
        }

        // refresh uniforms common to several materials

        if (fog && material.fog) {
          refreshUniformsFog(m_uniforms, fog)
        }

        if (material.isMeshBasicMaterial) {
          refreshUniformsCommon(m_uniforms, material)
        } else if (material.isMeshLambertMaterial) {
          refreshUniformsCommon(m_uniforms, material)
          refreshUniformsLambert(m_uniforms, material)
        } else if (material.isMeshPhongMaterial) {
          refreshUniformsCommon(m_uniforms, material)

          if (material.isMeshToonMaterial) {
            refreshUniformsToon(m_uniforms, material)
          } else {
            refreshUniformsPhong(m_uniforms, material)
          }
        } else if (material.isMeshStandardMaterial) {
          refreshUniformsCommon(m_uniforms, material)

          if (material.isMeshPhysicalMaterial) {
            refreshUniformsPhysical(m_uniforms, material)
          } else {
            refreshUniformsStandard(m_uniforms, material)
          }
        } else if (material.isMeshDepthMaterial) {
          refreshUniformsCommon(m_uniforms, material)
          refreshUniformsDepth(m_uniforms, material)
        } else if (material.isMeshDistanceMaterial) {
          refreshUniformsCommon(m_uniforms, material)
          refreshUniformsDistance(m_uniforms, material)
        } else if (material.isMeshNormalMaterial) {
          refreshUniformsCommon(m_uniforms, material)
          refreshUniformsNormal(m_uniforms, material)
        } else if (material.isLineBasicMaterial) {
          refreshUniformsLine(m_uniforms, material)

          if (material.isLineDashedMaterial) {
            refreshUniformsDash(m_uniforms, material)
          }
        } else if (material.isPointsMaterial) {
          refreshUniformsPoints(m_uniforms, material)
        } else if (material.isShadowMaterial) {
          m_uniforms.color.value = material.color
          m_uniforms.opacity.value = material.opacity
        }

        // RectAreaLight Texture
        // TODO (mrdoob): Find a nicer implementation

        if (m_uniforms.ltc_1 !== undefined) m_uniforms.ltc_1.value = UniformsLib.LTC_1
        if (m_uniforms.ltc_2 !== undefined) m_uniforms.ltc_2.value = UniformsLib.LTC_2

        WebGLUniforms.upload(_gl, materialProperties.uniformsList, m_uniforms, _this)
      }

      if (material.isShaderMaterial && material.uniformsNeedUpdate === true) {
        WebGLUniforms.upload(_gl, materialProperties.uniformsList, m_uniforms, _this)
        material.uniformsNeedUpdate = false
      }

      // common matrices

      p_uniforms.setValue(_gl, 'modelViewMatrix', object.modelViewMatrix)
      p_uniforms.setValue(_gl, 'normalMatrix', object.normalMatrix)
      p_uniforms.setValue(_gl, 'modelMatrix', object.matrixWorld)

      return program
    }

    // Uniforms (refresh uniforms objects)

    function refreshUniformsCommon(uniforms, material) {
      uniforms.opacity.value = material.opacity

      if (material.color) {
        uniforms.diffuse.value = material.color
      }

      if (material.emissive) {
        uniforms.emissive.value.copy(material.emissive).multiplyScalar(material.emissiveIntensity)
      }

      if (material.map) {
        uniforms.map.value = material.map
      }

      if (material.alphaMap) {
        uniforms.alphaMap.value = material.alphaMap
      }

      if (material.specularMap) {
        uniforms.specularMap.value = material.specularMap
      }

      if (material.envMap) {
        uniforms.envMap.value = material.envMap

        // don't flip CubeTexture envMaps, flip everything else:
        //  WebGLRenderTargetCube will be flipped for backwards compatibility
        //  WebGLRenderTargetCube.texture will be flipped because it's a Texture and NOT a CubeTexture
        // this check must be handled differently, or removed entirely, if WebGLRenderTargetCube uses a CubeTexture in the future
        uniforms.flipEnvMap.value = !(material.envMap && material.envMap.isCubeTexture) ? 1 : -1

        uniforms.reflectivity.value = material.reflectivity
        uniforms.refractionRatio.value = material.refractionRatio
      }

      if (material.lightMap) {
        uniforms.lightMap.value = material.lightMap
        uniforms.lightMapIntensity.value = material.lightMapIntensity
      }

      if (material.aoMap) {
        uniforms.aoMap.value = material.aoMap
        uniforms.aoMapIntensity.value = material.aoMapIntensity
      }

      // uv repeat and offset setting priorities
      // 1. color map
      // 2. specular map
      // 3. normal map
      // 4. bump map
      // 5. alpha map
      // 6. emissive map

      var uvScaleMap

      if (material.map) {
        uvScaleMap = material.map
      } else if (material.specularMap) {
        uvScaleMap = material.specularMap
      } else if (material.displacementMap) {
        uvScaleMap = material.displacementMap
      } else if (material.normalMap) {
        uvScaleMap = material.normalMap
      } else if (material.bumpMap) {
        uvScaleMap = material.bumpMap
      } else if (material.roughnessMap) {
        uvScaleMap = material.roughnessMap
      } else if (material.metalnessMap) {
        uvScaleMap = material.metalnessMap
      } else if (material.alphaMap) {
        uvScaleMap = material.alphaMap
      } else if (material.emissiveMap) {
        uvScaleMap = material.emissiveMap
      }

      if (uvScaleMap !== undefined) {
        // backwards compatibility
        if (uvScaleMap.isWebGLRenderTarget) {
          uvScaleMap = uvScaleMap.texture
        }

        if (uvScaleMap.matrixAutoUpdate === true) {
          var offset = uvScaleMap.offset
          var repeat = uvScaleMap.repeat
          var rotation = uvScaleMap.rotation
          var center = uvScaleMap.center

          uvScaleMap.matrix.setUvTransform(
            offset.x,
            offset.y,
            repeat.x,
            repeat.y,
            rotation,
            center.x,
            center.y
          )
        }

        uniforms.uvTransform.value.copy(uvScaleMap.matrix)
      }
    }

    function refreshUniformsLine(uniforms, material) {
      uniforms.diffuse.value = material.color
      uniforms.opacity.value = material.opacity
    }

    function refreshUniformsDash(uniforms, material) {
      uniforms.dashSize.value = material.dashSize
      uniforms.totalSize.value = material.dashSize + material.gapSize
      uniforms.scale.value = material.scale
    }

    function refreshUniformsPoints(uniforms, material) {
      uniforms.diffuse.value = material.color
      uniforms.opacity.value = material.opacity
      uniforms.size.value = material.size * _pixelRatio
      uniforms.scale.value = _height * 0.5

      uniforms.map.value = material.map

      if (material.map !== null) {
        if (material.map.matrixAutoUpdate === true) {
          var offset = material.map.offset
          var repeat = material.map.repeat
          var rotation = material.map.rotation
          var center = material.map.center

          material.map.matrix.setUvTransform(
            offset.x,
            offset.y,
            repeat.x,
            repeat.y,
            rotation,
            center.x,
            center.y
          )
        }

        uniforms.uvTransform.value.copy(material.map.matrix)
      }
    }

    function refreshUniformsFog(uniforms, fog) {
      uniforms.fogColor.value = fog.color

      if (fog.isFog) {
        uniforms.fogNear.value = fog.near
        uniforms.fogFar.value = fog.far
      } else if (fog.isFogExp2) {
        uniforms.fogDensity.value = fog.density
      }
    }

    function refreshUniformsLambert(uniforms, material) {
      if (material.emissiveMap) {
        uniforms.emissiveMap.value = material.emissiveMap
      }
    }

    function refreshUniformsPhong(uniforms, material) {
      uniforms.specular.value = material.specular
      uniforms.shininess.value = Math.max(material.shininess, 1e-4) // to prevent pow( 0.0, 0.0 )

      if (material.emissiveMap) {
        uniforms.emissiveMap.value = material.emissiveMap
      }

      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    function refreshUniformsToon(uniforms, material) {
      refreshUniformsPhong(uniforms, material)

      if (material.gradientMap) {
        uniforms.gradientMap.value = material.gradientMap
      }
    }

    function refreshUniformsStandard(uniforms, material) {
      uniforms.roughness.value = material.roughness
      uniforms.metalness.value = material.metalness

      if (material.roughnessMap) {
        uniforms.roughnessMap.value = material.roughnessMap
      }

      if (material.metalnessMap) {
        uniforms.metalnessMap.value = material.metalnessMap
      }

      if (material.emissiveMap) {
        uniforms.emissiveMap.value = material.emissiveMap
      }

      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }

      if (material.envMap) {
        //uniforms.envMap.value = material.envMap; // part of uniforms common
        uniforms.envMapIntensity.value = material.envMapIntensity
      }
    }

    function refreshUniformsPhysical(uniforms, material) {
      uniforms.clearCoat.value = material.clearCoat
      uniforms.clearCoatRoughness.value = material.clearCoatRoughness

      refreshUniformsStandard(uniforms, material)
    }

    function refreshUniformsDepth(uniforms, material) {
      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    function refreshUniformsDistance(uniforms, material) {
      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }

      uniforms.referencePosition.value.copy(material.referencePosition)
      uniforms.nearDistance.value = material.nearDistance
      uniforms.farDistance.value = material.farDistance
    }

    function refreshUniformsNormal(uniforms, material) {
      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    // If uniforms are marked as clean, they don't need to be loaded to the GPU.

    function markUniformsLightsNeedsUpdate(uniforms, value) {
      uniforms.ambientLightColor.needsUpdate = value

      uniforms.directionalLights.needsUpdate = value
      uniforms.pointLights.needsUpdate = value
      uniforms.spotLights.needsUpdate = value
      uniforms.rectAreaLights.needsUpdate = value
      uniforms.hemisphereLights.needsUpdate = value
    }

    // Textures

    function allocTextureUnit() {
      var textureUnit = _usedTextureUnits

      if (textureUnit >= capabilities.maxTextures) {
        console.warn(
          'THREE.WebGLRenderer: Trying to use ' +
            textureUnit +
            ' texture units while this GPU supports only ' +
            capabilities.maxTextures
        )
      }

      _usedTextureUnits += 1

      return textureUnit
    }

    this.allocTextureUnit = allocTextureUnit

    // this.setTexture2D = setTexture2D;
    this.setTexture2D = (function () {
      var warned = false

      // backwards compatibility: peel texture.texture
      return function setTexture2D(texture, slot) {
        if (texture && texture.isWebGLRenderTarget) {
          if (!warned) {
            console.warn(
              "THREE.WebGLRenderer.setTexture2D: don't use render targets as textures. Use their .texture property instead."
            )
            warned = true
          }

          texture = texture.texture
        }

        textures.setTexture2D(texture, slot)
      }
    })()

    this.setTexture = (function () {
      var warned = false

      return function setTexture(texture, slot) {
        if (!warned) {
          console.warn('THREE.WebGLRenderer: .setTexture is deprecated, use setTexture2D instead.')
          warned = true
        }

        textures.setTexture2D(texture, slot)
      }
    })()

    this.setTextureCube = (function () {
      var warned = false

      return function setTextureCube(texture, slot) {
        // backwards compatibility: peel texture.texture
        if (texture && texture.isWebGLRenderTargetCube) {
          if (!warned) {
            console.warn(
              "THREE.WebGLRenderer.setTextureCube: don't use cube render targets as textures. Use their .texture property instead."
            )
            warned = true
          }

          texture = texture.texture
        }

        // currently relying on the fact that WebGLRenderTargetCube.texture is a Texture and NOT a CubeTexture
        // TODO: unify these code paths
        if (
          (texture && texture.isCubeTexture) ||
          (Array.isArray(texture.image) && texture.image.length === 6)
        ) {
          // CompressedTexture can have Array in image :/

          // this function alone should take care of cube textures
          textures.setTextureCube(texture, slot)
        } else {
          // assumed: texture property of THREE.WebGLRenderTargetCube

          textures.setTextureCubeDynamic(texture, slot)
        }
      }
    })()

    this.getRenderTarget = function () {
      return _currentRenderTarget
    }

    this.setRenderTarget = function (renderTarget) {
      _currentRenderTarget = renderTarget

      if (renderTarget && properties.get(renderTarget).__webglFramebuffer === undefined) {
        textures.setupRenderTarget(renderTarget)
      }

      var framebuffer = null
      var isCube = false

      if (renderTarget) {
        var __webglFramebuffer = properties.get(renderTarget).__webglFramebuffer

        if (renderTarget.isWebGLRenderTargetCube) {
          framebuffer = __webglFramebuffer[renderTarget.activeCubeFace]
          isCube = true
        } else {
          framebuffer = __webglFramebuffer
        }

        _currentViewport.copy(renderTarget.viewport)
        _currentScissor.copy(renderTarget.scissor)
        _currentScissorTest = renderTarget.scissorTest
      } else {
        _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio)
        _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio)
        _currentScissorTest = _scissorTest
      }

      if (_currentFramebuffer !== framebuffer) {
        _gl.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer)
        _currentFramebuffer = framebuffer
      }

      state.viewport(_currentViewport)
      state.scissor(_currentScissor)
      state.setScissorTest(_currentScissorTest)

      if (isCube) {
        var textureProperties = properties.get(renderTarget.texture)
        _gl.framebufferTexture2D(
          _gl.FRAMEBUFFER,
          _gl.COLOR_ATTACHMENT0,
          _gl.TEXTURE_CUBE_MAP_POSITIVE_X + renderTarget.activeCubeFace,
          textureProperties.__webglTexture,
          renderTarget.activeMipMapLevel
        )
      }
    }

    this.readRenderTargetPixels = function (renderTarget, x, y, width, height, buffer) {
      if (!(renderTarget && renderTarget.isWebGLRenderTarget)) {
        console.error(
          'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.'
        )
        return
      }

      var framebuffer = properties.get(renderTarget).__webglFramebuffer

      if (framebuffer) {
        var restore = false

        if (framebuffer !== _currentFramebuffer) {
          _gl.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer)

          restore = true
        }

        try {
          var texture = renderTarget.texture
          var textureFormat = texture.format
          var textureType = texture.type

          if (
            textureFormat !== RGBAFormat &&
            utils.convert(textureFormat) !== _gl.getParameter(_gl.IMPLEMENTATION_COLOR_READ_FORMAT)
          ) {
            console.error(
              'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.'
            )
            return
          }

          if (
            textureType !== UnsignedByteType &&
            utils.convert(textureType) !== _gl.getParameter(_gl.IMPLEMENTATION_COLOR_READ_TYPE) && // IE11, Edge and Chrome Mac < 52 (#9513)
            !(
              textureType === FloatType &&
              (extensions.get('OES_texture_float') || extensions.get('WEBGL_color_buffer_float'))
            ) && // Chrome Mac >= 52 and Firefox
            !(textureType === HalfFloatType && extensions.get('EXT_color_buffer_half_float'))
          ) {
            console.error(
              'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.'
            )
            return
          }

          if (_gl.checkFramebufferStatus(_gl.FRAMEBUFFER) === _gl.FRAMEBUFFER_COMPLETE) {
            // the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)

            if (
              x >= 0 &&
              x <= renderTarget.width - width &&
              y >= 0 &&
              y <= renderTarget.height - height
            ) {
              _gl.readPixels(
                x,
                y,
                width,
                height,
                utils.convert(textureFormat),
                utils.convert(textureType),
                buffer
              )
            }
          } else {
            console.error(
              'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.'
            )
          }
        } finally {
          if (restore) {
            _gl.bindFramebuffer(_gl.FRAMEBUFFER, _currentFramebuffer)
          }
        }
      }
    }

    this.copyFramebufferToTexture = function (position, texture, level) {
      var width = texture.image.width
      var height = texture.image.height
      var internalFormat = utils.convert(texture.format)

      this.setTexture2D(texture, 0)

      _gl.copyTexImage2D(
        _gl.TEXTURE_2D,
        level || 0,
        internalFormat,
        position.x,
        position.y,
        width,
        height,
        0
      )
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   */

  function FogExp2(color, density) {
    this.name = ''

    this.color = new Color(color)
    this.density = density !== undefined ? density : 0.00025
  }

  FogExp2.prototype.isFogExp2 = true

  FogExp2.prototype.clone = function () {
    return new FogExp2(this.color.getHex(), this.density)
  }

  FogExp2.prototype.toJSON = function (/* meta */) {
    return {
      type: 'FogExp2',
      color: this.color.getHex(),
      density: this.density
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   */

  function Fog(color, near, far) {
    this.name = ''

    this.color = new Color(color)

    this.near = near !== undefined ? near : 1
    this.far = far !== undefined ? far : 1000
  }

  Fog.prototype.isFog = true

  Fog.prototype.clone = function () {
    return new Fog(this.color.getHex(), this.near, this.far)
  }

  Fog.prototype.toJSON = function (/* meta */) {
    return {
      type: 'Fog',
      color: this.color.getHex(),
      near: this.near,
      far: this.far
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function Scene() {
    Object3D.call(this)

    this.type = 'Scene'

    this.background = null
    this.fog = null
    this.overrideMaterial = null

    this.autoUpdate = true // checked by the renderer
  }

  Scene.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Scene,

    copy: function (source, recursive) {
      Object3D.prototype.copy.call(this, source, recursive)

      if (source.background !== null) this.background = source.background.clone()
      if (source.fog !== null) this.fog = source.fog.clone()
      if (source.overrideMaterial !== null) this.overrideMaterial = source.overrideMaterial.clone()

      this.autoUpdate = source.autoUpdate
      this.matrixAutoUpdate = source.matrixAutoUpdate

      return this
    },

    toJSON: function (meta) {
      var data = Object3D.prototype.toJSON.call(this, meta)

      if (this.background !== null) data.object.background = this.background.toJSON(meta)
      if (this.fog !== null) data.object.fog = this.fog.toJSON()

      return data
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  color: <hex>,
   *  opacity: <float>,
   *  map: new THREE.Texture( <Image> ),
   *
   *	uvOffset: new THREE.Vector2(),
   *	uvScale: new THREE.Vector2()
   * }
   */

  function SpriteMaterial(parameters) {
    Material.call(this)

    this.type = 'SpriteMaterial'

    this.color = new Color(0xffffff)
    this.map = null

    this.rotation = 0

    this.fog = false
    this.lights = false

    this.setValues(parameters)
  }

  SpriteMaterial.prototype = Object.create(Material.prototype)
  SpriteMaterial.prototype.constructor = SpriteMaterial
  SpriteMaterial.prototype.isSpriteMaterial = true

  SpriteMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.color.copy(source.color)
    this.map = source.map

    this.rotation = source.rotation

    return this
  }

  /**
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   */

  function Sprite(material) {
    Object3D.call(this)

    this.type = 'Sprite'

    this.material = material !== undefined ? material : new SpriteMaterial()

    this.center = new Vector2(0.5, 0.5)
  }

  Sprite.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Sprite,

    isSprite: true,

    raycast: (function () {
      var intersectPoint = new Vector3()
      var worldPosition = new Vector3()
      var worldScale = new Vector3()

      return function raycast(raycaster, intersects) {
        worldPosition.setFromMatrixPosition(this.matrixWorld)
        raycaster.ray.closestPointToPoint(worldPosition, intersectPoint)

        worldScale.setFromMatrixScale(this.matrixWorld)
        var guessSizeSq = (worldScale.x * worldScale.y) / 4

        if (worldPosition.distanceToSquared(intersectPoint) > guessSizeSq) return

        var distance = raycaster.ray.origin.distanceTo(intersectPoint)

        if (distance < raycaster.near || distance > raycaster.far) return

        intersects.push({
          distance: distance,
          point: intersectPoint.clone(),
          face: null,
          object: this
        })
      }
    })(),

    clone: function () {
      return new this.constructor(this.material).copy(this)
    },

    copy: function (source) {
      Object3D.prototype.copy.call(this, source)

      if (source.center !== undefined) this.center.copy(source.center)

      return this
    }
  })

  /**
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   */

  function LOD() {
    Object3D.call(this)

    this.type = 'LOD'

    Object.defineProperties(this, {
      levels: {
        enumerable: true,
        value: []
      }
    })
  }

  LOD.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: LOD,

    copy: function (source) {
      Object3D.prototype.copy.call(this, source, false)

      var levels = source.levels

      for (var i = 0, l = levels.length; i < l; i++) {
        var level = levels[i]

        this.addLevel(level.object.clone(), level.distance)
      }

      return this
    },

    addLevel: function (object, distance) {
      if (distance === undefined) distance = 0

      distance = Math.abs(distance)

      var levels = this.levels

      for (var l = 0; l < levels.length; l++) {
        if (distance < levels[l].distance) {
          break
        }
      }

      levels.splice(l, 0, { distance: distance, object: object })

      this.add(object)
    },

    getObjectForDistance: function (distance) {
      var levels = this.levels

      for (var i = 1, l = levels.length; i < l; i++) {
        if (distance < levels[i].distance) {
          break
        }
      }

      return levels[i - 1].object
    },

    raycast: (function () {
      var matrixPosition = new Vector3()

      return function raycast(raycaster, intersects) {
        matrixPosition.setFromMatrixPosition(this.matrixWorld)

        var distance = raycaster.ray.origin.distanceTo(matrixPosition)

        this.getObjectForDistance(distance).raycast(raycaster, intersects)
      }
    })(),

    update: (function () {
      var v1 = new Vector3()
      var v2 = new Vector3()

      return function update(camera) {
        var levels = this.levels

        if (levels.length > 1) {
          v1.setFromMatrixPosition(camera.matrixWorld)
          v2.setFromMatrixPosition(this.matrixWorld)

          var distance = v1.distanceTo(v2)

          levels[0].object.visible = true

          for (var i = 1, l = levels.length; i < l; i++) {
            if (distance >= levels[i].distance) {
              levels[i - 1].object.visible = false
              levels[i].object.visible = true
            } else {
              break
            }
          }

          for (; i < l; i++) {
            levels[i].object.visible = false
          }
        }
      }
    })(),

    toJSON: function (meta) {
      var data = Object3D.prototype.toJSON.call(this, meta)

      data.object.levels = []

      var levels = this.levels

      for (var i = 0, l = levels.length; i < l; i++) {
        var level = levels[i]

        data.object.levels.push({
          object: level.object.uuid,
          distance: level.distance
        })
      }

      return data
    }
  })

  /**
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   * @author michael guerrero / http://realitymeltdown.com
   * @author ikerr / http://verold.com
   */

  function Skeleton(bones, boneInverses) {
    // copy the bone array

    bones = bones || []

    this.bones = bones.slice(0)
    this.boneMatrices = new Float32Array(this.bones.length * 16)

    // use the supplied bone inverses or calculate the inverses

    if (boneInverses === undefined) {
      this.calculateInverses()
    } else {
      if (this.bones.length === boneInverses.length) {
        this.boneInverses = boneInverses.slice(0)
      } else {
        console.warn('THREE.Skeleton boneInverses is the wrong length.')

        this.boneInverses = []

        for (var i = 0, il = this.bones.length; i < il; i++) {
          this.boneInverses.push(new Matrix4())
        }
      }
    }
  }

  Object.assign(Skeleton.prototype, {
    calculateInverses: function () {
      this.boneInverses = []

      for (var i = 0, il = this.bones.length; i < il; i++) {
        var inverse = new Matrix4()

        if (this.bones[i]) {
          inverse.getInverse(this.bones[i].matrixWorld)
        }

        this.boneInverses.push(inverse)
      }
    },

    pose: function () {
      var bone, i, il

      // recover the bind-time world matrices

      for (i = 0, il = this.bones.length; i < il; i++) {
        bone = this.bones[i]

        if (bone) {
          bone.matrixWorld.getInverse(this.boneInverses[i])
        }
      }

      // compute the local matrices, positions, rotations and scales

      for (i = 0, il = this.bones.length; i < il; i++) {
        bone = this.bones[i]

        if (bone) {
          if (bone.parent && bone.parent.isBone) {
            bone.matrix.getInverse(bone.parent.matrixWorld)
            bone.matrix.multiply(bone.matrixWorld)
          } else {
            bone.matrix.copy(bone.matrixWorld)
          }

          bone.matrix.decompose(bone.position, bone.quaternion, bone.scale)
        }
      }
    },

    update: (function () {
      var offsetMatrix = new Matrix4()
      var identityMatrix = new Matrix4()

      return function update() {
        var bones = this.bones
        var boneInverses = this.boneInverses
        var boneMatrices = this.boneMatrices
        var boneTexture = this.boneTexture

        // flatten bone matrices to array

        for (var i = 0, il = bones.length; i < il; i++) {
          // compute the offset between the current and the original transform

          var matrix = bones[i] ? bones[i].matrixWorld : identityMatrix

          offsetMatrix.multiplyMatrices(matrix, boneInverses[i])
          offsetMatrix.toArray(boneMatrices, i * 16)
        }

        if (boneTexture !== undefined) {
          boneTexture.needsUpdate = true
        }
      }
    })(),

    clone: function () {
      return new Skeleton(this.bones, this.boneInverses)
    },

    getBoneByName: function (name) {
      for (var i = 0, il = this.bones.length; i < il; i++) {
        var bone = this.bones[i]

        if (bone.name === name) {
          return bone
        }
      }

      return undefined
    }
  })

  /**
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   * @author ikerr / http://verold.com
   */

  function Bone() {
    Object3D.call(this)

    this.type = 'Bone'
  }

  Bone.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Bone,

    isBone: true
  })

  /**
   * @author mikael emtinger / http://gomo.se/
   * @author alteredq / http://alteredqualia.com/
   * @author ikerr / http://verold.com
   */

  function SkinnedMesh(geometry, material) {
    Mesh.call(this, geometry, material)

    this.type = 'SkinnedMesh'

    this.bindMode = 'attached'
    this.bindMatrix = new Matrix4()
    this.bindMatrixInverse = new Matrix4()

    var bones = this.initBones()
    var skeleton = new Skeleton(bones)

    this.bind(skeleton, this.matrixWorld)

    this.normalizeSkinWeights()
  }

  SkinnedMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
    constructor: SkinnedMesh,

    isSkinnedMesh: true,

    initBones: function () {
      var bones = [],
        bone,
        gbone
      var i, il

      if (this.geometry && this.geometry.bones !== undefined) {
        // first, create array of 'Bone' objects from geometry data

        for (i = 0, il = this.geometry.bones.length; i < il; i++) {
          gbone = this.geometry.bones[i]

          // create new 'Bone' object

          bone = new Bone()
          bones.push(bone)

          // apply values

          bone.name = gbone.name
          bone.position.fromArray(gbone.pos)
          bone.quaternion.fromArray(gbone.rotq)
          if (gbone.scl !== undefined) bone.scale.fromArray(gbone.scl)
        }

        // second, create bone hierarchy

        for (i = 0, il = this.geometry.bones.length; i < il; i++) {
          gbone = this.geometry.bones[i]

          if (gbone.parent !== -1 && gbone.parent !== null && bones[gbone.parent] !== undefined) {
            // subsequent bones in the hierarchy

            bones[gbone.parent].add(bones[i])
          } else {
            // topmost bone, immediate child of the skinned mesh

            this.add(bones[i])
          }
        }
      }

      // now the bones are part of the scene graph and children of the skinned mesh.
      // let's update the corresponding matrices

      this.updateMatrixWorld(true)

      return bones
    },

    bind: function (skeleton, bindMatrix) {
      this.skeleton = skeleton

      if (bindMatrix === undefined) {
        this.updateMatrixWorld(true)

        this.skeleton.calculateInverses()

        bindMatrix = this.matrixWorld
      }

      this.bindMatrix.copy(bindMatrix)
      this.bindMatrixInverse.getInverse(bindMatrix)
    },

    pose: function () {
      this.skeleton.pose()
    },

    normalizeSkinWeights: function () {
      var scale, i

      if (this.geometry && this.geometry.isGeometry) {
        for (i = 0; i < this.geometry.skinWeights.length; i++) {
          var sw = this.geometry.skinWeights[i]

          scale = 1.0 / sw.manhattanLength()

          if (scale !== Infinity) {
            sw.multiplyScalar(scale)
          } else {
            sw.set(1, 0, 0, 0) // do something reasonable
          }
        }
      } else if (this.geometry && this.geometry.isBufferGeometry) {
        var vec = new Vector4()

        var skinWeight = this.geometry.attributes.skinWeight

        for (i = 0; i < skinWeight.count; i++) {
          vec.x = skinWeight.getX(i)
          vec.y = skinWeight.getY(i)
          vec.z = skinWeight.getZ(i)
          vec.w = skinWeight.getW(i)

          scale = 1.0 / vec.manhattanLength()

          if (scale !== Infinity) {
            vec.multiplyScalar(scale)
          } else {
            vec.set(1, 0, 0, 0) // do something reasonable
          }

          skinWeight.setXYZW(i, vec.x, vec.y, vec.z, vec.w)
        }
      }
    },

    updateMatrixWorld: function (force) {
      Mesh.prototype.updateMatrixWorld.call(this, force)

      if (this.bindMode === 'attached') {
        this.bindMatrixInverse.getInverse(this.matrixWorld)
      } else if (this.bindMode === 'detached') {
        this.bindMatrixInverse.getInverse(this.bindMatrix)
      } else {
        console.warn('THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode)
      }
    },

    clone: function () {
      return new this.constructor(this.geometry, this.material).copy(this)
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  color: <hex>,
   *  opacity: <float>,
   *
   *  linewidth: <float>,
   *  linecap: "round",
   *  linejoin: "round"
   * }
   */

  function LineBasicMaterial(parameters) {
    Material.call(this)

    this.type = 'LineBasicMaterial'

    this.color = new Color(0xffffff)

    this.linewidth = 1
    this.linecap = 'round'
    this.linejoin = 'round'

    this.lights = false

    this.setValues(parameters)
  }

  LineBasicMaterial.prototype = Object.create(Material.prototype)
  LineBasicMaterial.prototype.constructor = LineBasicMaterial

  LineBasicMaterial.prototype.isLineBasicMaterial = true

  LineBasicMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.color.copy(source.color)

    this.linewidth = source.linewidth
    this.linecap = source.linecap
    this.linejoin = source.linejoin

    return this
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function Line(geometry, material, mode) {
    if (mode === 1) {
      console.warn(
        'THREE.Line: parameter THREE.LinePieces no longer supported. Created THREE.LineSegments instead.'
      )
      return new LineSegments(geometry, material)
    }

    Object3D.call(this)

    this.type = 'Line'

    this.geometry = geometry !== undefined ? geometry : new BufferGeometry()
    this.material =
      material !== undefined ? material : new LineBasicMaterial({ color: Math.random() * 0xffffff })
  }

  Line.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Line,

    isLine: true,

    computeLineDistances: (function () {
      var start = new Vector3()
      var end = new Vector3()

      return function computeLineDistances() {
        var geometry = this.geometry

        if (geometry.isBufferGeometry) {
          // we assume non-indexed geometry

          if (geometry.index === null) {
            var positionAttribute = geometry.attributes.position
            var lineDistances = [0]

            for (var i = 1, l = positionAttribute.count; i < l; i++) {
              start.fromBufferAttribute(positionAttribute, i - 1)
              end.fromBufferAttribute(positionAttribute, i)

              lineDistances[i] = lineDistances[i - 1]
              lineDistances[i] += start.distanceTo(end)
            }

            geometry.addAttribute(
              'lineDistance',
              new THREE.Float32BufferAttribute(lineDistances, 1)
            )
          } else {
            console.warn(
              'THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.'
            )
          }
        } else if (geometry.isGeometry) {
          var vertices = geometry.vertices
          var lineDistances = geometry.lineDistances

          lineDistances[0] = 0

          for (var i = 1, l = vertices.length; i < l; i++) {
            lineDistances[i] = lineDistances[i - 1]
            lineDistances[i] += vertices[i - 1].distanceTo(vertices[i])
          }
        }

        return this
      }
    })(),

    raycast: (function () {
      var inverseMatrix = new Matrix4()
      var ray = new Ray()
      var sphere = new Sphere()

      return function raycast(raycaster, intersects) {
        var precision = raycaster.linePrecision
        var precisionSq = precision * precision

        var geometry = this.geometry
        var matrixWorld = this.matrixWorld

        // Checking boundingSphere distance to ray

        if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

        sphere.copy(geometry.boundingSphere)
        sphere.applyMatrix4(matrixWorld)

        if (raycaster.ray.intersectsSphere(sphere) === false) return

        //

        inverseMatrix.getInverse(matrixWorld)
        ray.copy(raycaster.ray).applyMatrix4(inverseMatrix)

        var vStart = new Vector3()
        var vEnd = new Vector3()
        var interSegment = new Vector3()
        var interRay = new Vector3()
        var step = this && this.isLineSegments ? 2 : 1

        if (geometry.isBufferGeometry) {
          var index = geometry.index
          var attributes = geometry.attributes
          var positions = attributes.position.array

          if (index !== null) {
            var indices = index.array

            for (var i = 0, l = indices.length - 1; i < l; i += step) {
              var a = indices[i]
              var b = indices[i + 1]

              vStart.fromArray(positions, a * 3)
              vEnd.fromArray(positions, b * 3)

              var distSq = ray.distanceSqToSegment(vStart, vEnd, interRay, interSegment)

              if (distSq > precisionSq) continue

              interRay.applyMatrix4(this.matrixWorld) //Move back to world space for distance calculation

              var distance = raycaster.ray.origin.distanceTo(interRay)

              if (distance < raycaster.near || distance > raycaster.far) continue

              intersects.push({
                distance: distance,
                // What do we want? intersection point on the ray or on the segment??
                // point: raycaster.ray.at( distance ),
                point: interSegment.clone().applyMatrix4(this.matrixWorld),
                index: i,
                face: null,
                faceIndex: null,
                object: this
              })
            }
          } else {
            for (var i = 0, l = positions.length / 3 - 1; i < l; i += step) {
              vStart.fromArray(positions, 3 * i)
              vEnd.fromArray(positions, 3 * i + 3)

              var distSq = ray.distanceSqToSegment(vStart, vEnd, interRay, interSegment)

              if (distSq > precisionSq) continue

              interRay.applyMatrix4(this.matrixWorld) //Move back to world space for distance calculation

              var distance = raycaster.ray.origin.distanceTo(interRay)

              if (distance < raycaster.near || distance > raycaster.far) continue

              intersects.push({
                distance: distance,
                // What do we want? intersection point on the ray or on the segment??
                // point: raycaster.ray.at( distance ),
                point: interSegment.clone().applyMatrix4(this.matrixWorld),
                index: i,
                face: null,
                faceIndex: null,
                object: this
              })
            }
          }
        } else if (geometry.isGeometry) {
          var vertices = geometry.vertices
          var nbVertices = vertices.length

          for (var i = 0; i < nbVertices - 1; i += step) {
            var distSq = ray.distanceSqToSegment(
              vertices[i],
              vertices[i + 1],
              interRay,
              interSegment
            )

            if (distSq > precisionSq) continue

            interRay.applyMatrix4(this.matrixWorld) //Move back to world space for distance calculation

            var distance = raycaster.ray.origin.distanceTo(interRay)

            if (distance < raycaster.near || distance > raycaster.far) continue

            intersects.push({
              distance: distance,
              // What do we want? intersection point on the ray or on the segment??
              // point: raycaster.ray.at( distance ),
              point: interSegment.clone().applyMatrix4(this.matrixWorld),
              index: i,
              face: null,
              faceIndex: null,
              object: this
            })
          }
        }
      }
    })(),

    clone: function () {
      return new this.constructor(this.geometry, this.material).copy(this)
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function LineSegments(geometry, material) {
    Line.call(this, geometry, material)

    this.type = 'LineSegments'
  }

  LineSegments.prototype = Object.assign(Object.create(Line.prototype), {
    constructor: LineSegments,

    isLineSegments: true,

    computeLineDistances: (function () {
      var start = new Vector3()
      var end = new Vector3()

      return function computeLineDistances() {
        var geometry = this.geometry

        if (geometry.isBufferGeometry) {
          // we assume non-indexed geometry

          if (geometry.index === null) {
            var positionAttribute = geometry.attributes.position
            var lineDistances = []

            for (var i = 0, l = positionAttribute.count; i < l; i += 2) {
              start.fromBufferAttribute(positionAttribute, i)
              end.fromBufferAttribute(positionAttribute, i + 1)

              lineDistances[i] = i === 0 ? 0 : lineDistances[i - 1]
              lineDistances[i + 1] = lineDistances[i] + start.distanceTo(end)
            }

            geometry.addAttribute(
              'lineDistance',
              new THREE.Float32BufferAttribute(lineDistances, 1)
            )
          } else {
            console.warn(
              'THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.'
            )
          }
        } else if (geometry.isGeometry) {
          var vertices = geometry.vertices
          var lineDistances = geometry.lineDistances

          for (var i = 0, l = vertices.length; i < l; i += 2) {
            start.copy(vertices[i])
            end.copy(vertices[i + 1])

            lineDistances[i] = i === 0 ? 0 : lineDistances[i - 1]
            lineDistances[i + 1] = lineDistances[i] + start.distanceTo(end)
          }
        }

        return this
      }
    })()
  })

  /**
   * @author mgreter / http://github.com/mgreter
   */

  function LineLoop(geometry, material) {
    Line.call(this, geometry, material)

    this.type = 'LineLoop'
  }

  LineLoop.prototype = Object.assign(Object.create(Line.prototype), {
    constructor: LineLoop,

    isLineLoop: true
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  color: <hex>,
   *  opacity: <float>,
   *  map: new THREE.Texture( <Image> ),
   *
   *  size: <float>,
   *  sizeAttenuation: <bool>
   * }
   */

  function PointsMaterial(parameters) {
    Material.call(this)

    this.type = 'PointsMaterial'

    this.color = new Color(0xffffff)

    this.map = null

    this.size = 1
    this.sizeAttenuation = true

    this.lights = false

    this.setValues(parameters)
  }

  PointsMaterial.prototype = Object.create(Material.prototype)
  PointsMaterial.prototype.constructor = PointsMaterial

  PointsMaterial.prototype.isPointsMaterial = true

  PointsMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.color.copy(source.color)

    this.map = source.map

    this.size = source.size
    this.sizeAttenuation = source.sizeAttenuation

    return this
  }

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function Points(geometry, material) {
    Object3D.call(this)

    this.type = 'Points'

    this.geometry = geometry !== undefined ? geometry : new BufferGeometry()
    this.material =
      material !== undefined ? material : new PointsMaterial({ color: Math.random() * 0xffffff })
  }

  Points.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Points,

    isPoints: true,

    raycast: (function () {
      var inverseMatrix = new Matrix4()
      var ray = new Ray()
      var sphere = new Sphere()

      return function raycast(raycaster, intersects) {
        var object = this
        var geometry = this.geometry
        var matrixWorld = this.matrixWorld
        var threshold = raycaster.params.Points.threshold

        // Checking boundingSphere distance to ray

        if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

        sphere.copy(geometry.boundingSphere)
        sphere.applyMatrix4(matrixWorld)
        sphere.radius += threshold

        if (raycaster.ray.intersectsSphere(sphere) === false) return

        //

        inverseMatrix.getInverse(matrixWorld)
        ray.copy(raycaster.ray).applyMatrix4(inverseMatrix)

        var localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3)
        var localThresholdSq = localThreshold * localThreshold
        var position = new Vector3()

        function testPoint(point, index) {
          var rayPointDistanceSq = ray.distanceSqToPoint(point)

          if (rayPointDistanceSq < localThresholdSq) {
            var intersectPoint = ray.closestPointToPoint(point)
            intersectPoint.applyMatrix4(matrixWorld)

            var distance = raycaster.ray.origin.distanceTo(intersectPoint)

            if (distance < raycaster.near || distance > raycaster.far) return

            intersects.push({
              distance: distance,
              distanceToRay: Math.sqrt(rayPointDistanceSq),
              point: intersectPoint.clone(),
              index: index,
              face: null,
              object: object
            })
          }
        }

        if (geometry.isBufferGeometry) {
          var index = geometry.index
          var attributes = geometry.attributes
          var positions = attributes.position.array

          if (index !== null) {
            var indices = index.array

            for (var i = 0, il = indices.length; i < il; i++) {
              var a = indices[i]

              position.fromArray(positions, a * 3)

              testPoint(position, a)
            }
          } else {
            for (var i = 0, l = positions.length / 3; i < l; i++) {
              position.fromArray(positions, i * 3)

              testPoint(position, i)
            }
          }
        } else {
          var vertices = geometry.vertices

          for (var i = 0, l = vertices.length; i < l; i++) {
            testPoint(vertices[i], i)
          }
        }
      }
    })(),

    clone: function () {
      return new this.constructor(this.geometry, this.material).copy(this)
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function Group() {
    Object3D.call(this)

    this.type = 'Group'
  }

  Group.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Group,

    isGroup: true
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function VideoTexture(
    video,
    mapping,
    wrapS,
    wrapT,
    magFilter,
    minFilter,
    format,
    type,
    anisotropy
  ) {
    Texture.call(this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy)

    this.generateMipmaps = false
  }

  VideoTexture.prototype = Object.assign(Object.create(Texture.prototype), {
    constructor: VideoTexture,

    isVideoTexture: true,

    update: function () {
      var video = this.image

      if (video.readyState >= video.HAVE_CURRENT_DATA) {
        this.needsUpdate = true
      }
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function CompressedTexture(
    mipmaps,
    width,
    height,
    format,
    type,
    mapping,
    wrapS,
    wrapT,
    magFilter,
    minFilter,
    anisotropy,
    encoding
  ) {
    Texture.call(
      this,
      null,
      mapping,
      wrapS,
      wrapT,
      magFilter,
      minFilter,
      format,
      type,
      anisotropy,
      encoding
    )

    this.image = { width: width, height: height }
    this.mipmaps = mipmaps

    // no flipping for cube textures
    // (also flipping doesn't work for compressed textures )

    this.flipY = false

    // can't generate mipmaps for compressed textures
    // mips must be embedded in DDS files

    this.generateMipmaps = false
  }

  CompressedTexture.prototype = Object.create(Texture.prototype)
  CompressedTexture.prototype.constructor = CompressedTexture

  CompressedTexture.prototype.isCompressedTexture = true

  /**
   * @author Matt DesLauriers / @mattdesl
   * @author atix / arthursilber.de
   */

  function DepthTexture(
    width,
    height,
    type,
    mapping,
    wrapS,
    wrapT,
    magFilter,
    minFilter,
    anisotropy,
    format
  ) {
    format = format !== undefined ? format : DepthFormat

    if (format !== DepthFormat && format !== DepthStencilFormat) {
      throw new Error(
        'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat'
      )
    }

    if (type === undefined && format === DepthFormat) type = UnsignedShortType
    if (type === undefined && format === DepthStencilFormat) type = UnsignedInt248Type

    Texture.call(this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy)

    this.image = { width: width, height: height }

    this.magFilter = magFilter !== undefined ? magFilter : NearestFilter
    this.minFilter = minFilter !== undefined ? minFilter : NearestFilter

    this.flipY = false
    this.generateMipmaps = false
  }

  DepthTexture.prototype = Object.create(Texture.prototype)
  DepthTexture.prototype.constructor = DepthTexture
  DepthTexture.prototype.isDepthTexture = true

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / https://github.com/Mugen87
   */

  function WireframeGeometry(geometry) {
    BufferGeometry.call(this)

    this.type = 'WireframeGeometry'

    // buffer

    var vertices = []

    // helper variables

    var i, j, l, o, ol
    var edge = [0, 0],
      edges = {},
      e,
      edge1,
      edge2
    var key,
      keys = ['a', 'b', 'c']
    var vertex

    // different logic for Geometry and BufferGeometry

    if (geometry && geometry.isGeometry) {
      // create a data structure that contains all edges without duplicates

      var faces = geometry.faces

      for (i = 0, l = faces.length; i < l; i++) {
        var face = faces[i]

        for (j = 0; j < 3; j++) {
          edge1 = face[keys[j]]
          edge2 = face[keys[(j + 1) % 3]]
          edge[0] = Math.min(edge1, edge2) // sorting prevents duplicates
          edge[1] = Math.max(edge1, edge2)

          key = edge[0] + ',' + edge[1]

          if (edges[key] === undefined) {
            edges[key] = { index1: edge[0], index2: edge[1] }
          }
        }
      }

      // generate vertices

      for (key in edges) {
        e = edges[key]

        vertex = geometry.vertices[e.index1]
        vertices.push(vertex.x, vertex.y, vertex.z)

        vertex = geometry.vertices[e.index2]
        vertices.push(vertex.x, vertex.y, vertex.z)
      }
    } else if (geometry && geometry.isBufferGeometry) {
      var position, indices, groups
      var group, start, count
      var index1, index2

      vertex = new Vector3()

      if (geometry.index !== null) {
        // indexed BufferGeometry

        position = geometry.attributes.position
        indices = geometry.index
        groups = geometry.groups

        if (groups.length === 0) {
          groups = [{ start: 0, count: indices.count, materialIndex: 0 }]
        }

        // create a data structure that contains all eges without duplicates

        for (o = 0, ol = groups.length; o < ol; ++o) {
          group = groups[o]

          start = group.start
          count = group.count

          for (i = start, l = start + count; i < l; i += 3) {
            for (j = 0; j < 3; j++) {
              edge1 = indices.getX(i + j)
              edge2 = indices.getX(i + ((j + 1) % 3))
              edge[0] = Math.min(edge1, edge2) // sorting prevents duplicates
              edge[1] = Math.max(edge1, edge2)

              key = edge[0] + ',' + edge[1]

              if (edges[key] === undefined) {
                edges[key] = { index1: edge[0], index2: edge[1] }
              }
            }
          }
        }

        // generate vertices

        for (key in edges) {
          e = edges[key]

          vertex.fromBufferAttribute(position, e.index1)
          vertices.push(vertex.x, vertex.y, vertex.z)

          vertex.fromBufferAttribute(position, e.index2)
          vertices.push(vertex.x, vertex.y, vertex.z)
        }
      } else {
        // non-indexed BufferGeometry

        position = geometry.attributes.position

        for (i = 0, l = position.count / 3; i < l; i++) {
          for (j = 0; j < 3; j++) {
            // three edges per triangle, an edge is represented as (index1, index2)
            // e.g. the first triangle has the following edges: (0,1),(1,2),(2,0)

            index1 = 3 * i + j
            vertex.fromBufferAttribute(position, index1)
            vertices.push(vertex.x, vertex.y, vertex.z)

            index2 = 3 * i + ((j + 1) % 3)
            vertex.fromBufferAttribute(position, index2)
            vertices.push(vertex.x, vertex.y, vertex.z)
          }
        }
      }
    }

    // build geometry

    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
  }

  WireframeGeometry.prototype = Object.create(BufferGeometry.prototype)
  WireframeGeometry.prototype.constructor = WireframeGeometry

  /**
   * @author zz85 / https://github.com/zz85
   * @author Mugen87 / https://github.com/Mugen87
   *
   * Parametric Surfaces Geometry
   * based on the brilliant article by @prideout http://prideout.net/blog/?p=44
   */

  // ParametricGeometry

  function ParametricGeometry(func, slices, stacks) {
    Geometry.call(this)

    this.type = 'ParametricGeometry'

    this.parameters = {
      func: func,
      slices: slices,
      stacks: stacks
    }

    this.fromBufferGeometry(new ParametricBufferGeometry(func, slices, stacks))
    this.mergeVertices()
  }

  ParametricGeometry.prototype = Object.create(Geometry.prototype)
  ParametricGeometry.prototype.constructor = ParametricGeometry

  // ParametricBufferGeometry

  function ParametricBufferGeometry(func, slices, stacks) {
    BufferGeometry.call(this)

    this.type = 'ParametricBufferGeometry'

    this.parameters = {
      func: func,
      slices: slices,
      stacks: stacks
    }

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    var EPS = 0.00001

    var normal = new Vector3()

    var p0 = new Vector3(),
      p1 = new Vector3()
    var pu = new Vector3(),
      pv = new Vector3()

    var i, j

    // generate vertices, normals and uvs

    var sliceCount = slices + 1

    for (i = 0; i <= stacks; i++) {
      var v = i / stacks

      for (j = 0; j <= slices; j++) {
        var u = j / slices

        // vertex

        p0 = func(u, v, p0)
        vertices.push(p0.x, p0.y, p0.z)

        // normal

        // approximate tangent vectors via finite differences

        if (u - EPS >= 0) {
          p1 = func(u - EPS, v, p1)
          pu.subVectors(p0, p1)
        } else {
          p1 = func(u + EPS, v, p1)
          pu.subVectors(p1, p0)
        }

        if (v - EPS >= 0) {
          p1 = func(u, v - EPS, p1)
          pv.subVectors(p0, p1)
        } else {
          p1 = func(u, v + EPS, p1)
          pv.subVectors(p1, p0)
        }

        // cross product of tangent vectors returns surface normal

        normal.crossVectors(pu, pv).normalize()
        normals.push(normal.x, normal.y, normal.z)

        // uv

        uvs.push(u, v)
      }
    }

    // generate indices

    for (i = 0; i < stacks; i++) {
      for (j = 0; j < slices; j++) {
        var a = i * sliceCount + j
        var b = i * sliceCount + j + 1
        var c = (i + 1) * sliceCount + j + 1
        var d = (i + 1) * sliceCount + j

        // faces one and two

        indices.push(a, b, d)
        indices.push(b, c, d)
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))
  }

  ParametricBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  ParametricBufferGeometry.prototype.constructor = ParametricBufferGeometry

  /**
   * @author clockworkgeek / https://github.com/clockworkgeek
   * @author timothypratley / https://github.com/timothypratley
   * @author WestLangley / http://github.com/WestLangley
   * @author Mugen87 / https://github.com/Mugen87
   */

  // PolyhedronGeometry

  function PolyhedronGeometry(vertices, indices, radius, detail) {
    Geometry.call(this)

    this.type = 'PolyhedronGeometry'

    this.parameters = {
      vertices: vertices,
      indices: indices,
      radius: radius,
      detail: detail
    }

    this.fromBufferGeometry(new PolyhedronBufferGeometry(vertices, indices, radius, detail))
    this.mergeVertices()
  }

  PolyhedronGeometry.prototype = Object.create(Geometry.prototype)
  PolyhedronGeometry.prototype.constructor = PolyhedronGeometry

  // PolyhedronBufferGeometry

  function PolyhedronBufferGeometry(vertices, indices, radius, detail) {
    BufferGeometry.call(this)

    this.type = 'PolyhedronBufferGeometry'

    this.parameters = {
      vertices: vertices,
      indices: indices,
      radius: radius,
      detail: detail
    }

    radius = radius || 1
    detail = detail || 0

    // default buffer data

    var vertexBuffer = []
    var uvBuffer = []

    // the subdivision creates the vertex buffer data

    subdivide(detail)

    // all vertices should lie on a conceptual sphere with a given radius

    appplyRadius(radius)

    // finally, create the uv data

    generateUVs()

    // build non-indexed geometry

    this.addAttribute('position', new Float32BufferAttribute(vertexBuffer, 3))
    this.addAttribute('normal', new Float32BufferAttribute(vertexBuffer.slice(), 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvBuffer, 2))

    if (detail === 0) {
      this.computeVertexNormals() // flat normals
    } else {
      this.normalizeNormals() // smooth normals
    }

    // helper functions

    function subdivide(detail) {
      var a = new Vector3()
      var b = new Vector3()
      var c = new Vector3()

      // iterate over all faces and apply a subdivison with the given detail value

      for (var i = 0; i < indices.length; i += 3) {
        // get the vertices of the face

        getVertexByIndex(indices[i + 0], a)
        getVertexByIndex(indices[i + 1], b)
        getVertexByIndex(indices[i + 2], c)

        // perform subdivision

        subdivideFace(a, b, c, detail)
      }
    }

    function subdivideFace(a, b, c, detail) {
      var cols = Math.pow(2, detail)

      // we use this multidimensional array as a data structure for creating the subdivision

      var v = []

      var i, j

      // construct all of the vertices for this subdivision

      for (i = 0; i <= cols; i++) {
        v[i] = []

        var aj = a.clone().lerp(c, i / cols)
        var bj = b.clone().lerp(c, i / cols)

        var rows = cols - i

        for (j = 0; j <= rows; j++) {
          if (j === 0 && i === cols) {
            v[i][j] = aj
          } else {
            v[i][j] = aj.clone().lerp(bj, j / rows)
          }
        }
      }

      // construct all of the faces

      for (i = 0; i < cols; i++) {
        for (j = 0; j < 2 * (cols - i) - 1; j++) {
          var k = Math.floor(j / 2)

          if (j % 2 === 0) {
            pushVertex(v[i][k + 1])
            pushVertex(v[i + 1][k])
            pushVertex(v[i][k])
          } else {
            pushVertex(v[i][k + 1])
            pushVertex(v[i + 1][k + 1])
            pushVertex(v[i + 1][k])
          }
        }
      }
    }

    function appplyRadius(radius) {
      var vertex = new Vector3()

      // iterate over the entire buffer and apply the radius to each vertex

      for (var i = 0; i < vertexBuffer.length; i += 3) {
        vertex.x = vertexBuffer[i + 0]
        vertex.y = vertexBuffer[i + 1]
        vertex.z = vertexBuffer[i + 2]

        vertex.normalize().multiplyScalar(radius)

        vertexBuffer[i + 0] = vertex.x
        vertexBuffer[i + 1] = vertex.y
        vertexBuffer[i + 2] = vertex.z
      }
    }

    function generateUVs() {
      var vertex = new Vector3()

      for (var i = 0; i < vertexBuffer.length; i += 3) {
        vertex.x = vertexBuffer[i + 0]
        vertex.y = vertexBuffer[i + 1]
        vertex.z = vertexBuffer[i + 2]

        var u = azimuth(vertex) / 2 / Math.PI + 0.5
        var v = inclination(vertex) / Math.PI + 0.5
        uvBuffer.push(u, 1 - v)
      }

      correctUVs()

      correctSeam()
    }

    function correctSeam() {
      // handle case when face straddles the seam, see #3269

      for (var i = 0; i < uvBuffer.length; i += 6) {
        // uv data of a single face

        var x0 = uvBuffer[i + 0]
        var x1 = uvBuffer[i + 2]
        var x2 = uvBuffer[i + 4]

        var max = Math.max(x0, x1, x2)
        var min = Math.min(x0, x1, x2)

        // 0.9 is somewhat arbitrary

        if (max > 0.9 && min < 0.1) {
          if (x0 < 0.2) uvBuffer[i + 0] += 1
          if (x1 < 0.2) uvBuffer[i + 2] += 1
          if (x2 < 0.2) uvBuffer[i + 4] += 1
        }
      }
    }

    function pushVertex(vertex) {
      vertexBuffer.push(vertex.x, vertex.y, vertex.z)
    }

    function getVertexByIndex(index, vertex) {
      var stride = index * 3

      vertex.x = vertices[stride + 0]
      vertex.y = vertices[stride + 1]
      vertex.z = vertices[stride + 2]
    }

    function correctUVs() {
      var a = new Vector3()
      var b = new Vector3()
      var c = new Vector3()

      var centroid = new Vector3()

      var uvA = new Vector2()
      var uvB = new Vector2()
      var uvC = new Vector2()

      for (var i = 0, j = 0; i < vertexBuffer.length; i += 9, j += 6) {
        a.set(vertexBuffer[i + 0], vertexBuffer[i + 1], vertexBuffer[i + 2])
        b.set(vertexBuffer[i + 3], vertexBuffer[i + 4], vertexBuffer[i + 5])
        c.set(vertexBuffer[i + 6], vertexBuffer[i + 7], vertexBuffer[i + 8])

        uvA.set(uvBuffer[j + 0], uvBuffer[j + 1])
        uvB.set(uvBuffer[j + 2], uvBuffer[j + 3])
        uvC.set(uvBuffer[j + 4], uvBuffer[j + 5])

        centroid.copy(a).add(b).add(c).divideScalar(3)

        var azi = azimuth(centroid)

        correctUV(uvA, j + 0, a, azi)
        correctUV(uvB, j + 2, b, azi)
        correctUV(uvC, j + 4, c, azi)
      }
    }

    function correctUV(uv, stride, vector, azimuth) {
      if (azimuth < 0 && uv.x === 1) {
        uvBuffer[stride] = uv.x - 1
      }

      if (vector.x === 0 && vector.z === 0) {
        uvBuffer[stride] = azimuth / 2 / Math.PI + 0.5
      }
    }

    // Angle around the Y axis, counter-clockwise when looking from above.

    function azimuth(vector) {
      return Math.atan2(vector.z, -vector.x)
    }

    // Angle above the XZ plane.

    function inclination(vector) {
      return Math.atan2(-vector.y, Math.sqrt(vector.x * vector.x + vector.z * vector.z))
    }
  }

  PolyhedronBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  PolyhedronBufferGeometry.prototype.constructor = PolyhedronBufferGeometry

  /**
   * @author timothypratley / https://github.com/timothypratley
   * @author Mugen87 / https://github.com/Mugen87
   */

  // TetrahedronGeometry

  function TetrahedronGeometry(radius, detail) {
    Geometry.call(this)

    this.type = 'TetrahedronGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }

    this.fromBufferGeometry(new TetrahedronBufferGeometry(radius, detail))
    this.mergeVertices()
  }

  TetrahedronGeometry.prototype = Object.create(Geometry.prototype)
  TetrahedronGeometry.prototype.constructor = TetrahedronGeometry

  // TetrahedronBufferGeometry

  function TetrahedronBufferGeometry(radius, detail) {
    var vertices = [1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1]

    var indices = [2, 1, 0, 0, 3, 2, 1, 3, 0, 2, 3, 1]

    PolyhedronBufferGeometry.call(this, vertices, indices, radius, detail)

    this.type = 'TetrahedronBufferGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }
  }

  TetrahedronBufferGeometry.prototype = Object.create(PolyhedronBufferGeometry.prototype)
  TetrahedronBufferGeometry.prototype.constructor = TetrahedronBufferGeometry

  /**
   * @author timothypratley / https://github.com/timothypratley
   * @author Mugen87 / https://github.com/Mugen87
   */

  // OctahedronGeometry

  function OctahedronGeometry(radius, detail) {
    Geometry.call(this)

    this.type = 'OctahedronGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }

    this.fromBufferGeometry(new OctahedronBufferGeometry(radius, detail))
    this.mergeVertices()
  }

  OctahedronGeometry.prototype = Object.create(Geometry.prototype)
  OctahedronGeometry.prototype.constructor = OctahedronGeometry

  // OctahedronBufferGeometry

  function OctahedronBufferGeometry(radius, detail) {
    var vertices = [1, 0, 0, -1, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 1, 0, 0, -1]

    var indices = [0, 2, 4, 0, 4, 3, 0, 3, 5, 0, 5, 2, 1, 2, 5, 1, 5, 3, 1, 3, 4, 1, 4, 2]

    PolyhedronBufferGeometry.call(this, vertices, indices, radius, detail)

    this.type = 'OctahedronBufferGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }
  }

  OctahedronBufferGeometry.prototype = Object.create(PolyhedronBufferGeometry.prototype)
  OctahedronBufferGeometry.prototype.constructor = OctahedronBufferGeometry

  /**
   * @author timothypratley / https://github.com/timothypratley
   * @author Mugen87 / https://github.com/Mugen87
   */

  // IcosahedronGeometry

  function IcosahedronGeometry(radius, detail) {
    Geometry.call(this)

    this.type = 'IcosahedronGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }

    this.fromBufferGeometry(new IcosahedronBufferGeometry(radius, detail))
    this.mergeVertices()
  }

  IcosahedronGeometry.prototype = Object.create(Geometry.prototype)
  IcosahedronGeometry.prototype.constructor = IcosahedronGeometry

  // IcosahedronBufferGeometry

  function IcosahedronBufferGeometry(radius, detail) {
    var t = (1 + Math.sqrt(5)) / 2

    var vertices = [
      -1,
      t,
      0,
      1,
      t,
      0,
      -1,
      -t,
      0,
      1,
      -t,
      0,
      0,
      -1,
      t,
      0,
      1,
      t,
      0,
      -1,
      -t,
      0,
      1,
      -t,
      t,
      0,
      -1,
      t,
      0,
      1,
      -t,
      0,
      -1,
      -t,
      0,
      1
    ]

    var indices = [
      0, 11, 5, 0, 5, 1, 0, 1, 7, 0, 7, 10, 0, 10, 11, 1, 5, 9, 5, 11, 4, 11, 10, 2, 10, 7, 6, 7, 1,
      8, 3, 9, 4, 3, 4, 2, 3, 2, 6, 3, 6, 8, 3, 8, 9, 4, 9, 5, 2, 4, 11, 6, 2, 10, 8, 6, 7, 9, 8, 1
    ]

    PolyhedronBufferGeometry.call(this, vertices, indices, radius, detail)

    this.type = 'IcosahedronBufferGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }
  }

  IcosahedronBufferGeometry.prototype = Object.create(PolyhedronBufferGeometry.prototype)
  IcosahedronBufferGeometry.prototype.constructor = IcosahedronBufferGeometry

  /**
   * @author Abe Pazos / https://hamoid.com
   * @author Mugen87 / https://github.com/Mugen87
   */

  // DodecahedronGeometry

  function DodecahedronGeometry(radius, detail) {
    Geometry.call(this)

    this.type = 'DodecahedronGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }

    this.fromBufferGeometry(new DodecahedronBufferGeometry(radius, detail))
    this.mergeVertices()
  }

  DodecahedronGeometry.prototype = Object.create(Geometry.prototype)
  DodecahedronGeometry.prototype.constructor = DodecahedronGeometry

  // DodecahedronBufferGeometry

  function DodecahedronBufferGeometry(radius, detail) {
    var t = (1 + Math.sqrt(5)) / 2
    var r = 1 / t

    var vertices = [
      // (±1, ±1, ±1)
      -1,
      -1,
      -1,
      -1,
      -1,
      1,
      -1,
      1,
      -1,
      -1,
      1,
      1,
      1,
      -1,
      -1,
      1,
      -1,
      1,
      1,
      1,
      -1,
      1,
      1,
      1,

      // (0, ±1/φ, ±φ)
      0,
      -r,
      -t,
      0,
      -r,
      t,
      0,
      r,
      -t,
      0,
      r,
      t,

      // (±1/φ, ±φ, 0)
      -r,
      -t,
      0,
      -r,
      t,
      0,
      r,
      -t,
      0,
      r,
      t,
      0,

      // (±φ, 0, ±1/φ)
      -t,
      0,
      -r,
      t,
      0,
      -r,
      -t,
      0,
      r,
      t,
      0,
      r
    ]

    var indices = [
      3, 11, 7, 3, 7, 15, 3, 15, 13, 7, 19, 17, 7, 17, 6, 7, 6, 15, 17, 4, 8, 17, 8, 10, 17, 10, 6,
      8, 0, 16, 8, 16, 2, 8, 2, 10, 0, 12, 1, 0, 1, 18, 0, 18, 16, 6, 10, 2, 6, 2, 13, 6, 13, 15, 2,
      16, 18, 2, 18, 3, 2, 3, 13, 18, 1, 9, 18, 9, 11, 18, 11, 3, 4, 14, 12, 4, 12, 0, 4, 0, 8, 11,
      9, 5, 11, 5, 19, 11, 19, 7, 19, 5, 14, 19, 14, 4, 19, 4, 17, 1, 12, 14, 1, 14, 5, 1, 5, 9
    ]

    PolyhedronBufferGeometry.call(this, vertices, indices, radius, detail)

    this.type = 'DodecahedronBufferGeometry'

    this.parameters = {
      radius: radius,
      detail: detail
    }
  }

  DodecahedronBufferGeometry.prototype = Object.create(PolyhedronBufferGeometry.prototype)
  DodecahedronBufferGeometry.prototype.constructor = DodecahedronBufferGeometry

  /**
   * @author oosmoxiecode / https://github.com/oosmoxiecode
   * @author WestLangley / https://github.com/WestLangley
   * @author zz85 / https://github.com/zz85
   * @author miningold / https://github.com/miningold
   * @author jonobr1 / https://github.com/jonobr1
   * @author Mugen87 / https://github.com/Mugen87
   *
   */

  // TubeGeometry

  function TubeGeometry(path, tubularSegments, radius, radialSegments, closed, taper) {
    Geometry.call(this)

    this.type = 'TubeGeometry'

    this.parameters = {
      path: path,
      tubularSegments: tubularSegments,
      radius: radius,
      radialSegments: radialSegments,
      closed: closed
    }

    if (taper !== undefined) console.warn('THREE.TubeGeometry: taper has been removed.')

    var bufferGeometry = new TubeBufferGeometry(
      path,
      tubularSegments,
      radius,
      radialSegments,
      closed
    )

    // expose internals

    this.tangents = bufferGeometry.tangents
    this.normals = bufferGeometry.normals
    this.binormals = bufferGeometry.binormals

    // create geometry

    this.fromBufferGeometry(bufferGeometry)
    this.mergeVertices()
  }

  TubeGeometry.prototype = Object.create(Geometry.prototype)
  TubeGeometry.prototype.constructor = TubeGeometry

  // TubeBufferGeometry

  function TubeBufferGeometry(path, tubularSegments, radius, radialSegments, closed) {
    BufferGeometry.call(this)

    this.type = 'TubeBufferGeometry'

    this.parameters = {
      path: path,
      tubularSegments: tubularSegments,
      radius: radius,
      radialSegments: radialSegments,
      closed: closed
    }

    tubularSegments = tubularSegments || 64
    radius = radius || 1
    radialSegments = radialSegments || 8
    closed = closed || false

    var frames = path.computeFrenetFrames(tubularSegments, closed)

    // expose internals

    this.tangents = frames.tangents
    this.normals = frames.normals
    this.binormals = frames.binormals

    // helper variables

    var vertex = new Vector3()
    var normal = new Vector3()
    var uv = new Vector2()
    var P = new Vector3()

    var i, j

    // buffer

    var vertices = []
    var normals = []
    var uvs = []
    var indices = []

    // create buffer data

    generateBufferData()

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))

    // functions

    function generateBufferData() {
      for (i = 0; i < tubularSegments; i++) {
        generateSegment(i)
      }

      // if the geometry is not closed, generate the last row of vertices and normals
      // at the regular position on the given path
      //
      // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)

      generateSegment(closed === false ? tubularSegments : 0)

      // uvs are generated in a separate function.
      // this makes it easy compute correct values for closed geometries

      generateUVs()

      // finally create faces

      generateIndices()
    }

    function generateSegment(i) {
      // we use getPointAt to sample evenly distributed points from the given path

      P = path.getPointAt(i / tubularSegments, P)

      // retrieve corresponding normal and binormal

      var N = frames.normals[i]
      var B = frames.binormals[i]

      // generate normals and vertices for the current segment

      for (j = 0; j <= radialSegments; j++) {
        var v = (j / radialSegments) * Math.PI * 2

        var sin = Math.sin(v)
        var cos = -Math.cos(v)

        // normal

        normal.x = cos * N.x + sin * B.x
        normal.y = cos * N.y + sin * B.y
        normal.z = cos * N.z + sin * B.z
        normal.normalize()

        normals.push(normal.x, normal.y, normal.z)

        // vertex

        vertex.x = P.x + radius * normal.x
        vertex.y = P.y + radius * normal.y
        vertex.z = P.z + radius * normal.z

        vertices.push(vertex.x, vertex.y, vertex.z)
      }
    }

    function generateIndices() {
      for (j = 1; j <= tubularSegments; j++) {
        for (i = 1; i <= radialSegments; i++) {
          var a = (radialSegments + 1) * (j - 1) + (i - 1)
          var b = (radialSegments + 1) * j + (i - 1)
          var c = (radialSegments + 1) * j + i
          var d = (radialSegments + 1) * (j - 1) + i

          // faces

          indices.push(a, b, d)
          indices.push(b, c, d)
        }
      }
    }

    function generateUVs() {
      for (i = 0; i <= tubularSegments; i++) {
        for (j = 0; j <= radialSegments; j++) {
          uv.x = i / tubularSegments
          uv.y = j / radialSegments

          uvs.push(uv.x, uv.y)
        }
      }
    }
  }

  TubeBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  TubeBufferGeometry.prototype.constructor = TubeBufferGeometry

  /**
   * @author oosmoxiecode
   * @author Mugen87 / https://github.com/Mugen87
   *
   * based on http://www.blackpawn.com/texts/pqtorus/
   */

  // TorusKnotGeometry

  function TorusKnotGeometry(radius, tube, tubularSegments, radialSegments, p, q, heightScale) {
    Geometry.call(this)

    this.type = 'TorusKnotGeometry'

    this.parameters = {
      radius: radius,
      tube: tube,
      tubularSegments: tubularSegments,
      radialSegments: radialSegments,
      p: p,
      q: q
    }

    if (heightScale !== undefined)
      console.warn(
        'THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.'
      )

    this.fromBufferGeometry(
      new TorusKnotBufferGeometry(radius, tube, tubularSegments, radialSegments, p, q)
    )
    this.mergeVertices()
  }

  TorusKnotGeometry.prototype = Object.create(Geometry.prototype)
  TorusKnotGeometry.prototype.constructor = TorusKnotGeometry

  // TorusKnotBufferGeometry

  function TorusKnotBufferGeometry(radius, tube, tubularSegments, radialSegments, p, q) {
    BufferGeometry.call(this)

    this.type = 'TorusKnotBufferGeometry'

    this.parameters = {
      radius: radius,
      tube: tube,
      tubularSegments: tubularSegments,
      radialSegments: radialSegments,
      p: p,
      q: q
    }

    radius = radius || 1
    tube = tube || 0.4
    tubularSegments = Math.floor(tubularSegments) || 64
    radialSegments = Math.floor(radialSegments) || 8
    p = p || 2
    q = q || 3

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // helper variables

    var i, j

    var vertex = new Vector3()
    var normal = new Vector3()

    var P1 = new Vector3()
    var P2 = new Vector3()

    var B = new Vector3()
    var T = new Vector3()
    var N = new Vector3()

    // generate vertices, normals and uvs

    for (i = 0; i <= tubularSegments; ++i) {
      // the radian "u" is used to calculate the position on the torus curve of the current tubular segement

      var u = (i / tubularSegments) * p * Math.PI * 2

      // now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.
      // these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions

      calculatePositionOnCurve(u, p, q, radius, P1)
      calculatePositionOnCurve(u + 0.01, p, q, radius, P2)

      // calculate orthonormal basis

      T.subVectors(P2, P1)
      N.addVectors(P2, P1)
      B.crossVectors(T, N)
      N.crossVectors(B, T)

      // normalize B, N. T can be ignored, we don't use it

      B.normalize()
      N.normalize()

      for (j = 0; j <= radialSegments; ++j) {
        // now calculate the vertices. they are nothing more than an extrusion of the torus curve.
        // because we extrude a shape in the xy-plane, there is no need to calculate a z-value.

        var v = (j / radialSegments) * Math.PI * 2
        var cx = -tube * Math.cos(v)
        var cy = tube * Math.sin(v)

        // now calculate the final vertex position.
        // first we orient the extrusion with our basis vectos, then we add it to the current position on the curve

        vertex.x = P1.x + (cx * N.x + cy * B.x)
        vertex.y = P1.y + (cx * N.y + cy * B.y)
        vertex.z = P1.z + (cx * N.z + cy * B.z)

        vertices.push(vertex.x, vertex.y, vertex.z)

        // normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)

        normal.subVectors(vertex, P1).normalize()

        normals.push(normal.x, normal.y, normal.z)

        // uv

        uvs.push(i / tubularSegments)
        uvs.push(j / radialSegments)
      }
    }

    // generate indices

    for (j = 1; j <= tubularSegments; j++) {
      for (i = 1; i <= radialSegments; i++) {
        // indices

        var a = (radialSegments + 1) * (j - 1) + (i - 1)
        var b = (radialSegments + 1) * j + (i - 1)
        var c = (radialSegments + 1) * j + i
        var d = (radialSegments + 1) * (j - 1) + i

        // faces

        indices.push(a, b, d)
        indices.push(b, c, d)
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))

    // this function calculates the current position on the torus curve

    function calculatePositionOnCurve(u, p, q, radius, position) {
      var cu = Math.cos(u)
      var su = Math.sin(u)
      var quOverP = (q / p) * u
      var cs = Math.cos(quOverP)

      position.x = radius * (2 + cs) * 0.5 * cu
      position.y = radius * (2 + cs) * su * 0.5
      position.z = radius * Math.sin(quOverP) * 0.5
    }
  }

  TorusKnotBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  TorusKnotBufferGeometry.prototype.constructor = TorusKnotBufferGeometry

  /**
   * @author oosmoxiecode
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / https://github.com/Mugen87
   */

  // TorusGeometry

  function TorusGeometry(radius, tube, radialSegments, tubularSegments, arc) {
    Geometry.call(this)

    this.type = 'TorusGeometry'

    this.parameters = {
      radius: radius,
      tube: tube,
      radialSegments: radialSegments,
      tubularSegments: tubularSegments,
      arc: arc
    }

    this.fromBufferGeometry(
      new TorusBufferGeometry(radius, tube, radialSegments, tubularSegments, arc)
    )
    this.mergeVertices()
  }

  TorusGeometry.prototype = Object.create(Geometry.prototype)
  TorusGeometry.prototype.constructor = TorusGeometry

  // TorusBufferGeometry

  function TorusBufferGeometry(radius, tube, radialSegments, tubularSegments, arc) {
    BufferGeometry.call(this)

    this.type = 'TorusBufferGeometry'

    this.parameters = {
      radius: radius,
      tube: tube,
      radialSegments: radialSegments,
      tubularSegments: tubularSegments,
      arc: arc
    }

    radius = radius || 1
    tube = tube || 0.4
    radialSegments = Math.floor(radialSegments) || 8
    tubularSegments = Math.floor(tubularSegments) || 6
    arc = arc || Math.PI * 2

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // helper variables

    var center = new Vector3()
    var vertex = new Vector3()
    var normal = new Vector3()

    var j, i

    // generate vertices, normals and uvs

    for (j = 0; j <= radialSegments; j++) {
      for (i = 0; i <= tubularSegments; i++) {
        var u = (i / tubularSegments) * arc
        var v = (j / radialSegments) * Math.PI * 2

        // vertex

        vertex.x = (radius + tube * Math.cos(v)) * Math.cos(u)
        vertex.y = (radius + tube * Math.cos(v)) * Math.sin(u)
        vertex.z = tube * Math.sin(v)

        vertices.push(vertex.x, vertex.y, vertex.z)

        // normal

        center.x = radius * Math.cos(u)
        center.y = radius * Math.sin(u)
        normal.subVectors(vertex, center).normalize()

        normals.push(normal.x, normal.y, normal.z)

        // uv

        uvs.push(i / tubularSegments)
        uvs.push(j / radialSegments)
      }
    }

    // generate indices

    for (j = 1; j <= radialSegments; j++) {
      for (i = 1; i <= tubularSegments; i++) {
        // indices

        var a = (tubularSegments + 1) * j + i - 1
        var b = (tubularSegments + 1) * (j - 1) + i - 1
        var c = (tubularSegments + 1) * (j - 1) + i
        var d = (tubularSegments + 1) * j + i

        // faces

        indices.push(a, b, d)
        indices.push(b, c, d)
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))
  }

  TorusBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  TorusBufferGeometry.prototype.constructor = TorusBufferGeometry

  /**
   * @author Mugen87 / https://github.com/Mugen87
   * Port from https://github.com/mapbox/earcut (v2.1.2)
   */

  var Earcut = {
    triangulate: function (data, holeIndices, dim) {
      dim = dim || 2

      var hasHoles = holeIndices && holeIndices.length,
        outerLen = hasHoles ? holeIndices[0] * dim : data.length,
        outerNode = linkedList(data, 0, outerLen, dim, true),
        triangles = []

      if (!outerNode) return triangles

      var minX, minY, maxX, maxY, x, y, invSize

      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim)

      // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox

      if (data.length > 80 * dim) {
        minX = maxX = data[0]
        minY = maxY = data[1]

        for (var i = dim; i < outerLen; i += dim) {
          x = data[i]
          y = data[i + 1]
          if (x < minX) minX = x
          if (y < minY) minY = y
          if (x > maxX) maxX = x
          if (y > maxY) maxY = y
        }

        // minX, minY and invSize are later used to transform coords into integers for z-order calculation

        invSize = Math.max(maxX - minX, maxY - minY)
        invSize = invSize !== 0 ? 1 / invSize : 0
      }

      earcutLinked(outerNode, triangles, dim, minX, minY, invSize)

      return triangles
    }
  }

  // create a circular doubly linked list from polygon points in the specified winding order

  function linkedList(data, start, end, dim, clockwise) {
    var i, last

    if (clockwise === signedArea(data, start, end, dim) > 0) {
      for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last)
    } else {
      for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last)
    }

    if (last && equals(last, last.next)) {
      removeNode(last)
      last = last.next
    }

    return last
  }

  // eliminate colinear or duplicate points

  function filterPoints(start, end) {
    if (!start) return start
    if (!end) end = start

    var p = start,
      again

    do {
      again = false

      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
        removeNode(p)
        p = end = p.prev
        if (p === p.next) break
        again = true
      } else {
        p = p.next
      }
    } while (again || p !== end)

    return end
  }

  // main ear slicing loop which triangulates a polygon (given as a linked list)

  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
    if (!ear) return

    // interlink polygon nodes in z-order

    if (!pass && invSize) indexCurve(ear, minX, minY, invSize)

    var stop = ear,
      prev,
      next

    // iterate through ears, slicing them one by one

    while (ear.prev !== ear.next) {
      prev = ear.prev
      next = ear.next

      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
        // cut off the triangle
        triangles.push(prev.i / dim)
        triangles.push(ear.i / dim)
        triangles.push(next.i / dim)

        removeNode(ear)

        // skipping the next vertice leads to less sliver triangles
        ear = next.next
        stop = next.next

        continue
      }

      ear = next

      // if we looped through the whole remaining polygon and can't find any more ears

      if (ear === stop) {
        // try filtering points and slicing again

        if (!pass) {
          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1)

          // if this didn't work, try curing all small self-intersections locally
        } else if (pass === 1) {
          ear = cureLocalIntersections(ear, triangles, dim)
          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2)

          // as a last resort, try splitting the remaining polygon into two
        } else if (pass === 2) {
          splitEarcut(ear, triangles, dim, minX, minY, invSize)
        }

        break
      }
    }
  }

  // check whether a polygon node forms a valid ear with adjacent nodes

  function isEar(ear) {
    var a = ear.prev,
      b = ear,
      c = ear.next

    if (area(a, b, c) >= 0) return false // reflex, can't be an ear

    // now make sure we don't have other points inside the potential ear
    var p = ear.next.next

    while (p !== ear.prev) {
      if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) {
        return false
      }

      p = p.next
    }

    return true
  }

  function isEarHashed(ear, minX, minY, invSize) {
    var a = ear.prev,
      b = ear,
      c = ear.next

    if (area(a, b, c) >= 0) return false // reflex, can't be an ear

    // triangle bbox; min & max are calculated like this for speed

    var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : b.x < c.x ? b.x : c.x,
      minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : b.y < c.y ? b.y : c.y,
      maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : b.x > c.x ? b.x : c.x,
      maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : b.y > c.y ? b.y : c.y

    // z-order range for the current triangle bbox;

    var minZ = zOrder(minTX, minTY, minX, minY, invSize),
      maxZ = zOrder(maxTX, maxTY, minX, minY, invSize)

    // first look for points inside the triangle in increasing z-order

    var p = ear.nextZ

    while (p && p.z <= maxZ) {
      if (
        p !== ear.prev &&
        p !== ear.next &&
        pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
        area(p.prev, p, p.next) >= 0
      )
        return false
      p = p.nextZ
    }

    // then look for points in decreasing z-order

    p = ear.prevZ

    while (p && p.z >= minZ) {
      if (
        p !== ear.prev &&
        p !== ear.next &&
        pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
        area(p.prev, p, p.next) >= 0
      )
        return false

      p = p.prevZ
    }

    return true
  }

  // go through all polygon nodes and cure small local self-intersections

  function cureLocalIntersections(start, triangles, dim) {
    var p = start

    do {
      var a = p.prev,
        b = p.next.next

      if (
        !equals(a, b) &&
        intersects(a, p, p.next, b) &&
        locallyInside(a, b) &&
        locallyInside(b, a)
      ) {
        triangles.push(a.i / dim)
        triangles.push(p.i / dim)
        triangles.push(b.i / dim)

        // remove two nodes involved

        removeNode(p)
        removeNode(p.next)

        p = start = b
      }

      p = p.next
    } while (p !== start)

    return p
  }

  // try splitting polygon into two and triangulate them independently

  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
    // look for a valid diagonal that divides the polygon into two

    var a = start

    do {
      var b = a.next.next

      while (b !== a.prev) {
        if (a.i !== b.i && isValidDiagonal(a, b)) {
          // split the polygon in two by the diagonal

          var c = splitPolygon(a, b)

          // filter colinear points around the cuts

          a = filterPoints(a, a.next)
          c = filterPoints(c, c.next)

          // run earcut on each half

          earcutLinked(a, triangles, dim, minX, minY, invSize)
          earcutLinked(c, triangles, dim, minX, minY, invSize)
          return
        }

        b = b.next
      }

      a = a.next
    } while (a !== start)
  }

  // link every hole into the outer loop, producing a single-ring polygon without holes

  function eliminateHoles(data, holeIndices, outerNode, dim) {
    var queue = [],
      i,
      len,
      start,
      end,
      list

    for (i = 0, len = holeIndices.length; i < len; i++) {
      start = holeIndices[i] * dim
      end = i < len - 1 ? holeIndices[i + 1] * dim : data.length
      list = linkedList(data, start, end, dim, false)
      if (list === list.next) list.steiner = true
      queue.push(getLeftmost(list))
    }

    queue.sort(compareX)

    // process holes from left to right

    for (i = 0; i < queue.length; i++) {
      eliminateHole(queue[i], outerNode)
      outerNode = filterPoints(outerNode, outerNode.next)
    }

    return outerNode
  }

  function compareX(a, b) {
    return a.x - b.x
  }

  // find a bridge between vertices that connects hole with an outer ring and and link it

  function eliminateHole(hole, outerNode) {
    outerNode = findHoleBridge(hole, outerNode)

    if (outerNode) {
      var b = splitPolygon(outerNode, hole)

      filterPoints(b, b.next)
    }
  }

  // David Eberly's algorithm for finding a bridge between hole and outer polygon

  function findHoleBridge(hole, outerNode) {
    var p = outerNode,
      hx = hole.x,
      hy = hole.y,
      qx = -Infinity,
      m

    // find a segment intersected by a ray from the hole's leftmost point to the left;
    // segment's endpoint with lesser x will be potential connection point

    do {
      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
        var x = p.x + ((hy - p.y) * (p.next.x - p.x)) / (p.next.y - p.y)

        if (x <= hx && x > qx) {
          qx = x

          if (x === hx) {
            if (hy === p.y) return p
            if (hy === p.next.y) return p.next
          }

          m = p.x < p.next.x ? p : p.next
        }
      }

      p = p.next
    } while (p !== outerNode)

    if (!m) return null

    if (hx === qx) return m.prev // hole touches outer segment; pick lower endpoint

    // look for points inside the triangle of hole point, segment intersection and endpoint;
    // if there are no points found, we have a valid connection;
    // otherwise choose the point of the minimum angle with the ray as connection point

    var stop = m,
      mx = m.x,
      my = m.y,
      tanMin = Infinity,
      tan

    p = m.next

    while (p !== stop) {
      if (
        hx >= p.x &&
        p.x >= mx &&
        hx !== p.x &&
        pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)
      ) {
        tan = Math.abs(hy - p.y) / (hx - p.x) // tangential

        if ((tan < tanMin || (tan === tanMin && p.x > m.x)) && locallyInside(p, hole)) {
          m = p
          tanMin = tan
        }
      }

      p = p.next
    }

    return m
  }

  // interlink polygon nodes in z-order

  function indexCurve(start, minX, minY, invSize) {
    var p = start

    do {
      if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, invSize)
      p.prevZ = p.prev
      p.nextZ = p.next
      p = p.next
    } while (p !== start)

    p.prevZ.nextZ = null
    p.prevZ = null

    sortLinked(p)
  }

  // Simon Tatham's linked list merge sort algorithm
  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html

  function sortLinked(list) {
    var i,
      p,
      q,
      e,
      tail,
      numMerges,
      pSize,
      qSize,
      inSize = 1

    do {
      p = list
      list = null
      tail = null
      numMerges = 0

      while (p) {
        numMerges++
        q = p
        pSize = 0

        for (i = 0; i < inSize; i++) {
          pSize++
          q = q.nextZ
          if (!q) break
        }

        qSize = inSize

        while (pSize > 0 || (qSize > 0 && q)) {
          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
            e = p
            p = p.nextZ
            pSize--
          } else {
            e = q
            q = q.nextZ
            qSize--
          }

          if (tail) tail.nextZ = e
          else list = e

          e.prevZ = tail
          tail = e
        }

        p = q
      }

      tail.nextZ = null
      inSize *= 2
    } while (numMerges > 1)

    return list
  }

  // z-order of a point given coords and inverse of the longer side of data bbox

  function zOrder(x, y, minX, minY, invSize) {
    // coords are transformed into non-negative 15-bit integer range

    x = 32767 * (x - minX) * invSize
    y = 32767 * (y - minY) * invSize

    x = (x | (x << 8)) & 0x00ff00ff
    x = (x | (x << 4)) & 0x0f0f0f0f
    x = (x | (x << 2)) & 0x33333333
    x = (x | (x << 1)) & 0x55555555

    y = (y | (y << 8)) & 0x00ff00ff
    y = (y | (y << 4)) & 0x0f0f0f0f
    y = (y | (y << 2)) & 0x33333333
    y = (y | (y << 1)) & 0x55555555

    return x | (y << 1)
  }

  // find the leftmost node of a polygon ring

  function getLeftmost(start) {
    var p = start,
      leftmost = start

    do {
      if (p.x < leftmost.x) leftmost = p
      p = p.next
    } while (p !== start)

    return leftmost
  }

  // check if a point lies within a convex triangle

  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
    return (
      (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
      (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
      (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0
    )
  }

  // check if a diagonal between two polygon nodes is valid (lies in polygon interior)

  function isValidDiagonal(a, b) {
    return (
      a.next.i !== b.i &&
      a.prev.i !== b.i &&
      !intersectsPolygon(a, b) &&
      locallyInside(a, b) &&
      locallyInside(b, a) &&
      middleInside(a, b)
    )
  }

  // signed area of a triangle

  function area(p, q, r) {
    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)
  }

  // check if two points are equal

  function equals(p1, p2) {
    return p1.x === p2.x && p1.y === p2.y
  }

  // check if two segments intersect

  function intersects(p1, q1, p2, q2) {
    if ((equals(p1, q1) && equals(p2, q2)) || (equals(p1, q2) && equals(p2, q1))) return true

    return (
      area(p1, q1, p2) > 0 !== area(p1, q1, q2) > 0 && area(p2, q2, p1) > 0 !== area(p2, q2, q1) > 0
    )
  }

  // check if a polygon diagonal intersects any polygon segments

  function intersectsPolygon(a, b) {
    var p = a

    do {
      if (
        p.i !== a.i &&
        p.next.i !== a.i &&
        p.i !== b.i &&
        p.next.i !== b.i &&
        intersects(p, p.next, a, b)
      ) {
        return true
      }

      p = p.next
    } while (p !== a)

    return false
  }

  // check if a polygon diagonal is locally inside the polygon

  function locallyInside(a, b) {
    return area(a.prev, a, a.next) < 0
      ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0
      : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0
  }

  // check if the middle point of a polygon diagonal is inside the polygon

  function middleInside(a, b) {
    var p = a,
      inside = false,
      px = (a.x + b.x) / 2,
      py = (a.y + b.y) / 2

    do {
      if (
        p.y > py !== p.next.y > py &&
        p.next.y !== p.y &&
        px < ((p.next.x - p.x) * (py - p.y)) / (p.next.y - p.y) + p.x
      ) {
        inside = !inside
      }

      p = p.next
    } while (p !== a)

    return inside
  }

  // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
  // if one belongs to the outer ring and another to a hole, it merges it into a single ring

  function splitPolygon(a, b) {
    var a2 = new Node(a.i, a.x, a.y),
      b2 = new Node(b.i, b.x, b.y),
      an = a.next,
      bp = b.prev

    a.next = b
    b.prev = a

    a2.next = an
    an.prev = a2

    b2.next = a2
    a2.prev = b2

    bp.next = b2
    b2.prev = bp

    return b2
  }

  // create a node and optionally link it with previous one (in a circular doubly linked list)

  function insertNode(i, x, y, last) {
    var p = new Node(i, x, y)

    if (!last) {
      p.prev = p
      p.next = p
    } else {
      p.next = last.next
      p.prev = last
      last.next.prev = p
      last.next = p
    }

    return p
  }

  function removeNode(p) {
    p.next.prev = p.prev
    p.prev.next = p.next

    if (p.prevZ) p.prevZ.nextZ = p.nextZ
    if (p.nextZ) p.nextZ.prevZ = p.prevZ
  }

  function Node(i, x, y) {
    // vertice index in coordinates array
    this.i = i

    // vertex coordinates
    this.x = x
    this.y = y

    // previous and next vertice nodes in a polygon ring
    this.prev = null
    this.next = null

    // z-order curve value
    this.z = null

    // previous and next nodes in z-order
    this.prevZ = null
    this.nextZ = null

    // indicates whether this is a steiner point
    this.steiner = false
  }

  function signedArea(data, start, end, dim) {
    var sum = 0

    for (var i = start, j = end - dim; i < end; i += dim) {
      sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1])
      j = i
    }

    return sum
  }

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   */

  var ShapeUtils = {
    // calculate area of the contour polygon

    area: function (contour) {
      var n = contour.length
      var a = 0.0

      for (var p = n - 1, q = 0; q < n; p = q++) {
        a += contour[p].x * contour[q].y - contour[q].x * contour[p].y
      }

      return a * 0.5
    },

    isClockWise: function (pts) {
      return ShapeUtils.area(pts) < 0
    },

    triangulateShape: function (contour, holes) {
      var vertices = [] // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]
      var holeIndices = [] // array of hole indices
      var faces = [] // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]

      removeDupEndPts(contour)
      addContour(vertices, contour)

      //

      var holeIndex = contour.length

      holes.forEach(removeDupEndPts)

      for (var i = 0; i < holes.length; i++) {
        holeIndices.push(holeIndex)
        holeIndex += holes[i].length
        addContour(vertices, holes[i])
      }

      //

      var triangles = Earcut.triangulate(vertices, holeIndices)

      //

      for (var i = 0; i < triangles.length; i += 3) {
        faces.push(triangles.slice(i, i + 3))
      }

      return faces
    }
  }

  function removeDupEndPts(points) {
    var l = points.length

    if (l > 2 && points[l - 1].equals(points[0])) {
      points.pop()
    }
  }

  function addContour(vertices, contour) {
    for (var i = 0; i < contour.length; i++) {
      vertices.push(contour[i].x)
      vertices.push(contour[i].y)
    }
  }

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   *
   * Creates extruded geometry from a path shape.
   *
   * parameters = {
   *
   *  curveSegments: <int>, // number of points on the curves
   *  steps: <int>, // number of points for z-side extrusions / used for subdividing segments of extrude spline too
   *  amount: <int>, // Depth to extrude the shape
   *
   *  bevelEnabled: <bool>, // turn on bevel
   *  bevelThickness: <float>, // how deep into the original shape bevel goes
   *  bevelSize: <float>, // how far from shape outline is bevel
   *  bevelSegments: <int>, // number of bevel layers
   *
   *  extrudePath: <THREE.Curve> // curve to extrude shape along
   *  frames: <Object> // containing arrays of tangents, normals, binormals
   *
   *  UVGenerator: <Object> // object that provides UV generator functions
   *
   * }
   */

  // ExtrudeGeometry

  function ExtrudeGeometry(shapes, options) {
    Geometry.call(this)

    this.type = 'ExtrudeGeometry'

    this.parameters = {
      shapes: shapes,
      options: options
    }

    this.fromBufferGeometry(new ExtrudeBufferGeometry(shapes, options))
    this.mergeVertices()
  }

  ExtrudeGeometry.prototype = Object.create(Geometry.prototype)
  ExtrudeGeometry.prototype.constructor = ExtrudeGeometry

  // ExtrudeBufferGeometry

  function ExtrudeBufferGeometry(shapes, options) {
    if (typeof shapes === 'undefined') {
      return
    }

    BufferGeometry.call(this)

    this.type = 'ExtrudeBufferGeometry'

    shapes = Array.isArray(shapes) ? shapes : [shapes]

    this.addShapeList(shapes, options)

    this.computeVertexNormals()

    // can't really use automatic vertex normals
    // as then front and back sides get smoothed too
    // should do separate smoothing just for sides

    //this.computeVertexNormals();

    //console.log( "took", ( Date.now() - startTime ) );
  }

  ExtrudeBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  ExtrudeBufferGeometry.prototype.constructor = ExtrudeBufferGeometry

  ExtrudeBufferGeometry.prototype.getArrays = function () {
    var positionAttribute = this.getAttribute('position')
    var verticesArray = positionAttribute ? Array.prototype.slice.call(positionAttribute.array) : []

    var uvAttribute = this.getAttribute('uv')
    var uvArray = uvAttribute ? Array.prototype.slice.call(uvAttribute.array) : []

    var IndexAttribute = this.index
    var indicesArray = IndexAttribute ? Array.prototype.slice.call(IndexAttribute.array) : []

    return {
      position: verticesArray,
      uv: uvArray,
      index: indicesArray
    }
  }

  ExtrudeBufferGeometry.prototype.addShapeList = function (shapes, options) {
    var sl = shapes.length
    options.arrays = this.getArrays()

    for (var s = 0; s < sl; s++) {
      var shape = shapes[s]
      this.addShape(shape, options)
    }

    this.setIndex(options.arrays.index)
    this.addAttribute('position', new Float32BufferAttribute(options.arrays.position, 3))
    this.addAttribute('uv', new Float32BufferAttribute(options.arrays.uv, 2))
  }

  ExtrudeBufferGeometry.prototype.addShape = function (shape, options) {
    var arrays = options.arrays ? options.arrays : this.getArrays()
    var verticesArray = arrays.position
    var indicesArray = arrays.index
    var uvArray = arrays.uv

    var placeholder = []

    var amount = options.amount !== undefined ? options.amount : 100

    var bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6 // 10
    var bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2 // 8
    var bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3

    var bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true // false

    var curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12

    var steps = options.steps !== undefined ? options.steps : 1

    var extrudePath = options.extrudePath
    var extrudePts,
      extrudeByPath = false

    // Use default WorldUVGenerator if no UV generators are specified.
    var uvgen =
      options.UVGenerator !== undefined ? options.UVGenerator : ExtrudeGeometry.WorldUVGenerator

    var splineTube, binormal, normal, position2
    if (extrudePath) {
      extrudePts = extrudePath.getSpacedPoints(steps)

      extrudeByPath = true
      bevelEnabled = false // bevels not supported for path extrusion

      // SETUP TNB variables

      // TODO1 - have a .isClosed in spline?

      splineTube =
        options.frames !== undefined
          ? options.frames
          : extrudePath.computeFrenetFrames(steps, false)

      // console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);

      binormal = new Vector3()
      normal = new Vector3()
      position2 = new Vector3()
    }

    // Safeguards if bevels are not enabled

    if (!bevelEnabled) {
      bevelSegments = 0
      bevelThickness = 0
      bevelSize = 0
    }

    // Variables initialization

    var ahole, h, hl // looping of holes
    var scope = this

    var shapePoints = shape.extractPoints(curveSegments)

    var vertices = shapePoints.shape
    var holes = shapePoints.holes

    var reverse = !ShapeUtils.isClockWise(vertices)

    if (reverse) {
      vertices = vertices.reverse()

      // Maybe we should also check if holes are in the opposite direction, just to be safe ...

      for (h = 0, hl = holes.length; h < hl; h++) {
        ahole = holes[h]

        if (ShapeUtils.isClockWise(ahole)) {
          holes[h] = ahole.reverse()
        }
      }
    }

    var faces = ShapeUtils.triangulateShape(vertices, holes)

    /* Vertices */

    var contour = vertices // vertices has all points but contour has only points of circumference

    for (h = 0, hl = holes.length; h < hl; h++) {
      ahole = holes[h]

      vertices = vertices.concat(ahole)
    }

    function scalePt2(pt, vec, size) {
      if (!vec) console.error('THREE.ExtrudeGeometry: vec does not exist')

      return vec.clone().multiplyScalar(size).add(pt)
    }

    var b,
      bs,
      t,
      z,
      vert,
      vlen = vertices.length,
      face,
      flen = faces.length

    // Find directions for point movement

    function getBevelVec(inPt, inPrev, inNext) {
      // computes for inPt the corresponding point inPt' on a new contour
      //   shifted by 1 unit (length of normalized vector) to the left
      // if we walk along contour clockwise, this new contour is outside the old one
      //
      // inPt' is the intersection of the two lines parallel to the two
      //  adjacent edges of inPt at a distance of 1 unit on the left side.

      var v_trans_x, v_trans_y, shrink_by // resulting translation vector for inPt

      // good reading for geometry algorithms (here: line-line intersection)
      // http://geomalgorithms.com/a05-_intersect-1.html

      var v_prev_x = inPt.x - inPrev.x,
        v_prev_y = inPt.y - inPrev.y
      var v_next_x = inNext.x - inPt.x,
        v_next_y = inNext.y - inPt.y

      var v_prev_lensq = v_prev_x * v_prev_x + v_prev_y * v_prev_y

      // check for collinear edges
      var collinear0 = v_prev_x * v_next_y - v_prev_y * v_next_x

      if (Math.abs(collinear0) > Number.EPSILON) {
        // not collinear

        // length of vectors for normalizing

        var v_prev_len = Math.sqrt(v_prev_lensq)
        var v_next_len = Math.sqrt(v_next_x * v_next_x + v_next_y * v_next_y)

        // shift adjacent points by unit vectors to the left

        var ptPrevShift_x = inPrev.x - v_prev_y / v_prev_len
        var ptPrevShift_y = inPrev.y + v_prev_x / v_prev_len

        var ptNextShift_x = inNext.x - v_next_y / v_next_len
        var ptNextShift_y = inNext.y + v_next_x / v_next_len

        // scaling factor for v_prev to intersection point

        var sf =
          ((ptNextShift_x - ptPrevShift_x) * v_next_y -
            (ptNextShift_y - ptPrevShift_y) * v_next_x) /
          (v_prev_x * v_next_y - v_prev_y * v_next_x)

        // vector from inPt to intersection point

        v_trans_x = ptPrevShift_x + v_prev_x * sf - inPt.x
        v_trans_y = ptPrevShift_y + v_prev_y * sf - inPt.y

        // Don't normalize!, otherwise sharp corners become ugly
        //  but prevent crazy spikes
        var v_trans_lensq = v_trans_x * v_trans_x + v_trans_y * v_trans_y
        if (v_trans_lensq <= 2) {
          return new Vector2(v_trans_x, v_trans_y)
        } else {
          shrink_by = Math.sqrt(v_trans_lensq / 2)
        }
      } else {
        // handle special case of collinear edges

        var direction_eq = false // assumes: opposite
        if (v_prev_x > Number.EPSILON) {
          if (v_next_x > Number.EPSILON) {
            direction_eq = true
          }
        } else {
          if (v_prev_x < -Number.EPSILON) {
            if (v_next_x < -Number.EPSILON) {
              direction_eq = true
            }
          } else {
            if (Math.sign(v_prev_y) === Math.sign(v_next_y)) {
              direction_eq = true
            }
          }
        }

        if (direction_eq) {
          // console.log("Warning: lines are a straight sequence");
          v_trans_x = -v_prev_y
          v_trans_y = v_prev_x
          shrink_by = Math.sqrt(v_prev_lensq)
        } else {
          // console.log("Warning: lines are a straight spike");
          v_trans_x = v_prev_x
          v_trans_y = v_prev_y
          shrink_by = Math.sqrt(v_prev_lensq / 2)
        }
      }

      return new Vector2(v_trans_x / shrink_by, v_trans_y / shrink_by)
    }

    var contourMovements = []

    for (var i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i++, j++, k++) {
      if (j === il) j = 0
      if (k === il) k = 0

      //  (j)---(i)---(k)
      // console.log('i,j,k', i, j , k)

      contourMovements[i] = getBevelVec(contour[i], contour[j], contour[k])
    }

    var holesMovements = [],
      oneHoleMovements,
      verticesMovements = contourMovements.concat()

    for (h = 0, hl = holes.length; h < hl; h++) {
      ahole = holes[h]

      oneHoleMovements = []

      for (i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i++, j++, k++) {
        if (j === il) j = 0
        if (k === il) k = 0

        //  (j)---(i)---(k)
        oneHoleMovements[i] = getBevelVec(ahole[i], ahole[j], ahole[k])
      }

      holesMovements.push(oneHoleMovements)
      verticesMovements = verticesMovements.concat(oneHoleMovements)
    }

    // Loop bevelSegments, 1 for the front, 1 for the back

    for (b = 0; b < bevelSegments; b++) {
      //for ( b = bevelSegments; b > 0; b -- ) {

      t = b / bevelSegments
      z = bevelThickness * Math.cos((t * Math.PI) / 2)
      bs = bevelSize * Math.sin((t * Math.PI) / 2)

      // contract shape

      for (i = 0, il = contour.length; i < il; i++) {
        vert = scalePt2(contour[i], contourMovements[i], bs)

        v(vert.x, vert.y, -z)
      }

      // expand holes

      for (h = 0, hl = holes.length; h < hl; h++) {
        ahole = holes[h]
        oneHoleMovements = holesMovements[h]

        for (i = 0, il = ahole.length; i < il; i++) {
          vert = scalePt2(ahole[i], oneHoleMovements[i], bs)

          v(vert.x, vert.y, -z)
        }
      }
    }

    bs = bevelSize

    // Back facing vertices

    for (i = 0; i < vlen; i++) {
      vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i]

      if (!extrudeByPath) {
        v(vert.x, vert.y, 0)
      } else {
        // v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );

        normal.copy(splineTube.normals[0]).multiplyScalar(vert.x)
        binormal.copy(splineTube.binormals[0]).multiplyScalar(vert.y)

        position2.copy(extrudePts[0]).add(normal).add(binormal)

        v(position2.x, position2.y, position2.z)
      }
    }

    // Add stepped vertices...
    // Including front facing vertices

    var s

    for (s = 1; s <= steps; s++) {
      for (i = 0; i < vlen; i++) {
        vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i]

        if (!extrudeByPath) {
          v(vert.x, vert.y, (amount / steps) * s)
        } else {
          // v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );

          normal.copy(splineTube.normals[s]).multiplyScalar(vert.x)
          binormal.copy(splineTube.binormals[s]).multiplyScalar(vert.y)

          position2.copy(extrudePts[s]).add(normal).add(binormal)

          v(position2.x, position2.y, position2.z)
        }
      }
    }

    // Add bevel segments planes

    //for ( b = 1; b <= bevelSegments; b ++ ) {
    for (b = bevelSegments - 1; b >= 0; b--) {
      t = b / bevelSegments
      z = bevelThickness * Math.cos((t * Math.PI) / 2)
      bs = bevelSize * Math.sin((t * Math.PI) / 2)

      // contract shape

      for (i = 0, il = contour.length; i < il; i++) {
        vert = scalePt2(contour[i], contourMovements[i], bs)
        v(vert.x, vert.y, amount + z)
      }

      // expand holes

      for (h = 0, hl = holes.length; h < hl; h++) {
        ahole = holes[h]
        oneHoleMovements = holesMovements[h]

        for (i = 0, il = ahole.length; i < il; i++) {
          vert = scalePt2(ahole[i], oneHoleMovements[i], bs)

          if (!extrudeByPath) {
            v(vert.x, vert.y, amount + z)
          } else {
            v(vert.x, vert.y + extrudePts[steps - 1].y, extrudePts[steps - 1].x + z)
          }
        }
      }
    }

    /* Faces */

    // Top and bottom faces

    buildLidFaces()

    // Sides faces

    buildSideFaces()

    /////  Internal functions

    function buildLidFaces() {
      var start = verticesArray.length / 3

      if (bevelEnabled) {
        var layer = 0 // steps + 1
        var offset = vlen * layer

        // Bottom faces

        for (i = 0; i < flen; i++) {
          face = faces[i]
          f3(face[2] + offset, face[1] + offset, face[0] + offset)
        }

        layer = steps + bevelSegments * 2
        offset = vlen * layer

        // Top faces

        for (i = 0; i < flen; i++) {
          face = faces[i]
          f3(face[0] + offset, face[1] + offset, face[2] + offset)
        }
      } else {
        // Bottom faces

        for (i = 0; i < flen; i++) {
          face = faces[i]
          f3(face[2], face[1], face[0])
        }

        // Top faces

        for (i = 0; i < flen; i++) {
          face = faces[i]
          f3(face[0] + vlen * steps, face[1] + vlen * steps, face[2] + vlen * steps)
        }
      }

      scope.addGroup(
        start,
        verticesArray.length / 3 - start,
        options.material !== undefined ? options.material : 0
      )
    }

    // Create faces for the z-sides of the shape

    function buildSideFaces() {
      var start = verticesArray.length / 3
      var layeroffset = 0
      sidewalls(contour, layeroffset)
      layeroffset += contour.length

      for (h = 0, hl = holes.length; h < hl; h++) {
        ahole = holes[h]
        sidewalls(ahole, layeroffset)

        //, true
        layeroffset += ahole.length
      }

      scope.addGroup(
        start,
        verticesArray.length / 3 - start,
        options.extrudeMaterial !== undefined ? options.extrudeMaterial : 1
      )
    }

    function sidewalls(contour, layeroffset) {
      var j, k
      i = contour.length

      while (--i >= 0) {
        j = i
        k = i - 1
        if (k < 0) k = contour.length - 1

        //console.log('b', i,j, i-1, k,vertices.length);

        var s = 0,
          sl = steps + bevelSegments * 2

        for (s = 0; s < sl; s++) {
          var slen1 = vlen * s
          var slen2 = vlen * (s + 1)

          var a = layeroffset + j + slen1,
            b = layeroffset + k + slen1,
            c = layeroffset + k + slen2,
            d = layeroffset + j + slen2

          f4(a, b, c, d)
        }
      }
    }

    function v(x, y, z) {
      placeholder.push(x)
      placeholder.push(y)
      placeholder.push(z)
    }

    function f3(a, b, c) {
      addVertex(a)
      addVertex(b)
      addVertex(c)

      var nextIndex = verticesArray.length / 3
      var uvs = uvgen.generateTopUV(
        scope,
        verticesArray,
        nextIndex - 3,
        nextIndex - 2,
        nextIndex - 1
      )

      addUV(uvs[0])
      addUV(uvs[1])
      addUV(uvs[2])
    }

    function f4(a, b, c, d) {
      addVertex(a)
      addVertex(b)
      addVertex(d)

      addVertex(b)
      addVertex(c)
      addVertex(d)

      var nextIndex = verticesArray.length / 3
      var uvs = uvgen.generateSideWallUV(
        scope,
        verticesArray,
        nextIndex - 6,
        nextIndex - 3,
        nextIndex - 2,
        nextIndex - 1
      )

      addUV(uvs[0])
      addUV(uvs[1])
      addUV(uvs[3])

      addUV(uvs[1])
      addUV(uvs[2])
      addUV(uvs[3])
    }

    function addVertex(index) {
      indicesArray.push(verticesArray.length / 3)
      verticesArray.push(placeholder[index * 3 + 0])
      verticesArray.push(placeholder[index * 3 + 1])
      verticesArray.push(placeholder[index * 3 + 2])
    }

    function addUV(vector2) {
      uvArray.push(vector2.x)
      uvArray.push(vector2.y)
    }

    if (!options.arrays) {
      this.setIndex(indicesArray)
      this.addAttribute('position', new Float32BufferAttribute(verticesArray, 3))
      this.addAttribute('uv', new Float32BufferAttribute(uvArray, 2))
    }
  }

  ExtrudeGeometry.WorldUVGenerator = {
    generateTopUV: function (geometry, vertices, indexA, indexB, indexC) {
      var a_x = vertices[indexA * 3]
      var a_y = vertices[indexA * 3 + 1]
      var b_x = vertices[indexB * 3]
      var b_y = vertices[indexB * 3 + 1]
      var c_x = vertices[indexC * 3]
      var c_y = vertices[indexC * 3 + 1]

      return [new Vector2(a_x, a_y), new Vector2(b_x, b_y), new Vector2(c_x, c_y)]
    },

    generateSideWallUV: function (geometry, vertices, indexA, indexB, indexC, indexD) {
      var a_x = vertices[indexA * 3]
      var a_y = vertices[indexA * 3 + 1]
      var a_z = vertices[indexA * 3 + 2]
      var b_x = vertices[indexB * 3]
      var b_y = vertices[indexB * 3 + 1]
      var b_z = vertices[indexB * 3 + 2]
      var c_x = vertices[indexC * 3]
      var c_y = vertices[indexC * 3 + 1]
      var c_z = vertices[indexC * 3 + 2]
      var d_x = vertices[indexD * 3]
      var d_y = vertices[indexD * 3 + 1]
      var d_z = vertices[indexD * 3 + 2]

      if (Math.abs(a_y - b_y) < 0.01) {
        return [
          new Vector2(a_x, 1 - a_z),
          new Vector2(b_x, 1 - b_z),
          new Vector2(c_x, 1 - c_z),
          new Vector2(d_x, 1 - d_z)
        ]
      } else {
        return [
          new Vector2(a_y, 1 - a_z),
          new Vector2(b_y, 1 - b_z),
          new Vector2(c_y, 1 - c_z),
          new Vector2(d_y, 1 - d_z)
        ]
      }
    }
  }

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * @author alteredq / http://alteredqualia.com/
   *
   * Text = 3D Text
   *
   * parameters = {
   *  font: <THREE.Font>, // font
   *
   *  size: <float>, // size of the text
   *  height: <float>, // thickness to extrude text
   *  curveSegments: <int>, // number of points on the curves
   *
   *  bevelEnabled: <bool>, // turn on bevel
   *  bevelThickness: <float>, // how deep into text bevel goes
   *  bevelSize: <float> // how far from text outline is bevel
   * }
   */

  // TextGeometry

  function TextGeometry(text, parameters) {
    Geometry.call(this)

    this.type = 'TextGeometry'

    this.parameters = {
      text: text,
      parameters: parameters
    }

    this.fromBufferGeometry(new TextBufferGeometry(text, parameters))
    this.mergeVertices()
  }

  TextGeometry.prototype = Object.create(Geometry.prototype)
  TextGeometry.prototype.constructor = TextGeometry

  // TextBufferGeometry

  function TextBufferGeometry(text, parameters) {
    parameters = parameters || {}

    var font = parameters.font

    if (!(font && font.isFont)) {
      console.error('THREE.TextGeometry: font parameter is not an instance of THREE.Font.')
      return new Geometry()
    }

    var shapes = font.generateShapes(text, parameters.size, parameters.curveSegments)

    // translate parameters to ExtrudeGeometry API

    parameters.amount = parameters.height !== undefined ? parameters.height : 50

    // defaults

    if (parameters.bevelThickness === undefined) parameters.bevelThickness = 10
    if (parameters.bevelSize === undefined) parameters.bevelSize = 8
    if (parameters.bevelEnabled === undefined) parameters.bevelEnabled = false

    ExtrudeBufferGeometry.call(this, shapes, parameters)

    this.type = 'TextBufferGeometry'
  }

  TextBufferGeometry.prototype = Object.create(ExtrudeBufferGeometry.prototype)
  TextBufferGeometry.prototype.constructor = TextBufferGeometry

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author benaadams / https://twitter.com/ben_a_adams
   * @author Mugen87 / https://github.com/Mugen87
   */

  // SphereGeometry

  function SphereGeometry(
    radius,
    widthSegments,
    heightSegments,
    phiStart,
    phiLength,
    thetaStart,
    thetaLength
  ) {
    Geometry.call(this)

    this.type = 'SphereGeometry'

    this.parameters = {
      radius: radius,
      widthSegments: widthSegments,
      heightSegments: heightSegments,
      phiStart: phiStart,
      phiLength: phiLength,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    this.fromBufferGeometry(
      new SphereBufferGeometry(
        radius,
        widthSegments,
        heightSegments,
        phiStart,
        phiLength,
        thetaStart,
        thetaLength
      )
    )
    this.mergeVertices()
  }

  SphereGeometry.prototype = Object.create(Geometry.prototype)
  SphereGeometry.prototype.constructor = SphereGeometry

  // SphereBufferGeometry

  function SphereBufferGeometry(
    radius,
    widthSegments,
    heightSegments,
    phiStart,
    phiLength,
    thetaStart,
    thetaLength
  ) {
    BufferGeometry.call(this)

    this.type = 'SphereBufferGeometry'

    this.parameters = {
      radius: radius,
      widthSegments: widthSegments,
      heightSegments: heightSegments,
      phiStart: phiStart,
      phiLength: phiLength,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    radius = radius || 1

    widthSegments = Math.max(3, Math.floor(widthSegments) || 8)
    heightSegments = Math.max(2, Math.floor(heightSegments) || 6)

    phiStart = phiStart !== undefined ? phiStart : 0
    phiLength = phiLength !== undefined ? phiLength : Math.PI * 2

    thetaStart = thetaStart !== undefined ? thetaStart : 0
    thetaLength = thetaLength !== undefined ? thetaLength : Math.PI

    var thetaEnd = thetaStart + thetaLength

    var ix, iy

    var index = 0
    var grid = []

    var vertex = new Vector3()
    var normal = new Vector3()

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // generate vertices, normals and uvs

    for (iy = 0; iy <= heightSegments; iy++) {
      var verticesRow = []

      var v = iy / heightSegments

      for (ix = 0; ix <= widthSegments; ix++) {
        var u = ix / widthSegments

        // vertex

        vertex.x =
          -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength)
        vertex.y = radius * Math.cos(thetaStart + v * thetaLength)
        vertex.z =
          radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength)

        vertices.push(vertex.x, vertex.y, vertex.z)

        // normal

        normal.set(vertex.x, vertex.y, vertex.z).normalize()
        normals.push(normal.x, normal.y, normal.z)

        // uv

        uvs.push(u, 1 - v)

        verticesRow.push(index++)
      }

      grid.push(verticesRow)
    }

    // indices

    for (iy = 0; iy < heightSegments; iy++) {
      for (ix = 0; ix < widthSegments; ix++) {
        var a = grid[iy][ix + 1]
        var b = grid[iy][ix]
        var c = grid[iy + 1][ix]
        var d = grid[iy + 1][ix + 1]

        if (iy !== 0 || thetaStart > 0) indices.push(a, b, d)
        if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d)
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))
  }

  SphereBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  SphereBufferGeometry.prototype.constructor = SphereBufferGeometry

  /**
   * @author Kaleb Murphy
   * @author Mugen87 / https://github.com/Mugen87
   */

  // RingGeometry

  function RingGeometry(
    innerRadius,
    outerRadius,
    thetaSegments,
    phiSegments,
    thetaStart,
    thetaLength
  ) {
    Geometry.call(this)

    this.type = 'RingGeometry'

    this.parameters = {
      innerRadius: innerRadius,
      outerRadius: outerRadius,
      thetaSegments: thetaSegments,
      phiSegments: phiSegments,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    this.fromBufferGeometry(
      new RingBufferGeometry(
        innerRadius,
        outerRadius,
        thetaSegments,
        phiSegments,
        thetaStart,
        thetaLength
      )
    )
    this.mergeVertices()
  }

  RingGeometry.prototype = Object.create(Geometry.prototype)
  RingGeometry.prototype.constructor = RingGeometry

  // RingBufferGeometry

  function RingBufferGeometry(
    innerRadius,
    outerRadius,
    thetaSegments,
    phiSegments,
    thetaStart,
    thetaLength
  ) {
    BufferGeometry.call(this)

    this.type = 'RingBufferGeometry'

    this.parameters = {
      innerRadius: innerRadius,
      outerRadius: outerRadius,
      thetaSegments: thetaSegments,
      phiSegments: phiSegments,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    innerRadius = innerRadius || 0.5
    outerRadius = outerRadius || 1

    thetaStart = thetaStart !== undefined ? thetaStart : 0
    thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2

    thetaSegments = thetaSegments !== undefined ? Math.max(3, thetaSegments) : 8
    phiSegments = phiSegments !== undefined ? Math.max(1, phiSegments) : 1

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // some helper variables

    var segment
    var radius = innerRadius
    var radiusStep = (outerRadius - innerRadius) / phiSegments
    var vertex = new Vector3()
    var uv = new Vector2()
    var j, i

    // generate vertices, normals and uvs

    for (j = 0; j <= phiSegments; j++) {
      for (i = 0; i <= thetaSegments; i++) {
        // values are generate from the inside of the ring to the outside

        segment = thetaStart + (i / thetaSegments) * thetaLength

        // vertex

        vertex.x = radius * Math.cos(segment)
        vertex.y = radius * Math.sin(segment)

        vertices.push(vertex.x, vertex.y, vertex.z)

        // normal

        normals.push(0, 0, 1)

        // uv

        uv.x = (vertex.x / outerRadius + 1) / 2
        uv.y = (vertex.y / outerRadius + 1) / 2

        uvs.push(uv.x, uv.y)
      }

      // increase the radius for next row of vertices

      radius += radiusStep
    }

    // indices

    for (j = 0; j < phiSegments; j++) {
      var thetaSegmentLevel = j * (thetaSegments + 1)

      for (i = 0; i < thetaSegments; i++) {
        segment = i + thetaSegmentLevel

        var a = segment
        var b = segment + thetaSegments + 1
        var c = segment + thetaSegments + 2
        var d = segment + 1

        // faces

        indices.push(a, b, d)
        indices.push(b, c, d)
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))
  }

  RingBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  RingBufferGeometry.prototype.constructor = RingBufferGeometry

  /**
   * @author astrodud / http://astrodud.isgreat.org/
   * @author zz85 / https://github.com/zz85
   * @author bhouston / http://clara.io
   * @author Mugen87 / https://github.com/Mugen87
   */

  // LatheGeometry

  function LatheGeometry(points, segments, phiStart, phiLength) {
    Geometry.call(this)

    this.type = 'LatheGeometry'

    this.parameters = {
      points: points,
      segments: segments,
      phiStart: phiStart,
      phiLength: phiLength
    }

    this.fromBufferGeometry(new LatheBufferGeometry(points, segments, phiStart, phiLength))
    this.mergeVertices()
  }

  LatheGeometry.prototype = Object.create(Geometry.prototype)
  LatheGeometry.prototype.constructor = LatheGeometry

  // LatheBufferGeometry

  function LatheBufferGeometry(points, segments, phiStart, phiLength) {
    BufferGeometry.call(this)

    this.type = 'LatheBufferGeometry'

    this.parameters = {
      points: points,
      segments: segments,
      phiStart: phiStart,
      phiLength: phiLength
    }

    segments = Math.floor(segments) || 12
    phiStart = phiStart || 0
    phiLength = phiLength || Math.PI * 2

    // clamp phiLength so it's in range of [ 0, 2PI ]

    phiLength = _Math.clamp(phiLength, 0, Math.PI * 2)

    // buffers

    var indices = []
    var vertices = []
    var uvs = []

    // helper variables

    var base
    var inverseSegments = 1.0 / segments
    var vertex = new Vector3()
    var uv = new Vector2()
    var i, j

    // generate vertices and uvs

    for (i = 0; i <= segments; i++) {
      var phi = phiStart + i * inverseSegments * phiLength

      var sin = Math.sin(phi)
      var cos = Math.cos(phi)

      for (j = 0; j <= points.length - 1; j++) {
        // vertex

        vertex.x = points[j].x * sin
        vertex.y = points[j].y
        vertex.z = points[j].x * cos

        vertices.push(vertex.x, vertex.y, vertex.z)

        // uv

        uv.x = i / segments
        uv.y = j / (points.length - 1)

        uvs.push(uv.x, uv.y)
      }
    }

    // indices

    for (i = 0; i < segments; i++) {
      for (j = 0; j < points.length - 1; j++) {
        base = j + i * points.length

        var a = base
        var b = base + points.length
        var c = base + points.length + 1
        var d = base + 1

        // faces

        indices.push(a, b, d)
        indices.push(b, c, d)
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))

    // generate normals

    this.computeVertexNormals()

    // if the geometry is closed, we need to average the normals along the seam.
    // because the corresponding vertices are identical (but still have different UVs).

    if (phiLength === Math.PI * 2) {
      var normals = this.attributes.normal.array
      var n1 = new Vector3()
      var n2 = new Vector3()
      var n = new Vector3()

      // this is the buffer offset for the last line of vertices

      base = segments * points.length * 3

      for (i = 0, j = 0; i < points.length; i++, j += 3) {
        // select the normal of the vertex in the first line

        n1.x = normals[j + 0]
        n1.y = normals[j + 1]
        n1.z = normals[j + 2]

        // select the normal of the vertex in the last line

        n2.x = normals[base + j + 0]
        n2.y = normals[base + j + 1]
        n2.z = normals[base + j + 2]

        // average normals

        n.addVectors(n1, n2).normalize()

        // assign the new values to both normals

        normals[j + 0] = normals[base + j + 0] = n.x
        normals[j + 1] = normals[base + j + 1] = n.y
        normals[j + 2] = normals[base + j + 2] = n.z
      }
    }
  }

  LatheBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  LatheBufferGeometry.prototype.constructor = LatheBufferGeometry

  /**
   * @author jonobr1 / http://jonobr1.com
   * @author Mugen87 / https://github.com/Mugen87
   */

  // ShapeGeometry

  function ShapeGeometry(shapes, curveSegments) {
    Geometry.call(this)

    this.type = 'ShapeGeometry'

    if (typeof curveSegments === 'object') {
      console.warn('THREE.ShapeGeometry: Options parameter has been removed.')

      curveSegments = curveSegments.curveSegments
    }

    this.parameters = {
      shapes: shapes,
      curveSegments: curveSegments
    }

    this.fromBufferGeometry(new ShapeBufferGeometry(shapes, curveSegments))
    this.mergeVertices()
  }

  ShapeGeometry.prototype = Object.create(Geometry.prototype)
  ShapeGeometry.prototype.constructor = ShapeGeometry

  ShapeGeometry.prototype.toJSON = function () {
    var data = Geometry.prototype.toJSON.call(this)

    var shapes = this.parameters.shapes

    return toJSON(shapes, data)
  }

  // ShapeBufferGeometry

  function ShapeBufferGeometry(shapes, curveSegments) {
    BufferGeometry.call(this)

    this.type = 'ShapeBufferGeometry'

    this.parameters = {
      shapes: shapes,
      curveSegments: curveSegments
    }

    curveSegments = curveSegments || 12

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // helper variables

    var groupStart = 0
    var groupCount = 0

    // allow single and array values for "shapes" parameter

    if (Array.isArray(shapes) === false) {
      addShape(shapes)
    } else {
      for (var i = 0; i < shapes.length; i++) {
        addShape(shapes[i])

        this.addGroup(groupStart, groupCount, i) // enables MultiMaterial support

        groupStart += groupCount
        groupCount = 0
      }
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))

    // helper functions

    function addShape(shape) {
      var i, l, shapeHole

      var indexOffset = vertices.length / 3
      var points = shape.extractPoints(curveSegments)

      var shapeVertices = points.shape
      var shapeHoles = points.holes

      // check direction of vertices

      if (ShapeUtils.isClockWise(shapeVertices) === false) {
        shapeVertices = shapeVertices.reverse()

        // also check if holes are in the opposite direction

        for (i = 0, l = shapeHoles.length; i < l; i++) {
          shapeHole = shapeHoles[i]

          if (ShapeUtils.isClockWise(shapeHole) === true) {
            shapeHoles[i] = shapeHole.reverse()
          }
        }
      }

      var faces = ShapeUtils.triangulateShape(shapeVertices, shapeHoles)

      // join vertices of inner and outer paths to a single array

      for (i = 0, l = shapeHoles.length; i < l; i++) {
        shapeHole = shapeHoles[i]
        shapeVertices = shapeVertices.concat(shapeHole)
      }

      // vertices, normals, uvs

      for (i = 0, l = shapeVertices.length; i < l; i++) {
        var vertex = shapeVertices[i]

        vertices.push(vertex.x, vertex.y, 0)
        normals.push(0, 0, 1)
        uvs.push(vertex.x, vertex.y) // world uvs
      }

      // incides

      for (i = 0, l = faces.length; i < l; i++) {
        var face = faces[i]

        var a = face[0] + indexOffset
        var b = face[1] + indexOffset
        var c = face[2] + indexOffset

        indices.push(a, b, c)
        groupCount += 3
      }
    }
  }

  ShapeBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  ShapeBufferGeometry.prototype.constructor = ShapeBufferGeometry

  ShapeBufferGeometry.prototype.toJSON = function () {
    var data = BufferGeometry.prototype.toJSON.call(this)

    var shapes = this.parameters.shapes

    return toJSON(shapes, data)
  }

  //

  function toJSON(shapes, data) {
    data.shapes = []

    if (Array.isArray(shapes)) {
      for (var i = 0, l = shapes.length; i < l; i++) {
        var shape = shapes[i]

        data.shapes.push(shape.uuid)
      }
    } else {
      data.shapes.push(shapes.uuid)
    }

    return data
  }

  /**
   * @author WestLangley / http://github.com/WestLangley
   * @author Mugen87 / https://github.com/Mugen87
   */

  function EdgesGeometry(geometry, thresholdAngle) {
    BufferGeometry.call(this)

    this.type = 'EdgesGeometry'

    this.parameters = {
      thresholdAngle: thresholdAngle
    }

    thresholdAngle = thresholdAngle !== undefined ? thresholdAngle : 1

    // buffer

    var vertices = []

    // helper variables

    var thresholdDot = Math.cos(_Math.DEG2RAD * thresholdAngle)
    var edge = [0, 0],
      edges = {},
      edge1,
      edge2
    var key,
      keys = ['a', 'b', 'c']

    // prepare source geometry

    var geometry2

    if (geometry.isBufferGeometry) {
      geometry2 = new Geometry()
      geometry2.fromBufferGeometry(geometry)
    } else {
      geometry2 = geometry.clone()
    }

    geometry2.mergeVertices()
    geometry2.computeFaceNormals()

    var sourceVertices = geometry2.vertices
    var faces = geometry2.faces

    // now create a data structure where each entry represents an edge with its adjoining faces

    for (var i = 0, l = faces.length; i < l; i++) {
      var face = faces[i]

      for (var j = 0; j < 3; j++) {
        edge1 = face[keys[j]]
        edge2 = face[keys[(j + 1) % 3]]
        edge[0] = Math.min(edge1, edge2)
        edge[1] = Math.max(edge1, edge2)

        key = edge[0] + ',' + edge[1]

        if (edges[key] === undefined) {
          edges[key] = { index1: edge[0], index2: edge[1], face1: i, face2: undefined }
        } else {
          edges[key].face2 = i
        }
      }
    }

    // generate vertices

    for (key in edges) {
      var e = edges[key]

      // an edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value. default = 1 degree.

      if (
        e.face2 === undefined ||
        faces[e.face1].normal.dot(faces[e.face2].normal) <= thresholdDot
      ) {
        var vertex = sourceVertices[e.index1]
        vertices.push(vertex.x, vertex.y, vertex.z)

        vertex = sourceVertices[e.index2]
        vertices.push(vertex.x, vertex.y, vertex.z)
      }
    }

    // build geometry

    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
  }

  EdgesGeometry.prototype = Object.create(BufferGeometry.prototype)
  EdgesGeometry.prototype.constructor = EdgesGeometry

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / https://github.com/Mugen87
   */

  // CylinderGeometry

  function CylinderGeometry(
    radiusTop,
    radiusBottom,
    height,
    radialSegments,
    heightSegments,
    openEnded,
    thetaStart,
    thetaLength
  ) {
    Geometry.call(this)

    this.type = 'CylinderGeometry'

    this.parameters = {
      radiusTop: radiusTop,
      radiusBottom: radiusBottom,
      height: height,
      radialSegments: radialSegments,
      heightSegments: heightSegments,
      openEnded: openEnded,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    this.fromBufferGeometry(
      new CylinderBufferGeometry(
        radiusTop,
        radiusBottom,
        height,
        radialSegments,
        heightSegments,
        openEnded,
        thetaStart,
        thetaLength
      )
    )
    this.mergeVertices()
  }

  CylinderGeometry.prototype = Object.create(Geometry.prototype)
  CylinderGeometry.prototype.constructor = CylinderGeometry

  // CylinderBufferGeometry

  function CylinderBufferGeometry(
    radiusTop,
    radiusBottom,
    height,
    radialSegments,
    heightSegments,
    openEnded,
    thetaStart,
    thetaLength
  ) {
    BufferGeometry.call(this)

    this.type = 'CylinderBufferGeometry'

    this.parameters = {
      radiusTop: radiusTop,
      radiusBottom: radiusBottom,
      height: height,
      radialSegments: radialSegments,
      heightSegments: heightSegments,
      openEnded: openEnded,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    var scope = this

    radiusTop = radiusTop !== undefined ? radiusTop : 1
    radiusBottom = radiusBottom !== undefined ? radiusBottom : 1
    height = height || 1

    radialSegments = Math.floor(radialSegments) || 8
    heightSegments = Math.floor(heightSegments) || 1

    openEnded = openEnded !== undefined ? openEnded : false
    thetaStart = thetaStart !== undefined ? thetaStart : 0.0
    thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // helper variables

    var index = 0
    var indexArray = []
    var halfHeight = height / 2
    var groupStart = 0

    // generate geometry

    generateTorso()

    if (openEnded === false) {
      if (radiusTop > 0) generateCap(true)
      if (radiusBottom > 0) generateCap(false)
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))

    function generateTorso() {
      var x, y
      var normal = new Vector3()
      var vertex = new Vector3()

      var groupCount = 0

      // this will be used to calculate the normal
      var slope = (radiusBottom - radiusTop) / height

      // generate vertices, normals and uvs

      for (y = 0; y <= heightSegments; y++) {
        var indexRow = []

        var v = y / heightSegments

        // calculate the radius of the current row

        var radius = v * (radiusBottom - radiusTop) + radiusTop

        for (x = 0; x <= radialSegments; x++) {
          var u = x / radialSegments

          var theta = u * thetaLength + thetaStart

          var sinTheta = Math.sin(theta)
          var cosTheta = Math.cos(theta)

          // vertex

          vertex.x = radius * sinTheta
          vertex.y = -v * height + halfHeight
          vertex.z = radius * cosTheta
          vertices.push(vertex.x, vertex.y, vertex.z)

          // normal

          normal.set(sinTheta, slope, cosTheta).normalize()
          normals.push(normal.x, normal.y, normal.z)

          // uv

          uvs.push(u, 1 - v)

          // save index of vertex in respective row

          indexRow.push(index++)
        }

        // now save vertices of the row in our index array

        indexArray.push(indexRow)
      }

      // generate indices

      for (x = 0; x < radialSegments; x++) {
        for (y = 0; y < heightSegments; y++) {
          // we use the index array to access the correct indices

          var a = indexArray[y][x]
          var b = indexArray[y + 1][x]
          var c = indexArray[y + 1][x + 1]
          var d = indexArray[y][x + 1]

          // faces

          indices.push(a, b, d)
          indices.push(b, c, d)

          // update group counter

          groupCount += 6
        }
      }

      // add a group to the geometry. this will ensure multi material support

      scope.addGroup(groupStart, groupCount, 0)

      // calculate new start value for groups

      groupStart += groupCount
    }

    function generateCap(top) {
      var x, centerIndexStart, centerIndexEnd

      var uv = new Vector2()
      var vertex = new Vector3()

      var groupCount = 0

      var radius = top === true ? radiusTop : radiusBottom
      var sign = top === true ? 1 : -1

      // save the index of the first center vertex
      centerIndexStart = index

      // first we generate the center vertex data of the cap.
      // because the geometry needs one set of uvs per face,
      // we must generate a center vertex per face/segment

      for (x = 1; x <= radialSegments; x++) {
        // vertex

        vertices.push(0, halfHeight * sign, 0)

        // normal

        normals.push(0, sign, 0)

        // uv

        uvs.push(0.5, 0.5)

        // increase index

        index++
      }

      // save the index of the last center vertex

      centerIndexEnd = index

      // now we generate the surrounding vertices, normals and uvs

      for (x = 0; x <= radialSegments; x++) {
        var u = x / radialSegments
        var theta = u * thetaLength + thetaStart

        var cosTheta = Math.cos(theta)
        var sinTheta = Math.sin(theta)

        // vertex

        vertex.x = radius * sinTheta
        vertex.y = halfHeight * sign
        vertex.z = radius * cosTheta
        vertices.push(vertex.x, vertex.y, vertex.z)

        // normal

        normals.push(0, sign, 0)

        // uv

        uv.x = cosTheta * 0.5 + 0.5
        uv.y = sinTheta * 0.5 * sign + 0.5
        uvs.push(uv.x, uv.y)

        // increase index

        index++
      }

      // generate indices

      for (x = 0; x < radialSegments; x++) {
        var c = centerIndexStart + x
        var i = centerIndexEnd + x

        if (top === true) {
          // face top

          indices.push(i, i + 1, c)
        } else {
          // face bottom

          indices.push(i + 1, i, c)
        }

        groupCount += 3
      }

      // add a group to the geometry. this will ensure multi material support

      scope.addGroup(groupStart, groupCount, top === true ? 1 : 2)

      // calculate new start value for groups

      groupStart += groupCount
    }
  }

  CylinderBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  CylinderBufferGeometry.prototype.constructor = CylinderBufferGeometry

  /**
   * @author abelnation / http://github.com/abelnation
   */

  // ConeGeometry

  function ConeGeometry(
    radius,
    height,
    radialSegments,
    heightSegments,
    openEnded,
    thetaStart,
    thetaLength
  ) {
    CylinderGeometry.call(
      this,
      0,
      radius,
      height,
      radialSegments,
      heightSegments,
      openEnded,
      thetaStart,
      thetaLength
    )

    this.type = 'ConeGeometry'

    this.parameters = {
      radius: radius,
      height: height,
      radialSegments: radialSegments,
      heightSegments: heightSegments,
      openEnded: openEnded,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }
  }

  ConeGeometry.prototype = Object.create(CylinderGeometry.prototype)
  ConeGeometry.prototype.constructor = ConeGeometry

  // ConeBufferGeometry

  function ConeBufferGeometry(
    radius,
    height,
    radialSegments,
    heightSegments,
    openEnded,
    thetaStart,
    thetaLength
  ) {
    CylinderBufferGeometry.call(
      this,
      0,
      radius,
      height,
      radialSegments,
      heightSegments,
      openEnded,
      thetaStart,
      thetaLength
    )

    this.type = 'ConeBufferGeometry'

    this.parameters = {
      radius: radius,
      height: height,
      radialSegments: radialSegments,
      heightSegments: heightSegments,
      openEnded: openEnded,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }
  }

  ConeBufferGeometry.prototype = Object.create(CylinderBufferGeometry.prototype)
  ConeBufferGeometry.prototype.constructor = ConeBufferGeometry

  /**
   * @author benaadams / https://twitter.com/ben_a_adams
   * @author Mugen87 / https://github.com/Mugen87
   * @author hughes
   */

  // CircleGeometry

  function CircleGeometry(radius, segments, thetaStart, thetaLength) {
    Geometry.call(this)

    this.type = 'CircleGeometry'

    this.parameters = {
      radius: radius,
      segments: segments,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    this.fromBufferGeometry(new CircleBufferGeometry(radius, segments, thetaStart, thetaLength))
    this.mergeVertices()
  }

  CircleGeometry.prototype = Object.create(Geometry.prototype)
  CircleGeometry.prototype.constructor = CircleGeometry

  // CircleBufferGeometry

  function CircleBufferGeometry(radius, segments, thetaStart, thetaLength) {
    BufferGeometry.call(this)

    this.type = 'CircleBufferGeometry'

    this.parameters = {
      radius: radius,
      segments: segments,
      thetaStart: thetaStart,
      thetaLength: thetaLength
    }

    radius = radius || 1
    segments = segments !== undefined ? Math.max(3, segments) : 8

    thetaStart = thetaStart !== undefined ? thetaStart : 0
    thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2

    // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []

    // helper variables

    var i, s
    var vertex = new Vector3()
    var uv = new Vector2()

    // center point

    vertices.push(0, 0, 0)
    normals.push(0, 0, 1)
    uvs.push(0.5, 0.5)

    for (s = 0, i = 3; s <= segments; s++, i += 3) {
      var segment = thetaStart + (s / segments) * thetaLength

      // vertex

      vertex.x = radius * Math.cos(segment)
      vertex.y = radius * Math.sin(segment)

      vertices.push(vertex.x, vertex.y, vertex.z)

      // normal

      normals.push(0, 0, 1)

      // uvs

      uv.x = (vertices[i] / radius + 1) / 2
      uv.y = (vertices[i + 1] / radius + 1) / 2

      uvs.push(uv.x, uv.y)
    }

    // indices

    for (i = 1; i <= segments; i++) {
      indices.push(i, i + 1, 0)
    }

    // build geometry

    this.setIndex(indices)
    this.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.addAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.addAttribute('uv', new Float32BufferAttribute(uvs, 2))
  }

  CircleBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  CircleBufferGeometry.prototype.constructor = CircleBufferGeometry

  var Geometries = Object.freeze({
    WireframeGeometry: WireframeGeometry,
    ParametricGeometry: ParametricGeometry,
    ParametricBufferGeometry: ParametricBufferGeometry,
    TetrahedronGeometry: TetrahedronGeometry,
    TetrahedronBufferGeometry: TetrahedronBufferGeometry,
    OctahedronGeometry: OctahedronGeometry,
    OctahedronBufferGeometry: OctahedronBufferGeometry,
    IcosahedronGeometry: IcosahedronGeometry,
    IcosahedronBufferGeometry: IcosahedronBufferGeometry,
    DodecahedronGeometry: DodecahedronGeometry,
    DodecahedronBufferGeometry: DodecahedronBufferGeometry,
    PolyhedronGeometry: PolyhedronGeometry,
    PolyhedronBufferGeometry: PolyhedronBufferGeometry,
    TubeGeometry: TubeGeometry,
    TubeBufferGeometry: TubeBufferGeometry,
    TorusKnotGeometry: TorusKnotGeometry,
    TorusKnotBufferGeometry: TorusKnotBufferGeometry,
    TorusGeometry: TorusGeometry,
    TorusBufferGeometry: TorusBufferGeometry,
    TextGeometry: TextGeometry,
    TextBufferGeometry: TextBufferGeometry,
    SphereGeometry: SphereGeometry,
    SphereBufferGeometry: SphereBufferGeometry,
    RingGeometry: RingGeometry,
    RingBufferGeometry: RingBufferGeometry,
    PlaneGeometry: PlaneGeometry,
    PlaneBufferGeometry: PlaneBufferGeometry,
    LatheGeometry: LatheGeometry,
    LatheBufferGeometry: LatheBufferGeometry,
    ShapeGeometry: ShapeGeometry,
    ShapeBufferGeometry: ShapeBufferGeometry,
    ExtrudeGeometry: ExtrudeGeometry,
    ExtrudeBufferGeometry: ExtrudeBufferGeometry,
    EdgesGeometry: EdgesGeometry,
    ConeGeometry: ConeGeometry,
    ConeBufferGeometry: ConeBufferGeometry,
    CylinderGeometry: CylinderGeometry,
    CylinderBufferGeometry: CylinderBufferGeometry,
    CircleGeometry: CircleGeometry,
    CircleBufferGeometry: CircleBufferGeometry,
    BoxGeometry: BoxGeometry,
    BoxBufferGeometry: BoxBufferGeometry
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   *
   * parameters = {
   *  color: <THREE.Color>,
   *  opacity: <float>
   * }
   */

  function ShadowMaterial(parameters) {
    Material.call(this)

    this.type = 'ShadowMaterial'

    this.color = new Color(0x000000)
    this.opacity = 1.0

    this.lights = true
    this.transparent = true

    this.setValues(parameters)
  }

  ShadowMaterial.prototype = Object.create(Material.prototype)
  ShadowMaterial.prototype.constructor = ShadowMaterial

  ShadowMaterial.prototype.isShadowMaterial = true

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function RawShaderMaterial(parameters) {
    ShaderMaterial.call(this, parameters)

    this.type = 'RawShaderMaterial'
  }

  RawShaderMaterial.prototype = Object.create(ShaderMaterial.prototype)
  RawShaderMaterial.prototype.constructor = RawShaderMaterial

  RawShaderMaterial.prototype.isRawShaderMaterial = true

  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   * parameters = {
   *  color: <hex>,
   *  roughness: <float>,
   *  metalness: <float>,
   *  opacity: <float>,
   *
   *  map: new THREE.Texture( <Image> ),
   *
   *  lightMap: new THREE.Texture( <Image> ),
   *  lightMapIntensity: <float>
   *
   *  aoMap: new THREE.Texture( <Image> ),
   *  aoMapIntensity: <float>
   *
   *  emissive: <hex>,
   *  emissiveIntensity: <float>
   *  emissiveMap: new THREE.Texture( <Image> ),
   *
   *  bumpMap: new THREE.Texture( <Image> ),
   *  bumpScale: <float>,
   *
   *  normalMap: new THREE.Texture( <Image> ),
   *  normalScale: <Vector2>,
   *
   *  displacementMap: new THREE.Texture( <Image> ),
   *  displacementScale: <float>,
   *  displacementBias: <float>,
   *
   *  roughnessMap: new THREE.Texture( <Image> ),
   *
   *  metalnessMap: new THREE.Texture( <Image> ),
   *
   *  alphaMap: new THREE.Texture( <Image> ),
   *
   *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
   *  envMapIntensity: <float>
   *
   *  refractionRatio: <float>,
   *
   *  wireframe: <boolean>,
   *  wireframeLinewidth: <float>,
   *
   *  skinning: <bool>,
   *  morphTargets: <bool>,
   *  morphNormals: <bool>
   * }
   */

  function MeshStandardMaterial(parameters) {
    Material.call(this)

    this.defines = { STANDARD: '' }

    this.type = 'MeshStandardMaterial'

    this.color = new Color(0xffffff) // diffuse
    this.roughness = 0.5
    this.metalness = 0.5

    this.map = null

    this.lightMap = null
    this.lightMapIntensity = 1.0

    this.aoMap = null
    this.aoMapIntensity = 1.0

    this.emissive = new Color(0x000000)
    this.emissiveIntensity = 1.0
    this.emissiveMap = null

    this.bumpMap = null
    this.bumpScale = 1

    this.normalMap = null
    this.normalScale = new Vector2(1, 1)

    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0

    this.roughnessMap = null

    this.metalnessMap = null

    this.alphaMap = null

    this.envMap = null
    this.envMapIntensity = 1.0

    this.refractionRatio = 0.98

    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'

    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false

    this.setValues(parameters)
  }

  MeshStandardMaterial.prototype = Object.create(Material.prototype)
  MeshStandardMaterial.prototype.constructor = MeshStandardMaterial

  MeshStandardMaterial.prototype.isMeshStandardMaterial = true

  MeshStandardMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.defines = { STANDARD: '' }

    this.color.copy(source.color)
    this.roughness = source.roughness
    this.metalness = source.metalness

    this.map = source.map

    this.lightMap = source.lightMap
    this.lightMapIntensity = source.lightMapIntensity

    this.aoMap = source.aoMap
    this.aoMapIntensity = source.aoMapIntensity

    this.emissive.copy(source.emissive)
    this.emissiveMap = source.emissiveMap
    this.emissiveIntensity = source.emissiveIntensity

    this.bumpMap = source.bumpMap
    this.bumpScale = source.bumpScale

    this.normalMap = source.normalMap
    this.normalScale.copy(source.normalScale)

    this.displacementMap = source.displacementMap
    this.displacementScale = source.displacementScale
    this.displacementBias = source.displacementBias

    this.roughnessMap = source.roughnessMap

    this.metalnessMap = source.metalnessMap

    this.alphaMap = source.alphaMap

    this.envMap = source.envMap
    this.envMapIntensity = source.envMapIntensity

    this.refractionRatio = source.refractionRatio

    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth
    this.wireframeLinecap = source.wireframeLinecap
    this.wireframeLinejoin = source.wireframeLinejoin

    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals

    return this
  }

  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   * parameters = {
   *  reflectivity: <float>
   * }
   */

  function MeshPhysicalMaterial(parameters) {
    MeshStandardMaterial.call(this)

    this.defines = { PHYSICAL: '' }

    this.type = 'MeshPhysicalMaterial'

    this.reflectivity = 0.5 // maps to F0 = 0.04

    this.clearCoat = 0.0
    this.clearCoatRoughness = 0.0

    this.setValues(parameters)
  }

  MeshPhysicalMaterial.prototype = Object.create(MeshStandardMaterial.prototype)
  MeshPhysicalMaterial.prototype.constructor = MeshPhysicalMaterial

  MeshPhysicalMaterial.prototype.isMeshPhysicalMaterial = true

  MeshPhysicalMaterial.prototype.copy = function (source) {
    MeshStandardMaterial.prototype.copy.call(this, source)

    this.defines = { PHYSICAL: '' }

    this.reflectivity = source.reflectivity

    this.clearCoat = source.clearCoat
    this.clearCoatRoughness = source.clearCoatRoughness

    return this
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  color: <hex>,
   *  specular: <hex>,
   *  shininess: <float>,
   *  opacity: <float>,
   *
   *  map: new THREE.Texture( <Image> ),
   *
   *  lightMap: new THREE.Texture( <Image> ),
   *  lightMapIntensity: <float>
   *
   *  aoMap: new THREE.Texture( <Image> ),
   *  aoMapIntensity: <float>
   *
   *  emissive: <hex>,
   *  emissiveIntensity: <float>
   *  emissiveMap: new THREE.Texture( <Image> ),
   *
   *  bumpMap: new THREE.Texture( <Image> ),
   *  bumpScale: <float>,
   *
   *  normalMap: new THREE.Texture( <Image> ),
   *  normalScale: <Vector2>,
   *
   *  displacementMap: new THREE.Texture( <Image> ),
   *  displacementScale: <float>,
   *  displacementBias: <float>,
   *
   *  specularMap: new THREE.Texture( <Image> ),
   *
   *  alphaMap: new THREE.Texture( <Image> ),
   *
   *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
   *  combine: THREE.Multiply,
   *  reflectivity: <float>,
   *  refractionRatio: <float>,
   *
   *  wireframe: <boolean>,
   *  wireframeLinewidth: <float>,
   *
   *  skinning: <bool>,
   *  morphTargets: <bool>,
   *  morphNormals: <bool>
   * }
   */

  function MeshPhongMaterial(parameters) {
    Material.call(this)

    this.type = 'MeshPhongMaterial'

    this.color = new Color(0xffffff) // diffuse
    this.specular = new Color(0x111111)
    this.shininess = 30

    this.map = null

    this.lightMap = null
    this.lightMapIntensity = 1.0

    this.aoMap = null
    this.aoMapIntensity = 1.0

    this.emissive = new Color(0x000000)
    this.emissiveIntensity = 1.0
    this.emissiveMap = null

    this.bumpMap = null
    this.bumpScale = 1

    this.normalMap = null
    this.normalScale = new Vector2(1, 1)

    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0

    this.specularMap = null

    this.alphaMap = null

    this.envMap = null
    this.combine = MultiplyOperation
    this.reflectivity = 1
    this.refractionRatio = 0.98

    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'

    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false

    this.setValues(parameters)
  }

  MeshPhongMaterial.prototype = Object.create(Material.prototype)
  MeshPhongMaterial.prototype.constructor = MeshPhongMaterial

  MeshPhongMaterial.prototype.isMeshPhongMaterial = true

  MeshPhongMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.color.copy(source.color)
    this.specular.copy(source.specular)
    this.shininess = source.shininess

    this.map = source.map

    this.lightMap = source.lightMap
    this.lightMapIntensity = source.lightMapIntensity

    this.aoMap = source.aoMap
    this.aoMapIntensity = source.aoMapIntensity

    this.emissive.copy(source.emissive)
    this.emissiveMap = source.emissiveMap
    this.emissiveIntensity = source.emissiveIntensity

    this.bumpMap = source.bumpMap
    this.bumpScale = source.bumpScale

    this.normalMap = source.normalMap
    this.normalScale.copy(source.normalScale)

    this.displacementMap = source.displacementMap
    this.displacementScale = source.displacementScale
    this.displacementBias = source.displacementBias

    this.specularMap = source.specularMap

    this.alphaMap = source.alphaMap

    this.envMap = source.envMap
    this.combine = source.combine
    this.reflectivity = source.reflectivity
    this.refractionRatio = source.refractionRatio

    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth
    this.wireframeLinecap = source.wireframeLinecap
    this.wireframeLinejoin = source.wireframeLinejoin

    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals

    return this
  }

  /**
   * @author takahirox / http://github.com/takahirox
   *
   * parameters = {
   *  gradientMap: new THREE.Texture( <Image> )
   * }
   */

  function MeshToonMaterial(parameters) {
    MeshPhongMaterial.call(this)

    this.defines = { TOON: '' }

    this.type = 'MeshToonMaterial'

    this.gradientMap = null

    this.setValues(parameters)
  }

  MeshToonMaterial.prototype = Object.create(MeshPhongMaterial.prototype)
  MeshToonMaterial.prototype.constructor = MeshToonMaterial

  MeshToonMaterial.prototype.isMeshToonMaterial = true

  MeshToonMaterial.prototype.copy = function (source) {
    MeshPhongMaterial.prototype.copy.call(this, source)

    this.gradientMap = source.gradientMap

    return this
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author WestLangley / http://github.com/WestLangley
   *
   * parameters = {
   *  opacity: <float>,
   *
   *  bumpMap: new THREE.Texture( <Image> ),
   *  bumpScale: <float>,
   *
   *  normalMap: new THREE.Texture( <Image> ),
   *  normalScale: <Vector2>,
   *
   *  displacementMap: new THREE.Texture( <Image> ),
   *  displacementScale: <float>,
   *  displacementBias: <float>,
   *
   *  wireframe: <boolean>,
   *  wireframeLinewidth: <float>
   *
   *  skinning: <bool>,
   *  morphTargets: <bool>,
   *  morphNormals: <bool>
   * }
   */

  function MeshNormalMaterial(parameters) {
    Material.call(this)

    this.type = 'MeshNormalMaterial'

    this.bumpMap = null
    this.bumpScale = 1

    this.normalMap = null
    this.normalScale = new Vector2(1, 1)

    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0

    this.wireframe = false
    this.wireframeLinewidth = 1

    this.fog = false
    this.lights = false

    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false

    this.setValues(parameters)
  }

  MeshNormalMaterial.prototype = Object.create(Material.prototype)
  MeshNormalMaterial.prototype.constructor = MeshNormalMaterial

  MeshNormalMaterial.prototype.isMeshNormalMaterial = true

  MeshNormalMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.bumpMap = source.bumpMap
    this.bumpScale = source.bumpScale

    this.normalMap = source.normalMap
    this.normalScale.copy(source.normalScale)

    this.displacementMap = source.displacementMap
    this.displacementScale = source.displacementScale
    this.displacementBias = source.displacementBias

    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth

    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals

    return this
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  color: <hex>,
   *  opacity: <float>,
   *
   *  map: new THREE.Texture( <Image> ),
   *
   *  lightMap: new THREE.Texture( <Image> ),
   *  lightMapIntensity: <float>
   *
   *  aoMap: new THREE.Texture( <Image> ),
   *  aoMapIntensity: <float>
   *
   *  emissive: <hex>,
   *  emissiveIntensity: <float>
   *  emissiveMap: new THREE.Texture( <Image> ),
   *
   *  specularMap: new THREE.Texture( <Image> ),
   *
   *  alphaMap: new THREE.Texture( <Image> ),
   *
   *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
   *  combine: THREE.Multiply,
   *  reflectivity: <float>,
   *  refractionRatio: <float>,
   *
   *  wireframe: <boolean>,
   *  wireframeLinewidth: <float>,
   *
   *  skinning: <bool>,
   *  morphTargets: <bool>,
   *  morphNormals: <bool>
   * }
   */

  function MeshLambertMaterial(parameters) {
    Material.call(this)

    this.type = 'MeshLambertMaterial'

    this.color = new Color(0xffffff) // diffuse

    this.map = null

    this.lightMap = null
    this.lightMapIntensity = 1.0

    this.aoMap = null
    this.aoMapIntensity = 1.0

    this.emissive = new Color(0x000000)
    this.emissiveIntensity = 1.0
    this.emissiveMap = null

    this.specularMap = null

    this.alphaMap = null

    this.envMap = null
    this.combine = MultiplyOperation
    this.reflectivity = 1
    this.refractionRatio = 0.98

    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'

    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false

    this.setValues(parameters)
  }

  MeshLambertMaterial.prototype = Object.create(Material.prototype)
  MeshLambertMaterial.prototype.constructor = MeshLambertMaterial

  MeshLambertMaterial.prototype.isMeshLambertMaterial = true

  MeshLambertMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)

    this.color.copy(source.color)

    this.map = source.map

    this.lightMap = source.lightMap
    this.lightMapIntensity = source.lightMapIntensity

    this.aoMap = source.aoMap
    this.aoMapIntensity = source.aoMapIntensity

    this.emissive.copy(source.emissive)
    this.emissiveMap = source.emissiveMap
    this.emissiveIntensity = source.emissiveIntensity

    this.specularMap = source.specularMap

    this.alphaMap = source.alphaMap

    this.envMap = source.envMap
    this.combine = source.combine
    this.reflectivity = source.reflectivity
    this.refractionRatio = source.refractionRatio

    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth
    this.wireframeLinecap = source.wireframeLinecap
    this.wireframeLinejoin = source.wireframeLinejoin

    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals

    return this
  }

  /**
   * @author alteredq / http://alteredqualia.com/
   *
   * parameters = {
   *  color: <hex>,
   *  opacity: <float>,
   *
   *  linewidth: <float>,
   *
   *  scale: <float>,
   *  dashSize: <float>,
   *  gapSize: <float>
   * }
   */

  function LineDashedMaterial(parameters) {
    LineBasicMaterial.call(this)

    this.type = 'LineDashedMaterial'

    this.scale = 1
    this.dashSize = 3
    this.gapSize = 1

    this.setValues(parameters)
  }

  LineDashedMaterial.prototype = Object.create(LineBasicMaterial.prototype)
  LineDashedMaterial.prototype.constructor = LineDashedMaterial

  LineDashedMaterial.prototype.isLineDashedMaterial = true

  LineDashedMaterial.prototype.copy = function (source) {
    LineBasicMaterial.prototype.copy.call(this, source)

    this.scale = source.scale
    this.dashSize = source.dashSize
    this.gapSize = source.gapSize

    return this
  }

  var Materials = Object.freeze({
    ShadowMaterial: ShadowMaterial,
    SpriteMaterial: SpriteMaterial,
    RawShaderMaterial: RawShaderMaterial,
    ShaderMaterial: ShaderMaterial,
    PointsMaterial: PointsMaterial,
    MeshPhysicalMaterial: MeshPhysicalMaterial,
    MeshStandardMaterial: MeshStandardMaterial,
    MeshPhongMaterial: MeshPhongMaterial,
    MeshToonMaterial: MeshToonMaterial,
    MeshNormalMaterial: MeshNormalMaterial,
    MeshLambertMaterial: MeshLambertMaterial,
    MeshDepthMaterial: MeshDepthMaterial,
    MeshDistanceMaterial: MeshDistanceMaterial,
    MeshBasicMaterial: MeshBasicMaterial,
    LineDashedMaterial: LineDashedMaterial,
    LineBasicMaterial: LineBasicMaterial,
    Material: Material
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  var Cache = {
    enabled: false,

    files: {},

    add: function (key, file) {
      if (this.enabled === false) return

      // console.log( 'THREE.Cache', 'Adding key:', key );

      this.files[key] = file
    },

    get: function (key) {
      if (this.enabled === false) return

      // console.log( 'THREE.Cache', 'Checking key:', key );

      return this.files[key]
    },

    remove: function (key) {
      delete this.files[key]
    },

    clear: function () {
      this.files = {}
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function LoadingManager(onLoad, onProgress, onError) {
    var scope = this

    var isLoading = false
    var itemsLoaded = 0
    var itemsTotal = 0
    var urlModifier = undefined

    this.onStart = undefined
    this.onLoad = onLoad
    this.onProgress = onProgress
    this.onError = onError

    this.itemStart = function (url) {
      itemsTotal++

      if (isLoading === false) {
        if (scope.onStart !== undefined) {
          scope.onStart(url, itemsLoaded, itemsTotal)
        }
      }

      isLoading = true
    }

    this.itemEnd = function (url) {
      itemsLoaded++

      if (scope.onProgress !== undefined) {
        scope.onProgress(url, itemsLoaded, itemsTotal)
      }

      if (itemsLoaded === itemsTotal) {
        isLoading = false

        if (scope.onLoad !== undefined) {
          scope.onLoad()
        }
      }
    }

    this.itemError = function (url) {
      if (scope.onError !== undefined) {
        scope.onError(url)
      }
    }

    this.resolveURL = function (url) {
      if (urlModifier) {
        return urlModifier(url)
      }

      return url
    }

    this.setURLModifier = function (transform) {
      urlModifier = transform
      return this
    }
  }

  var DefaultLoadingManager = new LoadingManager()

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  var loading = {}

  function FileLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
  }

  Object.assign(FileLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      if (url === undefined) url = ''

      if (this.path !== undefined) url = this.path + url

      url = this.manager.resolveURL(url)

      var scope = this

      var cached = Cache.get(url)

      if (cached !== undefined) {
        scope.manager.itemStart(url)

        setTimeout(function () {
          if (onLoad) onLoad(cached)

          scope.manager.itemEnd(url)
        }, 0)

        return cached
      }

      // Check if request is duplicate

      if (loading[url] !== undefined) {
        loading[url].push({
          onLoad: onLoad,
          onProgress: onProgress,
          onError: onError
        })

        return
      }

      // Check for data: URI
      var dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/
      var dataUriRegexResult = url.match(dataUriRegex)

      // Safari can not handle Data URIs through XMLHttpRequest so process manually
      if (dataUriRegexResult) {
        var mimeType = dataUriRegexResult[1]
        var isBase64 = !!dataUriRegexResult[2]
        var data = dataUriRegexResult[3]

        data = window.decodeURIComponent(data)

        if (isBase64) data = window.atob(data)

        try {
          var response
          var responseType = (this.responseType || '').toLowerCase()

          switch (responseType) {
            case 'arraybuffer':
            case 'blob':
              var view = new Uint8Array(data.length)

              for (var i = 0; i < data.length; i++) {
                view[i] = data.charCodeAt(i)
              }

              if (responseType === 'blob') {
                response = new Blob([view.buffer], { type: mimeType })
              } else {
                response = view.buffer
              }

              break

            case 'document':
              var parser = new DOMParser()
              response = parser.parseFromString(data, mimeType)

              break

            case 'json':
              response = JSON.parse(data)

              break

            default: // 'text' or other
              response = data

              break
          }

          // Wait for next browser tick like standard XMLHttpRequest event dispatching does
          window.setTimeout(function () {
            if (onLoad) onLoad(response)

            scope.manager.itemEnd(url)
          }, 0)
        } catch (error) {
          // Wait for next browser tick like standard XMLHttpRequest event dispatching does
          window.setTimeout(function () {
            if (onError) onError(error)

            scope.manager.itemEnd(url)
            scope.manager.itemError(url)
          }, 0)
        }
      } else {
        // Initialise array for duplicate requests

        loading[url] = []

        loading[url].push({
          onLoad: onLoad,
          onProgress: onProgress,
          onError: onError
        })

        var request = new XMLHttpRequest()

        request.open('GET', url, true)

        request.addEventListener(
          'load',
          function (event) {
            var response = this.response

            Cache.add(url, response)

            var callbacks = loading[url]

            delete loading[url]

            if (this.status === 200) {
              for (var i = 0, il = callbacks.length; i < il; i++) {
                var callback = callbacks[i]
                if (callback.onLoad) callback.onLoad(response)
              }

              scope.manager.itemEnd(url)
            } else if (this.status === 0) {
              // Some browsers return HTTP Status 0 when using non-http protocol
              // e.g. 'file://' or 'data://'. Handle as success.

              console.warn('THREE.FileLoader: HTTP Status 0 received.')

              for (var i = 0, il = callbacks.length; i < il; i++) {
                var callback = callbacks[i]
                if (callback.onLoad) callback.onLoad(response)
              }

              scope.manager.itemEnd(url)
            } else {
              for (var i = 0, il = callbacks.length; i < il; i++) {
                var callback = callbacks[i]
                if (callback.onError) callback.onError(event)
              }

              scope.manager.itemEnd(url)
              scope.manager.itemError(url)
            }
          },
          false
        )

        request.addEventListener(
          'progress',
          function (event) {
            var callbacks = loading[url]

            for (var i = 0, il = callbacks.length; i < il; i++) {
              var callback = callbacks[i]
              if (callback.onProgress) callback.onProgress(event)
            }
          },
          false
        )

        request.addEventListener(
          'error',
          function (event) {
            var callbacks = loading[url]

            delete loading[url]

            for (var i = 0, il = callbacks.length; i < il; i++) {
              var callback = callbacks[i]
              if (callback.onError) callback.onError(event)
            }

            scope.manager.itemEnd(url)
            scope.manager.itemError(url)
          },
          false
        )

        if (this.responseType !== undefined) request.responseType = this.responseType
        if (this.withCredentials !== undefined) request.withCredentials = this.withCredentials

        if (request.overrideMimeType)
          request.overrideMimeType(this.mimeType !== undefined ? this.mimeType : 'text/plain')

        for (var header in this.requestHeader) {
          request.setRequestHeader(header, this.requestHeader[header])
        }

        request.send(null)
      }

      scope.manager.itemStart(url)

      return request
    },

    setPath: function (value) {
      this.path = value
      return this
    },

    setResponseType: function (value) {
      this.responseType = value
      return this
    },

    setWithCredentials: function (value) {
      this.withCredentials = value
      return this
    },

    setMimeType: function (value) {
      this.mimeType = value
      return this
    },

    setRequestHeader: function (value) {
      this.requestHeader = value
      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   *
   * Abstract Base class to block based textures loader (dds, pvr, ...)
   */

  function CompressedTextureLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager

    // override in sub classes
    this._parser = null
  }

  Object.assign(CompressedTextureLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      var scope = this

      var images = []

      var texture = new CompressedTexture()
      texture.image = images

      var loader = new FileLoader(this.manager)
      loader.setPath(this.path)
      loader.setResponseType('arraybuffer')

      function loadTexture(i) {
        loader.load(
          url[i],
          function (buffer) {
            var texDatas = scope._parser(buffer, true)

            images[i] = {
              width: texDatas.width,
              height: texDatas.height,
              format: texDatas.format,
              mipmaps: texDatas.mipmaps
            }

            loaded += 1

            if (loaded === 6) {
              if (texDatas.mipmapCount === 1) texture.minFilter = LinearFilter

              texture.format = texDatas.format
              texture.needsUpdate = true

              if (onLoad) onLoad(texture)
            }
          },
          onProgress,
          onError
        )
      }

      if (Array.isArray(url)) {
        var loaded = 0

        for (var i = 0, il = url.length; i < il; ++i) {
          loadTexture(i)
        }
      } else {
        // compressed cubemap texture stored in a single DDS file

        loader.load(
          url,
          function (buffer) {
            var texDatas = scope._parser(buffer, true)

            if (texDatas.isCubemap) {
              var faces = texDatas.mipmaps.length / texDatas.mipmapCount

              for (var f = 0; f < faces; f++) {
                images[f] = { mipmaps: [] }

                for (var i = 0; i < texDatas.mipmapCount; i++) {
                  images[f].mipmaps.push(texDatas.mipmaps[f * texDatas.mipmapCount + i])
                  images[f].format = texDatas.format
                  images[f].width = texDatas.width
                  images[f].height = texDatas.height
                }
              }
            } else {
              texture.image.width = texDatas.width
              texture.image.height = texDatas.height
              texture.mipmaps = texDatas.mipmaps
            }

            if (texDatas.mipmapCount === 1) {
              texture.minFilter = LinearFilter
            }

            texture.format = texDatas.format
            texture.needsUpdate = true

            if (onLoad) onLoad(texture)
          },
          onProgress,
          onError
        )
      }

      return texture
    },

    setPath: function (value) {
      this.path = value
      return this
    }
  })

  /**
   * @author Nikos M. / https://github.com/foo123/
   *
   * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)
   */

  function DataTextureLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager

    // override in sub classes
    this._parser = null
  }

  Object.assign(DataTextureLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      var scope = this

      var texture = new DataTexture()

      var loader = new FileLoader(this.manager)
      loader.setResponseType('arraybuffer')

      loader.load(
        url,
        function (buffer) {
          var texData = scope._parser(buffer)

          if (!texData) return

          if (undefined !== texData.image) {
            texture.image = texData.image
          } else if (undefined !== texData.data) {
            texture.image.width = texData.width
            texture.image.height = texData.height
            texture.image.data = texData.data
          }

          texture.wrapS = undefined !== texData.wrapS ? texData.wrapS : ClampToEdgeWrapping
          texture.wrapT = undefined !== texData.wrapT ? texData.wrapT : ClampToEdgeWrapping

          texture.magFilter = undefined !== texData.magFilter ? texData.magFilter : LinearFilter
          texture.minFilter =
            undefined !== texData.minFilter ? texData.minFilter : LinearMipMapLinearFilter

          texture.anisotropy = undefined !== texData.anisotropy ? texData.anisotropy : 1

          if (undefined !== texData.format) {
            texture.format = texData.format
          }
          if (undefined !== texData.type) {
            texture.type = texData.type
          }

          if (undefined !== texData.mipmaps) {
            texture.mipmaps = texData.mipmaps
          }

          if (1 === texData.mipmapCount) {
            texture.minFilter = LinearFilter
          }

          texture.needsUpdate = true

          if (onLoad) onLoad(texture, texData)
        },
        onProgress,
        onError
      )

      return texture
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function ImageLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
  }

  Object.assign(ImageLoader.prototype, {
    crossOrigin: 'Anonymous',

    load: function (url, onLoad, onProgress, onError) {
      if (url === undefined) url = ''

      if (this.path !== undefined) url = this.path + url

      url = this.manager.resolveURL(url)

      var scope = this

      var cached = Cache.get(url)

      if (cached !== undefined) {
        scope.manager.itemStart(url)

        setTimeout(function () {
          if (onLoad) onLoad(cached)

          scope.manager.itemEnd(url)
        }, 0)

        return cached
      }

      var image = document.createElementNS('http://www.w3.org/1999/xhtml', 'img')

      image.addEventListener(
        'load',
        function () {
          Cache.add(url, this)

          if (onLoad) onLoad(this)

          scope.manager.itemEnd(url)
        },
        false
      )

      /*
			image.addEventListener( 'progress', function ( event ) {

				if ( onProgress ) onProgress( event );

			}, false );
			*/

      image.addEventListener(
        'error',
        function (event) {
          if (onError) onError(event)

          scope.manager.itemEnd(url)
          scope.manager.itemError(url)
        },
        false
      )

      if (url.substr(0, 5) !== 'data:') {
        if (this.crossOrigin !== undefined) image.crossOrigin = this.crossOrigin
      }

      scope.manager.itemStart(url)

      image.src = url

      return image
    },

    setCrossOrigin: function (value) {
      this.crossOrigin = value
      return this
    },

    setPath: function (value) {
      this.path = value
      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function CubeTextureLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
  }

  Object.assign(CubeTextureLoader.prototype, {
    crossOrigin: 'Anonymous',

    load: function (urls, onLoad, onProgress, onError) {
      var texture = new CubeTexture()

      var loader = new ImageLoader(this.manager)
      loader.setCrossOrigin(this.crossOrigin)
      loader.setPath(this.path)

      var loaded = 0

      function loadTexture(i) {
        loader.load(
          urls[i],
          function (image) {
            texture.images[i] = image

            loaded++

            if (loaded === 6) {
              texture.needsUpdate = true

              if (onLoad) onLoad(texture)
            }
          },
          undefined,
          onError
        )
      }

      for (var i = 0; i < urls.length; ++i) {
        loadTexture(i)
      }

      return texture
    },

    setCrossOrigin: function (value) {
      this.crossOrigin = value
      return this
    },

    setPath: function (value) {
      this.path = value
      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function TextureLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
  }

  Object.assign(TextureLoader.prototype, {
    crossOrigin: 'Anonymous',

    load: function (url, onLoad, onProgress, onError) {
      var texture = new Texture()

      var loader = new ImageLoader(this.manager)
      loader.setCrossOrigin(this.crossOrigin)
      loader.setPath(this.path)

      loader.load(
        url,
        function (image) {
          texture.image = image

          // JPEGs can't have an alpha channel, so memory can be saved by storing them as RGB.
          var isJPEG = url.search(/\.(jpg|jpeg)$/) > 0 || url.search(/^data\:image\/jpeg/) === 0

          texture.format = isJPEG ? RGBFormat : RGBAFormat
          texture.needsUpdate = true

          if (onLoad !== undefined) {
            onLoad(texture)
          }
        },
        onProgress,
        onError
      )

      return texture
    },

    setCrossOrigin: function (value) {
      this.crossOrigin = value
      return this
    },

    setPath: function (value) {
      this.path = value
      return this
    }
  })

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * Extensible curve object
   *
   * Some common of curve methods:
   * .getPoint( t, optionalTarget ), .getTangent( t )
   * .getPointAt( u, optionalTarget ), .getTangentAt( u )
   * .getPoints(), .getSpacedPoints()
   * .getLength()
   * .updateArcLengths()
   *
   * This following curves inherit from THREE.Curve:
   *
   * -- 2D curves --
   * THREE.ArcCurve
   * THREE.CubicBezierCurve
   * THREE.EllipseCurve
   * THREE.LineCurve
   * THREE.QuadraticBezierCurve
   * THREE.SplineCurve
   *
   * -- 3D curves --
   * THREE.CatmullRomCurve3
   * THREE.CubicBezierCurve3
   * THREE.LineCurve3
   * THREE.QuadraticBezierCurve3
   *
   * A series of curves can be represented as a THREE.CurvePath.
   *
   **/

  /**************************************************************
   *	Abstract Curve base class
   **************************************************************/

  function Curve() {
    this.type = 'Curve'

    this.arcLengthDivisions = 200
  }

  Object.assign(Curve.prototype, {
    // Virtual base class method to overwrite and implement in subclasses
    //	- t [0 .. 1]

    getPoint: function (/* t, optionalTarget */) {
      console.warn('THREE.Curve: .getPoint() not implemented.')
      return null
    },

    // Get point at relative position in curve according to arc length
    // - u [0 .. 1]

    getPointAt: function (u, optionalTarget) {
      var t = this.getUtoTmapping(u)
      return this.getPoint(t, optionalTarget)
    },

    // Get sequence of points using getPoint( t )

    getPoints: function (divisions) {
      if (divisions === undefined) divisions = 5

      var points = []

      for (var d = 0; d <= divisions; d++) {
        points.push(this.getPoint(d / divisions))
      }

      return points
    },

    // Get sequence of points using getPointAt( u )

    getSpacedPoints: function (divisions) {
      if (divisions === undefined) divisions = 5

      var points = []

      for (var d = 0; d <= divisions; d++) {
        points.push(this.getPointAt(d / divisions))
      }

      return points
    },

    // Get total curve arc length

    getLength: function () {
      var lengths = this.getLengths()
      return lengths[lengths.length - 1]
    },

    // Get list of cumulative segment lengths

    getLengths: function (divisions) {
      if (divisions === undefined) divisions = this.arcLengthDivisions

      if (
        this.cacheArcLengths &&
        this.cacheArcLengths.length === divisions + 1 &&
        !this.needsUpdate
      ) {
        return this.cacheArcLengths
      }

      this.needsUpdate = false

      var cache = []
      var current,
        last = this.getPoint(0)
      var p,
        sum = 0

      cache.push(0)

      for (p = 1; p <= divisions; p++) {
        current = this.getPoint(p / divisions)
        sum += current.distanceTo(last)
        cache.push(sum)
        last = current
      }

      this.cacheArcLengths = cache

      return cache // { sums: cache, sum: sum }; Sum is in the last element.
    },

    updateArcLengths: function () {
      this.needsUpdate = true
      this.getLengths()
    },

    // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant

    getUtoTmapping: function (u, distance) {
      var arcLengths = this.getLengths()

      var i = 0,
        il = arcLengths.length

      var targetArcLength // The targeted u distance value to get

      if (distance) {
        targetArcLength = distance
      } else {
        targetArcLength = u * arcLengths[il - 1]
      }

      // binary search for the index with largest value smaller than target u distance

      var low = 0,
        high = il - 1,
        comparison

      while (low <= high) {
        i = Math.floor(low + (high - low) / 2) // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats

        comparison = arcLengths[i] - targetArcLength

        if (comparison < 0) {
          low = i + 1
        } else if (comparison > 0) {
          high = i - 1
        } else {
          high = i
          break

          // DONE
        }
      }

      i = high

      if (arcLengths[i] === targetArcLength) {
        return i / (il - 1)
      }

      // we could get finer grain at lengths, or use simple interpolation between two points

      var lengthBefore = arcLengths[i]
      var lengthAfter = arcLengths[i + 1]

      var segmentLength = lengthAfter - lengthBefore

      // determine where we are between the 'before' and 'after' points

      var segmentFraction = (targetArcLength - lengthBefore) / segmentLength

      // add that fractional amount to t

      var t = (i + segmentFraction) / (il - 1)

      return t
    },

    // Returns a unit vector tangent at t
    // In case any sub curve does not implement its tangent derivation,
    // 2 points a small delta apart will be used to find its gradient
    // which seems to give a reasonable approximation

    getTangent: function (t) {
      var delta = 0.0001
      var t1 = t - delta
      var t2 = t + delta

      // Capping in case of danger

      if (t1 < 0) t1 = 0
      if (t2 > 1) t2 = 1

      var pt1 = this.getPoint(t1)
      var pt2 = this.getPoint(t2)

      var vec = pt2.clone().sub(pt1)
      return vec.normalize()
    },

    getTangentAt: function (u) {
      var t = this.getUtoTmapping(u)
      return this.getTangent(t)
    },

    computeFrenetFrames: function (segments, closed) {
      // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf

      var normal = new Vector3()

      var tangents = []
      var normals = []
      var binormals = []

      var vec = new Vector3()
      var mat = new Matrix4()

      var i, u, theta

      // compute the tangent vectors for each segment on the curve

      for (i = 0; i <= segments; i++) {
        u = i / segments

        tangents[i] = this.getTangentAt(u)
        tangents[i].normalize()
      }

      // select an initial normal vector perpendicular to the first tangent vector,
      // and in the direction of the minimum tangent xyz component

      normals[0] = new Vector3()
      binormals[0] = new Vector3()
      var min = Number.MAX_VALUE
      var tx = Math.abs(tangents[0].x)
      var ty = Math.abs(tangents[0].y)
      var tz = Math.abs(tangents[0].z)

      if (tx <= min) {
        min = tx
        normal.set(1, 0, 0)
      }

      if (ty <= min) {
        min = ty
        normal.set(0, 1, 0)
      }

      if (tz <= min) {
        normal.set(0, 0, 1)
      }

      vec.crossVectors(tangents[0], normal).normalize()

      normals[0].crossVectors(tangents[0], vec)
      binormals[0].crossVectors(tangents[0], normals[0])

      // compute the slowly-varying normal and binormal vectors for each segment on the curve

      for (i = 1; i <= segments; i++) {
        normals[i] = normals[i - 1].clone()

        binormals[i] = binormals[i - 1].clone()

        vec.crossVectors(tangents[i - 1], tangents[i])

        if (vec.length() > Number.EPSILON) {
          vec.normalize()

          theta = Math.acos(_Math.clamp(tangents[i - 1].dot(tangents[i]), -1, 1)) // clamp for floating pt errors

          normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta))
        }

        binormals[i].crossVectors(tangents[i], normals[i])
      }

      // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same

      if (closed === true) {
        theta = Math.acos(_Math.clamp(normals[0].dot(normals[segments]), -1, 1))
        theta /= segments

        if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) {
          theta = -theta
        }

        for (i = 1; i <= segments; i++) {
          // twist a little...
          normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i))
          binormals[i].crossVectors(tangents[i], normals[i])
        }
      }

      return {
        tangents: tangents,
        normals: normals,
        binormals: binormals
      }
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (source) {
      this.arcLengthDivisions = source.arcLengthDivisions

      return this
    },

    toJSON: function () {
      var data = {
        metadata: {
          version: 4.5,
          type: 'Curve',
          generator: 'Curve.toJSON'
        }
      }

      data.arcLengthDivisions = this.arcLengthDivisions
      data.type = this.type

      return data
    },

    fromJSON: function (json) {
      this.arcLengthDivisions = json.arcLengthDivisions

      return this
    }
  })

  function EllipseCurve(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
    Curve.call(this)

    this.type = 'EllipseCurve'

    this.aX = aX || 0
    this.aY = aY || 0

    this.xRadius = xRadius || 1
    this.yRadius = yRadius || 1

    this.aStartAngle = aStartAngle || 0
    this.aEndAngle = aEndAngle || 2 * Math.PI

    this.aClockwise = aClockwise || false

    this.aRotation = aRotation || 0
  }

  EllipseCurve.prototype = Object.create(Curve.prototype)
  EllipseCurve.prototype.constructor = EllipseCurve

  EllipseCurve.prototype.isEllipseCurve = true

  EllipseCurve.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector2()

    var twoPi = Math.PI * 2
    var deltaAngle = this.aEndAngle - this.aStartAngle
    var samePoints = Math.abs(deltaAngle) < Number.EPSILON

    // ensures that deltaAngle is 0 .. 2 PI
    while (deltaAngle < 0) deltaAngle += twoPi
    while (deltaAngle > twoPi) deltaAngle -= twoPi

    if (deltaAngle < Number.EPSILON) {
      if (samePoints) {
        deltaAngle = 0
      } else {
        deltaAngle = twoPi
      }
    }

    if (this.aClockwise === true && !samePoints) {
      if (deltaAngle === twoPi) {
        deltaAngle = -twoPi
      } else {
        deltaAngle = deltaAngle - twoPi
      }
    }

    var angle = this.aStartAngle + t * deltaAngle
    var x = this.aX + this.xRadius * Math.cos(angle)
    var y = this.aY + this.yRadius * Math.sin(angle)

    if (this.aRotation !== 0) {
      var cos = Math.cos(this.aRotation)
      var sin = Math.sin(this.aRotation)

      var tx = x - this.aX
      var ty = y - this.aY

      // Rotate the point about the center of the ellipse.
      x = tx * cos - ty * sin + this.aX
      y = tx * sin + ty * cos + this.aY
    }

    return point.set(x, y)
  }

  EllipseCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.aX = source.aX
    this.aY = source.aY

    this.xRadius = source.xRadius
    this.yRadius = source.yRadius

    this.aStartAngle = source.aStartAngle
    this.aEndAngle = source.aEndAngle

    this.aClockwise = source.aClockwise

    this.aRotation = source.aRotation

    return this
  }

  EllipseCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.aX = this.aX
    data.aY = this.aY

    data.xRadius = this.xRadius
    data.yRadius = this.yRadius

    data.aStartAngle = this.aStartAngle
    data.aEndAngle = this.aEndAngle

    data.aClockwise = this.aClockwise

    data.aRotation = this.aRotation

    return data
  }

  EllipseCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.aX = json.aX
    this.aY = json.aY

    this.xRadius = json.xRadius
    this.yRadius = json.yRadius

    this.aStartAngle = json.aStartAngle
    this.aEndAngle = json.aEndAngle

    this.aClockwise = json.aClockwise

    this.aRotation = json.aRotation

    return this
  }

  function ArcCurve(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
    EllipseCurve.call(this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise)

    this.type = 'ArcCurve'
  }

  ArcCurve.prototype = Object.create(EllipseCurve.prototype)
  ArcCurve.prototype.constructor = ArcCurve

  ArcCurve.prototype.isArcCurve = true

  /**
   * @author zz85 https://github.com/zz85
   *
   * Centripetal CatmullRom Curve - which is useful for avoiding
   * cusps and self-intersections in non-uniform catmull rom curves.
   * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
   *
   * curve.type accepts centripetal(default), chordal and catmullrom
   * curve.tension is used for catmullrom which defaults to 0.5
   */

  /*
	Based on an optimized c++ solution in
	 - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/
	 - http://ideone.com/NoEbVM

	This CubicPoly class could be used for reusing some variables and calculations,
	but for three.js curve use, it could be possible inlined and flatten into a single function call
	which can be placed in CurveUtils.
	*/

  function CubicPoly() {
    var c0 = 0,
      c1 = 0,
      c2 = 0,
      c3 = 0

    /*
     * Compute coefficients for a cubic polynomial
     *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3
     * such that
     *   p(0) = x0, p(1) = x1
     *  and
     *   p'(0) = t0, p'(1) = t1.
     */
    function init(x0, x1, t0, t1) {
      c0 = x0
      c1 = t0
      c2 = -3 * x0 + 3 * x1 - 2 * t0 - t1
      c3 = 2 * x0 - 2 * x1 + t0 + t1
    }

    return {
      initCatmullRom: function (x0, x1, x2, x3, tension) {
        init(x1, x2, tension * (x2 - x0), tension * (x3 - x1))
      },

      initNonuniformCatmullRom: function (x0, x1, x2, x3, dt0, dt1, dt2) {
        // compute tangents when parameterized in [t1,t2]
        var t1 = (x1 - x0) / dt0 - (x2 - x0) / (dt0 + dt1) + (x2 - x1) / dt1
        var t2 = (x2 - x1) / dt1 - (x3 - x1) / (dt1 + dt2) + (x3 - x2) / dt2

        // rescale tangents for parametrization in [0,1]
        t1 *= dt1
        t2 *= dt1

        init(x1, x2, t1, t2)
      },

      calc: function (t) {
        var t2 = t * t
        var t3 = t2 * t
        return c0 + c1 * t + c2 * t2 + c3 * t3
      }
    }
  }

  //

  var tmp = new Vector3()
  var px = new CubicPoly()
  var py = new CubicPoly()
  var pz = new CubicPoly()

  function CatmullRomCurve3(points, closed, curveType, tension) {
    Curve.call(this)

    this.type = 'CatmullRomCurve3'

    this.points = points || []
    this.closed = closed || false
    this.curveType = curveType || 'centripetal'
    this.tension = tension || 0.5
  }

  CatmullRomCurve3.prototype = Object.create(Curve.prototype)
  CatmullRomCurve3.prototype.constructor = CatmullRomCurve3

  CatmullRomCurve3.prototype.isCatmullRomCurve3 = true

  CatmullRomCurve3.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector3()

    var points = this.points
    var l = points.length

    var p = (l - (this.closed ? 0 : 1)) * t
    var intPoint = Math.floor(p)
    var weight = p - intPoint

    if (this.closed) {
      intPoint +=
        intPoint > 0 ? 0 : (Math.floor(Math.abs(intPoint) / points.length) + 1) * points.length
    } else if (weight === 0 && intPoint === l - 1) {
      intPoint = l - 2
      weight = 1
    }

    var p0, p1, p2, p3 // 4 points

    if (this.closed || intPoint > 0) {
      p0 = points[(intPoint - 1) % l]
    } else {
      // extrapolate first point
      tmp.subVectors(points[0], points[1]).add(points[0])
      p0 = tmp
    }

    p1 = points[intPoint % l]
    p2 = points[(intPoint + 1) % l]

    if (this.closed || intPoint + 2 < l) {
      p3 = points[(intPoint + 2) % l]
    } else {
      // extrapolate last point
      tmp.subVectors(points[l - 1], points[l - 2]).add(points[l - 1])
      p3 = tmp
    }

    if (this.curveType === 'centripetal' || this.curveType === 'chordal') {
      // init Centripetal / Chordal Catmull-Rom
      var pow = this.curveType === 'chordal' ? 0.5 : 0.25
      var dt0 = Math.pow(p0.distanceToSquared(p1), pow)
      var dt1 = Math.pow(p1.distanceToSquared(p2), pow)
      var dt2 = Math.pow(p2.distanceToSquared(p3), pow)

      // safety check for repeated points
      if (dt1 < 1e-4) dt1 = 1.0
      if (dt0 < 1e-4) dt0 = dt1
      if (dt2 < 1e-4) dt2 = dt1

      px.initNonuniformCatmullRom(p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2)
      py.initNonuniformCatmullRom(p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2)
      pz.initNonuniformCatmullRom(p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2)
    } else if (this.curveType === 'catmullrom') {
      px.initCatmullRom(p0.x, p1.x, p2.x, p3.x, this.tension)
      py.initCatmullRom(p0.y, p1.y, p2.y, p3.y, this.tension)
      pz.initCatmullRom(p0.z, p1.z, p2.z, p3.z, this.tension)
    }

    point.set(px.calc(weight), py.calc(weight), pz.calc(weight))

    return point
  }

  CatmullRomCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.points = []

    for (var i = 0, l = source.points.length; i < l; i++) {
      var point = source.points[i]

      this.points.push(point.clone())
    }

    this.closed = source.closed
    this.curveType = source.curveType
    this.tension = source.tension

    return this
  }

  CatmullRomCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.points = []

    for (var i = 0, l = this.points.length; i < l; i++) {
      var point = this.points[i]
      data.points.push(point.toArray())
    }

    data.closed = this.closed
    data.curveType = this.curveType
    data.tension = this.tension

    return data
  }

  CatmullRomCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.points = []

    for (var i = 0, l = json.points.length; i < l; i++) {
      var point = json.points[i]
      this.points.push(new Vector3().fromArray(point))
    }

    this.closed = json.closed
    this.curveType = json.curveType
    this.tension = json.tension

    return this
  }

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   *
   * Bezier Curves formulas obtained from
   * http://en.wikipedia.org/wiki/Bézier_curve
   */

  function CatmullRom(t, p0, p1, p2, p3) {
    var v0 = (p2 - p0) * 0.5
    var v1 = (p3 - p1) * 0.5
    var t2 = t * t
    var t3 = t * t2
    return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1
  }

  //

  function QuadraticBezierP0(t, p) {
    var k = 1 - t
    return k * k * p
  }

  function QuadraticBezierP1(t, p) {
    return 2 * (1 - t) * t * p
  }

  function QuadraticBezierP2(t, p) {
    return t * t * p
  }

  function QuadraticBezier(t, p0, p1, p2) {
    return QuadraticBezierP0(t, p0) + QuadraticBezierP1(t, p1) + QuadraticBezierP2(t, p2)
  }

  //

  function CubicBezierP0(t, p) {
    var k = 1 - t
    return k * k * k * p
  }

  function CubicBezierP1(t, p) {
    var k = 1 - t
    return 3 * k * k * t * p
  }

  function CubicBezierP2(t, p) {
    return 3 * (1 - t) * t * t * p
  }

  function CubicBezierP3(t, p) {
    return t * t * t * p
  }

  function CubicBezier(t, p0, p1, p2, p3) {
    return CubicBezierP0(t, p0) + CubicBezierP1(t, p1) + CubicBezierP2(t, p2) + CubicBezierP3(t, p3)
  }

  function CubicBezierCurve(v0, v1, v2, v3) {
    Curve.call(this)

    this.type = 'CubicBezierCurve'

    this.v0 = v0 || new Vector2()
    this.v1 = v1 || new Vector2()
    this.v2 = v2 || new Vector2()
    this.v3 = v3 || new Vector2()
  }

  CubicBezierCurve.prototype = Object.create(Curve.prototype)
  CubicBezierCurve.prototype.constructor = CubicBezierCurve

  CubicBezierCurve.prototype.isCubicBezierCurve = true

  CubicBezierCurve.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector2()

    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2,
      v3 = this.v3

    point.set(CubicBezier(t, v0.x, v1.x, v2.x, v3.x), CubicBezier(t, v0.y, v1.y, v2.y, v3.y))

    return point
  }

  CubicBezierCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    this.v3.copy(source.v3)

    return this
  }

  CubicBezierCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    data.v3 = this.v3.toArray()

    return data
  }

  CubicBezierCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    this.v3.fromArray(json.v3)

    return this
  }

  function CubicBezierCurve3(v0, v1, v2, v3) {
    Curve.call(this)

    this.type = 'CubicBezierCurve3'

    this.v0 = v0 || new Vector3()
    this.v1 = v1 || new Vector3()
    this.v2 = v2 || new Vector3()
    this.v3 = v3 || new Vector3()
  }

  CubicBezierCurve3.prototype = Object.create(Curve.prototype)
  CubicBezierCurve3.prototype.constructor = CubicBezierCurve3

  CubicBezierCurve3.prototype.isCubicBezierCurve3 = true

  CubicBezierCurve3.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector3()

    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2,
      v3 = this.v3

    point.set(
      CubicBezier(t, v0.x, v1.x, v2.x, v3.x),
      CubicBezier(t, v0.y, v1.y, v2.y, v3.y),
      CubicBezier(t, v0.z, v1.z, v2.z, v3.z)
    )

    return point
  }

  CubicBezierCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    this.v3.copy(source.v3)

    return this
  }

  CubicBezierCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    data.v3 = this.v3.toArray()

    return data
  }

  CubicBezierCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    this.v3.fromArray(json.v3)

    return this
  }

  function LineCurve(v1, v2) {
    Curve.call(this)

    this.type = 'LineCurve'

    this.v1 = v1 || new Vector2()
    this.v2 = v2 || new Vector2()
  }

  LineCurve.prototype = Object.create(Curve.prototype)
  LineCurve.prototype.constructor = LineCurve

  LineCurve.prototype.isLineCurve = true

  LineCurve.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector2()

    if (t === 1) {
      point.copy(this.v2)
    } else {
      point.copy(this.v2).sub(this.v1)
      point.multiplyScalar(t).add(this.v1)
    }

    return point
  }

  // Line curve is linear, so we can overwrite default getPointAt

  LineCurve.prototype.getPointAt = function (u, optionalTarget) {
    return this.getPoint(u, optionalTarget)
  }

  LineCurve.prototype.getTangent = function (/* t */) {
    var tangent = this.v2.clone().sub(this.v1)

    return tangent.normalize()
  }

  LineCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.v1.copy(source.v1)
    this.v2.copy(source.v2)

    return this
  }

  LineCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()

    return data
  }

  LineCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)

    return this
  }

  function LineCurve3(v1, v2) {
    Curve.call(this)

    this.type = 'LineCurve3'

    this.v1 = v1 || new Vector3()
    this.v2 = v2 || new Vector3()
  }

  LineCurve3.prototype = Object.create(Curve.prototype)
  LineCurve3.prototype.constructor = LineCurve3

  LineCurve3.prototype.isLineCurve3 = true

  LineCurve3.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector3()

    if (t === 1) {
      point.copy(this.v2)
    } else {
      point.copy(this.v2).sub(this.v1)
      point.multiplyScalar(t).add(this.v1)
    }

    return point
  }

  // Line curve is linear, so we can overwrite default getPointAt

  LineCurve3.prototype.getPointAt = function (u, optionalTarget) {
    return this.getPoint(u, optionalTarget)
  }

  LineCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.v1.copy(source.v1)
    this.v2.copy(source.v2)

    return this
  }

  LineCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()

    return data
  }

  LineCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)

    return this
  }

  function QuadraticBezierCurve(v0, v1, v2) {
    Curve.call(this)

    this.type = 'QuadraticBezierCurve'

    this.v0 = v0 || new Vector2()
    this.v1 = v1 || new Vector2()
    this.v2 = v2 || new Vector2()
  }

  QuadraticBezierCurve.prototype = Object.create(Curve.prototype)
  QuadraticBezierCurve.prototype.constructor = QuadraticBezierCurve

  QuadraticBezierCurve.prototype.isQuadraticBezierCurve = true

  QuadraticBezierCurve.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector2()

    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2

    point.set(QuadraticBezier(t, v0.x, v1.x, v2.x), QuadraticBezier(t, v0.y, v1.y, v2.y))

    return point
  }

  QuadraticBezierCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)

    return this
  }

  QuadraticBezierCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()

    return data
  }

  QuadraticBezierCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)

    return this
  }

  function QuadraticBezierCurve3(v0, v1, v2) {
    Curve.call(this)

    this.type = 'QuadraticBezierCurve3'

    this.v0 = v0 || new Vector3()
    this.v1 = v1 || new Vector3()
    this.v2 = v2 || new Vector3()
  }

  QuadraticBezierCurve3.prototype = Object.create(Curve.prototype)
  QuadraticBezierCurve3.prototype.constructor = QuadraticBezierCurve3

  QuadraticBezierCurve3.prototype.isQuadraticBezierCurve3 = true

  QuadraticBezierCurve3.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector3()

    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2

    point.set(
      QuadraticBezier(t, v0.x, v1.x, v2.x),
      QuadraticBezier(t, v0.y, v1.y, v2.y),
      QuadraticBezier(t, v0.z, v1.z, v2.z)
    )

    return point
  }

  QuadraticBezierCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)

    return this
  }

  QuadraticBezierCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()

    return data
  }

  QuadraticBezierCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)

    return this
  }

  function SplineCurve(points /* array of Vector2 */) {
    Curve.call(this)

    this.type = 'SplineCurve'

    this.points = points || []
  }

  SplineCurve.prototype = Object.create(Curve.prototype)
  SplineCurve.prototype.constructor = SplineCurve

  SplineCurve.prototype.isSplineCurve = true

  SplineCurve.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector2()

    var points = this.points
    var p = (points.length - 1) * t

    var intPoint = Math.floor(p)
    var weight = p - intPoint

    var p0 = points[intPoint === 0 ? intPoint : intPoint - 1]
    var p1 = points[intPoint]
    var p2 = points[intPoint > points.length - 2 ? points.length - 1 : intPoint + 1]
    var p3 = points[intPoint > points.length - 3 ? points.length - 1 : intPoint + 2]

    point.set(
      CatmullRom(weight, p0.x, p1.x, p2.x, p3.x),
      CatmullRom(weight, p0.y, p1.y, p2.y, p3.y)
    )

    return point
  }

  SplineCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)

    this.points = []

    for (var i = 0, l = source.points.length; i < l; i++) {
      var point = source.points[i]

      this.points.push(point.clone())
    }

    return this
  }

  SplineCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)

    data.points = []

    for (var i = 0, l = this.points.length; i < l; i++) {
      var point = this.points[i]
      data.points.push(point.toArray())
    }

    return data
  }

  SplineCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)

    this.points = []

    for (var i = 0, l = json.points.length; i < l; i++) {
      var point = json.points[i]
      this.points.push(new Vector2().fromArray(point))
    }

    return this
  }

  var Curves = Object.freeze({
    ArcCurve: ArcCurve,
    CatmullRomCurve3: CatmullRomCurve3,
    CubicBezierCurve: CubicBezierCurve,
    CubicBezierCurve3: CubicBezierCurve3,
    EllipseCurve: EllipseCurve,
    LineCurve: LineCurve,
    LineCurve3: LineCurve3,
    QuadraticBezierCurve: QuadraticBezierCurve,
    QuadraticBezierCurve3: QuadraticBezierCurve3,
    SplineCurve: SplineCurve
  })

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   *
   **/

  /**************************************************************
   *	Curved Path - a curve path is simply a array of connected
   *  curves, but retains the api of a curve
   **************************************************************/

  function CurvePath() {
    Curve.call(this)

    this.type = 'CurvePath'

    this.curves = []
    this.autoClose = false // Automatically closes the path
  }

  CurvePath.prototype = Object.assign(Object.create(Curve.prototype), {
    constructor: CurvePath,

    add: function (curve) {
      this.curves.push(curve)
    },

    closePath: function () {
      // Add a line curve if start and end of lines are not connected
      var startPoint = this.curves[0].getPoint(0)
      var endPoint = this.curves[this.curves.length - 1].getPoint(1)

      if (!startPoint.equals(endPoint)) {
        this.curves.push(new LineCurve(endPoint, startPoint))
      }
    },

    // To get accurate point with reference to
    // entire path distance at time t,
    // following has to be done:

    // 1. Length of each sub path have to be known
    // 2. Locate and identify type of curve
    // 3. Get t for the curve
    // 4. Return curve.getPointAt(t')

    getPoint: function (t) {
      var d = t * this.getLength()
      var curveLengths = this.getCurveLengths()
      var i = 0

      // To think about boundaries points.

      while (i < curveLengths.length) {
        if (curveLengths[i] >= d) {
          var diff = curveLengths[i] - d
          var curve = this.curves[i]

          var segmentLength = curve.getLength()
          var u = segmentLength === 0 ? 0 : 1 - diff / segmentLength

          return curve.getPointAt(u)
        }

        i++
      }

      return null

      // loop where sum != 0, sum > d , sum+1 <d
    },

    // We cannot use the default THREE.Curve getPoint() with getLength() because in
    // THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath
    // getPoint() depends on getLength

    getLength: function () {
      var lens = this.getCurveLengths()
      return lens[lens.length - 1]
    },

    // cacheLengths must be recalculated.
    updateArcLengths: function () {
      this.needsUpdate = true
      this.cacheLengths = null
      this.getCurveLengths()
    },

    // Compute lengths and cache them
    // We cannot overwrite getLengths() because UtoT mapping uses it.

    getCurveLengths: function () {
      // We use cache values if curves and cache array are same length

      if (this.cacheLengths && this.cacheLengths.length === this.curves.length) {
        return this.cacheLengths
      }

      // Get length of sub-curve
      // Push sums into cached array

      var lengths = [],
        sums = 0

      for (var i = 0, l = this.curves.length; i < l; i++) {
        sums += this.curves[i].getLength()
        lengths.push(sums)
      }

      this.cacheLengths = lengths

      return lengths
    },

    getSpacedPoints: function (divisions) {
      if (divisions === undefined) divisions = 40

      var points = []

      for (var i = 0; i <= divisions; i++) {
        points.push(this.getPoint(i / divisions))
      }

      if (this.autoClose) {
        points.push(points[0])
      }

      return points
    },

    getPoints: function (divisions) {
      divisions = divisions || 12

      var points = [],
        last

      for (var i = 0, curves = this.curves; i < curves.length; i++) {
        var curve = curves[i]
        var resolution =
          curve && curve.isEllipseCurve
            ? divisions * 2
            : curve && curve.isLineCurve
              ? 1
              : curve && curve.isSplineCurve
                ? divisions * curve.points.length
                : divisions

        var pts = curve.getPoints(resolution)

        for (var j = 0; j < pts.length; j++) {
          var point = pts[j]

          if (last && last.equals(point)) continue // ensures no consecutive points are duplicates

          points.push(point)
          last = point
        }
      }

      if (this.autoClose && points.length > 1 && !points[points.length - 1].equals(points[0])) {
        points.push(points[0])
      }

      return points
    },

    copy: function (source) {
      Curve.prototype.copy.call(this, source)

      this.curves = []

      for (var i = 0, l = source.curves.length; i < l; i++) {
        var curve = source.curves[i]

        this.curves.push(curve.clone())
      }

      this.autoClose = source.autoClose

      return this
    },

    toJSON: function () {
      var data = Curve.prototype.toJSON.call(this)

      data.autoClose = this.autoClose
      data.curves = []

      for (var i = 0, l = this.curves.length; i < l; i++) {
        var curve = this.curves[i]
        data.curves.push(curve.toJSON())
      }

      return data
    },

    fromJSON: function (json) {
      Curve.prototype.fromJSON.call(this, json)

      this.autoClose = json.autoClose
      this.curves = []

      for (var i = 0, l = json.curves.length; i < l; i++) {
        var curve = json.curves[i]
        this.curves.push(new Curves[curve.type]().fromJSON(curve))
      }

      return this
    }
  })

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * Creates free form 2d path using series of points, lines or curves.
   **/

  function Path(points) {
    CurvePath.call(this)

    this.type = 'Path'

    this.currentPoint = new Vector2()

    if (points) {
      this.setFromPoints(points)
    }
  }

  Path.prototype = Object.assign(Object.create(CurvePath.prototype), {
    constructor: Path,

    setFromPoints: function (points) {
      this.moveTo(points[0].x, points[0].y)

      for (var i = 1, l = points.length; i < l; i++) {
        this.lineTo(points[i].x, points[i].y)
      }
    },

    moveTo: function (x, y) {
      this.currentPoint.set(x, y) // TODO consider referencing vectors instead of copying?
    },

    lineTo: function (x, y) {
      var curve = new LineCurve(this.currentPoint.clone(), new Vector2(x, y))
      this.curves.push(curve)

      this.currentPoint.set(x, y)
    },

    quadraticCurveTo: function (aCPx, aCPy, aX, aY) {
      var curve = new QuadraticBezierCurve(
        this.currentPoint.clone(),
        new Vector2(aCPx, aCPy),
        new Vector2(aX, aY)
      )

      this.curves.push(curve)

      this.currentPoint.set(aX, aY)
    },

    bezierCurveTo: function (aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
      var curve = new CubicBezierCurve(
        this.currentPoint.clone(),
        new Vector2(aCP1x, aCP1y),
        new Vector2(aCP2x, aCP2y),
        new Vector2(aX, aY)
      )

      this.curves.push(curve)

      this.currentPoint.set(aX, aY)
    },

    splineThru: function (pts /*Array of Vector*/) {
      var npts = [this.currentPoint.clone()].concat(pts)

      var curve = new SplineCurve(npts)
      this.curves.push(curve)

      this.currentPoint.copy(pts[pts.length - 1])
    },

    arc: function (aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
      var x0 = this.currentPoint.x
      var y0 = this.currentPoint.y

      this.absarc(aX + x0, aY + y0, aRadius, aStartAngle, aEndAngle, aClockwise)
    },

    absarc: function (aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
      this.absellipse(aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise)
    },

    ellipse: function (aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
      var x0 = this.currentPoint.x
      var y0 = this.currentPoint.y

      this.absellipse(
        aX + x0,
        aY + y0,
        xRadius,
        yRadius,
        aStartAngle,
        aEndAngle,
        aClockwise,
        aRotation
      )
    },

    absellipse: function (aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
      var curve = new EllipseCurve(
        aX,
        aY,
        xRadius,
        yRadius,
        aStartAngle,
        aEndAngle,
        aClockwise,
        aRotation
      )

      if (this.curves.length > 0) {
        // if a previous curve is present, attempt to join
        var firstPoint = curve.getPoint(0)

        if (!firstPoint.equals(this.currentPoint)) {
          this.lineTo(firstPoint.x, firstPoint.y)
        }
      }

      this.curves.push(curve)

      var lastPoint = curve.getPoint(1)
      this.currentPoint.copy(lastPoint)
    },

    copy: function (source) {
      CurvePath.prototype.copy.call(this, source)

      this.currentPoint.copy(source.currentPoint)

      return this
    },

    toJSON: function () {
      var data = CurvePath.prototype.toJSON.call(this)

      data.currentPoint = this.currentPoint.toArray()

      return data
    },

    fromJSON: function (json) {
      CurvePath.prototype.fromJSON.call(this, json)

      this.currentPoint.fromArray(json.currentPoint)

      return this
    }
  })

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * Defines a 2d shape plane using paths.
   **/

  // STEP 1 Create a path.
  // STEP 2 Turn path into shape.
  // STEP 3 ExtrudeGeometry takes in Shape/Shapes
  // STEP 3a - Extract points from each shape, turn to vertices
  // STEP 3b - Triangulate each shape, add faces.

  function Shape(points) {
    Path.call(this, points)

    this.uuid = _Math.generateUUID()

    this.type = 'Shape'

    this.holes = []
  }

  Shape.prototype = Object.assign(Object.create(Path.prototype), {
    constructor: Shape,

    getPointsHoles: function (divisions) {
      var holesPts = []

      for (var i = 0, l = this.holes.length; i < l; i++) {
        holesPts[i] = this.holes[i].getPoints(divisions)
      }

      return holesPts
    },

    // get points of shape and holes (keypoints based on segments parameter)

    extractPoints: function (divisions) {
      return {
        shape: this.getPoints(divisions),
        holes: this.getPointsHoles(divisions)
      }
    },

    copy: function (source) {
      Path.prototype.copy.call(this, source)

      this.holes = []

      for (var i = 0, l = source.holes.length; i < l; i++) {
        var hole = source.holes[i]

        this.holes.push(hole.clone())
      }

      return this
    },

    toJSON: function () {
      var data = Path.prototype.toJSON.call(this)

      data.uuid = this.uuid
      data.holes = []

      for (var i = 0, l = this.holes.length; i < l; i++) {
        var hole = this.holes[i]
        data.holes.push(hole.toJSON())
      }

      return data
    },

    fromJSON: function (json) {
      Path.prototype.fromJSON.call(this, json)

      this.uuid = json.uuid
      this.holes = []

      for (var i = 0, l = json.holes.length; i < l; i++) {
        var hole = json.holes[i]
        this.holes.push(new Path().fromJSON(hole))
      }

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   */

  function Light(color, intensity) {
    Object3D.call(this)

    this.type = 'Light'

    this.color = new Color(color)
    this.intensity = intensity !== undefined ? intensity : 1

    this.receiveShadow = undefined
  }

  Light.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Light,

    isLight: true,

    copy: function (source) {
      Object3D.prototype.copy.call(this, source)

      this.color.copy(source.color)
      this.intensity = source.intensity

      return this
    },

    toJSON: function (meta) {
      var data = Object3D.prototype.toJSON.call(this, meta)

      data.object.color = this.color.getHex()
      data.object.intensity = this.intensity

      if (this.groundColor !== undefined) data.object.groundColor = this.groundColor.getHex()

      if (this.distance !== undefined) data.object.distance = this.distance
      if (this.angle !== undefined) data.object.angle = this.angle
      if (this.decay !== undefined) data.object.decay = this.decay
      if (this.penumbra !== undefined) data.object.penumbra = this.penumbra

      if (this.shadow !== undefined) data.object.shadow = this.shadow.toJSON()

      return data
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function HemisphereLight(skyColor, groundColor, intensity) {
    Light.call(this, skyColor, intensity)

    this.type = 'HemisphereLight'

    this.castShadow = undefined

    this.position.copy(Object3D.DefaultUp)
    this.updateMatrix()

    this.groundColor = new Color(groundColor)
  }

  HemisphereLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: HemisphereLight,

    isHemisphereLight: true,

    copy: function (source) {
      Light.prototype.copy.call(this, source)

      this.groundColor.copy(source.groundColor)

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function LightShadow(camera) {
    this.camera = camera

    this.bias = 0
    this.radius = 1

    this.mapSize = new Vector2(512, 512)

    this.map = null
    this.matrix = new Matrix4()
  }

  Object.assign(LightShadow.prototype, {
    copy: function (source) {
      this.camera = source.camera.clone()

      this.bias = source.bias
      this.radius = source.radius

      this.mapSize.copy(source.mapSize)

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    toJSON: function () {
      var object = {}

      if (this.bias !== 0) object.bias = this.bias
      if (this.radius !== 1) object.radius = this.radius
      if (this.mapSize.x !== 512 || this.mapSize.y !== 512) object.mapSize = this.mapSize.toArray()

      object.camera = this.camera.toJSON(false).object
      delete object.camera.matrix

      return object
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function SpotLightShadow() {
    LightShadow.call(this, new PerspectiveCamera(50, 1, 0.5, 500))
  }

  SpotLightShadow.prototype = Object.assign(Object.create(LightShadow.prototype), {
    constructor: SpotLightShadow,

    isSpotLightShadow: true,

    update: function (light) {
      var camera = this.camera

      var fov = _Math.RAD2DEG * 2 * light.angle
      var aspect = this.mapSize.width / this.mapSize.height
      var far = light.distance || camera.far

      if (fov !== camera.fov || aspect !== camera.aspect || far !== camera.far) {
        camera.fov = fov
        camera.aspect = aspect
        camera.far = far
        camera.updateProjectionMatrix()
      }
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function SpotLight(color, intensity, distance, angle, penumbra, decay) {
    Light.call(this, color, intensity)

    this.type = 'SpotLight'

    this.position.copy(Object3D.DefaultUp)
    this.updateMatrix()

    this.target = new Object3D()

    Object.defineProperty(this, 'power', {
      get: function () {
        // intensity = power per solid angle.
        // ref: equation (17) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        return this.intensity * Math.PI
      },
      set: function (power) {
        // intensity = power per solid angle.
        // ref: equation (17) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        this.intensity = power / Math.PI
      }
    })

    this.distance = distance !== undefined ? distance : 0
    this.angle = angle !== undefined ? angle : Math.PI / 3
    this.penumbra = penumbra !== undefined ? penumbra : 0
    this.decay = decay !== undefined ? decay : 1 // for physically correct lights, should be 2.

    this.shadow = new SpotLightShadow()
  }

  SpotLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: SpotLight,

    isSpotLight: true,

    copy: function (source) {
      Light.prototype.copy.call(this, source)

      this.distance = source.distance
      this.angle = source.angle
      this.penumbra = source.penumbra
      this.decay = source.decay

      this.target = source.target.clone()

      this.shadow = source.shadow.clone()

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function PointLight(color, intensity, distance, decay) {
    Light.call(this, color, intensity)

    this.type = 'PointLight'

    Object.defineProperty(this, 'power', {
      get: function () {
        // intensity = power per solid angle.
        // ref: equation (15) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        return this.intensity * 4 * Math.PI
      },
      set: function (power) {
        // intensity = power per solid angle.
        // ref: equation (15) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        this.intensity = power / (4 * Math.PI)
      }
    })

    this.distance = distance !== undefined ? distance : 0
    this.decay = decay !== undefined ? decay : 1 // for physically correct lights, should be 2.

    this.shadow = new LightShadow(new PerspectiveCamera(90, 1, 0.5, 500))
  }

  PointLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: PointLight,

    isPointLight: true,

    copy: function (source) {
      Light.prototype.copy.call(this, source)

      this.distance = source.distance
      this.decay = source.decay

      this.shadow = source.shadow.clone()

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function DirectionalLightShadow() {
    LightShadow.call(this, new OrthographicCamera(-5, 5, 5, -5, 0.5, 500))
  }

  DirectionalLightShadow.prototype = Object.assign(Object.create(LightShadow.prototype), {
    constructor: DirectionalLightShadow
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   */

  function DirectionalLight(color, intensity) {
    Light.call(this, color, intensity)

    this.type = 'DirectionalLight'

    this.position.copy(Object3D.DefaultUp)
    this.updateMatrix()

    this.target = new Object3D()

    this.shadow = new DirectionalLightShadow()
  }

  DirectionalLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: DirectionalLight,

    isDirectionalLight: true,

    copy: function (source) {
      Light.prototype.copy.call(this, source)

      this.target = source.target.clone()

      this.shadow = source.shadow.clone()

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function AmbientLight(color, intensity) {
    Light.call(this, color, intensity)

    this.type = 'AmbientLight'

    this.castShadow = undefined
  }

  AmbientLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: AmbientLight,

    isAmbientLight: true
  })

  /**
   * @author abelnation / http://github.com/abelnation
   */

  function RectAreaLight(color, intensity, width, height) {
    Light.call(this, color, intensity)

    this.type = 'RectAreaLight'

    this.width = width !== undefined ? width : 10
    this.height = height !== undefined ? height : 10
  }

  RectAreaLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: RectAreaLight,

    isRectAreaLight: true,

    copy: function (source) {
      Light.prototype.copy.call(this, source)

      this.width = source.width
      this.height = source.height

      return this
    },

    toJSON: function (meta) {
      var data = Light.prototype.toJSON.call(this, meta)

      data.object.width = this.width
      data.object.height = this.height

      return data
    }
  })

  /**
   *
   * A Track that interpolates Strings
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function StringKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  StringKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: StringKeyframeTrack,

    ValueTypeName: 'string',
    ValueBufferType: Array,

    DefaultInterpolation: InterpolateDiscrete,

    InterpolantFactoryMethodLinear: undefined,

    InterpolantFactoryMethodSmooth: undefined
  })

  /**
   *
   * A Track of Boolean keyframe values.
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function BooleanKeyframeTrack(name, times, values) {
    KeyframeTrack.call(this, name, times, values)
  }

  BooleanKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: BooleanKeyframeTrack,

    ValueTypeName: 'bool',
    ValueBufferType: Array,

    DefaultInterpolation: InterpolateDiscrete,

    InterpolantFactoryMethodLinear: undefined,
    InterpolantFactoryMethodSmooth: undefined

    // Note: Actually this track could have a optimized / compressed
    // representation of a single value and a custom interpolant that
    // computes "firstValue ^ isOdd( index )".
  })

  /**
   * Abstract base class of interpolants over parametric samples.
   *
   * The parameter domain is one dimensional, typically the time or a path
   * along a curve defined by the data.
   *
   * The sample values can have any dimensionality and derived classes may
   * apply special interpretations to the data.
   *
   * This class provides the interval seek in a Template Method, deferring
   * the actual interpolation to derived classes.
   *
   * Time complexity is O(1) for linear access crossing at most two points
   * and O(log N) for random access, where N is the number of positions.
   *
   * References:
   *
   * 		http://www.oodesign.com/template-method-pattern.html
   *
   * @author tschw
   */

  function Interpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    this.parameterPositions = parameterPositions
    this._cachedIndex = 0

    this.resultBuffer =
      resultBuffer !== undefined ? resultBuffer : new sampleValues.constructor(sampleSize)
    this.sampleValues = sampleValues
    this.valueSize = sampleSize
  }

  Object.assign(Interpolant.prototype, {
    evaluate: function (t) {
      var pp = this.parameterPositions,
        i1 = this._cachedIndex,
        t1 = pp[i1],
        t0 = pp[i1 - 1]

      validate_interval: {
        seek: {
          var right

          linear_scan: {
            //- See http://jsperf.com/comparison-to-undefined/3
            //- slower code:
            //-
            //- 				if ( t >= t1 || t1 === undefined ) {
            forward_scan: if (!(t < t1)) {
              for (var giveUpAt = i1 + 2; ; ) {
                if (t1 === undefined) {
                  if (t < t0) break forward_scan

                  // after end

                  i1 = pp.length
                  this._cachedIndex = i1
                  return this.afterEnd_(i1 - 1, t, t0)
                }

                if (i1 === giveUpAt) break // this loop

                t0 = t1
                t1 = pp[++i1]

                if (t < t1) {
                  // we have arrived at the sought interval
                  break seek
                }
              }

              // prepare binary search on the right side of the index
              right = pp.length
              break linear_scan
            }

            //- slower code:
            //-					if ( t < t0 || t0 === undefined ) {
            if (!(t >= t0)) {
              // looping?

              var t1global = pp[1]

              if (t < t1global) {
                i1 = 2 // + 1, using the scan for the details
                t0 = t1global
              }

              // linear reverse scan

              for (var giveUpAt = i1 - 2; ; ) {
                if (t0 === undefined) {
                  // before start

                  this._cachedIndex = 0
                  return this.beforeStart_(0, t, t1)
                }

                if (i1 === giveUpAt) break // this loop

                t1 = t0
                t0 = pp[--i1 - 1]

                if (t >= t0) {
                  // we have arrived at the sought interval
                  break seek
                }
              }

              // prepare binary search on the left side of the index
              right = i1
              i1 = 0
              break linear_scan
            }

            // the interval is valid

            break validate_interval
          } // linear scan

          // binary search

          while (i1 < right) {
            var mid = (i1 + right) >>> 1

            if (t < pp[mid]) {
              right = mid
            } else {
              i1 = mid + 1
            }
          }

          t1 = pp[i1]
          t0 = pp[i1 - 1]

          // check boundary cases, again

          if (t0 === undefined) {
            this._cachedIndex = 0
            return this.beforeStart_(0, t, t1)
          }

          if (t1 === undefined) {
            i1 = pp.length
            this._cachedIndex = i1
            return this.afterEnd_(i1 - 1, t0, t)
          }
        } // seek

        this._cachedIndex = i1

        this.intervalChanged_(i1, t0, t1)
      } // validate_interval

      return this.interpolate_(i1, t0, t, t1)
    },

    settings: null, // optional, subclass-specific settings structure
    // Note: The indirection allows central control of many interpolants.

    // --- Protected interface

    DefaultSettings_: {},

    getSettings_: function () {
      return this.settings || this.DefaultSettings_
    },

    copySampleValue_: function (index) {
      // copies a sample value to the result buffer

      var result = this.resultBuffer,
        values = this.sampleValues,
        stride = this.valueSize,
        offset = index * stride

      for (var i = 0; i !== stride; ++i) {
        result[i] = values[offset + i]
      }

      return result
    },

    // Template methods for derived classes:

    interpolate_: function (/* i1, t0, t, t1 */) {
      throw new Error('call to abstract method')
      // implementations shall return this.resultBuffer
    },

    intervalChanged_: function (/* i1, t0, t1 */) {
      // empty
    }
  })

  //!\ DECLARE ALIAS AFTER assign prototype !
  Object.assign(Interpolant.prototype, {
    //( 0, t, t0 ), returns this.resultBuffer
    beforeStart_: Interpolant.prototype.copySampleValue_,

    //( N-1, tN-1, t ), returns this.resultBuffer
    afterEnd_: Interpolant.prototype.copySampleValue_
  })

  /**
   * Spherical linear unit quaternion interpolant.
   *
   * @author tschw
   */

  function QuaternionLinearInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
  }

  QuaternionLinearInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: QuaternionLinearInterpolant,

    interpolate_: function (i1, t0, t, t1) {
      var result = this.resultBuffer,
        values = this.sampleValues,
        stride = this.valueSize,
        offset = i1 * stride,
        alpha = (t - t0) / (t1 - t0)

      for (var end = offset + stride; offset !== end; offset += 4) {
        Quaternion.slerpFlat(result, 0, values, offset - stride, values, offset, alpha)
      }

      return result
    }
  })

  /**
   *
   * A Track of quaternion keyframe values.
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function QuaternionKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  QuaternionKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: QuaternionKeyframeTrack,

    ValueTypeName: 'quaternion',

    // ValueBufferType is inherited

    DefaultInterpolation: InterpolateLinear,

    InterpolantFactoryMethodLinear: function (result) {
      return new QuaternionLinearInterpolant(this.times, this.values, this.getValueSize(), result)
    },

    InterpolantFactoryMethodSmooth: undefined // not yet implemented
  })

  /**
   *
   * A Track of keyframe values that represent color.
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function ColorKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  ColorKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: ColorKeyframeTrack,

    ValueTypeName: 'color'

    // ValueBufferType is inherited

    // DefaultInterpolation is inherited

    // Note: Very basic implementation and nothing special yet.
    // However, this is the place for color space parameterization.
  })

  /**
   *
   * A Track of numeric keyframe values.
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function NumberKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  NumberKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: NumberKeyframeTrack,

    ValueTypeName: 'number'

    // ValueBufferType is inherited

    // DefaultInterpolation is inherited
  })

  /**
   * Fast and simple cubic spline interpolant.
   *
   * It was derived from a Hermitian construction setting the first derivative
   * at each sample position to the linear slope between neighboring positions
   * over their parameter interval.
   *
   * @author tschw
   */

  function CubicInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)

    this._weightPrev = -0
    this._offsetPrev = -0
    this._weightNext = -0
    this._offsetNext = -0
  }

  CubicInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: CubicInterpolant,

    DefaultSettings_: {
      endingStart: ZeroCurvatureEnding,
      endingEnd: ZeroCurvatureEnding
    },

    intervalChanged_: function (i1, t0, t1) {
      var pp = this.parameterPositions,
        iPrev = i1 - 2,
        iNext = i1 + 1,
        tPrev = pp[iPrev],
        tNext = pp[iNext]

      if (tPrev === undefined) {
        switch (this.getSettings_().endingStart) {
          case ZeroSlopeEnding:
            // f'(t0) = 0
            iPrev = i1
            tPrev = 2 * t0 - t1

            break

          case WrapAroundEnding:
            // use the other end of the curve
            iPrev = pp.length - 2
            tPrev = t0 + pp[iPrev] - pp[iPrev + 1]

            break

          default: // ZeroCurvatureEnding
            // f''(t0) = 0 a.k.a. Natural Spline
            iPrev = i1
            tPrev = t1
        }
      }

      if (tNext === undefined) {
        switch (this.getSettings_().endingEnd) {
          case ZeroSlopeEnding:
            // f'(tN) = 0
            iNext = i1
            tNext = 2 * t1 - t0

            break

          case WrapAroundEnding:
            // use the other end of the curve
            iNext = 1
            tNext = t1 + pp[1] - pp[0]

            break

          default: // ZeroCurvatureEnding
            // f''(tN) = 0, a.k.a. Natural Spline
            iNext = i1 - 1
            tNext = t0
        }
      }

      var halfDt = (t1 - t0) * 0.5,
        stride = this.valueSize

      this._weightPrev = halfDt / (t0 - tPrev)
      this._weightNext = halfDt / (tNext - t1)
      this._offsetPrev = iPrev * stride
      this._offsetNext = iNext * stride
    },

    interpolate_: function (i1, t0, t, t1) {
      var result = this.resultBuffer,
        values = this.sampleValues,
        stride = this.valueSize,
        o1 = i1 * stride,
        o0 = o1 - stride,
        oP = this._offsetPrev,
        oN = this._offsetNext,
        wP = this._weightPrev,
        wN = this._weightNext,
        p = (t - t0) / (t1 - t0),
        pp = p * p,
        ppp = pp * p

      // evaluate polynomials

      var sP = -wP * ppp + 2 * wP * pp - wP * p
      var s0 = (1 + wP) * ppp + (-1.5 - 2 * wP) * pp + (-0.5 + wP) * p + 1
      var s1 = (-1 - wN) * ppp + (1.5 + wN) * pp + 0.5 * p
      var sN = wN * ppp - wN * pp

      // combine data linearly

      for (var i = 0; i !== stride; ++i) {
        result[i] =
          sP * values[oP + i] + s0 * values[o0 + i] + s1 * values[o1 + i] + sN * values[oN + i]
      }

      return result
    }
  })

  /**
   * @author tschw
   */

  function LinearInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
  }

  LinearInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: LinearInterpolant,

    interpolate_: function (i1, t0, t, t1) {
      var result = this.resultBuffer,
        values = this.sampleValues,
        stride = this.valueSize,
        offset1 = i1 * stride,
        offset0 = offset1 - stride,
        weight1 = (t - t0) / (t1 - t0),
        weight0 = 1 - weight1

      for (var i = 0; i !== stride; ++i) {
        result[i] = values[offset0 + i] * weight0 + values[offset1 + i] * weight1
      }

      return result
    }
  })

  /**
   *
   * Interpolant that evaluates to the sample value at the position preceeding
   * the parameter.
   *
   * @author tschw
   */

  function DiscreteInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
  }

  DiscreteInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: DiscreteInterpolant,

    interpolate_: function (i1 /*, t0, t, t1 */) {
      return this.copySampleValue_(i1 - 1)
    }
  })

  /**
   * @author tschw
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   */

  var AnimationUtils = {
    // same as Array.prototype.slice, but also works on typed arrays
    arraySlice: function (array, from, to) {
      if (AnimationUtils.isTypedArray(array)) {
        // in ios9 array.subarray(from, undefined) will return empty array
        // but array.subarray(from) or array.subarray(from, len) is correct
        return new array.constructor(array.subarray(from, to !== undefined ? to : array.length))
      }

      return array.slice(from, to)
    },

    // converts an array to a specific type
    convertArray: function (array, type, forceClone) {
      if (
        !array || // let 'undefined' and 'null' pass
        (!forceClone && array.constructor === type)
      )
        return array

      if (typeof type.BYTES_PER_ELEMENT === 'number') {
        return new type(array) // create typed array
      }

      return Array.prototype.slice.call(array) // create Array
    },

    isTypedArray: function (object) {
      return ArrayBuffer.isView(object) && !(object instanceof DataView)
    },

    // returns an array by which times and values can be sorted
    getKeyframeOrder: function (times) {
      function compareTime(i, j) {
        return times[i] - times[j]
      }

      var n = times.length
      var result = new Array(n)
      for (var i = 0; i !== n; ++i) result[i] = i

      result.sort(compareTime)

      return result
    },

    // uses the array previously returned by 'getKeyframeOrder' to sort data
    sortedArray: function (values, stride, order) {
      var nValues = values.length
      var result = new values.constructor(nValues)

      for (var i = 0, dstOffset = 0; dstOffset !== nValues; ++i) {
        var srcOffset = order[i] * stride

        for (var j = 0; j !== stride; ++j) {
          result[dstOffset++] = values[srcOffset + j]
        }
      }

      return result
    },

    // function for parsing AOS keyframe formats
    flattenJSON: function (jsonKeys, times, values, valuePropertyName) {
      var i = 1,
        key = jsonKeys[0]

      while (key !== undefined && key[valuePropertyName] === undefined) {
        key = jsonKeys[i++]
      }

      if (key === undefined) return // no data

      var value = key[valuePropertyName]
      if (value === undefined) return // no data

      if (Array.isArray(value)) {
        do {
          value = key[valuePropertyName]

          if (value !== undefined) {
            times.push(key.time)
            values.push.apply(values, value) // push all elements
          }

          key = jsonKeys[i++]
        } while (key !== undefined)
      } else if (value.toArray !== undefined) {
        // ...assume THREE.Math-ish

        do {
          value = key[valuePropertyName]

          if (value !== undefined) {
            times.push(key.time)
            value.toArray(values, values.length)
          }

          key = jsonKeys[i++]
        } while (key !== undefined)
      } else {
        // otherwise push as-is

        do {
          value = key[valuePropertyName]

          if (value !== undefined) {
            times.push(key.time)
            values.push(value)
          }

          key = jsonKeys[i++]
        } while (key !== undefined)
      }
    }
  }

  /**
   *
   * A timed sequence of keyframes for a specific property.
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function KeyframeTrack(name, times, values, interpolation) {
    if (name === undefined) throw new Error('THREE.KeyframeTrack: track name is undefined')
    if (times === undefined || times.length === 0)
      throw new Error('THREE.KeyframeTrack: no keyframes in track named ' + name)

    this.name = name

    this.times = AnimationUtils.convertArray(times, this.TimeBufferType)
    this.values = AnimationUtils.convertArray(values, this.ValueBufferType)

    this.setInterpolation(interpolation || this.DefaultInterpolation)

    this.validate()
    this.optimize()
  }

  // Static methods:

  Object.assign(KeyframeTrack, {
    // Serialization (in static context, because of constructor invocation
    // and automatic invocation of .toJSON):

    parse: function (json) {
      if (json.type === undefined) {
        throw new Error('THREE.KeyframeTrack: track type undefined, can not parse')
      }

      var trackType = KeyframeTrack._getTrackTypeForValueTypeName(json.type)

      if (json.times === undefined) {
        var times = [],
          values = []

        AnimationUtils.flattenJSON(json.keys, times, values, 'value')

        json.times = times
        json.values = values
      }

      // derived classes can define a static parse method
      if (trackType.parse !== undefined) {
        return trackType.parse(json)
      } else {
        // by default, we assume a constructor compatible with the base
        return new trackType(json.name, json.times, json.values, json.interpolation)
      }
    },

    toJSON: function (track) {
      var trackType = track.constructor

      var json

      // derived classes can define a static toJSON method
      if (trackType.toJSON !== undefined) {
        json = trackType.toJSON(track)
      } else {
        // by default, we assume the data can be serialized as-is
        json = {
          name: track.name,
          times: AnimationUtils.convertArray(track.times, Array),
          values: AnimationUtils.convertArray(track.values, Array)
        }

        var interpolation = track.getInterpolation()

        if (interpolation !== track.DefaultInterpolation) {
          json.interpolation = interpolation
        }
      }

      json.type = track.ValueTypeName // mandatory

      return json
    },

    _getTrackTypeForValueTypeName: function (typeName) {
      switch (typeName.toLowerCase()) {
        case 'scalar':
        case 'double':
        case 'float':
        case 'number':
        case 'integer':
          return NumberKeyframeTrack

        case 'vector':
        case 'vector2':
        case 'vector3':
        case 'vector4':
          return VectorKeyframeTrack

        case 'color':
          return ColorKeyframeTrack

        case 'quaternion':
          return QuaternionKeyframeTrack

        case 'bool':
        case 'boolean':
          return BooleanKeyframeTrack

        case 'string':
          return StringKeyframeTrack
      }

      throw new Error('THREE.KeyframeTrack: Unsupported typeName: ' + typeName)
    }
  })

  Object.assign(KeyframeTrack.prototype, {
    constructor: KeyframeTrack,

    TimeBufferType: Float32Array,

    ValueBufferType: Float32Array,

    DefaultInterpolation: InterpolateLinear,

    InterpolantFactoryMethodDiscrete: function (result) {
      return new DiscreteInterpolant(this.times, this.values, this.getValueSize(), result)
    },

    InterpolantFactoryMethodLinear: function (result) {
      return new LinearInterpolant(this.times, this.values, this.getValueSize(), result)
    },

    InterpolantFactoryMethodSmooth: function (result) {
      return new CubicInterpolant(this.times, this.values, this.getValueSize(), result)
    },

    setInterpolation: function (interpolation) {
      var factoryMethod

      switch (interpolation) {
        case InterpolateDiscrete:
          factoryMethod = this.InterpolantFactoryMethodDiscrete

          break

        case InterpolateLinear:
          factoryMethod = this.InterpolantFactoryMethodLinear

          break

        case InterpolateSmooth:
          factoryMethod = this.InterpolantFactoryMethodSmooth

          break
      }

      if (factoryMethod === undefined) {
        var message =
          'unsupported interpolation for ' +
          this.ValueTypeName +
          ' keyframe track named ' +
          this.name

        if (this.createInterpolant === undefined) {
          // fall back to default, unless the default itself is messed up
          if (interpolation !== this.DefaultInterpolation) {
            this.setInterpolation(this.DefaultInterpolation)
          } else {
            throw new Error(message) // fatal, in this case
          }
        }

        console.warn('THREE.KeyframeTrack:', message)
        return
      }

      this.createInterpolant = factoryMethod
    },

    getInterpolation: function () {
      switch (this.createInterpolant) {
        case this.InterpolantFactoryMethodDiscrete:
          return InterpolateDiscrete

        case this.InterpolantFactoryMethodLinear:
          return InterpolateLinear

        case this.InterpolantFactoryMethodSmooth:
          return InterpolateSmooth
      }
    },

    getValueSize: function () {
      return this.values.length / this.times.length
    },

    // move all keyframes either forwards or backwards in time
    shift: function (timeOffset) {
      if (timeOffset !== 0.0) {
        var times = this.times

        for (var i = 0, n = times.length; i !== n; ++i) {
          times[i] += timeOffset
        }
      }

      return this
    },

    // scale all keyframe times by a factor (useful for frame <-> seconds conversions)
    scale: function (timeScale) {
      if (timeScale !== 1.0) {
        var times = this.times

        for (var i = 0, n = times.length; i !== n; ++i) {
          times[i] *= timeScale
        }
      }

      return this
    },

    // removes keyframes before and after animation without changing any values within the range [startTime, endTime].
    // IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
    trim: function (startTime, endTime) {
      var times = this.times,
        nKeys = times.length,
        from = 0,
        to = nKeys - 1

      while (from !== nKeys && times[from] < startTime) {
        ++from
      }

      while (to !== -1 && times[to] > endTime) {
        --to
      }

      ++to // inclusive -> exclusive bound

      if (from !== 0 || to !== nKeys) {
        // empty tracks are forbidden, so keep at least one keyframe
        if (from >= to) (to = Math.max(to, 1)), (from = to - 1)

        var stride = this.getValueSize()
        this.times = AnimationUtils.arraySlice(times, from, to)
        this.values = AnimationUtils.arraySlice(this.values, from * stride, to * stride)
      }

      return this
    },

    // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
    validate: function () {
      var valid = true

      var valueSize = this.getValueSize()
      if (valueSize - Math.floor(valueSize) !== 0) {
        console.error('THREE.KeyframeTrack: Invalid value size in track.', this)
        valid = false
      }

      var times = this.times,
        values = this.values,
        nKeys = times.length

      if (nKeys === 0) {
        console.error('THREE.KeyframeTrack: Track is empty.', this)
        valid = false
      }

      var prevTime = null

      for (var i = 0; i !== nKeys; i++) {
        var currTime = times[i]

        if (typeof currTime === 'number' && isNaN(currTime)) {
          console.error('THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime)
          valid = false
          break
        }

        if (prevTime !== null && prevTime > currTime) {
          console.error('THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime)
          valid = false
          break
        }

        prevTime = currTime
      }

      if (values !== undefined) {
        if (AnimationUtils.isTypedArray(values)) {
          for (var i = 0, n = values.length; i !== n; ++i) {
            var value = values[i]

            if (isNaN(value)) {
              console.error('THREE.KeyframeTrack: Value is not a valid number.', this, i, value)
              valid = false
              break
            }
          }
        }
      }

      return valid
    },

    // removes equivalent sequential keys as common in morph target sequences
    // (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
    optimize: function () {
      var times = this.times,
        values = this.values,
        stride = this.getValueSize(),
        smoothInterpolation = this.getInterpolation() === InterpolateSmooth,
        writeIndex = 1,
        lastIndex = times.length - 1

      for (var i = 1; i < lastIndex; ++i) {
        var keep = false

        var time = times[i]
        var timeNext = times[i + 1]

        // remove adjacent keyframes scheduled at the same time

        if (time !== timeNext && (i !== 1 || time !== time[0])) {
          if (!smoothInterpolation) {
            // remove unnecessary keyframes same as their neighbors

            var offset = i * stride,
              offsetP = offset - stride,
              offsetN = offset + stride

            for (var j = 0; j !== stride; ++j) {
              var value = values[offset + j]

              if (value !== values[offsetP + j] || value !== values[offsetN + j]) {
                keep = true
                break
              }
            }
          } else {
            keep = true
          }
        }

        // in-place compaction

        if (keep) {
          if (i !== writeIndex) {
            times[writeIndex] = times[i]

            var readOffset = i * stride,
              writeOffset = writeIndex * stride

            for (var j = 0; j !== stride; ++j) {
              values[writeOffset + j] = values[readOffset + j]
            }
          }

          ++writeIndex
        }
      }

      // flush last keyframe (compaction looks ahead)

      if (lastIndex > 0) {
        times[writeIndex] = times[lastIndex]

        for (
          var readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0;
          j !== stride;
          ++j
        ) {
          values[writeOffset + j] = values[readOffset + j]
        }

        ++writeIndex
      }

      if (writeIndex !== times.length) {
        this.times = AnimationUtils.arraySlice(times, 0, writeIndex)
        this.values = AnimationUtils.arraySlice(values, 0, writeIndex * stride)
      }

      return this
    }
  })

  /**
   *
   * A Track of vectored keyframe values.
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function VectorKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  VectorKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: VectorKeyframeTrack,

    ValueTypeName: 'vector'

    // ValueBufferType is inherited

    // DefaultInterpolation is inherited
  })

  /**
   *
   * Reusable set of Tracks that represent an animation.
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   */

  function AnimationClip(name, duration, tracks) {
    this.name = name
    this.tracks = tracks
    this.duration = duration !== undefined ? duration : -1

    this.uuid = _Math.generateUUID()

    // this means it should figure out its duration by scanning the tracks
    if (this.duration < 0) {
      this.resetDuration()
    }

    this.optimize()
  }

  Object.assign(AnimationClip, {
    parse: function (json) {
      var tracks = [],
        jsonTracks = json.tracks,
        frameTime = 1.0 / (json.fps || 1.0)

      for (var i = 0, n = jsonTracks.length; i !== n; ++i) {
        tracks.push(KeyframeTrack.parse(jsonTracks[i]).scale(frameTime))
      }

      return new AnimationClip(json.name, json.duration, tracks)
    },

    toJSON: function (clip) {
      var tracks = [],
        clipTracks = clip.tracks

      var json = {
        name: clip.name,
        duration: clip.duration,
        tracks: tracks
      }

      for (var i = 0, n = clipTracks.length; i !== n; ++i) {
        tracks.push(KeyframeTrack.toJSON(clipTracks[i]))
      }

      return json
    },

    CreateFromMorphTargetSequence: function (name, morphTargetSequence, fps, noLoop) {
      var numMorphTargets = morphTargetSequence.length
      var tracks = []

      for (var i = 0; i < numMorphTargets; i++) {
        var times = []
        var values = []

        times.push((i + numMorphTargets - 1) % numMorphTargets, i, (i + 1) % numMorphTargets)

        values.push(0, 1, 0)

        var order = AnimationUtils.getKeyframeOrder(times)
        times = AnimationUtils.sortedArray(times, 1, order)
        values = AnimationUtils.sortedArray(values, 1, order)

        // if there is a key at the first frame, duplicate it as the
        // last frame as well for perfect loop.
        if (!noLoop && times[0] === 0) {
          times.push(numMorphTargets)
          values.push(values[0])
        }

        tracks.push(
          new NumberKeyframeTrack(
            '.morphTargetInfluences[' + morphTargetSequence[i].name + ']',
            times,
            values
          ).scale(1.0 / fps)
        )
      }

      return new AnimationClip(name, -1, tracks)
    },

    findByName: function (objectOrClipArray, name) {
      var clipArray = objectOrClipArray

      if (!Array.isArray(objectOrClipArray)) {
        var o = objectOrClipArray
        clipArray = (o.geometry && o.geometry.animations) || o.animations
      }

      for (var i = 0; i < clipArray.length; i++) {
        if (clipArray[i].name === name) {
          return clipArray[i]
        }
      }

      return null
    },

    CreateClipsFromMorphTargetSequences: function (morphTargets, fps, noLoop) {
      var animationToMorphTargets = {}

      // tested with https://regex101.com/ on trick sequences
      // such flamingo_flyA_003, flamingo_run1_003, crdeath0059
      var pattern = /^([\w-]*?)([\d]+)$/

      // sort morph target names into animation groups based
      // patterns like Walk_001, Walk_002, Run_001, Run_002
      for (var i = 0, il = morphTargets.length; i < il; i++) {
        var morphTarget = morphTargets[i]
        var parts = morphTarget.name.match(pattern)

        if (parts && parts.length > 1) {
          var name = parts[1]

          var animationMorphTargets = animationToMorphTargets[name]
          if (!animationMorphTargets) {
            animationToMorphTargets[name] = animationMorphTargets = []
          }

          animationMorphTargets.push(morphTarget)
        }
      }

      var clips = []

      for (var name in animationToMorphTargets) {
        clips.push(
          AnimationClip.CreateFromMorphTargetSequence(
            name,
            animationToMorphTargets[name],
            fps,
            noLoop
          )
        )
      }

      return clips
    },

    // parse the animation.hierarchy format
    parseAnimation: function (animation, bones) {
      if (!animation) {
        console.error('THREE.AnimationClip: No animation in JSONLoader data.')
        return null
      }

      var addNonemptyTrack = function (
        trackType,
        trackName,
        animationKeys,
        propertyName,
        destTracks
      ) {
        // only return track if there are actually keys.
        if (animationKeys.length !== 0) {
          var times = []
          var values = []

          AnimationUtils.flattenJSON(animationKeys, times, values, propertyName)

          // empty keys are filtered out, so check again
          if (times.length !== 0) {
            destTracks.push(new trackType(trackName, times, values))
          }
        }
      }

      var tracks = []

      var clipName = animation.name || 'default'
      // automatic length determination in AnimationClip.
      var duration = animation.length || -1
      var fps = animation.fps || 30

      var hierarchyTracks = animation.hierarchy || []

      for (var h = 0; h < hierarchyTracks.length; h++) {
        var animationKeys = hierarchyTracks[h].keys

        // skip empty tracks
        if (!animationKeys || animationKeys.length === 0) continue

        // process morph targets
        if (animationKeys[0].morphTargets) {
          // figure out all morph targets used in this track
          var morphTargetNames = {}

          for (var k = 0; k < animationKeys.length; k++) {
            if (animationKeys[k].morphTargets) {
              for (var m = 0; m < animationKeys[k].morphTargets.length; m++) {
                morphTargetNames[animationKeys[k].morphTargets[m]] = -1
              }
            }
          }

          // create a track for each morph target with all zero
          // morphTargetInfluences except for the keys in which
          // the morphTarget is named.
          for (var morphTargetName in morphTargetNames) {
            var times = []
            var values = []

            for (var m = 0; m !== animationKeys[k].morphTargets.length; ++m) {
              var animationKey = animationKeys[k]

              times.push(animationKey.time)
              values.push(animationKey.morphTarget === morphTargetName ? 1 : 0)
            }

            tracks.push(
              new NumberKeyframeTrack(
                '.morphTargetInfluence[' + morphTargetName + ']',
                times,
                values
              )
            )
          }

          duration = morphTargetNames.length * (fps || 1.0)
        } else {
          // ...assume skeletal animation

          var boneName = '.bones[' + bones[h].name + ']'

          addNonemptyTrack(
            VectorKeyframeTrack,
            boneName + '.position',
            animationKeys,
            'pos',
            tracks
          )

          addNonemptyTrack(
            QuaternionKeyframeTrack,
            boneName + '.quaternion',
            animationKeys,
            'rot',
            tracks
          )

          addNonemptyTrack(VectorKeyframeTrack, boneName + '.scale', animationKeys, 'scl', tracks)
        }
      }

      if (tracks.length === 0) {
        return null
      }

      var clip = new AnimationClip(clipName, duration, tracks)

      return clip
    }
  })

  Object.assign(AnimationClip.prototype, {
    resetDuration: function () {
      var tracks = this.tracks,
        duration = 0

      for (var i = 0, n = tracks.length; i !== n; ++i) {
        var track = this.tracks[i]

        duration = Math.max(duration, track.times[track.times.length - 1])
      }

      this.duration = duration
    },

    trim: function () {
      for (var i = 0; i < this.tracks.length; i++) {
        this.tracks[i].trim(0, this.duration)
      }

      return this
    },

    optimize: function () {
      for (var i = 0; i < this.tracks.length; i++) {
        this.tracks[i].optimize()
      }

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function MaterialLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
    this.textures = {}
  }

  Object.assign(MaterialLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      var scope = this

      var loader = new FileLoader(scope.manager)
      loader.load(
        url,
        function (text) {
          onLoad(scope.parse(JSON.parse(text)))
        },
        onProgress,
        onError
      )
    },

    setTextures: function (value) {
      this.textures = value
    },

    parse: function (json) {
      var textures = this.textures

      function getTexture(name) {
        if (textures[name] === undefined) {
          console.warn('THREE.MaterialLoader: Undefined texture', name)
        }

        return textures[name]
      }

      var material = new Materials[json.type]()

      if (json.uuid !== undefined) material.uuid = json.uuid
      if (json.name !== undefined) material.name = json.name
      if (json.color !== undefined) material.color.setHex(json.color)
      if (json.roughness !== undefined) material.roughness = json.roughness
      if (json.metalness !== undefined) material.metalness = json.metalness
      if (json.emissive !== undefined) material.emissive.setHex(json.emissive)
      if (json.specular !== undefined) material.specular.setHex(json.specular)
      if (json.shininess !== undefined) material.shininess = json.shininess
      if (json.clearCoat !== undefined) material.clearCoat = json.clearCoat
      if (json.clearCoatRoughness !== undefined)
        material.clearCoatRoughness = json.clearCoatRoughness
      if (json.uniforms !== undefined) material.uniforms = json.uniforms
      if (json.vertexShader !== undefined) material.vertexShader = json.vertexShader
      if (json.fragmentShader !== undefined) material.fragmentShader = json.fragmentShader
      if (json.vertexColors !== undefined) material.vertexColors = json.vertexColors
      if (json.fog !== undefined) material.fog = json.fog
      if (json.flatShading !== undefined) material.flatShading = json.flatShading
      if (json.blending !== undefined) material.blending = json.blending
      if (json.side !== undefined) material.side = json.side
      if (json.opacity !== undefined) material.opacity = json.opacity
      if (json.transparent !== undefined) material.transparent = json.transparent
      if (json.alphaTest !== undefined) material.alphaTest = json.alphaTest
      if (json.depthTest !== undefined) material.depthTest = json.depthTest
      if (json.depthWrite !== undefined) material.depthWrite = json.depthWrite
      if (json.colorWrite !== undefined) material.colorWrite = json.colorWrite
      if (json.wireframe !== undefined) material.wireframe = json.wireframe
      if (json.wireframeLinewidth !== undefined)
        material.wireframeLinewidth = json.wireframeLinewidth
      if (json.wireframeLinecap !== undefined) material.wireframeLinecap = json.wireframeLinecap
      if (json.wireframeLinejoin !== undefined) material.wireframeLinejoin = json.wireframeLinejoin

      if (json.rotation !== undefined) material.rotation = json.rotation

      if (json.linewidth !== 1) material.linewidth = json.linewidth
      if (json.dashSize !== undefined) material.dashSize = json.dashSize
      if (json.gapSize !== undefined) material.gapSize = json.gapSize
      if (json.scale !== undefined) material.scale = json.scale

      if (json.skinning !== undefined) material.skinning = json.skinning
      if (json.morphTargets !== undefined) material.morphTargets = json.morphTargets
      if (json.dithering !== undefined) material.dithering = json.dithering

      if (json.visible !== undefined) material.visible = json.visible
      if (json.userData !== undefined) material.userData = json.userData

      // Deprecated

      if (json.shading !== undefined) material.flatShading = json.shading === 1 // THREE.FlatShading

      // for PointsMaterial

      if (json.size !== undefined) material.size = json.size
      if (json.sizeAttenuation !== undefined) material.sizeAttenuation = json.sizeAttenuation

      // maps

      if (json.map !== undefined) material.map = getTexture(json.map)

      if (json.alphaMap !== undefined) {
        material.alphaMap = getTexture(json.alphaMap)
        material.transparent = true
      }

      if (json.bumpMap !== undefined) material.bumpMap = getTexture(json.bumpMap)
      if (json.bumpScale !== undefined) material.bumpScale = json.bumpScale

      if (json.normalMap !== undefined) material.normalMap = getTexture(json.normalMap)
      if (json.normalScale !== undefined) {
        var normalScale = json.normalScale

        if (Array.isArray(normalScale) === false) {
          // Blender exporter used to export a scalar. See #7459

          normalScale = [normalScale, normalScale]
        }

        material.normalScale = new Vector2().fromArray(normalScale)
      }

      if (json.displacementMap !== undefined)
        material.displacementMap = getTexture(json.displacementMap)
      if (json.displacementScale !== undefined) material.displacementScale = json.displacementScale
      if (json.displacementBias !== undefined) material.displacementBias = json.displacementBias

      if (json.roughnessMap !== undefined) material.roughnessMap = getTexture(json.roughnessMap)
      if (json.metalnessMap !== undefined) material.metalnessMap = getTexture(json.metalnessMap)

      if (json.emissiveMap !== undefined) material.emissiveMap = getTexture(json.emissiveMap)
      if (json.emissiveIntensity !== undefined) material.emissiveIntensity = json.emissiveIntensity

      if (json.specularMap !== undefined) material.specularMap = getTexture(json.specularMap)

      if (json.envMap !== undefined) material.envMap = getTexture(json.envMap)

      if (json.reflectivity !== undefined) material.reflectivity = json.reflectivity

      if (json.lightMap !== undefined) material.lightMap = getTexture(json.lightMap)
      if (json.lightMapIntensity !== undefined) material.lightMapIntensity = json.lightMapIntensity

      if (json.aoMap !== undefined) material.aoMap = getTexture(json.aoMap)
      if (json.aoMapIntensity !== undefined) material.aoMapIntensity = json.aoMapIntensity

      if (json.gradientMap !== undefined) material.gradientMap = getTexture(json.gradientMap)

      return material
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function BufferGeometryLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
  }

  Object.assign(BufferGeometryLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      var scope = this

      var loader = new FileLoader(scope.manager)
      loader.load(
        url,
        function (text) {
          onLoad(scope.parse(JSON.parse(text)))
        },
        onProgress,
        onError
      )
    },

    parse: function (json) {
      var geometry = new BufferGeometry()

      var index = json.data.index

      if (index !== undefined) {
        var typedArray = new TYPED_ARRAYS[index.type](index.array)
        geometry.setIndex(new BufferAttribute(typedArray, 1))
      }

      var attributes = json.data.attributes

      for (var key in attributes) {
        var attribute = attributes[key]
        var typedArray = new TYPED_ARRAYS[attribute.type](attribute.array)

        geometry.addAttribute(
          key,
          new BufferAttribute(typedArray, attribute.itemSize, attribute.normalized)
        )
      }

      var groups = json.data.groups || json.data.drawcalls || json.data.offsets

      if (groups !== undefined) {
        for (var i = 0, n = groups.length; i !== n; ++i) {
          var group = groups[i]

          geometry.addGroup(group.start, group.count, group.materialIndex)
        }
      }

      var boundingSphere = json.data.boundingSphere

      if (boundingSphere !== undefined) {
        var center = new Vector3()

        if (boundingSphere.center !== undefined) {
          center.fromArray(boundingSphere.center)
        }

        geometry.boundingSphere = new Sphere(center, boundingSphere.radius)
      }

      return geometry
    }
  })

  var TYPED_ARRAYS = {
    Int8Array: Int8Array,
    Uint8Array: Uint8Array,
    // Workaround for IE11 pre KB2929437. See #11440
    Uint8ClampedArray: typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : Uint8Array,
    Int16Array: Int16Array,
    Uint16Array: Uint16Array,
    Int32Array: Int32Array,
    Uint32Array: Uint32Array,
    Float32Array: Float32Array,
    Float64Array: Float64Array
  }

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function Loader() {
    this.onLoadStart = function () {}
    this.onLoadProgress = function () {}
    this.onLoadComplete = function () {}
  }

  Loader.Handlers = {
    handlers: [],

    add: function (regex, loader) {
      this.handlers.push(regex, loader)
    },

    get: function (file) {
      var handlers = this.handlers

      for (var i = 0, l = handlers.length; i < l; i += 2) {
        var regex = handlers[i]
        var loader = handlers[i + 1]

        if (regex.test(file)) {
          return loader
        }
      }

      return null
    }
  }

  Object.assign(Loader.prototype, {
    crossOrigin: undefined,

    initMaterials: function (materials, texturePath, crossOrigin) {
      var array = []

      for (var i = 0; i < materials.length; ++i) {
        array[i] = this.createMaterial(materials[i], texturePath, crossOrigin)
      }

      return array
    },

    createMaterial: (function () {
      var BlendingMode = {
        NoBlending: NoBlending,
        NormalBlending: NormalBlending,
        AdditiveBlending: AdditiveBlending,
        SubtractiveBlending: SubtractiveBlending,
        MultiplyBlending: MultiplyBlending,
        CustomBlending: CustomBlending
      }

      var color = new Color()
      var textureLoader = new TextureLoader()
      var materialLoader = new MaterialLoader()

      return function createMaterial(m, texturePath, crossOrigin) {
        // convert from old material format

        var textures = {}

        function loadTexture(path, repeat, offset, wrap, anisotropy) {
          var fullPath = texturePath + path
          var loader = Loader.Handlers.get(fullPath)

          var texture

          if (loader !== null) {
            texture = loader.load(fullPath)
          } else {
            textureLoader.setCrossOrigin(crossOrigin)
            texture = textureLoader.load(fullPath)
          }

          if (repeat !== undefined) {
            texture.repeat.fromArray(repeat)

            if (repeat[0] !== 1) texture.wrapS = RepeatWrapping
            if (repeat[1] !== 1) texture.wrapT = RepeatWrapping
          }

          if (offset !== undefined) {
            texture.offset.fromArray(offset)
          }

          if (wrap !== undefined) {
            if (wrap[0] === 'repeat') texture.wrapS = RepeatWrapping
            if (wrap[0] === 'mirror') texture.wrapS = MirroredRepeatWrapping

            if (wrap[1] === 'repeat') texture.wrapT = RepeatWrapping
            if (wrap[1] === 'mirror') texture.wrapT = MirroredRepeatWrapping
          }

          if (anisotropy !== undefined) {
            texture.anisotropy = anisotropy
          }

          var uuid = _Math.generateUUID()

          textures[uuid] = texture

          return uuid
        }

        //

        var json = {
          uuid: _Math.generateUUID(),
          type: 'MeshLambertMaterial'
        }

        for (var name in m) {
          var value = m[name]

          switch (name) {
            case 'DbgColor':
            case 'DbgIndex':
            case 'opticalDensity':
            case 'illumination':
              break
            case 'DbgName':
              json.name = value
              break
            case 'blending':
              json.blending = BlendingMode[value]
              break
            case 'colorAmbient':
            case 'mapAmbient':
              console.warn('THREE.Loader.createMaterial:', name, 'is no longer supported.')
              break
            case 'colorDiffuse':
              json.color = color.fromArray(value).getHex()
              break
            case 'colorSpecular':
              json.specular = color.fromArray(value).getHex()
              break
            case 'colorEmissive':
              json.emissive = color.fromArray(value).getHex()
              break
            case 'specularCoef':
              json.shininess = value
              break
            case 'shading':
              if (value.toLowerCase() === 'basic') json.type = 'MeshBasicMaterial'
              if (value.toLowerCase() === 'phong') json.type = 'MeshPhongMaterial'
              if (value.toLowerCase() === 'standard') json.type = 'MeshStandardMaterial'
              break
            case 'mapDiffuse':
              json.map = loadTexture(
                value,
                m.mapDiffuseRepeat,
                m.mapDiffuseOffset,
                m.mapDiffuseWrap,
                m.mapDiffuseAnisotropy
              )
              break
            case 'mapDiffuseRepeat':
            case 'mapDiffuseOffset':
            case 'mapDiffuseWrap':
            case 'mapDiffuseAnisotropy':
              break
            case 'mapEmissive':
              json.emissiveMap = loadTexture(
                value,
                m.mapEmissiveRepeat,
                m.mapEmissiveOffset,
                m.mapEmissiveWrap,
                m.mapEmissiveAnisotropy
              )
              break
            case 'mapEmissiveRepeat':
            case 'mapEmissiveOffset':
            case 'mapEmissiveWrap':
            case 'mapEmissiveAnisotropy':
              break
            case 'mapLight':
              json.lightMap = loadTexture(
                value,
                m.mapLightRepeat,
                m.mapLightOffset,
                m.mapLightWrap,
                m.mapLightAnisotropy
              )
              break
            case 'mapLightRepeat':
            case 'mapLightOffset':
            case 'mapLightWrap':
            case 'mapLightAnisotropy':
              break
            case 'mapAO':
              json.aoMap = loadTexture(
                value,
                m.mapAORepeat,
                m.mapAOOffset,
                m.mapAOWrap,
                m.mapAOAnisotropy
              )
              break
            case 'mapAORepeat':
            case 'mapAOOffset':
            case 'mapAOWrap':
            case 'mapAOAnisotropy':
              break
            case 'mapBump':
              json.bumpMap = loadTexture(
                value,
                m.mapBumpRepeat,
                m.mapBumpOffset,
                m.mapBumpWrap,
                m.mapBumpAnisotropy
              )
              break
            case 'mapBumpScale':
              json.bumpScale = value
              break
            case 'mapBumpRepeat':
            case 'mapBumpOffset':
            case 'mapBumpWrap':
            case 'mapBumpAnisotropy':
              break
            case 'mapNormal':
              json.normalMap = loadTexture(
                value,
                m.mapNormalRepeat,
                m.mapNormalOffset,
                m.mapNormalWrap,
                m.mapNormalAnisotropy
              )
              break
            case 'mapNormalFactor':
              json.normalScale = [value, value]
              break
            case 'mapNormalRepeat':
            case 'mapNormalOffset':
            case 'mapNormalWrap':
            case 'mapNormalAnisotropy':
              break
            case 'mapSpecular':
              json.specularMap = loadTexture(
                value,
                m.mapSpecularRepeat,
                m.mapSpecularOffset,
                m.mapSpecularWrap,
                m.mapSpecularAnisotropy
              )
              break
            case 'mapSpecularRepeat':
            case 'mapSpecularOffset':
            case 'mapSpecularWrap':
            case 'mapSpecularAnisotropy':
              break
            case 'mapMetalness':
              json.metalnessMap = loadTexture(
                value,
                m.mapMetalnessRepeat,
                m.mapMetalnessOffset,
                m.mapMetalnessWrap,
                m.mapMetalnessAnisotropy
              )
              break
            case 'mapMetalnessRepeat':
            case 'mapMetalnessOffset':
            case 'mapMetalnessWrap':
            case 'mapMetalnessAnisotropy':
              break
            case 'mapRoughness':
              json.roughnessMap = loadTexture(
                value,
                m.mapRoughnessRepeat,
                m.mapRoughnessOffset,
                m.mapRoughnessWrap,
                m.mapRoughnessAnisotropy
              )
              break
            case 'mapRoughnessRepeat':
            case 'mapRoughnessOffset':
            case 'mapRoughnessWrap':
            case 'mapRoughnessAnisotropy':
              break
            case 'mapAlpha':
              json.alphaMap = loadTexture(
                value,
                m.mapAlphaRepeat,
                m.mapAlphaOffset,
                m.mapAlphaWrap,
                m.mapAlphaAnisotropy
              )
              break
            case 'mapAlphaRepeat':
            case 'mapAlphaOffset':
            case 'mapAlphaWrap':
            case 'mapAlphaAnisotropy':
              break
            case 'flipSided':
              json.side = BackSide
              break
            case 'doubleSided':
              json.side = DoubleSide
              break
            case 'transparency':
              console.warn('THREE.Loader.createMaterial: transparency has been renamed to opacity')
              json.opacity = value
              break
            case 'depthTest':
            case 'depthWrite':
            case 'colorWrite':
            case 'opacity':
            case 'reflectivity':
            case 'transparent':
            case 'visible':
            case 'wireframe':
              json[name] = value
              break
            case 'vertexColors':
              if (value === true) json.vertexColors = VertexColors
              if (value === 'face') json.vertexColors = FaceColors
              break
            default:
              console.error('THREE.Loader.createMaterial: Unsupported', name, value)
              break
          }
        }

        if (json.type === 'MeshBasicMaterial') delete json.emissive
        if (json.type !== 'MeshPhongMaterial') delete json.specular

        if (json.opacity < 1) json.transparent = true

        materialLoader.setTextures(textures)

        return materialLoader.parse(json)
      }
    })()
  })

  /**
   * @author Don McCurdy / https://www.donmccurdy.com
   */

  var LoaderUtils = {
    decodeText: function (array) {
      if (typeof TextDecoder !== 'undefined') {
        return new TextDecoder().decode(array)
      }

      // Avoid the String.fromCharCode.apply(null, array) shortcut, which
      // throws a "maximum call stack size exceeded" error for large arrays.

      var s = ''

      for (var i = 0, il = array.length; i < il; i++) {
        // Implicitly assumes little-endian.
        s += String.fromCharCode(array[i])
      }

      // Merges multi-byte utf-8 characters.
      return decodeURIComponent(escape(s))
    },

    extractUrlBase: function (url) {
      var parts = url.split('/')

      if (parts.length === 1) return './'

      parts.pop()

      return parts.join('/') + '/'
    }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author alteredq / http://alteredqualia.com/
   */

  function JSONLoader(manager) {
    if (typeof manager === 'boolean') {
      console.warn('THREE.JSONLoader: showStatus parameter has been removed from constructor.')
      manager = undefined
    }

    this.manager = manager !== undefined ? manager : DefaultLoadingManager

    this.withCredentials = false
  }

  Object.assign(JSONLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      var scope = this

      var texturePath =
        this.texturePath && typeof this.texturePath === 'string'
          ? this.texturePath
          : LoaderUtils.extractUrlBase(url)

      var loader = new FileLoader(this.manager)
      loader.setWithCredentials(this.withCredentials)
      loader.load(
        url,
        function (text) {
          var json = JSON.parse(text)
          var metadata = json.metadata

          if (metadata !== undefined) {
            var type = metadata.type

            if (type !== undefined) {
              if (type.toLowerCase() === 'object') {
                console.error(
                  'THREE.JSONLoader: ' + url + ' should be loaded with THREE.ObjectLoader instead.'
                )
                return
              }

              if (type.toLowerCase() === 'scene') {
                console.error(
                  'THREE.JSONLoader: ' + url + ' should be loaded with THREE.SceneLoader instead.'
                )
                return
              }
            }
          }

          var object = scope.parse(json, texturePath)
          onLoad(object.geometry, object.materials)
        },
        onProgress,
        onError
      )
    },

    setTexturePath: function (value) {
      this.texturePath = value
    },

    parse: (function () {
      function parseModel(json, geometry) {
        function isBitSet(value, position) {
          return value & (1 << position)
        }

        var i,
          j,
          fi,
          offset,
          zLength,
          colorIndex,
          normalIndex,
          uvIndex,
          materialIndex,
          type,
          isQuad,
          hasMaterial,
          hasFaceVertexUv,
          hasFaceNormal,
          hasFaceVertexNormal,
          hasFaceColor,
          hasFaceVertexColor,
          vertex,
          face,
          faceA,
          faceB,
          hex,
          normal,
          uvLayer,
          uv,
          u,
          v,
          faces = json.faces,
          vertices = json.vertices,
          normals = json.normals,
          colors = json.colors,
          scale = json.scale,
          nUvLayers = 0

        if (json.uvs !== undefined) {
          // disregard empty arrays

          for (i = 0; i < json.uvs.length; i++) {
            if (json.uvs[i].length) nUvLayers++
          }

          for (i = 0; i < nUvLayers; i++) {
            geometry.faceVertexUvs[i] = []
          }
        }

        offset = 0
        zLength = vertices.length

        while (offset < zLength) {
          vertex = new Vector3()

          vertex.x = vertices[offset++] * scale
          vertex.y = vertices[offset++] * scale
          vertex.z = vertices[offset++] * scale

          geometry.vertices.push(vertex)
        }

        offset = 0
        zLength = faces.length

        while (offset < zLength) {
          type = faces[offset++]

          isQuad = isBitSet(type, 0)
          hasMaterial = isBitSet(type, 1)
          hasFaceVertexUv = isBitSet(type, 3)
          hasFaceNormal = isBitSet(type, 4)
          hasFaceVertexNormal = isBitSet(type, 5)
          hasFaceColor = isBitSet(type, 6)
          hasFaceVertexColor = isBitSet(type, 7)

          // console.log("type", type, "bits", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor);

          if (isQuad) {
            faceA = new Face3()
            faceA.a = faces[offset]
            faceA.b = faces[offset + 1]
            faceA.c = faces[offset + 3]

            faceB = new Face3()
            faceB.a = faces[offset + 1]
            faceB.b = faces[offset + 2]
            faceB.c = faces[offset + 3]

            offset += 4

            if (hasMaterial) {
              materialIndex = faces[offset++]
              faceA.materialIndex = materialIndex
              faceB.materialIndex = materialIndex
            }

            // to get face <=> uv index correspondence

            fi = geometry.faces.length

            if (hasFaceVertexUv) {
              for (i = 0; i < nUvLayers; i++) {
                uvLayer = json.uvs[i]

                geometry.faceVertexUvs[i][fi] = []
                geometry.faceVertexUvs[i][fi + 1] = []

                for (j = 0; j < 4; j++) {
                  uvIndex = faces[offset++]

                  u = uvLayer[uvIndex * 2]
                  v = uvLayer[uvIndex * 2 + 1]

                  uv = new Vector2(u, v)

                  if (j !== 2) geometry.faceVertexUvs[i][fi].push(uv)
                  if (j !== 0) geometry.faceVertexUvs[i][fi + 1].push(uv)
                }
              }
            }

            if (hasFaceNormal) {
              normalIndex = faces[offset++] * 3

              faceA.normal.set(normals[normalIndex++], normals[normalIndex++], normals[normalIndex])

              faceB.normal.copy(faceA.normal)
            }

            if (hasFaceVertexNormal) {
              for (i = 0; i < 4; i++) {
                normalIndex = faces[offset++] * 3

                normal = new Vector3(
                  normals[normalIndex++],
                  normals[normalIndex++],
                  normals[normalIndex]
                )

                if (i !== 2) faceA.vertexNormals.push(normal)
                if (i !== 0) faceB.vertexNormals.push(normal)
              }
            }

            if (hasFaceColor) {
              colorIndex = faces[offset++]
              hex = colors[colorIndex]

              faceA.color.setHex(hex)
              faceB.color.setHex(hex)
            }

            if (hasFaceVertexColor) {
              for (i = 0; i < 4; i++) {
                colorIndex = faces[offset++]
                hex = colors[colorIndex]

                if (i !== 2) faceA.vertexColors.push(new Color(hex))
                if (i !== 0) faceB.vertexColors.push(new Color(hex))
              }
            }

            geometry.faces.push(faceA)
            geometry.faces.push(faceB)
          } else {
            face = new Face3()
            face.a = faces[offset++]
            face.b = faces[offset++]
            face.c = faces[offset++]

            if (hasMaterial) {
              materialIndex = faces[offset++]
              face.materialIndex = materialIndex
            }

            // to get face <=> uv index correspondence

            fi = geometry.faces.length

            if (hasFaceVertexUv) {
              for (i = 0; i < nUvLayers; i++) {
                uvLayer = json.uvs[i]

                geometry.faceVertexUvs[i][fi] = []

                for (j = 0; j < 3; j++) {
                  uvIndex = faces[offset++]

                  u = uvLayer[uvIndex * 2]
                  v = uvLayer[uvIndex * 2 + 1]

                  uv = new Vector2(u, v)

                  geometry.faceVertexUvs[i][fi].push(uv)
                }
              }
            }

            if (hasFaceNormal) {
              normalIndex = faces[offset++] * 3

              face.normal.set(normals[normalIndex++], normals[normalIndex++], normals[normalIndex])
            }

            if (hasFaceVertexNormal) {
              for (i = 0; i < 3; i++) {
                normalIndex = faces[offset++] * 3

                normal = new Vector3(
                  normals[normalIndex++],
                  normals[normalIndex++],
                  normals[normalIndex]
                )

                face.vertexNormals.push(normal)
              }
            }

            if (hasFaceColor) {
              colorIndex = faces[offset++]
              face.color.setHex(colors[colorIndex])
            }

            if (hasFaceVertexColor) {
              for (i = 0; i < 3; i++) {
                colorIndex = faces[offset++]
                face.vertexColors.push(new Color(colors[colorIndex]))
              }
            }

            geometry.faces.push(face)
          }
        }
      }

      function parseSkin(json, geometry) {
        var influencesPerVertex =
          json.influencesPerVertex !== undefined ? json.influencesPerVertex : 2

        if (json.skinWeights) {
          for (var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex) {
            var x = json.skinWeights[i]
            var y = influencesPerVertex > 1 ? json.skinWeights[i + 1] : 0
            var z = influencesPerVertex > 2 ? json.skinWeights[i + 2] : 0
            var w = influencesPerVertex > 3 ? json.skinWeights[i + 3] : 0

            geometry.skinWeights.push(new Vector4(x, y, z, w))
          }
        }

        if (json.skinIndices) {
          for (var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex) {
            var a = json.skinIndices[i]
            var b = influencesPerVertex > 1 ? json.skinIndices[i + 1] : 0
            var c = influencesPerVertex > 2 ? json.skinIndices[i + 2] : 0
            var d = influencesPerVertex > 3 ? json.skinIndices[i + 3] : 0

            geometry.skinIndices.push(new Vector4(a, b, c, d))
          }
        }

        geometry.bones = json.bones

        if (
          geometry.bones &&
          geometry.bones.length > 0 &&
          (geometry.skinWeights.length !== geometry.skinIndices.length ||
            geometry.skinIndices.length !== geometry.vertices.length)
        ) {
          console.warn(
            'When skinning, number of vertices (' +
              geometry.vertices.length +
              '), skinIndices (' +
              geometry.skinIndices.length +
              '), and skinWeights (' +
              geometry.skinWeights.length +
              ') should match.'
          )
        }
      }

      function parseMorphing(json, geometry) {
        var scale = json.scale

        if (json.morphTargets !== undefined) {
          for (var i = 0, l = json.morphTargets.length; i < l; i++) {
            geometry.morphTargets[i] = {}
            geometry.morphTargets[i].name = json.morphTargets[i].name
            geometry.morphTargets[i].vertices = []

            var dstVertices = geometry.morphTargets[i].vertices
            var srcVertices = json.morphTargets[i].vertices

            for (var v = 0, vl = srcVertices.length; v < vl; v += 3) {
              var vertex = new Vector3()
              vertex.x = srcVertices[v] * scale
              vertex.y = srcVertices[v + 1] * scale
              vertex.z = srcVertices[v + 2] * scale

              dstVertices.push(vertex)
            }
          }
        }

        if (json.morphColors !== undefined && json.morphColors.length > 0) {
          console.warn(
            'THREE.JSONLoader: "morphColors" no longer supported. Using them as face colors.'
          )

          var faces = geometry.faces
          var morphColors = json.morphColors[0].colors

          for (var i = 0, l = faces.length; i < l; i++) {
            faces[i].color.fromArray(morphColors, i * 3)
          }
        }
      }

      function parseAnimations(json, geometry) {
        var outputAnimations = []

        // parse old style Bone/Hierarchy animations
        var animations = []

        if (json.animation !== undefined) {
          animations.push(json.animation)
        }

        if (json.animations !== undefined) {
          if (json.animations.length) {
            animations = animations.concat(json.animations)
          } else {
            animations.push(json.animations)
          }
        }

        for (var i = 0; i < animations.length; i++) {
          var clip = AnimationClip.parseAnimation(animations[i], geometry.bones)
          if (clip) outputAnimations.push(clip)
        }

        // parse implicit morph animations
        if (geometry.morphTargets) {
          // TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary.
          var morphAnimationClips = AnimationClip.CreateClipsFromMorphTargetSequences(
            geometry.morphTargets,
            10
          )
          outputAnimations = outputAnimations.concat(morphAnimationClips)
        }

        if (outputAnimations.length > 0) geometry.animations = outputAnimations
      }

      return function parse(json, texturePath) {
        if (json.data !== undefined) {
          // Geometry 4.0 spec
          json = json.data
        }

        if (json.scale !== undefined) {
          json.scale = 1.0 / json.scale
        } else {
          json.scale = 1.0
        }

        var geometry = new Geometry()

        parseModel(json, geometry)
        parseSkin(json, geometry)
        parseMorphing(json, geometry)
        parseAnimations(json, geometry)

        geometry.computeFaceNormals()
        geometry.computeBoundingSphere()

        if (json.materials === undefined || json.materials.length === 0) {
          return { geometry: geometry }
        } else {
          var materials = Loader.prototype.initMaterials(
            json.materials,
            texturePath,
            this.crossOrigin
          )

          return { geometry: geometry, materials: materials }
        }
      }
    })()
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function ObjectLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
    this.texturePath = ''
  }

  Object.assign(ObjectLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      if (this.texturePath === '') {
        this.texturePath = url.substring(0, url.lastIndexOf('/') + 1)
      }

      var scope = this

      var loader = new FileLoader(scope.manager)
      loader.load(
        url,
        function (text) {
          var json = null

          try {
            json = JSON.parse(text)
          } catch (error) {
            if (onError !== undefined) onError(error)

            console.error("THREE:ObjectLoader: Can't parse " + url + '.', error.message)

            return
          }

          var metadata = json.metadata

          if (
            metadata === undefined ||
            metadata.type === undefined ||
            metadata.type.toLowerCase() === 'geometry'
          ) {
            console.error(
              "THREE.ObjectLoader: Can't load " + url + '. Use THREE.JSONLoader instead.'
            )
            return
          }

          scope.parse(json, onLoad)
        },
        onProgress,
        onError
      )
    },

    setTexturePath: function (value) {
      this.texturePath = value
    },

    setCrossOrigin: function (value) {
      this.crossOrigin = value
    },

    parse: function (json, onLoad) {
      var shapes = this.parseShape(json.shapes)
      var geometries = this.parseGeometries(json.geometries, shapes)

      var images = this.parseImages(json.images, function () {
        if (onLoad !== undefined) onLoad(object)
      })

      var textures = this.parseTextures(json.textures, images)
      var materials = this.parseMaterials(json.materials, textures)

      var object = this.parseObject(json.object, geometries, materials)

      if (json.animations) {
        object.animations = this.parseAnimations(json.animations)
      }

      if (json.images === undefined || json.images.length === 0) {
        if (onLoad !== undefined) onLoad(object)
      }

      return object
    },

    parseShape: function (json) {
      var shapes = {}

      if (json !== undefined) {
        for (var i = 0, l = json.length; i < l; i++) {
          var shape = new Shape().fromJSON(json[i])

          shapes[shape.uuid] = shape
        }
      }

      return shapes
    },

    parseGeometries: function (json, shapes) {
      var geometries = {}

      if (json !== undefined) {
        var geometryLoader = new JSONLoader()
        var bufferGeometryLoader = new BufferGeometryLoader()

        for (var i = 0, l = json.length; i < l; i++) {
          var geometry
          var data = json[i]

          switch (data.type) {
            case 'PlaneGeometry':
            case 'PlaneBufferGeometry':
              geometry = new Geometries[data.type](
                data.width,
                data.height,
                data.widthSegments,
                data.heightSegments
              )

              break

            case 'BoxGeometry':
            case 'BoxBufferGeometry':
            case 'CubeGeometry': // backwards compatible
              geometry = new Geometries[data.type](
                data.width,
                data.height,
                data.depth,
                data.widthSegments,
                data.heightSegments,
                data.depthSegments
              )

              break

            case 'CircleGeometry':
            case 'CircleBufferGeometry':
              geometry = new Geometries[data.type](
                data.radius,
                data.segments,
                data.thetaStart,
                data.thetaLength
              )

              break

            case 'CylinderGeometry':
            case 'CylinderBufferGeometry':
              geometry = new Geometries[data.type](
                data.radiusTop,
                data.radiusBottom,
                data.height,
                data.radialSegments,
                data.heightSegments,
                data.openEnded,
                data.thetaStart,
                data.thetaLength
              )

              break

            case 'ConeGeometry':
            case 'ConeBufferGeometry':
              geometry = new Geometries[data.type](
                data.radius,
                data.height,
                data.radialSegments,
                data.heightSegments,
                data.openEnded,
                data.thetaStart,
                data.thetaLength
              )

              break

            case 'SphereGeometry':
            case 'SphereBufferGeometry':
              geometry = new Geometries[data.type](
                data.radius,
                data.widthSegments,
                data.heightSegments,
                data.phiStart,
                data.phiLength,
                data.thetaStart,
                data.thetaLength
              )

              break

            case 'DodecahedronGeometry':
            case 'DodecahedronBufferGeometry':
            case 'IcosahedronGeometry':
            case 'IcosahedronBufferGeometry':
            case 'OctahedronGeometry':
            case 'OctahedronBufferGeometry':
            case 'TetrahedronGeometry':
            case 'TetrahedronBufferGeometry':
              geometry = new Geometries[data.type](data.radius, data.detail)

              break

            case 'RingGeometry':
            case 'RingBufferGeometry':
              geometry = new Geometries[data.type](
                data.innerRadius,
                data.outerRadius,
                data.thetaSegments,
                data.phiSegments,
                data.thetaStart,
                data.thetaLength
              )

              break

            case 'TorusGeometry':
            case 'TorusBufferGeometry':
              geometry = new Geometries[data.type](
                data.radius,
                data.tube,
                data.radialSegments,
                data.tubularSegments,
                data.arc
              )

              break

            case 'TorusKnotGeometry':
            case 'TorusKnotBufferGeometry':
              geometry = new Geometries[data.type](
                data.radius,
                data.tube,
                data.tubularSegments,
                data.radialSegments,
                data.p,
                data.q
              )

              break

            case 'LatheGeometry':
            case 'LatheBufferGeometry':
              geometry = new Geometries[data.type](
                data.points,
                data.segments,
                data.phiStart,
                data.phiLength
              )

              break

            case 'PolyhedronGeometry':
            case 'PolyhedronBufferGeometry':
              geometry = new Geometries[data.type](
                data.vertices,
                data.indices,
                data.radius,
                data.details
              )

              break

            case 'ShapeGeometry':
            case 'ShapeBufferGeometry':
              var geometryShapes = []

              for (var i = 0, l = data.shapes.length; i < l; i++) {
                var shape = shapes[data.shapes[i]]

                geometryShapes.push(shape)
              }

              geometry = new Geometries[data.type](geometryShapes, data.curveSegments)

              break

            case 'BufferGeometry':
              geometry = bufferGeometryLoader.parse(data)

              break

            case 'Geometry':
              geometry = geometryLoader.parse(data, this.texturePath).geometry

              break

            default:
              console.warn('THREE.ObjectLoader: Unsupported geometry type "' + data.type + '"')

              continue
          }

          geometry.uuid = data.uuid

          if (data.name !== undefined) geometry.name = data.name

          geometries[data.uuid] = geometry
        }
      }

      return geometries
    },

    parseMaterials: function (json, textures) {
      var materials = {}

      if (json !== undefined) {
        var loader = new MaterialLoader()
        loader.setTextures(textures)

        for (var i = 0, l = json.length; i < l; i++) {
          var data = json[i]

          if (data.type === 'MultiMaterial') {
            // Deprecated

            var array = []

            for (var j = 0; j < data.materials.length; j++) {
              array.push(loader.parse(data.materials[j]))
            }

            materials[data.uuid] = array
          } else {
            materials[data.uuid] = loader.parse(data)
          }
        }
      }

      return materials
    },

    parseAnimations: function (json) {
      var animations = []

      for (var i = 0; i < json.length; i++) {
        var clip = AnimationClip.parse(json[i])

        animations.push(clip)
      }

      return animations
    },

    parseImages: function (json, onLoad) {
      var scope = this
      var images = {}

      function loadImage(url) {
        scope.manager.itemStart(url)

        return loader.load(
          url,
          function () {
            scope.manager.itemEnd(url)
          },
          undefined,
          function () {
            scope.manager.itemEnd(url)
            scope.manager.itemError(url)
          }
        )
      }

      if (json !== undefined && json.length > 0) {
        var manager = new LoadingManager(onLoad)

        var loader = new ImageLoader(manager)
        loader.setCrossOrigin(this.crossOrigin)

        for (var i = 0, l = json.length; i < l; i++) {
          var image = json[i]
          var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test(image.url)
            ? image.url
            : scope.texturePath + image.url

          images[image.uuid] = loadImage(path)
        }
      }

      return images
    },

    parseTextures: function (json, images) {
      function parseConstant(value, type) {
        if (typeof value === 'number') return value

        console.warn('THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value)

        return type[value]
      }

      var textures = {}

      if (json !== undefined) {
        for (var i = 0, l = json.length; i < l; i++) {
          var data = json[i]

          if (data.image === undefined) {
            console.warn('THREE.ObjectLoader: No "image" specified for', data.uuid)
          }

          if (images[data.image] === undefined) {
            console.warn('THREE.ObjectLoader: Undefined image', data.image)
          }

          var texture = new Texture(images[data.image])
          texture.needsUpdate = true

          texture.uuid = data.uuid

          if (data.name !== undefined) texture.name = data.name

          if (data.mapping !== undefined)
            texture.mapping = parseConstant(data.mapping, TEXTURE_MAPPING)

          if (data.offset !== undefined) texture.offset.fromArray(data.offset)
          if (data.repeat !== undefined) texture.repeat.fromArray(data.repeat)
          if (data.center !== undefined) texture.center.fromArray(data.center)
          if (data.rotation !== undefined) texture.rotation = data.rotation

          if (data.wrap !== undefined) {
            texture.wrapS = parseConstant(data.wrap[0], TEXTURE_WRAPPING)
            texture.wrapT = parseConstant(data.wrap[1], TEXTURE_WRAPPING)
          }

          if (data.minFilter !== undefined)
            texture.minFilter = parseConstant(data.minFilter, TEXTURE_FILTER)
          if (data.magFilter !== undefined)
            texture.magFilter = parseConstant(data.magFilter, TEXTURE_FILTER)
          if (data.anisotropy !== undefined) texture.anisotropy = data.anisotropy

          if (data.flipY !== undefined) texture.flipY = data.flipY

          textures[data.uuid] = texture
        }
      }

      return textures
    },

    parseObject: function (data, geometries, materials) {
      var object

      function getGeometry(name) {
        if (geometries[name] === undefined) {
          console.warn('THREE.ObjectLoader: Undefined geometry', name)
        }

        return geometries[name]
      }

      function getMaterial(name) {
        if (name === undefined) return undefined

        if (Array.isArray(name)) {
          var array = []

          for (var i = 0, l = name.length; i < l; i++) {
            var uuid = name[i]

            if (materials[uuid] === undefined) {
              console.warn('THREE.ObjectLoader: Undefined material', uuid)
            }

            array.push(materials[uuid])
          }

          return array
        }

        if (materials[name] === undefined) {
          console.warn('THREE.ObjectLoader: Undefined material', name)
        }

        return materials[name]
      }

      switch (data.type) {
        case 'Scene':
          object = new Scene()

          if (data.background !== undefined) {
            if (Number.isInteger(data.background)) {
              object.background = new Color(data.background)
            }
          }

          if (data.fog !== undefined) {
            if (data.fog.type === 'Fog') {
              object.fog = new Fog(data.fog.color, data.fog.near, data.fog.far)
            } else if (data.fog.type === 'FogExp2') {
              object.fog = new FogExp2(data.fog.color, data.fog.density)
            }
          }

          break

        case 'PerspectiveCamera':
          object = new PerspectiveCamera(data.fov, data.aspect, data.near, data.far)

          if (data.focus !== undefined) object.focus = data.focus
          if (data.zoom !== undefined) object.zoom = data.zoom
          if (data.filmGauge !== undefined) object.filmGauge = data.filmGauge
          if (data.filmOffset !== undefined) object.filmOffset = data.filmOffset
          if (data.view !== undefined) object.view = Object.assign({}, data.view)

          break

        case 'OrthographicCamera':
          object = new OrthographicCamera(
            data.left,
            data.right,
            data.top,
            data.bottom,
            data.near,
            data.far
          )

          break

        case 'AmbientLight':
          object = new AmbientLight(data.color, data.intensity)

          break

        case 'DirectionalLight':
          object = new DirectionalLight(data.color, data.intensity)

          break

        case 'PointLight':
          object = new PointLight(data.color, data.intensity, data.distance, data.decay)

          break

        case 'RectAreaLight':
          object = new RectAreaLight(data.color, data.intensity, data.width, data.height)

          break

        case 'SpotLight':
          object = new SpotLight(
            data.color,
            data.intensity,
            data.distance,
            data.angle,
            data.penumbra,
            data.decay
          )

          break

        case 'HemisphereLight':
          object = new HemisphereLight(data.color, data.groundColor, data.intensity)

          break

        case 'SkinnedMesh':
          console.warn('THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.')

        case 'Mesh':
          var geometry = getGeometry(data.geometry)
          var material = getMaterial(data.material)

          if (geometry.bones && geometry.bones.length > 0) {
            object = new SkinnedMesh(geometry, material)
          } else {
            object = new Mesh(geometry, material)
          }

          break

        case 'LOD':
          object = new LOD()

          break

        case 'Line':
          object = new Line(getGeometry(data.geometry), getMaterial(data.material), data.mode)

          break

        case 'LineLoop':
          object = new LineLoop(getGeometry(data.geometry), getMaterial(data.material))

          break

        case 'LineSegments':
          object = new LineSegments(getGeometry(data.geometry), getMaterial(data.material))

          break

        case 'PointCloud':
        case 'Points':
          object = new Points(getGeometry(data.geometry), getMaterial(data.material))

          break

        case 'Sprite':
          object = new Sprite(getMaterial(data.material))

          break

        case 'Group':
          object = new Group()

          break

        default:
          object = new Object3D()
      }

      object.uuid = data.uuid

      if (data.name !== undefined) object.name = data.name
      if (data.matrix !== undefined) {
        object.matrix.fromArray(data.matrix)
        object.matrix.decompose(object.position, object.quaternion, object.scale)
      } else {
        if (data.position !== undefined) object.position.fromArray(data.position)
        if (data.rotation !== undefined) object.rotation.fromArray(data.rotation)
        if (data.quaternion !== undefined) object.quaternion.fromArray(data.quaternion)
        if (data.scale !== undefined) object.scale.fromArray(data.scale)
      }

      if (data.castShadow !== undefined) object.castShadow = data.castShadow
      if (data.receiveShadow !== undefined) object.receiveShadow = data.receiveShadow

      if (data.shadow) {
        if (data.shadow.bias !== undefined) object.shadow.bias = data.shadow.bias
        if (data.shadow.radius !== undefined) object.shadow.radius = data.shadow.radius
        if (data.shadow.mapSize !== undefined) object.shadow.mapSize.fromArray(data.shadow.mapSize)
        if (data.shadow.camera !== undefined)
          object.shadow.camera = this.parseObject(data.shadow.camera)
      }

      if (data.visible !== undefined) object.visible = data.visible
      if (data.userData !== undefined) object.userData = data.userData

      if (data.children !== undefined) {
        var children = data.children

        for (var i = 0; i < children.length; i++) {
          object.add(this.parseObject(children[i], geometries, materials))
        }
      }

      if (data.type === 'LOD') {
        var levels = data.levels

        for (var l = 0; l < levels.length; l++) {
          var level = levels[l]
          var child = object.getObjectByProperty('uuid', level.object)

          if (child !== undefined) {
            object.addLevel(child, level.distance)
          }
        }
      }

      return object
    }
  })

  var TEXTURE_MAPPING = {
    UVMapping: UVMapping,
    CubeReflectionMapping: CubeReflectionMapping,
    CubeRefractionMapping: CubeRefractionMapping,
    EquirectangularReflectionMapping: EquirectangularReflectionMapping,
    EquirectangularRefractionMapping: EquirectangularRefractionMapping,
    SphericalReflectionMapping: SphericalReflectionMapping,
    CubeUVReflectionMapping: CubeUVReflectionMapping,
    CubeUVRefractionMapping: CubeUVRefractionMapping
  }

  var TEXTURE_WRAPPING = {
    RepeatWrapping: RepeatWrapping,
    ClampToEdgeWrapping: ClampToEdgeWrapping,
    MirroredRepeatWrapping: MirroredRepeatWrapping
  }

  var TEXTURE_FILTER = {
    NearestFilter: NearestFilter,
    NearestMipMapNearestFilter: NearestMipMapNearestFilter,
    NearestMipMapLinearFilter: NearestMipMapLinearFilter,
    LinearFilter: LinearFilter,
    LinearMipMapNearestFilter: LinearMipMapNearestFilter,
    LinearMipMapLinearFilter: LinearMipMapLinearFilter
  }

  /**
   * @author thespite / http://clicktorelease.com/
   */

  function ImageBitmapLoader(manager) {
    if (typeof createImageBitmap === 'undefined') {
      console.warn('THREE.ImageBitmapLoader: createImageBitmap() not supported.')
    }

    if (typeof fetch === 'undefined') {
      console.warn('THREE.ImageBitmapLoader: fetch() not supported.')
    }

    this.manager = manager !== undefined ? manager : DefaultLoadingManager
    this.options = undefined
  }

  ImageBitmapLoader.prototype = {
    constructor: ImageBitmapLoader,

    setOptions: function setOptions(options) {
      this.options = options

      return this
    },

    load: function load(url, onLoad, onProgress, onError) {
      if (url === undefined) url = ''

      if (this.path !== undefined) url = this.path + url

      var scope = this

      var cached = Cache.get(url)

      if (cached !== undefined) {
        scope.manager.itemStart(url)

        setTimeout(function () {
          if (onLoad) onLoad(cached)

          scope.manager.itemEnd(url)
        }, 0)

        return cached
      }

      fetch(url)
        .then(function (res) {
          return res.blob()
        })
        .then(function (blob) {
          return createImageBitmap(blob, scope.options)
        })
        .then(function (imageBitmap) {
          Cache.add(url, imageBitmap)

          if (onLoad) onLoad(imageBitmap)

          scope.manager.itemEnd(url)
        })
        .catch(function (e) {
          if (onError) onError(e)

          scope.manager.itemEnd(url)
          scope.manager.itemError(url)
        })
    },

    setCrossOrigin: function (/* value */) {
      return this
    },

    setPath: function (value) {
      this.path = value
      return this
    }
  }

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * minimal class for proxing functions to Path. Replaces old "extractSubpaths()"
   **/

  function ShapePath() {
    this.type = 'ShapePath'

    this.subPaths = []
    this.currentPath = null
  }

  Object.assign(ShapePath.prototype, {
    moveTo: function (x, y) {
      this.currentPath = new Path()
      this.subPaths.push(this.currentPath)
      this.currentPath.moveTo(x, y)
    },

    lineTo: function (x, y) {
      this.currentPath.lineTo(x, y)
    },

    quadraticCurveTo: function (aCPx, aCPy, aX, aY) {
      this.currentPath.quadraticCurveTo(aCPx, aCPy, aX, aY)
    },

    bezierCurveTo: function (aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
      this.currentPath.bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY)
    },

    splineThru: function (pts) {
      this.currentPath.splineThru(pts)
    },

    toShapes: function (isCCW, noHoles) {
      function toShapesNoHoles(inSubpaths) {
        var shapes = []

        for (var i = 0, l = inSubpaths.length; i < l; i++) {
          var tmpPath = inSubpaths[i]

          var tmpShape = new Shape()
          tmpShape.curves = tmpPath.curves

          shapes.push(tmpShape)
        }

        return shapes
      }

      function isPointInsidePolygon(inPt, inPolygon) {
        var polyLen = inPolygon.length

        // inPt on polygon contour => immediate success    or
        // toggling of inside/outside at every single! intersection point of an edge
        //  with the horizontal line through inPt, left of inPt
        //  not counting lowerY endpoints of edges and whole edges on that line
        var inside = false
        for (var p = polyLen - 1, q = 0; q < polyLen; p = q++) {
          var edgeLowPt = inPolygon[p]
          var edgeHighPt = inPolygon[q]

          var edgeDx = edgeHighPt.x - edgeLowPt.x
          var edgeDy = edgeHighPt.y - edgeLowPt.y

          if (Math.abs(edgeDy) > Number.EPSILON) {
            // not parallel
            if (edgeDy < 0) {
              edgeLowPt = inPolygon[q]
              edgeDx = -edgeDx
              edgeHighPt = inPolygon[p]
              edgeDy = -edgeDy
            }
            if (inPt.y < edgeLowPt.y || inPt.y > edgeHighPt.y) continue

            if (inPt.y === edgeLowPt.y) {
              if (inPt.x === edgeLowPt.x) return true // inPt is on contour ?
              // continue;				// no intersection or edgeLowPt => doesn't count !!!
            } else {
              var perpEdge = edgeDy * (inPt.x - edgeLowPt.x) - edgeDx * (inPt.y - edgeLowPt.y)
              if (perpEdge === 0) return true // inPt is on contour ?
              if (perpEdge < 0) continue
              inside = !inside // true intersection left of inPt
            }
          } else {
            // parallel or collinear
            if (inPt.y !== edgeLowPt.y) continue // parallel
            // edge lies on the same horizontal line as inPt
            if (
              (edgeHighPt.x <= inPt.x && inPt.x <= edgeLowPt.x) ||
              (edgeLowPt.x <= inPt.x && inPt.x <= edgeHighPt.x)
            )
              return true // inPt: Point on contour !
            // continue;
          }
        }

        return inside
      }

      var isClockWise = ShapeUtils.isClockWise

      var subPaths = this.subPaths
      if (subPaths.length === 0) return []

      if (noHoles === true) return toShapesNoHoles(subPaths)

      var solid,
        tmpPath,
        tmpShape,
        shapes = []

      if (subPaths.length === 1) {
        tmpPath = subPaths[0]
        tmpShape = new Shape()
        tmpShape.curves = tmpPath.curves
        shapes.push(tmpShape)
        return shapes
      }

      var holesFirst = !isClockWise(subPaths[0].getPoints())
      holesFirst = isCCW ? !holesFirst : holesFirst

      // console.log("Holes first", holesFirst);

      var betterShapeHoles = []
      var newShapes = []
      var newShapeHoles = []
      var mainIdx = 0
      var tmpPoints

      newShapes[mainIdx] = undefined
      newShapeHoles[mainIdx] = []

      for (var i = 0, l = subPaths.length; i < l; i++) {
        tmpPath = subPaths[i]
        tmpPoints = tmpPath.getPoints()
        solid = isClockWise(tmpPoints)
        solid = isCCW ? !solid : solid

        if (solid) {
          if (!holesFirst && newShapes[mainIdx]) mainIdx++

          newShapes[mainIdx] = { s: new Shape(), p: tmpPoints }
          newShapes[mainIdx].s.curves = tmpPath.curves

          if (holesFirst) mainIdx++
          newShapeHoles[mainIdx] = []

          //console.log('cw', i);
        } else {
          newShapeHoles[mainIdx].push({ h: tmpPath, p: tmpPoints[0] })

          //console.log('ccw', i);
        }
      }

      // only Holes? -> probably all Shapes with wrong orientation
      if (!newShapes[0]) return toShapesNoHoles(subPaths)

      if (newShapes.length > 1) {
        var ambiguous = false
        var toChange = []

        for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx++) {
          betterShapeHoles[sIdx] = []
        }

        for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx++) {
          var sho = newShapeHoles[sIdx]

          for (var hIdx = 0; hIdx < sho.length; hIdx++) {
            var ho = sho[hIdx]
            var hole_unassigned = true

            for (var s2Idx = 0; s2Idx < newShapes.length; s2Idx++) {
              if (isPointInsidePolygon(ho.p, newShapes[s2Idx].p)) {
                if (sIdx !== s2Idx) toChange.push({ froms: sIdx, tos: s2Idx, hole: hIdx })
                if (hole_unassigned) {
                  hole_unassigned = false
                  betterShapeHoles[s2Idx].push(ho)
                } else {
                  ambiguous = true
                }
              }
            }
            if (hole_unassigned) {
              betterShapeHoles[sIdx].push(ho)
            }
          }
        }
        // console.log("ambiguous: ", ambiguous);
        if (toChange.length > 0) {
          // console.log("to change: ", toChange);
          if (!ambiguous) newShapeHoles = betterShapeHoles
        }
      }

      var tmpHoles

      for (var i = 0, il = newShapes.length; i < il; i++) {
        tmpShape = newShapes[i].s
        shapes.push(tmpShape)
        tmpHoles = newShapeHoles[i]

        for (var j = 0, jl = tmpHoles.length; j < jl; j++) {
          tmpShape.holes.push(tmpHoles[j].h)
        }
      }

      //console.log("shape", shapes);

      return shapes
    }
  })

  /**
   * @author zz85 / http://www.lab4games.net/zz85/blog
   * @author mrdoob / http://mrdoob.com/
   */

  function Font(data) {
    this.type = 'Font'

    this.data = data
  }

  Object.assign(Font.prototype, {
    isFont: true,

    generateShapes: function (text, size, divisions) {
      if (size === undefined) size = 100
      if (divisions === undefined) divisions = 4

      var shapes = []
      var paths = createPaths(text, size, divisions, this.data)

      for (var p = 0, pl = paths.length; p < pl; p++) {
        Array.prototype.push.apply(shapes, paths[p].toShapes())
      }

      return shapes
    }
  })

  function createPaths(text, size, divisions, data) {
    var chars = String(text).split('')
    var scale = size / data.resolution
    var line_height =
      (data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness) * scale

    var paths = []

    var offsetX = 0,
      offsetY = 0

    for (var i = 0; i < chars.length; i++) {
      var char = chars[i]

      if (char === '\n') {
        offsetX = 0
        offsetY -= line_height
      } else {
        var ret = createPath(char, divisions, scale, offsetX, offsetY, data)
        offsetX += ret.offsetX
        paths.push(ret.path)
      }
    }

    return paths
  }

  function createPath(char, divisions, scale, offsetX, offsetY, data) {
    var glyph = data.glyphs[char] || data.glyphs['?']

    if (!glyph) return

    var path = new ShapePath()

    var x, y, cpx, cpy, cpx1, cpy1, cpx2, cpy2

    if (glyph.o) {
      var outline = glyph._cachedOutline || (glyph._cachedOutline = glyph.o.split(' '))

      for (var i = 0, l = outline.length; i < l; ) {
        var action = outline[i++]

        switch (action) {
          case 'm': // moveTo
            x = outline[i++] * scale + offsetX
            y = outline[i++] * scale + offsetY

            path.moveTo(x, y)

            break

          case 'l': // lineTo
            x = outline[i++] * scale + offsetX
            y = outline[i++] * scale + offsetY

            path.lineTo(x, y)

            break

          case 'q': // quadraticCurveTo
            cpx = outline[i++] * scale + offsetX
            cpy = outline[i++] * scale + offsetY
            cpx1 = outline[i++] * scale + offsetX
            cpy1 = outline[i++] * scale + offsetY

            path.quadraticCurveTo(cpx1, cpy1, cpx, cpy)

            break

          case 'b': // bezierCurveTo
            cpx = outline[i++] * scale + offsetX
            cpy = outline[i++] * scale + offsetY
            cpx1 = outline[i++] * scale + offsetX
            cpy1 = outline[i++] * scale + offsetY
            cpx2 = outline[i++] * scale + offsetX
            cpy2 = outline[i++] * scale + offsetY

            path.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, cpx, cpy)

            break
        }
      }
    }

    return { offsetX: glyph.ha * scale, path: path }
  }

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function FontLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
  }

  Object.assign(FontLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      var scope = this

      var loader = new FileLoader(this.manager)
      loader.setPath(this.path)
      loader.load(
        url,
        function (text) {
          var json

          try {
            json = JSON.parse(text)
          } catch (e) {
            console.warn(
              'THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead.'
            )
            json = JSON.parse(text.substring(65, text.length - 2))
          }

          var font = scope.parse(json)

          if (onLoad) onLoad(font)
        },
        onProgress,
        onError
      )
    },

    parse: function (json) {
      return new Font(json)
    },

    setPath: function (value) {
      this.path = value
      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  var context

  var AudioContext = {
    getContext: function () {
      if (context === undefined) {
        context = new (window.AudioContext || window.webkitAudioContext)()
      }

      return context
    },

    setContext: function (value) {
      context = value
    }
  }

  /**
   * @author Reece Aaron Lecrivain / http://reecenotes.com/
   */

  function AudioLoader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
  }

  Object.assign(AudioLoader.prototype, {
    load: function (url, onLoad, onProgress, onError) {
      var loader = new FileLoader(this.manager)
      loader.setResponseType('arraybuffer')
      loader.load(
        url,
        function (buffer) {
          var context = AudioContext.getContext()

          context.decodeAudioData(buffer, function (audioBuffer) {
            onLoad(audioBuffer)
          })
        },
        onProgress,
        onError
      )
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function StereoCamera() {
    this.type = 'StereoCamera'

    this.aspect = 1

    this.eyeSep = 0.064

    this.cameraL = new PerspectiveCamera()
    this.cameraL.layers.enable(1)
    this.cameraL.matrixAutoUpdate = false

    this.cameraR = new PerspectiveCamera()
    this.cameraR.layers.enable(2)
    this.cameraR.matrixAutoUpdate = false
  }

  Object.assign(StereoCamera.prototype, {
    update: (function () {
      var instance, focus, fov, aspect, near, far, zoom, eyeSep

      var eyeRight = new Matrix4()
      var eyeLeft = new Matrix4()

      return function update(camera) {
        var needsUpdate =
          instance !== this ||
          focus !== camera.focus ||
          fov !== camera.fov ||
          aspect !== camera.aspect * this.aspect ||
          near !== camera.near ||
          far !== camera.far ||
          zoom !== camera.zoom ||
          eyeSep !== this.eyeSep

        if (needsUpdate) {
          instance = this
          focus = camera.focus
          fov = camera.fov
          aspect = camera.aspect * this.aspect
          near = camera.near
          far = camera.far
          zoom = camera.zoom

          // Off-axis stereoscopic effect based on
          // http://paulbourke.net/stereographics/stereorender/

          var projectionMatrix = camera.projectionMatrix.clone()
          eyeSep = this.eyeSep / 2
          var eyeSepOnProjection = (eyeSep * near) / focus
          var ymax = (near * Math.tan(_Math.DEG2RAD * fov * 0.5)) / zoom
          var xmin, xmax

          // translate xOffset

          eyeLeft.elements[12] = -eyeSep
          eyeRight.elements[12] = eyeSep

          // for left eye

          xmin = -ymax * aspect + eyeSepOnProjection
          xmax = ymax * aspect + eyeSepOnProjection

          projectionMatrix.elements[0] = (2 * near) / (xmax - xmin)
          projectionMatrix.elements[8] = (xmax + xmin) / (xmax - xmin)

          this.cameraL.projectionMatrix.copy(projectionMatrix)

          // for right eye

          xmin = -ymax * aspect - eyeSepOnProjection
          xmax = ymax * aspect - eyeSepOnProjection

          projectionMatrix.elements[0] = (2 * near) / (xmax - xmin)
          projectionMatrix.elements[8] = (xmax + xmin) / (xmax - xmin)

          this.cameraR.projectionMatrix.copy(projectionMatrix)
        }

        this.cameraL.matrixWorld.copy(camera.matrixWorld).multiply(eyeLeft)
        this.cameraR.matrixWorld.copy(camera.matrixWorld).multiply(eyeRight)
      }
    })()
  })

  /**
   * Camera for rendering cube maps
   *	- renders scene into axis-aligned cube
   *
   * @author alteredq / http://alteredqualia.com/
   */

  function CubeCamera(near, far, cubeResolution) {
    Object3D.call(this)

    this.type = 'CubeCamera'

    var fov = 90,
      aspect = 1

    var cameraPX = new PerspectiveCamera(fov, aspect, near, far)
    cameraPX.up.set(0, -1, 0)
    cameraPX.lookAt(new Vector3(1, 0, 0))
    this.add(cameraPX)

    var cameraNX = new PerspectiveCamera(fov, aspect, near, far)
    cameraNX.up.set(0, -1, 0)
    cameraNX.lookAt(new Vector3(-1, 0, 0))
    this.add(cameraNX)

    var cameraPY = new PerspectiveCamera(fov, aspect, near, far)
    cameraPY.up.set(0, 0, 1)
    cameraPY.lookAt(new Vector3(0, 1, 0))
    this.add(cameraPY)

    var cameraNY = new PerspectiveCamera(fov, aspect, near, far)
    cameraNY.up.set(0, 0, -1)
    cameraNY.lookAt(new Vector3(0, -1, 0))
    this.add(cameraNY)

    var cameraPZ = new PerspectiveCamera(fov, aspect, near, far)
    cameraPZ.up.set(0, -1, 0)
    cameraPZ.lookAt(new Vector3(0, 0, 1))
    this.add(cameraPZ)

    var cameraNZ = new PerspectiveCamera(fov, aspect, near, far)
    cameraNZ.up.set(0, -1, 0)
    cameraNZ.lookAt(new Vector3(0, 0, -1))
    this.add(cameraNZ)

    var options = { format: RGBFormat, magFilter: LinearFilter, minFilter: LinearFilter }

    this.renderTarget = new WebGLRenderTargetCube(cubeResolution, cubeResolution, options)
    this.renderTarget.texture.name = 'CubeCamera'

    this.update = function (renderer, scene) {
      if (this.parent === null) this.updateMatrixWorld()

      var renderTarget = this.renderTarget
      var generateMipmaps = renderTarget.texture.generateMipmaps

      renderTarget.texture.generateMipmaps = false

      renderTarget.activeCubeFace = 0
      renderer.render(scene, cameraPX, renderTarget)

      renderTarget.activeCubeFace = 1
      renderer.render(scene, cameraNX, renderTarget)

      renderTarget.activeCubeFace = 2
      renderer.render(scene, cameraPY, renderTarget)

      renderTarget.activeCubeFace = 3
      renderer.render(scene, cameraNY, renderTarget)

      renderTarget.activeCubeFace = 4
      renderer.render(scene, cameraPZ, renderTarget)

      renderTarget.texture.generateMipmaps = generateMipmaps

      renderTarget.activeCubeFace = 5
      renderer.render(scene, cameraNZ, renderTarget)

      renderer.setRenderTarget(null)
    }

    this.clear = function (renderer, color, depth, stencil) {
      var renderTarget = this.renderTarget

      for (var i = 0; i < 6; i++) {
        renderTarget.activeCubeFace = i
        renderer.setRenderTarget(renderTarget)

        renderer.clear(color, depth, stencil)
      }

      renderer.setRenderTarget(null)
    }
  }

  CubeCamera.prototype = Object.create(Object3D.prototype)
  CubeCamera.prototype.constructor = CubeCamera

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function AudioListener() {
    Object3D.call(this)

    this.type = 'AudioListener'

    this.context = AudioContext.getContext()

    this.gain = this.context.createGain()
    this.gain.connect(this.context.destination)

    this.filter = null
  }

  AudioListener.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: AudioListener,

    getInput: function () {
      return this.gain
    },

    removeFilter: function () {
      if (this.filter !== null) {
        this.gain.disconnect(this.filter)
        this.filter.disconnect(this.context.destination)
        this.gain.connect(this.context.destination)
        this.filter = null
      }
    },

    getFilter: function () {
      return this.filter
    },

    setFilter: function (value) {
      if (this.filter !== null) {
        this.gain.disconnect(this.filter)
        this.filter.disconnect(this.context.destination)
      } else {
        this.gain.disconnect(this.context.destination)
      }

      this.filter = value
      this.gain.connect(this.filter)
      this.filter.connect(this.context.destination)
    },

    getMasterVolume: function () {
      return this.gain.gain.value
    },

    setMasterVolume: function (value) {
      this.gain.gain.value = value
    },

    updateMatrixWorld: (function () {
      var position = new Vector3()
      var quaternion = new Quaternion()
      var scale = new Vector3()

      var orientation = new Vector3()

      return function updateMatrixWorld(force) {
        Object3D.prototype.updateMatrixWorld.call(this, force)

        var listener = this.context.listener
        var up = this.up

        this.matrixWorld.decompose(position, quaternion, scale)

        orientation.set(0, 0, -1).applyQuaternion(quaternion)

        if (listener.positionX) {
          listener.positionX.setValueAtTime(position.x, this.context.currentTime)
          listener.positionY.setValueAtTime(position.y, this.context.currentTime)
          listener.positionZ.setValueAtTime(position.z, this.context.currentTime)
          listener.forwardX.setValueAtTime(orientation.x, this.context.currentTime)
          listener.forwardY.setValueAtTime(orientation.y, this.context.currentTime)
          listener.forwardZ.setValueAtTime(orientation.z, this.context.currentTime)
          listener.upX.setValueAtTime(up.x, this.context.currentTime)
          listener.upY.setValueAtTime(up.y, this.context.currentTime)
          listener.upZ.setValueAtTime(up.z, this.context.currentTime)
        } else {
          listener.setPosition(position.x, position.y, position.z)
          listener.setOrientation(orientation.x, orientation.y, orientation.z, up.x, up.y, up.z)
        }
      }
    })()
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author Reece Aaron Lecrivain / http://reecenotes.com/
   */

  function Audio(listener) {
    Object3D.call(this)

    this.type = 'Audio'

    this.context = listener.context

    this.gain = this.context.createGain()
    this.gain.connect(listener.getInput())

    this.autoplay = false

    this.buffer = null
    this.loop = false
    this.startTime = 0
    this.offset = 0
    this.playbackRate = 1
    this.isPlaying = false
    this.hasPlaybackControl = true
    this.sourceType = 'empty'

    this.filters = []
  }

  Audio.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Audio,

    getOutput: function () {
      return this.gain
    },

    setNodeSource: function (audioNode) {
      this.hasPlaybackControl = false
      this.sourceType = 'audioNode'
      this.source = audioNode
      this.connect()

      return this
    },

    setBuffer: function (audioBuffer) {
      this.buffer = audioBuffer
      this.sourceType = 'buffer'

      if (this.autoplay) this.play()

      return this
    },

    play: function () {
      if (this.isPlaying === true) {
        console.warn('THREE.Audio: Audio is already playing.')
        return
      }

      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return
      }

      var source = this.context.createBufferSource()

      source.buffer = this.buffer
      source.loop = this.loop
      source.onended = this.onEnded.bind(this)
      source.playbackRate.setValueAtTime(this.playbackRate, this.startTime)
      this.startTime = this.context.currentTime
      source.start(this.startTime, this.offset)

      this.isPlaying = true

      this.source = source

      return this.connect()
    },

    pause: function () {
      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return
      }

      if (this.isPlaying === true) {
        this.source.stop()
        this.offset += (this.context.currentTime - this.startTime) * this.playbackRate
        this.isPlaying = false
      }

      return this
    },

    stop: function () {
      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return
      }

      this.source.stop()
      this.offset = 0
      this.isPlaying = false

      return this
    },

    connect: function () {
      if (this.filters.length > 0) {
        this.source.connect(this.filters[0])

        for (var i = 1, l = this.filters.length; i < l; i++) {
          this.filters[i - 1].connect(this.filters[i])
        }

        this.filters[this.filters.length - 1].connect(this.getOutput())
      } else {
        this.source.connect(this.getOutput())
      }

      return this
    },

    disconnect: function () {
      if (this.filters.length > 0) {
        this.source.disconnect(this.filters[0])

        for (var i = 1, l = this.filters.length; i < l; i++) {
          this.filters[i - 1].disconnect(this.filters[i])
        }

        this.filters[this.filters.length - 1].disconnect(this.getOutput())
      } else {
        this.source.disconnect(this.getOutput())
      }

      return this
    },

    getFilters: function () {
      return this.filters
    },

    setFilters: function (value) {
      if (!value) value = []

      if (this.isPlaying === true) {
        this.disconnect()
        this.filters = value
        this.connect()
      } else {
        this.filters = value
      }

      return this
    },

    getFilter: function () {
      return this.getFilters()[0]
    },

    setFilter: function (filter) {
      return this.setFilters(filter ? [filter] : [])
    },

    setPlaybackRate: function (value) {
      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return
      }

      this.playbackRate = value

      if (this.isPlaying === true) {
        this.source.playbackRate.setValueAtTime(this.playbackRate, this.context.currentTime)
      }

      return this
    },

    getPlaybackRate: function () {
      return this.playbackRate
    },

    onEnded: function () {
      this.isPlaying = false
    },

    getLoop: function () {
      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return false
      }

      return this.loop
    },

    setLoop: function (value) {
      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return
      }

      this.loop = value

      if (this.isPlaying === true) {
        this.source.loop = this.loop
      }

      return this
    },

    getVolume: function () {
      return this.gain.gain.value
    },

    setVolume: function (value) {
      this.gain.gain.value = value

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function PositionalAudio(listener) {
    Audio.call(this, listener)

    this.panner = this.context.createPanner()
    this.panner.connect(this.gain)
  }

  PositionalAudio.prototype = Object.assign(Object.create(Audio.prototype), {
    constructor: PositionalAudio,

    getOutput: function () {
      return this.panner
    },

    getRefDistance: function () {
      return this.panner.refDistance
    },

    setRefDistance: function (value) {
      this.panner.refDistance = value
    },

    getRolloffFactor: function () {
      return this.panner.rolloffFactor
    },

    setRolloffFactor: function (value) {
      this.panner.rolloffFactor = value
    },

    getDistanceModel: function () {
      return this.panner.distanceModel
    },

    setDistanceModel: function (value) {
      this.panner.distanceModel = value
    },

    getMaxDistance: function () {
      return this.panner.maxDistance
    },

    setMaxDistance: function (value) {
      this.panner.maxDistance = value
    },

    updateMatrixWorld: (function () {
      var position = new Vector3()

      return function updateMatrixWorld(force) {
        Object3D.prototype.updateMatrixWorld.call(this, force)

        position.setFromMatrixPosition(this.matrixWorld)

        this.panner.setPosition(position.x, position.y, position.z)
      }
    })()
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function AudioAnalyser(audio, fftSize) {
    this.analyser = audio.context.createAnalyser()
    this.analyser.fftSize = fftSize !== undefined ? fftSize : 2048

    this.data = new Uint8Array(this.analyser.frequencyBinCount)

    audio.getOutput().connect(this.analyser)
  }

  Object.assign(AudioAnalyser.prototype, {
    getFrequencyData: function () {
      this.analyser.getByteFrequencyData(this.data)

      return this.data
    },

    getAverageFrequency: function () {
      var value = 0,
        data = this.getFrequencyData()

      for (var i = 0; i < data.length; i++) {
        value += data[i]
      }

      return value / data.length
    }
  })

  /**
   *
   * Buffered scene graph property that allows weighted accumulation.
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function PropertyMixer(binding, typeName, valueSize) {
    this.binding = binding
    this.valueSize = valueSize

    var bufferType = Float64Array,
      mixFunction

    switch (typeName) {
      case 'quaternion':
        mixFunction = this._slerp
        break

      case 'string':
      case 'bool':
        bufferType = Array
        mixFunction = this._select
        break

      default:
        mixFunction = this._lerp
    }

    this.buffer = new bufferType(valueSize * 4)
    // layout: [ incoming | accu0 | accu1 | orig ]
    //
    // interpolators can use .buffer as their .result
    // the data then goes to 'incoming'
    //
    // 'accu0' and 'accu1' are used frame-interleaved for
    // the cumulative result and are compared to detect
    // changes
    //
    // 'orig' stores the original state of the property

    this._mixBufferRegion = mixFunction

    this.cumulativeWeight = 0

    this.useCount = 0
    this.referenceCount = 0
  }

  Object.assign(PropertyMixer.prototype, {
    // accumulate data in the 'incoming' region into 'accu<i>'
    accumulate: function (accuIndex, weight) {
      // note: happily accumulating nothing when weight = 0, the caller knows
      // the weight and shouldn't have made the call in the first place

      var buffer = this.buffer,
        stride = this.valueSize,
        offset = accuIndex * stride + stride,
        currentWeight = this.cumulativeWeight

      if (currentWeight === 0) {
        // accuN := incoming * weight

        for (var i = 0; i !== stride; ++i) {
          buffer[offset + i] = buffer[i]
        }

        currentWeight = weight
      } else {
        // accuN := accuN + incoming * weight

        currentWeight += weight
        var mix = weight / currentWeight
        this._mixBufferRegion(buffer, offset, 0, mix, stride)
      }

      this.cumulativeWeight = currentWeight
    },

    // apply the state of 'accu<i>' to the binding when accus differ
    apply: function (accuIndex) {
      var stride = this.valueSize,
        buffer = this.buffer,
        offset = accuIndex * stride + stride,
        weight = this.cumulativeWeight,
        binding = this.binding

      this.cumulativeWeight = 0

      if (weight < 1) {
        // accuN := accuN + original * ( 1 - cumulativeWeight )

        var originalValueOffset = stride * 3

        this._mixBufferRegion(buffer, offset, originalValueOffset, 1 - weight, stride)
      }

      for (var i = stride, e = stride + stride; i !== e; ++i) {
        if (buffer[i] !== buffer[i + stride]) {
          // value has changed -> update scene graph

          binding.setValue(buffer, offset)
          break
        }
      }
    },

    // remember the state of the bound property and copy it to both accus
    saveOriginalState: function () {
      var binding = this.binding

      var buffer = this.buffer,
        stride = this.valueSize,
        originalValueOffset = stride * 3

      binding.getValue(buffer, originalValueOffset)

      // accu[0..1] := orig -- initially detect changes against the original
      for (var i = stride, e = originalValueOffset; i !== e; ++i) {
        buffer[i] = buffer[originalValueOffset + (i % stride)]
      }

      this.cumulativeWeight = 0
    },

    // apply the state previously taken via 'saveOriginalState' to the binding
    restoreOriginalState: function () {
      var originalValueOffset = this.valueSize * 3
      this.binding.setValue(this.buffer, originalValueOffset)
    },

    // mix functions

    _select: function (buffer, dstOffset, srcOffset, t, stride) {
      if (t >= 0.5) {
        for (var i = 0; i !== stride; ++i) {
          buffer[dstOffset + i] = buffer[srcOffset + i]
        }
      }
    },

    _slerp: function (buffer, dstOffset, srcOffset, t) {
      Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t)
    },

    _lerp: function (buffer, dstOffset, srcOffset, t, stride) {
      var s = 1 - t

      for (var i = 0; i !== stride; ++i) {
        var j = dstOffset + i

        buffer[j] = buffer[j] * s + buffer[srcOffset + i] * t
      }
    }
  })

  /**
   *
   * A reference to a real property in the scene graph.
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  // Characters [].:/ are reserved for track binding syntax.
  var RESERVED_CHARS_RE = '\\[\\]\\.:\\/'

  function Composite(targetGroup, path, optionalParsedPath) {
    var parsedPath = optionalParsedPath || PropertyBinding.parseTrackName(path)

    this._targetGroup = targetGroup
    this._bindings = targetGroup.subscribe_(path, parsedPath)
  }

  Object.assign(Composite.prototype, {
    getValue: function (array, offset) {
      this.bind() // bind all binding

      var firstValidIndex = this._targetGroup.nCachedObjects_,
        binding = this._bindings[firstValidIndex]

      // and only call .getValue on the first
      if (binding !== undefined) binding.getValue(array, offset)
    },

    setValue: function (array, offset) {
      var bindings = this._bindings

      for (var i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) {
        bindings[i].setValue(array, offset)
      }
    },

    bind: function () {
      var bindings = this._bindings

      for (var i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) {
        bindings[i].bind()
      }
    },

    unbind: function () {
      var bindings = this._bindings

      for (var i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) {
        bindings[i].unbind()
      }
    }
  })

  function PropertyBinding(rootNode, path, parsedPath) {
    this.path = path
    this.parsedPath = parsedPath || PropertyBinding.parseTrackName(path)

    this.node = PropertyBinding.findNode(rootNode, this.parsedPath.nodeName) || rootNode

    this.rootNode = rootNode
  }

  Object.assign(PropertyBinding, {
    Composite: Composite,

    create: function (root, path, parsedPath) {
      if (!(root && root.isAnimationObjectGroup)) {
        return new PropertyBinding(root, path, parsedPath)
      } else {
        return new PropertyBinding.Composite(root, path, parsedPath)
      }
    },

    /**
     * Replaces spaces with underscores and removes unsupported characters from
     * node names, to ensure compatibility with parseTrackName().
     *
     * @param  {string} name Node name to be sanitized.
     * @return {string}
     */
    sanitizeNodeName: (function () {
      var reservedRe = new RegExp('[' + RESERVED_CHARS_RE + ']', 'g')

      return function sanitizeNodeName(name) {
        return name.replace(/\s/g, '_').replace(reservedRe, '')
      }
    })(),

    parseTrackName: (function () {
      // Attempts to allow node names from any language. ES5's `\w` regexp matches
      // only latin characters, and the unicode \p{L} is not yet supported. So
      // instead, we exclude reserved characters and match everything else.
      var wordChar = '[^' + RESERVED_CHARS_RE + ']'
      var wordCharOrDot = '[^' + RESERVED_CHARS_RE.replace('\\.', '') + ']'

      // Parent directories, delimited by '/' or ':'. Currently unused, but must
      // be matched to parse the rest of the track name.
      var directoryRe = /((?:WC+[\/:])*)/.source.replace('WC', wordChar)

      // Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.
      var nodeRe = /(WCOD+)?/.source.replace('WCOD', wordCharOrDot)

      // Object on target node, and accessor. May not contain reserved
      // characters. Accessor may contain any character except closing bracket.
      var objectRe = /(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace('WC', wordChar)

      // Property and accessor. May not contain reserved characters. Accessor may
      // contain any non-bracket characters.
      var propertyRe = /\.(WC+)(?:\[(.+)\])?/.source.replace('WC', wordChar)

      var trackRe = new RegExp('' + '^' + directoryRe + nodeRe + objectRe + propertyRe + '$')

      var supportedObjectNames = ['material', 'materials', 'bones']

      return function parseTrackName(trackName) {
        var matches = trackRe.exec(trackName)

        if (!matches) {
          throw new Error('PropertyBinding: Cannot parse trackName: ' + trackName)
        }

        var results = {
          // directoryName: matches[ 1 ], // (tschw) currently unused
          nodeName: matches[2],
          objectName: matches[3],
          objectIndex: matches[4],
          propertyName: matches[5], // required
          propertyIndex: matches[6]
        }

        var lastDot = results.nodeName && results.nodeName.lastIndexOf('.')

        if (lastDot !== undefined && lastDot !== -1) {
          var objectName = results.nodeName.substring(lastDot + 1)

          // Object names must be checked against a whitelist. Otherwise, there
          // is no way to parse 'foo.bar.baz': 'baz' must be a property, but
          // 'bar' could be the objectName, or part of a nodeName (which can
          // include '.' characters).
          if (supportedObjectNames.indexOf(objectName) !== -1) {
            results.nodeName = results.nodeName.substring(0, lastDot)
            results.objectName = objectName
          }
        }

        if (results.propertyName === null || results.propertyName.length === 0) {
          throw new Error(
            'PropertyBinding: can not parse propertyName from trackName: ' + trackName
          )
        }

        return results
      }
    })(),

    findNode: function (root, nodeName) {
      if (
        !nodeName ||
        nodeName === '' ||
        nodeName === 'root' ||
        nodeName === '.' ||
        nodeName === -1 ||
        nodeName === root.name ||
        nodeName === root.uuid
      ) {
        return root
      }

      // search into skeleton bones.
      if (root.skeleton) {
        var bone = root.skeleton.getBoneByName(nodeName)

        if (bone !== undefined) {
          return bone
        }
      }

      // search into node subtree.
      if (root.children) {
        var searchNodeSubtree = function (children) {
          for (var i = 0; i < children.length; i++) {
            var childNode = children[i]

            if (childNode.name === nodeName || childNode.uuid === nodeName) {
              return childNode
            }

            var result = searchNodeSubtree(childNode.children)

            if (result) return result
          }

          return null
        }

        var subTreeNode = searchNodeSubtree(root.children)

        if (subTreeNode) {
          return subTreeNode
        }
      }

      return null
    }
  })

  Object.assign(PropertyBinding.prototype, {
    // prototype, continued

    // these are used to "bind" a nonexistent property
    _getValue_unavailable: function () {},
    _setValue_unavailable: function () {},

    BindingType: {
      Direct: 0,
      EntireArray: 1,
      ArrayElement: 2,
      HasFromToArray: 3
    },

    Versioning: {
      None: 0,
      NeedsUpdate: 1,
      MatrixWorldNeedsUpdate: 2
    },

    GetterByBindingType: [
      function getValue_direct(buffer, offset) {
        buffer[offset] = this.node[this.propertyName]
      },

      function getValue_array(buffer, offset) {
        var source = this.resolvedProperty

        for (var i = 0, n = source.length; i !== n; ++i) {
          buffer[offset++] = source[i]
        }
      },

      function getValue_arrayElement(buffer, offset) {
        buffer[offset] = this.resolvedProperty[this.propertyIndex]
      },

      function getValue_toArray(buffer, offset) {
        this.resolvedProperty.toArray(buffer, offset)
      }
    ],

    SetterByBindingTypeAndVersioning: [
      [
        // Direct

        function setValue_direct(buffer, offset) {
          this.targetObject[this.propertyName] = buffer[offset]
        },

        function setValue_direct_setNeedsUpdate(buffer, offset) {
          this.targetObject[this.propertyName] = buffer[offset]
          this.targetObject.needsUpdate = true
        },

        function setValue_direct_setMatrixWorldNeedsUpdate(buffer, offset) {
          this.targetObject[this.propertyName] = buffer[offset]
          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ],
      [
        // EntireArray

        function setValue_array(buffer, offset) {
          var dest = this.resolvedProperty

          for (var i = 0, n = dest.length; i !== n; ++i) {
            dest[i] = buffer[offset++]
          }
        },

        function setValue_array_setNeedsUpdate(buffer, offset) {
          var dest = this.resolvedProperty

          for (var i = 0, n = dest.length; i !== n; ++i) {
            dest[i] = buffer[offset++]
          }

          this.targetObject.needsUpdate = true
        },

        function setValue_array_setMatrixWorldNeedsUpdate(buffer, offset) {
          var dest = this.resolvedProperty

          for (var i = 0, n = dest.length; i !== n; ++i) {
            dest[i] = buffer[offset++]
          }

          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ],
      [
        // ArrayElement

        function setValue_arrayElement(buffer, offset) {
          this.resolvedProperty[this.propertyIndex] = buffer[offset]
        },

        function setValue_arrayElement_setNeedsUpdate(buffer, offset) {
          this.resolvedProperty[this.propertyIndex] = buffer[offset]
          this.targetObject.needsUpdate = true
        },

        function setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer, offset) {
          this.resolvedProperty[this.propertyIndex] = buffer[offset]
          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ],
      [
        // HasToFromArray

        function setValue_fromArray(buffer, offset) {
          this.resolvedProperty.fromArray(buffer, offset)
        },

        function setValue_fromArray_setNeedsUpdate(buffer, offset) {
          this.resolvedProperty.fromArray(buffer, offset)
          this.targetObject.needsUpdate = true
        },

        function setValue_fromArray_setMatrixWorldNeedsUpdate(buffer, offset) {
          this.resolvedProperty.fromArray(buffer, offset)
          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ]
    ],

    getValue: function getValue_unbound(targetArray, offset) {
      this.bind()
      this.getValue(targetArray, offset)

      // Note: This class uses a State pattern on a per-method basis:
      // 'bind' sets 'this.getValue' / 'setValue' and shadows the
      // prototype version of these methods with one that represents
      // the bound state. When the property is not found, the methods
      // become no-ops.
    },

    setValue: function getValue_unbound(sourceArray, offset) {
      this.bind()
      this.setValue(sourceArray, offset)
    },

    // create getter / setter pair for a property in the scene graph
    bind: function () {
      var targetObject = this.node,
        parsedPath = this.parsedPath,
        objectName = parsedPath.objectName,
        propertyName = parsedPath.propertyName,
        propertyIndex = parsedPath.propertyIndex

      if (!targetObject) {
        targetObject = PropertyBinding.findNode(this.rootNode, parsedPath.nodeName) || this.rootNode

        this.node = targetObject
      }

      // set fail state so we can just 'return' on error
      this.getValue = this._getValue_unavailable
      this.setValue = this._setValue_unavailable

      // ensure there is a value node
      if (!targetObject) {
        console.error(
          'THREE.PropertyBinding: Trying to update node for track: ' +
            this.path +
            " but it wasn't found."
        )
        return
      }

      if (objectName) {
        var objectIndex = parsedPath.objectIndex

        // special cases were we need to reach deeper into the hierarchy to get the face materials....
        switch (objectName) {
          case 'materials':
            if (!targetObject.material) {
              console.error(
                'THREE.PropertyBinding: Can not bind to material as node does not have a material.',
                this
              )
              return
            }

            if (!targetObject.material.materials) {
              console.error(
                'THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.',
                this
              )
              return
            }

            targetObject = targetObject.material.materials

            break

          case 'bones':
            if (!targetObject.skeleton) {
              console.error(
                'THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.',
                this
              )
              return
            }

            // potential future optimization: skip this if propertyIndex is already an integer
            // and convert the integer string to a true integer.

            targetObject = targetObject.skeleton.bones

            // support resolving morphTarget names into indices.
            for (var i = 0; i < targetObject.length; i++) {
              if (targetObject[i].name === objectIndex) {
                objectIndex = i
                break
              }
            }

            break

          default:
            if (targetObject[objectName] === undefined) {
              console.error(
                'THREE.PropertyBinding: Can not bind to objectName of node undefined.',
                this
              )
              return
            }

            targetObject = targetObject[objectName]
        }

        if (objectIndex !== undefined) {
          if (targetObject[objectIndex] === undefined) {
            console.error(
              'THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.',
              this,
              targetObject
            )
            return
          }

          targetObject = targetObject[objectIndex]
        }
      }

      // resolve property
      var nodeProperty = targetObject[propertyName]

      if (nodeProperty === undefined) {
        var nodeName = parsedPath.nodeName

        console.error(
          'THREE.PropertyBinding: Trying to update property for track: ' +
            nodeName +
            '.' +
            propertyName +
            " but it wasn't found.",
          targetObject
        )
        return
      }

      // determine versioning scheme
      var versioning = this.Versioning.None

      if (targetObject.needsUpdate !== undefined) {
        // material

        versioning = this.Versioning.NeedsUpdate
        this.targetObject = targetObject
      } else if (targetObject.matrixWorldNeedsUpdate !== undefined) {
        // node transform

        versioning = this.Versioning.MatrixWorldNeedsUpdate
        this.targetObject = targetObject
      }

      // determine how the property gets bound
      var bindingType = this.BindingType.Direct

      if (propertyIndex !== undefined) {
        // access a sub element of the property array (only primitives are supported right now)

        if (propertyName === 'morphTargetInfluences') {
          // potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.

          // support resolving morphTarget names into indices.
          if (!targetObject.geometry) {
            console.error(
              'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.',
              this
            )
            return
          }

          if (targetObject.geometry.isBufferGeometry) {
            if (!targetObject.geometry.morphAttributes) {
              console.error(
                'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.',
                this
              )
              return
            }

            for (var i = 0; i < this.node.geometry.morphAttributes.position.length; i++) {
              if (targetObject.geometry.morphAttributes.position[i].name === propertyIndex) {
                propertyIndex = i
                break
              }
            }
          } else {
            if (!targetObject.geometry.morphTargets) {
              console.error(
                'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphTargets.',
                this
              )
              return
            }

            for (var i = 0; i < this.node.geometry.morphTargets.length; i++) {
              if (targetObject.geometry.morphTargets[i].name === propertyIndex) {
                propertyIndex = i
                break
              }
            }
          }
        }

        bindingType = this.BindingType.ArrayElement

        this.resolvedProperty = nodeProperty
        this.propertyIndex = propertyIndex
      } else if (nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined) {
        // must use copy for Object3D.Euler/Quaternion

        bindingType = this.BindingType.HasFromToArray

        this.resolvedProperty = nodeProperty
      } else if (Array.isArray(nodeProperty)) {
        bindingType = this.BindingType.EntireArray

        this.resolvedProperty = nodeProperty
      } else {
        this.propertyName = propertyName
      }

      // select getter / setter
      this.getValue = this.GetterByBindingType[bindingType]
      this.setValue = this.SetterByBindingTypeAndVersioning[bindingType][versioning]
    },

    unbind: function () {
      this.node = null

      // back to the prototype version of getValue / setValue
      // note: avoiding to mutate the shape of 'this' via 'delete'
      this.getValue = this._getValue_unbound
      this.setValue = this._setValue_unbound
    }
  })

  //!\ DECLARE ALIAS AFTER assign prototype !
  Object.assign(PropertyBinding.prototype, {
    // initial state of these methods that calls 'bind'
    _getValue_unbound: PropertyBinding.prototype.getValue,
    _setValue_unbound: PropertyBinding.prototype.setValue
  })

  /**
   *
   * A group of objects that receives a shared animation state.
   *
   * Usage:
   *
   * 	-	Add objects you would otherwise pass as 'root' to the
   * 		constructor or the .clipAction method of AnimationMixer.
   *
   * 	-	Instead pass this object as 'root'.
   *
   * 	-	You can also add and remove objects later when the mixer
   * 		is running.
   *
   * Note:
   *
   *  	Objects of this class appear as one object to the mixer,
   *  	so cache control of the individual objects must be done
   *  	on the group.
   *
   * Limitation:
   *
   * 	- 	The animated properties must be compatible among the
   * 		all objects in the group.
   *
   *  -	A single property can either be controlled through a
   *  	target group or directly, but not both.
   *
   * @author tschw
   */

  function AnimationObjectGroup() {
    this.uuid = _Math.generateUUID()

    // cached objects followed by the active ones
    this._objects = Array.prototype.slice.call(arguments)

    this.nCachedObjects_ = 0 // threshold
    // note: read by PropertyBinding.Composite

    var indices = {}
    this._indicesByUUID = indices // for bookkeeping

    for (var i = 0, n = arguments.length; i !== n; ++i) {
      indices[arguments[i].uuid] = i
    }

    this._paths = [] // inside: string
    this._parsedPaths = [] // inside: { we don't care, here }
    this._bindings = [] // inside: Array< PropertyBinding >
    this._bindingsIndicesByPath = {} // inside: indices in these arrays

    var scope = this

    this.stats = {
      objects: {
        get total() {
          return scope._objects.length
        },
        get inUse() {
          return this.total - scope.nCachedObjects_
        }
      },
      get bindingsPerObject() {
        return scope._bindings.length
      }
    }
  }

  Object.assign(AnimationObjectGroup.prototype, {
    isAnimationObjectGroup: true,

    add: function () {
      var objects = this._objects,
        nObjects = objects.length,
        nCachedObjects = this.nCachedObjects_,
        indicesByUUID = this._indicesByUUID,
        paths = this._paths,
        parsedPaths = this._parsedPaths,
        bindings = this._bindings,
        nBindings = bindings.length,
        knownObject = undefined

      for (var i = 0, n = arguments.length; i !== n; ++i) {
        var object = arguments[i],
          uuid = object.uuid,
          index = indicesByUUID[uuid]

        if (index === undefined) {
          // unknown object -> add it to the ACTIVE region

          index = nObjects++
          indicesByUUID[uuid] = index
          objects.push(object)

          // accounting is done, now do the same for all bindings

          for (var j = 0, m = nBindings; j !== m; ++j) {
            bindings[j].push(new PropertyBinding(object, paths[j], parsedPaths[j]))
          }
        } else if (index < nCachedObjects) {
          knownObject = objects[index]

          // move existing object to the ACTIVE region

          var firstActiveIndex = --nCachedObjects,
            lastCachedObject = objects[firstActiveIndex]

          indicesByUUID[lastCachedObject.uuid] = index
          objects[index] = lastCachedObject

          indicesByUUID[uuid] = firstActiveIndex
          objects[firstActiveIndex] = object

          // accounting is done, now do the same for all bindings

          for (var j = 0, m = nBindings; j !== m; ++j) {
            var bindingsForPath = bindings[j],
              lastCached = bindingsForPath[firstActiveIndex],
              binding = bindingsForPath[index]

            bindingsForPath[index] = lastCached

            if (binding === undefined) {
              // since we do not bother to create new bindings
              // for objects that are cached, the binding may
              // or may not exist

              binding = new PropertyBinding(object, paths[j], parsedPaths[j])
            }

            bindingsForPath[firstActiveIndex] = binding
          }
        } else if (objects[index] !== knownObject) {
          console.error(
            'THREE.AnimationObjectGroup: Different objects with the same UUID ' +
              'detected. Clean the caches or recreate your infrastructure when reloading scenes.'
          )
        } // else the object is already where we want it to be
      } // for arguments

      this.nCachedObjects_ = nCachedObjects
    },

    remove: function () {
      var objects = this._objects,
        nCachedObjects = this.nCachedObjects_,
        indicesByUUID = this._indicesByUUID,
        bindings = this._bindings,
        nBindings = bindings.length

      for (var i = 0, n = arguments.length; i !== n; ++i) {
        var object = arguments[i],
          uuid = object.uuid,
          index = indicesByUUID[uuid]

        if (index !== undefined && index >= nCachedObjects) {
          // move existing object into the CACHED region

          var lastCachedIndex = nCachedObjects++,
            firstActiveObject = objects[lastCachedIndex]

          indicesByUUID[firstActiveObject.uuid] = index
          objects[index] = firstActiveObject

          indicesByUUID[uuid] = lastCachedIndex
          objects[lastCachedIndex] = object

          // accounting is done, now do the same for all bindings

          for (var j = 0, m = nBindings; j !== m; ++j) {
            var bindingsForPath = bindings[j],
              firstActive = bindingsForPath[lastCachedIndex],
              binding = bindingsForPath[index]

            bindingsForPath[index] = firstActive
            bindingsForPath[lastCachedIndex] = binding
          }
        }
      } // for arguments

      this.nCachedObjects_ = nCachedObjects
    },

    // remove & forget
    uncache: function () {
      var objects = this._objects,
        nObjects = objects.length,
        nCachedObjects = this.nCachedObjects_,
        indicesByUUID = this._indicesByUUID,
        bindings = this._bindings,
        nBindings = bindings.length

      for (var i = 0, n = arguments.length; i !== n; ++i) {
        var object = arguments[i],
          uuid = object.uuid,
          index = indicesByUUID[uuid]

        if (index !== undefined) {
          delete indicesByUUID[uuid]

          if (index < nCachedObjects) {
            // object is cached, shrink the CACHED region

            var firstActiveIndex = --nCachedObjects,
              lastCachedObject = objects[firstActiveIndex],
              lastIndex = --nObjects,
              lastObject = objects[lastIndex]

            // last cached object takes this object's place
            indicesByUUID[lastCachedObject.uuid] = index
            objects[index] = lastCachedObject

            // last object goes to the activated slot and pop
            indicesByUUID[lastObject.uuid] = firstActiveIndex
            objects[firstActiveIndex] = lastObject
            objects.pop()

            // accounting is done, now do the same for all bindings

            for (var j = 0, m = nBindings; j !== m; ++j) {
              var bindingsForPath = bindings[j],
                lastCached = bindingsForPath[firstActiveIndex],
                last = bindingsForPath[lastIndex]

              bindingsForPath[index] = lastCached
              bindingsForPath[firstActiveIndex] = last
              bindingsForPath.pop()
            }
          } else {
            // object is active, just swap with the last and pop

            var lastIndex = --nObjects,
              lastObject = objects[lastIndex]

            indicesByUUID[lastObject.uuid] = index
            objects[index] = lastObject
            objects.pop()

            // accounting is done, now do the same for all bindings

            for (var j = 0, m = nBindings; j !== m; ++j) {
              var bindingsForPath = bindings[j]

              bindingsForPath[index] = bindingsForPath[lastIndex]
              bindingsForPath.pop()
            }
          } // cached or active
        } // if object is known
      } // for arguments

      this.nCachedObjects_ = nCachedObjects
    },

    // Internal interface used by befriended PropertyBinding.Composite:

    subscribe_: function (path, parsedPath) {
      // returns an array of bindings for the given path that is changed
      // according to the contained objects in the group

      var indicesByPath = this._bindingsIndicesByPath,
        index = indicesByPath[path],
        bindings = this._bindings

      if (index !== undefined) return bindings[index]

      var paths = this._paths,
        parsedPaths = this._parsedPaths,
        objects = this._objects,
        nObjects = objects.length,
        nCachedObjects = this.nCachedObjects_,
        bindingsForPath = new Array(nObjects)

      index = bindings.length

      indicesByPath[path] = index

      paths.push(path)
      parsedPaths.push(parsedPath)
      bindings.push(bindingsForPath)

      for (var i = nCachedObjects, n = objects.length; i !== n; ++i) {
        var object = objects[i]
        bindingsForPath[i] = new PropertyBinding(object, path, parsedPath)
      }

      return bindingsForPath
    },

    unsubscribe_: function (path) {
      // tells the group to forget about a property path and no longer
      // update the array previously obtained with 'subscribe_'

      var indicesByPath = this._bindingsIndicesByPath,
        index = indicesByPath[path]

      if (index !== undefined) {
        var paths = this._paths,
          parsedPaths = this._parsedPaths,
          bindings = this._bindings,
          lastBindingsIndex = bindings.length - 1,
          lastBindings = bindings[lastBindingsIndex],
          lastBindingsPath = path[lastBindingsIndex]

        indicesByPath[lastBindingsPath] = index

        bindings[index] = lastBindings
        bindings.pop()

        parsedPaths[index] = parsedPaths[lastBindingsIndex]
        parsedPaths.pop()

        paths[index] = paths[lastBindingsIndex]
        paths.pop()
      }
    }
  })

  /**
   *
   * Action provided by AnimationMixer for scheduling clip playback on specific
   * objects.
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   *
   */

  function AnimationAction(mixer, clip, localRoot) {
    this._mixer = mixer
    this._clip = clip
    this._localRoot = localRoot || null

    var tracks = clip.tracks,
      nTracks = tracks.length,
      interpolants = new Array(nTracks)

    var interpolantSettings = {
      endingStart: ZeroCurvatureEnding,
      endingEnd: ZeroCurvatureEnding
    }

    for (var i = 0; i !== nTracks; ++i) {
      var interpolant = tracks[i].createInterpolant(null)
      interpolants[i] = interpolant
      interpolant.settings = interpolantSettings
    }

    this._interpolantSettings = interpolantSettings

    this._interpolants = interpolants // bound by the mixer

    // inside: PropertyMixer (managed by the mixer)
    this._propertyBindings = new Array(nTracks)

    this._cacheIndex = null // for the memory manager
    this._byClipCacheIndex = null // for the memory manager

    this._timeScaleInterpolant = null
    this._weightInterpolant = null

    this.loop = LoopRepeat
    this._loopCount = -1

    // global mixer time when the action is to be started
    // it's set back to 'null' upon start of the action
    this._startTime = null

    // scaled local time of the action
    // gets clamped or wrapped to 0..clip.duration according to loop
    this.time = 0

    this.timeScale = 1
    this._effectiveTimeScale = 1

    this.weight = 1
    this._effectiveWeight = 1

    this.repetitions = Infinity // no. of repetitions when looping

    this.paused = false // true -> zero effective time scale
    this.enabled = true // false -> zero effective weight

    this.clampWhenFinished = false // keep feeding the last frame?

    this.zeroSlopeAtStart = true // for smooth interpolation w/o separate
    this.zeroSlopeAtEnd = true // clips for start, loop and end
  }

  Object.assign(AnimationAction.prototype, {
    // State & Scheduling

    play: function () {
      this._mixer._activateAction(this)

      return this
    },

    stop: function () {
      this._mixer._deactivateAction(this)

      return this.reset()
    },

    reset: function () {
      this.paused = false
      this.enabled = true

      this.time = 0 // restart clip
      this._loopCount = -1 // forget previous loops
      this._startTime = null // forget scheduling

      return this.stopFading().stopWarping()
    },

    isRunning: function () {
      return (
        this.enabled &&
        !this.paused &&
        this.timeScale !== 0 &&
        this._startTime === null &&
        this._mixer._isActiveAction(this)
      )
    },

    // return true when play has been called
    isScheduled: function () {
      return this._mixer._isActiveAction(this)
    },

    startAt: function (time) {
      this._startTime = time

      return this
    },

    setLoop: function (mode, repetitions) {
      this.loop = mode
      this.repetitions = repetitions

      return this
    },

    // Weight

    // set the weight stopping any scheduled fading
    // although .enabled = false yields an effective weight of zero, this
    // method does *not* change .enabled, because it would be confusing
    setEffectiveWeight: function (weight) {
      this.weight = weight

      // note: same logic as when updated at runtime
      this._effectiveWeight = this.enabled ? weight : 0

      return this.stopFading()
    },

    // return the weight considering fading and .enabled
    getEffectiveWeight: function () {
      return this._effectiveWeight
    },

    fadeIn: function (duration) {
      return this._scheduleFading(duration, 0, 1)
    },

    fadeOut: function (duration) {
      return this._scheduleFading(duration, 1, 0)
    },

    crossFadeFrom: function (fadeOutAction, duration, warp) {
      fadeOutAction.fadeOut(duration)
      this.fadeIn(duration)

      if (warp) {
        var fadeInDuration = this._clip.duration,
          fadeOutDuration = fadeOutAction._clip.duration,
          startEndRatio = fadeOutDuration / fadeInDuration,
          endStartRatio = fadeInDuration / fadeOutDuration

        fadeOutAction.warp(1.0, startEndRatio, duration)
        this.warp(endStartRatio, 1.0, duration)
      }

      return this
    },

    crossFadeTo: function (fadeInAction, duration, warp) {
      return fadeInAction.crossFadeFrom(this, duration, warp)
    },

    stopFading: function () {
      var weightInterpolant = this._weightInterpolant

      if (weightInterpolant !== null) {
        this._weightInterpolant = null
        this._mixer._takeBackControlInterpolant(weightInterpolant)
      }

      return this
    },

    // Time Scale Control

    // set the time scale stopping any scheduled warping
    // although .paused = true yields an effective time scale of zero, this
    // method does *not* change .paused, because it would be confusing
    setEffectiveTimeScale: function (timeScale) {
      this.timeScale = timeScale
      this._effectiveTimeScale = this.paused ? 0 : timeScale

      return this.stopWarping()
    },

    // return the time scale considering warping and .paused
    getEffectiveTimeScale: function () {
      return this._effectiveTimeScale
    },

    setDuration: function (duration) {
      this.timeScale = this._clip.duration / duration

      return this.stopWarping()
    },

    syncWith: function (action) {
      this.time = action.time
      this.timeScale = action.timeScale

      return this.stopWarping()
    },

    halt: function (duration) {
      return this.warp(this._effectiveTimeScale, 0, duration)
    },

    warp: function (startTimeScale, endTimeScale, duration) {
      var mixer = this._mixer,
        now = mixer.time,
        interpolant = this._timeScaleInterpolant,
        timeScale = this.timeScale

      if (interpolant === null) {
        interpolant = mixer._lendControlInterpolant()
        this._timeScaleInterpolant = interpolant
      }

      var times = interpolant.parameterPositions,
        values = interpolant.sampleValues

      times[0] = now
      times[1] = now + duration

      values[0] = startTimeScale / timeScale
      values[1] = endTimeScale / timeScale

      return this
    },

    stopWarping: function () {
      var timeScaleInterpolant = this._timeScaleInterpolant

      if (timeScaleInterpolant !== null) {
        this._timeScaleInterpolant = null
        this._mixer._takeBackControlInterpolant(timeScaleInterpolant)
      }

      return this
    },

    // Object Accessors

    getMixer: function () {
      return this._mixer
    },

    getClip: function () {
      return this._clip
    },

    getRoot: function () {
      return this._localRoot || this._mixer._root
    },

    // Interna

    _update: function (time, deltaTime, timeDirection, accuIndex) {
      // called by the mixer

      if (!this.enabled) {
        // call ._updateWeight() to update ._effectiveWeight

        this._updateWeight(time)
        return
      }

      var startTime = this._startTime

      if (startTime !== null) {
        // check for scheduled start of action

        var timeRunning = (time - startTime) * timeDirection
        if (timeRunning < 0 || timeDirection === 0) {
          return // yet to come / don't decide when delta = 0
        }

        // start

        this._startTime = null // unschedule
        deltaTime = timeDirection * timeRunning
      }

      // apply time scale and advance time

      deltaTime *= this._updateTimeScale(time)
      var clipTime = this._updateTime(deltaTime)

      // note: _updateTime may disable the action resulting in
      // an effective weight of 0

      var weight = this._updateWeight(time)

      if (weight > 0) {
        var interpolants = this._interpolants
        var propertyMixers = this._propertyBindings

        for (var j = 0, m = interpolants.length; j !== m; ++j) {
          interpolants[j].evaluate(clipTime)
          propertyMixers[j].accumulate(accuIndex, weight)
        }
      }
    },

    _updateWeight: function (time) {
      var weight = 0

      if (this.enabled) {
        weight = this.weight
        var interpolant = this._weightInterpolant

        if (interpolant !== null) {
          var interpolantValue = interpolant.evaluate(time)[0]

          weight *= interpolantValue

          if (time > interpolant.parameterPositions[1]) {
            this.stopFading()

            if (interpolantValue === 0) {
              // faded out, disable
              this.enabled = false
            }
          }
        }
      }

      this._effectiveWeight = weight
      return weight
    },

    _updateTimeScale: function (time) {
      var timeScale = 0

      if (!this.paused) {
        timeScale = this.timeScale

        var interpolant = this._timeScaleInterpolant

        if (interpolant !== null) {
          var interpolantValue = interpolant.evaluate(time)[0]

          timeScale *= interpolantValue

          if (time > interpolant.parameterPositions[1]) {
            this.stopWarping()

            if (timeScale === 0) {
              // motion has halted, pause
              this.paused = true
            } else {
              // warp done - apply final time scale
              this.timeScale = timeScale
            }
          }
        }
      }

      this._effectiveTimeScale = timeScale
      return timeScale
    },

    _updateTime: function (deltaTime) {
      var time = this.time + deltaTime

      if (deltaTime === 0) return time

      var duration = this._clip.duration,
        loop = this.loop,
        loopCount = this._loopCount

      if (loop === LoopOnce) {
        if (loopCount === -1) {
          // just started

          this._loopCount = 0
          this._setEndings(true, true, false)
        }

        handle_stop: {
          if (time >= duration) {
            time = duration
          } else if (time < 0) {
            time = 0
          } else break handle_stop

          if (this.clampWhenFinished) this.paused = true
          else this.enabled = false

          this._mixer.dispatchEvent({
            type: 'finished',
            action: this,
            direction: deltaTime < 0 ? -1 : 1
          })
        }
      } else {
        // repetitive Repeat or PingPong

        var pingPong = loop === LoopPingPong

        if (loopCount === -1) {
          // just started

          if (deltaTime >= 0) {
            loopCount = 0

            this._setEndings(true, this.repetitions === 0, pingPong)
          } else {
            // when looping in reverse direction, the initial
            // transition through zero counts as a repetition,
            // so leave loopCount at -1

            this._setEndings(this.repetitions === 0, true, pingPong)
          }
        }

        if (time >= duration || time < 0) {
          // wrap around

          var loopDelta = Math.floor(time / duration) // signed
          time -= duration * loopDelta

          loopCount += Math.abs(loopDelta)

          var pending = this.repetitions - loopCount

          if (pending < 0) {
            // have to stop (switch state, clamp time, fire event)

            if (this.clampWhenFinished) this.paused = true
            else this.enabled = false

            time = deltaTime > 0 ? duration : 0

            this._mixer.dispatchEvent({
              type: 'finished',
              action: this,
              direction: deltaTime > 0 ? 1 : -1
            })
          } else {
            // keep running

            if (pending === 0) {
              // entering the last round

              var atStart = deltaTime < 0
              this._setEndings(atStart, !atStart, pingPong)
            } else {
              this._setEndings(false, false, pingPong)
            }

            this._loopCount = loopCount

            this._mixer.dispatchEvent({
              type: 'loop',
              action: this,
              loopDelta: loopDelta
            })
          }
        }

        if (pingPong && (loopCount & 1) === 1) {
          // invert time for the "pong round"

          this.time = time
          return duration - time
        }
      }

      this.time = time
      return time
    },

    _setEndings: function (atStart, atEnd, pingPong) {
      var settings = this._interpolantSettings

      if (pingPong) {
        settings.endingStart = ZeroSlopeEnding
        settings.endingEnd = ZeroSlopeEnding
      } else {
        // assuming for LoopOnce atStart == atEnd == true

        if (atStart) {
          settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding
        } else {
          settings.endingStart = WrapAroundEnding
        }

        if (atEnd) {
          settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding
        } else {
          settings.endingEnd = WrapAroundEnding
        }
      }
    },

    _scheduleFading: function (duration, weightNow, weightThen) {
      var mixer = this._mixer,
        now = mixer.time,
        interpolant = this._weightInterpolant

      if (interpolant === null) {
        interpolant = mixer._lendControlInterpolant()
        this._weightInterpolant = interpolant
      }

      var times = interpolant.parameterPositions,
        values = interpolant.sampleValues

      times[0] = now
      values[0] = weightNow
      times[1] = now + duration
      values[1] = weightThen

      return this
    }
  })

  /**
   *
   * Player for AnimationClips.
   *
   *
   * @author Ben Houston / http://clara.io/
   * @author David Sarno / http://lighthaus.us/
   * @author tschw
   */

  function AnimationMixer(root) {
    this._root = root
    this._initMemoryManager()
    this._accuIndex = 0

    this.time = 0

    this.timeScale = 1.0
  }

  AnimationMixer.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: AnimationMixer,

    _bindAction: function (action, prototypeAction) {
      var root = action._localRoot || this._root,
        tracks = action._clip.tracks,
        nTracks = tracks.length,
        bindings = action._propertyBindings,
        interpolants = action._interpolants,
        rootUuid = root.uuid,
        bindingsByRoot = this._bindingsByRootAndName,
        bindingsByName = bindingsByRoot[rootUuid]

      if (bindingsByName === undefined) {
        bindingsByName = {}
        bindingsByRoot[rootUuid] = bindingsByName
      }

      for (var i = 0; i !== nTracks; ++i) {
        var track = tracks[i],
          trackName = track.name,
          binding = bindingsByName[trackName]

        if (binding !== undefined) {
          bindings[i] = binding
        } else {
          binding = bindings[i]

          if (binding !== undefined) {
            // existing binding, make sure the cache knows

            if (binding._cacheIndex === null) {
              ++binding.referenceCount
              this._addInactiveBinding(binding, rootUuid, trackName)
            }

            continue
          }

          var path = prototypeAction && prototypeAction._propertyBindings[i].binding.parsedPath

          binding = new PropertyMixer(
            PropertyBinding.create(root, trackName, path),
            track.ValueTypeName,
            track.getValueSize()
          )

          ++binding.referenceCount
          this._addInactiveBinding(binding, rootUuid, trackName)

          bindings[i] = binding
        }

        interpolants[i].resultBuffer = binding.buffer
      }
    },

    _activateAction: function (action) {
      if (!this._isActiveAction(action)) {
        if (action._cacheIndex === null) {
          // this action has been forgotten by the cache, but the user
          // appears to be still using it -> rebind

          var rootUuid = (action._localRoot || this._root).uuid,
            clipUuid = action._clip.uuid,
            actionsForClip = this._actionsByClip[clipUuid]

          this._bindAction(action, actionsForClip && actionsForClip.knownActions[0])

          this._addInactiveAction(action, clipUuid, rootUuid)
        }

        var bindings = action._propertyBindings

        // increment reference counts / sort out state
        for (var i = 0, n = bindings.length; i !== n; ++i) {
          var binding = bindings[i]

          if (binding.useCount++ === 0) {
            this._lendBinding(binding)
            binding.saveOriginalState()
          }
        }

        this._lendAction(action)
      }
    },

    _deactivateAction: function (action) {
      if (this._isActiveAction(action)) {
        var bindings = action._propertyBindings

        // decrement reference counts / sort out state
        for (var i = 0, n = bindings.length; i !== n; ++i) {
          var binding = bindings[i]

          if (--binding.useCount === 0) {
            binding.restoreOriginalState()
            this._takeBackBinding(binding)
          }
        }

        this._takeBackAction(action)
      }
    },

    // Memory manager

    _initMemoryManager: function () {
      this._actions = [] // 'nActiveActions' followed by inactive ones
      this._nActiveActions = 0

      this._actionsByClip = {}
      // inside:
      // {
      // 		knownActions: Array< AnimationAction >	- used as prototypes
      // 		actionByRoot: AnimationAction			- lookup
      // }

      this._bindings = [] // 'nActiveBindings' followed by inactive ones
      this._nActiveBindings = 0

      this._bindingsByRootAndName = {} // inside: Map< name, PropertyMixer >

      this._controlInterpolants = [] // same game as above
      this._nActiveControlInterpolants = 0

      var scope = this

      this.stats = {
        actions: {
          get total() {
            return scope._actions.length
          },
          get inUse() {
            return scope._nActiveActions
          }
        },
        bindings: {
          get total() {
            return scope._bindings.length
          },
          get inUse() {
            return scope._nActiveBindings
          }
        },
        controlInterpolants: {
          get total() {
            return scope._controlInterpolants.length
          },
          get inUse() {
            return scope._nActiveControlInterpolants
          }
        }
      }
    },

    // Memory management for AnimationAction objects

    _isActiveAction: function (action) {
      var index = action._cacheIndex
      return index !== null && index < this._nActiveActions
    },

    _addInactiveAction: function (action, clipUuid, rootUuid) {
      var actions = this._actions,
        actionsByClip = this._actionsByClip,
        actionsForClip = actionsByClip[clipUuid]

      if (actionsForClip === undefined) {
        actionsForClip = {
          knownActions: [action],
          actionByRoot: {}
        }

        action._byClipCacheIndex = 0

        actionsByClip[clipUuid] = actionsForClip
      } else {
        var knownActions = actionsForClip.knownActions

        action._byClipCacheIndex = knownActions.length
        knownActions.push(action)
      }

      action._cacheIndex = actions.length
      actions.push(action)

      actionsForClip.actionByRoot[rootUuid] = action
    },

    _removeInactiveAction: function (action) {
      var actions = this._actions,
        lastInactiveAction = actions[actions.length - 1],
        cacheIndex = action._cacheIndex

      lastInactiveAction._cacheIndex = cacheIndex
      actions[cacheIndex] = lastInactiveAction
      actions.pop()

      action._cacheIndex = null

      var clipUuid = action._clip.uuid,
        actionsByClip = this._actionsByClip,
        actionsForClip = actionsByClip[clipUuid],
        knownActionsForClip = actionsForClip.knownActions,
        lastKnownAction = knownActionsForClip[knownActionsForClip.length - 1],
        byClipCacheIndex = action._byClipCacheIndex

      lastKnownAction._byClipCacheIndex = byClipCacheIndex
      knownActionsForClip[byClipCacheIndex] = lastKnownAction
      knownActionsForClip.pop()

      action._byClipCacheIndex = null

      var actionByRoot = actionsForClip.actionByRoot,
        rootUuid = (action._localRoot || this._root).uuid

      delete actionByRoot[rootUuid]

      if (knownActionsForClip.length === 0) {
        delete actionsByClip[clipUuid]
      }

      this._removeInactiveBindingsForAction(action)
    },

    _removeInactiveBindingsForAction: function (action) {
      var bindings = action._propertyBindings
      for (var i = 0, n = bindings.length; i !== n; ++i) {
        var binding = bindings[i]

        if (--binding.referenceCount === 0) {
          this._removeInactiveBinding(binding)
        }
      }
    },

    _lendAction: function (action) {
      // [ active actions |  inactive actions  ]
      // [  active actions >| inactive actions ]
      //                 s        a
      //                  <-swap->
      //                 a        s

      var actions = this._actions,
        prevIndex = action._cacheIndex,
        lastActiveIndex = this._nActiveActions++,
        firstInactiveAction = actions[lastActiveIndex]

      action._cacheIndex = lastActiveIndex
      actions[lastActiveIndex] = action

      firstInactiveAction._cacheIndex = prevIndex
      actions[prevIndex] = firstInactiveAction
    },

    _takeBackAction: function (action) {
      // [  active actions  | inactive actions ]
      // [ active actions |< inactive actions  ]
      //        a        s
      //         <-swap->
      //        s        a

      var actions = this._actions,
        prevIndex = action._cacheIndex,
        firstInactiveIndex = --this._nActiveActions,
        lastActiveAction = actions[firstInactiveIndex]

      action._cacheIndex = firstInactiveIndex
      actions[firstInactiveIndex] = action

      lastActiveAction._cacheIndex = prevIndex
      actions[prevIndex] = lastActiveAction
    },

    // Memory management for PropertyMixer objects

    _addInactiveBinding: function (binding, rootUuid, trackName) {
      var bindingsByRoot = this._bindingsByRootAndName,
        bindingByName = bindingsByRoot[rootUuid],
        bindings = this._bindings

      if (bindingByName === undefined) {
        bindingByName = {}
        bindingsByRoot[rootUuid] = bindingByName
      }

      bindingByName[trackName] = binding

      binding._cacheIndex = bindings.length
      bindings.push(binding)
    },

    _removeInactiveBinding: function (binding) {
      var bindings = this._bindings,
        propBinding = binding.binding,
        rootUuid = propBinding.rootNode.uuid,
        trackName = propBinding.path,
        bindingsByRoot = this._bindingsByRootAndName,
        bindingByName = bindingsByRoot[rootUuid],
        lastInactiveBinding = bindings[bindings.length - 1],
        cacheIndex = binding._cacheIndex

      lastInactiveBinding._cacheIndex = cacheIndex
      bindings[cacheIndex] = lastInactiveBinding
      bindings.pop()

      delete bindingByName[trackName]

      remove_empty_map: {
        for (var _ in bindingByName) break remove_empty_map // eslint-disable-line no-unused-vars

        delete bindingsByRoot[rootUuid]
      }
    },

    _lendBinding: function (binding) {
      var bindings = this._bindings,
        prevIndex = binding._cacheIndex,
        lastActiveIndex = this._nActiveBindings++,
        firstInactiveBinding = bindings[lastActiveIndex]

      binding._cacheIndex = lastActiveIndex
      bindings[lastActiveIndex] = binding

      firstInactiveBinding._cacheIndex = prevIndex
      bindings[prevIndex] = firstInactiveBinding
    },

    _takeBackBinding: function (binding) {
      var bindings = this._bindings,
        prevIndex = binding._cacheIndex,
        firstInactiveIndex = --this._nActiveBindings,
        lastActiveBinding = bindings[firstInactiveIndex]

      binding._cacheIndex = firstInactiveIndex
      bindings[firstInactiveIndex] = binding

      lastActiveBinding._cacheIndex = prevIndex
      bindings[prevIndex] = lastActiveBinding
    },

    // Memory management of Interpolants for weight and time scale

    _lendControlInterpolant: function () {
      var interpolants = this._controlInterpolants,
        lastActiveIndex = this._nActiveControlInterpolants++,
        interpolant = interpolants[lastActiveIndex]

      if (interpolant === undefined) {
        interpolant = new LinearInterpolant(
          new Float32Array(2),
          new Float32Array(2),
          1,
          this._controlInterpolantsResultBuffer
        )

        interpolant.__cacheIndex = lastActiveIndex
        interpolants[lastActiveIndex] = interpolant
      }

      return interpolant
    },

    _takeBackControlInterpolant: function (interpolant) {
      var interpolants = this._controlInterpolants,
        prevIndex = interpolant.__cacheIndex,
        firstInactiveIndex = --this._nActiveControlInterpolants,
        lastActiveInterpolant = interpolants[firstInactiveIndex]

      interpolant.__cacheIndex = firstInactiveIndex
      interpolants[firstInactiveIndex] = interpolant

      lastActiveInterpolant.__cacheIndex = prevIndex
      interpolants[prevIndex] = lastActiveInterpolant
    },

    _controlInterpolantsResultBuffer: new Float32Array(1),

    // return an action for a clip optionally using a custom root target
    // object (this method allocates a lot of dynamic memory in case a
    // previously unknown clip/root combination is specified)
    clipAction: function (clip, optionalRoot) {
      var root = optionalRoot || this._root,
        rootUuid = root.uuid,
        clipObject = typeof clip === 'string' ? AnimationClip.findByName(root, clip) : clip,
        clipUuid = clipObject !== null ? clipObject.uuid : clip,
        actionsForClip = this._actionsByClip[clipUuid],
        prototypeAction = null

      if (actionsForClip !== undefined) {
        var existingAction = actionsForClip.actionByRoot[rootUuid]

        if (existingAction !== undefined) {
          return existingAction
        }

        // we know the clip, so we don't have to parse all
        // the bindings again but can just copy
        prototypeAction = actionsForClip.knownActions[0]

        // also, take the clip from the prototype action
        if (clipObject === null) clipObject = prototypeAction._clip
      }

      // clip must be known when specified via string
      if (clipObject === null) return null

      // allocate all resources required to run it
      var newAction = new AnimationAction(this, clipObject, optionalRoot)

      this._bindAction(newAction, prototypeAction)

      // and make the action known to the memory manager
      this._addInactiveAction(newAction, clipUuid, rootUuid)

      return newAction
    },

    // get an existing action
    existingAction: function (clip, optionalRoot) {
      var root = optionalRoot || this._root,
        rootUuid = root.uuid,
        clipObject = typeof clip === 'string' ? AnimationClip.findByName(root, clip) : clip,
        clipUuid = clipObject ? clipObject.uuid : clip,
        actionsForClip = this._actionsByClip[clipUuid]

      if (actionsForClip !== undefined) {
        return actionsForClip.actionByRoot[rootUuid] || null
      }

      return null
    },

    // deactivates all previously scheduled actions
    stopAllAction: function () {
      var actions = this._actions,
        nActions = this._nActiveActions,
        bindings = this._bindings,
        nBindings = this._nActiveBindings

      this._nActiveActions = 0
      this._nActiveBindings = 0

      for (var i = 0; i !== nActions; ++i) {
        actions[i].reset()
      }

      for (var i = 0; i !== nBindings; ++i) {
        bindings[i].useCount = 0
      }

      return this
    },

    // advance the time and update apply the animation
    update: function (deltaTime) {
      deltaTime *= this.timeScale

      var actions = this._actions,
        nActions = this._nActiveActions,
        time = (this.time += deltaTime),
        timeDirection = Math.sign(deltaTime),
        accuIndex = (this._accuIndex ^= 1)

      // run active actions

      for (var i = 0; i !== nActions; ++i) {
        var action = actions[i]

        action._update(time, deltaTime, timeDirection, accuIndex)
      }

      // update scene graph

      var bindings = this._bindings,
        nBindings = this._nActiveBindings

      for (var i = 0; i !== nBindings; ++i) {
        bindings[i].apply(accuIndex)
      }

      return this
    },

    // return this mixer's root target object
    getRoot: function () {
      return this._root
    },

    // free all resources specific to a particular clip
    uncacheClip: function (clip) {
      var actions = this._actions,
        clipUuid = clip.uuid,
        actionsByClip = this._actionsByClip,
        actionsForClip = actionsByClip[clipUuid]

      if (actionsForClip !== undefined) {
        // note: just calling _removeInactiveAction would mess up the
        // iteration state and also require updating the state we can
        // just throw away

        var actionsToRemove = actionsForClip.knownActions

        for (var i = 0, n = actionsToRemove.length; i !== n; ++i) {
          var action = actionsToRemove[i]

          this._deactivateAction(action)

          var cacheIndex = action._cacheIndex,
            lastInactiveAction = actions[actions.length - 1]

          action._cacheIndex = null
          action._byClipCacheIndex = null

          lastInactiveAction._cacheIndex = cacheIndex
          actions[cacheIndex] = lastInactiveAction
          actions.pop()

          this._removeInactiveBindingsForAction(action)
        }

        delete actionsByClip[clipUuid]
      }
    },

    // free all resources specific to a particular root target object
    uncacheRoot: function (root) {
      var rootUuid = root.uuid,
        actionsByClip = this._actionsByClip

      for (var clipUuid in actionsByClip) {
        var actionByRoot = actionsByClip[clipUuid].actionByRoot,
          action = actionByRoot[rootUuid]

        if (action !== undefined) {
          this._deactivateAction(action)
          this._removeInactiveAction(action)
        }
      }

      var bindingsByRoot = this._bindingsByRootAndName,
        bindingByName = bindingsByRoot[rootUuid]

      if (bindingByName !== undefined) {
        for (var trackName in bindingByName) {
          var binding = bindingByName[trackName]
          binding.restoreOriginalState()
          this._removeInactiveBinding(binding)
        }
      }
    },

    // remove a targeted clip from the cache
    uncacheAction: function (clip, optionalRoot) {
      var action = this.existingAction(clip, optionalRoot)

      if (action !== null) {
        this._deactivateAction(action)
        this._removeInactiveAction(action)
      }
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function Uniform(value) {
    if (typeof value === 'string') {
      console.warn('THREE.Uniform: Type parameter is no longer needed.')
      value = arguments[1]
    }

    this.value = value
  }

  Uniform.prototype.clone = function () {
    return new Uniform(this.value.clone === undefined ? this.value : this.value.clone())
  }

  /**
   * @author benaadams / https://twitter.com/ben_a_adams
   */

  function InstancedBufferGeometry() {
    BufferGeometry.call(this)

    this.type = 'InstancedBufferGeometry'
    this.maxInstancedCount = undefined
  }

  InstancedBufferGeometry.prototype = Object.assign(Object.create(BufferGeometry.prototype), {
    constructor: InstancedBufferGeometry,

    isInstancedBufferGeometry: true,

    copy: function (source) {
      BufferGeometry.prototype.copy.call(this, source)

      this.maxInstancedCount = source.maxInstancedCount

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    }
  })

  /**
   * @author benaadams / https://twitter.com/ben_a_adams
   */

  function InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, normalized) {
    this.uuid = _Math.generateUUID()

    this.data = interleavedBuffer
    this.itemSize = itemSize
    this.offset = offset

    this.normalized = normalized === true
  }

  Object.defineProperties(InterleavedBufferAttribute.prototype, {
    count: {
      get: function () {
        return this.data.count
      }
    },

    array: {
      get: function () {
        return this.data.array
      }
    }
  })

  Object.assign(InterleavedBufferAttribute.prototype, {
    isInterleavedBufferAttribute: true,

    setX: function (index, x) {
      this.data.array[index * this.data.stride + this.offset] = x

      return this
    },

    setY: function (index, y) {
      this.data.array[index * this.data.stride + this.offset + 1] = y

      return this
    },

    setZ: function (index, z) {
      this.data.array[index * this.data.stride + this.offset + 2] = z

      return this
    },

    setW: function (index, w) {
      this.data.array[index * this.data.stride + this.offset + 3] = w

      return this
    },

    getX: function (index) {
      return this.data.array[index * this.data.stride + this.offset]
    },

    getY: function (index) {
      return this.data.array[index * this.data.stride + this.offset + 1]
    },

    getZ: function (index) {
      return this.data.array[index * this.data.stride + this.offset + 2]
    },

    getW: function (index) {
      return this.data.array[index * this.data.stride + this.offset + 3]
    },

    setXY: function (index, x, y) {
      index = index * this.data.stride + this.offset

      this.data.array[index + 0] = x
      this.data.array[index + 1] = y

      return this
    },

    setXYZ: function (index, x, y, z) {
      index = index * this.data.stride + this.offset

      this.data.array[index + 0] = x
      this.data.array[index + 1] = y
      this.data.array[index + 2] = z

      return this
    },

    setXYZW: function (index, x, y, z, w) {
      index = index * this.data.stride + this.offset

      this.data.array[index + 0] = x
      this.data.array[index + 1] = y
      this.data.array[index + 2] = z
      this.data.array[index + 3] = w

      return this
    }
  })

  /**
   * @author benaadams / https://twitter.com/ben_a_adams
   */

  function InterleavedBuffer(array, stride) {
    this.uuid = _Math.generateUUID()

    this.array = array
    this.stride = stride
    this.count = array !== undefined ? array.length / stride : 0

    this.dynamic = false
    this.updateRange = { offset: 0, count: -1 }

    this.onUploadCallback = function () {}

    this.version = 0
  }

  Object.defineProperty(InterleavedBuffer.prototype, 'needsUpdate', {
    set: function (value) {
      if (value === true) this.version++
    }
  })

  Object.assign(InterleavedBuffer.prototype, {
    isInterleavedBuffer: true,

    setArray: function (array) {
      if (Array.isArray(array)) {
        throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.')
      }

      this.count = array !== undefined ? array.length / this.stride : 0
      this.array = array
    },

    setDynamic: function (value) {
      this.dynamic = value

      return this
    },

    copy: function (source) {
      this.array = new source.array.constructor(source.array)
      this.count = source.count
      this.stride = source.stride
      this.dynamic = source.dynamic

      return this
    },

    copyAt: function (index1, attribute, index2) {
      index1 *= this.stride
      index2 *= attribute.stride

      for (var i = 0, l = this.stride; i < l; i++) {
        this.array[index1 + i] = attribute.array[index2 + i]
      }

      return this
    },

    set: function (value, offset) {
      if (offset === undefined) offset = 0

      this.array.set(value, offset)

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    onUpload: function (callback) {
      this.onUploadCallback = callback

      return this
    }
  })

  /**
   * @author benaadams / https://twitter.com/ben_a_adams
   */

  function InstancedInterleavedBuffer(array, stride, meshPerAttribute) {
    InterleavedBuffer.call(this, array, stride)

    this.meshPerAttribute = meshPerAttribute || 1
  }

  InstancedInterleavedBuffer.prototype = Object.assign(Object.create(InterleavedBuffer.prototype), {
    constructor: InstancedInterleavedBuffer,

    isInstancedInterleavedBuffer: true,

    copy: function (source) {
      InterleavedBuffer.prototype.copy.call(this, source)

      this.meshPerAttribute = source.meshPerAttribute

      return this
    }
  })

  /**
   * @author benaadams / https://twitter.com/ben_a_adams
   */

  function InstancedBufferAttribute(array, itemSize, meshPerAttribute) {
    BufferAttribute.call(this, array, itemSize)

    this.meshPerAttribute = meshPerAttribute || 1
  }

  InstancedBufferAttribute.prototype = Object.assign(Object.create(BufferAttribute.prototype), {
    constructor: InstancedBufferAttribute,

    isInstancedBufferAttribute: true,

    copy: function (source) {
      BufferAttribute.prototype.copy.call(this, source)

      this.meshPerAttribute = source.meshPerAttribute

      return this
    }
  })

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author bhouston / http://clara.io/
   * @author stephomi / http://stephaneginier.com/
   */

  function Raycaster(origin, direction, near, far) {
    this.ray = new Ray(origin, direction)
    // direction is assumed to be normalized (for accurate distance calculations)

    this.near = near || 0
    this.far = far || Infinity

    this.params = {
      Mesh: {},
      Line: {},
      LOD: {},
      Points: { threshold: 1 },
      Sprite: {}
    }

    Object.defineProperties(this.params, {
      PointCloud: {
        get: function () {
          console.warn('THREE.Raycaster: params.PointCloud has been renamed to params.Points.')
          return this.Points
        }
      }
    })
  }

  function ascSort(a, b) {
    return a.distance - b.distance
  }

  function intersectObject(object, raycaster, intersects, recursive) {
    if (object.visible === false) return

    object.raycast(raycaster, intersects)

    if (recursive === true) {
      var children = object.children

      for (var i = 0, l = children.length; i < l; i++) {
        intersectObject(children[i], raycaster, intersects, true)
      }
    }
  }

  Object.assign(Raycaster.prototype, {
    linePrecision: 1,

    set: function (origin, direction) {
      // direction is assumed to be normalized (for accurate distance calculations)

      this.ray.set(origin, direction)
    },

    setFromCamera: function (coords, camera) {
      if (camera && camera.isPerspectiveCamera) {
        this.ray.origin.setFromMatrixPosition(camera.matrixWorld)
        this.ray.direction
          .set(coords.x, coords.y, 0.5)
          .unproject(camera)
          .sub(this.ray.origin)
          .normalize()
      } else if (camera && camera.isOrthographicCamera) {
        this.ray.origin
          .set(coords.x, coords.y, (camera.near + camera.far) / (camera.near - camera.far))
          .unproject(camera) // set origin in plane of camera
        this.ray.direction.set(0, 0, -1).transformDirection(camera.matrixWorld)
      } else {
        console.error('THREE.Raycaster: Unsupported camera type.')
      }
    },

    intersectObject: function (object, recursive) {
      var intersects = []

      intersectObject(object, this, intersects, recursive)

      intersects.sort(ascSort)

      return intersects
    },

    intersectObjects: function (objects, recursive) {
      var intersects = []

      if (Array.isArray(objects) === false) {
        console.warn('THREE.Raycaster.intersectObjects: objects is not an Array.')
        return intersects
      }

      for (var i = 0, l = objects.length; i < l; i++) {
        intersectObject(objects[i], this, intersects, recursive)
      }

      intersects.sort(ascSort)

      return intersects
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function Clock(autoStart) {
    this.autoStart = autoStart !== undefined ? autoStart : true

    this.startTime = 0
    this.oldTime = 0
    this.elapsedTime = 0

    this.running = false
  }

  Object.assign(Clock.prototype, {
    start: function () {
      this.startTime = (typeof performance === 'undefined' ? Date : performance).now() // see #10732

      this.oldTime = this.startTime
      this.elapsedTime = 0
      this.running = true
    },

    stop: function () {
      this.getElapsedTime()
      this.running = false
      this.autoStart = false
    },

    getElapsedTime: function () {
      this.getDelta()
      return this.elapsedTime
    },

    getDelta: function () {
      var diff = 0

      if (this.autoStart && !this.running) {
        this.start()
        return 0
      }

      if (this.running) {
        var newTime = (typeof performance === 'undefined' ? Date : performance).now()

        diff = (newTime - this.oldTime) / 1000
        this.oldTime = newTime

        this.elapsedTime += diff
      }

      return diff
    }
  })

  /**
   * @author bhouston / http://clara.io
   * @author WestLangley / http://github.com/WestLangley
   *
   * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system
   *
   * The poles (phi) are at the positive and negative y axis.
   * The equator starts at positive z.
   */

  function Spherical(radius, phi, theta) {
    this.radius = radius !== undefined ? radius : 1.0
    this.phi = phi !== undefined ? phi : 0 // up / down towards top and bottom pole
    this.theta = theta !== undefined ? theta : 0 // around the equator of the sphere

    return this
  }

  Object.assign(Spherical.prototype, {
    set: function (radius, phi, theta) {
      this.radius = radius
      this.phi = phi
      this.theta = theta

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (other) {
      this.radius = other.radius
      this.phi = other.phi
      this.theta = other.theta

      return this
    },

    // restrict phi to be betwee EPS and PI-EPS
    makeSafe: function () {
      var EPS = 0.000001
      this.phi = Math.max(EPS, Math.min(Math.PI - EPS, this.phi))

      return this
    },

    setFromVector3: function (vec3) {
      this.radius = vec3.length()

      if (this.radius === 0) {
        this.theta = 0
        this.phi = 0
      } else {
        this.theta = Math.atan2(vec3.x, vec3.z) // equator angle around y-up axis
        this.phi = Math.acos(_Math.clamp(vec3.y / this.radius, -1, 1)) // polar angle
      }

      return this
    }
  })

  /**
   * @author Mugen87 / https://github.com/Mugen87
   *
   * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system
   *
   */

  function Cylindrical(radius, theta, y) {
    this.radius = radius !== undefined ? radius : 1.0 // distance from the origin to a point in the x-z plane
    this.theta = theta !== undefined ? theta : 0 // counterclockwise angle in the x-z plane measured in radians from the positive z-axis
    this.y = y !== undefined ? y : 0 // height above the x-z plane

    return this
  }

  Object.assign(Cylindrical.prototype, {
    set: function (radius, theta, y) {
      this.radius = radius
      this.theta = theta
      this.y = y

      return this
    },

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (other) {
      this.radius = other.radius
      this.theta = other.theta
      this.y = other.y

      return this
    },

    setFromVector3: function (vec3) {
      this.radius = Math.sqrt(vec3.x * vec3.x + vec3.z * vec3.z)
      this.theta = Math.atan2(vec3.x, vec3.z)
      this.y = vec3.y

      return this
    }
  })

  /**
   * @author bhouston / http://clara.io
   */

  function Box2(min, max) {
    this.min = min !== undefined ? min : new Vector2(+Infinity, +Infinity)
    this.max = max !== undefined ? max : new Vector2(-Infinity, -Infinity)
  }

  Object.assign(Box2.prototype, {
    set: function (min, max) {
      this.min.copy(min)
      this.max.copy(max)

      return this
    },

    setFromPoints: function (points) {
      this.makeEmpty()

      for (var i = 0, il = points.length; i < il; i++) {
        this.expandByPoint(points[i])
      }

      return this
    },

    setFromCenterAndSize: (function () {
      var v1 = new Vector2()

      return function setFromCenterAndSize(center, size) {
        var halfSize = v1.copy(size).multiplyScalar(0.5)
        this.min.copy(center).sub(halfSize)
        this.max.copy(center).add(halfSize)

        return this
      }
    })(),

    clone: function () {
      return new this.constructor().copy(this)
    },

    copy: function (box) {
      this.min.copy(box.min)
      this.max.copy(box.max)

      return this
    },

    makeEmpty: function () {
      this.min.x = this.min.y = +Infinity
      this.max.x = this.max.y = -Infinity

      return this
    },

    isEmpty: function () {
      // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes

      return this.max.x < this.min.x || this.max.y < this.min.y
    },

    getCenter: function (optionalTarget) {
      var result = optionalTarget || new Vector2()
      return this.isEmpty()
        ? result.set(0, 0)
        : result.addVectors(this.min, this.max).multiplyScalar(0.5)
    },

    getSize: function (optionalTarget) {
      var result = optionalTarget || new Vector2()
      return this.isEmpty() ? result.set(0, 0) : result.subVectors(this.max, this.min)
    },

    expandByPoint: function (point) {
      this.min.min(point)
      this.max.max(point)

      return this
    },

    expandByVector: function (vector) {
      this.min.sub(vector)
      this.max.add(vector)

      return this
    },

    expandByScalar: function (scalar) {
      this.min.addScalar(-scalar)
      this.max.addScalar(scalar)

      return this
    },

    containsPoint: function (point) {
      return point.x < this.min.x ||
        point.x > this.max.x ||
        point.y < this.min.y ||
        point.y > this.max.y
        ? false
        : true
    },

    containsBox: function (box) {
      return (
        this.min.x <= box.min.x &&
        box.max.x <= this.max.x &&
        this.min.y <= box.min.y &&
        box.max.y <= this.max.y
      )
    },

    getParameter: function (point, optionalTarget) {
      // This can potentially have a divide by zero if the box
      // has a size dimension of 0.

      var result = optionalTarget || new Vector2()

      return result.set(
        (point.x - this.min.x) / (this.max.x - this.min.x),
        (point.y - this.min.y) / (this.max.y - this.min.y)
      )
    },

    intersectsBox: function (box) {
      // using 4 splitting planes to rule out intersections

      return box.max.x < this.min.x ||
        box.min.x > this.max.x ||
        box.max.y < this.min.y ||
        box.min.y > this.max.y
        ? false
        : true
    },

    clampPoint: function (point, optionalTarget) {
      var result = optionalTarget || new Vector2()
      return result.copy(point).clamp(this.min, this.max)
    },

    distanceToPoint: (function () {
      var v1 = new Vector2()

      return function distanceToPoint(point) {
        var clampedPoint = v1.copy(point).clamp(this.min, this.max)
        return clampedPoint.sub(point).length()
      }
    })(),

    intersect: function (box) {
      this.min.max(box.min)
      this.max.min(box.max)

      return this
    },

    union: function (box) {
      this.min.min(box.min)
      this.max.max(box.max)

      return this
    },

    translate: function (offset) {
      this.min.add(offset)
      this.max.add(offset)

      return this
    },

    equals: function (box) {
      return box.min.equals(this.min) && box.max.equals(this.max)
    }
  })

  /**
   * @author alteredq / http://alteredqualia.com/
   */

  function ImmediateRenderObject(material) {
    Object3D.call(this)

    this.material = material
    this.render = function (/* renderCallback */) {}
  }

  ImmediateRenderObject.prototype = Object.create(Object3D.prototype)
  ImmediateRenderObject.prototype.constructor = ImmediateRenderObject

  ImmediateRenderObject.prototype.isImmediateRenderObject = true

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author WestLangley / http://github.com/WestLangley
   */

  function VertexNormalsHelper(object, size, hex, linewidth) {
    this.object = object

    this.size = size !== undefined ? size : 1

    var color = hex !== undefined ? hex : 0xff0000

    var width = linewidth !== undefined ? linewidth : 1

    //

    var nNormals = 0

    var objGeometry = this.object.geometry

    if (objGeometry && objGeometry.isGeometry) {
      nNormals = objGeometry.faces.length * 3
    } else if (objGeometry && objGeometry.isBufferGeometry) {
      nNormals = objGeometry.attributes.normal.count
    }

    //

    var geometry = new BufferGeometry()

    var positions = new Float32BufferAttribute(nNormals * 2 * 3, 3)

    geometry.addAttribute('position', positions)

    LineSegments.call(this, geometry, new LineBasicMaterial({ color: color, linewidth: width }))

    //

    this.matrixAutoUpdate = false

    this.update()
  }

  VertexNormalsHelper.prototype = Object.create(LineSegments.prototype)
  VertexNormalsHelper.prototype.constructor = VertexNormalsHelper

  VertexNormalsHelper.prototype.update = (function () {
    var v1 = new Vector3()
    var v2 = new Vector3()
    var normalMatrix = new Matrix3()

    return function update() {
      var keys = ['a', 'b', 'c']

      this.object.updateMatrixWorld(true)

      normalMatrix.getNormalMatrix(this.object.matrixWorld)

      var matrixWorld = this.object.matrixWorld

      var position = this.geometry.attributes.position

      //

      var objGeometry = this.object.geometry

      if (objGeometry && objGeometry.isGeometry) {
        var vertices = objGeometry.vertices

        var faces = objGeometry.faces

        var idx = 0

        for (var i = 0, l = faces.length; i < l; i++) {
          var face = faces[i]

          for (var j = 0, jl = face.vertexNormals.length; j < jl; j++) {
            var vertex = vertices[face[keys[j]]]

            var normal = face.vertexNormals[j]

            v1.copy(vertex).applyMatrix4(matrixWorld)

            v2.copy(normal).applyMatrix3(normalMatrix).normalize().multiplyScalar(this.size).add(v1)

            position.setXYZ(idx, v1.x, v1.y, v1.z)

            idx = idx + 1

            position.setXYZ(idx, v2.x, v2.y, v2.z)

            idx = idx + 1
          }
        }
      } else if (objGeometry && objGeometry.isBufferGeometry) {
        var objPos = objGeometry.attributes.position

        var objNorm = objGeometry.attributes.normal

        var idx = 0

        // for simplicity, ignore index and drawcalls, and render every normal

        for (var j = 0, jl = objPos.count; j < jl; j++) {
          v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld)

          v2.set(objNorm.getX(j), objNorm.getY(j), objNorm.getZ(j))

          v2.applyMatrix3(normalMatrix).normalize().multiplyScalar(this.size).add(v1)

          position.setXYZ(idx, v1.x, v1.y, v1.z)

          idx = idx + 1

          position.setXYZ(idx, v2.x, v2.y, v2.z)

          idx = idx + 1
        }
      }

      position.needsUpdate = true
    }
  })()

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   * @author WestLangley / http://github.com/WestLangley
   */

  function SpotLightHelper(light, color) {
    Object3D.call(this)

    this.light = light
    this.light.updateMatrixWorld()

    this.matrix = light.matrixWorld
    this.matrixAutoUpdate = false

    this.color = color

    var geometry = new BufferGeometry()

    var positions = [
      0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, -1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, 1
    ]

    for (var i = 0, j = 1, l = 32; i < l; i++, j++) {
      var p1 = (i / l) * Math.PI * 2
      var p2 = (j / l) * Math.PI * 2

      positions.push(Math.cos(p1), Math.sin(p1), 1, Math.cos(p2), Math.sin(p2), 1)
    }

    geometry.addAttribute('position', new Float32BufferAttribute(positions, 3))

    var material = new LineBasicMaterial({ fog: false })

    this.cone = new LineSegments(geometry, material)
    this.add(this.cone)

    this.update()
  }

  SpotLightHelper.prototype = Object.create(Object3D.prototype)
  SpotLightHelper.prototype.constructor = SpotLightHelper

  SpotLightHelper.prototype.dispose = function () {
    this.cone.geometry.dispose()
    this.cone.material.dispose()
  }

  SpotLightHelper.prototype.update = (function () {
    var vector = new Vector3()
    var vector2 = new Vector3()

    return function update() {
      this.light.updateMatrixWorld()

      var coneLength = this.light.distance ? this.light.distance : 1000
      var coneWidth = coneLength * Math.tan(this.light.angle)

      this.cone.scale.set(coneWidth, coneWidth, coneLength)

      vector.setFromMatrixPosition(this.light.matrixWorld)
      vector2.setFromMatrixPosition(this.light.target.matrixWorld)

      this.cone.lookAt(vector2.sub(vector))

      if (this.color !== undefined) {
        this.cone.material.color.set(this.color)
      } else {
        this.cone.material.color.copy(this.light.color)
      }
    }
  })()

  /**
   * @author Sean Griffin / http://twitter.com/sgrif
   * @author Michael Guerrero / http://realitymeltdown.com
   * @author mrdoob / http://mrdoob.com/
   * @author ikerr / http://verold.com
   * @author Mugen87 / https://github.com/Mugen87
   */

  function getBoneList(object) {
    var boneList = []

    if (object && object.isBone) {
      boneList.push(object)
    }

    for (var i = 0; i < object.children.length; i++) {
      boneList.push.apply(boneList, getBoneList(object.children[i]))
    }

    return boneList
  }

  function SkeletonHelper(object) {
    var bones = getBoneList(object)

    var geometry = new BufferGeometry()

    var vertices = []
    var colors = []

    var color1 = new Color(0, 0, 1)
    var color2 = new Color(0, 1, 0)

    for (var i = 0; i < bones.length; i++) {
      var bone = bones[i]

      if (bone.parent && bone.parent.isBone) {
        vertices.push(0, 0, 0)
        vertices.push(0, 0, 0)
        colors.push(color1.r, color1.g, color1.b)
        colors.push(color2.r, color2.g, color2.b)
      }
    }

    geometry.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    geometry.addAttribute('color', new Float32BufferAttribute(colors, 3))

    var material = new LineBasicMaterial({
      vertexColors: VertexColors,
      depthTest: false,
      depthWrite: false,
      transparent: true
    })

    LineSegments.call(this, geometry, material)

    this.root = object
    this.bones = bones

    this.matrix = object.matrixWorld
    this.matrixAutoUpdate = false
  }

  SkeletonHelper.prototype = Object.create(LineSegments.prototype)
  SkeletonHelper.prototype.constructor = SkeletonHelper

  SkeletonHelper.prototype.updateMatrixWorld = (function () {
    var vector = new Vector3()

    var boneMatrix = new Matrix4()
    var matrixWorldInv = new Matrix4()

    return function updateMatrixWorld(force) {
      var bones = this.bones

      var geometry = this.geometry
      var position = geometry.getAttribute('position')

      matrixWorldInv.getInverse(this.root.matrixWorld)

      for (var i = 0, j = 0; i < bones.length; i++) {
        var bone = bones[i]

        if (bone.parent && bone.parent.isBone) {
          boneMatrix.multiplyMatrices(matrixWorldInv, bone.matrixWorld)
          vector.setFromMatrixPosition(boneMatrix)
          position.setXYZ(j, vector.x, vector.y, vector.z)

          boneMatrix.multiplyMatrices(matrixWorldInv, bone.parent.matrixWorld)
          vector.setFromMatrixPosition(boneMatrix)
          position.setXYZ(j + 1, vector.x, vector.y, vector.z)

          j += 2
        }
      }

      geometry.getAttribute('position').needsUpdate = true

      Object3D.prototype.updateMatrixWorld.call(this, force)
    }
  })()

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   */

  function PointLightHelper(light, sphereSize, color) {
    this.light = light
    this.light.updateMatrixWorld()

    this.color = color

    var geometry = new SphereBufferGeometry(sphereSize, 4, 2)
    var material = new MeshBasicMaterial({ wireframe: true, fog: false })

    Mesh.call(this, geometry, material)

    this.matrix = this.light.matrixWorld
    this.matrixAutoUpdate = false

    this.update()

    /*
		var distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );
		var distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );

		this.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );
		this.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );

		var d = light.distance;

		if ( d === 0.0 ) {

			this.lightDistance.visible = false;

		} else {

			this.lightDistance.scale.set( d, d, d );

		}

		this.add( this.lightDistance );
		*/
  }

  PointLightHelper.prototype = Object.create(Mesh.prototype)
  PointLightHelper.prototype.constructor = PointLightHelper

  PointLightHelper.prototype.dispose = function () {
    this.geometry.dispose()
    this.material.dispose()
  }

  PointLightHelper.prototype.update = function () {
    if (this.color !== undefined) {
      this.material.color.set(this.color)
    } else {
      this.material.color.copy(this.light.color)
    }

    /*
		var d = this.light.distance;

		if ( d === 0.0 ) {

			this.lightDistance.visible = false;

		} else {

			this.lightDistance.visible = true;
			this.lightDistance.scale.set( d, d, d );

		}
		*/
  }

  /**
   * @author abelnation / http://github.com/abelnation
   * @author Mugen87 / http://github.com/Mugen87
   * @author WestLangley / http://github.com/WestLangley
   */

  function RectAreaLightHelper(light, color) {
    Object3D.call(this)

    this.light = light
    this.light.updateMatrixWorld()

    this.matrix = light.matrixWorld
    this.matrixAutoUpdate = false

    this.color = color

    var material = new LineBasicMaterial({ fog: false })

    var geometry = new BufferGeometry()

    geometry.addAttribute('position', new BufferAttribute(new Float32Array(5 * 3), 3))

    this.line = new Line(geometry, material)
    this.add(this.line)

    this.update()
  }

  RectAreaLightHelper.prototype = Object.create(Object3D.prototype)
  RectAreaLightHelper.prototype.constructor = RectAreaLightHelper

  RectAreaLightHelper.prototype.dispose = function () {
    this.children[0].geometry.dispose()
    this.children[0].material.dispose()
  }

  RectAreaLightHelper.prototype.update = function () {
    // calculate new dimensions of the helper

    var hx = this.light.width * 0.5
    var hy = this.light.height * 0.5

    var position = this.line.geometry.attributes.position
    var array = position.array

    // update vertices

    array[0] = hx
    array[1] = -hy
    array[2] = 0
    array[3] = hx
    array[4] = hy
    array[5] = 0
    array[6] = -hx
    array[7] = hy
    array[8] = 0
    array[9] = -hx
    array[10] = -hy
    array[11] = 0
    array[12] = hx
    array[13] = -hy
    array[14] = 0

    position.needsUpdate = true

    if (this.color !== undefined) {
      this.line.material.color.set(this.color)
    } else {
      this.line.material.color.copy(this.light.color)
    }
  }

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / https://github.com/Mugen87
   */

  function HemisphereLightHelper(light, size, color) {
    Object3D.call(this)

    this.light = light
    this.light.updateMatrixWorld()

    this.matrix = light.matrixWorld
    this.matrixAutoUpdate = false

    this.color = color

    var geometry = new OctahedronBufferGeometry(size)
    geometry.rotateY(Math.PI * 0.5)

    this.material = new MeshBasicMaterial({ wireframe: true, fog: false })
    if (this.color === undefined) this.material.vertexColors = VertexColors

    var position = geometry.getAttribute('position')
    var colors = new Float32Array(position.count * 3)

    geometry.addAttribute('color', new BufferAttribute(colors, 3))

    this.add(new Mesh(geometry, this.material))

    this.update()
  }

  HemisphereLightHelper.prototype = Object.create(Object3D.prototype)
  HemisphereLightHelper.prototype.constructor = HemisphereLightHelper

  HemisphereLightHelper.prototype.dispose = function () {
    this.children[0].geometry.dispose()
    this.children[0].material.dispose()
  }

  HemisphereLightHelper.prototype.update = (function () {
    var vector = new Vector3()

    var color1 = new Color()
    var color2 = new Color()

    return function update() {
      var mesh = this.children[0]

      if (this.color !== undefined) {
        this.material.color.set(this.color)
      } else {
        var colors = mesh.geometry.getAttribute('color')

        color1.copy(this.light.color)
        color2.copy(this.light.groundColor)

        for (var i = 0, l = colors.count; i < l; i++) {
          var color = i < l / 2 ? color1 : color2

          colors.setXYZ(i, color.r, color.g, color.b)
        }

        colors.needsUpdate = true
      }

      mesh.lookAt(vector.setFromMatrixPosition(this.light.matrixWorld).negate())
    }
  })()

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function GridHelper(size, divisions, color1, color2) {
    size = size || 10
    divisions = divisions || 10
    color1 = new Color(color1 !== undefined ? color1 : 0x444444)
    color2 = new Color(color2 !== undefined ? color2 : 0x888888)

    var center = divisions / 2
    var step = size / divisions
    var halfSize = size / 2

    var vertices = [],
      colors = []

    for (var i = 0, j = 0, k = -halfSize; i <= divisions; i++, k += step) {
      vertices.push(-halfSize, 0, k, halfSize, 0, k)
      vertices.push(k, 0, -halfSize, k, 0, halfSize)

      var color = i === center ? color1 : color2

      color.toArray(colors, j)
      j += 3
      color.toArray(colors, j)
      j += 3
      color.toArray(colors, j)
      j += 3
      color.toArray(colors, j)
      j += 3
    }

    var geometry = new BufferGeometry()
    geometry.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    geometry.addAttribute('color', new Float32BufferAttribute(colors, 3))

    var material = new LineBasicMaterial({ vertexColors: VertexColors })

    LineSegments.call(this, geometry, material)
  }

  GridHelper.prototype = Object.create(LineSegments.prototype)
  GridHelper.prototype.constructor = GridHelper

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / http://github.com/Mugen87
   * @author Hectate / http://www.github.com/Hectate
   */

  function PolarGridHelper(radius, radials, circles, divisions, color1, color2) {
    radius = radius || 10
    radials = radials || 16
    circles = circles || 8
    divisions = divisions || 64
    color1 = new Color(color1 !== undefined ? color1 : 0x444444)
    color2 = new Color(color2 !== undefined ? color2 : 0x888888)

    var vertices = []
    var colors = []

    var x, z
    var v, i, j, r, color

    // create the radials

    for (i = 0; i <= radials; i++) {
      v = (i / radials) * (Math.PI * 2)

      x = Math.sin(v) * radius
      z = Math.cos(v) * radius

      vertices.push(0, 0, 0)
      vertices.push(x, 0, z)

      color = i & 1 ? color1 : color2

      colors.push(color.r, color.g, color.b)
      colors.push(color.r, color.g, color.b)
    }

    // create the circles

    for (i = 0; i <= circles; i++) {
      color = i & 1 ? color1 : color2

      r = radius - (radius / circles) * i

      for (j = 0; j < divisions; j++) {
        // first vertex

        v = (j / divisions) * (Math.PI * 2)

        x = Math.sin(v) * r
        z = Math.cos(v) * r

        vertices.push(x, 0, z)
        colors.push(color.r, color.g, color.b)

        // second vertex

        v = ((j + 1) / divisions) * (Math.PI * 2)

        x = Math.sin(v) * r
        z = Math.cos(v) * r

        vertices.push(x, 0, z)
        colors.push(color.r, color.g, color.b)
      }
    }

    var geometry = new BufferGeometry()
    geometry.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    geometry.addAttribute('color', new Float32BufferAttribute(colors, 3))

    var material = new LineBasicMaterial({ vertexColors: VertexColors })

    LineSegments.call(this, geometry, material)
  }

  PolarGridHelper.prototype = Object.create(LineSegments.prototype)
  PolarGridHelper.prototype.constructor = PolarGridHelper

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author WestLangley / http://github.com/WestLangley
   */

  function FaceNormalsHelper(object, size, hex, linewidth) {
    // FaceNormalsHelper only supports THREE.Geometry

    this.object = object

    this.size = size !== undefined ? size : 1

    var color = hex !== undefined ? hex : 0xffff00

    var width = linewidth !== undefined ? linewidth : 1

    //

    var nNormals = 0

    var objGeometry = this.object.geometry

    if (objGeometry && objGeometry.isGeometry) {
      nNormals = objGeometry.faces.length
    } else {
      console.warn(
        'THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.'
      )
    }

    //

    var geometry = new BufferGeometry()

    var positions = new Float32BufferAttribute(nNormals * 2 * 3, 3)

    geometry.addAttribute('position', positions)

    LineSegments.call(this, geometry, new LineBasicMaterial({ color: color, linewidth: width }))

    //

    this.matrixAutoUpdate = false
    this.update()
  }

  FaceNormalsHelper.prototype = Object.create(LineSegments.prototype)
  FaceNormalsHelper.prototype.constructor = FaceNormalsHelper

  FaceNormalsHelper.prototype.update = (function () {
    var v1 = new Vector3()
    var v2 = new Vector3()
    var normalMatrix = new Matrix3()

    return function update() {
      this.object.updateMatrixWorld(true)

      normalMatrix.getNormalMatrix(this.object.matrixWorld)

      var matrixWorld = this.object.matrixWorld

      var position = this.geometry.attributes.position

      //

      var objGeometry = this.object.geometry

      var vertices = objGeometry.vertices

      var faces = objGeometry.faces

      var idx = 0

      for (var i = 0, l = faces.length; i < l; i++) {
        var face = faces[i]

        var normal = face.normal

        v1.copy(vertices[face.a])
          .add(vertices[face.b])
          .add(vertices[face.c])
          .divideScalar(3)
          .applyMatrix4(matrixWorld)

        v2.copy(normal).applyMatrix3(normalMatrix).normalize().multiplyScalar(this.size).add(v1)

        position.setXYZ(idx, v1.x, v1.y, v1.z)

        idx = idx + 1

        position.setXYZ(idx, v2.x, v2.y, v2.z)

        idx = idx + 1
      }

      position.needsUpdate = true
    }
  })()

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author mrdoob / http://mrdoob.com/
   * @author WestLangley / http://github.com/WestLangley
   */

  function DirectionalLightHelper(light, size, color) {
    Object3D.call(this)

    this.light = light
    this.light.updateMatrixWorld()

    this.matrix = light.matrixWorld
    this.matrixAutoUpdate = false

    this.color = color

    if (size === undefined) size = 1

    var geometry = new BufferGeometry()
    geometry.addAttribute(
      'position',
      new Float32BufferAttribute(
        [-size, size, 0, size, size, 0, size, -size, 0, -size, -size, 0, -size, size, 0],
        3
      )
    )

    var material = new LineBasicMaterial({ fog: false })

    this.lightPlane = new Line(geometry, material)
    this.add(this.lightPlane)

    geometry = new BufferGeometry()
    geometry.addAttribute('position', new Float32BufferAttribute([0, 0, 0, 0, 0, 1], 3))

    this.targetLine = new Line(geometry, material)
    this.add(this.targetLine)

    this.update()
  }

  DirectionalLightHelper.prototype = Object.create(Object3D.prototype)
  DirectionalLightHelper.prototype.constructor = DirectionalLightHelper

  DirectionalLightHelper.prototype.dispose = function () {
    this.lightPlane.geometry.dispose()
    this.lightPlane.material.dispose()
    this.targetLine.geometry.dispose()
    this.targetLine.material.dispose()
  }

  DirectionalLightHelper.prototype.update = (function () {
    var v1 = new Vector3()
    var v2 = new Vector3()
    var v3 = new Vector3()

    return function update() {
      v1.setFromMatrixPosition(this.light.matrixWorld)
      v2.setFromMatrixPosition(this.light.target.matrixWorld)
      v3.subVectors(v2, v1)

      this.lightPlane.lookAt(v3)

      if (this.color !== undefined) {
        this.lightPlane.material.color.set(this.color)
        this.targetLine.material.color.set(this.color)
      } else {
        this.lightPlane.material.color.copy(this.light.color)
        this.targetLine.material.color.copy(this.light.color)
      }

      this.targetLine.lookAt(v3)
      this.targetLine.scale.z = v3.length()
    }
  })()

  /**
   * @author alteredq / http://alteredqualia.com/
   * @author Mugen87 / https://github.com/Mugen87
   *
   *	- shows frustum, line of sight and up of the camera
   *	- suitable for fast updates
   * 	- based on frustum visualization in lightgl.js shadowmap example
   *		http://evanw.github.com/lightgl.js/tests/shadowmap.html
   */

  function CameraHelper(camera) {
    var geometry = new BufferGeometry()
    var material = new LineBasicMaterial({ color: 0xffffff, vertexColors: FaceColors })

    var vertices = []
    var colors = []

    var pointMap = {}

    // colors

    var colorFrustum = new Color(0xffaa00)
    var colorCone = new Color(0xff0000)
    var colorUp = new Color(0x00aaff)
    var colorTarget = new Color(0xffffff)
    var colorCross = new Color(0x333333)

    // near

    addLine('n1', 'n2', colorFrustum)
    addLine('n2', 'n4', colorFrustum)
    addLine('n4', 'n3', colorFrustum)
    addLine('n3', 'n1', colorFrustum)

    // far

    addLine('f1', 'f2', colorFrustum)
    addLine('f2', 'f4', colorFrustum)
    addLine('f4', 'f3', colorFrustum)
    addLine('f3', 'f1', colorFrustum)

    // sides

    addLine('n1', 'f1', colorFrustum)
    addLine('n2', 'f2', colorFrustum)
    addLine('n3', 'f3', colorFrustum)
    addLine('n4', 'f4', colorFrustum)

    // cone

    addLine('p', 'n1', colorCone)
    addLine('p', 'n2', colorCone)
    addLine('p', 'n3', colorCone)
    addLine('p', 'n4', colorCone)

    // up

    addLine('u1', 'u2', colorUp)
    addLine('u2', 'u3', colorUp)
    addLine('u3', 'u1', colorUp)

    // target

    addLine('c', 't', colorTarget)
    addLine('p', 'c', colorCross)

    // cross

    addLine('cn1', 'cn2', colorCross)
    addLine('cn3', 'cn4', colorCross)

    addLine('cf1', 'cf2', colorCross)
    addLine('cf3', 'cf4', colorCross)

    function addLine(a, b, color) {
      addPoint(a, color)
      addPoint(b, color)
    }

    function addPoint(id, color) {
      vertices.push(0, 0, 0)
      colors.push(color.r, color.g, color.b)

      if (pointMap[id] === undefined) {
        pointMap[id] = []
      }

      pointMap[id].push(vertices.length / 3 - 1)
    }

    geometry.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    geometry.addAttribute('color', new Float32BufferAttribute(colors, 3))

    LineSegments.call(this, geometry, material)

    this.camera = camera
    if (this.camera.updateProjectionMatrix) this.camera.updateProjectionMatrix()

    this.matrix = camera.matrixWorld
    this.matrixAutoUpdate = false

    this.pointMap = pointMap

    this.update()
  }

  CameraHelper.prototype = Object.create(LineSegments.prototype)
  CameraHelper.prototype.constructor = CameraHelper

  CameraHelper.prototype.update = (function () {
    var geometry, pointMap

    var vector = new Vector3()
    var camera = new Camera()

    function setPoint(point, x, y, z) {
      vector.set(x, y, z).unproject(camera)

      var points = pointMap[point]

      if (points !== undefined) {
        var position = geometry.getAttribute('position')

        for (var i = 0, l = points.length; i < l; i++) {
          position.setXYZ(points[i], vector.x, vector.y, vector.z)
        }
      }
    }

    return function update() {
      geometry = this.geometry
      pointMap = this.pointMap

      var w = 1,
        h = 1

      // we need just camera projection matrix
      // world matrix must be identity

      camera.projectionMatrix.copy(this.camera.projectionMatrix)

      // center / target

      setPoint('c', 0, 0, -1)
      setPoint('t', 0, 0, 1)

      // near

      setPoint('n1', -w, -h, -1)
      setPoint('n2', w, -h, -1)
      setPoint('n3', -w, h, -1)
      setPoint('n4', w, h, -1)

      // far

      setPoint('f1', -w, -h, 1)
      setPoint('f2', w, -h, 1)
      setPoint('f3', -w, h, 1)
      setPoint('f4', w, h, 1)

      // up

      setPoint('u1', w * 0.7, h * 1.1, -1)
      setPoint('u2', -w * 0.7, h * 1.1, -1)
      setPoint('u3', 0, h * 2, -1)

      // cross

      setPoint('cf1', -w, 0, 1)
      setPoint('cf2', w, 0, 1)
      setPoint('cf3', 0, -h, 1)
      setPoint('cf4', 0, h, 1)

      setPoint('cn1', -w, 0, -1)
      setPoint('cn2', w, 0, -1)
      setPoint('cn3', 0, -h, -1)
      setPoint('cn4', 0, h, -1)

      geometry.getAttribute('position').needsUpdate = true
    }
  })()

  /**
   * @author mrdoob / http://mrdoob.com/
   * @author Mugen87 / http://github.com/Mugen87
   */

  function BoxHelper(object, color) {
    this.object = object

    if (color === undefined) color = 0xffff00

    var indices = new Uint16Array([
      0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7
    ])
    var positions = new Float32Array(8 * 3)

    var geometry = new BufferGeometry()
    geometry.setIndex(new BufferAttribute(indices, 1))
    geometry.addAttribute('position', new BufferAttribute(positions, 3))

    LineSegments.call(this, geometry, new LineBasicMaterial({ color: color }))

    this.matrixAutoUpdate = false

    this.update()
  }

  BoxHelper.prototype = Object.create(LineSegments.prototype)
  BoxHelper.prototype.constructor = BoxHelper

  BoxHelper.prototype.update = (function () {
    var box = new Box3()

    return function update(object) {
      if (object !== undefined) {
        console.warn('THREE.BoxHelper: .update() has no longer arguments.')
      }

      if (this.object !== undefined) {
        box.setFromObject(this.object)
      }

      if (box.isEmpty()) return

      var min = box.min
      var max = box.max

      /*
			  5____4
			1/___0/|
			| 6__|_7
			2/___3/

			0: max.x, max.y, max.z
			1: min.x, max.y, max.z
			2: min.x, min.y, max.z
			3: max.x, min.y, max.z
			4: max.x, max.y, min.z
			5: min.x, max.y, min.z
			6: min.x, min.y, min.z
			7: max.x, min.y, min.z
			*/

      var position = this.geometry.attributes.position
      var array = position.array

      array[0] = max.x
      array[1] = max.y
      array[2] = max.z
      array[3] = min.x
      array[4] = max.y
      array[5] = max.z
      array[6] = min.x
      array[7] = min.y
      array[8] = max.z
      array[9] = max.x
      array[10] = min.y
      array[11] = max.z
      array[12] = max.x
      array[13] = max.y
      array[14] = min.z
      array[15] = min.x
      array[16] = max.y
      array[17] = min.z
      array[18] = min.x
      array[19] = min.y
      array[20] = min.z
      array[21] = max.x
      array[22] = min.y
      array[23] = min.z

      position.needsUpdate = true

      this.geometry.computeBoundingSphere()
    }
  })()

  BoxHelper.prototype.setFromObject = function (object) {
    this.object = object
    this.update()

    return this
  }

  /**
   * @author WestLangley / http://github.com/WestLangley
   */

  function Box3Helper(box, hex) {
    this.type = 'Box3Helper'

    this.box = box

    var color = hex !== undefined ? hex : 0xffff00

    var indices = new Uint16Array([
      0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7
    ])

    var positions = [
      1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1
    ]

    var geometry = new BufferGeometry()

    geometry.setIndex(new BufferAttribute(indices, 1))

    geometry.addAttribute('position', new Float32BufferAttribute(positions, 3))

    LineSegments.call(this, geometry, new LineBasicMaterial({ color: color }))

    this.geometry.computeBoundingSphere()
  }

  Box3Helper.prototype = Object.create(LineSegments.prototype)
  Box3Helper.prototype.constructor = Box3Helper

  Box3Helper.prototype.updateMatrixWorld = function (force) {
    var box = this.box

    if (box.isEmpty()) return

    box.getCenter(this.position)

    box.getSize(this.scale)

    this.scale.multiplyScalar(0.5)

    Object3D.prototype.updateMatrixWorld.call(this, force)
  }

  /**
   * @author WestLangley / http://github.com/WestLangley
   */

  function PlaneHelper(plane, size, hex) {
    this.type = 'PlaneHelper'

    this.plane = plane

    this.size = size === undefined ? 1 : size

    var color = hex !== undefined ? hex : 0xffff00

    var positions = [
      1, -1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 0, 0, 1, 0, 0,
      0
    ]

    var geometry = new BufferGeometry()
    geometry.addAttribute('position', new Float32BufferAttribute(positions, 3))
    geometry.computeBoundingSphere()

    Line.call(this, geometry, new LineBasicMaterial({ color: color }))

    //

    var positions2 = [1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1]

    var geometry2 = new BufferGeometry()
    geometry2.addAttribute('position', new Float32BufferAttribute(positions2, 3))
    geometry2.computeBoundingSphere()

    this.add(
      new Mesh(
        geometry2,
        new MeshBasicMaterial({ color: color, opacity: 0.2, transparent: true, depthWrite: false })
      )
    )
  }

  PlaneHelper.prototype = Object.create(Line.prototype)
  PlaneHelper.prototype.constructor = PlaneHelper

  PlaneHelper.prototype.updateMatrixWorld = function (force) {
    var scale = -this.plane.constant

    if (Math.abs(scale) < 1e-8) scale = 1e-8 // sign does not matter

    this.scale.set(0.5 * this.size, 0.5 * this.size, scale)

    this.lookAt(this.plane.normal)

    Object3D.prototype.updateMatrixWorld.call(this, force)
  }

  /**
   * @author WestLangley / http://github.com/WestLangley
   * @author zz85 / http://github.com/zz85
   * @author bhouston / http://clara.io
   *
   * Creates an arrow for visualizing directions
   *
   * Parameters:
   *  dir - Vector3
   *  origin - Vector3
   *  length - Number
   *  color - color in hex value
   *  headLength - Number
   *  headWidth - Number
   */

  var lineGeometry
  var coneGeometry

  function ArrowHelper(dir, origin, length, color, headLength, headWidth) {
    // dir is assumed to be normalized

    Object3D.call(this)

    if (color === undefined) color = 0xffff00
    if (length === undefined) length = 1
    if (headLength === undefined) headLength = 0.2 * length
    if (headWidth === undefined) headWidth = 0.2 * headLength

    if (lineGeometry === undefined) {
      lineGeometry = new BufferGeometry()
      lineGeometry.addAttribute('position', new Float32BufferAttribute([0, 0, 0, 0, 1, 0], 3))

      coneGeometry = new CylinderBufferGeometry(0, 0.5, 1, 5, 1)
      coneGeometry.translate(0, -0.5, 0)
    }

    this.position.copy(origin)

    this.line = new Line(lineGeometry, new LineBasicMaterial({ color: color }))
    this.line.matrixAutoUpdate = false
    this.add(this.line)

    this.cone = new Mesh(coneGeometry, new MeshBasicMaterial({ color: color }))
    this.cone.matrixAutoUpdate = false
    this.add(this.cone)

    this.setDirection(dir)
    this.setLength(length, headLength, headWidth)
  }

  ArrowHelper.prototype = Object.create(Object3D.prototype)
  ArrowHelper.prototype.constructor = ArrowHelper

  ArrowHelper.prototype.setDirection = (function () {
    var axis = new Vector3()
    var radians

    return function setDirection(dir) {
      // dir is assumed to be normalized

      if (dir.y > 0.99999) {
        this.quaternion.set(0, 0, 0, 1)
      } else if (dir.y < -0.99999) {
        this.quaternion.set(1, 0, 0, 0)
      } else {
        axis.set(dir.z, 0, -dir.x).normalize()

        radians = Math.acos(dir.y)

        this.quaternion.setFromAxisAngle(axis, radians)
      }
    }
  })()

  ArrowHelper.prototype.setLength = function (length, headLength, headWidth) {
    if (headLength === undefined) headLength = 0.2 * length
    if (headWidth === undefined) headWidth = 0.2 * headLength

    this.line.scale.set(1, Math.max(0, length - headLength), 1)
    this.line.updateMatrix()

    this.cone.scale.set(headWidth, headLength, headWidth)
    this.cone.position.y = length
    this.cone.updateMatrix()
  }

  ArrowHelper.prototype.setColor = function (color) {
    this.line.material.color.copy(color)
    this.cone.material.color.copy(color)
  }

  /**
   * @author sroucheray / http://sroucheray.org/
   * @author mrdoob / http://mrdoob.com/
   */

  function AxesHelper(size) {
    size = size || 1

    var vertices = [0, 0, 0, size, 0, 0, 0, 0, 0, 0, size, 0, 0, 0, 0, 0, 0, size]

    var colors = [1, 0, 0, 1, 0.6, 0, 0, 1, 0, 0.6, 1, 0, 0, 0, 1, 0, 0.6, 1]

    var geometry = new BufferGeometry()
    geometry.addAttribute('position', new Float32BufferAttribute(vertices, 3))
    geometry.addAttribute('color', new Float32BufferAttribute(colors, 3))

    var material = new LineBasicMaterial({ vertexColors: VertexColors })

    LineSegments.call(this, geometry, material)
  }

  AxesHelper.prototype = Object.create(LineSegments.prototype)
  AxesHelper.prototype.constructor = AxesHelper

  /**
   * @author mrdoob / http://mrdoob.com/
   */

  function Face4(a, b, c, d, normal, color, materialIndex) {
    console.warn('THREE.Face4 has been removed. A THREE.Face3 will be created instead.')
    return new Face3(a, b, c, normal, color, materialIndex)
  }

  var LineStrip = 0

  var LinePieces = 1

  function MeshFaceMaterial(materials) {
    console.warn('THREE.MeshFaceMaterial has been removed. Use an Array instead.')
    return materials
  }

  function MultiMaterial(materials) {
    if (materials === undefined) materials = []

    console.warn('THREE.MultiMaterial has been removed. Use an Array instead.')
    materials.isMultiMaterial = true
    materials.materials = materials
    materials.clone = function () {
      return materials.slice()
    }
    return materials
  }

  function PointCloud(geometry, material) {
    console.warn('THREE.PointCloud has been renamed to THREE.Points.')
    return new Points(geometry, material)
  }

  function Particle(material) {
    console.warn('THREE.Particle has been renamed to THREE.Sprite.')
    return new Sprite(material)
  }

  function ParticleSystem(geometry, material) {
    console.warn('THREE.ParticleSystem has been renamed to THREE.Points.')
    return new Points(geometry, material)
  }

  function PointCloudMaterial(parameters) {
    console.warn('THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.')
    return new PointsMaterial(parameters)
  }

  function ParticleBasicMaterial(parameters) {
    console.warn('THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.')
    return new PointsMaterial(parameters)
  }

  function ParticleSystemMaterial(parameters) {
    console.warn('THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.')
    return new PointsMaterial(parameters)
  }

  function Vertex(x, y, z) {
    console.warn('THREE.Vertex has been removed. Use THREE.Vector3 instead.')
    return new Vector3(x, y, z)
  }

  //

  function DynamicBufferAttribute(array, itemSize) {
    console.warn(
      'THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.'
    )
    return new BufferAttribute(array, itemSize).setDynamic(true)
  }

  function Int8Attribute(array, itemSize) {
    console.warn(
      'THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.'
    )
    return new Int8BufferAttribute(array, itemSize)
  }

  function Uint8Attribute(array, itemSize) {
    console.warn(
      'THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.'
    )
    return new Uint8BufferAttribute(array, itemSize)
  }

  function Uint8ClampedAttribute(array, itemSize) {
    console.warn(
      'THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.'
    )
    return new Uint8ClampedBufferAttribute(array, itemSize)
  }

  function Int16Attribute(array, itemSize) {
    console.warn(
      'THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.'
    )
    return new Int16BufferAttribute(array, itemSize)
  }

  function Uint16Attribute(array, itemSize) {
    console.warn(
      'THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.'
    )
    return new Uint16BufferAttribute(array, itemSize)
  }

  function Int32Attribute(array, itemSize) {
    console.warn(
      'THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.'
    )
    return new Int32BufferAttribute(array, itemSize)
  }

  function Uint32Attribute(array, itemSize) {
    console.warn(
      'THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.'
    )
    return new Uint32BufferAttribute(array, itemSize)
  }

  function Float32Attribute(array, itemSize) {
    console.warn(
      'THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.'
    )
    return new Float32BufferAttribute(array, itemSize)
  }

  function Float64Attribute(array, itemSize) {
    console.warn(
      'THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.'
    )
    return new Float64BufferAttribute(array, itemSize)
  }

  //

  Curve.create = function (construct, getPoint) {
    console.log('THREE.Curve.create() has been deprecated')

    construct.prototype = Object.create(Curve.prototype)
    construct.prototype.constructor = construct
    construct.prototype.getPoint = getPoint

    return construct
  }

  //

  Object.assign(CurvePath.prototype, {
    createPointsGeometry: function (divisions) {
      console.warn(
        'THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.'
      )

      // generate geometry from path points (for Line or Points objects)

      var pts = this.getPoints(divisions)
      return this.createGeometry(pts)
    },

    createSpacedPointsGeometry: function (divisions) {
      console.warn(
        'THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.'
      )

      // generate geometry from equidistant sampling along the path

      var pts = this.getSpacedPoints(divisions)
      return this.createGeometry(pts)
    },

    createGeometry: function (points) {
      console.warn(
        'THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.'
      )

      var geometry = new Geometry()

      for (var i = 0, l = points.length; i < l; i++) {
        var point = points[i]
        geometry.vertices.push(new Vector3(point.x, point.y, point.z || 0))
      }

      return geometry
    }
  })

  //

  Object.assign(Path.prototype, {
    fromPoints: function (points) {
      console.warn('THREE.Path: .fromPoints() has been renamed to .setFromPoints().')
      this.setFromPoints(points)
    }
  })

  //

  function ClosedSplineCurve3(points) {
    console.warn(
      'THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.'
    )

    CatmullRomCurve3.call(this, points)
    this.type = 'catmullrom'
    this.closed = true
  }

  ClosedSplineCurve3.prototype = Object.create(CatmullRomCurve3.prototype)

  //

  function SplineCurve3(points) {
    console.warn('THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.')

    CatmullRomCurve3.call(this, points)
    this.type = 'catmullrom'
  }

  SplineCurve3.prototype = Object.create(CatmullRomCurve3.prototype)

  //

  function Spline(points) {
    console.warn('THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.')

    CatmullRomCurve3.call(this, points)
    this.type = 'catmullrom'
  }

  Spline.prototype = Object.create(CatmullRomCurve3.prototype)

  Object.assign(Spline.prototype, {
    initFromArray: function (/* a */) {
      console.error('THREE.Spline: .initFromArray() has been removed.')
    },
    getControlPointsArray: function (/* optionalTarget */) {
      console.error('THREE.Spline: .getControlPointsArray() has been removed.')
    },
    reparametrizeByArcLength: function (/* samplingCoef */) {
      console.error('THREE.Spline: .reparametrizeByArcLength() has been removed.')
    }
  })

  //

  function AxisHelper(size) {
    console.warn('THREE.AxisHelper has been renamed to THREE.AxesHelper.')
    return new AxesHelper(size)
  }

  function BoundingBoxHelper(object, color) {
    console.warn('THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.')
    return new BoxHelper(object, color)
  }

  function EdgesHelper(object, hex) {
    console.warn('THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.')
    return new LineSegments(
      new EdgesGeometry(object.geometry),
      new LineBasicMaterial({ color: hex !== undefined ? hex : 0xffffff })
    )
  }

  GridHelper.prototype.setColors = function () {
    console.error(
      'THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.'
    )
  }

  SkeletonHelper.prototype.update = function () {
    console.error('THREE.SkeletonHelper: update() no longer needs to be called.')
  }

  function WireframeHelper(object, hex) {
    console.warn('THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.')
    return new LineSegments(
      new WireframeGeometry(object.geometry),
      new LineBasicMaterial({ color: hex !== undefined ? hex : 0xffffff })
    )
  }

  //

  Object.assign(Loader.prototype, {
    extractUrlBase: function (url) {
      console.warn(
        'THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.'
      )
      return LoaderUtils.extractUrlBase(url)
    }
  })

  function XHRLoader(manager) {
    console.warn('THREE.XHRLoader has been renamed to THREE.FileLoader.')
    return new FileLoader(manager)
  }

  function BinaryTextureLoader(manager) {
    console.warn('THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.')
    return new DataTextureLoader(manager)
  }

  //

  Object.assign(Box2.prototype, {
    center: function (optionalTarget) {
      console.warn('THREE.Box2: .center() has been renamed to .getCenter().')
      return this.getCenter(optionalTarget)
    },
    empty: function () {
      console.warn('THREE.Box2: .empty() has been renamed to .isEmpty().')
      return this.isEmpty()
    },
    isIntersectionBox: function (box) {
      console.warn('THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().')
      return this.intersectsBox(box)
    },
    size: function (optionalTarget) {
      console.warn('THREE.Box2: .size() has been renamed to .getSize().')
      return this.getSize(optionalTarget)
    }
  })

  Object.assign(Box3.prototype, {
    center: function (optionalTarget) {
      console.warn('THREE.Box3: .center() has been renamed to .getCenter().')
      return this.getCenter(optionalTarget)
    },
    empty: function () {
      console.warn('THREE.Box3: .empty() has been renamed to .isEmpty().')
      return this.isEmpty()
    },
    isIntersectionBox: function (box) {
      console.warn('THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().')
      return this.intersectsBox(box)
    },
    isIntersectionSphere: function (sphere) {
      console.warn('THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().')
      return this.intersectsSphere(sphere)
    },
    size: function (optionalTarget) {
      console.warn('THREE.Box3: .size() has been renamed to .getSize().')
      return this.getSize(optionalTarget)
    }
  })

  Line3.prototype.center = function (optionalTarget) {
    console.warn('THREE.Line3: .center() has been renamed to .getCenter().')
    return this.getCenter(optionalTarget)
  }

  Object.assign(_Math, {
    random16: function () {
      console.warn('THREE.Math: .random16() has been deprecated. Use Math.random() instead.')
      return Math.random()
    },

    nearestPowerOfTwo: function (value) {
      console.warn('THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().')
      return _Math.floorPowerOfTwo(value)
    },

    nextPowerOfTwo: function (value) {
      console.warn('THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().')
      return _Math.ceilPowerOfTwo(value)
    }
  })

  Object.assign(Matrix3.prototype, {
    flattenToArrayOffset: function (array, offset) {
      console.warn(
        'THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.'
      )
      return this.toArray(array, offset)
    },
    multiplyVector3: function (vector) {
      console.warn(
        'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.'
      )
      return vector.applyMatrix3(this)
    },
    multiplyVector3Array: function (/* a */) {
      console.error('THREE.Matrix3: .multiplyVector3Array() has been removed.')
    },
    applyToBuffer: function (buffer /*, offset, length */) {
      console.warn(
        'THREE.Matrix3: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.'
      )
      return this.applyToBufferAttribute(buffer)
    },
    applyToVector3Array: function (/* array, offset, length */) {
      console.error('THREE.Matrix3: .applyToVector3Array() has been removed.')
    }
  })

  Object.assign(Matrix4.prototype, {
    extractPosition: function (m) {
      console.warn('THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().')
      return this.copyPosition(m)
    },
    flattenToArrayOffset: function (array, offset) {
      console.warn(
        'THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.'
      )
      return this.toArray(array, offset)
    },
    getPosition: (function () {
      var v1

      return function getPosition() {
        if (v1 === undefined) v1 = new Vector3()
        console.warn(
          'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.'
        )
        return v1.setFromMatrixColumn(this, 3)
      }
    })(),
    setRotationFromQuaternion: function (q) {
      console.warn(
        'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().'
      )
      return this.makeRotationFromQuaternion(q)
    },
    multiplyToArray: function () {
      console.warn('THREE.Matrix4: .multiplyToArray() has been removed.')
    },
    multiplyVector3: function (vector) {
      console.warn(
        'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.'
      )
      return vector.applyMatrix4(this)
    },
    multiplyVector4: function (vector) {
      console.warn(
        'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.'
      )
      return vector.applyMatrix4(this)
    },
    multiplyVector3Array: function (/* a */) {
      console.error('THREE.Matrix4: .multiplyVector3Array() has been removed.')
    },
    rotateAxis: function (v) {
      console.warn(
        'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.'
      )
      v.transformDirection(this)
    },
    crossVector: function (vector) {
      console.warn(
        'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.'
      )
      return vector.applyMatrix4(this)
    },
    translate: function () {
      console.error('THREE.Matrix4: .translate() has been removed.')
    },
    rotateX: function () {
      console.error('THREE.Matrix4: .rotateX() has been removed.')
    },
    rotateY: function () {
      console.error('THREE.Matrix4: .rotateY() has been removed.')
    },
    rotateZ: function () {
      console.error('THREE.Matrix4: .rotateZ() has been removed.')
    },
    rotateByAxis: function () {
      console.error('THREE.Matrix4: .rotateByAxis() has been removed.')
    },
    applyToBuffer: function (buffer /*, offset, length */) {
      console.warn(
        'THREE.Matrix4: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.'
      )
      return this.applyToBufferAttribute(buffer)
    },
    applyToVector3Array: function (/* array, offset, length */) {
      console.error('THREE.Matrix4: .applyToVector3Array() has been removed.')
    },
    makeFrustum: function (left, right, bottom, top, near, far) {
      console.warn(
        'THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.'
      )
      return this.makePerspective(left, right, top, bottom, near, far)
    }
  })

  Plane.prototype.isIntersectionLine = function (line) {
    console.warn('THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().')
    return this.intersectsLine(line)
  }

  Quaternion.prototype.multiplyVector3 = function (vector) {
    console.warn(
      'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.'
    )
    return vector.applyQuaternion(this)
  }

  Object.assign(Ray.prototype, {
    isIntersectionBox: function (box) {
      console.warn('THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().')
      return this.intersectsBox(box)
    },
    isIntersectionPlane: function (plane) {
      console.warn('THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().')
      return this.intersectsPlane(plane)
    },
    isIntersectionSphere: function (sphere) {
      console.warn('THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().')
      return this.intersectsSphere(sphere)
    }
  })

  Object.assign(Shape.prototype, {
    extractAllPoints: function (divisions) {
      console.warn(
        'THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.'
      )
      return this.extractPoints(divisions)
    },
    extrude: function (options) {
      console.warn('THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.')
      return new ExtrudeGeometry(this, options)
    },
    makeGeometry: function (options) {
      console.warn('THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.')
      return new ShapeGeometry(this, options)
    }
  })

  Object.assign(Vector2.prototype, {
    fromAttribute: function (attribute, index, offset) {
      console.warn('THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().')
      return this.fromBufferAttribute(attribute, index, offset)
    },
    distanceToManhattan: function (v) {
      console.warn(
        'THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().'
      )
      return this.manhattanDistanceTo(v)
    },
    lengthManhattan: function () {
      console.warn('THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().')
      return this.manhattanLength()
    }
  })

  Object.assign(Vector3.prototype, {
    setEulerFromRotationMatrix: function () {
      console.error(
        'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.'
      )
    },
    setEulerFromQuaternion: function () {
      console.error(
        'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.'
      )
    },
    getPositionFromMatrix: function (m) {
      console.warn(
        'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().'
      )
      return this.setFromMatrixPosition(m)
    },
    getScaleFromMatrix: function (m) {
      console.warn(
        'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().'
      )
      return this.setFromMatrixScale(m)
    },
    getColumnFromMatrix: function (index, matrix) {
      console.warn(
        'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().'
      )
      return this.setFromMatrixColumn(matrix, index)
    },
    applyProjection: function (m) {
      console.warn(
        'THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.'
      )
      return this.applyMatrix4(m)
    },
    fromAttribute: function (attribute, index, offset) {
      console.warn('THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().')
      return this.fromBufferAttribute(attribute, index, offset)
    },
    distanceToManhattan: function (v) {
      console.warn(
        'THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().'
      )
      return this.manhattanDistanceTo(v)
    },
    lengthManhattan: function () {
      console.warn('THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().')
      return this.manhattanLength()
    }
  })

  Object.assign(Vector4.prototype, {
    fromAttribute: function (attribute, index, offset) {
      console.warn('THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().')
      return this.fromBufferAttribute(attribute, index, offset)
    },
    lengthManhattan: function () {
      console.warn('THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().')
      return this.manhattanLength()
    }
  })

  //

  Object.assign(Geometry.prototype, {
    computeTangents: function () {
      console.error('THREE.Geometry: .computeTangents() has been removed.')
    },
    computeLineDistances: function () {
      console.error(
        'THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.'
      )
    }
  })

  Object.assign(Object3D.prototype, {
    getChildByName: function (name) {
      console.warn('THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().')
      return this.getObjectByName(name)
    },
    renderDepth: function () {
      console.warn('THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.')
    },
    translate: function (distance, axis) {
      console.warn(
        'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.'
      )
      return this.translateOnAxis(axis, distance)
    }
  })

  Object.defineProperties(Object3D.prototype, {
    eulerOrder: {
      get: function () {
        console.warn('THREE.Object3D: .eulerOrder is now .rotation.order.')
        return this.rotation.order
      },
      set: function (value) {
        console.warn('THREE.Object3D: .eulerOrder is now .rotation.order.')
        this.rotation.order = value
      }
    },
    useQuaternion: {
      get: function () {
        console.warn(
          'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.'
        )
      },
      set: function () {
        console.warn(
          'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.'
        )
      }
    }
  })

  Object.defineProperties(LOD.prototype, {
    objects: {
      get: function () {
        console.warn('THREE.LOD: .objects has been renamed to .levels.')
        return this.levels
      }
    }
  })

  Object.defineProperty(Skeleton.prototype, 'useVertexTexture', {
    get: function () {
      console.warn('THREE.Skeleton: useVertexTexture has been removed.')
    },
    set: function () {
      console.warn('THREE.Skeleton: useVertexTexture has been removed.')
    }
  })

  Object.defineProperty(Curve.prototype, '__arcLengthDivisions', {
    get: function () {
      console.warn('THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.')
      return this.arcLengthDivisions
    },
    set: function (value) {
      console.warn('THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.')
      this.arcLengthDivisions = value
    }
  })

  //

  PerspectiveCamera.prototype.setLens = function (focalLength, filmGauge) {
    console.warn(
      'THREE.PerspectiveCamera.setLens is deprecated. ' +
        'Use .setFocalLength and .filmGauge for a photographic setup.'
    )

    if (filmGauge !== undefined) this.filmGauge = filmGauge
    this.setFocalLength(focalLength)
  }

  //

  Object.defineProperties(Light.prototype, {
    onlyShadow: {
      set: function () {
        console.warn('THREE.Light: .onlyShadow has been removed.')
      }
    },
    shadowCameraFov: {
      set: function (value) {
        console.warn('THREE.Light: .shadowCameraFov is now .shadow.camera.fov.')
        this.shadow.camera.fov = value
      }
    },
    shadowCameraLeft: {
      set: function (value) {
        console.warn('THREE.Light: .shadowCameraLeft is now .shadow.camera.left.')
        this.shadow.camera.left = value
      }
    },
    shadowCameraRight: {
      set: function (value) {
        console.warn('THREE.Light: .shadowCameraRight is now .shadow.camera.right.')
        this.shadow.camera.right = value
      }
    },
    shadowCameraTop: {
      set: function (value) {
        console.warn('THREE.Light: .shadowCameraTop is now .shadow.camera.top.')
        this.shadow.camera.top = value
      }
    },
    shadowCameraBottom: {
      set: function (value) {
        console.warn('THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.')
        this.shadow.camera.bottom = value
      }
    },
    shadowCameraNear: {
      set: function (value) {
        console.warn('THREE.Light: .shadowCameraNear is now .shadow.camera.near.')
        this.shadow.camera.near = value
      }
    },
    shadowCameraFar: {
      set: function (value) {
        console.warn('THREE.Light: .shadowCameraFar is now .shadow.camera.far.')
        this.shadow.camera.far = value
      }
    },
    shadowCameraVisible: {
      set: function () {
        console.warn(
          'THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.'
        )
      }
    },
    shadowBias: {
      set: function (value) {
        console.warn('THREE.Light: .shadowBias is now .shadow.bias.')
        this.shadow.bias = value
      }
    },
    shadowDarkness: {
      set: function () {
        console.warn('THREE.Light: .shadowDarkness has been removed.')
      }
    },
    shadowMapWidth: {
      set: function (value) {
        console.warn('THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.')
        this.shadow.mapSize.width = value
      }
    },
    shadowMapHeight: {
      set: function (value) {
        console.warn('THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.')
        this.shadow.mapSize.height = value
      }
    }
  })

  //

  Object.defineProperties(BufferAttribute.prototype, {
    length: {
      get: function () {
        console.warn('THREE.BufferAttribute: .length has been deprecated. Use .count instead.')
        return this.array.length
      }
    }
  })

  Object.assign(BufferGeometry.prototype, {
    addIndex: function (index) {
      console.warn('THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().')
      this.setIndex(index)
    },
    addDrawCall: function (start, count, indexOffset) {
      if (indexOffset !== undefined) {
        console.warn('THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.')
      }
      console.warn('THREE.BufferGeometry: .addDrawCall() is now .addGroup().')
      this.addGroup(start, count)
    },
    clearDrawCalls: function () {
      console.warn('THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().')
      this.clearGroups()
    },
    computeTangents: function () {
      console.warn('THREE.BufferGeometry: .computeTangents() has been removed.')
    },
    computeOffsets: function () {
      console.warn('THREE.BufferGeometry: .computeOffsets() has been removed.')
    }
  })

  Object.defineProperties(BufferGeometry.prototype, {
    drawcalls: {
      get: function () {
        console.error('THREE.BufferGeometry: .drawcalls has been renamed to .groups.')
        return this.groups
      }
    },
    offsets: {
      get: function () {
        console.warn('THREE.BufferGeometry: .offsets has been renamed to .groups.')
        return this.groups
      }
    }
  })

  //

  Object.defineProperties(Uniform.prototype, {
    dynamic: {
      set: function () {
        console.warn(
          'THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.'
        )
      }
    },
    onUpdate: {
      value: function () {
        console.warn(
          'THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.'
        )
        return this
      }
    }
  })

  //

  Object.defineProperties(Material.prototype, {
    wrapAround: {
      get: function () {
        console.warn('THREE.Material: .wrapAround has been removed.')
      },
      set: function () {
        console.warn('THREE.Material: .wrapAround has been removed.')
      }
    },
    wrapRGB: {
      get: function () {
        console.warn('THREE.Material: .wrapRGB has been removed.')
        return new Color()
      }
    },

    shading: {
      get: function () {
        console.error(
          'THREE.' +
            this.type +
            ': .shading has been removed. Use the boolean .flatShading instead.'
        )
      },
      set: function (value) {
        console.warn(
          'THREE.' +
            this.type +
            ': .shading has been removed. Use the boolean .flatShading instead.'
        )
        this.flatShading = value === FlatShading
      }
    }
  })

  Object.defineProperties(MeshPhongMaterial.prototype, {
    metal: {
      get: function () {
        console.warn(
          'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.'
        )
        return false
      },
      set: function () {
        console.warn(
          'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead'
        )
      }
    }
  })

  Object.defineProperties(ShaderMaterial.prototype, {
    derivatives: {
      get: function () {
        console.warn(
          'THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.'
        )
        return this.extensions.derivatives
      },
      set: function (value) {
        console.warn(
          'THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.'
        )
        this.extensions.derivatives = value
      }
    }
  })

  //

  Object.assign(WebGLRenderer.prototype, {
    getCurrentRenderTarget: function () {
      console.warn('THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().')
      return this.getRenderTarget()
    },

    getMaxAnisotropy: function () {
      console.warn(
        'THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().'
      )
      return this.capabilities.getMaxAnisotropy()
    },

    getPrecision: function () {
      console.warn('THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.')
      return this.capabilities.precision
    },

    resetGLState: function () {
      console.warn('THREE.WebGLRenderer: .resetGLState() is now .state.reset().')
      return this.state.reset()
    },

    supportsFloatTextures: function () {
      console.warn(
        "THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' )."
      )
      return this.extensions.get('OES_texture_float')
    },
    supportsHalfFloatTextures: function () {
      console.warn(
        "THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' )."
      )
      return this.extensions.get('OES_texture_half_float')
    },
    supportsStandardDerivatives: function () {
      console.warn(
        "THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' )."
      )
      return this.extensions.get('OES_standard_derivatives')
    },
    supportsCompressedTextureS3TC: function () {
      console.warn(
        "THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' )."
      )
      return this.extensions.get('WEBGL_compressed_texture_s3tc')
    },
    supportsCompressedTexturePVRTC: function () {
      console.warn(
        "THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' )."
      )
      return this.extensions.get('WEBGL_compressed_texture_pvrtc')
    },
    supportsBlendMinMax: function () {
      console.warn(
        "THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' )."
      )
      return this.extensions.get('EXT_blend_minmax')
    },
    supportsVertexTextures: function () {
      console.warn(
        'THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.'
      )
      return this.capabilities.vertexTextures
    },
    supportsInstancedArrays: function () {
      console.warn(
        "THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' )."
      )
      return this.extensions.get('ANGLE_instanced_arrays')
    },
    enableScissorTest: function (boolean) {
      console.warn('THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().')
      this.setScissorTest(boolean)
    },
    initMaterial: function () {
      console.warn('THREE.WebGLRenderer: .initMaterial() has been removed.')
    },
    addPrePlugin: function () {
      console.warn('THREE.WebGLRenderer: .addPrePlugin() has been removed.')
    },
    addPostPlugin: function () {
      console.warn('THREE.WebGLRenderer: .addPostPlugin() has been removed.')
    },
    updateShadowMap: function () {
      console.warn('THREE.WebGLRenderer: .updateShadowMap() has been removed.')
    },
    setFaceCulling: function () {
      console.warn('THREE.WebGLRenderer: .setFaceCulling() has been removed.')
    }
  })

  Object.defineProperties(WebGLRenderer.prototype, {
    shadowMapEnabled: {
      get: function () {
        return this.shadowMap.enabled
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.')
        this.shadowMap.enabled = value
      }
    },
    shadowMapType: {
      get: function () {
        return this.shadowMap.type
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.')
        this.shadowMap.type = value
      }
    },
    shadowMapCullFace: {
      get: function () {
        console.warn(
          'THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.'
        )
        return undefined
      },
      set: function (/* value */) {
        console.warn(
          'THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.'
        )
      }
    }
  })

  Object.defineProperties(WebGLShadowMap.prototype, {
    cullFace: {
      get: function () {
        console.warn(
          'THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.'
        )
        return undefined
      },
      set: function (/* cullFace */) {
        console.warn(
          'THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.'
        )
      }
    },
    renderReverseSided: {
      get: function () {
        console.warn(
          'THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.'
        )
        return undefined
      },
      set: function () {
        console.warn(
          'THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.'
        )
      }
    },
    renderSingleSided: {
      get: function () {
        console.warn(
          'THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.'
        )
        return undefined
      },
      set: function () {
        console.warn(
          'THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.'
        )
      }
    }
  })

  //

  Object.defineProperties(WebGLRenderTarget.prototype, {
    wrapS: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.')
        return this.texture.wrapS
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.')
        this.texture.wrapS = value
      }
    },
    wrapT: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.')
        return this.texture.wrapT
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.')
        this.texture.wrapT = value
      }
    },
    magFilter: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.')
        return this.texture.magFilter
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.')
        this.texture.magFilter = value
      }
    },
    minFilter: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.')
        return this.texture.minFilter
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.')
        this.texture.minFilter = value
      }
    },
    anisotropy: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.')
        return this.texture.anisotropy
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.')
        this.texture.anisotropy = value
      }
    },
    offset: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .offset is now .texture.offset.')
        return this.texture.offset
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .offset is now .texture.offset.')
        this.texture.offset = value
      }
    },
    repeat: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .repeat is now .texture.repeat.')
        return this.texture.repeat
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .repeat is now .texture.repeat.')
        this.texture.repeat = value
      }
    },
    format: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .format is now .texture.format.')
        return this.texture.format
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .format is now .texture.format.')
        this.texture.format = value
      }
    },
    type: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .type is now .texture.type.')
        return this.texture.type
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .type is now .texture.type.')
        this.texture.type = value
      }
    },
    generateMipmaps: {
      get: function () {
        console.warn('THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.')
        return this.texture.generateMipmaps
      },
      set: function (value) {
        console.warn('THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.')
        this.texture.generateMipmaps = value
      }
    }
  })

  //

  Object.defineProperties(WebVRManager.prototype, {
    standing: {
      set: function (/* value */) {
        console.warn('THREE.WebVRManager: .standing has been removed.')
      }
    }
  })

  //

  Audio.prototype.load = function (file) {
    console.warn('THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.')
    var scope = this
    var audioLoader = new AudioLoader()
    audioLoader.load(file, function (buffer) {
      scope.setBuffer(buffer)
    })
    return this
  }

  AudioAnalyser.prototype.getData = function () {
    console.warn('THREE.AudioAnalyser: .getData() is now .getFrequencyData().')
    return this.getFrequencyData()
  }

  //

  CubeCamera.prototype.updateCubeMap = function (renderer, scene) {
    console.warn('THREE.CubeCamera: .updateCubeMap() is now .update().')
    return this.update(renderer, scene)
  }

  //

  var GeometryUtils = {
    merge: function (geometry1, geometry2, materialIndexOffset) {
      console.warn(
        'THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.'
      )
      var matrix

      if (geometry2.isMesh) {
        geometry2.matrixAutoUpdate && geometry2.updateMatrix()

        matrix = geometry2.matrix
        geometry2 = geometry2.geometry
      }

      geometry1.merge(geometry2, matrix, materialIndexOffset)
    },

    center: function (geometry) {
      console.warn(
        'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.'
      )
      return geometry.center()
    }
  }

  var ImageUtils = {
    crossOrigin: undefined,

    loadTexture: function (url, mapping, onLoad, onError) {
      console.warn(
        'THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.'
      )

      var loader = new TextureLoader()
      loader.setCrossOrigin(this.crossOrigin)

      var texture = loader.load(url, onLoad, undefined, onError)

      if (mapping) texture.mapping = mapping

      return texture
    },

    loadTextureCube: function (urls, mapping, onLoad, onError) {
      console.warn(
        'THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.'
      )

      var loader = new CubeTextureLoader()
      loader.setCrossOrigin(this.crossOrigin)

      var texture = loader.load(urls, onLoad, undefined, onError)

      if (mapping) texture.mapping = mapping

      return texture
    },

    loadCompressedTexture: function () {
      console.error(
        'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.'
      )
    },

    loadCompressedTextureCube: function () {
      console.error(
        'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.'
      )
    }
  }

  //

  function Projector() {
    console.error('THREE.Projector has been moved to /examples/js/renderers/Projector.js.')

    this.projectVector = function (vector, camera) {
      console.warn('THREE.Projector: .projectVector() is now vector.project().')
      vector.project(camera)
    }

    this.unprojectVector = function (vector, camera) {
      console.warn('THREE.Projector: .unprojectVector() is now vector.unproject().')
      vector.unproject(camera)
    }

    this.pickingRay = function () {
      console.error('THREE.Projector: .pickingRay() is now raycaster.setFromCamera().')
    }
  }

  //

  function CanvasRenderer() {
    console.error('THREE.CanvasRenderer has been moved to /examples/js/renderers/CanvasRenderer.js')

    this.domElement = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')
    this.clear = function () {}
    this.render = function () {}
    this.setClearColor = function () {}
    this.setSize = function () {}
  }

  //

  var SceneUtils = {
    createMultiMaterialObject: function (/* geometry, materials */) {
      console.error('THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js')
    },

    detach: function (/* child, parent, scene */) {
      console.error('THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js')
    },

    attach: function (/* child, scene, parent */) {
      console.error('THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js')
    }
  }

  //

  function LensFlare() {
    console.error('THREE.LensFlare has been moved to /examples/js/objects/Lensflare.js')
  }

  exports.WebGLRenderTargetCube = WebGLRenderTargetCube
  exports.WebGLRenderTarget = WebGLRenderTarget
  exports.WebGLRenderer = WebGLRenderer
  exports.ShaderLib = ShaderLib
  exports.UniformsLib = UniformsLib
  exports.UniformsUtils = UniformsUtils
  exports.ShaderChunk = ShaderChunk
  exports.FogExp2 = FogExp2
  exports.Fog = Fog
  exports.Scene = Scene
  exports.Sprite = Sprite
  exports.LOD = LOD
  exports.SkinnedMesh = SkinnedMesh
  exports.Skeleton = Skeleton
  exports.Bone = Bone
  exports.Mesh = Mesh
  exports.LineSegments = LineSegments
  exports.LineLoop = LineLoop
  exports.Line = Line
  exports.Points = Points
  exports.Group = Group
  exports.VideoTexture = VideoTexture
  exports.DataTexture = DataTexture
  exports.CompressedTexture = CompressedTexture
  exports.CubeTexture = CubeTexture
  exports.CanvasTexture = CanvasTexture
  exports.DepthTexture = DepthTexture
  exports.Texture = Texture
  exports.CompressedTextureLoader = CompressedTextureLoader
  exports.DataTextureLoader = DataTextureLoader
  exports.CubeTextureLoader = CubeTextureLoader
  exports.TextureLoader = TextureLoader
  exports.ObjectLoader = ObjectLoader
  exports.MaterialLoader = MaterialLoader
  exports.BufferGeometryLoader = BufferGeometryLoader
  exports.DefaultLoadingManager = DefaultLoadingManager
  exports.LoadingManager = LoadingManager
  exports.JSONLoader = JSONLoader
  exports.ImageLoader = ImageLoader
  exports.ImageBitmapLoader = ImageBitmapLoader
  exports.FontLoader = FontLoader
  exports.FileLoader = FileLoader
  exports.Loader = Loader
  exports.LoaderUtils = LoaderUtils
  exports.Cache = Cache
  exports.AudioLoader = AudioLoader
  exports.SpotLightShadow = SpotLightShadow
  exports.SpotLight = SpotLight
  exports.PointLight = PointLight
  exports.RectAreaLight = RectAreaLight
  exports.HemisphereLight = HemisphereLight
  exports.DirectionalLightShadow = DirectionalLightShadow
  exports.DirectionalLight = DirectionalLight
  exports.AmbientLight = AmbientLight
  exports.LightShadow = LightShadow
  exports.Light = Light
  exports.StereoCamera = StereoCamera
  exports.PerspectiveCamera = PerspectiveCamera
  exports.OrthographicCamera = OrthographicCamera
  exports.CubeCamera = CubeCamera
  exports.ArrayCamera = ArrayCamera
  exports.Camera = Camera
  exports.AudioListener = AudioListener
  exports.PositionalAudio = PositionalAudio
  exports.AudioContext = AudioContext
  exports.AudioAnalyser = AudioAnalyser
  exports.Audio = Audio
  exports.VectorKeyframeTrack = VectorKeyframeTrack
  exports.StringKeyframeTrack = StringKeyframeTrack
  exports.QuaternionKeyframeTrack = QuaternionKeyframeTrack
  exports.NumberKeyframeTrack = NumberKeyframeTrack
  exports.ColorKeyframeTrack = ColorKeyframeTrack
  exports.BooleanKeyframeTrack = BooleanKeyframeTrack
  exports.PropertyMixer = PropertyMixer
  exports.PropertyBinding = PropertyBinding
  exports.KeyframeTrack = KeyframeTrack
  exports.AnimationUtils = AnimationUtils
  exports.AnimationObjectGroup = AnimationObjectGroup
  exports.AnimationMixer = AnimationMixer
  exports.AnimationClip = AnimationClip
  exports.Uniform = Uniform
  exports.InstancedBufferGeometry = InstancedBufferGeometry
  exports.BufferGeometry = BufferGeometry
  exports.Geometry = Geometry
  exports.InterleavedBufferAttribute = InterleavedBufferAttribute
  exports.InstancedInterleavedBuffer = InstancedInterleavedBuffer
  exports.InterleavedBuffer = InterleavedBuffer
  exports.InstancedBufferAttribute = InstancedBufferAttribute
  exports.Face3 = Face3
  exports.Object3D = Object3D
  exports.Raycaster = Raycaster
  exports.Layers = Layers
  exports.EventDispatcher = EventDispatcher
  exports.Clock = Clock
  exports.QuaternionLinearInterpolant = QuaternionLinearInterpolant
  exports.LinearInterpolant = LinearInterpolant
  exports.DiscreteInterpolant = DiscreteInterpolant
  exports.CubicInterpolant = CubicInterpolant
  exports.Interpolant = Interpolant
  exports.Triangle = Triangle
  exports.Math = _Math
  exports.Spherical = Spherical
  exports.Cylindrical = Cylindrical
  exports.Plane = Plane
  exports.Frustum = Frustum
  exports.Sphere = Sphere
  exports.Ray = Ray
  exports.Matrix4 = Matrix4
  exports.Matrix3 = Matrix3
  exports.Box3 = Box3
  exports.Box2 = Box2
  exports.Line3 = Line3
  exports.Euler = Euler
  exports.Vector4 = Vector4
  exports.Vector3 = Vector3
  exports.Vector2 = Vector2
  exports.Quaternion = Quaternion
  exports.Color = Color
  exports.ImmediateRenderObject = ImmediateRenderObject
  exports.VertexNormalsHelper = VertexNormalsHelper
  exports.SpotLightHelper = SpotLightHelper
  exports.SkeletonHelper = SkeletonHelper
  exports.PointLightHelper = PointLightHelper
  exports.RectAreaLightHelper = RectAreaLightHelper
  exports.HemisphereLightHelper = HemisphereLightHelper
  exports.GridHelper = GridHelper
  exports.PolarGridHelper = PolarGridHelper
  exports.FaceNormalsHelper = FaceNormalsHelper
  exports.DirectionalLightHelper = DirectionalLightHelper
  exports.CameraHelper = CameraHelper
  exports.BoxHelper = BoxHelper
  exports.Box3Helper = Box3Helper
  exports.PlaneHelper = PlaneHelper
  exports.ArrowHelper = ArrowHelper
  exports.AxesHelper = AxesHelper
  exports.Shape = Shape
  exports.Path = Path
  exports.ShapePath = ShapePath
  exports.Font = Font
  exports.CurvePath = CurvePath
  exports.Curve = Curve
  exports.ShapeUtils = ShapeUtils
  exports.WebGLUtils = WebGLUtils
  exports.WireframeGeometry = WireframeGeometry
  exports.ParametricGeometry = ParametricGeometry
  exports.ParametricBufferGeometry = ParametricBufferGeometry
  exports.TetrahedronGeometry = TetrahedronGeometry
  exports.TetrahedronBufferGeometry = TetrahedronBufferGeometry
  exports.OctahedronGeometry = OctahedronGeometry
  exports.OctahedronBufferGeometry = OctahedronBufferGeometry
  exports.IcosahedronGeometry = IcosahedronGeometry
  exports.IcosahedronBufferGeometry = IcosahedronBufferGeometry
  exports.DodecahedronGeometry = DodecahedronGeometry
  exports.DodecahedronBufferGeometry = DodecahedronBufferGeometry
  exports.PolyhedronGeometry = PolyhedronGeometry
  exports.PolyhedronBufferGeometry = PolyhedronBufferGeometry
  exports.TubeGeometry = TubeGeometry
  exports.TubeBufferGeometry = TubeBufferGeometry
  exports.TorusKnotGeometry = TorusKnotGeometry
  exports.TorusKnotBufferGeometry = TorusKnotBufferGeometry
  exports.TorusGeometry = TorusGeometry
  exports.TorusBufferGeometry = TorusBufferGeometry
  exports.TextGeometry = TextGeometry
  exports.TextBufferGeometry = TextBufferGeometry
  exports.SphereGeometry = SphereGeometry
  exports.SphereBufferGeometry = SphereBufferGeometry
  exports.RingGeometry = RingGeometry
  exports.RingBufferGeometry = RingBufferGeometry
  exports.PlaneGeometry = PlaneGeometry
  exports.PlaneBufferGeometry = PlaneBufferGeometry
  exports.LatheGeometry = LatheGeometry
  exports.LatheBufferGeometry = LatheBufferGeometry
  exports.ShapeGeometry = ShapeGeometry
  exports.ShapeBufferGeometry = ShapeBufferGeometry
  exports.ExtrudeGeometry = ExtrudeGeometry
  exports.ExtrudeBufferGeometry = ExtrudeBufferGeometry
  exports.EdgesGeometry = EdgesGeometry
  exports.ConeGeometry = ConeGeometry
  exports.ConeBufferGeometry = ConeBufferGeometry
  exports.CylinderGeometry = CylinderGeometry
  exports.CylinderBufferGeometry = CylinderBufferGeometry
  exports.CircleGeometry = CircleGeometry
  exports.CircleBufferGeometry = CircleBufferGeometry
  exports.BoxGeometry = BoxGeometry
  exports.BoxBufferGeometry = BoxBufferGeometry
  exports.ShadowMaterial = ShadowMaterial
  exports.SpriteMaterial = SpriteMaterial
  exports.RawShaderMaterial = RawShaderMaterial
  exports.ShaderMaterial = ShaderMaterial
  exports.PointsMaterial = PointsMaterial
  exports.MeshPhysicalMaterial = MeshPhysicalMaterial
  exports.MeshStandardMaterial = MeshStandardMaterial
  exports.MeshPhongMaterial = MeshPhongMaterial
  exports.MeshToonMaterial = MeshToonMaterial
  exports.MeshNormalMaterial = MeshNormalMaterial
  exports.MeshLambertMaterial = MeshLambertMaterial
  exports.MeshDepthMaterial = MeshDepthMaterial
  exports.MeshDistanceMaterial = MeshDistanceMaterial
  exports.MeshBasicMaterial = MeshBasicMaterial
  exports.LineDashedMaterial = LineDashedMaterial
  exports.LineBasicMaterial = LineBasicMaterial
  exports.Material = Material
  exports.Float64BufferAttribute = Float64BufferAttribute
  exports.Float32BufferAttribute = Float32BufferAttribute
  exports.Uint32BufferAttribute = Uint32BufferAttribute
  exports.Int32BufferAttribute = Int32BufferAttribute
  exports.Uint16BufferAttribute = Uint16BufferAttribute
  exports.Int16BufferAttribute = Int16BufferAttribute
  exports.Uint8ClampedBufferAttribute = Uint8ClampedBufferAttribute
  exports.Uint8BufferAttribute = Uint8BufferAttribute
  exports.Int8BufferAttribute = Int8BufferAttribute
  exports.BufferAttribute = BufferAttribute
  exports.ArcCurve = ArcCurve
  exports.CatmullRomCurve3 = CatmullRomCurve3
  exports.CubicBezierCurve = CubicBezierCurve
  exports.CubicBezierCurve3 = CubicBezierCurve3
  exports.EllipseCurve = EllipseCurve
  exports.LineCurve = LineCurve
  exports.LineCurve3 = LineCurve3
  exports.QuadraticBezierCurve = QuadraticBezierCurve
  exports.QuadraticBezierCurve3 = QuadraticBezierCurve3
  exports.SplineCurve = SplineCurve
  exports.REVISION = REVISION
  exports.MOUSE = MOUSE
  exports.CullFaceNone = CullFaceNone
  exports.CullFaceBack = CullFaceBack
  exports.CullFaceFront = CullFaceFront
  exports.CullFaceFrontBack = CullFaceFrontBack
  exports.FrontFaceDirectionCW = FrontFaceDirectionCW
  exports.FrontFaceDirectionCCW = FrontFaceDirectionCCW
  exports.BasicShadowMap = BasicShadowMap
  exports.PCFShadowMap = PCFShadowMap
  exports.PCFSoftShadowMap = PCFSoftShadowMap
  exports.FrontSide = FrontSide
  exports.BackSide = BackSide
  exports.DoubleSide = DoubleSide
  exports.FlatShading = FlatShading
  exports.SmoothShading = SmoothShading
  exports.NoColors = NoColors
  exports.FaceColors = FaceColors
  exports.VertexColors = VertexColors
  exports.NoBlending = NoBlending
  exports.NormalBlending = NormalBlending
  exports.AdditiveBlending = AdditiveBlending
  exports.SubtractiveBlending = SubtractiveBlending
  exports.MultiplyBlending = MultiplyBlending
  exports.CustomBlending = CustomBlending
  exports.AddEquation = AddEquation
  exports.SubtractEquation = SubtractEquation
  exports.ReverseSubtractEquation = ReverseSubtractEquation
  exports.MinEquation = MinEquation
  exports.MaxEquation = MaxEquation
  exports.ZeroFactor = ZeroFactor
  exports.OneFactor = OneFactor
  exports.SrcColorFactor = SrcColorFactor
  exports.OneMinusSrcColorFactor = OneMinusSrcColorFactor
  exports.SrcAlphaFactor = SrcAlphaFactor
  exports.OneMinusSrcAlphaFactor = OneMinusSrcAlphaFactor
  exports.DstAlphaFactor = DstAlphaFactor
  exports.OneMinusDstAlphaFactor = OneMinusDstAlphaFactor
  exports.DstColorFactor = DstColorFactor
  exports.OneMinusDstColorFactor = OneMinusDstColorFactor
  exports.SrcAlphaSaturateFactor = SrcAlphaSaturateFactor
  exports.NeverDepth = NeverDepth
  exports.AlwaysDepth = AlwaysDepth
  exports.LessDepth = LessDepth
  exports.LessEqualDepth = LessEqualDepth
  exports.EqualDepth = EqualDepth
  exports.GreaterEqualDepth = GreaterEqualDepth
  exports.GreaterDepth = GreaterDepth
  exports.NotEqualDepth = NotEqualDepth
  exports.MultiplyOperation = MultiplyOperation
  exports.MixOperation = MixOperation
  exports.AddOperation = AddOperation
  exports.NoToneMapping = NoToneMapping
  exports.LinearToneMapping = LinearToneMapping
  exports.ReinhardToneMapping = ReinhardToneMapping
  exports.Uncharted2ToneMapping = Uncharted2ToneMapping
  exports.CineonToneMapping = CineonToneMapping
  exports.UVMapping = UVMapping
  exports.CubeReflectionMapping = CubeReflectionMapping
  exports.CubeRefractionMapping = CubeRefractionMapping
  exports.EquirectangularReflectionMapping = EquirectangularReflectionMapping
  exports.EquirectangularRefractionMapping = EquirectangularRefractionMapping
  exports.SphericalReflectionMapping = SphericalReflectionMapping
  exports.CubeUVReflectionMapping = CubeUVReflectionMapping
  exports.CubeUVRefractionMapping = CubeUVRefractionMapping
  exports.RepeatWrapping = RepeatWrapping
  exports.ClampToEdgeWrapping = ClampToEdgeWrapping
  exports.MirroredRepeatWrapping = MirroredRepeatWrapping
  exports.NearestFilter = NearestFilter
  exports.NearestMipMapNearestFilter = NearestMipMapNearestFilter
  exports.NearestMipMapLinearFilter = NearestMipMapLinearFilter
  exports.LinearFilter = LinearFilter
  exports.LinearMipMapNearestFilter = LinearMipMapNearestFilter
  exports.LinearMipMapLinearFilter = LinearMipMapLinearFilter
  exports.UnsignedByteType = UnsignedByteType
  exports.ByteType = ByteType
  exports.ShortType = ShortType
  exports.UnsignedShortType = UnsignedShortType
  exports.IntType = IntType
  exports.UnsignedIntType = UnsignedIntType
  exports.FloatType = FloatType
  exports.HalfFloatType = HalfFloatType
  exports.UnsignedShort4444Type = UnsignedShort4444Type
  exports.UnsignedShort5551Type = UnsignedShort5551Type
  exports.UnsignedShort565Type = UnsignedShort565Type
  exports.UnsignedInt248Type = UnsignedInt248Type
  exports.AlphaFormat = AlphaFormat
  exports.RGBFormat = RGBFormat
  exports.RGBAFormat = RGBAFormat
  exports.LuminanceFormat = LuminanceFormat
  exports.LuminanceAlphaFormat = LuminanceAlphaFormat
  exports.RGBEFormat = RGBEFormat
  exports.DepthFormat = DepthFormat
  exports.DepthStencilFormat = DepthStencilFormat
  exports.RGB_S3TC_DXT1_Format = RGB_S3TC_DXT1_Format
  exports.RGBA_S3TC_DXT1_Format = RGBA_S3TC_DXT1_Format
  exports.RGBA_S3TC_DXT3_Format = RGBA_S3TC_DXT3_Format
  exports.RGBA_S3TC_DXT5_Format = RGBA_S3TC_DXT5_Format
  exports.RGB_PVRTC_4BPPV1_Format = RGB_PVRTC_4BPPV1_Format
  exports.RGB_PVRTC_2BPPV1_Format = RGB_PVRTC_2BPPV1_Format
  exports.RGBA_PVRTC_4BPPV1_Format = RGBA_PVRTC_4BPPV1_Format
  exports.RGBA_PVRTC_2BPPV1_Format = RGBA_PVRTC_2BPPV1_Format
  exports.RGB_ETC1_Format = RGB_ETC1_Format
  exports.RGBA_ASTC_4x4_Format = RGBA_ASTC_4x4_Format
  exports.RGBA_ASTC_5x4_Format = RGBA_ASTC_5x4_Format
  exports.RGBA_ASTC_5x5_Format = RGBA_ASTC_5x5_Format
  exports.RGBA_ASTC_6x5_Format = RGBA_ASTC_6x5_Format
  exports.RGBA_ASTC_6x6_Format = RGBA_ASTC_6x6_Format
  exports.RGBA_ASTC_8x5_Format = RGBA_ASTC_8x5_Format
  exports.RGBA_ASTC_8x6_Format = RGBA_ASTC_8x6_Format
  exports.RGBA_ASTC_8x8_Format = RGBA_ASTC_8x8_Format
  exports.RGBA_ASTC_10x5_Format = RGBA_ASTC_10x5_Format
  exports.RGBA_ASTC_10x6_Format = RGBA_ASTC_10x6_Format
  exports.RGBA_ASTC_10x8_Format = RGBA_ASTC_10x8_Format
  exports.RGBA_ASTC_10x10_Format = RGBA_ASTC_10x10_Format
  exports.RGBA_ASTC_12x10_Format = RGBA_ASTC_12x10_Format
  exports.RGBA_ASTC_12x12_Format = RGBA_ASTC_12x12_Format
  exports.LoopOnce = LoopOnce
  exports.LoopRepeat = LoopRepeat
  exports.LoopPingPong = LoopPingPong
  exports.InterpolateDiscrete = InterpolateDiscrete
  exports.InterpolateLinear = InterpolateLinear
  exports.InterpolateSmooth = InterpolateSmooth
  exports.ZeroCurvatureEnding = ZeroCurvatureEnding
  exports.ZeroSlopeEnding = ZeroSlopeEnding
  exports.WrapAroundEnding = WrapAroundEnding
  exports.TrianglesDrawMode = TrianglesDrawMode
  exports.TriangleStripDrawMode = TriangleStripDrawMode
  exports.TriangleFanDrawMode = TriangleFanDrawMode
  exports.LinearEncoding = LinearEncoding
  exports.sRGBEncoding = sRGBEncoding
  exports.GammaEncoding = GammaEncoding
  exports.RGBEEncoding = RGBEEncoding
  exports.LogLuvEncoding = LogLuvEncoding
  exports.RGBM7Encoding = RGBM7Encoding
  exports.RGBM16Encoding = RGBM16Encoding
  exports.RGBDEncoding = RGBDEncoding
  exports.BasicDepthPacking = BasicDepthPacking
  exports.RGBADepthPacking = RGBADepthPacking
  exports.CubeGeometry = BoxGeometry
  exports.Face4 = Face4
  exports.LineStrip = LineStrip
  exports.LinePieces = LinePieces
  exports.MeshFaceMaterial = MeshFaceMaterial
  exports.MultiMaterial = MultiMaterial
  exports.PointCloud = PointCloud
  exports.Particle = Particle
  exports.ParticleSystem = ParticleSystem
  exports.PointCloudMaterial = PointCloudMaterial
  exports.ParticleBasicMaterial = ParticleBasicMaterial
  exports.ParticleSystemMaterial = ParticleSystemMaterial
  exports.Vertex = Vertex
  exports.DynamicBufferAttribute = DynamicBufferAttribute
  exports.Int8Attribute = Int8Attribute
  exports.Uint8Attribute = Uint8Attribute
  exports.Uint8ClampedAttribute = Uint8ClampedAttribute
  exports.Int16Attribute = Int16Attribute
  exports.Uint16Attribute = Uint16Attribute
  exports.Int32Attribute = Int32Attribute
  exports.Uint32Attribute = Uint32Attribute
  exports.Float32Attribute = Float32Attribute
  exports.Float64Attribute = Float64Attribute
  exports.ClosedSplineCurve3 = ClosedSplineCurve3
  exports.SplineCurve3 = SplineCurve3
  exports.Spline = Spline
  exports.AxisHelper = AxisHelper
  exports.BoundingBoxHelper = BoundingBoxHelper
  exports.EdgesHelper = EdgesHelper
  exports.WireframeHelper = WireframeHelper
  exports.XHRLoader = XHRLoader
  exports.BinaryTextureLoader = BinaryTextureLoader
  exports.GeometryUtils = GeometryUtils
  exports.ImageUtils = ImageUtils
  exports.Projector = Projector
  exports.CanvasRenderer = CanvasRenderer
  exports.SceneUtils = SceneUtils
  exports.LensFlare = LensFlare

  Object.defineProperty(exports, '__esModule', { value: true })
})