@aura3d/controls 1.0.6

package/src/Picking.ts

@@ -0,0 +1,234 @@
+import {
+  ControlVector3,
+  traverseControlObject,
+  type ControlObject3DLike,
+  type ControlPickMetadata,
+  type Vector3Like
+} from "./NativeControlTypes";
+
+export interface ThreeCompatPickResult {
+  readonly object: ControlObject3DLike;
+  readonly distance: number;
+  readonly distanceAlongRay: number;
+  readonly perpendicularDistance: number;
+  readonly point: ControlVector3;
+  readonly radius: number;
+  readonly metadata?: ControlPickMetadata;
+}
+
+export interface PickingOptions {
+  readonly near?: number;
+  readonly far?: number;
+  readonly tolerance?: number;
+  readonly includeInvisible?: boolean;
+  readonly includeNonRenderableMetadata?: boolean;
+  readonly metadata?: (object: ControlObject3DLike) => ControlPickMetadata | undefined;
+}
+
+export interface PickingDiagnostics {
+  readonly testedObjects: number;
+  readonly candidateObjects: number;
+  readonly hitCount: number;
+  readonly skippedInvisible: number;
+  readonly skippedNonPickable: number;
+  readonly skippedDisabled: number;
+  readonly skippedOutOfRange: number;
+  readonly skippedMissedRadius: number;
+  readonly nearestMissPerpendicularDistance: number | null;
+  readonly nearestHitLabel: string | null;
+}
+
+export interface PickingReport {
+  readonly hit: ThreeCompatPickResult | null;
+  readonly hits: readonly ThreeCompatPickResult[];
+  readonly diagnostics: PickingDiagnostics;
+}
+
+export class Picking {
+  pick(
+    root: ControlObject3DLike,
+    origin: Vector3Like = new ControlVector3(),
+    direction: Vector3Like = new ControlVector3(0, 0, -1),
+    options: PickingOptions = {}
+  ): ThreeCompatPickResult | null {
+    return this.report(root, origin, direction, options).hit;
+  }
+
+  pickAll(
+    root: ControlObject3DLike,
+    origin: Vector3Like = new ControlVector3(),
+    direction: Vector3Like = new ControlVector3(0, 0, -1),
+    options: PickingOptions = {}
+  ): readonly ThreeCompatPickResult[] {
+    return this.report(root, origin, direction, options).hits;
+  }
+
+  report(
+    root: ControlObject3DLike,
+    origin: Vector3Like = new ControlVector3(),
+    direction: Vector3Like = new ControlVector3(0, 0, -1),
+    options: PickingOptions = {}
+  ): PickingReport {
+    const normalizedDirection = normalizedRayDirection(direction);
+    const near = finiteRange(options.near ?? 0, "near", 0);
+    const far = finiteRange(options.far ?? Number.POSITIVE_INFINITY, "far", near);
+    const tolerance = finiteRange(options.tolerance ?? 0, "tolerance", 0);
+    const hits: ThreeCompatPickResult[] = [];
+    const counters = {
+      testedObjects: 0,
+      candidateObjects: 0,
+      skippedInvisible: 0,
+      skippedNonPickable: 0,
+      skippedDisabled: 0,
+      skippedOutOfRange: 0,
+      skippedMissedRadius: 0
+    };
+    let nearestMissPerpendicularDistance = Number.POSITIVE_INFINITY;
+
+    traverseControlObject(root, (object) => {
+      counters.testedObjects += 1;
+      if (object.visible === false && options.includeInvisible !== true) {
+        counters.skippedInvisible += 1;
+        return;
+      }
+      const metadata = resolvePickMetadata(object, options);
+      if (metadata?.selectable === false) {
+        counters.skippedDisabled += 1;
+        return;
+      }
+      if (!isPickableObject(object, metadata, options)) {
+        counters.skippedNonPickable += 1;
+        return;
+      }
+      counters.candidateObjects += 1;
+      const toObject = new ControlVector3(
+        object.position.x - origin.x,
+        object.position.y - origin.y,
+        object.position.z - origin.z
+      );
+      const distanceAlongRay = dot(toObject, normalizedDirection);
+      if (distanceAlongRay < near || distanceAlongRay > far) {
+        counters.skippedOutOfRange += 1;
+        return;
+      }
+      const closestPoint = pointOnRay(origin, normalizedDirection, distanceAlongRay);
+      const perpendicularDistance = new ControlVector3(
+        object.position.x - closestPoint.x,
+        object.position.y - closestPoint.y,
+        object.position.z - closestPoint.z
+      ).length();
+      const radius = resolvePickRadius(object, metadata) + tolerance;
+      if (perpendicularDistance > radius) {
+        counters.skippedMissedRadius += 1;
+        nearestMissPerpendicularDistance = Math.min(nearestMissPerpendicularDistance, perpendicularDistance);
+        return;
+      }
+      const rayEntryDistance = Math.max(near, distanceAlongRay - Math.sqrt(Math.max(0, radius * radius - perpendicularDistance * perpendicularDistance)));
+      hits.push({
+        object,
+        distance: rayEntryDistance,
+        distanceAlongRay,
+        perpendicularDistance,
+        point: pointOnRay(origin, normalizedDirection, rayEntryDistance),
+        radius,
+        metadata
+      });
+    });
+
+    hits.sort(compareHits);
+    const hit = hits[0] ?? null;
+    return {
+      hit,
+      hits,
+      diagnostics: {
+        ...counters,
+        hitCount: hits.length,
+        nearestMissPerpendicularDistance: Number.isFinite(nearestMissPerpendicularDistance) ? nearestMissPerpendicularDistance : null,
+        nearestHitLabel: hit ? pickLabel(hit.object, hit.metadata) : null
+      }
+    };
+  }
+}
+
+function normalizedRayDirection(direction: Vector3Like): ControlVector3 {
+  const normalized = new ControlVector3(direction.x, direction.y, direction.z);
+  const length = normalized.length();
+  if (!Number.isFinite(length) || length <= 1e-8) {
+    throw new RangeError("Picking ray direction must be finite and non-zero.");
+  }
+  return normalized.set(normalized.x / length, normalized.y / length, normalized.z / length);
+}
+
+function finiteRange(value: number, label: string, minimum: number): number {
+  if (value === Number.POSITIVE_INFINITY && label === "far") return value;
+  if (!Number.isFinite(value) || value < minimum) {
+    throw new RangeError(`Picking ${label} must be finite and >= ${minimum}.`);
+  }
+  return value;
+}
+
+function resolvePickMetadata(object: ControlObject3DLike, options: PickingOptions): ControlPickMetadata | undefined {
+  return options.metadata?.(object)
+    ?? object.picking
+    ?? readUserDataMetadata(object.userData);
+}
+
+function readUserDataMetadata(userData: Record<string, unknown> | undefined): ControlPickMetadata | undefined {
+  const value = userData?.a3dPicking ?? userData?.picking;
+  if (!value || typeof value !== "object") return undefined;
+  return value as ControlPickMetadata;
+}
+
+function isPickableObject(
+  object: ControlObject3DLike,
+  metadata: ControlPickMetadata | undefined,
+  options: PickingOptions
+): boolean {
+  if (metadata && options.includeNonRenderableMetadata !== false) return true;
+  return object.type === "Mesh" || object.type === "Sprite" || object.type === "Points" || object.type === "LineSegments";
+}
+
+function resolvePickRadius(object: ControlObject3DLike, metadata: ControlPickMetadata | undefined): number {
+  const explicit = metadata?.pickRadius ?? object.pickRadius ?? readUserDataRadius(object.userData);
+  if (explicit !== undefined) return positiveFinite(explicit, "pickRadius");
+  const scale = object.scale;
+  if (!scale) return 0.5;
+  const radius = Math.max(Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z)) * 0.5;
+  return Number.isFinite(radius) && radius > 0 ? radius : 0.5;
+}
+
+function readUserDataRadius(userData: Record<string, unknown> | undefined): number | undefined {
+  const value = userData?.a3dPickRadius;
+  return typeof value === "number" ? value : undefined;
+}
+
+function positiveFinite(value: number, label: string): number {
+  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`Picking ${label} must be finite and positive.`);
+  return value;
+}
+
+function dot(left: Vector3Like, right: Vector3Like): number {
+  return left.x * right.x + left.y * right.y + left.z * right.z;
+}
+
+function pointOnRay(origin: Vector3Like, direction: Vector3Like, distance: number): ControlVector3 {
+  return new ControlVector3(
+    origin.x + direction.x * distance,
+    origin.y + direction.y * distance,
+    origin.z + direction.z * distance
+  );
+}
+
+function compareHits(left: ThreeCompatPickResult, right: ThreeCompatPickResult): number {
+  const distanceDelta = left.distance - right.distance;
+  if (Math.abs(distanceDelta) > 1e-8) return distanceDelta;
+  return pickPriority(right) - pickPriority(left);
+}
+
+function pickPriority(hit: ThreeCompatPickResult): number {
+  return hit.metadata?.priority ?? hit.object.pickPriority ?? 0;
+}
+
+function pickLabel(object: ControlObject3DLike, metadata: ControlPickMetadata | undefined): string | null {
+  return metadata?.label ?? metadata?.id ?? object.name ?? null;
+}

