@galfus/engine 0.0.0-stage → 0.31.1-alpha

package/src/realm2d/sync.ts

@@ -0,0 +1,284 @@
+/**
+ * Realm 2D synchronization system syncing ECS state with core GalfusEngine.
+ */
+
+import type { GalfusEngine, Material2DDesc, Transform2DDesc } from '@galfus/transport-types';
+import type { AnchorMatrixCache } from '../anchors/cache';
+import type { EntityId } from '../ecs/entity';
+import type { EcsWorld } from '../ecs/world';
+import { mat2d, vec2 } from '../math';
+import { SpatialDirtyFlags } from '../spatial/flags';
+import type {
+  Camera2DComponent,
+  Light2DComponent,
+  Model2DComponent,
+  ParticleEmitter2DComponent,
+  Shape2DComponent,
+  Sprite2DComponent,
+  Svg2DComponent
+} from './components';
+
+const SCALE = vec2.create();
+
+export class Realm2DSyncSystem {
+  private readonly _syncedMaterials = new Set<number>();
+  private readonly _syncedSprites = new Set<number>();
+  private readonly _syncedShapes = new Set<number>();
+  private readonly _syncedLights = new Set<number>();
+  private readonly _syncedCameras = new Set<number>();
+  private readonly _syncedSvgs = new Set<number>();
+  private readonly _syncedEmitters = new Set<number>();
+
+  constructor(
+    readonly realmId: number,
+    readonly cache: AnchorMatrixCache,
+    private readonly onSvgChanged?: (svgId: number) => void
+  ) {}
+
+  /**
+   * Extracts a Transform2DDesc from the persistent cache and component metadata.
+   */
+  getResolvedTransform(world: EcsWorld, id: EntityId): Transform2DDesc {
+    const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+    const mat = model ? model.worldMatrix : this.cache.getWorld2D(id);
+
+    if (mat) {
+      const tx = mat[4];
+      const ty = mat[5];
+      mat2d.getScaling(SCALE, mat);
+
+      return {
+        position: [tx, ty],
+        rotation: mat2d.getRotation(mat),
+        scale: [SCALE[0], SCALE[1]],
+        zLayer: model?.zLayer ?? 0,
+        drawOrder: model?.drawOrder ?? 0
+      };
+    }
+
+    return { position: [0, 0] };
+  }
+
+  /**
+   * Synchronizes all active 2D components to the engine driver.
+   */
+  sync(
+    world: EcsWorld,
+    engine: GalfusEngine,
+    materials: ReadonlyMap<number, Material2DDesc> = new Map()
+  ): void {
+    for (const [id, desc] of materials) {
+      if (!this._syncedMaterials.has(id)) {
+        engine.realm2dCreateMaterial(this.realmId, id, desc);
+        this._syncedMaterials.add(id);
+      }
+    }
+    for (const id of this._syncedMaterials) {
+      if (!materials.has(id)) {
+        engine.realm2dDestroyMaterial(this.realmId, id);
+        this._syncedMaterials.delete(id);
+      }
+    }
+    // 1. Sync Sprites
+    const spriteEntities = world.query('Sprite2D');
+    const currentSprites = new Set<number>();
+    for (const id of spriteEntities) {
+      const sprite = world.getComponent<Sprite2DComponent>(id, 'Sprite2D');
+      if (!sprite) continue;
+      currentSprites.add(sprite.spriteId);
+
+      const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+      const tf = this.getResolvedTransform(world, id);
+      const isRegistered = this._syncedSprites.has(sprite.spriteId);
+      const isSpatialDirty = model ? (model.flags & SpatialDirtyFlags.WorldDirty) !== 0 : false;
+
+      if (!isRegistered || sprite.isDirty) {
+        engine.realm2dCreateSprite(this.realmId, sprite.spriteId, sprite.desc, tf);
+        this._syncedSprites.add(sprite.spriteId);
+        sprite.isDirty = false;
+      } else if (isSpatialDirty) {
+        engine.realm2dSetSpriteTransform(this.realmId, sprite.spriteId, tf);
+      }
+    }
+    for (const spriteId of this._syncedSprites) {
+      if (!currentSprites.has(spriteId)) {
+        engine.realm2dDestroySprite(this.realmId, spriteId);
+        this._syncedSprites.delete(spriteId);
+      }
+    }
+
+    // 2. Sync Shapes
+    const shapeEntities = world.query('Shape2D');
+    const currentShapes = new Set<number>();
+    for (const id of shapeEntities) {
+      const shape = world.getComponent<Shape2DComponent>(id, 'Shape2D');
+      if (!shape) continue;
+      currentShapes.add(shape.shapeId);
+
+      const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+      const tf = this.getResolvedTransform(world, id);
+      const isRegistered = this._syncedShapes.has(shape.shapeId);
+      const isSpatialDirty = model ? (model.flags & SpatialDirtyFlags.WorldDirty) !== 0 : false;
+
+      if (!isRegistered || shape.isDirty) {
+        engine.realm2dCreateShape(this.realmId, shape.shapeId, shape.desc, tf);
+        this._syncedShapes.add(shape.shapeId);
+        shape.isDirty = false;
+      } else if (isSpatialDirty) {
+        engine.realm2dSetShapeTransform(this.realmId, shape.shapeId, tf);
+      }
+    }
+    for (const shapeId of this._syncedShapes) {
+      if (!currentShapes.has(shapeId)) {
+        engine.realm2dDestroyShape(this.realmId, shapeId);
+        this._syncedShapes.delete(shapeId);
+      }
+    }
+
+    // 3. Sync Lights
+    const lightEntities = world.query('Light2D');
+    const currentLights = new Set<number>();
+    for (const id of lightEntities) {
+      const light = world.getComponent<Light2DComponent>(id, 'Light2D');
+      if (!light) continue;
+      currentLights.add(light.lightId);
+
+      const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+      const isSpatialDirty = model ? (model.flags & SpatialDirtyFlags.WorldDirty) !== 0 : false;
+      const tf = this.getResolvedTransform(world, id);
+      if (!this._syncedLights.has(light.lightId) || light.isDirty) {
+        engine.realm2dCreateLight(this.realmId, light.lightId, light.desc, tf);
+        this._syncedLights.add(light.lightId);
+        light.isDirty = false;
+      } else if (isSpatialDirty) {
+        engine.realm2dSetLightTransform(this.realmId, light.lightId, tf);
+      }
+    }
+    for (const lightId of this._syncedLights) {
+      if (!currentLights.has(lightId)) {
+        engine.realm2dDestroyLight(this.realmId, lightId);
+        this._syncedLights.delete(lightId);
+      }
+    }
+
+    // 4. Sync Cameras
+    const cameraEntities = world.query('Camera2D');
+    const currentCameras = new Set<number>();
+    for (const id of cameraEntities) {
+      const camera = world.getComponent<Camera2DComponent>(id, 'Camera2D');
+      if (!camera) continue;
+      currentCameras.add(camera.cameraId);
+
+      const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+      const isSpatialDirty = model ? (model.flags & SpatialDirtyFlags.WorldDirty) !== 0 : false;
+      const tf = this.getResolvedTransform(world, id);
+      if (!this._syncedCameras.has(camera.cameraId) || camera.isDirty) {
+        engine.realm2dCreateCamera(this.realmId, camera.cameraId, camera.desc, tf);
+        this._syncedCameras.add(camera.cameraId);
+        camera.isDirty = false;
+      } else if (isSpatialDirty) {
+        engine.realm2dSetCameraTransform(this.realmId, camera.cameraId, tf);
+      }
+    }
+    for (const camId of this._syncedCameras) {
+      if (!currentCameras.has(camId)) {
+        engine.realm2dDestroyCamera(this.realmId, camId);
+        this._syncedCameras.delete(camId);
+      }
+    }
+
+    // 5. Sync SVGs
+    const svgEntities = world.query('Svg2D');
+    const currentSvgs = new Set<number>();
+    for (const id of svgEntities) {
+      const svg = world.getComponent<Svg2DComponent>(id, 'Svg2D');
+      if (!svg) continue;
+      currentSvgs.add(svg.svgId);
+
+      const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+      const tf = this.getResolvedTransform(world, id);
+      const isRegistered = this._syncedSvgs.has(svg.svgId);
+      const isSpatialDirty = model ? (model.flags & SpatialDirtyFlags.WorldDirty) !== 0 : false;
+
+      if (!isRegistered || svg.isDirty) {
+        engine.realm2dCreateSvg(this.realmId, svg.svgId, svg.desc, tf);
+        this.onSvgChanged?.(svg.svgId);
+        this._syncedSvgs.add(svg.svgId);
+        svg.isDirty = false;
+      } else if (isSpatialDirty) {
+        engine.realm2dSetSvgTransform(this.realmId, svg.svgId, tf);
+      }
+    }
+    for (const svgId of this._syncedSvgs) {
+      if (!currentSvgs.has(svgId)) {
+        engine.realm2dDestroySvg(this.realmId, svgId);
+        this.onSvgChanged?.(svgId);
+        this._syncedSvgs.delete(svgId);
+      }
+    }
+
+    // 6. Sync Particle Emitters
+    const emitterEntities = world.query('ParticleEmitter2D');
+    const currentEmitters = new Set<number>();
+    for (const id of emitterEntities) {
+      const emitter = world.getComponent<ParticleEmitter2DComponent>(id, 'ParticleEmitter2D');
+      if (!emitter) continue;
+      currentEmitters.add(emitter.emitterId);
+
+      const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+      const isSpatialDirty = model ? (model.flags & SpatialDirtyFlags.WorldDirty) !== 0 : false;
+      const tf = this.getResolvedTransform(world, id);
+      if (!this._syncedEmitters.has(emitter.emitterId) || emitter.isDirty) {
+        engine.realm2dCreateParticleEmitter(this.realmId, emitter.emitterId, emitter.desc, tf);
+        this._syncedEmitters.add(emitter.emitterId);
+        emitter.isDirty = false;
+      } else if (isSpatialDirty) {
+        engine.realm2dSetParticleEmitterTransform(this.realmId, emitter.emitterId, tf);
+      }
+    }
+    for (const emitterId of this._syncedEmitters) {
+      if (!currentEmitters.has(emitterId)) {
+        engine.realm2dDestroyParticleEmitter(this.realmId, emitterId);
+        this._syncedEmitters.delete(emitterId);
+      }
+    }
+
+    // 7. Clear WorldDirty for all Model2D entities after all Core sync steps are complete
+    for (const id of world.query('Model2D')) {
+      const model = world.getComponent<Model2DComponent>(id, 'Model2D');
+      if (model) {
+        model.flags &= ~SpatialDirtyFlags.WorldDirty;
+      }
+    }
+  }
+
+  isSvgSynced(svgId: number): boolean {
+    return this._syncedSvgs.has(svgId);
+  }
+
+  isEmitterSynced(emitterId: number): boolean {
+    return this._syncedEmitters.has(emitterId);
+  }
+
+  /**
+   * Disposes all tracked IDs on the engine when the realm is destroyed.
+   */
+  dispose(engine: GalfusEngine | null): void {
+    if (engine) {
+      for (const id of this._syncedSprites) engine.realm2dDestroySprite(this.realmId, id);
+      for (const id of this._syncedShapes) engine.realm2dDestroyShape(this.realmId, id);
+      for (const id of this._syncedLights) engine.realm2dDestroyLight(this.realmId, id);
+      for (const id of this._syncedCameras) engine.realm2dDestroyCamera(this.realmId, id);
+      for (const id of this._syncedSvgs) engine.realm2dDestroySvg(this.realmId, id);
+      for (const id of this._syncedEmitters) engine.realm2dDestroyParticleEmitter(this.realmId, id);
+      for (const id of this._syncedMaterials) engine.realm2dDestroyMaterial(this.realmId, id);
+    }
+    this._syncedSprites.clear();
+    this._syncedShapes.clear();
+    this._syncedLights.clear();
+    this._syncedCameras.clear();
+    this._syncedSvgs.clear();
+    this._syncedEmitters.clear();
+    this._syncedMaterials.clear();
+  }
+}

