three-stdlib 2.16.0 → 2.16.2

package/utils/RoughnessMipmapper.mjs

@@ -1,213 +0,0 @@
-import { Mesh, PlaneGeometry, OrthographicCamera, MathUtils, WebGLRenderTarget, Vector2, RawShaderMaterial, NoBlending } from "three";
-var _mipmapMaterial = _getMipmapMaterial();
-var _mesh = new Mesh(new PlaneGeometry(2, 2), _mipmapMaterial);
-var _flatCamera = new OrthographicCamera(0, 1, 0, 1, 0, 1);
-var _tempTarget = null;
-var _renderer = null;
-function RoughnessMipmapper(renderer) {
-  _renderer = renderer;
-  _renderer.compile(_mesh, _flatCamera);
-}
-RoughnessMipmapper.prototype = {
-  constructor: RoughnessMipmapper,
-  generateMipmaps: function(material) {
-    if ("roughnessMap" in material === false)
-      return;
-    var { roughnessMap, normalMap } = material;
-    if (roughnessMap === null || normalMap === null || !roughnessMap.generateMipmaps || material.userData.roughnessUpdated) {
-      return;
-    }
-    material.userData.roughnessUpdated = true;
-    var width = Math.max(roughnessMap.image.width, normalMap.image.width);
-    var height = Math.max(roughnessMap.image.height, normalMap.image.height);
-    if (!MathUtils.isPowerOfTwo(width) || !MathUtils.isPowerOfTwo(height))
-      return;
-    var oldTarget = _renderer.getRenderTarget();
-    var autoClear = _renderer.autoClear;
-    _renderer.autoClear = false;
-    if (_tempTarget === null || _tempTarget.width !== width || _tempTarget.height !== height) {
-      if (_tempTarget !== null)
-        _tempTarget.dispose();
-      _tempTarget = new WebGLRenderTarget(width, height, {
-        depthBuffer: false
-      });
-      _tempTarget.scissorTest = true;
-    }
-    if (width !== roughnessMap.image.width || height !== roughnessMap.image.height) {
-      var params = {
-        wrapS: roughnessMap.wrapS,
-        wrapT: roughnessMap.wrapT,
-        magFilter: roughnessMap.magFilter,
-        minFilter: roughnessMap.minFilter,
-        depthBuffer: false
-      };
-      var newRoughnessTarget = new WebGLRenderTarget(width, height, params);
-      newRoughnessTarget.texture.generateMipmaps = true;
-      _renderer.setRenderTarget(newRoughnessTarget);
-      material.roughnessMap = newRoughnessTarget.texture;
-      if (material.metalnessMap == roughnessMap)
-        material.metalnessMap = material.roughnessMap;
-      if (material.aoMap == roughnessMap)
-        material.aoMap = material.roughnessMap;
-    }
-    _mipmapMaterial.uniforms.roughnessMap.value = roughnessMap;
-    _mipmapMaterial.uniforms.normalMap.value = normalMap;
-    var position = new Vector2(0, 0);
-    var texelSize = _mipmapMaterial.uniforms.texelSize.value;
-    for (let mip = 0; width >= 1 && height >= 1; ++mip, width /= 2, height /= 2) {
-      texelSize.set(1 / width, 1 / height);
-      if (mip == 0)
-        texelSize.set(0, 0);
-      _tempTarget.viewport.set(position.x, position.y, width, height);
-      _tempTarget.scissor.set(position.x, position.y, width, height);
-      _renderer.setRenderTarget(_tempTarget);
-      _renderer.render(_mesh, _flatCamera);
-      _renderer.copyFramebufferToTexture(position, material.roughnessMap, mip);
-      _mipmapMaterial.uniforms.roughnessMap.value = material.roughnessMap;
-    }
-    if (roughnessMap !== material.roughnessMap)
-      roughnessMap.dispose();
-    _renderer.setRenderTarget(oldTarget);
-    _renderer.autoClear = autoClear;
-  },
-  dispose: function() {
-    _mipmapMaterial.dispose();
-    _mesh.geometry.dispose();
-    if (_tempTarget != null)
-      _tempTarget.dispose();
-  }
-};
-function _getMipmapMaterial() {
-  var shaderMaterial = new RawShaderMaterial({
-    uniforms: {
-      roughnessMap: { value: null },
-      normalMap: { value: null },
-      texelSize: { value: new Vector2(1, 1) }
-    },
-    vertexShader: `
-			precision mediump float;
-			precision mediump int;
-
-			attribute vec3 position;
-			attribute vec2 uv;
-
-			varying vec2 vUv;
-
-			void main() {
-
-				vUv = uv;
-
-				gl_Position = vec4( position, 1.0 );
-
-			}
-		`,
-    fragmentShader: `
-			precision mediump float;
-			precision mediump int;
-
-			varying vec2 vUv;
-
-			uniform sampler2D roughnessMap;
-			uniform sampler2D normalMap;
-			uniform vec2 texelSize;
-
-			#define ENVMAP_TYPE_CUBE_UV
-
-			vec4 envMapTexelToLinear( vec4 a ) { return a; }
-
-			#include <cube_uv_reflection_fragment>
-
-			float roughnessToVariance( float roughness ) {
-
-				float variance = 0.0;
-
-				if ( roughness >= r1 ) {
-
-					variance = ( r0 - roughness ) * ( v1 - v0 ) / ( r0 - r1 ) + v0;
-
-				} else if ( roughness >= r4 ) {
-
-					variance = ( r1 - roughness ) * ( v4 - v1 ) / ( r1 - r4 ) + v1;
-
-				} else if ( roughness >= r5 ) {
-
-					variance = ( r4 - roughness ) * ( v5 - v4 ) / ( r4 - r5 ) + v4;
-
-				} else {
-
-					float roughness2 = roughness * roughness;
-
-					variance = 1.79 * roughness2 * roughness2;
-
-				}
-
-				return variance;
-
-			}
-
-			float varianceToRoughness( float variance ) {
-
-				float roughness = 0.0;
-
-				if ( variance >= v1 ) {
-
-					roughness = ( v0 - variance ) * ( r1 - r0 ) / ( v0 - v1 ) + r0;
-
-				} else if ( variance >= v4 ) {
-
-					roughness = ( v1 - variance ) * ( r4 - r1 ) / ( v1 - v4 ) + r1;
-
-				} else if ( variance >= v5 ) {
-
-					roughness = ( v4 - variance ) * ( r5 - r4 ) / ( v4 - v5 ) + r4;
-
-				} else {
-
-					roughness = pow( 0.559 * variance, 0.25 ); // 0.559 = 1.0 / 1.79
-
-				}
-
-				return roughness;
-
-			}
-
-			void main() {
-
-				gl_FragColor = texture2D( roughnessMap, vUv, - 1.0 );
-
-				if ( texelSize.x == 0.0 ) return;
-
-				float roughness = gl_FragColor.g;
-
-				float variance = roughnessToVariance( roughness );
-
-				vec3 avgNormal;
-
-				for ( float x = - 1.0; x < 2.0; x += 2.0 ) {
-
-					for ( float y = - 1.0; y < 2.0; y += 2.0 ) {
-
-						vec2 uv = vUv + vec2( x, y ) * 0.25 * texelSize;
-
-						avgNormal += normalize( texture2D( normalMap, uv, - 1.0 ).xyz - 0.5 );
-
-					}
-
-				}
-
-				variance += 1.0 - 0.25 * length( avgNormal );
-
-				gl_FragColor.g = varianceToRoughness( variance );
-
-			}
-		`,
-    blending: NoBlending,
-    depthTest: false,
-    depthWrite: false
-  });
-  shaderMaterial.type = "RoughnessMipmapper";
-  return shaderMaterial;
-}
-export {
-  RoughnessMipmapper
-};

