@forgeax/engine-picking 0.1.32 → 0.1.34

package/src/pick-triangle.ts

@@ -8,7 +8,6 @@
 import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
 import type { EntityHandle, World } from '@forgeax/engine-ecs';
 import { mat4, ray, type Vec3Like, vec3 } from '@forgeax/engine-math';
-import type { InstanceCollectionId, InstanceCollectionStore } from '@forgeax/engine-render';
 import { Instances, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { GlobalTransform, Transform } from '@forgeax/engine-scene';
 import type { MeshAsset } from '@forgeax/engine-types';
@@ -50,8 +49,6 @@ export type TrianglePickResult =
 export interface TrianglePickOptions {
   /** Resolve a loaded MeshAsset payload to its existing Catalog GUID. */
   readonly assetGuidOf?: (asset: MeshAsset) => string | undefined;
-  /** Read explicit instance matrices without advancing the renderer upload cursor. */
-  readonly instances?: Pick<InstanceCollectionStore, 'peek'>;
 }
 
 function narrowPosition(position: MeshAsset['attributes']['position']): Float32Array | undefined {
@@ -155,19 +152,13 @@ export function pickTriangle(
     let instanceTransforms: Float32Array | undefined;
     let instanceCount = 1;
     if (instancesData !== undefined) {
-      if (options.instances === undefined) {
+      instanceTransforms = instancesData.transforms;
+      if (instanceTransforms.length % 16 !== 0 || !instanceTransforms.every(Number.isFinite)) {
         unsupportedReason ??= 'instance-transforms-unavailable';
         unsupportedEntities.push(entity);
         continue;
       }
-      const snapshot = options.instances.peek(instancesData.collectionId as InstanceCollectionId);
-      if (!snapshot.ok) {
-        unsupportedReason ??= 'instance-transforms-unavailable';
-        unsupportedEntities.push(entity);
-        continue;
-      }
-      instanceTransforms = snapshot.value.transforms;
-      instanceCount = snapshot.value.count;
+      instanceCount = instanceTransforms.length / 16;
     }
 
     const positions = narrowPosition(mesh.attributes.position);

package/src/pick-vertex.ts

@@ -50,7 +50,7 @@ import { MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { GlobalTransform, Transform } from '@forgeax/engine-scene';
 import type { MeshAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
-import { computeScreenRay, readWorldMatrix } from './pick-core';
+import { computeScreenRay, readWorldMatrix, type ScreenRay } from './pick-core';
 
 // ── types ────────────────────────────────────────────────────────────────
 
@@ -197,24 +197,22 @@ function narrowPosition(
  */
 function collectVertexHits(
   world: World,
-  cameraEntity: EntityHandle,
+  cameraEntity: EntityHandle | undefined,
   screenX: number,
   screenY: number,
   viewportWidth: number,
   viewportHeight: number,
   entity: EntityHandle,
+  screenRayOverride?: ScreenRay,
 ): VertexHit[] {
   // ── camera validation + view/projection + screen->world ray (pick-core skeleton) ──
   // Throws PickError('camera-component-missing') when cameraEntity has no Camera;
   // returns undefined when the camera has no resolvable GlobalTransform.world (D-9 preamble miss).
-  const screenRay = computeScreenRay(
-    world,
-    cameraEntity,
-    screenX,
-    screenY,
-    viewportWidth,
-    viewportHeight,
-  );
+  const screenRay =
+    screenRayOverride ??
+    (cameraEntity === undefined
+      ? undefined
+      : computeScreenRay(world, cameraEntity, screenX, screenY, viewportWidth, viewportHeight));
   if (screenRay === undefined) {
     return [];
   }
@@ -446,14 +444,39 @@ export function pickVertexOnEntity(
   entity: EntityHandle,
   options?: { limit: number },
 ): VertexHit | VertexHit[] | undefined {
+  return pickVertexOnEntityWithScreenRay(
+    world,
+    computeScreenRay(world, cameraEntity, screenX, screenY, viewportWidth, viewportHeight),
+    screenX,
+    screenY,
+    viewportWidth,
+    viewportHeight,
+    entity,
+    options,
+  );
+}
+
+/** Query one entity using a receipt-bound screen ray from the accepted frame. */
+export function pickVertexOnEntityWithScreenRay(
+  world: World,
+  screenRay: ScreenRay | undefined,
+  screenX: number,
+  screenY: number,
+  viewportWidth: number,
+  viewportHeight: number,
+  entity: EntityHandle,
+  options?: { limit: number },
+): VertexHit | VertexHit[] | undefined {
+  if (screenRay === undefined) return options === undefined ? undefined : [];
   const candidates = collectVertexHits(
     world,
-    cameraEntity,
+    undefined,
     screenX,
     screenY,
     viewportWidth,
     viewportHeight,
     entity,
+    screenRay,
   );
 
   // ── sort by screenDist ascending ──
@@ -534,6 +557,47 @@ export function pickVertex(
     viewportWidth,
     viewportHeight,
   );
+  return pickVertexFromScreenRay(
+    world,
+    screenRay,
+    screenX,
+    screenY,
+    viewportWidth,
+    viewportHeight,
+    options,
+  );
+}
+
+/** Query all entities using a receipt-bound screen ray from the accepted frame. */
+export function pickVertexWithScreenRay(
+  world: World,
+  screenRay: ScreenRay | undefined,
+  screenX: number,
+  screenY: number,
+  viewportWidth: number,
+  viewportHeight: number,
+  options?: { limit: number },
+): VertexHit | VertexHit[] | undefined {
+  return pickVertexFromScreenRay(
+    world,
+    screenRay,
+    screenX,
+    screenY,
+    viewportWidth,
+    viewportHeight,
+    options,
+  );
+}
+
+function pickVertexFromScreenRay(
+  world: World,
+  screenRay: ScreenRay | undefined,
+  screenX: number,
+  screenY: number,
+  viewportWidth: number,
+  viewportHeight: number,
+  options?: { limit: number },
+): VertexHit | VertexHit[] | undefined {
   if (screenRay === undefined) {
     if (options) return [];
     return undefined;
@@ -574,12 +638,13 @@ export function pickVertex(
     // Collect vertices for this entity
     const entityHits = collectVertexHits(
       world,
-      cameraEntity,
+      undefined,
       screenX,
       screenY,
       viewportWidth,
       viewportHeight,
       entity,
+      screenRay,
     );
     for (const h of entityHits) {
       allCandidates.push(h);

package/src/pick.ts

@@ -39,7 +39,7 @@ import { MeshFilter, MeshRenderer } from '@forgeax/engine-render';
 import { GlobalTransform, Transform } from '@forgeax/engine-scene';
 import type { MeshAsset } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
-import { computeScreenRay, readWorldMatrix } from './pick-core';
+import { computeScreenRay, readWorldMatrix, type ScreenRay } from './pick-core';
 
 /**
  * Result of a successful screen-to-entity pick.
@@ -92,6 +92,11 @@ export function pick(
     viewportHeight,
   );
   if (screenRay === undefined) return undefined;
+  return pickWithScreenRay(world, screenRay);
+}
+
+/** Raycast using a receipt-bound screen ray from the accepted render frame. */
+export function pickWithScreenRay(world: World, screenRay: ScreenRay): PickHit | undefined {
   const r = screenRay.ray;
 
   const query = world