package/src/realm2d/utils/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Realm 2D math, geometry and spatial utility functions.
+ */
+
+import type { Vec2 } from '../../math/vec2';
+
+export interface AABB2D {
+  min: [number, number];
+  max: [number, number];
+}
+
+export function createAABB2D(minX: number, minY: number, maxX: number, maxY: number): AABB2D {
+  return {
+    min: [minX, minY],
+    max: [maxX, maxY]
+  };
+}
+
+export function containsPoint2D(aabb: AABB2D, point: [number, number] | Vec2): boolean {
+  return (
+    point[0] >= aabb.min[0] &&
+    point[0] <= aabb.max[0] &&
+    point[1] >= aabb.min[1] &&
+    point[1] <= aabb.max[1]
+  );
+}
+
+export function intersectsAABB2D(a: AABB2D, b: AABB2D): boolean {
+  return (
+    a.min[0] <= b.max[0] && a.max[0] >= b.min[0] && a.min[1] <= b.max[1] && a.max[1] >= b.min[1]
+  );
+}

package/src/realm3d/components.ts

@@ -0,0 +1,341 @@
+/**
+ * Realm 3D component declarations.
+ * Incorporates spatial Model3D with contiguous local/world matrices and SpatialDirtyFlags.
+ */
+
+import type {
+  Camera3DDesc,
+  InstancedModel3DDesc,
+  Light3DDesc,
+  Material3DDesc,
+  ParticleEmitter3DDesc,
+  Portal3DDesc
+} from '@galfus/transport-types';
+import type { Component } from '../ecs/component';
+import type { EntityId } from '../ecs/entity';
+import { mat4, type Mat4, quat, type Quat, vec3, type Vec3 } from '../math/index';
+import { SpatialDirtyFlags } from '../spatial/flags';
+
+const SCRATCH_P = vec3.create();
+const SCRATCH_S = vec3.create();
+const SCRATCH_Q = quat.create();
+
+/**
+ * 3D Spatial node component holding dual 4x4 matrices (local and resolved world)
+ * and a two-stage dirty flag state machine (LocalDirty -> WorldDirty -> Clean).
+ */
+export class Model3DComponent implements Component {
+  readonly type = 'Model3D' as const;
+  readonly modelId: number;
+  readonly localMatrix: Mat4;
+  readonly worldMatrix: Mat4;
+  flags: SpatialDirtyFlags;
+
+  constructor(modelId: number, initialLocal?: Float32Array | number[]) {
+    this.modelId = modelId;
+    this.localMatrix = mat4.create();
+    this.worldMatrix = mat4.create();
+    if (initialLocal) {
+      this.localMatrix.set(initialLocal);
+      this.worldMatrix.set(initialLocal);
+    }
+    this.flags = SpatialDirtyFlags.LocalDirty | SpatialDirtyFlags.WorldDirty;
+  }
+
+  setPosition(x: number, y: number, z: number): this;
+  setPosition(position: [number, number, number] | Vec3): this;
+  setPosition(xOrPos: number | [number, number, number] | Vec3, y?: number, z?: number): this {
+    if (typeof xOrPos === 'number') {
+      this.localMatrix[12] = xOrPos;
+      this.localMatrix[13] = y ?? 0;
+      this.localMatrix[14] = z ?? 0;
+    } else {
+      this.localMatrix[12] = xOrPos[0];
+      this.localMatrix[13] = xOrPos[1];
+      this.localMatrix[14] = xOrPos[2];
+    }
+    this.flags |= SpatialDirtyFlags.LocalDirty;
+    return this;
+  }
+
+  setRotation(x: number, y: number, z: number, w: number): this;
+  setRotation(rotation: [number, number, number, number] | Quat): this;
+  setRotation(
+    xOrRot: number | [number, number, number, number] | Quat,
+    y?: number,
+    z?: number,
+    w?: number
+  ): this {
+    mat4.getTranslation(SCRATCH_P, this.localMatrix);
+    mat4.getScaling(SCRATCH_S, this.localMatrix);
+    let q: Quat;
+    if (typeof xOrRot === 'number') {
+      quat.set(SCRATCH_Q, xOrRot, y ?? 0, z ?? 0, w ?? 1);
+      q = SCRATCH_Q;
+    } else {
+      q = xOrRot as Quat;
+    }
+    mat4.fromRotationTranslationScale(this.localMatrix, q, SCRATCH_P, SCRATCH_S);
+    this.flags |= SpatialDirtyFlags.LocalDirty;
+    return this;
+  }
+
+  setScale(x: number, y: number, z: number): this;
+  setScale(scale: [number, number, number] | Vec3): this;
+  setScale(xOrScale: number | [number, number, number] | Vec3, y?: number, z?: number): this {
+    mat4.getTranslation(SCRATCH_P, this.localMatrix);
+    mat4.getRotation(SCRATCH_Q, this.localMatrix);
+    if (typeof xOrScale === 'number') {
+      vec3.set(SCRATCH_S, xOrScale, y ?? 1, z ?? 1);
+    } else {
+      vec3.set(SCRATCH_S, xOrScale[0], xOrScale[1], xOrScale[2]);
+    }
+    mat4.fromRotationTranslationScale(this.localMatrix, SCRATCH_Q, SCRATCH_P, SCRATCH_S);
+    this.flags |= SpatialDirtyFlags.LocalDirty;
+    return this;
+  }
+
+  setTRS(
+    position?: [number, number, number] | Vec3,
+    rotation?: [number, number, number, number] | Quat,
+    scale?: [number, number, number] | Vec3
+  ): this {
+    const p = (position ?? [0, 0, 0]) as unknown as Vec3;
+    const r = (rotation ?? [0, 0, 0, 1]) as unknown as Quat;
+    const s = (scale ?? [1, 1, 1]) as unknown as Vec3;
+    mat4.fromRotationTranslationScale(this.localMatrix, r, p, s);
+    this.flags |= SpatialDirtyFlags.LocalDirty;
+    return this;
+  }
+
+  setLocalMatrix(mat: Float32Array | number[]): this {
+    this.localMatrix.set(mat);
+    this.flags |= SpatialDirtyFlags.LocalDirty;
+    return this;
+  }
+
+  setWorldMatrix(mat: Float32Array | number[]): this {
+    this.worldMatrix.set(mat);
+    this.flags |= SpatialDirtyFlags.WorldDirty;
+    return this;
+  }
+
+  markLocalDirty(): void {
+    this.flags |= SpatialDirtyFlags.LocalDirty;
+  }
+
+  markWorldDirty(): void {
+    this.flags |= SpatialDirtyFlags.WorldDirty;
+  }
+
+  get isDirty(): boolean {
+    return this.flags !== SpatialDirtyFlags.Clean;
+  }
+
+  set isDirty(val: boolean) {
+    if (val) {
+      this.flags |= SpatialDirtyFlags.WorldDirty;
+    } else {
+      this.flags = SpatialDirtyFlags.Clean;
+    }
+  }
+}
+
+export function createModel3D(
+  modelId: number,
+  initialLocal?: Float32Array | number[]
+): Model3DComponent {
+  return new Model3DComponent(modelId, initialLocal);
+}
+
+/**
+ * 3D Mesh rendering component linked to an existing spatial Model3D on the same entity.
+ */
+export interface Mesh3DDesc {
+  geometryId: number;
+  materialId: number;
+  castShadow?: boolean;
+  receiveShadow?: boolean;
+  castOutline?: boolean;
+  outlineColor?: [number, number, number, number];
+  active?: boolean;
+  boneOffset?: number;
+  boneCount?: number;
+}
+
+export interface Mesh3DComponent extends Component {
+  readonly type: 'Mesh3D';
+  readonly meshId: number;
+  readonly modelId: number;
+  geometryId: number;
+  materialId: number;
+  castShadow: boolean;
+  receiveShadow: boolean;
+  castOutline: boolean;
+  outlineColor: [number, number, number, number];
+  active: boolean;
+  boneOffset: number;
+  boneCount: number;
+  isDirty: boolean;
+}
+
+export function createMesh3D(meshId: number, modelId: number, desc: Mesh3DDesc): Mesh3DComponent {
+  return {
+    type: 'Mesh3D',
+    meshId,
+    modelId,
+    geometryId: desc.geometryId,
+    materialId: desc.materialId,
+    castShadow: desc.castShadow ?? true,
+    receiveShadow: desc.receiveShadow ?? true,
+    castOutline: desc.castOutline ?? false,
+    outlineColor: desc.outlineColor ?? [1, 1, 1, 1],
+    active: desc.active ?? true,
+    boneOffset: desc.boneOffset ?? 0,
+    boneCount: desc.boneCount ?? 0,
+    isDirty: true
+  };
+}
+
+export interface Camera3DComponent extends Component {
+  readonly type: 'Camera3D';
+  readonly cameraId: number;
+  desc: Camera3DDesc;
+  isDirty: boolean;
+}
+
+export function createCamera3D(cameraId: number, desc: Camera3DDesc): Camera3DComponent {
+  return {
+    type: 'Camera3D',
+    cameraId,
+    desc,
+    isDirty: true
+  };
+}
+
+export interface Light3DComponent extends Component {
+  readonly type: 'Light3D';
+  readonly lightId: number;
+  desc: Light3DDesc;
+  isDirty: boolean;
+}
+
+export function createLight3D(lightId: number, desc: Light3DDesc): Light3DComponent {
+  return {
+    type: 'Light3D',
+    lightId,
+    desc,
+    isDirty: true
+  };
+}
+
+export type Primitive3DKind =
+  | { kind: 'cube'; size: number }
+  | { kind: 'plane'; width: number; depth: number }
+  | { kind: 'quad'; width: number; height: number }
+  | { kind: 'sphere'; radius: number; rings: number; sectors: number }
+  | { kind: 'cylinder'; radius: number; height: number; sectors: number }
+  | { kind: 'capsule'; radius: number; cylinderHeight: number; rings: number; sectors: number }
+  | { kind: 'pyramid'; width: number; depth: number; height: number }
+  | {
+      kind: 'torus';
+      majorRadius: number;
+      minorRadius: number;
+      majorSegments: number;
+      minorSegments: number;
+    }
+  | { kind: 'custom'; topology: number; vertexData: Uint8Array; indices: Uint32Array };
+
+export interface GeometryResourceEntry {
+  geometryId: number;
+  primitive: Primitive3DKind;
+  isDirty: boolean;
+  morphTargets?: { data: Uint8Array; count: number };
+}
+
+export interface MaterialResourceEntry {
+  materialId: number;
+  desc: Material3DDesc;
+  isDirty: boolean;
+}
+
+export interface ParticleEmitter3DComponent extends Component {
+  readonly type: 'ParticleEmitter3D';
+  readonly emitterId: number;
+  desc: ParticleEmitter3DDesc;
+  isDirty: boolean;
+}
+
+export function createParticleEmitter3D(
+  emitterId: number,
+  desc: ParticleEmitter3DDesc
+): ParticleEmitter3DComponent {
+  return {
+    type: 'ParticleEmitter3D',
+    emitterId,
+    desc,
+    isDirty: true
+  };
+}
+
+export interface Portal3DComponent extends Component {
+  readonly type: 'Portal3D';
+  readonly portalId: number;
+  desc: Portal3DDesc;
+  isDirty: boolean;
+}
+
+export function createPortal3D(portalId: number, desc: Portal3DDesc): Portal3DComponent {
+  return {
+    type: 'Portal3D',
+    portalId,
+    desc,
+    isDirty: true
+  };
+}
+
+export interface InstancedModel3DComponent extends Component {
+  readonly type: 'InstancedModel3D';
+  readonly instancedModelId: number;
+  desc: InstancedModel3DDesc;
+  isDirty: boolean;
+}
+
+export function createInstancedModel3D(
+  instancedModelId: number,
+  desc: InstancedModel3DDesc
+): InstancedModel3DComponent {
+  return {
+    type: 'InstancedModel3D',
+    instancedModelId,
+    desc,
+    isDirty: true
+  };
+}
+
+export interface Skin3DComponent extends Component {
+  readonly type: 'Skin3D';
+  readonly skinId: number;
+  readonly modelEntityId: EntityId;
+  readonly joints: EntityId[];
+  readonly inverseBindMatrices: Float32Array;
+  readonly jointMatrices: Float32Array;
+  isDirty?: boolean;
+}
+
+export function createSkin3D(
+  skinId: number,
+  modelEntityId: EntityId,
+  joints: EntityId[],
+  inverseBindMatrices: Float32Array
+): Skin3DComponent {
+  return {
+    type: 'Skin3D',
+    skinId,
+    modelEntityId,
+    joints,
+    inverseBindMatrices,
+    jointMatrices: new Float32Array(joints.length * 16),
+    isDirty: true
+  };
+}