package/utils/SceneUtils.mjs

@@ -1,36 +0,0 @@
-import { Group, Mesh } from "three";
-const SceneUtils = {
-  createMeshesFromInstancedMesh: function(instancedMesh) {
-    const group = new Group();
-    const count = instancedMesh.count;
-    const geometry = instancedMesh.geometry;
-    const material = instancedMesh.material;
-    for (let i = 0; i < count; i++) {
-      const mesh = new Mesh(geometry, material);
-      instancedMesh.getMatrixAt(i, mesh.matrix);
-      mesh.matrix.decompose(mesh.position, mesh.quaternion, mesh.scale);
-      group.add(mesh);
-    }
-    group.copy(instancedMesh);
-    group.updateMatrixWorld();
-    return group;
-  },
-  createMultiMaterialObject: function(geometry, materials) {
-    const group = new Group();
-    for (let i = 0, l = materials.length; i < l; i++) {
-      group.add(new Mesh(geometry, materials[i]));
-    }
-    return group;
-  },
-  detach: function(child, parent, scene) {
-    console.warn("THREE.SceneUtils: detach() has been deprecated. Use scene.attach( child ) instead.");
-    scene.attach(child);
-  },
-  attach: function(child, scene, parent) {
-    console.warn("THREE.SceneUtils: attach() has been deprecated. Use parent.attach( child ) instead.");
-    parent.attach(child);
-  }
-};
-export {
-  SceneUtils
-};

