@ohos-ports/react-three-drei 10.7.7-beta.0

package/web/pivotControls/PlaneSlider.js

@@ -0,0 +1,202 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { useThree } from '@react-three/fiber';
+import { Line } from '../../core/Line.js';
+import { Html } from '../Html.js';
+import { context } from './context.js';
+
+const decomposeIntoBasis = (e1, e2, offset) => {
+  const i1 = Math.abs(e1.x) >= Math.abs(e1.y) && Math.abs(e1.x) >= Math.abs(e1.z) ? 0 : Math.abs(e1.y) >= Math.abs(e1.x) && Math.abs(e1.y) >= Math.abs(e1.z) ? 1 : 2;
+  const e2DegrowthOrder = [0, 1, 2].sort((a, b) => Math.abs(e2.getComponent(b)) - Math.abs(e2.getComponent(a)));
+  const i2 = i1 === e2DegrowthOrder[0] ? e2DegrowthOrder[1] : e2DegrowthOrder[0];
+  const a1 = e1.getComponent(i1);
+  const a2 = e1.getComponent(i2);
+  const b1 = e2.getComponent(i1);
+  const b2 = e2.getComponent(i2);
+  const c1 = offset.getComponent(i1);
+  const c2 = offset.getComponent(i2);
+  const y = (c2 - c1 * (a2 / a1)) / (b2 - b1 * (a2 / a1));
+  const x = (c1 - y * b1) / a1;
+  return [x, y];
+};
+const ray = /* @__PURE__ */new THREE.Ray();
+const intersection = /* @__PURE__ */new THREE.Vector3();
+const offsetMatrix = /* @__PURE__ */new THREE.Matrix4();
+const PlaneSlider = ({
+  dir1,
+  dir2,
+  axis
+}) => {
+  const {
+    translation,
+    translationLimits,
+    annotations,
+    annotationsClass,
+    depthTest,
+    scale,
+    lineWidth,
+    fixed,
+    axisColors,
+    hoveredColor,
+    opacity,
+    renderOrder,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    userData
+  } = React.useContext(context);
+  const camControls = useThree(state => state.controls);
+  const divRef = React.useRef(null);
+  const objRef = React.useRef(null);
+  const clickInfo = React.useRef(null);
+  const offsetX0 = React.useRef(0);
+  const offsetY0 = React.useRef(0);
+  const [isHovered, setIsHovered] = React.useState(false);
+  const onPointerDown = React.useCallback(e => {
+    if (annotations) {
+      divRef.current.innerText = `${translation.current[(axis + 1) % 3].toFixed(2)}, ${translation.current[(axis + 2) % 3].toFixed(2)}`;
+      divRef.current.style.display = 'block';
+    }
+    e.stopPropagation();
+    const clickPoint = e.point.clone();
+    const origin = new THREE.Vector3().setFromMatrixPosition(objRef.current.matrixWorld);
+    const e1 = new THREE.Vector3().setFromMatrixColumn(objRef.current.matrixWorld, 0).normalize();
+    const e2 = new THREE.Vector3().setFromMatrixColumn(objRef.current.matrixWorld, 1).normalize();
+    const normal = new THREE.Vector3().setFromMatrixColumn(objRef.current.matrixWorld, 2).normalize();
+    const plane = new THREE.Plane().setFromNormalAndCoplanarPoint(normal, origin);
+    clickInfo.current = {
+      clickPoint,
+      e1,
+      e2,
+      plane
+    };
+    offsetX0.current = translation.current[(axis + 1) % 3];
+    offsetY0.current = translation.current[(axis + 2) % 3];
+    onDragStart({
+      component: 'Slider',
+      axis,
+      origin,
+      directions: [e1, e2, normal]
+    });
+    camControls && (camControls.enabled = false);
+    // @ts-ignore
+    e.target.setPointerCapture(e.pointerId);
+  }, [annotations, camControls, onDragStart, axis]);
+  const onPointerMove = React.useCallback(e => {
+    e.stopPropagation();
+    if (!isHovered) setIsHovered(true);
+    if (clickInfo.current) {
+      const {
+        clickPoint,
+        e1,
+        e2,
+        plane
+      } = clickInfo.current;
+      const [minX, maxX] = (translationLimits == null ? void 0 : translationLimits[(axis + 1) % 3]) || [undefined, undefined];
+      const [minY, maxY] = (translationLimits == null ? void 0 : translationLimits[(axis + 2) % 3]) || [undefined, undefined];
+      ray.copy(e.ray);
+      ray.intersectPlane(plane, intersection);
+      ray.direction.negate();
+      ray.intersectPlane(plane, intersection);
+      intersection.sub(clickPoint);
+      let [offsetX, offsetY] = decomposeIntoBasis(e1, e2, intersection);
+      /* let offsetY = (intersection.y - (intersection.x * e1.y) / e1.x) / (e2.y - (e2.x * e1.y) / e1.x)
+      let offsetX = (intersection.x - offsetY * e2.x) / e1.x */
+      if (minX !== undefined) {
+        offsetX = Math.max(offsetX, minX - offsetX0.current);
+      }
+      if (maxX !== undefined) {
+        offsetX = Math.min(offsetX, maxX - offsetX0.current);
+      }
+      if (minY !== undefined) {
+        offsetY = Math.max(offsetY, minY - offsetY0.current);
+      }
+      if (maxY !== undefined) {
+        offsetY = Math.min(offsetY, maxY - offsetY0.current);
+      }
+      translation.current[(axis + 1) % 3] = offsetX0.current + offsetX;
+      translation.current[(axis + 2) % 3] = offsetY0.current + offsetY;
+      if (annotations) {
+        divRef.current.innerText = `${translation.current[(axis + 1) % 3].toFixed(2)}, ${translation.current[(axis + 2) % 3].toFixed(2)}`;
+      }
+      offsetMatrix.makeTranslation(offsetX * e1.x + offsetY * e2.x, offsetX * e1.y + offsetY * e2.y, offsetX * e1.z + offsetY * e2.z);
+      onDrag(offsetMatrix);
+    }
+  }, [annotations, onDrag, isHovered, translation, translationLimits, axis]);
+  const onPointerUp = React.useCallback(e => {
+    if (annotations) {
+      divRef.current.style.display = 'none';
+    }
+    e.stopPropagation();
+    clickInfo.current = null;
+    onDragEnd();
+    camControls && (camControls.enabled = true);
+    // @ts-ignore
+    e.target.releasePointerCapture(e.pointerId);
+  }, [annotations, camControls, onDragEnd]);
+  const onPointerOut = React.useCallback(e => {
+    e.stopPropagation();
+    setIsHovered(false);
+  }, []);
+  const matrixL = React.useMemo(() => {
+    const dir1N = dir1.clone().normalize();
+    const dir2N = dir2.clone().normalize();
+    return new THREE.Matrix4().makeBasis(dir1N, dir2N, dir1N.clone().cross(dir2N));
+  }, [dir1, dir2]);
+  const pos1 = fixed ? 1 / 7 : scale / 7;
+  const length = fixed ? 0.225 : scale * 0.225;
+  const color = isHovered ? hoveredColor : axisColors[axis];
+  const points = React.useMemo(() => [new THREE.Vector3(0, 0, 0), new THREE.Vector3(0, length, 0), new THREE.Vector3(length, length, 0), new THREE.Vector3(length, 0, 0), new THREE.Vector3(0, 0, 0)], [length]);
+  return /*#__PURE__*/React.createElement("group", {
+    ref: objRef,
+    matrix: matrixL,
+    matrixAutoUpdate: false
+  }, annotations && /*#__PURE__*/React.createElement(Html, {
+    position: [0, 0, 0]
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'none',
+      background: '#151520',
+      color: 'white',
+      padding: '6px 8px',
+      borderRadius: 7,
+      whiteSpace: 'nowrap'
+    },
+    className: annotationsClass,
+    ref: divRef
+  })), /*#__PURE__*/React.createElement("group", {
+    position: [pos1 * 1.7, pos1 * 1.7, 0]
+  }, /*#__PURE__*/React.createElement("mesh", {
+    visible: true,
+    onPointerDown: onPointerDown,
+    onPointerMove: onPointerMove,
+    onPointerUp: onPointerUp,
+    onPointerOut: onPointerOut,
+    scale: length,
+    userData: userData,
+    renderOrder: renderOrder
+  }, /*#__PURE__*/React.createElement("planeGeometry", null), /*#__PURE__*/React.createElement("meshBasicMaterial", {
+    transparent: true,
+    depthTest: depthTest,
+    color: color,
+    polygonOffset: true,
+    polygonOffsetFactor: -10,
+    side: THREE.DoubleSide,
+    fog: false
+  })), /*#__PURE__*/React.createElement(Line, {
+    position: [-length / 2, -length / 2, 0],
+    transparent: true,
+    depthTest: depthTest,
+    points: points,
+    lineWidth: lineWidth,
+    color: color,
+    opacity: opacity,
+    polygonOffset: true,
+    polygonOffsetFactor: -10,
+    userData: userData,
+    fog: false,
+    renderOrder: renderOrder
+  })));
+};
+
+export { PlaneSlider };

