@haiyue/extensions 0.1.0 → 0.2.0

package/src/tween/Tween2DComponent.ts

@@ -1,83 +0,0 @@
-import { Component } from '@haiyue/engine';
-import { UniqueCheckType } from '@haiyue/engine/ecs';
-import { Easing, type EasingFunction } from '@haiyue/engine/tween';
-
-export type Tween2DEasingName = keyof typeof Easing;
-
-export interface Tween2DProperties {
-  x?: number;
-  y?: number;
-  rotation?: number;
-  scaleX?: number;
-  scaleY?: number;
-}
-
-export interface Tween2DComponentOptions {
-  from?: Tween2DProperties;
-  to?: Tween2DProperties;
-  duration?: number;
-  delay?: number;
-  easing?: Tween2DEasingName | EasingFunction | string;
-  removeOnComplete?: boolean;
-}
-
-export class Tween2DComponent extends Component {
-  static override UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
-  static override UniqueSymbol = Symbol.for('Tween2DComponent');
-  static editor = {
-    fields: {
-      from: { type: 'json', label: 'From JSON', rows: 4 },
-      to: { type: 'json', label: 'To JSON', rows: 4 },
-      duration: { type: 'number', label: 'Duration ms', min: 0, step: 16 },
-      delay: { type: 'number', label: 'Delay ms', min: 0, step: 16 },
-      easing: { type: 'text', label: 'Easing' },
-      removeOnComplete: { type: 'boolean', label: 'Remove On Complete' },
-    },
-  };
-
-  from: Tween2DProperties | null;
-  to: Tween2DProperties;
-  duration: number;
-  delay: number;
-  easing: Tween2DEasingName | EasingFunction | string;
-  removeOnComplete: boolean;
-  elapsed = 0;
-  started = false;
-  completed = false;
-  private _resolvedFrom: Tween2DProperties = {};
-
-  constructor(options: Tween2DComponentOptions = {}) {
-    super('Tween2DComponent');
-    this.from = options.from ? { ...options.from } : null;
-    this.to = { ...(options.to ?? {}) };
-    this.duration = Math.max(0, options.duration ?? 160);
-    this.delay = Math.max(0, options.delay ?? 0);
-    this.easing = options.easing ?? 'cubicOut';
-    this.removeOnComplete = options.removeOnComplete ?? true;
-  }
-
-  resolveFrom(current: Tween2DProperties): Tween2DProperties {
-    if (this.started) return this._resolvedFrom;
-    this._resolvedFrom = {};
-    for (const key of Object.keys(this.to) as Array<keyof Tween2DProperties>) {
-      this._resolvedFrom[key] = this.from?.[key] ?? current[key] ?? 0;
-    }
-    return this._resolvedFrom;
-  }
-
-  getEasingFunction(): EasingFunction {
-    if (typeof this.easing === 'function') return this.easing;
-    return Easing[this.easing as Tween2DEasingName] ?? Easing.linear;
-  }
-
-  override clone(): Tween2DComponent {
-    return new Tween2DComponent({
-      ...(this.from ? { from: { ...this.from } } : {}),
-      to: { ...this.to },
-      duration: this.duration,
-      delay: this.delay,
-      easing: this.easing,
-      removeOnComplete: this.removeOnComplete,
-    });
-  }
-}

package/src/tween/Tween2DSystem.ts

