three-stdlib 2.25.0 → 2.25.1

package/utils/GeometryCompressionUtils.js

@@ -1,573 +0,0 @@
-import { BufferAttribute, Matrix4, Vector3, Matrix3, MeshPhongMaterial, UniformsUtils, ShaderLib, ShaderChunk, REVISION } from "three";
-var GeometryCompressionUtils = {
-  /**
-   * Make the input mesh.geometry's normal attribute encoded and compressed by 3 different methods.
-   * Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the normal data.
-   *
-   * @param {THREE.Mesh} mesh
-   * @param {String} encodeMethod		"DEFAULT" || "OCT1Byte" || "OCT2Byte" || "ANGLES"
-   *
-   */
-  compressNormals: function(mesh, encodeMethod) {
-    if (!mesh.geometry) {
-      console.error("Mesh must contain geometry. ");
-    }
-    const normal = mesh.geometry.attributes.normal;
-    if (!normal) {
-      console.error("Geometry must contain normal attribute. ");
-    }
-    if (normal.isPacked)
-      return;
-    if (normal.itemSize != 3) {
-      console.error("normal.itemSize is not 3, which cannot be encoded. ");
-    }
-    const array = normal.array;
-    const count = normal.count;
-    let result;
-    if (encodeMethod == "DEFAULT") {
-      result = new Uint8Array(count * 3);
-      for (let idx = 0; idx < array.length; idx += 3) {
-        const encoded = this.EncodingFuncs.defaultEncode(array[idx], array[idx + 1], array[idx + 2], 1);
-        result[idx + 0] = encoded[0];
-        result[idx + 1] = encoded[1];
-        result[idx + 2] = encoded[2];
-      }
-      mesh.geometry.setAttribute("normal", new BufferAttribute(result, 3, true));
-      mesh.geometry.attributes.normal.bytes = result.length * 1;
-    } else if (encodeMethod == "OCT1Byte") {
-      result = new Int8Array(count * 2);
-      for (let idx = 0; idx < array.length; idx += 3) {
-        const encoded = this.EncodingFuncs.octEncodeBest(array[idx], array[idx + 1], array[idx + 2], 1);
-        result[idx / 3 * 2 + 0] = encoded[0];
-        result[idx / 3 * 2 + 1] = encoded[1];
-      }
-      mesh.geometry.setAttribute("normal", new BufferAttribute(result, 2, true));
-      mesh.geometry.attributes.normal.bytes = result.length * 1;
-    } else if (encodeMethod == "OCT2Byte") {
-      result = new Int16Array(count * 2);
-      for (let idx = 0; idx < array.length; idx += 3) {
-        const encoded = this.EncodingFuncs.octEncodeBest(array[idx], array[idx + 1], array[idx + 2], 2);
-        result[idx / 3 * 2 + 0] = encoded[0];
-        result[idx / 3 * 2 + 1] = encoded[1];
-      }
-      mesh.geometry.setAttribute("normal", new BufferAttribute(result, 2, true));
-      mesh.geometry.attributes.normal.bytes = result.length * 2;
-    } else if (encodeMethod == "ANGLES") {
-      result = new Uint16Array(count * 2);
-      for (let idx = 0; idx < array.length; idx += 3) {
-        const encoded = this.EncodingFuncs.anglesEncode(array[idx], array[idx + 1], array[idx + 2]);
-        result[idx / 3 * 2 + 0] = encoded[0];
-        result[idx / 3 * 2 + 1] = encoded[1];
-      }
-      mesh.geometry.setAttribute("normal", new BufferAttribute(result, 2, true));
-      mesh.geometry.attributes.normal.bytes = result.length * 2;
-    } else {
-      console.error("Unrecognized encoding method, should be `DEFAULT` or `ANGLES` or `OCT`. ");
-    }
-    mesh.geometry.attributes.normal.needsUpdate = true;
-    mesh.geometry.attributes.normal.isPacked = true;
-    mesh.geometry.attributes.normal.packingMethod = encodeMethod;
-    if (!(mesh.material instanceof PackedPhongMaterial)) {
-      mesh.material = new PackedPhongMaterial().copy(mesh.material);
-    }
-    if (encodeMethod == "ANGLES") {
-      mesh.material.defines.USE_PACKED_NORMAL = 0;
-    }
-    if (encodeMethod == "OCT1Byte") {
-      mesh.material.defines.USE_PACKED_NORMAL = 1;
-    }
-    if (encodeMethod == "OCT2Byte") {
-      mesh.material.defines.USE_PACKED_NORMAL = 1;
-    }
-    if (encodeMethod == "DEFAULT") {
-      mesh.material.defines.USE_PACKED_NORMAL = 2;
-    }
-  },
-  /**
-   * Make the input mesh.geometry's position attribute encoded and compressed.
-   * Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the position data.
-   *
-   * @param {THREE.Mesh} mesh
-   *
-   */
-  compressPositions: function(mesh) {
-    if (!mesh.geometry) {
-      console.error("Mesh must contain geometry. ");
-    }
-    const position = mesh.geometry.attributes.position;
-    if (!position) {
-      console.error("Geometry must contain position attribute. ");
-    }
-    if (position.isPacked)
-      return;
-    if (position.itemSize != 3) {
-      console.error("position.itemSize is not 3, which cannot be packed. ");
-    }
-    const array = position.array;
-    const encodingBytes = 2;
-    const result = this.EncodingFuncs.quantizedEncode(array, encodingBytes);
-    const quantized = result.quantized;
-    const decodeMat = result.decodeMat;
-    if (mesh.geometry.boundingBox == null)
-      mesh.geometry.computeBoundingBox();
-    if (mesh.geometry.boundingSphere == null)
-      mesh.geometry.computeBoundingSphere();
-    mesh.geometry.setAttribute("position", new BufferAttribute(quantized, 3));
-    mesh.geometry.attributes.position.isPacked = true;
-    mesh.geometry.attributes.position.needsUpdate = true;
-    mesh.geometry.attributes.position.bytes = quantized.length * encodingBytes;
-    if (!(mesh.material instanceof PackedPhongMaterial)) {
-      mesh.material = new PackedPhongMaterial().copy(mesh.material);
-    }
-    mesh.material.defines.USE_PACKED_POSITION = 0;
-    mesh.material.uniforms.quantizeMatPos.value = decodeMat;
-    mesh.material.uniforms.quantizeMatPos.needsUpdate = true;
-  },
-  /**
-   * Make the input mesh.geometry's uv attribute encoded and compressed.
-   * Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the uv data.
-   *
-   * @param {THREE.Mesh} mesh
-   *
-   */
-  compressUvs: function(mesh) {
-    if (!mesh.geometry) {
-      console.error("Mesh must contain geometry property. ");
-    }
-    const uvs = mesh.geometry.attributes.uv;
-    if (!uvs) {
-      console.error("Geometry must contain uv attribute. ");
-    }
-    if (uvs.isPacked)
-      return;
-    const range = { min: Infinity, max: -Infinity };
-    const array = uvs.array;
-    for (let i = 0; i < array.length; i++) {
-      range.min = Math.min(range.min, array[i]);
-      range.max = Math.max(range.max, array[i]);
-    }
-    let result;
-    if (range.min >= -1 && range.max <= 1) {
-      result = new Uint16Array(array.length);
-      for (let i = 0; i < array.length; i += 2) {
-        const encoded = this.EncodingFuncs.defaultEncode(array[i], array[i + 1], 0, 2);
-        result[i] = encoded[0];
-        result[i + 1] = encoded[1];
-      }
-      mesh.geometry.setAttribute("uv", new BufferAttribute(result, 2, true));
-      mesh.geometry.attributes.uv.isPacked = true;
-      mesh.geometry.attributes.uv.needsUpdate = true;
-      mesh.geometry.attributes.uv.bytes = result.length * 2;
-      if (!(mesh.material instanceof PackedPhongMaterial)) {
-        mesh.material = new PackedPhongMaterial().copy(mesh.material);
-      }
-      mesh.material.defines.USE_PACKED_UV = 0;
-    } else {
-      result = this.EncodingFuncs.quantizedEncodeUV(array, 2);
-      mesh.geometry.setAttribute("uv", new BufferAttribute(result.quantized, 2));
-      mesh.geometry.attributes.uv.isPacked = true;
-      mesh.geometry.attributes.uv.needsUpdate = true;
-      mesh.geometry.attributes.uv.bytes = result.quantized.length * 2;
-      if (!(mesh.material instanceof PackedPhongMaterial)) {
-        mesh.material = new PackedPhongMaterial().copy(mesh.material);
-      }
-      mesh.material.defines.USE_PACKED_UV = 1;
-      mesh.material.uniforms.quantizeMatUV.value = result.decodeMat;
-      mesh.material.uniforms.quantizeMatUV.needsUpdate = true;
-    }
-  },
-  EncodingFuncs: {
-    defaultEncode: function(x, y, z, bytes) {
-      if (bytes == 1) {
-        const tmpx = Math.round((x + 1) * 0.5 * 255);
-        const tmpy = Math.round((y + 1) * 0.5 * 255);
-        const tmpz = Math.round((z + 1) * 0.5 * 255);
-        return new Uint8Array([tmpx, tmpy, tmpz]);
-      } else if (bytes == 2) {
-        const tmpx = Math.round((x + 1) * 0.5 * 65535);
-        const tmpy = Math.round((y + 1) * 0.5 * 65535);
-        const tmpz = Math.round((z + 1) * 0.5 * 65535);
-        return new Uint16Array([tmpx, tmpy, tmpz]);
-      } else {
-        console.error("number of bytes must be 1 or 2");
-      }
-    },
-    defaultDecode: function(array, bytes) {
-      if (bytes == 1) {
-        return [array[0] / 255 * 2 - 1, array[1] / 255 * 2 - 1, array[2] / 255 * 2 - 1];
-      } else if (bytes == 2) {
-        return [array[0] / 65535 * 2 - 1, array[1] / 65535 * 2 - 1, array[2] / 65535 * 2 - 1];
-      } else {
-        console.error("number of bytes must be 1 or 2");
-      }
-    },
-    // for `Angles` encoding
-    anglesEncode: function(x, y, z) {
-      const normal0 = parseInt(0.5 * (1 + Math.atan2(y, x) / Math.PI) * 65535);
-      const normal1 = parseInt(0.5 * (1 + z) * 65535);
-      return new Uint16Array([normal0, normal1]);
-    },
-    // for `Octahedron` encoding
-    octEncodeBest: function(x, y, z, bytes) {
-      var oct, dec, best, currentCos, bestCos;
-      best = oct = octEncodeVec3(x, y, z, "floor", "floor");
-      dec = octDecodeVec2(oct);
-      bestCos = dot(x, y, z, dec);
-      oct = octEncodeVec3(x, y, z, "ceil", "floor");
-      dec = octDecodeVec2(oct);
-      currentCos = dot(x, y, z, dec);
-      if (currentCos > bestCos) {
-        best = oct;
-        bestCos = currentCos;
-      }
-      oct = octEncodeVec3(x, y, z, "floor", "ceil");
-      dec = octDecodeVec2(oct);
-      currentCos = dot(x, y, z, dec);
-      if (currentCos > bestCos) {
-        best = oct;
-        bestCos = currentCos;
-      }
-      oct = octEncodeVec3(x, y, z, "ceil", "ceil");
-      dec = octDecodeVec2(oct);
-      currentCos = dot(x, y, z, dec);
-      if (currentCos > bestCos) {
-        best = oct;
-      }
-      return best;
-      function octEncodeVec3(x0, y0, z0, xfunc, yfunc) {
-        var x2 = x0 / (Math.abs(x0) + Math.abs(y0) + Math.abs(z0));
-        var y2 = y0 / (Math.abs(x0) + Math.abs(y0) + Math.abs(z0));
-        if (z < 0) {
-          var tempx = (1 - Math.abs(y2)) * (x2 >= 0 ? 1 : -1);
-          var tempy = (1 - Math.abs(x2)) * (y2 >= 0 ? 1 : -1);
-          x2 = tempx;
-          y2 = tempy;
-          var diff = 1 - Math.abs(x2) - Math.abs(y2);
-          if (diff > 0) {
-            diff += 1e-3;
-            x2 += x2 > 0 ? diff / 2 : -diff / 2;
-            y2 += y2 > 0 ? diff / 2 : -diff / 2;
-          }
-        }
-        if (bytes == 1) {
-          return new Int8Array([Math[xfunc](x2 * 127.5 + (x2 < 0 ? 1 : 0)), Math[yfunc](y2 * 127.5 + (y2 < 0 ? 1 : 0))]);
-        }
-        if (bytes == 2) {
-          return new Int16Array([
-            Math[xfunc](x2 * 32767.5 + (x2 < 0 ? 1 : 0)),
-            Math[yfunc](y2 * 32767.5 + (y2 < 0 ? 1 : 0))
-          ]);
-        }
-      }
-      function octDecodeVec2(oct2) {
-        var x2 = oct2[0];
-        var y2 = oct2[1];
-        if (bytes == 1) {
-          x2 /= x2 < 0 ? 127 : 128;
-          y2 /= y2 < 0 ? 127 : 128;
-        } else if (bytes == 2) {
-          x2 /= x2 < 0 ? 32767 : 32768;
-          y2 /= y2 < 0 ? 32767 : 32768;
-        }
-        var z2 = 1 - Math.abs(x2) - Math.abs(y2);
-        if (z2 < 0) {
-          var tmpx = x2;
-          x2 = (1 - Math.abs(y2)) * (x2 >= 0 ? 1 : -1);
-          y2 = (1 - Math.abs(tmpx)) * (y2 >= 0 ? 1 : -1);
-        }
-        var length = Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2);
-        return [x2 / length, y2 / length, z2 / length];
-      }
-      function dot(x2, y2, z2, vec3) {
-        return x2 * vec3[0] + y2 * vec3[1] + z2 * vec3[2];
-      }
-    },
-    quantizedEncode: function(array, bytes) {
-      let quantized, segments;
-      if (bytes == 1) {
-        quantized = new Uint8Array(array.length);
-        segments = 255;
-      } else if (bytes == 2) {
-        quantized = new Uint16Array(array.length);
-        segments = 65535;
-      } else {
-        console.error("number of bytes error! ");
-      }
-      const decodeMat = new Matrix4();
-      const min = new Float32Array(3);
-      const max = new Float32Array(3);
-      min[0] = min[1] = min[2] = Number.MAX_VALUE;
-      max[0] = max[1] = max[2] = -Number.MAX_VALUE;
-      for (let i = 0; i < array.length; i += 3) {
-        min[0] = Math.min(min[0], array[i + 0]);
-        min[1] = Math.min(min[1], array[i + 1]);
-        min[2] = Math.min(min[2], array[i + 2]);
-        max[0] = Math.max(max[0], array[i + 0]);
-        max[1] = Math.max(max[1], array[i + 1]);
-        max[2] = Math.max(max[2], array[i + 2]);
-      }
-      decodeMat.scale(
-        new Vector3((max[0] - min[0]) / segments, (max[1] - min[1]) / segments, (max[2] - min[2]) / segments)
-      );
-      decodeMat.elements[12] = min[0];
-      decodeMat.elements[13] = min[1];
-      decodeMat.elements[14] = min[2];
-      decodeMat.transpose();
-      const multiplier = new Float32Array([
-        max[0] !== min[0] ? segments / (max[0] - min[0]) : 0,
-        max[1] !== min[1] ? segments / (max[1] - min[1]) : 0,
-        max[2] !== min[2] ? segments / (max[2] - min[2]) : 0
-      ]);
-      for (let i = 0; i < array.length; i += 3) {
-        quantized[i + 0] = Math.floor((array[i + 0] - min[0]) * multiplier[0]);
-        quantized[i + 1] = Math.floor((array[i + 1] - min[1]) * multiplier[1]);
-        quantized[i + 2] = Math.floor((array[i + 2] - min[2]) * multiplier[2]);
-      }
-      return {
-        quantized,
-        decodeMat
-      };
-    },
-    quantizedEncodeUV: function(array, bytes) {
-      let quantized, segments;
-      if (bytes == 1) {
-        quantized = new Uint8Array(array.length);
-        segments = 255;
-      } else if (bytes == 2) {
-        quantized = new Uint16Array(array.length);
-        segments = 65535;
-      } else {
-        console.error("number of bytes error! ");
-      }
-      const decodeMat = new Matrix3();
-      const min = new Float32Array(2);
-      const max = new Float32Array(2);
-      min[0] = min[1] = Number.MAX_VALUE;
-      max[0] = max[1] = -Number.MAX_VALUE;
-      for (let i = 0; i < array.length; i += 2) {
-        min[0] = Math.min(min[0], array[i + 0]);
-        min[1] = Math.min(min[1], array[i + 1]);
-        max[0] = Math.max(max[0], array[i + 0]);
-        max[1] = Math.max(max[1], array[i + 1]);
-      }
-      decodeMat.scale((max[0] - min[0]) / segments, (max[1] - min[1]) / segments);
-      decodeMat.elements[6] = min[0];
-      decodeMat.elements[7] = min[1];
-      decodeMat.transpose();
-      const multiplier = new Float32Array([
-        max[0] !== min[0] ? segments / (max[0] - min[0]) : 0,
-        max[1] !== min[1] ? segments / (max[1] - min[1]) : 0
-      ]);
-      for (let i = 0; i < array.length; i += 2) {
-        quantized[i + 0] = Math.floor((array[i + 0] - min[0]) * multiplier[0]);
-        quantized[i + 1] = Math.floor((array[i + 1] - min[1]) * multiplier[1]);
-      }
-      return {
-        quantized,
-        decodeMat
-      };
-    }
-  }
-};
-class PackedPhongMaterial extends MeshPhongMaterial {
-  constructor(parameters) {
-    super();
-    this.defines = {};
-    this.type = "PackedPhongMaterial";
-    this.uniforms = UniformsUtils.merge([
-      ShaderLib.phong.uniforms,
-      {
-        quantizeMatPos: { value: null },
-        quantizeMatUV: { value: null }
-      }
-    ]);
-    this.vertexShader = [
-      "#define PHONG",
-      "varying vec3 vViewPosition;",
-      "#ifndef FLAT_SHADED",
-      "varying vec3 vNormal;",
-      "#endif",
-      ShaderChunk.common,
-      ShaderChunk.uv_pars_vertex,
-      ShaderChunk.uv2_pars_vertex,
-      ShaderChunk.displacementmap_pars_vertex,
-      ShaderChunk.envmap_pars_vertex,
-      ShaderChunk.color_pars_vertex,
-      ShaderChunk.fog_pars_vertex,
-      ShaderChunk.morphtarget_pars_vertex,
-      ShaderChunk.skinning_pars_vertex,
-      ShaderChunk.shadowmap_pars_vertex,
-      ShaderChunk.logdepthbuf_pars_vertex,
-      ShaderChunk.clipping_planes_pars_vertex,
-      `#ifdef USE_PACKED_NORMAL
-					#if USE_PACKED_NORMAL == 0
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							float x = packedNormal.x * 2.0 - 1.0;
-							float y = packedNormal.y * 2.0 - 1.0;
-							vec2 scth = vec2(sin(x * PI), cos(x * PI));
-							vec2 scphi = vec2(sqrt(1.0 - y * y), y);
-							return normalize( vec3(scth.y * scphi.x, scth.x * scphi.x, scphi.y) );
-						}
-					#endif
-
-					#if USE_PACKED_NORMAL == 1
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							vec3 v = vec3(packedNormal.xy, 1.0 - abs(packedNormal.x) - abs(packedNormal.y));
-							if (v.z < 0.0)
-							{
-								v.xy = (1.0 - abs(v.yx)) * vec2((v.x >= 0.0) ? +1.0 : -1.0, (v.y >= 0.0) ? +1.0 : -1.0);
-							}
-							return normalize(v);
-						}
-					#endif
-
-					#if USE_PACKED_NORMAL == 2
-						vec3 decodeNormal(vec3 packedNormal)
-						{
-							vec3 v = (packedNormal * 2.0) - 1.0;
-							return normalize(v);
-						}
-					#endif
-				#endif`,
-      `#ifdef USE_PACKED_POSITION
-					#if USE_PACKED_POSITION == 0
-						uniform mat4 quantizeMatPos;
-					#endif
-				#endif`,
-      `#ifdef USE_PACKED_UV
-					#if USE_PACKED_UV == 1
-						uniform mat3 quantizeMatUV;
-					#endif
-				#endif`,
-      `#ifdef USE_PACKED_UV
-					#if USE_PACKED_UV == 0
-						vec2 decodeUV(vec2 packedUV)
-						{
-							vec2 uv = (packedUV * 2.0) - 1.0;
-							return uv;
-						}
-					#endif
-
-					#if USE_PACKED_UV == 1
-						vec2 decodeUV(vec2 packedUV)
-						{
-							vec2 uv = ( vec3(packedUV, 1.0) * quantizeMatUV ).xy;
-							return uv;
-						}
-					#endif
-				#endif`,
-      "void main() {",
-      ShaderChunk.uv_vertex,
-      `#ifdef USE_UV
-					#ifdef USE_PACKED_UV
-						vUv = decodeUV(vUv);
-					#endif
-				#endif`,
-      ShaderChunk.uv2_vertex,
-      ShaderChunk.color_vertex,
-      ShaderChunk.beginnormal_vertex,
-      `#ifdef USE_PACKED_NORMAL
-					objectNormal = decodeNormal(objectNormal);
-				#endif
-
-				#ifdef USE_TANGENT
-					vec3 objectTangent = vec3( tangent.xyz );
-				#endif
-				`,
-      ShaderChunk.morphnormal_vertex,
-      ShaderChunk.skinbase_vertex,
-      ShaderChunk.skinnormal_vertex,
-      ShaderChunk.defaultnormal_vertex,
-      "#ifndef FLAT_SHADED",
-      "	vNormal = normalize( transformedNormal );",
-      "#endif",
-      ShaderChunk.begin_vertex,
-      `#ifdef USE_PACKED_POSITION
-					#if USE_PACKED_POSITION == 0
-						transformed = ( vec4(transformed, 1.0) * quantizeMatPos ).xyz;
-					#endif
-				#endif`,
-      ShaderChunk.morphtarget_vertex,
-      ShaderChunk.skinning_vertex,
-      ShaderChunk.displacementmap_vertex,
-      ShaderChunk.project_vertex,
-      ShaderChunk.logdepthbuf_vertex,
-      ShaderChunk.clipping_planes_vertex,
-      "vViewPosition = - mvPosition.xyz;",
-      ShaderChunk.worldpos_vertex,
-      ShaderChunk.envmap_vertex,
-      ShaderChunk.shadowmap_vertex,
-      ShaderChunk.fog_vertex,
-      "}"
-    ].join("\n");
-    this.fragmentShader = [
-      "#define PHONG",
-      "uniform vec3 diffuse;",
-      "uniform vec3 emissive;",
-      "uniform vec3 specular;",
-      "uniform float shininess;",
-      "uniform float opacity;",
-      ShaderChunk.common,
-      ShaderChunk.packing,
-      ShaderChunk.dithering_pars_fragment,
-      ShaderChunk.color_pars_fragment,
-      ShaderChunk.uv_pars_fragment,
-      ShaderChunk.uv2_pars_fragment,
-      ShaderChunk.map_pars_fragment,
-      ShaderChunk.alphamap_pars_fragment,
-      ShaderChunk.aomap_pars_fragment,
-      ShaderChunk.lightmap_pars_fragment,
-      ShaderChunk.emissivemap_pars_fragment,
-      ShaderChunk.envmap_common_pars_fragment,
-      ShaderChunk.envmap_pars_fragment,
-      ShaderChunk.cube_uv_reflection_fragment,
-      ShaderChunk.fog_pars_fragment,
-      ShaderChunk.bsdfs,
-      ShaderChunk.lights_pars_begin,
-      ShaderChunk.lights_phong_pars_fragment,
-      ShaderChunk.shadowmap_pars_fragment,
-      ShaderChunk.bumpmap_pars_fragment,
-      ShaderChunk.normalmap_pars_fragment,
-      ShaderChunk.specularmap_pars_fragment,
-      ShaderChunk.logdepthbuf_pars_fragment,
-      ShaderChunk.clipping_planes_pars_fragment,
-      "void main() {",
-      ShaderChunk.clipping_planes_fragment,
-      "vec4 diffuseColor = vec4( diffuse, opacity );",
-      "ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );",
-      "vec3 totalEmissiveRadiance = emissive;",
-      ShaderChunk.logdepthbuf_fragment,
-      ShaderChunk.map_fragment,
-      ShaderChunk.color_fragment,
-      ShaderChunk.alphamap_fragment,
-      ShaderChunk.alphatest_fragment,
-      ShaderChunk.specularmap_fragment,
-      ShaderChunk.normal_fragment_begin,
-      ShaderChunk.normal_fragment_maps,
-      ShaderChunk.emissivemap_fragment,
-      // accumulation
-      ShaderChunk.lights_phong_fragment,
-      ShaderChunk.lights_fragment_begin,
-      ShaderChunk.lights_fragment_maps,
-      ShaderChunk.lights_fragment_end,
-      // modulation
-      ShaderChunk.aomap_fragment,
-      "vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;",
-      ShaderChunk.envmap_fragment,
-      "gl_FragColor = vec4( outgoingLight, diffuseColor.a );",
-      ShaderChunk.tonemapping_fragment,
-      parseInt(REVISION.replace(/\D+/g, "")) >= 154 ? ShaderChunk.colorspace_fragment : ShaderChunk.encodings_fragment,
-      ShaderChunk.fog_fragment,
-      ShaderChunk.premultiplied_alpha_fragment,
-      ShaderChunk.dithering_fragment,
-      "}"
-    ].join("\n");
-    this.setValues(parameters);
-  }
-}
-export {
-  GeometryCompressionUtils,
-  PackedPhongMaterial
-};

