@galfus/engine 0.0.0-stage → 0.31.1-alpha

package/src/interaction/snapshot2d.ts

@@ -0,0 +1,210 @@
+import type { SvgElementRect } from '@galfus/transport-types';
+import {
+  type Collider2DComponent,
+  type ColliderEntry,
+  type ColliderShape2D,
+  getColliderEntries
+} from '../collision/components';
+import { containsColliderPoint2D } from '../collision/query2d';
+import { mat2d, type Mat2d, type ReadonlyMat2d, vec2 } from '../math';
+import type {
+  Camera2DComponent,
+  Model2DComponent,
+  Shape2DComponent,
+  Sprite2DComponent,
+  Svg2DComponent
+} from '../realm2d/components';
+import type { Realm2D } from '../realm2d/realm';
+import type { InteractiveTarget } from './types';
+
+interface ShapeSnapshot {
+  inverse: Mat2d;
+  entry?: ColliderEntry<ColliderShape2D>;
+}
+export interface CameraSnapshot2D {
+  id: number;
+  slot: number;
+  x: number;
+  y: number;
+  rotation: number;
+  scale: number;
+  near: number;
+  far: number;
+}
+/** Reused storage for the 2D state submitted by one successful dispatch. */
+export class TargetSnapshot2D {
+  private readonly shapes: ShapeSnapshot[] = [];
+  private count = 0;
+  private readonly combined = mat2d.create();
+  private readonly previousModel = mat2d.create();
+  private hasModel = false;
+  private readonly svgInverse = mat2d.create();
+  private svgRect?: Readonly<SvgElementRect>;
+  private svgWidth = 0;
+  private svgHeight = 0;
+  private readonly point: [number, number] = [0, 0];
+  private readonly svgPosition = vec2.create();
+  private readonly svgScale = vec2.create();
+  zLayer = 0;
+  drawOrder = 0;
+  resourceId = 0;
+  valid = false;
+  exists = false;
+
+  capture(realm: Realm2D, entityId: number, target: InteractiveTarget): void {
+    const wasValid = this.valid;
+    this.valid = false;
+    this.exists = false;
+    this.count = 0;
+    const model = realm.world.getComponent<Model2DComponent>(entityId, 'Model2D');
+    if (!model) return;
+    let sameModel = this.hasModel;
+    for (let i = 0; i < 6; i++)
+      if (this.previousModel[i] !== model.worldMatrix[i]) sameModel = false;
+    mat2d.copy(this.previousModel, model.worldMatrix);
+    this.hasModel = true;
+    this.zLayer = model.zLayer;
+    this.drawOrder =
+      realm.world.getComponent<Svg2DComponent>(entityId, 'Svg2D')?.desc.drawOrder ??
+      realm.world.getComponent<Sprite2DComponent>(entityId, 'Sprite2D')?.desc.drawOrder ??
+      realm.world.getComponent<Shape2DComponent>(entityId, 'Shape2D')?.desc.drawOrder ??
+      model.drawOrder;
+    this.resourceId = model.modelId;
+    if (target.type === 'collider') {
+      const component = realm.world.getComponent<Collider2DComponent>(entityId, 'Collider2D');
+      if (!component) return;
+      for (const entry of getColliderEntries(component)) {
+        if (target.colliderId !== undefined && entry.colliderId !== target.colliderId) continue;
+        this.exists = true;
+        if (!entry.active) continue;
+        let saved = this.shapes[this.count];
+        if (!saved) {
+          saved = { inverse: mat2d.create() };
+          this.shapes.push(saved);
+        }
+        if (!sameModel || saved.entry !== entry) {
+          mat2d.multiply(
+            this.combined,
+            model.worldMatrix,
+            entry.matrix as unknown as ReadonlyMat2d
+          );
+          if (!mat2d.invert(saved.inverse, this.combined)) {
+            saved.entry = undefined;
+            continue;
+          }
+          saved.entry = entry;
+        }
+        this.count++;
+      }
+      this.valid = this.count > 0;
+      return;
+    }
+    const svg = realm.world.getComponent<Svg2DComponent>(entityId, 'Svg2D');
+    if (!svg || svg.svgId !== target.svgId) return;
+    const rect = realm.getSvgElementRect(svg.svgId, target.elementId);
+    if (!rect || !rect.viewportWidth || !rect.viewportHeight) return;
+    const width = svg.desc.dimensions?.[0] ?? rect.viewportWidth;
+    const height = svg.desc.dimensions?.[1] ?? rect.viewportHeight;
+    if (
+      wasValid &&
+      sameModel &&
+      rect === this.svgRect &&
+      width === this.svgWidth &&
+      height === this.svgHeight
+    ) {
+      this.valid = true;
+      return;
+    }
+    // Renderer decomposes the world transform into translation, rotation and signed scale.
+    mat2d.getTranslation(this.svgPosition, model.worldMatrix);
+    mat2d.getScaling(this.svgScale, model.worldMatrix);
+    mat2d.fromRotationTranslationScale(
+      this.combined,
+      this.svgPosition,
+      mat2d.getRotation(model.worldMatrix),
+      this.svgScale
+    );
+    if (!mat2d.invert(this.svgInverse, this.combined)) return;
+    this.svgRect = rect;
+    this.svgWidth = width;
+    this.svgHeight = height;
+    this.valid = this.svgWidth > 0 && this.svgHeight > 0;
+  }
+
+  contains(
+    worldPoint: [number, number],
+    target: InteractiveTarget,
+    outUv?: [number, number]
+  ): boolean {
+    if (!this.valid) return false;
+    if (target.type === 'collider') {
+      for (let i = 0; i < this.count; i++) {
+        const shape = this.shapes[i]!;
+        vec2.transformMat2d(this.point, worldPoint, shape.inverse);
+        if (shape.entry && containsColliderPoint2D(shape.entry.shape, this.point)) {
+          if (outUv && shape.entry.shape.type === 'rectangle') {
+            const hx = shape.entry.shape.halfExtents[0];
+            const hy = shape.entry.shape.halfExtents[1];
+            outUv[0] = Math.max(0, Math.min(1, (this.point[0] + hx) / (2 * hx)));
+            outUv[1] = Math.max(0, Math.min(1, (hy - this.point[1]) / (2 * hy)));
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+    const rect = this.svgRect!;
+    vec2.transformMat2d(this.point, worldPoint, this.svgInverse);
+    const x = (this.point[0] / this.svgWidth + 0.5) * rect.viewportWidth;
+    const y = (0.5 - this.point[1] / this.svgHeight) * rect.viewportHeight;
+    const inside =
+      x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;
+    if (inside && outUv) {
+      outUv[0] = Math.max(0, Math.min(1, (x - rect.x) / (rect.width || 1)));
+      outUv[1] = Math.max(0, Math.min(1, (y - rect.y) / (rect.height || 1)));
+    }
+    return inside;
+  }
+}
+
+export function captureCameras2D(realm: Realm2D, out: CameraSnapshot2D[]): void {
+  let count = 0;
+  for (const [entityId, camera] of realm.world.components.entries<Camera2DComponent>('Camera2D')) {
+    if (camera.desc.active === false) continue;
+    const model = realm.world.getComponent<Model2DComponent>(entityId, 'Model2D');
+    if (!model) continue;
+    let saved = out[count];
+    if (!saved)
+      out[count] = saved = { id: 0, slot: 0, x: 0, y: 0, rotation: 0, scale: 0, near: 0, far: 0 };
+    saved.id = camera.cameraId;
+    saved.slot = camera.desc.cameraSlot ?? 0;
+    saved.x = model.worldMatrix[4];
+    saved.y = model.worldMatrix[5];
+    saved.rotation = mat2d.getRotation(model.worldMatrix);
+    saved.scale = camera.desc.orthoScale;
+    saved.near = camera.desc.near ?? -1000;
+    saved.far = camera.desc.far ?? 1000;
+    count++;
+  }
+  out.length = count;
+}
+
+/** Maps a physical pixel in a resolved viewport into world coordinates. */
+export function pointerToWorld2D(
+  out: [number, number],
+  x: number,
+  y: number,
+  viewport: readonly [number, number, number, number],
+  camera: CameraSnapshot2D
+): boolean {
+  const [left, top, width, height] = viewport;
+  if (width <= 0 || height <= 0 || x < left || y < top || x >= left + width || y >= top + height)
+    return false;
+  const localX = (((x - left) / width - 0.5) * camera.scale * width) / height;
+  const localY = (0.5 - (y - top) / height) * camera.scale;
+  const sin = Math.sin(camera.rotation),
+    cos = Math.cos(camera.rotation);
+  out[0] = camera.x + localX * cos - localY * sin;
+  out[1] = camera.y + localX * sin + localY * cos;
+  return true;
+}

package/src/interaction/snapshot3d.ts

@@ -0,0 +1,214 @@
+import {
+  type Collider3DComponent,
+  type ColliderEntry,
+  type ColliderShape3D,
+  getColliderEntries
+} from '../collision/components';
+import { intersectCollider3D } from '../collision/query3d';
+import { mat4, type Mat4, quat, type ReadonlyMat4, vec3, type Vec3 } from '../math';
+import type { Camera3DComponent, Model3DComponent } from '../realm3d/components';
+import type { Realm3D } from '../realm3d/realm';
+
+interface Shape3D {
+  inverse: Mat4;
+  entry?: ColliderEntry<ColliderShape3D>;
+}
+export interface CameraSnapshot3D {
+  id: number;
+  slot: number;
+  perspective: boolean;
+  fov: number;
+  scale: number;
+  near: number;
+  far: number;
+  position: Vec3;
+  forward: Vec3;
+  right: Vec3;
+  up: Vec3;
+}
+const FORWARD: [number, number, number] = [0, 0, -1];
+const UP: [number, number, number] = [0, 1, 0];
+const RIGHT: [number, number, number] = [1, 0, 0];
+const ALT_UP: [number, number, number] = [0, 0, 1];
+
+export class TargetSnapshot3D {
+  private readonly shapes: Shape3D[] = [];
+  private count = 0;
+  private readonly combined = mat4.create();
+  private readonly previousModel = mat4.create();
+  private hasModel = false;
+  private readonly localOrigin = vec3.create();
+  private readonly localDirection = vec3.create();
+  private readonly hit: import('../collision/query3d').LocalRayHit3D = {
+    distance: 0,
+    normal: [0, 0, 0]
+  };
+  valid = false;
+  exists = false;
+
+  capture(realm: Realm3D, entityId: number, colliderId?: number): void {
+    this.valid = false;
+    this.exists = false;
+    this.count = 0;
+    const model = realm.world.getComponent<Model3DComponent>(entityId, 'Model3D');
+    const collider = realm.world.getComponent<Collider3DComponent>(entityId, 'Collider3D');
+    if (!model || !collider) return;
+    let sameModel = this.hasModel;
+    for (let i = 0; i < 16; i++)
+      if (this.previousModel[i] !== model.worldMatrix[i]) sameModel = false;
+    mat4.copy(this.previousModel, model.worldMatrix);
+    this.hasModel = true;
+    for (const entry of getColliderEntries(collider)) {
+      if (colliderId !== undefined && colliderId !== entry.colliderId) continue;
+      this.exists = true;
+      if (!entry.active) continue;
+      let saved = this.shapes[this.count];
+      if (!saved) this.shapes.push((saved = { inverse: mat4.create() }));
+      if (!sameModel || saved.entry !== entry) {
+        mat4.multiply(this.combined, model.worldMatrix, entry.matrix as unknown as ReadonlyMat4);
+        if (!mat4.invert(saved.inverse, this.combined)) {
+          saved.entry = undefined;
+          continue;
+        }
+        saved.entry = entry;
+      }
+      this.count++;
+    }
+    this.valid = this.count > 0;
+  }
+
+  distance(
+    origin: Vec3,
+    direction: Vec3,
+    maxDistance: number,
+    outUv?: [number, number]
+  ): number | undefined {
+    let closest = Infinity;
+    let closestHitUv: [number, number] | undefined;
+    for (let i = 0; i < this.count; i++) {
+      const item = this.shapes[i]!;
+      vec3.transformMat4(this.localOrigin, origin, item.inverse);
+      vec3.transformDirectionMat4(this.localDirection, direction, item.inverse);
+      if (!item.entry) continue;
+      const hit = intersectCollider3D(
+        item.entry.shape,
+        this.localOrigin,
+        this.localDirection,
+        maxDistance,
+        this.hit
+      );
+      if (hit && hit.distance < closest) {
+        closest = hit.distance;
+        closestHitUv = hit.uv ? [hit.uv[0], hit.uv[1]] : undefined;
+      }
+    }
+    if (closest < Infinity) {
+      if (outUv && closestHitUv) {
+        outUv[0] = closestHitUv[0];
+        outUv[1] = closestHitUv[1];
+      }
+      return closest;
+    }
+    return undefined;
+  }
+}
+
+const rotation = quat.create();
+const lookDirection = vec3.create();
+export function captureCameras3D(realm: Realm3D, out: CameraSnapshot3D[]): void {
+  let count = 0;
+  for (const [entityId, camera] of realm.world.components.entries<Camera3DComponent>('Camera3D')) {
+    const model = realm.world.getComponent<Model3DComponent>(entityId, 'Model3D');
+    if (!model) continue;
+    let saved = out[count];
+    if (!saved)
+      out[count] = saved = {
+        id: 0,
+        slot: 0,
+        perspective: true,
+        fov: 60,
+        scale: 10,
+        near: 0.1,
+        far: 1000,
+        position: vec3.create(),
+        forward: vec3.create(),
+        right: vec3.create(),
+        up: vec3.create()
+      };
+    saved.id = camera.cameraId;
+    saved.slot = camera.desc.cameraSlot ?? 0;
+    saved.perspective = camera.desc.kind !== 'orthographic';
+    saved.fov = camera.desc.fovY ?? 60;
+    saved.scale = camera.desc.orthoScale ?? 10;
+    saved.near = camera.desc.near ?? 0.1;
+    saved.far = camera.desc.far ?? 1000;
+    mat4.getTranslation(saved.position, model.worldMatrix);
+    mat4.getRotation(rotation, model.worldMatrix);
+    vec3.transformQuat(saved.forward, FORWARD, rotation);
+    vec3.transformQuat(saved.up, UP, rotation);
+    vec3.transformQuat(saved.right, RIGHT, rotation);
+    const lookAt = camera.desc.lookAt;
+    if (lookAt) {
+      vec3.subtract(lookDirection, lookAt.target, saved.position);
+      if (vec3.dot(lookDirection, lookDirection) > 1e-8) {
+        vec3.normalize(saved.forward, lookDirection);
+        vec3.cross(saved.right, saved.forward, lookAt.up ?? UP);
+        if (vec3.dot(saved.right, saved.right) <= 1e-8)
+          vec3.cross(saved.right, saved.forward, Math.abs(saved.forward[1]) < 0.99 ? UP : ALT_UP);
+        vec3.normalize(saved.right, saved.right);
+        vec3.cross(saved.up, saved.right, saved.forward);
+        vec3.normalize(saved.up, saved.up);
+      }
+    }
+    count++;
+  }
+  out.length = count;
+}
+
+export function pointerToRay3D(
+  origin: Vec3,
+  direction: Vec3,
+  x: number,
+  y: number,
+  viewport: readonly [number, number, number, number],
+  camera: CameraSnapshot3D
+): number | undefined {
+  const [left, top, width, height] = viewport;
+  if (
+    width <= 0 ||
+    height <= 0 ||
+    x < left ||
+    y < top ||
+    x >= left + width ||
+    y >= top + height ||
+    (camera.perspective && camera.near <= 0) ||
+    camera.far <= camera.near
+  )
+    return;
+  const u = (2 * (x - left)) / width - 1;
+  const v = 1 - (2 * (y - top)) / height;
+  let offsetX: number, offsetY: number;
+  if (camera.perspective) {
+    const half = Math.tan((camera.fov * Math.PI) / 360);
+    offsetX = (u * half * width) / height;
+    offsetY = v * half;
+    for (let i = 0; i < 3; i++)
+      direction[i] = camera.forward[i]! + camera.right[i]! * offsetX + camera.up[i]! * offsetY;
+    vec3.normalize(direction, direction);
+    const cosine = vec3.dot(direction, camera.forward);
+    if (cosine <= 0) return;
+    vec3.scaleAndAdd(origin, camera.position, direction, camera.near / cosine);
+    return (camera.far - camera.near) / cosine;
+  }
+  offsetX = (u * camera.scale * width) / height / 2;
+  offsetY = (v * camera.scale) / 2;
+  for (let i = 0; i < 3; i++) {
+    direction[i] = camera.forward[i]!;
+    origin[i] =
+      camera.position[i]! +
+      camera.right[i]! * offsetX +
+      camera.up[i]! * offsetY +
+      camera.forward[i]! * camera.near;
+  }
+  return camera.far - camera.near;
+}