@@ -1,78 +0,0 @@
-import { Entity, System, Transform2D, type World } from '@haiyue/engine';
-import { Tween2DComponent, type Tween2DProperties } from './Tween2DComponent';
-
-export interface Tween2DSystemOptions {
-  priority?: number;
-}
-
-function lerp(from: number, to: number, t: number): number {
-  return from + (to - from) * t;
-}
-
-function readTransform(transform: Transform2D, out: Required<Tween2DProperties>): Required<Tween2DProperties> {
-  out.x = transform.x;
-  out.y = transform.y;
-  out.rotation = transform.rotation;
-  out.scaleX = transform.scaleX;
-  out.scaleY = transform.scaleY;
-  return out;
-}
-
-export class Tween2DSystem extends System {
-  private readonly completedEntities: Entity[] = [];
-  private readonly transformScratch: Required<Tween2DProperties> = { x: 0, y: 0, rotation: 0, scaleX: 1, scaleY: 1 };
-
-  constructor(options: Tween2DSystemOptions = {}) {
-    super({ all: [Tween2DComponent, Transform2D] });
-    this.name = 'Tween2DSystem';
-    if (options.priority !== undefined) this.priority = options.priority;
-  }
-
-  override update(world: World, _time: number, delta: number): this {
-    if (this.disabled) return this;
-    this.completedEntities.length = 0;
-    const entities = this.entitySet.get(world);
-    if (entities) {
-      for (const entity of entities) this.updateEntity(entity, delta);
-    }
-    for (const entity of this.completedEntities) {
-      const tween = entity.getComponent(Tween2DComponent);
-      if (tween?.completed && tween.removeOnComplete) entity.removeComponent(tween);
-    }
-    return this;
-  }
-
-  private updateEntity(entity: Entity, delta: number): void {
-    const tween = entity.getComponent(Tween2DComponent);
-    const transform = entity.getComponent(Transform2D);
-    if (!tween || !transform || tween.completed) return;
-
-    tween.elapsed += delta;
-    if (tween.elapsed < tween.delay) return;
-
-    const from = tween.resolveFrom(readTransform(transform, this.transformScratch));
-    if (!tween.started) {
-      tween.started = true;
-      this.apply(transform, from, 0);
-    }
-
-    const duration = Math.max(1, tween.duration);
-    const raw = Math.min((tween.elapsed - tween.delay) / duration, 1);
-    const progress = tween.getEasingFunction()(raw);
-    this.apply(transform, from, progress, tween.to);
-
-    if (raw >= 1) {
-      tween.completed = true;
-      this.apply(transform, from, 1, tween.to);
-      if (tween.removeOnComplete) this.completedEntities.push(entity);
-    }
-  }
-
-  private apply(transform: Transform2D, from: Tween2DProperties, progress: number, to: Tween2DProperties = from): void {
-    if (to.x !== undefined) transform.x = lerp(from.x ?? transform.x, to.x, progress);
-    if (to.y !== undefined) transform.y = lerp(from.y ?? transform.y, to.y, progress);
-    if (to.rotation !== undefined) transform.rotation = lerp(from.rotation ?? transform.rotation, to.rotation, progress);
-    if (to.scaleX !== undefined) transform.scaleX = lerp(from.scaleX ?? transform.scaleX, to.scaleX, progress);
-    if (to.scaleY !== undefined) transform.scaleY = lerp(from.scaleY ?? transform.scaleY, to.scaleY, progress);
-  }
-}

package/src/tween.ts

@@ -1,4 +0,0 @@
-export { Tween2DComponent } from './tween/Tween2DComponent';
-export type { Tween2DComponentOptions, Tween2DEasingName, Tween2DProperties } from './tween/Tween2DComponent';
-export { Tween2DSystem } from './tween/Tween2DSystem';
-export type { Tween2DSystemOptions } from './tween/Tween2DSystem';

package/src/types/earcut.d.ts

@@ -1,7 +0,0 @@
-declare module 'earcut' {
-  export default function earcut(
-    vertices: ArrayLike<number>,
-    holeIndices?: ArrayLike<number> | null,
-    dimensions?: number,
-  ): number[];
-}

package/src/types/wgsl.d.ts

@@ -1,4 +0,0 @@
-declare module '*.wgsl' {
-  const source: string;
-  export default source;
-}

package/src/utils/RenderSystem2DBase.ts

