projectRays option for handle

Author: bbohlender

docs/handles/handle-component.md

@@ -53,6 +53,9 @@ Allows disabling automatic binding of the event listeners to the provided handle
 **apply**  
 The `apply` function is used to apply a state modification that originates from a user interaction to the state. This property allows overriding the default apply function, giving the developer complete control over how modifications affect the state. For instance, instead of applying the modification directly, the developer can apply it to their own state management solution. The state management solution can then apply the modification to the handle target.
 
+**projectRays**  
+Allows to configure whether rays from input devices should be projected onto the interaction space (3D plane or 3D Line).
+
 **alwaysUpdate**  
 In situations where the handle target is placed inside a constantly changing group, the `alwaysUpdate` flag ensures that the handle target's transformation is updated every frame to reflect the current state of the handle.
 

packages/handle/src/computations/one-pointer.ts

@@ -65,6 +65,7 @@ export function computeOnePointerHandleTransformState(
   //matrixHelper2 = initialPointerToTargetParentOffset
 
   projectOntoSpace(
+    options.projectRays,
     spaceHelper,
     pointerData.initialPointerWorldPoint,
     pointerData.pointerWorldOrigin,

packages/handle/src/computations/translate-as.ts

@@ -72,13 +72,28 @@ export function computeTranslateAsHandleTransformState(
 
   //compute initial delta between point and target projected on space
   deltaHelper1.setFromMatrixPosition(matrixHelper)
-  projectOntoSpace(space, pointerData.initialPointerWorldPoint, pointerData.pointerWorldOrigin, deltaHelper1, undefined)
+  projectOntoSpace(
+    options.projectRays,
+    space,
+    pointerData.initialPointerWorldPoint,
+    pointerData.pointerWorldOrigin,
+    deltaHelper1,
+    undefined,
+  )
   deltaHelper1.negate().add(pointerData.initialPointerWorldPoint)
 
   //compute current delta between point and target projected on space
   deltaHelper2.setFromMatrixPosition(targetWorldMatrix)
-  projectOntoSpace(space, pointerData.initialPointerWorldPoint, pointerData.pointerWorldOrigin, deltaHelper2, undefined)
   projectOntoSpace(
+    options.projectRays,
+    space,
+    pointerData.initialPointerWorldPoint,
+    pointerData.pointerWorldOrigin,
+    deltaHelper2,
+    undefined,
+  )
+  projectOntoSpace(
+    options.projectRays,
     space,
     pointerData.initialPointerWorldPoint,
     pointerData.pointerWorldOrigin,

packages/handle/src/computations/two-pointer.ts

@@ -69,13 +69,15 @@ export function computeTwoPointerHandleTransformState(
   addSpaceFromTransformOptions(space, qHelper1, storeData.initialTargetRotation, options.scale ?? true, 'scale')
   //project pointers into that space
   projectOntoSpace(
+    options.projectRays,
     space,
     pointer1Data.initialPointerWorldPoint,
     pointer1Data.pointerWorldOrigin,
     vectorHelper1.copy(pointer1Data.pointerWorldPoint),
     pointer1Data.pointerWorldDirection,
   )
   projectOntoSpace(
+    options.projectRays,
     space,
     pointer2Data.initialPointerWorldPoint,
     pointer2Data.pointerWorldOrigin,

packages/handle/src/computations/utils.ts

@@ -210,12 +210,16 @@ function applyTransformOptionsToAxis(
 }
 
 export function projectOntoSpace(
+  projectRays: boolean = true,
   space: Array<Vector3>,
   initialWorldPoint: Vector3,
   worldPointerOrigin: Vector3,
   worldPoint: Vector3,
   worldDirection: Vector3 | undefined,
 ): void {
+  if (!projectRays) {
+    return
+  }
   switch (space.length) {
     case 0:
     case 3:
@@ -382,9 +386,6 @@ const planeHelper = new Plane()
 const normalHelper = new Vector3()
 const vectorHelper = new Vector3()
 
-const _3Degree = (3 / 180) * Math.PI
-const _6Degree = (6 / 180) * Math.PI
-
 function projectOntoPlane(
   _axis1: Vector3,
   _axis2: Vector3,
@@ -396,9 +397,7 @@ function projectOntoPlane(
   normalHelper.crossVectors(_axis1, _axis2).normalize()
   planeHelper.setFromNormalAndCoplanarPoint(normalHelper, initialWorldPoint)
 
-  const angleDifference = worldDirection == null ? 0 : Math.abs(normalHelper.dot(worldDirection))
-
-  if (worldDirection == null || angleDifference < _3Degree) {
+  if (worldDirection == null) {
     //project point onto plane
     planeHelper.projectPoint(worldPoint, worldPoint)
     return
@@ -415,14 +414,6 @@ function projectOntoPlane(
 
   vectorHelper.copy(worldPoint)
   worldPoint.copy(worldPointerOrigin).addScaledVector(worldDirection, distanceAlongDirection)
-
-  if (angleDifference < _6Degree) {
-    //angleDifference is between 3° and 6°
-    //factor = 1 means that we want 100% from worldPoint and 0 from project point
-    const factor = (angleDifference - _3Degree) / _3Degree
-    planeHelper.projectPoint(vectorHelper, vectorHelper)
-    worldPoint.multiplyScalar(factor).addScaledVector(vectorHelper, 1 - factor)
-  }
 }
 
 /**
@@ -435,8 +426,7 @@ export function projectOntoAxis(
   worldPoint: Vector3,
   worldDirection: Vector3 | undefined,
 ): void {
-  const angleDifference = worldDirection == null ? 0 : 1 - Math.abs(axis.dot(worldDirection))
-  if (worldDirection == null || angleDifference < _3Degree) {
+  if (worldDirection == null) {
     projectPointOntoAxis(worldPoint, initialWorldPoint, axis)
     return
   }
@@ -461,13 +451,6 @@ export function projectOntoAxis(
   vectorHelper.copy(worldPoint)
   // 4. Calculate the nearest point on the first line
   worldPoint.copy(initialWorldPoint).addScaledVector(axis, t)
-  if (angleDifference < _6Degree) {
-    //angleDifference is between 3° and 6°
-    //factor = 1 means that we want 100% from worldPoint and 0 from project point
-    const factor = (angleDifference - _3Degree) / _3Degree
-    projectPointOntoAxis(vectorHelper, initialWorldPoint, axis)
-    worldPoint.multiplyScalar(factor).addScaledVector(vectorHelper, 1 - factor)
-  }
 }
 
 export function projectPointOntoAxis(target: Vector3, axisOrigin: Vector3, axisNormal: Vector3) {

packages/handle/src/store.ts

@@ -41,6 +41,11 @@ export type HandleOptions<T> = {
    * @default true
    */
   rotate?: HandleTransformOptions
+  /**
+   * allows to configure whether rays from input devices should be projected onto the interaction space (3D plane or 3D Line).
+   * @default true
+   */
+  projectRays?: boolean
   /**
    * @default true
    */
@@ -129,6 +134,7 @@ export class HandleStore<T>
     }
     const pointerWorldDirection = getWorldDirection(event, vectorHelper) ? vectorHelper.clone() : undefined
 
+    event.intersection.details.type
     this.inputState.set(event.pointerId, {
       pointerWorldDirection,
       pointerWorldPoint: event.point,