package/src/PickingAnnotations.ts

@@ -0,0 +1,391 @@
+import { Picking, type PickingOptions, type PickingReport, type ThreeCompatPickResult } from "./Picking";
+import { ControlVector3, type ControlObject3DLike, type ControlPickMetadata, type Vector3Like } from "./NativeControlTypes";
+
+export type PickingAnnotationKind = "hotspot" | "label" | "district" | "building" | "robot" | "entity";
+export type PickingAnnotationSource = "imported-gltf" | "procedural" | "screen-space";
+export type PickingAnnotationHitPolicy = "nearest" | "priority";
+
+export interface PickingAnnotation<TPayload = unknown> {
+  readonly id: string;
+  readonly label: string;
+  readonly kind: PickingAnnotationKind;
+  readonly position: Vector3Like | readonly [number, number, number];
+  readonly radius: number;
+  readonly priority?: number;
+  readonly group?: string;
+  readonly routeId?: string;
+  readonly source?: PickingAnnotationSource;
+  readonly selectable?: boolean;
+  readonly highlightable?: boolean;
+  readonly targetId?: string;
+  readonly payload?: TPayload;
+}
+
+export interface PickingAnnotationRoot<TPayload = unknown> extends ControlObject3DLike {
+  readonly type: "PickingAnnotationRoot";
+  readonly name: string;
+  readonly children: readonly PickingAnnotationObject<TPayload>[];
+}
+
+export interface PickingAnnotationObject<TPayload = unknown> extends ControlObject3DLike {
+  readonly type: "PickingAnnotation";
+  readonly name: string;
+  readonly picking: ControlPickMetadata;
+  readonly userData: {
+    readonly a3dPicking: ControlPickMetadata;
+    readonly a3dPickingAnnotation: PickingAnnotation<TPayload>;
+  };
+}
+
+export interface PickingAnnotationReport<TPayload = unknown> extends PickingReport {
+  readonly annotation: PickingAnnotation<TPayload> | null;
+  readonly annotations: readonly PickingAnnotation<TPayload>[];
+}
+
+export interface PickingAnnotationOptions extends PickingOptions {
+  readonly hitPolicy?: PickingAnnotationHitPolicy;
+}
+
+export interface ImportedGlbHotspotDescriptor<TPayload = unknown> {
+  readonly id?: string;
+  readonly nodeName?: string;
+  readonly label?: string;
+  readonly focusId?: string;
+  readonly position: Vector3Like | readonly [number, number, number];
+  readonly radius?: number;
+  readonly priority?: number;
+  readonly selectable?: boolean;
+  readonly highlightable?: boolean;
+  readonly payload?: TPayload;
+}
+
+export interface DistrictPickingDescriptor<TPayload = unknown> {
+  readonly id: string;
+  readonly label?: string;
+  readonly center: Vector3Like | readonly [number, number, number];
+  readonly radius: number;
+  readonly priority?: number;
+  readonly routeId?: string;
+  readonly payload?: TPayload;
+  readonly buildings?: readonly BuildingPickingDescriptor<TPayload>[];
+}
+
+export interface BuildingPickingDescriptor<TPayload = unknown> {
+  readonly id: string;
+  readonly label?: string;
+  readonly position: Vector3Like | readonly [number, number, number];
+  readonly radius: number;
+  readonly priority?: number;
+  readonly payload?: TPayload;
+}
+
+export interface EntityPickingDescriptor<TPayload = unknown> {
+  readonly id: string;
+  readonly label?: string;
+  readonly kind?: "robot" | "entity";
+  readonly position: Vector3Like | readonly [number, number, number];
+  readonly radius: number;
+  readonly priority?: number;
+  readonly group?: string;
+  readonly routeId?: string;
+  readonly payload?: TPayload;
+}
+
+export interface ScreenPickingAnnotation<TPayload = unknown> {
+  readonly id: string;
+  readonly label: string;
+  readonly kind: PickingAnnotationKind;
+  readonly x: number;
+  readonly y: number;
+  readonly radius: number;
+  readonly priority?: number;
+  readonly group?: string;
+  readonly routeId?: string;
+  readonly source?: PickingAnnotationSource;
+  readonly selectable?: boolean;
+  readonly highlightable?: boolean;
+  readonly targetId?: string;
+  readonly payload?: TPayload;
+}
+
+export interface ScreenPickingHit<TPayload = unknown> {
+  readonly annotation: ScreenPickingAnnotation<TPayload>;
+  readonly distance: number;
+}
+
+export interface ScreenPickingReport<TPayload = unknown> {
+  readonly hit: ScreenPickingHit<TPayload> | null;
+  readonly hits: readonly ScreenPickingHit<TPayload>[];
+  readonly diagnostics: {
+    readonly testedAnnotations: number;
+    readonly candidateAnnotations: number;
+    readonly hitCount: number;
+    readonly skippedDisabled: number;
+    readonly skippedOutOfRadius: number;
+    readonly nearestHitLabel: string | null;
+  };
+}
+
+export interface ScreenPickingOptions {
+  readonly tolerance?: number;
+  readonly hitPolicy?: PickingAnnotationHitPolicy;
+}
+
+export function createPickingAnnotationRoot<TPayload = unknown>(
+  name: string,
+  annotations: readonly PickingAnnotation<TPayload>[]
+): PickingAnnotationRoot<TPayload> {
+  return {
+    type: "PickingAnnotationRoot",
+    name,
+    position: new ControlVector3(),
+    children: annotations.map(createPickingAnnotationObject)
+  };
+}
+
+export function createPickingAnnotationObject<TPayload = unknown>(
+  annotation: PickingAnnotation<TPayload>
+): PickingAnnotationObject<TPayload> {
+  const radius = positiveFinite(annotation.radius, "annotation radius");
+  const metadata: ControlPickMetadata = {
+    id: annotation.id,
+    label: annotation.label,
+    kind: annotation.kind,
+    group: annotation.group,
+    selectable: annotation.selectable,
+    highlightable: annotation.highlightable,
+    pickRadius: radius,
+    priority: annotation.priority,
+    routeId: annotation.routeId,
+    source: annotation.source,
+    targetId: annotation.targetId,
+    payload: annotation.payload
+  };
+  return {
+    type: "PickingAnnotation",
+    name: annotation.label,
+    position: toVector3(annotation.position),
+    scale: new ControlVector3(radius * 2, radius * 2, radius * 2),
+    visible: annotation.selectable === false ? false : true,
+    pickRadius: radius,
+    pickPriority: annotation.priority,
+    picking: metadata,
+    userData: {
+      a3dPicking: metadata,
+      a3dPickingAnnotation: annotation
+    }
+  };
+}
+
+export function pickAnnotation<TPayload = unknown>(
+  root: ControlObject3DLike,
+  origin: Vector3Like = new ControlVector3(),
+  direction: Vector3Like = new ControlVector3(0, 0, -1),
+  options: PickingAnnotationOptions = {}
+): PickingAnnotationReport<TPayload> {
+  const report = new Picking().report(root, origin, direction, options);
+  const hits = options.hitPolicy === "priority"
+    ? [...report.hits].sort(compareAnnotationHitsByPriority)
+    : report.hits;
+  const hit = hits[0] ?? null;
+  return {
+    ...report,
+    hit,
+    hits,
+    annotation: hit ? annotationFromPickHit<TPayload>(hit) : null,
+    annotations: hits.map((candidate) => annotationFromPickHit<TPayload>(candidate)).filter((annotation): annotation is PickingAnnotation<TPayload> => Boolean(annotation))
+  };
+}
+
+export function annotationFromPickHit<TPayload = unknown>(
+  hit: ThreeCompatPickResult | null | undefined
+): PickingAnnotation<TPayload> | null {
+  const value = hit?.object.userData?.a3dPickingAnnotation;
+  return isPickingAnnotation(value) ? value as PickingAnnotation<TPayload> : null;
+}
+
+export function createImportedGlbHotspotAnnotations<TPayload = unknown>(
+  assetId: string,
+  hotspots: readonly ImportedGlbHotspotDescriptor<TPayload>[],
+  routeId?: string
+): readonly PickingAnnotation<TPayload>[] {
+  return hotspots.map((hotspot, index) => {
+    const targetId = hotspot.focusId ?? hotspot.nodeName ?? hotspot.id ?? `hotspot-${index}`;
+    return {
+      id: hotspot.id ?? `${assetId}:${targetId}`,
+      label: hotspot.label ?? readableLabel(targetId),
+      kind: "hotspot",
+      position: hotspot.position,
+      radius: hotspot.radius ?? 0.18,
+      priority: hotspot.priority ?? 100,
+      group: assetId,
+      routeId,
+      source: "imported-gltf",
+      selectable: hotspot.selectable,
+      highlightable: hotspot.highlightable ?? true,
+      targetId,
+      payload: hotspot.payload
+    };
+  });
+}
+
+export function createDistrictPickingAnnotations<TPayload = unknown>(
+  districts: readonly DistrictPickingDescriptor<TPayload>[]
+): readonly PickingAnnotation<TPayload>[] {
+  const annotations: PickingAnnotation<TPayload>[] = [];
+  for (const district of districts) {
+    annotations.push({
+      id: district.id,
+      label: district.label ?? readableLabel(district.id),
+      kind: "district",
+      position: district.center,
+      radius: district.radius,
+      priority: district.priority ?? 10,
+      group: "district",
+      routeId: district.routeId,
+      source: "procedural",
+      highlightable: true,
+      payload: district.payload
+    });
+    for (const building of district.buildings ?? []) {
+      annotations.push({
+        id: building.id,
+        label: building.label ?? readableLabel(building.id),
+        kind: "building",
+        position: building.position,
+        radius: building.radius,
+        priority: building.priority ?? 40,
+        group: district.id,
+        routeId: district.routeId,
+        source: "procedural",
+        highlightable: true,
+        payload: building.payload
+      });
+    }
+  }
+  return annotations;
+}
+
+export function createRobotPickingAnnotations<TPayload = unknown>(
+  robots: readonly EntityPickingDescriptor<TPayload>[]
+): readonly PickingAnnotation<TPayload>[] {
+  return createEntityPickingAnnotations(robots.map((robot) => ({ ...robot, kind: "robot" as const })), {
+    defaultGroup: "robot",
+    defaultPriority: 70
+  });
+}
+
+export function createEntityPickingAnnotations<TPayload = unknown>(
+  entities: readonly EntityPickingDescriptor<TPayload>[],
+  options: { readonly defaultGroup?: string; readonly defaultPriority?: number } = {}
+): readonly PickingAnnotation<TPayload>[] {
+  return entities.map((entity) => ({
+    id: entity.id,
+    label: entity.label ?? readableLabel(entity.id),
+    kind: entity.kind ?? "entity",
+    position: entity.position,
+    radius: entity.radius,
+    priority: entity.priority ?? options.defaultPriority ?? 50,
+    group: entity.group ?? options.defaultGroup,
+    routeId: entity.routeId,
+    source: "procedural",
+    highlightable: true,
+    targetId: entity.id,
+    payload: entity.payload
+  }));
+}
+
+export function pickScreenSpaceAnnotation<TPayload = unknown>(
+  pointer: { readonly x: number; readonly y: number },
+  annotations: readonly ScreenPickingAnnotation<TPayload>[],
+  options: ScreenPickingOptions = {}
+): ScreenPickingReport<TPayload> {
+  validateScreenPoint(pointer, "pointer");
+  const tolerance = options.tolerance ?? 0;
+  if (!Number.isFinite(tolerance) || tolerance < 0) throw new RangeError("Screen picking tolerance must be finite and non-negative.");
+  const hits: ScreenPickingHit<TPayload>[] = [];
+  let skippedDisabled = 0;
+  let skippedOutOfRadius = 0;
+
+  for (const annotation of annotations) {
+    if (annotation.selectable === false) {
+      skippedDisabled += 1;
+      continue;
+    }
+    validateScreenPoint(annotation, annotation.id);
+    const radius = positiveFinite(annotation.radius, `${annotation.id} screen radius`) + tolerance;
+    const distance = Math.hypot(pointer.x - annotation.x, pointer.y - annotation.y);
+    if (distance > radius) {
+      skippedOutOfRadius += 1;
+      continue;
+    }
+    hits.push({ annotation, distance });
+  }
+
+  hits.sort(options.hitPolicy === "priority" ? compareScreenHitsByPriority : compareScreenHitsByDistance);
+  const hit = hits[0] ?? null;
+  return {
+    hit,
+    hits,
+    diagnostics: {
+      testedAnnotations: annotations.length,
+      candidateAnnotations: annotations.length - skippedDisabled,
+      hitCount: hits.length,
+      skippedDisabled,
+      skippedOutOfRadius,
+      nearestHitLabel: hit?.annotation.label ?? null
+    }
+  };
+}
+
+function toVector3(value: Vector3Like | readonly [number, number, number]): ControlVector3 {
+  const tuple = value as readonly number[];
+  const vector = value as Vector3Like;
+  const x = Array.isArray(value) ? tuple[0] : vector.x;
+  const y = Array.isArray(value) ? tuple[1] : vector.y;
+  const z = Array.isArray(value) ? tuple[2] : vector.z;
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
+    throw new RangeError("Picking annotation position must contain three finite values.");
+  }
+  return new ControlVector3(x, y, z);
+}
+
+function positiveFinite(value: number, label: string): number {
+  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`Picking ${label} must be finite and positive.`);
+  return value;
+}
+
+function readableLabel(value: string): string {
+  return value.replace(/[_:-]+/g, " ").replace(/\s+/g, " ").trim() || "Picking target";
+}
+
+function compareAnnotationHitsByPriority(left: ThreeCompatPickResult, right: ThreeCompatPickResult): number {
+  const priorityDelta = (right.metadata?.priority ?? 0) - (left.metadata?.priority ?? 0);
+  if (Math.abs(priorityDelta) > 1e-8) return priorityDelta;
+  return left.distance - right.distance;
+}
+
+function isPickingAnnotation(value: unknown): value is PickingAnnotation {
+  return Boolean(value)
+    && typeof value === "object"
+    && typeof (value as { readonly id?: unknown }).id === "string"
+    && typeof (value as { readonly label?: unknown }).label === "string";
+}
+
+function validateScreenPoint(point: { readonly x: number; readonly y: number }, label: string): void {
+  if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+    throw new RangeError(`Screen picking ${label} must contain finite x/y values.`);
+  }
+}
+
+function compareScreenHitsByDistance(left: ScreenPickingHit, right: ScreenPickingHit): number {
+  const distanceDelta = left.distance - right.distance;
+  if (Math.abs(distanceDelta) > 1e-8) return distanceDelta;
+  return (right.annotation.priority ?? 0) - (left.annotation.priority ?? 0);
+}
+
+function compareScreenHitsByPriority(left: ScreenPickingHit, right: ScreenPickingHit): number {
+  const priorityDelta = (right.annotation.priority ?? 0) - (left.annotation.priority ?? 0);
+  if (Math.abs(priorityDelta) > 1e-8) return priorityDelta;
+  return left.distance - right.distance;
+}

package/src/PointerLockControls.ts

@@ -0,0 +1,15 @@
+import { createDefaultControlState, type ThreeCompatControlState } from "./ControlState";
+
+export class PointerLockControls {
+  readonly state: ThreeCompatControlState = createDefaultControlState();
+  locked = false;
+
+  lock(): void { this.locked = true; }
+  unlock(): void { this.locked = false; }
+
+  look(deltaX: number, deltaY: number): void {
+    if (!this.locked) return;
+    this.state.rotation.y += deltaX;
+    this.state.rotation.x += deltaY;
+  }
+}

package/src/SelectionManager.ts

@@ -0,0 +1,18 @@
+import type { ControlObject3DLike } from "./NativeControlTypes";
+
+export class SelectionManager {
+  readonly selected = new Set<ControlObject3DLike>();
+
+  select(object: ControlObject3DLike, additive = false): void {
+    if (!additive) this.clear();
+    this.selected.add(object);
+  }
+
+  deselect(object: ControlObject3DLike): void {
+    this.selected.delete(object);
+  }
+
+  clear(): void {
+    this.selected.clear();
+  }
+}