@react-three/drei 9.74.11 → 9.74.13

package/src/web/pivotControls/AxisArrow.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 vec1 = new THREE.Vector3();
+const vec2 = 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 = new THREE.Vector3(0, 1, 0);
+const offsetMatrix = new THREE.Matrix4();
+const AxisArrow = ({
+  direction,
+  axis
+}) => {
+  const {
+    translation,
+    translationLimits,
+    annotations,
+    annotationsClass,
+    depthTest,
+    scale,
+    lineWidth,
+    fixed,
+    axisColors,
+    hoveredColor,
+    opacity,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    userData
+  } = React.useContext(context); // @ts-expect-error new in @react-three/fiber@7.0.5
+
+  const camControls = useThree(state => state.controls);
+  const divRef = React.useRef(null);
+  const objRef = React.useRef(null);
+  const clickInfo = React.useRef(null);
+  const offset0 = React.useRef(0);
+  const [isHovered, setIsHovered] = React.useState(false);
+  const onPointerDown = React.useCallback(e => {
+    if (annotations) {
+      divRef.current.innerText = `${translation.current[axis].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();
+    clickInfo.current = {
+      clickPoint,
+      dir
+    };
+    offset0.current = translation.current[axis];
+    onDragStart({
+      component: 'Arrow',
+      axis,
+      origin,
+      directions: [dir]
+    });
+    camControls && (camControls.enabled = false); // @ts-ignore - setPointerCapture is not in the type definition
+
+    e.target.setPointerCapture(e.pointerId);
+  }, [annotations, direction, camControls, onDragStart, translation, axis]);
+  const onPointerMove = React.useCallback(e => {
+    e.stopPropagation();
+    if (!isHovered) setIsHovered(true);
+
+    if (clickInfo.current) {
+      const {
+        clickPoint,
+        dir
+      } = clickInfo.current;
+      const [min, max] = (translationLimits == null ? void 0 : translationLimits[axis]) || [undefined, undefined];
+      let offset = calculateOffset(clickPoint, dir, e.ray.origin, e.ray.direction);
+
+      if (min !== undefined) {
+        offset = Math.max(offset, min - offset0.current);
+      }
+
+      if (max !== undefined) {
+        offset = Math.min(offset, max - offset0.current);
+      }
+
+      translation.current[axis] = offset0.current + offset;
+
+      if (annotations) {
+        divRef.current.innerText = `${translation.current[axis].toFixed(2)}`;
+      }
+
+      offsetMatrix.makeTranslation(dir.x * offset, dir.y * offset, dir.z * offset);
+      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 - releasePointerCapture & PointerEvent#pointerId is not in the type definition
+
+    e.target.releasePointerCapture(e.pointerId);
+  }, [annotations, camControls, onDragEnd]);
+  const onPointerOut = React.useCallback(e => {
+    e.stopPropagation();
+    setIsHovered(false);
+  }, []);
+  const {
+    cylinderLength,
+    coneWidth,
+    coneLength,
+    matrixL
+  } = React.useMemo(() => {
+    const coneWidth = fixed ? lineWidth / scale * 1.6 : scale / 20;
+    const coneLength = fixed ? 0.2 : scale / 5;
+    const cylinderLength = fixed ? 1 - coneLength : scale - coneLength;
+    const quaternion = new THREE.Quaternion().setFromUnitVectors(upV, direction.clone().normalize());
+    const matrixL = new THREE.Matrix4().makeRotationFromQuaternion(quaternion);
+    return {
+      cylinderLength,
+      coneWidth,
+      coneLength,
+      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, -coneLength, 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", {
+    visible: false,
+    position: [0, (cylinderLength + coneLength) / 2.0, 0],
+    userData: userData
+  }, /*#__PURE__*/React.createElement("cylinderGeometry", {
+    args: [coneWidth * 1.4, coneWidth * 1.4, cylinderLength + coneLength, 8, 1]
+  })), /*#__PURE__*/React.createElement(Line, {
+    transparent: true,
+    raycast: () => null,
+    depthTest: depthTest,
+    points: [0, 0, 0, 0, cylinderLength, 0],
+    lineWidth: lineWidth,
+    color: color_,
+    opacity: opacity,
+    polygonOffset: true,
+    renderOrder: 1,
+    polygonOffsetFactor: -10,
+    fog: false
+  }), /*#__PURE__*/React.createElement("mesh", {
+    raycast: () => null,
+    position: [0, cylinderLength + coneLength / 2.0, 0],
+    renderOrder: 500
+  }, /*#__PURE__*/React.createElement("coneGeometry", {
+    args: [coneWidth, coneLength, 24, 1]
+  }), /*#__PURE__*/React.createElement("meshBasicMaterial", {
+    transparent: true,
+    depthTest: depthTest,
+    color: color_,
+    opacity: opacity,
+    polygonOffset: true,
+    polygonOffsetFactor: -10,
+    fog: false
+  }))));
+};
+
+export { AxisArrow, calculateOffset };

package/src/web/pivotControls/AxisRotator.js

@@ -0,0 +1,235 @@
+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 clamp from 'lodash.clamp';
+import { context } from './context.js';
+
+const clickDir = new THREE.Vector3();
+const intersectionDir = new THREE.Vector3();
+
+const toDegrees = radians => radians * 180 / Math.PI;
+
+const toRadians = degrees => degrees * Math.PI / 180;
+
+const calculateAngle = (clickPoint, intersectionPoint, origin, e1, e2) => {
+  clickDir.copy(clickPoint).sub(origin);
+  intersectionDir.copy(intersectionPoint).sub(origin);
+  const dote1e1 = e1.dot(e1);
+  const dote2e2 = e2.dot(e2);
+  const uClick = clickDir.dot(e1) / dote1e1;
+  const vClick = clickDir.dot(e2) / dote2e2;
+  const uIntersection = intersectionDir.dot(e1) / dote1e1;
+  const vIntersection = intersectionDir.dot(e2) / dote2e2;
+  const angleClick = Math.atan2(vClick, uClick);
+  const angleIntersection = Math.atan2(vIntersection, uIntersection);
+  return angleIntersection - angleClick;
+};
+
+const fmod = (num, denom) => {
+  let k = Math.floor(num / denom);
+  k = k < 0 ? k + 1 : k;
+  return num - k * denom;
+};
+
+const minimizeAngle = angle => {
+  let result = fmod(angle, 2 * Math.PI);
+
+  if (Math.abs(result) < 1e-6) {
+    return 0.0;
+  }
+
+  if (result < 0.0) {
+    result += 2 * Math.PI;
+  }
+
+  return result;
+};
+
+const rotMatrix = new THREE.Matrix4();
+const posNew = new THREE.Vector3();
+const ray = new THREE.Ray();
+const intersection = new THREE.Vector3();
+const AxisRotator = ({
+  dir1,
+  dir2,
+  axis
+}) => {
+  const {
+    rotationLimits,
+    annotations,
+    annotationsClass,
+    depthTest,
+    scale,
+    lineWidth,
+    fixed,
+    axisColors,
+    hoveredColor,
+    opacity,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    userData
+  } = React.useContext(context); // @ts-expect-error new in @react-three/fiber@7.0.5
+
+  const camControls = useThree(state => state.controls);
+  const divRef = React.useRef(null);
+  const objRef = React.useRef(null);
+  const angle0 = React.useRef(0);
+  const angle = React.useRef(0);
+  const clickInfo = React.useRef(null);
+  const [isHovered, setIsHovered] = React.useState(false);
+  const onPointerDown = React.useCallback(e => {
+    if (annotations) {
+      divRef.current.innerText = `${toDegrees(angle.current).toFixed(0)}º`;
+      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,
+      origin,
+      e1,
+      e2,
+      normal,
+      plane
+    };
+    onDragStart({
+      component: 'Rotator',
+      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,
+        origin,
+        e1,
+        e2,
+        normal,
+        plane
+      } = clickInfo.current;
+      const [min, max] = (rotationLimits == null ? void 0 : rotationLimits[axis]) || [undefined, undefined];
+      ray.copy(e.ray);
+      ray.intersectPlane(plane, intersection);
+      ray.direction.negate();
+      ray.intersectPlane(plane, intersection);
+      let deltaAngle = calculateAngle(clickPoint, intersection, origin, e1, e2);
+      let degrees = toDegrees(deltaAngle); // @ts-ignore
+
+      if (e.shiftKey) {
+        degrees = Math.round(degrees / 10) * 10;
+        deltaAngle = toRadians(degrees);
+      }
+
+      if (min !== undefined && max !== undefined && max - min < 2 * Math.PI) {
+        deltaAngle = minimizeAngle(deltaAngle);
+        deltaAngle = deltaAngle > Math.PI ? deltaAngle - 2 * Math.PI : deltaAngle;
+        deltaAngle = clamp(deltaAngle, min - angle0.current, max - angle0.current);
+        angle.current = angle0.current + deltaAngle;
+      } else {
+        angle.current = minimizeAngle(angle0.current + deltaAngle);
+        angle.current = angle.current > Math.PI ? angle.current - 2 * Math.PI : angle.current;
+      }
+
+      if (annotations) {
+        degrees = toDegrees(angle.current);
+        divRef.current.innerText = `${degrees.toFixed(0)}º`;
+      }
+
+      rotMatrix.makeRotationAxis(normal, deltaAngle);
+      posNew.copy(origin).applyMatrix4(rotMatrix).sub(origin).negate();
+      rotMatrix.setPosition(posNew);
+      onDrag(rotMatrix);
+    }
+  }, [annotations, onDrag, isHovered, rotationLimits, axis]);
+  const onPointerUp = React.useCallback(e => {
+    if (annotations) {
+      divRef.current.style.display = 'none';
+    }
+
+    e.stopPropagation();
+    angle0.current = angle.current;
+    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 r = fixed ? 0.65 : scale * 0.65;
+  const arc = React.useMemo(() => {
+    const segments = 32;
+    const points = [];
+
+    for (let j = 0; j <= segments; j++) {
+      const angle = j * (Math.PI / 2) / segments;
+      points.push(new THREE.Vector3(Math.cos(angle) * r, Math.sin(angle) * r, 0));
+    }
+
+    return points;
+  }, [r]);
+  return /*#__PURE__*/React.createElement("group", {
+    ref: objRef,
+    onPointerDown: onPointerDown,
+    onPointerMove: onPointerMove,
+    onPointerUp: onPointerUp,
+    onPointerOut: onPointerOut,
+    matrix: matrixL,
+    matrixAutoUpdate: false
+  }, annotations && /*#__PURE__*/React.createElement(Html, {
+    position: [r, r, 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(Line, {
+    points: arc,
+    lineWidth: lineWidth * 4,
+    visible: false,
+    userData: userData
+  }), /*#__PURE__*/React.createElement(Line, {
+    transparent: true,
+    raycast: () => null,
+    depthTest: depthTest,
+    points: arc,
+    lineWidth: lineWidth,
+    color: isHovered ? hoveredColor : axisColors[axis],
+    opacity: opacity,
+    polygonOffset: true,
+    polygonOffsetFactor: -10,
+    fog: false
+  }));
+};
+
+export { AxisRotator };

package/src/web/pivotControls/PlaneSlider.js

@@ -0,0 +1,211 @@
+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 = new THREE.Ray();
+const intersection = new THREE.Vector3();
+const offsetMatrix = new THREE.Matrix4();
+const PlaneSlider = ({
+  dir1,
+  dir2,
+  axis
+}) => {
+  const {
+    translation,
+    translationLimits,
+    annotations,
+    annotationsClass,
+    depthTest,
+    scale,
+    lineWidth,
+    fixed,
+    axisColors,
+    hoveredColor,
+    opacity,
+    onDragStart,
+    onDrag,
+    onDragEnd,
+    userData
+  } = React.useContext(context); // @ts-expect-error new in @react-three/fiber@7.0.5
+
+  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
+  }, /*#__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
+  })));
+};
+
+export { PlaneSlider };

package/src/web/pivotControls/context.js

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