three-stdlib 2.22.7 → 2.22.8

package/dist/utils/ShadowMapViewer.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const UnpackDepthRGBAShader = require("../shaders/UnpackDepthRGBAShader.js");
+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 THREE.OrthographicCamera(
+    window.innerWidth / -2,
+    window.innerWidth / 2,
+    window.innerHeight / 2,
+    window.innerHeight / -2,
+    1,
+    10
+  );
+  camera.position.set(0, 0, 2);
+  var scene = new THREE.Scene();
+  var shader = UnpackDepthRGBAShader.UnpackDepthRGBAShader;
+  var uniforms = THREE.UniformsUtils.clone(shader.uniforms);
+  var material = new THREE.ShaderMaterial({
+    uniforms,
+    vertexShader: shader.vertexShader,
+    fragmentShader: shader.fragmentShader
+  });
+  var plane = new THREE.PlaneGeometry(frame.width, frame.height);
+  var mesh = new THREE.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 THREE.Texture(labelCanvas);
+    labelTexture.magFilter = THREE.LinearFilter;
+    labelTexture.minFilter = THREE.LinearFilter;
+    labelTexture.needsUpdate = true;
+    var labelMaterial = new THREE.MeshBasicMaterial({
+      map: labelTexture,
+      side: THREE.DoubleSide
+    });
+    labelMaterial.transparent = true;
+    var labelPlane = new THREE.PlaneGeometry(labelCanvas.width, labelCanvas.height);
+    labelMesh = new THREE.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;
+exports.ShadowMapViewer = ShadowMapViewer;

package/dist/utils/ShadowMapViewer.mjs

@@ -0,0 +1,114 @@
+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/dist/utils/SkeletonUtils.d.ts

@@ -0,0 +1,30 @@
+import { AnimationClip, Bone, Matrix4, Object3D, Skeleton, SkeletonHelper } from 'three'
+
+export namespace SkeletonUtils {
+  function retarget(target: Object3D | Skeleton, source: Object3D | Skeleton, options: {}): void
+
+  function retargetClip(
+    target: Skeleton | Object3D,
+    source: Skeleton | Object3D,
+    clip: AnimationClip,
+    options: {},
+  ): AnimationClip
+
+  function getHelperFromSkeleton(skeleton: Skeleton): SkeletonHelper
+
+  function getSkeletonOffsets(target: Object3D | Skeleton, source: Object3D | Skeleton, options: {}): Matrix4[]
+
+  function renameBones(skeleton: Skeleton, names: {}): any
+
+  function getBones(skeleton: Skeleton | Bone[]): Bone[]
+
+  function getBoneByName(name: string, skeleton: Skeleton): Bone
+
+  function getNearestBone(bone: Bone, names: {}): Bone
+
+  function findBoneTrackData(name: string, tracks: any[]): {}
+
+  function getEqualsBonesNames(skeleton: Skeleton, targetSkeleton: Skeleton): string[]
+
+  function clone(source: Object3D): Object3D
+}

package/dist/utils/SkeletonUtils.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var SkeletonUtils = {
+  retarget: function() {
+    var pos = new THREE.Vector3(), quat = new THREE.Quaternion(), scale = new THREE.Vector3(), bindBoneMatrix = new THREE.Matrix4(), relativeMatrix = new THREE.Matrix4(), globalMatrix = new THREE.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 THREE.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 THREE.VectorKeyframeTrack(
+              ".bones[" + boneData.bone.name + "].position",
+              boneData.pos.times,
+              boneData.pos.values
+            )
+          );
+        }
+        convertedTracks.push(
+          new THREE.QuaternionKeyframeTrack(
+            ".bones[" + boneData.bone.name + "].quaternion",
+            boneData.quat.times,
+            boneData.quat.values
+          )
+        );
+      }
+    }
+    mixer.uncacheAction(clip);
+    return new THREE.AnimationClip(clip.name, -1, convertedTracks);
+  },
+  getHelperFromSkeleton: function(skeleton) {
+    var source = new THREE.SkeletonHelper(skeleton.bones[0]);
+    source.skeleton = skeleton;
+    return source;
+  },
+  getSkeletonOffsets: function() {
+    var targetParentPos = new THREE.Vector3(), targetPos = new THREE.Vector3(), sourceParentPos = new THREE.Vector3(), sourcePos = new THREE.Vector3(), targetDir = new THREE.Vector2(), sourceDir = new THREE.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 THREE.Vector2(targetPos.x, targetPos.y), new THREE.Vector2(targetParentPos.x, targetParentPos.y)).normalize();
+          sourceDir.subVectors(new THREE.Vector2(sourcePos.x, sourcePos.y), new THREE.Vector2(sourceParentPos.x, sourceParentPos.y)).normalize();
+          var laterialAngle = targetDir.angle() - sourceDir.angle();
+          var offset = new THREE.Matrix4().makeRotationFromEuler(new THREE.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);
+  }
+}
+exports.SkeletonUtils = SkeletonUtils;