@@ -1,164 +0,0 @@
-import {
-  type EntityHierarchyDisabledCache,
-  type FrameData,
-  type IEngine,
-  type RenderCommandContext,
-  isEntityDisabledInHierarchyCached,
-  getExtensionGPUResourceTracker,
-  requireEngineDevice,
-} from '@haiyue/engine/extension-authoring';
-import { Camera2D } from '@haiyue/engine/components';
-import { Entity, System, type SystemQuery, type World } from '@haiyue/engine/ecs';
-import { compute2DViewProjection, write2DCameraBuffer } from './camera2d';
-import { createObject2DGpu, destroyObject2DGpu, type Object2DGpu } from './render2dGpu';
-
-export interface RenderSystem2DBaseOptions {
-  loadOp?: 'clear' | 'load';
-  priority?: number;
-}
-
-export abstract class RenderSystem2DBase extends System {
-  protected readonly engine: IEngine;
-  protected cameraEntity: Entity;
-  protected readonly disabledHierarchyCache: EntityHierarchyDisabledCache = new Map();
-  protected readonly liveEntityIds = new Set<number>();
-
-  loadOp: 'clear' | 'load';
-  readonly recoveryLabel: string;
-  readonly recoverySource: { kind: 'component-render-system'; system: string };
-  private readonly unregisterRecovery: (() => void) | null;
-
-  protected constructor(
-    rule: SystemQuery,
-    engine: IEngine,
-    cameraEntity: Entity,
-    options: RenderSystem2DBaseOptions = {},
-    name?: string,
-  ) {
-    super(rule);
-    this.engine = engine;
-    this.cameraEntity = cameraEntity;
-    this.loadOp = options.loadOp ?? 'load';
-    if (name) this.name = name;
-    if (options.priority !== undefined) this.priority = options.priority;
-    this.recoveryLabel = `${name ?? this.constructor.name}:${this.id}`;
-    this.recoverySource = { kind: 'component-render-system', system: name ?? this.constructor.name };
-    this.unregisterRecovery = engine.registerDeviceRecoveryParticipant?.(this) ?? null;
-  }
-
-  setCameraEntity(cameraEntity: Entity): this {
-    this.cameraEntity = cameraEntity;
-    return this;
-  }
-
-  protected getCamera2D(context?: RenderCommandContext): Camera2D | null {
-    return this.getCameraEntity(context).getComponent(Camera2D);
-  }
-
-  protected getFrameData(context: RenderCommandContext): FrameData {
-    const cameraEntity = this.getCameraEntity(context);
-    const frameData = context.frameData ?? cameraEntity.world?.frameData;
-    if (!frameData) throw new Error(`${this.name} requires frame data from its render context or camera usage.`);
-    return frameData;
-  }
-
-  protected computeCameraViewProjection(camera: Camera2D, context?: RenderCommandContext): Float32Array {
-    if (context) {
-      return this.getFrameData(context).getCamera2D(
-        this.getCameraEntity(context),
-        camera,
-        context.view?.displayWidth ?? this.engine.displayWidth,
-        context.view?.displayHeight ?? this.engine.displayHeight,
-      ).viewProjectionMatrix;
-    }
-    return compute2DViewProjection(this.engine, this.cameraEntity, camera);
-  }
-
-  protected writeCameraBuffer(queue: GPUQueue, buffer: GPUBuffer, context?: RenderCommandContext): boolean {
-    const camera = this.getCamera2D(context);
-    if (!camera) return false;
-    write2DCameraBuffer(queue, buffer, this.computeCameraViewProjection(camera, context));
-    return true;
-  }
-
-  protected getWorldMatrix2D(entity: Entity, context: RenderCommandContext): Float32Array {
-    return this.getFrameData(context).getWorldMatrix2D(entity);
-  }
-
-  private getCameraEntity(context?: RenderCommandContext): Entity {
-    return context?.view?.camera.getComponent(Camera2D) ? context.view.camera : this.cameraEntity;
-  }
-
-  protected isEntityRenderable(entity: Entity): boolean {
-    return !isEntityDisabledInHierarchyCached(entity, this.disabledHierarchyCache);
-  }
-
-  protected beginLiveEntityTracking(): Set<number> {
-    this.liveEntityIds.clear();
-    this.disabledHierarchyCache.clear();
-    return this.liveEntityIds;
-  }
-
-  protected markEntityLive(entity: Entity | number): void {
-    this.liveEntityIds.add(typeof entity === 'number' ? entity : entity.id);
-  }
-
-  protected createObjectGpu(layout: GPUBindGroupLayout): Object2DGpu {
-    return createObject2DGpu(requireEngineDevice(this.engine), layout, getExtensionGPUResourceTracker(this.engine));
-  }
-
-  protected destroyObjectGpu(objectGpu: Object2DGpu): void {
-    destroyObject2DGpu(objectGpu);
-  }
-
-  protected getOrCreateEntityGpu<T>(
-    cache: Map<number, T>,
-    entity: Entity,
-    create: () => T,
-  ): T {
-    let gpu = cache.get(entity.id);
-    if (!gpu) {
-      gpu = create();
-      cache.set(entity.id, gpu);
-    }
-    return gpu;
-  }
-
-  protected releaseEntityGpuEntriesNotIn<T>(
-    cache: Map<number, T>,
-    destroy: (gpu: T) => void,
-    liveEntities: ReadonlySet<number> = this.liveEntityIds,
-  ): void {
-    for (const [entityId, gpu] of cache) {
-      if (!liveEntities.has(entityId)) {
-        destroy(gpu);
-        cache.delete(entityId);
-      }
-    }
-  }
-
-  protected destroyEntityGpuEntries<T>(
-    cache: Map<number, T>,
-    destroy: (gpu: T) => void,
-  ): void {
-    for (const gpu of cache.values()) destroy(gpu);
-    cache.clear();
-  }
-
-  suspendForDeviceLoss(): void {
-    this.releaseGpuResourcesForRecovery();
-  }
-
-  recoverGpuResource(_device: GPUDevice, signal: AbortSignal): void {
-    if (signal.aborted) throw signal.reason;
-    this.restoreGpuResourcesAfterRecovery();
-  }
-
-  override destroy(): this {
-    this.unregisterRecovery?.();
-    return super.destroy();
-  }
-
-  protected abstract releaseGpuResourcesForRecovery(): void;
-  protected restoreGpuResourcesAfterRecovery(): void {}
-}