package/web/pivotControls/ScalingSphere.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),t=require("three"),r=require("@react-three/fiber"),n=require("../Html.cjs.js"),o=require("./context.cjs.js"),a=require("../../core/calculateScaleFactor.cjs.js");function i(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}require("@babel/runtime/helpers/extends"),require("react-dom/client");var c=i(e),l=i(t);const s=new l.Vector3,u=new l.Vector3,p=(e,t,r,n)=>{const o=t.dot(t),a=t.dot(e)-t.dot(r),i=t.dot(n);if(0===i)return-a/o;s.copy(n).multiplyScalar(o/i).sub(t),u.copy(n).multiplyScalar(a/i).add(r).sub(e);return-s.dot(u)/s.dot(s)},d=new l.Vector3(0,1,0),m=new l.Vector3,f=new l.Matrix4;exports.ScalingSphere=({direction:e,axis:t})=>{const{scaleLimits:i,annotations:u,annotationsClass:x,depthTest:y,scale:g,lineWidth:h,fixed:b,axisColors:P,hoveredColor:M,opacity:w,renderOrder:v,onDragStart:O,onDrag:j,onDragEnd:k,userData:C}=c.useContext(o.context),S=r.useThree((e=>e.size)),E=r.useThree((e=>e.controls)),R=c.useRef(null),q=c.useRef(null),F=c.useRef(null),D=c.useRef(1),L=c.useRef(1),T=c.useRef(null),[V,z]=c.useState(!1),G=b?1.2:1.2*g,W=c.useCallback((r=>{u&&(R.current.innerText=`${L.current.toFixed(2)}`,R.current.style.display="block"),r.stopPropagation();const n=(new l.Matrix4).extractRotation(q.current.matrixWorld),o=r.point.clone(),i=(new l.Vector3).setFromMatrixPosition(q.current.matrixWorld),c=e.clone().applyMatrix4(n).normalize(),p=q.current.matrixWorld.clone(),d=p.clone().invert(),m=b?1/a.calculateScaleFactor(q.current.getWorldPosition(s),g,r.camera,S):1;T.current={clickPoint:o,dir:c,mPLG:p,mPLGInv:d,offsetMultiplier:m},O({component:"Sphere",axis:t,origin:i,directions:[c]}),E&&(E.enabled=!1),r.target.setPointerCapture(r.pointerId)}),[u,E,e,O,t,b,g,S]),I=c.useCallback((e=>{if(e.stopPropagation(),V||z(!0),T.current){const{clickPoint:r,dir:n,mPLG:o,mPLGInv:a,offsetMultiplier:c}=T.current,[l,s]=(null==i?void 0:i[t])||[1e-5,void 0],d=p(r,n,e.ray.origin,e.ray.direction)*c,x=b?d:d/g;let y=Math.pow(2,.2*x);e.shiftKey&&(y=Math.round(10*y)/10),y=Math.max(y,l/D.current),void 0!==s&&(y=Math.min(y,s/D.current)),L.current=D.current*y,F.current.position.set(0,G+d,0),u&&(R.current.innerText=`${L.current.toFixed(2)}`),m.set(1,1,1),m.setComponent(t,y),f.makeScale(m.x,m.y,m.z).premultiply(o).multiply(a),j(f)}}),[u,G,j,V,i,t]),_=c.useCallback((e=>{u&&(R.current.style.display="none"),e.stopPropagation(),D.current=L.current,T.current=null,F.current.position.set(0,G,0),k(),E&&(E.enabled=!0),e.target.releasePointerCapture(e.pointerId)}),[u,E,k,G]),U=c.useCallback((e=>{e.stopPropagation(),z(!1)}),[]),{radius:H,matrixL:Q}=c.useMemo((()=>{const t=b?h/g*1.8:g/22.5,r=(new l.Quaternion).setFromUnitVectors(d,e.clone().normalize());return{radius:t,matrixL:(new l.Matrix4).makeRotationFromQuaternion(r)}}),[e,g,h,b]),$=V?M:P[t];return c.createElement("group",{ref:q},c.createElement("group",{matrix:Q,matrixAutoUpdate:!1,onPointerDown:W,onPointerMove:I,onPointerUp:_,onPointerOut:U},u&&c.createElement(n.Html,{position:[0,G/2,0]},c.createElement("div",{style:{display:"none",background:"#151520",color:"white",padding:"6px 8px",borderRadius:7,whiteSpace:"nowrap"},className:x,ref:R})),c.createElement("mesh",{ref:F,position:[0,G,0],renderOrder:v,userData:C},c.createElement("sphereGeometry",{args:[H,12,12]}),c.createElement("meshBasicMaterial",{transparent:!0,depthTest:y,color:$,opacity:w,polygonOffset:!0,polygonOffsetFactor:-10}))))},exports.calculateOffset=p;