package/utils/GeometryUtils.cjs

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const hilbert2D = (center = new THREE.Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3) => {
-  const half = size / 2;
-  const vec_s = [
-    new THREE.Vector3(center.x - half, center.y, center.z - half),
-    new THREE.Vector3(center.x - half, center.y, center.z + half),
-    new THREE.Vector3(center.x + half, center.y, center.z + half),
-    new THREE.Vector3(center.x + half, center.y, center.z - half)
-  ];
-  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3]];
-  if (0 <= --iterations) {
-    const tmp = [];
-    Array.prototype.push.apply(tmp, hilbert2D(vec[0], half, iterations, v0, v3, v2, v1));
-    Array.prototype.push.apply(tmp, hilbert2D(vec[1], half, iterations, v0, v1, v2, v3));
-    Array.prototype.push.apply(tmp, hilbert2D(vec[2], half, iterations, v0, v1, v2, v3));
-    Array.prototype.push.apply(tmp, hilbert2D(vec[3], half, iterations, v2, v1, v0, v3));
-    return tmp;
-  }
-  return vec;
-};
-const hilbert3D = (center = new THREE.Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7) => {
-  const half = size / 2;
-  const vec_s = [
-    new THREE.Vector3(center.x - half, center.y + half, center.z - half),
-    new THREE.Vector3(center.x - half, center.y + half, center.z + half),
-    new THREE.Vector3(center.x - half, center.y - half, center.z + half),
-    new THREE.Vector3(center.x - half, center.y - half, center.z - half),
-    new THREE.Vector3(center.x + half, center.y - half, center.z - half),
-    new THREE.Vector3(center.x + half, center.y - half, center.z + half),
-    new THREE.Vector3(center.x + half, center.y + half, center.z + half),
-    new THREE.Vector3(center.x + half, center.y + half, center.z - half)
-  ];
-  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3], vec_s[v4], vec_s[v5], vec_s[v6], vec_s[v7]];
-  if (--iterations >= 0) {
-    const tmp = [];
-    Array.prototype.push.apply(tmp, hilbert3D(vec[0], half, iterations, v0, v3, v4, v7, v6, v5, v2, v1));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[1], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[2], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[3], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[4], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[5], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[6], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[7], half, iterations, v6, v5, v2, v1, v0, v3, v4, v7));
-    return tmp;
-  }
-  return vec;
-};
-const gosper = (size = 1) => {
-  function fractalize(config) {
-    let output = "";
-    let input = config.axiom;
-    for (let i = 0, il = config.steps; 0 <= il ? i < il : i > il; 0 <= il ? i++ : i--) {
-      output = "";
-      for (let j = 0, jl = input.length; j < jl; j++) {
-        const char = input[j];
-        if (char in config.rules) {
-          output += config.rules[char];
-        } else {
-          output += char;
-        }
-      }
-      input = output;
-    }
-    return output;
-  }
-  function toPoints(config) {
-    let currX = 0;
-    let currY = 0;
-    let angle = 0;
-    const path = [0, 0, 0];
-    const fractal = config.fractal;
-    for (let i = 0, l = fractal.length; i < l; i++) {
-      const char = fractal[i];
-      if (char === "+") {
-        angle += config.angle;
-      } else if (char === "-") {
-        angle -= config.angle;
-      } else if (char === "F") {
-        currX += config.size * Math.cos(angle);
-        currY += -config.size * Math.sin(angle);
-        path.push(currX, currY, 0);
-      }
-    }
-    return path;
-  }
-  const gosper2 = fractalize({
-    axiom: "A",
-    steps: 4,
-    rules: {
-      A: "A+BF++BF-FA--FAFA-BF+",
-      B: "-FA+BFBF++BF+FA--FA-B"
-    }
-  });
-  const points = toPoints({
-    fractal: gosper2,
-    size,
-    angle: Math.PI / 3
-    // 60 degrees
-  });
-  return points;
-};
-const GeometryUtils = {
-  hilbert3D,
-  gosper,
-  hilbert2D
-};
-exports.GeometryUtils = GeometryUtils;