package/src/utils/arrayAccess.ts

@@ -1,17 +0,0 @@
-/** Reads an element whose presence is an internal runtime invariant. */
-export function requiredItemAt<T>(values: ArrayLike<T>, index: number, label: string): T {
-  const value = values[index];
-  if (value === undefined) {
-    throw new RangeError(`${label} is missing element ${index} (length ${values.length}).`);
-  }
-  return value;
-}
-
-/** Reads a number whose presence is an internal runtime invariant. */
-export function requiredNumberAt(values: ArrayLike<number>, index: number, label: string): number {
-  const value = values[index];
-  if (value === undefined || !Number.isFinite(value)) {
-    throw new RangeError(`${label} requires a finite value at ${index} (length ${values.length}).`);
-  }
-  return value;
-}

package/src/utils/camera2d.ts

@@ -1,68 +0,0 @@
-import { Camera2D, Entity, Transform2D } from '@haiyue/engine';
-import { Transform3D } from '@haiyue/engine/components';
-import { type IEngine } from '@haiyue/engine/core';
-import { mat4 } from 'wgpu-matrix';
-
-export interface Camera2DScratch {
-  viewMatrix: Float32Array;
-  viewProjMatrix: Float32Array;
-}
-
-export function createCamera2DScratch(): Camera2DScratch {
-  return {
-    viewMatrix: mat4.identity() as Float32Array,
-    viewProjMatrix: mat4.identity() as Float32Array,
-  };
-}
-
-export function compute2DViewProjection(
-  engine: IEngine,
-  cameraEntity: Entity,
-  camera: Camera2D,
-  scratch: Camera2DScratch = createCamera2DScratch(),
-): Float32Array {
-  camera.resize(engine.displayWidth, engine.displayHeight);
-  const transform = cameraEntity.getComponent(Transform3D);
-  if (!transform) return camera.projectionMatrix;
-  transform.updateWorldMatrix();
-  const viewMatrix = mat4.inverse(transform.worldMatrix, scratch.viewMatrix) as Float32Array;
-  return mat4.multiply(camera.projectionMatrix, viewMatrix, scratch.viewProjMatrix) as Float32Array;
-}
-
-export function write2DCameraBuffer(queue: GPUQueue, buffer: GPUBuffer, viewProj: Float32Array): void {
-  queue.writeBuffer(buffer, 0, viewProj.buffer as ArrayBuffer, viewProj.byteOffset, viewProj.byteLength);
-}
-
-export const IDENTITY_2D_WORLD_MATRIX = mat4.identity() as Float32Array;
-
-export type WorldMatrix2DFrameCache = Map<Entity, Float32Array>;
-
-export function get2DEntityWorldMatrix(entity: Entity, cache?: WorldMatrix2DFrameCache): Float32Array {
-  const cached = cache?.get(entity);
-  if (cached) return cached;
-
-  const transform2D = entity.getComponent(Transform2D);
-  if (transform2D) {
-    const parent = entity.parent as Entity | null;
-    const parentMatrix = parent ? get2DEntityWorldMatrix(parent, cache) : undefined;
-    const parentTransform2D = parent?.getComponent(Transform2D);
-    const parentTransform3D = parent?.getComponent(Transform3D);
-    transform2D.updateWorldMatrix(parentMatrix, parentTransform2D?.worldVersion ?? parentTransform3D?.worldVersion ?? 0);
-    cache?.set(entity, transform2D.worldMatrix);
-    return transform2D.worldMatrix;
-  }
-
-  const transform3D = entity.getComponent(Transform3D);
-  if (transform3D) {
-    const parent = entity.parent as Entity | null;
-    const parentMatrix = parent ? get2DEntityWorldMatrix(parent, cache) : undefined;
-    const parentTransform2D = parent?.getComponent(Transform2D);
-    const parentTransform3D = parent?.getComponent(Transform3D);
-    transform3D.updateWorldMatrix(parentMatrix, parentTransform2D?.worldVersion ?? parentTransform3D?.worldVersion ?? 0);
-    cache?.set(entity, transform3D.worldMatrix);
-    return transform3D.worldMatrix;
-  }
-
-  cache?.set(entity, IDENTITY_2D_WORLD_MATRIX);
-  return IDENTITY_2D_WORLD_MATRIX;
-}