package/web/pivotControls/ScalingSphere.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as THREE from 'three';
+export declare const calculateOffset: (clickPoint: THREE.Vector3, normal: THREE.Vector3, rayStart: THREE.Vector3, rayDir: THREE.Vector3) => number;
+export declare const ScalingSphere: React.FC<{
+    direction: THREE.Vector3;
+    axis: 0 | 1 | 2;
+}>;

package/web/pivotControls/ScalingSphere.js

@@ -0,0 +1,192 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { useThree } from '@react-three/fiber';
+import { Html } from '../Html.js';
+import { context } from './context.js';
+import { calculateScaleFactor } from '../../core/calculateScaleFactor.js';
+
+const vec1 = /* @__PURE__ */new THREE.Vector3();
+const vec2 = /* @__PURE__ */new THREE.Vector3();
+const calculateOffset = (clickPoint, normal, rayStart, rayDir) => {
+  const e1 = normal.dot(normal);
+  const e2 = normal.dot(clickPoint) - normal.dot(rayStart);
+  const e3 = normal.dot(rayDir);
+  if (e3 === 0) {
+    return -e2 / e1;
+  }
+  vec1.copy(rayDir).multiplyScalar(e1 / e3).sub(normal);
+  vec2.copy(rayDir).multiplyScalar(e2 / e3).add(rayStart).sub(clickPoint);
+  const offset = -vec1.dot(vec2) / vec1.dot(vec1);
+  return offset;
+};
+const upV = /* @__PURE__ */new THREE.Vector3(0, 1, 0);
+const scaleV = /* @__PURE__ */new THREE.Vector3();
+const scaleMatrix = /* @__PURE__ */new THREE.Matrix4();
+const ScalingSphere = ({
+  direction,
+  axis
+}) => {
+  const {
+    scaleLimits,
+    annotations,
+    annotationsClass,
+    depthTest,
+    scale,
+    lineWidth,
+    fixed,
+    axisColors,
+    hoveredColor,
+    opacity,
+    renderOrder,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    userData
+  } = React.useContext(context);
+  const size = useThree(state => state.size);
+  const camControls = useThree(state => state.controls);
+  const divRef = React.useRef(null);
+  const objRef = React.useRef(null);
+  const meshRef = React.useRef(null);
+  const scale0 = React.useRef(1);
+  const scaleCur = React.useRef(1);
+  const clickInfo = React.useRef(null);
+  const [isHovered, setIsHovered] = React.useState(false);
+  const position = fixed ? 1.2 : 1.2 * scale;
+  const onPointerDown = React.useCallback(e => {
+    if (annotations) {
+      divRef.current.innerText = `${scaleCur.current.toFixed(2)}`;
+      divRef.current.style.display = 'block';
+    }
+    e.stopPropagation();
+    const rotation = new THREE.Matrix4().extractRotation(objRef.current.matrixWorld);
+    const clickPoint = e.point.clone();
+    const origin = new THREE.Vector3().setFromMatrixPosition(objRef.current.matrixWorld);
+    const dir = direction.clone().applyMatrix4(rotation).normalize();
+    const mPLG = objRef.current.matrixWorld.clone();
+    const mPLGInv = mPLG.clone().invert();
+    const offsetMultiplier = fixed ? 1 / calculateScaleFactor(objRef.current.getWorldPosition(vec1), scale, e.camera, size) : 1;
+    clickInfo.current = {
+      clickPoint,
+      dir,
+      mPLG,
+      mPLGInv,
+      offsetMultiplier
+    };
+    onDragStart({
+      component: 'Sphere',
+      axis,
+      origin,
+      directions: [dir]
+    });
+    camControls && (camControls.enabled = false);
+    // @ts-ignore - setPointerCapture is not in the type definition
+    e.target.setPointerCapture(e.pointerId);
+  }, [annotations, camControls, direction, onDragStart, axis, fixed, scale, size]);
+  const onPointerMove = React.useCallback(e => {
+    e.stopPropagation();
+    if (!isHovered) setIsHovered(true);
+    if (clickInfo.current) {
+      const {
+        clickPoint,
+        dir,
+        mPLG,
+        mPLGInv,
+        offsetMultiplier
+      } = clickInfo.current;
+      const [min, max] = (scaleLimits == null ? void 0 : scaleLimits[axis]) || [1e-5, undefined]; // always limit the minimal value, since setting it very low might break the transform
+
+      const offsetW = calculateOffset(clickPoint, dir, e.ray.origin, e.ray.direction);
+      const offsetL = offsetW * offsetMultiplier;
+      const offsetH = fixed ? offsetL : offsetL / scale;
+      let upscale = Math.pow(2, offsetH * 0.2);
+
+      // @ts-ignore
+      if (e.shiftKey) {
+        upscale = Math.round(upscale * 10) / 10;
+      }
+      upscale = Math.max(upscale, min / scale0.current);
+      if (max !== undefined) {
+        upscale = Math.min(upscale, max / scale0.current);
+      }
+      scaleCur.current = scale0.current * upscale;
+      meshRef.current.position.set(0, position + offsetL, 0);
+      if (annotations) {
+        divRef.current.innerText = `${scaleCur.current.toFixed(2)}`;
+      }
+      scaleV.set(1, 1, 1);
+      scaleV.setComponent(axis, upscale);
+      scaleMatrix.makeScale(scaleV.x, scaleV.y, scaleV.z).premultiply(mPLG).multiply(mPLGInv);
+      onDrag(scaleMatrix);
+    }
+  }, [annotations, position, onDrag, isHovered, scaleLimits, axis]);
+  const onPointerUp = React.useCallback(e => {
+    if (annotations) {
+      divRef.current.style.display = 'none';
+    }
+    e.stopPropagation();
+    scale0.current = scaleCur.current;
+    clickInfo.current = null;
+    meshRef.current.position.set(0, position, 0);
+    onDragEnd();
+    camControls && (camControls.enabled = true);
+    // @ts-ignore - releasePointerCapture & PointerEvent#pointerId is not in the type definition
+    e.target.releasePointerCapture(e.pointerId);
+  }, [annotations, camControls, onDragEnd, position]);
+  const onPointerOut = React.useCallback(e => {
+    e.stopPropagation();
+    setIsHovered(false);
+  }, []);
+  const {
+    radius,
+    matrixL
+  } = React.useMemo(() => {
+    const radius = fixed ? lineWidth / scale * 1.8 : scale / 22.5;
+    const quaternion = new THREE.Quaternion().setFromUnitVectors(upV, direction.clone().normalize());
+    const matrixL = new THREE.Matrix4().makeRotationFromQuaternion(quaternion);
+    return {
+      radius,
+      matrixL
+    };
+  }, [direction, scale, lineWidth, fixed]);
+  const color = isHovered ? hoveredColor : axisColors[axis];
+  return /*#__PURE__*/React.createElement("group", {
+    ref: objRef
+  }, /*#__PURE__*/React.createElement("group", {
+    matrix: matrixL,
+    matrixAutoUpdate: false,
+    onPointerDown: onPointerDown,
+    onPointerMove: onPointerMove,
+    onPointerUp: onPointerUp,
+    onPointerOut: onPointerOut
+  }, annotations && /*#__PURE__*/React.createElement(Html, {
+    position: [0, position / 2, 0]
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'none',
+      background: '#151520',
+      color: 'white',
+      padding: '6px 8px',
+      borderRadius: 7,
+      whiteSpace: 'nowrap'
+    },
+    className: annotationsClass,
+    ref: divRef
+  })), /*#__PURE__*/React.createElement("mesh", {
+    ref: meshRef,
+    position: [0, position, 0],
+    renderOrder: renderOrder,
+    userData: userData
+  }, /*#__PURE__*/React.createElement("sphereGeometry", {
+    args: [radius, 12, 12]
+  }), /*#__PURE__*/React.createElement("meshBasicMaterial", {
+    transparent: true,
+    depthTest: depthTest,
+    color: color,
+    opacity: opacity,
+    polygonOffset: true,
+    polygonOffsetFactor: -10
+  }))));
+};
+
+export { ScalingSphere, calculateOffset };