package/utils/ShadowMapViewer.mjs

@@ -1,114 +0,0 @@
-import { OrthographicCamera, Scene, UniformsUtils, ShaderMaterial, PlaneGeometry, Mesh, Texture, LinearFilter, MeshBasicMaterial, DoubleSide } from "three";
-import { UnpackDepthRGBAShader } from "../shaders/UnpackDepthRGBAShader.mjs";
-var ShadowMapViewer = function(light) {
-  var scope = this;
-  var doRenderLabel = light.name !== void 0 && light.name !== "";
-  var userAutoClearSetting;
-  var frame = {
-    x: 10,
-    y: 10,
-    width: 256,
-    height: 256
-  };
-  var camera = new OrthographicCamera(
-    window.innerWidth / -2,
-    window.innerWidth / 2,
-    window.innerHeight / 2,
-    window.innerHeight / -2,
-    1,
-    10
-  );
-  camera.position.set(0, 0, 2);
-  var scene = new Scene();
-  var shader = UnpackDepthRGBAShader;
-  var uniforms = UniformsUtils.clone(shader.uniforms);
-  var material = new ShaderMaterial({
-    uniforms,
-    vertexShader: shader.vertexShader,
-    fragmentShader: shader.fragmentShader
-  });
-  var plane = new PlaneGeometry(frame.width, frame.height);
-  var mesh = new Mesh(plane, material);
-  scene.add(mesh);
-  var labelCanvas, labelMesh;
-  if (doRenderLabel) {
-    labelCanvas = document.createElement("canvas");
-    var context = labelCanvas.getContext("2d");
-    context.font = "Bold 20px Arial";
-    var labelWidth = context.measureText(light.name).width;
-    labelCanvas.width = labelWidth;
-    labelCanvas.height = 25;
-    context.font = "Bold 20px Arial";
-    context.fillStyle = "rgba( 255, 0, 0, 1 )";
-    context.fillText(light.name, 0, 20);
-    var labelTexture = new Texture(labelCanvas);
-    labelTexture.magFilter = LinearFilter;
-    labelTexture.minFilter = LinearFilter;
-    labelTexture.needsUpdate = true;
-    var labelMaterial = new MeshBasicMaterial({
-      map: labelTexture,
-      side: DoubleSide
-    });
-    labelMaterial.transparent = true;
-    var labelPlane = new PlaneGeometry(labelCanvas.width, labelCanvas.height);
-    labelMesh = new Mesh(labelPlane, labelMaterial);
-    scene.add(labelMesh);
-  }
-  function resetPosition() {
-    scope.position.set(scope.position.x, scope.position.y);
-  }
-  this.enabled = true;
-  this.size = {
-    width: frame.width,
-    height: frame.height,
-    set: function(width, height) {
-      this.width = width;
-      this.height = height;
-      mesh.scale.set(this.width / frame.width, this.height / frame.height, 1);
-      resetPosition();
-    }
-  };
-  this.position = {
-    x: frame.x,
-    y: frame.y,
-    set: function(x, y) {
-      this.x = x;
-      this.y = y;
-      var width = scope.size.width;
-      var height = scope.size.height;
-      mesh.position.set(-window.innerWidth / 2 + width / 2 + this.x, window.innerHeight / 2 - height / 2 - this.y, 0);
-      if (doRenderLabel) {
-        labelMesh.position.set(mesh.position.x, mesh.position.y - scope.size.height / 2 + labelCanvas.height / 2, 0);
-      }
-    }
-  };
-  this.render = function(renderer) {
-    if (this.enabled) {
-      uniforms.tDiffuse.value = light.shadow.map.texture;
-      userAutoClearSetting = renderer.autoClear;
-      renderer.autoClear = false;
-      renderer.clearDepth();
-      renderer.render(scene, camera);
-      renderer.autoClear = userAutoClearSetting;
-    }
-  };
-  this.updateForWindowResize = function() {
-    if (this.enabled) {
-      camera.left = window.innerWidth / -2;
-      camera.right = window.innerWidth / 2;
-      camera.top = window.innerHeight / 2;
-      camera.bottom = window.innerHeight / -2;
-      camera.updateProjectionMatrix();
-      this.update();
-    }
-  };
-  this.update = function() {
-    this.position.set(this.position.x, this.position.y);
-    this.size.set(this.size.width, this.size.height);
-  };
-  this.update();
-};
-ShadowMapViewer.prototype.constructor = ShadowMapViewer;
-export {
-  ShadowMapViewer
-};