package/src/utils/render2dGpu.ts

@@ -1,132 +0,0 @@
-import { estimateTextureBytes, type ExtensionGPUResourceTracker } from '@haiyue/engine/extension-authoring';
-
-export interface Camera2DGpu {
-  layout: GPUBindGroupLayout;
-  buffer: GPUBuffer;
-  tracker?: ExtensionGPUResourceTracker;
-  bindGroup: GPUBindGroup;
-}
-
-export interface Object2DGpu {
-  buffer: GPUBuffer;
-  bindGroup: GPUBindGroup;
-  snapshot: Float32Array;
-  tracker?: ExtensionGPUResourceTracker;
-}
-
-export interface Texture2DGpu {
-  layout: GPUBindGroupLayout;
-  sampler: GPUSampler;
-  fallbackTexture: GPUTexture;
-  fallbackBindGroup: GPUBindGroup;
-  tracker?: ExtensionGPUResourceTracker;
-}
-
-export function createCamera2DLayout(device: GPUDevice): GPUBindGroupLayout {
-  return device.createBindGroupLayout({
-    entries: [{ binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } }],
-  });
-}
-
-export function createCamera2DGpu(
-  device: GPUDevice,
-  tracker?: ExtensionGPUResourceTracker,
-  layout = createCamera2DLayout(device),
-): Camera2DGpu {
-  const buffer = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  tracker?.trackBuffer(buffer, 'render2d.cameraBuffer', 64);
-  const bindGroup = device.createBindGroup({
-    layout,
-    entries: [{ binding: 0, resource: { buffer } }],
-  });
-  return { layout, buffer, bindGroup, ...(tracker === undefined ? {} : { tracker }) };
-}
-
-export function createObject2DLayout(device: GPUDevice): GPUBindGroupLayout {
-  return device.createBindGroupLayout({
-    entries: [{ binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } }],
-  });
-}
-
-export function createObject2DGpu(device: GPUDevice, layout: GPUBindGroupLayout, tracker?: ExtensionGPUResourceTracker): Object2DGpu {
-  const buffer = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-  tracker?.trackBuffer(buffer, 'render2d.objectBuffer', 64);
-  return {
-    buffer,
-    bindGroup: device.createBindGroup({
-      layout,
-      entries: [{ binding: 0, resource: { buffer } }],
-    }),
-    snapshot: createMatrixSnapshot(),
-    ...(tracker === undefined ? {} : { tracker }),
-  };
-}
-
-export function createTexture2DGpu(device: GPUDevice, fallbackAlpha = 255, tracker?: ExtensionGPUResourceTracker): Texture2DGpu {
-  const layout = device.createBindGroupLayout({
-    entries: [
-      { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
-      { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
-    ],
-  });
-  const sampler = device.createSampler({ magFilter: 'linear', minFilter: 'linear' });
-  const fallbackTexture = device.createTexture({
-    size: [1, 1],
-    format: 'rgba8unorm',
-    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
-  });
-  tracker?.trackTexture(fallbackTexture, 'render2d.fallbackTexture', estimateTextureBytes([1, 1, 1], 'rgba8unorm'));
-  device.queue.writeTexture(
-    { texture: fallbackTexture },
-    new Uint8Array([255, 255, 255, fallbackAlpha]),
-    { bytesPerRow: 4 },
-    [1, 1],
-  );
-  const fallbackBindGroup = device.createBindGroup({
-    layout,
-    entries: [
-      { binding: 0, resource: fallbackTexture.createView() },
-      { binding: 1, resource: sampler },
-    ],
-  });
-  return { layout, sampler, fallbackTexture, fallbackBindGroup, ...(tracker === undefined ? {} : { tracker }) };
-}
-
-export function writeFloatBuffer(queue: GPUQueue, buffer: GPUBuffer, data: Float32Array): void {
-  queue.writeBuffer(buffer, 0, data.buffer as ArrayBuffer, data.byteOffset, data.byteLength);
-}
-
-export function matrixEquals(a: Float32Array, b: Float32Array): boolean {
-  for (let i = 0; i < 16; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-
-export function createMatrixSnapshot(): Float32Array {
-  const snapshot = new Float32Array(16);
-  snapshot.fill(Number.NaN);
-  return snapshot;
-}
-
-export function writeObjectMatrixIfChanged(queue: GPUQueue, gpu: Object2DGpu, matrix: Float32Array): boolean {
-  if (matrixEquals(gpu.snapshot, matrix)) return false;
-  writeFloatBuffer(queue, gpu.buffer, matrix);
-  gpu.snapshot.set(matrix);
-  return true;
-}
-
-export function destroyCamera2DGpu(gpu: Camera2DGpu): void {
-  gpu.tracker?.untrackBuffer(gpu.buffer);
-  gpu.buffer.destroy();
-}
-
-export function destroyObject2DGpu(gpu: Object2DGpu): void {
-  gpu.tracker?.untrackBuffer(gpu.buffer);
-  gpu.buffer.destroy();
-}
-
-export function destroyTexture2DGpu(gpu: Texture2DGpu): void {
-  gpu.tracker?.untrackTexture(gpu.fallbackTexture);
-  gpu.fallbackTexture.destroy();
-}