package/web/pivotControls/context.cjs.js

@@ -0,0 +1 @@
+"use strict";function e(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}Object.defineProperty(exports,"__esModule",{value:!0});const t=e(require("react")).createContext(null);exports.context=t;

package/web/pivotControls/context.d.ts

@@ -0,0 +1,33 @@
+import * as THREE from 'three';
+import * as React from 'react';
+export type OnDragStartProps = {
+    component: 'Arrow' | 'Slider' | 'Rotator' | 'Sphere';
+    axis: 0 | 1 | 2;
+    origin: THREE.Vector3;
+    directions: THREE.Vector3[];
+};
+export type PivotContext = {
+    onDragStart: (props: OnDragStartProps) => void;
+    onDrag: (mdW: THREE.Matrix4) => void;
+    onDragEnd: () => void;
+    translation: {
+        current: [number, number, number];
+    };
+    translationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    rotationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    scaleLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    axisColors: [string | number, string | number, string | number];
+    hoveredColor: string | number;
+    opacity: number;
+    scale: number;
+    lineWidth: number;
+    fixed: boolean;
+    depthTest: boolean;
+    renderOrder: number;
+    userData?: {
+        [key: string]: any;
+    };
+    annotations?: boolean;
+    annotationsClass?: string;
+};
+export declare const context: React.Context<PivotContext>;