package/utils/SkeletonUtils.mjs

@@ -1,292 +0,0 @@
-import { Vector3, Quaternion, Matrix4, AnimationMixer, VectorKeyframeTrack, QuaternionKeyframeTrack, AnimationClip, SkeletonHelper, Vector2, Euler } from "three";
-var SkeletonUtils = {
-  retarget: function() {
-    var pos = new Vector3(), quat = new Quaternion(), scale = new Vector3(), bindBoneMatrix = new Matrix4(), relativeMatrix = new Matrix4(), globalMatrix = new Matrix4();
-    return function(target, source, options) {
-      options = options || {};
-      options.preserveMatrix = options.preserveMatrix !== void 0 ? options.preserveMatrix : true;
-      options.preservePosition = options.preservePosition !== void 0 ? options.preservePosition : true;
-      options.preserveHipPosition = options.preserveHipPosition !== void 0 ? options.preserveHipPosition : false;
-      options.useTargetMatrix = options.useTargetMatrix !== void 0 ? options.useTargetMatrix : false;
-      options.hip = options.hip !== void 0 ? options.hip : "hip";
-      options.names = options.names || {};
-      var sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source), bones = target.isObject3D ? target.skeleton.bones : this.getBones(target), bindBones, bone, name, boneTo, bonesPosition, i;
-      if (target.isObject3D) {
-        target.skeleton.pose();
-      } else {
-        options.useTargetMatrix = true;
-        options.preserveMatrix = false;
-      }
-      if (options.preservePosition) {
-        bonesPosition = [];
-        for (i = 0; i < bones.length; i++) {
-          bonesPosition.push(bones[i].position.clone());
-        }
-      }
-      if (options.preserveMatrix) {
-        target.updateMatrixWorld();
-        target.matrixWorld.identity();
-        for (i = 0; i < target.children.length; ++i) {
-          target.children[i].updateMatrixWorld(true);
-        }
-      }
-      if (options.offsets) {
-        bindBones = [];
-        for (i = 0; i < bones.length; ++i) {
-          bone = bones[i];
-          name = options.names[bone.name] || bone.name;
-          if (options.offsets && options.offsets[name]) {
-            bone.matrix.multiply(options.offsets[name]);
-            bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
-            bone.updateMatrixWorld();
-          }
-          bindBones.push(bone.matrixWorld.clone());
-        }
-      }
-      for (i = 0; i < bones.length; ++i) {
-        bone = bones[i];
-        name = options.names[bone.name] || bone.name;
-        boneTo = this.getBoneByName(name, sourceBones);
-        globalMatrix.copy(bone.matrixWorld);
-        if (boneTo) {
-          boneTo.updateMatrixWorld();
-          if (options.useTargetMatrix) {
-            relativeMatrix.copy(boneTo.matrixWorld);
-          } else {
-            relativeMatrix.copy(target.matrixWorld).invert();
-            relativeMatrix.multiply(boneTo.matrixWorld);
-          }
-          scale.setFromMatrixScale(relativeMatrix);
-          relativeMatrix.scale(scale.set(1 / scale.x, 1 / scale.y, 1 / scale.z));
-          globalMatrix.makeRotationFromQuaternion(quat.setFromRotationMatrix(relativeMatrix));
-          if (target.isObject3D) {
-            var boneIndex = bones.indexOf(bone), wBindMatrix = bindBones ? bindBones[boneIndex] : bindBoneMatrix.copy(target.skeleton.boneInverses[boneIndex]).invert();
-            globalMatrix.multiply(wBindMatrix);
-          }
-          globalMatrix.copyPosition(relativeMatrix);
-        }
-        if (bone.parent && bone.parent.isBone) {
-          bone.matrix.copy(bone.parent.matrixWorld).invert();
-          bone.matrix.multiply(globalMatrix);
-        } else {
-          bone.matrix.copy(globalMatrix);
-        }
-        if (options.preserveHipPosition && name === options.hip) {
-          bone.matrix.setPosition(pos.set(0, bone.position.y, 0));
-        }
-        bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
-        bone.updateMatrixWorld();
-      }
-      if (options.preservePosition) {
-        for (i = 0; i < bones.length; ++i) {
-          bone = bones[i];
-          name = options.names[bone.name] || bone.name;
-          if (name !== options.hip) {
-            bone.position.copy(bonesPosition[i]);
-          }
-        }
-      }
-      if (options.preserveMatrix) {
-        target.updateMatrixWorld(true);
-      }
-    };
-  }(),
-  retargetClip: function(target, source, clip, options) {
-    options = options || {};
-    options.useFirstFramePosition = options.useFirstFramePosition !== void 0 ? options.useFirstFramePosition : false;
-    options.fps = options.fps !== void 0 ? options.fps : 30;
-    options.names = options.names || [];
-    if (!source.isObject3D) {
-      source = this.getHelperFromSkeleton(source);
-    }
-    var numFrames = Math.round(clip.duration * (options.fps / 1e3) * 1e3), delta = 1 / options.fps, convertedTracks = [], mixer = new AnimationMixer(source), bones = this.getBones(target.skeleton), boneDatas = [], positionOffset, bone, boneTo, boneData, name, i, j;
-    mixer.clipAction(clip).play();
-    mixer.update(0);
-    source.updateMatrixWorld();
-    for (i = 0; i < numFrames; ++i) {
-      var time = i * delta;
-      this.retarget(target, source, options);
-      for (j = 0; j < bones.length; ++j) {
-        name = options.names[bones[j].name] || bones[j].name;
-        boneTo = this.getBoneByName(name, source.skeleton);
-        if (boneTo) {
-          bone = bones[j];
-          boneData = boneDatas[j] = boneDatas[j] || { bone };
-          if (options.hip === name) {
-            if (!boneData.pos) {
-              boneData.pos = {
-                times: new Float32Array(numFrames),
-                values: new Float32Array(numFrames * 3)
-              };
-            }
-            if (options.useFirstFramePosition) {
-              if (i === 0) {
-                positionOffset = bone.position.clone();
-              }
-              bone.position.sub(positionOffset);
-            }
-            boneData.pos.times[i] = time;
-            bone.position.toArray(boneData.pos.values, i * 3);
-          }
-          if (!boneData.quat) {
-            boneData.quat = {
-              times: new Float32Array(numFrames),
-              values: new Float32Array(numFrames * 4)
-            };
-          }
-          boneData.quat.times[i] = time;
-          bone.quaternion.toArray(boneData.quat.values, i * 4);
-        }
-      }
-      mixer.update(delta);
-      source.updateMatrixWorld();
-    }
-    for (i = 0; i < boneDatas.length; ++i) {
-      boneData = boneDatas[i];
-      if (boneData) {
-        if (boneData.pos) {
-          convertedTracks.push(
-            new VectorKeyframeTrack(
-              ".bones[" + boneData.bone.name + "].position",
-              boneData.pos.times,
-              boneData.pos.values
-            )
-          );
-        }
-        convertedTracks.push(
-          new QuaternionKeyframeTrack(
-            ".bones[" + boneData.bone.name + "].quaternion",
-            boneData.quat.times,
-            boneData.quat.values
-          )
-        );
-      }
-    }
-    mixer.uncacheAction(clip);
-    return new AnimationClip(clip.name, -1, convertedTracks);
-  },
-  getHelperFromSkeleton: function(skeleton) {
-    var source = new SkeletonHelper(skeleton.bones[0]);
-    source.skeleton = skeleton;
-    return source;
-  },
-  getSkeletonOffsets: function() {
-    var targetParentPos = new Vector3(), targetPos = new Vector3(), sourceParentPos = new Vector3(), sourcePos = new Vector3(), targetDir = new Vector2(), sourceDir = new Vector2();
-    return function(target, source, options) {
-      options = options || {};
-      options.hip = options.hip !== void 0 ? options.hip : "hip";
-      options.names = options.names || {};
-      if (!source.isObject3D) {
-        source = this.getHelperFromSkeleton(source);
-      }
-      var nameKeys = Object.keys(options.names), nameValues = Object.values(options.names), sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source), bones = target.isObject3D ? target.skeleton.bones : this.getBones(target), offsets = [], bone, boneTo, name, i;
-      target.skeleton.pose();
-      for (i = 0; i < bones.length; ++i) {
-        bone = bones[i];
-        name = options.names[bone.name] || bone.name;
-        boneTo = this.getBoneByName(name, sourceBones);
-        if (boneTo && name !== options.hip) {
-          var boneParent = this.getNearestBone(bone.parent, nameKeys), boneToParent = this.getNearestBone(boneTo.parent, nameValues);
-          boneParent.updateMatrixWorld();
-          boneToParent.updateMatrixWorld();
-          targetParentPos.setFromMatrixPosition(boneParent.matrixWorld);
-          targetPos.setFromMatrixPosition(bone.matrixWorld);
-          sourceParentPos.setFromMatrixPosition(boneToParent.matrixWorld);
-          sourcePos.setFromMatrixPosition(boneTo.matrixWorld);
-          targetDir.subVectors(new Vector2(targetPos.x, targetPos.y), new Vector2(targetParentPos.x, targetParentPos.y)).normalize();
-          sourceDir.subVectors(new Vector2(sourcePos.x, sourcePos.y), new Vector2(sourceParentPos.x, sourceParentPos.y)).normalize();
-          var laterialAngle = targetDir.angle() - sourceDir.angle();
-          var offset = new Matrix4().makeRotationFromEuler(new Euler(0, 0, laterialAngle));
-          bone.matrix.multiply(offset);
-          bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
-          bone.updateMatrixWorld();
-          offsets[name] = offset;
-        }
-      }
-      return offsets;
-    };
-  }(),
-  renameBones: function(skeleton, names) {
-    var bones = this.getBones(skeleton);
-    for (let i = 0; i < bones.length; ++i) {
-      var bone = bones[i];
-      if (names[bone.name]) {
-        bone.name = names[bone.name];
-      }
-    }
-    return this;
-  },
-  getBones: function(skeleton) {
-    return Array.isArray(skeleton) ? skeleton : skeleton.bones;
-  },
-  getBoneByName: function(name, skeleton) {
-    for (let i = 0, bones = this.getBones(skeleton); i < bones.length; i++) {
-      if (name === bones[i].name)
-        return bones[i];
-    }
-  },
-  getNearestBone: function(bone, names) {
-    while (bone.isBone) {
-      if (names.indexOf(bone.name) !== -1) {
-        return bone;
-      }
-      bone = bone.parent;
-    }
-  },
-  findBoneTrackData: function(name, tracks) {
-    var regexp = /\[(.*)\]\.(.*)/, result = { name };
-    for (let i = 0; i < tracks.length; ++i) {
-      var trackData = regexp.exec(tracks[i].name);
-      if (trackData && name === trackData[1]) {
-        result[trackData[2]] = i;
-      }
-    }
-    return result;
-  },
-  getEqualsBonesNames: function(skeleton, targetSkeleton) {
-    var sourceBones = this.getBones(skeleton), targetBones = this.getBones(targetSkeleton), bones = [];
-    search:
-      for (let i = 0; i < sourceBones.length; i++) {
-        var boneName = sourceBones[i].name;
-        for (let j = 0; j < targetBones.length; j++) {
-          if (boneName === targetBones[j].name) {
-            bones.push(boneName);
-            continue search;
-          }
-        }
-      }
-    return bones;
-  },
-  clone: function(source) {
-    var sourceLookup = /* @__PURE__ */ new Map();
-    var cloneLookup = /* @__PURE__ */ new Map();
-    var clone = source.clone();
-    parallelTraverse(source, clone, function(sourceNode, clonedNode) {
-      sourceLookup.set(clonedNode, sourceNode);
-      cloneLookup.set(sourceNode, clonedNode);
-    });
-    clone.traverse(function(node) {
-      if (!node.isSkinnedMesh)
-        return;
-      var clonedMesh = node;
-      var sourceMesh = sourceLookup.get(node);
-      var sourceBones = sourceMesh.skeleton.bones;
-      clonedMesh.skeleton = sourceMesh.skeleton.clone();
-      clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
-      clonedMesh.skeleton.bones = sourceBones.map(function(bone) {
-        return cloneLookup.get(bone);
-      });
-      clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
-    });
-    return clone;
-  }
-};
-function parallelTraverse(a, b, callback) {
-  callback(a, b);
-  for (let i = 0; i < a.children.length; i++) {
-    parallelTraverse(a.children[i], b.children[i], callback);
-  }
-}
-export {
-  SkeletonUtils
-};