Source: utils.js

  1. import { Vector3, Matrix4 } from 'three';
  3. /**
  4.  * A collection of utilities.
  5.  * @module utils
  6.  */
  8. const t1 = new Vector3();
  9. const t2 = new Vector3();
  10. const t3 = new Vector3();
  11. const m1 = new Matrix4();
  13. /**
  14.  * Returns the world position of object and sets
  15.  * it on target.
  16.  *
  17.  * @param {THREE.Object3D} object
  18.  * @param {THREE.Vector3} target
  19.  */
  20. export function getWorldPosition(object, target) {
  21.   return target.setFromMatrixPosition(object.matrixWorld);
  22. }
  24. /**
  25.  * Returns the distance between two objects.
  26.  *
  27.  * @param {THREE.Object3D} obj1
  28.  * @param {THREE.Object3D} obj2
  29.  * @return {number}
  30.  */
  31. export function getWorldDistance(obj1, obj2) {
  32.   getWorldPosition(obj1, t1);
  33.   getWorldPosition(obj2, t2);
  34.   return a.distanceTo(b);
  35. }
  37. /**
  38.  * Sets the target to the centroid position between all passed in
  39.  * positions.
  40.  *
  41.  * @param {Array<THREE.Vector3>} positions
  42.  * @param {THREE.Vector3} target
  43.  */
  44. export function getCentroid(positions, target) {
  45.   target.set(0, 0, 0);
  46.   for (let position of positions) {
  47.     target.add(position);
  48.   }
  49.   target.divideScalar(positions.length);
  51.   return target;
  52. };
  54. /**
  55.  * Takes a direction vector and an up vector and sets
  56.  * `target` quaternion to the rotation. Similar to THREE.Matrix4's
  57.  * `lookAt` function, except rather than taking two Vector3 points,
  58.  * we've already calculaeld the direction earlier so skip the first half.
  59.  *
  60.  * @param {THREE.Vector3} direction
  61.  * @param {THREE.Vector3} up
  62.  * @param {THREE.Quaternion} target
  63.  */
  64. export function setQuaternionFromDirection(direction, up, target) {
  65.   const x = t1;
  66.   const y = t2;
  67.   const z = t3;
  68.   const m = m1;
  69.   const el = m1.elements;
  71.   z.copy(direction);
  72.   x.crossVectors(up, z);
  74.   if (x.lengthSq() === 0) {
  75.     // parallel
  76.     if (Math.abs(up.z) === 1) {
  77.       z.x += 0.0001;
  78.     } else {
  79.       z.z += 0.0001;
  80.     }
  81.     z.normalize();
  82.     x.crossVectors(up, z);
  83.   }
  85.   x.normalize();
  86.   y.crossVectors(z, x);
  88.   el[ 0 ] = x.x; el[ 4 ] = y.x; el[ 8 ] = z.x;
  89.   el[ 1 ] = x.y; el[ 5 ] = y.y; el[ 9 ] = z.y;
  90.   el[ 2 ] = x.z; el[ 6 ] = y.z; el[ 10 ] = z.z;
  92.   target.setFromRotationMatrix(m);
  93. }
  95. /**
  96.  * Implementation of Unity's Transform.transformPoint, which is similar
  97.  * to three's Vector3.transformDirection, except we want to take scale into account,
  98.  * as we're not transforming a direction. Function taken from BabylonJS.
  99.  *
  100.  * From BabylonJS's `Vector3.transformCoordinates`:
  101.  * Sets the passed vector coordinates with the result of the transformation by the
  102.  * passed matrix of the passed vector. This method computes tranformed coordinates only,
  103.  * not transformed direction vectors (ie. it takes translation in account)
  104.  *
  105.  * @see https://docs.unity3d.com/ScriptReference/Transform.TransformPoint.html
  106.  * @see https://github.com/BabylonJS/Babylon.js/blob/6050288da37623088d5f613ca2d85aef877c5cd5/src/Math/babylon.math.ts#L1936
  107.  * @param {THREE.Vector3} vector
  108.  * @param {THREE.Matrix4} matrix
  109.  * @param {THREE.Vector3} target
  110.  */
  111. export function transformPoint(vector, matrix, target) {
  112.   const e = matrix.elements;
  114.   const x = (vector.x * e[0]) + (vector.y * e[4]) + (vector.z * e[8]) + e[12];
  115.   const y = (vector.x * e[1]) + (vector.y * e[5]) + (vector.z * e[9]) + e[13];
  116.   const z = (vector.x * e[2]) + (vector.y * e[6]) + (vector.z * e[10]) + e[14];
  117.   const w = (vector.x * e[3]) + (vector.y * e[7]) + (vector.z * e[11]) + e[15];
  118.   target.set(x / w, y / w, z / w);
  119. };