package/web/pivotControls/context.js

@@ -0,0 +1,5 @@
+import * as React from 'react';
+
+const context = /* @__PURE__ */React.createContext(null);
+
+export { context };

package/web/pivotControls/index.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/extends"),r=require("@react-three/fiber"),t=require("react"),i=require("three"),a=require("./AxisArrow.cjs.js"),n=require("./AxisRotator.cjs.js"),o=require("./PlaneSlider.cjs.js"),c=require("./ScalingSphere.cjs.js"),l=require("./context.cjs.js"),s=require("../../core/calculateScaleFactor.cjs.js");function u(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}function d(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var i=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,i.get?i:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}require("../../core/Line.cjs.js"),require("three-stdlib"),require("../Html.cjs.js"),require("react-dom/client");var m=u(e),x=d(t),p=d(i);const f=new p.Matrix4,y=new p.Matrix4,w=new p.Matrix4,g=new p.Matrix4,b=new p.Matrix4,E=new p.Matrix4,j=new p.Matrix4,S=new p.Matrix4,h=new p.Matrix4,v=new p.Box3,M=new p.Box3,A=new p.Vector3,q=new p.Vector3,R=new p.Vector3,V=new p.Vector3,P=new p.Vector3,W=new p.Vector3(1,0,0),D=new p.Vector3(0,1,0),O=new p.Vector3(0,0,1),C=x.forwardRef((({enabled:e=!0,matrix:t,onDragStart:i,onDrag:u,onDragEnd:d,autoTransform:C=!0,anchor:L,disableAxes:B=!1,disableSliders:F=!1,disableRotations:z=!1,disableScaling:T=!1,activeAxes:_=[!0,!0,!0],offset:k=[0,0,0],rotation:H=[0,0,0],scale:I=1,lineWidth:U=4,fixed:G=!1,translationLimits:J,rotationLimits:K,scaleLimits:N,depthTest:Q=!0,renderOrder:X=500,axisColors:Y=["#ff2060","#20df80","#2080ff"],hoveredColor:Z="#ffff40",annotations:$=!1,annotationsClass:ee,opacity:re=1,visible:te=!0,userData:ie,children:ae,...ne},oe)=>{const ce=r.useThree((e=>e.invalidate)),le=x.useRef(null),se=x.useRef(null),ue=x.useRef(null),de=x.useRef(null),me=x.useRef([0,0,0]),xe=x.useRef(new p.Vector3(1,1,1)),pe=x.useRef(new p.Vector3(1,1,1));x.useLayoutEffect((()=>{L&&(de.current.updateWorldMatrix(!0,!0),g.copy(de.current.matrixWorld).invert(),v.makeEmpty(),de.current.traverse((e=>{e.geometry&&(e.geometry.boundingBox||e.geometry.computeBoundingBox(),E.copy(e.matrixWorld).premultiply(g),M.copy(e.geometry.boundingBox),M.applyMatrix4(E),v.union(M))})),A.copy(v.max).add(v.min).multiplyScalar(.5),q.copy(v.max).sub(v.min).multiplyScalar(.5),R.copy(q).multiply(new p.Vector3(...L)).add(A),V.set(...k).add(R),ue.current.position.copy(V),ce())}));const fe=x.useMemo((()=>({onDragStart:e=>{f.copy(se.current.matrix),y.copy(se.current.matrixWorld),i&&i(e),ce()},onDrag:e=>{w.copy(le.current.matrixWorld),g.copy(w).invert(),b.copy(y).premultiply(e),E.copy(b).premultiply(g),j.copy(f).invert(),S.copy(E).multiply(j),C&&se.current.matrix.copy(E),u&&u(E,S,b,e),ce()},onDragEnd:()=>{d&&d(),ce()},translation:me,translationLimits:J,rotationLimits:K,axisColors:Y,hoveredColor:Z,opacity:re,scale:I,lineWidth:U,fixed:G,depthTest:Q,renderOrder:X,userData:ie,annotations:$,annotationsClass:ee})),[i,u,d,me,J,K,N,Q,I,U,G,...Y,Z,re,ie,C,$,ee]),ye=new p.Vector3;return r.useFrame((e=>{if(G){const r=s.calculateScaleFactor(ue.current.getWorldPosition(ye),I,e.camera,e.size);xe.current.setScalar(r)}t&&t instanceof p.Matrix4&&(se.current.matrix=t),se.current.updateWorldMatrix(!0,!0),h.makeRotationFromEuler(ue.current.rotation).setPosition(ue.current.position).premultiply(se.current.matrixWorld),pe.current.setFromMatrixScale(h),P.copy(xe.current).divide(pe.current),(Math.abs(ue.current.scale.x-P.x)>1e-4||Math.abs(ue.current.scale.y-P.y)>1e-4||Math.abs(ue.current.scale.z-P.z)>1e-4)&&(ue.current.scale.copy(P),e.invalidate())})),x.useImperativeHandle(oe,(()=>se.current),[]),x.createElement(l.context.Provider,{value:fe},x.createElement("group",{ref:le},x.createElement("group",m.default({ref:se,matrix:t,matrixAutoUpdate:!1},ne),x.createElement("group",{visible:te,ref:ue,position:k,rotation:H},e&&x.createElement(x.Fragment,null,!B&&_[0]&&x.createElement(a.AxisArrow,{axis:0,direction:W}),!B&&_[1]&&x.createElement(a.AxisArrow,{axis:1,direction:D}),!B&&_[2]&&x.createElement(a.AxisArrow,{axis:2,direction:O}),!F&&_[0]&&_[1]&&x.createElement(o.PlaneSlider,{axis:2,dir1:W,dir2:D}),!F&&_[0]&&_[2]&&x.createElement(o.PlaneSlider,{axis:1,dir1:O,dir2:W}),!F&&_[2]&&_[1]&&x.createElement(o.PlaneSlider,{axis:0,dir1:D,dir2:O}),!z&&_[0]&&_[1]&&x.createElement(n.AxisRotator,{axis:2,dir1:W,dir2:D}),!z&&_[0]&&_[2]&&x.createElement(n.AxisRotator,{axis:1,dir1:O,dir2:W}),!z&&_[2]&&_[1]&&x.createElement(n.AxisRotator,{axis:0,dir1:D,dir2:O}),!T&&_[0]&&x.createElement(c.ScalingSphere,{axis:0,direction:W}),!T&&_[1]&&x.createElement(c.ScalingSphere,{axis:1,direction:D}),!T&&_[2]&&x.createElement(c.ScalingSphere,{axis:2,direction:O}))),x.createElement("group",{ref:de},ae))))}));exports.PivotControls=C;

