@doki-land/live2d 0.0.18 → 0.0.19

package/dist/index.d.ts

@@ -226,6 +226,9 @@ declare class ActorModelSlot {
     get model(): InternalModel | null;
     get drawPass(): ModelDrawPass | null;
     ensureDrawPass(): ModelDrawPass;
+    /** Load-time stable id → binding map (binding.value updated on setParameter). */
+    parameterMap(): ReadonlyMap<string, ParameterBinding>;
+    resolveParameter(id: string): number | undefined;
     load(source: ModelSource, resolver?: AssetResolver): Promise<InternalModel>;
     loadAsset(asset: ModelAsset): Promise<InternalModel>;
     setParameter(id: string, value: number): void;
@@ -274,6 +277,8 @@ declare class Live2dActorImpl implements Live2dActor {
     loadAsset(asset: ModelAsset): Promise<InternalModel>;
     setParameter(id: string, value: number): void;
     listParameters(): readonly _doki_land_live2d_renderer.ParameterBinding[];
+    parameterMap(): ReadonlyMap<string, _doki_land_live2d_renderer.ParameterBinding>;
+    resolveParameter(id: string): number | undefined;
     listMotionGroups(): Record<string, readonly _doki_land_live2d_core.MotionDefinition[]>;
     playMotion(group: string, index?: number, options?: PlayMotionActorOptions): Promise<boolean>;
     stopMotion(opts?: {
@@ -343,6 +348,9 @@ interface Live2DRuntime extends Live2DSession {
     readonly actor: Live2dActorImpl;
     setParameter(id: string, value: number): void;
     listParameters(): readonly ParameterBinding[];
+    /** Stable load-time parameter map for focus / hosts (no per-frame rebuild). */
+    parameterMap(): ReadonlyMap<string, ParameterBinding>;
+    resolveParameter(id: string): number | undefined;
     hitTest(x: number, y: number): string | null;
     listMotionGroups(): Record<string, readonly _doki_land_live2d_core.MotionDefinition[]>;
     playMotion(group: string, index?: number, options?: PlayMotionOptions): Promise<boolean>;
@@ -372,8 +380,10 @@ declare function createLive2D(options?: CreateLive2DOptions): Live2DRuntime;
  * ANGLE_X/Y use the full declared range, ANGLE_Z combines both axes, and body
  * and eye parameters receive the corresponding normalized axis. Parameters not
  * declared by a model are skipped.
+ *
+ * Prefer a stable `Map` from load-time bindings to avoid per-frame Map rebuild.
  */
-declare function focusParameterUpdates(parameters: readonly ParameterBinding[], dragX: number, dragY: number): Array<{
+declare function focusParameterUpdates(parameters: readonly ParameterBinding[] | ReadonlyMap<string, ParameterBinding>, dragX: number, dragY: number): Array<{
     id: string;
     value: number;
 }>;

package/dist/index.js

@@ -523,6 +523,8 @@ var ActorModelSlot = class {
   #backend = null;
   #lease = null;
   #loadGeneration = 0;
+  #paramById = /* @__PURE__ */ new Map();
+  #paramIndexById = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#assets = options.assets;
     this.#renderer = options.renderer;
@@ -575,7 +577,7 @@ var ActorModelSlot = class {
         this.#backend.setParameter(this.#model, s.id, s.value);
         continue;
       }
-      const cur = this.#backend.listParameters?.(this.#model).find((p) => p.id === s.id)?.value ?? s.value;
+      const cur = this.#paramById.get(s.id)?.value ?? s.value;
       this.#backend.setParameter(
         this.#model,
         s.id,
@@ -583,6 +585,35 @@ var ActorModelSlot = class {
       );
     }
   }
+  #rebuildParamCache() {
+    this.#paramById.clear();
+    this.#paramIndexById.clear();
+    if (!this.#model || !this.#backend?.listParameters) return;
+    const list = this.#backend.listParameters(this.#model);
+    for (let i = 0; i < list.length; i++) {
+      const p = list[i];
+      this.#paramById.set(p.id, p);
+      const resolved = this.#backend.resolveParameter?.(
+        this.#model,
+        p.id
+      );
+      this.#paramIndexById.set(p.id, resolved ?? i);
+    }
+  }
+  #clearParamCache() {
+    this.#paramById.clear();
+    this.#paramIndexById.clear();
+  }
+  /** Load-time stable id → binding map (binding.value updated on setParameter). */
+  parameterMap() {
+    return this.#paramById;
+  }
+  resolveParameter(id) {
+    if (this.#model && this.#backend?.resolveParameter) {
+      return this.#backend.resolveParameter(this.#model, id);
+    }
+    return this.#paramIndexById.get(id);
+  }
   async load(source, resolver) {
     const gen = ++this.#loadGeneration;
     this.#report({
@@ -638,6 +669,7 @@ var ActorModelSlot = class {
     this.#lease = lease;
     this.#model = model;
     this.#backend = backend;
+    this.#rebuildParamCache();
     this.#report({
       stage: "ready",
       progress: 1,
@@ -725,6 +757,7 @@ var ActorModelSlot = class {
     }
     this.#model = null;
     this.#backend = null;
+    this.#clearParamCache();
     this.#releaseLease();
     this.#drawPass?.setTextures([]);
     this.#drawPass?.destroy();
@@ -734,7 +767,12 @@ var ActorModelSlot = class {
 
 // src/stage/assets/focus.ts
 function focusParameterUpdates(parameters, dragX, dragY) {
-  const byId = new Map(parameters.map((p) => [p.id, p]));
+  const byId = parameters instanceof Map || isParamMap(parameters) ? parameters : new Map(
+    parameters.map((p) => [
+      p.id,
+      p
+    ])
+  );
   const x = clampUnit(dragX);
   const y = clampUnit(dragY);
   const out = [];
@@ -752,6 +790,9 @@ function focusParameterUpdates(parameters, dragX, dragY) {
   set("PARAM_EYE_BALL_Y", y);
   return out;
 }
+function isParamMap(value) {
+  return typeof value === "object" && value !== null && typeof value.get === "function" && typeof value.keys === "function" && !Array.isArray(value);
+}
 function clampUnit(n) {
   if (n > 1) return 1;
   if (n < -1) return -1;
@@ -843,26 +884,74 @@ function compareActorsForDraw(a, b, definedLayers) {
 function compareActorsForHit(a, b, definedLayers) {
   return compareActorsForDraw(b, a, definedLayers);
 }
-function transformDrawablesForStage(drawables, transform, opacity) {
-  const alpha = Math.min(1, Math.max(0, opacity));
-  return drawables.map((d) => {
-    if (!d.visible || alpha <= 0) return { ...d, visible: false };
-    const pos = new Float32Array(d.vertexPositions.length);
-    for (let i = 0; i < pos.length; i += 2) {
-      const { stageX, stageY } = modelNdcToStage(
-        d.vertexPositions[i],
-        d.vertexPositions[i + 1],
-        transform
-      );
-      pos[i] = stageX * 2 - 1;
-      pos[i + 1] = 1 - stageY * 2;
+var StageDrawableScratch = class {
+  #meshes = [];
+  #view = [];
+  transform(drawables, transform, opacity) {
+    const alpha = Math.min(1, Math.max(0, opacity));
+    const n = drawables.length;
+    while (this.#meshes.length < n) {
+      this.#meshes.push(createScratchMesh());
+    }
+    if (this.#view.length !== n) {
+      this.#view = this.#meshes.slice(0, n);
+    }
+    for (let i = 0; i < n; i++) {
+      const src = drawables[i];
+      const dst = this.#meshes[i];
+      copyMeshMeta(src, dst);
+      if (!src.visible || alpha <= 0) {
+        dst.visible = false;
+        dst.opacity = 0;
+        continue;
+      }
+      const len = src.vertexPositions.length;
+      let pos = dst.vertexPositions;
+      if (pos.length !== len) {
+        pos = new Float32Array(len);
+        dst.vertexPositions = pos;
+      }
+      for (let j = 0; j < len; j += 2) {
+        const { stageX, stageY } = modelNdcToStage(
+          src.vertexPositions[j],
+          src.vertexPositions[j + 1],
+          transform
+        );
+        pos[j] = stageX * 2 - 1;
+        pos[j + 1] = 1 - stageY * 2;
+      }
+      dst.opacity = src.opacity * alpha;
+      dst.visible = true;
     }
-    return {
-      ...d,
-      vertexPositions: pos,
-      opacity: d.opacity * alpha
-    };
-  });
+    return this.#view;
+  }
+};
+function createScratchMesh() {
+  return {
+    index: 0,
+    textureIndex: 0,
+    vertexPositions: new Float32Array(0),
+    uvs: new Float32Array(0),
+    indices: new Uint16Array(0),
+    opacity: 1,
+    blendMode: 0,
+    invertedMask: false,
+    renderOrder: 0,
+    dynamicFlag: true,
+    maskIndices: [],
+    visible: true
+  };
+}
+function copyMeshMeta(src, dst) {
+  dst.index = src.index;
+  dst.textureIndex = src.textureIndex;
+  dst.uvs = src.uvs;
+  dst.indices = src.indices;
+  dst.blendMode = src.blendMode;
+  dst.invertedMask = src.invertedMask;
+  dst.renderOrder = src.renderOrder;
+  dst.dynamicFlag = src.dynamicFlag;
+  dst.maskIndices = src.maskIndices;
 }
 
 // src/stage/actor.ts
@@ -945,6 +1034,12 @@ var Live2dActorImpl = class {
   listParameters() {
     return this.#slot.listParameters();
   }
+  parameterMap() {
+    return this.#slot.parameterMap();
+  }
+  resolveParameter(id) {
+    return this.#slot.resolveParameter(id);
+  }
   listMotionGroups() {
     return this.#slot.listMotionGroups();
   }
@@ -968,7 +1063,7 @@ var Live2dActorImpl = class {
       this.#transform
     );
     for (const u of focusParameterUpdates(
-      this.#slot.listParameters(),
+      this.#slot.parameterMap(),
       dragX,
       dragY
     )) {
@@ -1099,6 +1194,12 @@ function createSingleActorFacade(stage, actor, backends) {
     listParameters() {
       return actor.listParameters();
     },
+    parameterMap() {
+      return actor.parameterMap();
+    },
+    resolveParameter(id) {
+      return actor.resolveParameter(id);
+    },
     listMotionGroups() {
       return actor.listMotionGroups();
     },
@@ -1491,6 +1592,14 @@ var ModelAssetRegistry = class {
 };
 
 // src/stage/stage.ts
+var IDENTITY_MAT4 = /* @__PURE__ */ (() => {
+  const m = new Float32Array(16);
+  m[0] = 1;
+  m[5] = 1;
+  m[10] = 1;
+  m[15] = 1;
+  return m;
+})();
 var Live2dStageImpl = class {
   #backends;
   #renderer;
@@ -1509,6 +1618,8 @@ var Live2dStageImpl = class {
     ["pointermove", /* @__PURE__ */ new Set()],
     ["pointerup", /* @__PURE__ */ new Set()]
   ]);
+  #drawScratch = new StageDrawableScratch();
+  #sortedActors = [];
   #canvas = null;
   #initPromise = null;
   #rafId = null;
@@ -1613,21 +1724,24 @@ var Live2dStageImpl = class {
   }
   render() {
     if (this.#destroyed || !this.#canvas) return;
-    const sorted = [...this.#actors.values()].sort(
-      (a, b) => compareActorsForDraw(a, b, this.#definedLayers)
-    );
+    const sorted = this.#sortedActors;
+    sorted.length = 0;
+    for (const actor of this.#actors.values()) {
+      sorted.push(actor);
+    }
+    sorted.sort((a, b) => compareActorsForDraw(a, b, this.#definedLayers));
     this.#renderer.beginFrame();
     for (const actor of sorted) {
       if (!actor.visible || actor.opacity <= 0) continue;
       const drawables = actor.lastDrawables;
       const pass = actor.slot.drawPass;
       if (!drawables || !pass) continue;
-      const placed = transformDrawablesForStage(
+      const placed = this.#drawScratch.transform(
         drawables,
         actor.getTransform(),
         actor.opacity
       );
-      pass.draw(placed, new Float32Array(16));
+      pass.draw(placed, IDENTITY_MAT4);
     }
     this.#renderer.endFrame();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doki-land/live2d",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Live2D in the browser — load moc2/moc3 models, Stage + multi-actor, motion; WebGPU/WebGL2/Canvas2D. Main entry for live2d.ts.",
   "type": "module",
   "license": "MIT",
@@ -59,9 +59,9 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@doki-land/live2d-core": "0.0.18",
-    "@doki-land/live2d-loader": "0.0.18",
-    "@doki-land/live2d-renderer": "0.0.18"
+    "@doki-land/live2d-core": "0.0.19",
+    "@doki-land/live2d-loader": "0.0.19",
+    "@doki-land/live2d-renderer": "0.0.19"
   },
   "sideEffects": false
 }

package/src/stage/actor-model-slot.ts

@@ -52,6 +52,8 @@ export class ActorModelSlot {
     #backend: ModelBackend | null = null;
     #lease: ModelAssetLease | null = null;
     #loadGeneration = 0;
+    readonly #paramById = new Map<string, ParameterBinding>();
+    readonly #paramIndexById = new Map<string, number>();
 
     constructor(options: ActorModelSlotOptions) {
         this.#assets = options.assets;
@@ -111,10 +113,7 @@ export class ActorModelSlot {
                 this.#backend.setParameter(this.#model, s.id, s.value);
                 continue;
             }
-            const cur =
-                this.#backend
-                    .listParameters?.(this.#model)
-                    .find((p) => p.id === s.id)?.value ?? s.value;
+            const cur = this.#paramById.get(s.id)?.value ?? s.value;
             this.#backend.setParameter(
                 this.#model,
                 s.id,
@@ -123,6 +122,39 @@ export class ActorModelSlot {
         }
     }
 
+    #rebuildParamCache(): void {
+        this.#paramById.clear();
+        this.#paramIndexById.clear();
+        if (!this.#model || !this.#backend?.listParameters) return;
+        const list = this.#backend.listParameters(this.#model);
+        for (let i = 0; i < list.length; i++) {
+            const p = list[i]!;
+            this.#paramById.set(p.id, p);
+            const resolved = this.#backend.resolveParameter?.(
+                this.#model,
+                p.id,
+            );
+            this.#paramIndexById.set(p.id, resolved ?? i);
+        }
+    }
+
+    #clearParamCache(): void {
+        this.#paramById.clear();
+        this.#paramIndexById.clear();
+    }
+
+    /** Load-time stable id → binding map (binding.value updated on setParameter). */
+    parameterMap(): ReadonlyMap<string, ParameterBinding> {
+        return this.#paramById;
+    }
+
+    resolveParameter(id: string): number | undefined {
+        if (this.#model && this.#backend?.resolveParameter) {
+            return this.#backend.resolveParameter(this.#model, id);
+        }
+        return this.#paramIndexById.get(id);
+    }
+
     async load(
         source: ModelSource,
         resolver?: AssetResolver,
@@ -193,6 +225,7 @@ export class ActorModelSlot {
         this.#lease = lease;
         this.#model = model;
         this.#backend = backend;
+        this.#rebuildParamCache();
         this.#report({
             stage: "ready",
             progress: 1,
@@ -317,6 +350,7 @@ export class ActorModelSlot {
         }
         this.#model = null;
         this.#backend = null;
+        this.#clearParamCache();
         this.#releaseLease();
         this.#drawPass?.setTextures([]);
         this.#drawPass?.destroy();

package/src/stage/actor.ts

@@ -128,6 +128,14 @@ export class Live2dActorImpl implements Live2dActor {
         return this.#slot.listParameters();
     }
 
+    parameterMap() {
+        return this.#slot.parameterMap();
+    }
+
+    resolveParameter(id: string) {
+        return this.#slot.resolveParameter(id);
+    }
+
     listMotionGroups() {
         return this.#slot.listMotionGroups();
     }
@@ -159,7 +167,7 @@ export class Live2dActorImpl implements Live2dActor {
             this.#transform,
         );
         for (const u of focusParameterUpdates(
-            this.#slot.listParameters(),
+            this.#slot.parameterMap(),
             dragX,
             dragY,
         )) {

package/src/stage/assets/focus.ts

@@ -6,13 +6,25 @@ import type { ParameterBinding } from "@doki-land/live2d-renderer";
  * ANGLE_X/Y use the full declared range, ANGLE_Z combines both axes, and body
  * and eye parameters receive the corresponding normalized axis. Parameters not
  * declared by a model are skipped.
+ *
+ * Prefer a stable `Map` from load-time bindings to avoid per-frame Map rebuild.
  */
 export function focusParameterUpdates(
-    parameters: readonly ParameterBinding[],
+    parameters:
+        | readonly ParameterBinding[]
+        | ReadonlyMap<string, ParameterBinding>,
     dragX: number,
     dragY: number,
 ): Array<{ id: string; value: number }> {
-    const byId = new Map(parameters.map((p) => [p.id, p]));
+    const byId =
+        parameters instanceof Map || isParamMap(parameters)
+            ? parameters
+            : new Map(
+                  (parameters as readonly ParameterBinding[]).map((p) => [
+                      p.id,
+                      p,
+                  ]),
+              );
     const x = clampUnit(dragX);
     const y = clampUnit(dragY);
     const out: Array<{ id: string; value: number }> = [];
@@ -35,6 +47,18 @@ export function focusParameterUpdates(
     return out;
 }
 
+function isParamMap(
+    value: unknown,
+): value is ReadonlyMap<string, ParameterBinding> {
+    return (
+        typeof value === "object" &&
+        value !== null &&
+        typeof (value as Map<string, unknown>).get === "function" &&
+        typeof (value as Map<string, unknown>).keys === "function" &&
+        !Array.isArray(value)
+    );
+}
+
 function clampUnit(n: number): number {
     if (n > 1) return 1;
     if (n < -1) return -1;

package/src/stage/single-facade.ts

@@ -33,6 +33,9 @@ export interface Live2DRuntime extends Live2DSession {
 
     setParameter(id: string, value: number): void;
     listParameters(): readonly ParameterBinding[];
+    /** Stable load-time parameter map for focus / hosts (no per-frame rebuild). */
+    parameterMap(): ReadonlyMap<string, ParameterBinding>;
+    resolveParameter(id: string): number | undefined;
     hitTest(x: number, y: number): string | null;
     listMotionGroups(): Record<
         string,
@@ -141,6 +144,12 @@ export function createSingleActorFacade(
         listParameters() {
             return actor.listParameters();
         },
+        parameterMap() {
+            return actor.parameterMap();
+        },
+        resolveParameter(id) {
+            return actor.resolveParameter(id);
+        },
         listMotionGroups() {
             return actor.listMotionGroups();
         },

package/src/stage/stage.ts

@@ -23,9 +23,19 @@ import {
     clientToStage,
     compareActorsForDraw,
     compareActorsForHit,
-    transformDrawablesForStage,
+    StageDrawableScratch,
 } from "./transform.js";
 
+/** Resident identity model matrix — backends currently ignore it; never alloc per frame. */
+export const IDENTITY_MAT4 = /* @__PURE__ */ (() => {
+    const m = new Float32Array(16);
+    m[0] = 1;
+    m[5] = 1;
+    m[10] = 1;
+    m[15] = 1;
+    return m;
+})();
+
 export interface CreateLive2dStageFullOptions extends CreateLive2dStageOptions {
     backends?: ModelBackend[];
     renderer?: Renderer;
@@ -55,6 +65,8 @@ export class Live2dStageImpl implements Live2dStage {
         ["pointermove", new Set()],
         ["pointerup", new Set()],
     ]);
+    readonly #drawScratch = new StageDrawableScratch();
+    readonly #sortedActors: Live2dActorImpl[] = [];
 
     #canvas: HTMLCanvasElement | null = null;
     #initPromise: Promise<void> | null = null;
@@ -178,9 +190,12 @@ export class Live2dStageImpl implements Live2dStage {
 
     render(): void {
         if (this.#destroyed || !this.#canvas) return;
-        const sorted = [...this.#actors.values()].sort((a, b) =>
-            compareActorsForDraw(a, b, this.#definedLayers),
-        );
+        const sorted = this.#sortedActors;
+        sorted.length = 0;
+        for (const actor of this.#actors.values()) {
+            sorted.push(actor);
+        }
+        sorted.sort((a, b) => compareActorsForDraw(a, b, this.#definedLayers));
 
         this.#renderer.beginFrame();
         for (const actor of sorted) {
@@ -188,12 +203,12 @@ export class Live2dStageImpl implements Live2dStage {
             const drawables = actor.lastDrawables;
             const pass = actor.slot.drawPass;
             if (!drawables || !pass) continue;
-            const placed = transformDrawablesForStage(
+            const placed = this.#drawScratch.transform(
                 drawables,
                 actor.getTransform(),
                 actor.opacity,
             );
-            pass.draw(placed, new Float32Array(16));
+            pass.draw(placed, IDENTITY_MAT4);
         }
         this.#renderer.endFrame();
     }

package/src/stage/transform.ts

@@ -133,29 +133,96 @@ export function compareActorsForHit<
     return compareActorsForDraw(b, a, definedLayers);
 }
 
+/**
+ * Resident scratch for {@link transformDrawablesForStage}: stable mesh objects
+ * and vertex buffers (no per-frame `map` / `{...d}` / `new Float32Array`).
+ * Safe to reuse across actors when each transformed list is drawn before the
+ * next `transform` call.
+ */
+export class StageDrawableScratch {
+    readonly #meshes: DrawableMesh[] = [];
+    #view: DrawableMesh[] = [];
+
+    transform(
+        drawables: readonly DrawableMesh[],
+        transform: ActorTransform,
+        opacity: number,
+    ): readonly DrawableMesh[] {
+        const alpha = Math.min(1, Math.max(0, opacity));
+        const n = drawables.length;
+        while (this.#meshes.length < n) {
+            this.#meshes.push(createScratchMesh());
+        }
+        if (this.#view.length !== n) {
+            this.#view = this.#meshes.slice(0, n);
+        }
+        for (let i = 0; i < n; i++) {
+            const src = drawables[i]!;
+            const dst = this.#meshes[i]!;
+            copyMeshMeta(src, dst);
+            if (!src.visible || alpha <= 0) {
+                dst.visible = false;
+                dst.opacity = 0;
+                continue;
+            }
+            const len = src.vertexPositions.length;
+            let pos = dst.vertexPositions;
+            if (pos.length !== len) {
+                pos = new Float32Array(len);
+                dst.vertexPositions = pos;
+            }
+            for (let j = 0; j < len; j += 2) {
+                const { stageX, stageY } = modelNdcToStage(
+                    src.vertexPositions[j]!,
+                    src.vertexPositions[j + 1]!,
+                    transform,
+                );
+                pos[j] = stageX * 2 - 1;
+                pos[j + 1] = 1 - stageY * 2;
+            }
+            dst.opacity = src.opacity * alpha;
+            dst.visible = true;
+        }
+        return this.#view;
+    }
+}
+
+function createScratchMesh(): DrawableMesh {
+    return {
+        index: 0,
+        textureIndex: 0,
+        vertexPositions: new Float32Array(0),
+        uvs: new Float32Array(0),
+        indices: new Uint16Array(0),
+        opacity: 1,
+        blendMode: 0,
+        invertedMask: false,
+        renderOrder: 0,
+        dynamicFlag: true,
+        maskIndices: [],
+        visible: true,
+    };
+}
+
+function copyMeshMeta(src: DrawableMesh, dst: DrawableMesh): void {
+    dst.index = src.index;
+    dst.textureIndex = src.textureIndex;
+    dst.uvs = src.uvs;
+    dst.indices = src.indices;
+    dst.blendMode = src.blendMode;
+    dst.invertedMask = src.invertedMask;
+    dst.renderOrder = src.renderOrder;
+    dst.dynamicFlag = src.dynamicFlag;
+    dst.maskIndices = src.maskIndices;
+}
+
 /** Bake actor stage placement into drawable vertices (renderer stays single-pass). */
 export function transformDrawablesForStage(
     drawables: readonly DrawableMesh[],
     transform: ActorTransform,
     opacity: number,
-): DrawableMesh[] {
-    const alpha = Math.min(1, Math.max(0, opacity));
-    return drawables.map((d) => {
-        if (!d.visible || alpha <= 0) return { ...d, visible: false };
-        const pos = new Float32Array(d.vertexPositions.length);
-        for (let i = 0; i < pos.length; i += 2) {
-            const { stageX, stageY } = modelNdcToStage(
-                d.vertexPositions[i]!,
-                d.vertexPositions[i + 1]!,
-                transform,
-            );
-            pos[i] = stageX * 2 - 1;
-            pos[i + 1] = 1 - stageY * 2;
-        }
-        return {
-            ...d,
-            vertexPositions: pos,
-            opacity: d.opacity * alpha,
-        };
-    });
+    scratch?: StageDrawableScratch,
+): readonly DrawableMesh[] {
+    const pool = scratch ?? new StageDrawableScratch();
+    return pool.transform(drawables, transform, opacity);
 }