package/web/pivotControls/index.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../../helpers/ts-utils';
+import { OnDragStartProps } from './context';
+export type PivotControlsProps = {
+    enabled?: boolean;
+    scale?: number;
+    lineWidth?: number;
+    fixed?: boolean;
+    offset?: [number, number, number];
+    rotation?: [number, number, number];
+    matrix?: THREE.Matrix4;
+    anchor?: [number, number, number];
+    autoTransform?: boolean;
+    activeAxes?: [boolean, boolean, boolean];
+    disableAxes?: boolean;
+    disableSliders?: boolean;
+    disableRotations?: boolean;
+    disableScaling?: boolean;
+    translationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    rotationLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    scaleLimits?: [[number, number] | undefined, [number, number] | undefined, [number, number] | undefined];
+    axisColors?: [string | number, string | number, string | number];
+    hoveredColor?: string | number;
+    annotations?: boolean;
+    annotationsClass?: string;
+    onDragStart?: (props: OnDragStartProps) => void;
+    onDrag?: (l: THREE.Matrix4, deltaL: THREE.Matrix4, w: THREE.Matrix4, deltaW: THREE.Matrix4) => void;
+    onDragEnd?: () => void;
+    depthTest?: boolean;
+    renderOrder?: number;
+    opacity?: number;
+    visible?: boolean;
+    userData?: {
+        [key: string]: any;
+    };
+    children?: React.ReactNode;
+};
+export declare const PivotControls: ForwardRefComponent<PivotControlsProps, THREE.Group>;