@zephyr3d/scene 0.9.26 → 0.10.0

package/dist/animation/skin_palette_atlas.js

@@ -0,0 +1,252 @@
+import { Disposable, DRef } from '@zephyr3d/base';
+import { getDevice } from '../app/api.js';
+
+/** Floats in one slot: a 4x4 matrix stored as 4 rgba32f texels on one row */ const FLOATS_PER_SLOT = 16;
+/** Texels in one slot */ const TEXELS_PER_SLOT = 4;
+/** Atlas width in texels, a multiple of TEXELS_PER_SLOT so no slot straddles two rows */ const ATLAS_WIDTH = 1024;
+/** Initial atlas height in rows */ const INITIAL_HEIGHT = 64;
+/**
+ * Shaders compute texel indices as floats, which stay exact below 2^24, so the atlas never holds
+ * more texels than that
+ */ const MAX_TEXELS = 1 << 24;
+/**
+ * Shared rgba32f texture holding the skinning matrix palettes of all skinned meshes.
+ *
+ * @remarks
+ * The atlas is addressed in slots of 4 texels (one 4x4 matrix, one row per texel), so the
+ * shader fetches a matrix the same way it fetched one from a per-skeleton joint texture.
+ * Blocks are allocated first-fit from a free list and keep their place until released, so the
+ * slot index of a block can be stored in instance data without being rewritten every frame.
+ *
+ * Writes go to a CPU-side mirror and the dirty rows are uploaded once per frame by {@link flush}.
+ * Growing the atlas replaces its texture; {@link changeTag} tells consumers holding the old one.
+ * The old texture is only released, so a consumer still holding a reference keeps it alive until
+ * it switches over.
+ *
+ * @internal
+ */ class SkinPaletteAtlas extends Disposable {
+    static _instance = null;
+    static _uploadListeners = [];
+    static _replaceListeners = [];
+    _texture;
+    _data;
+    _height;
+    /** Free slot ranges sorted by base, never adjacent to each other */ _freeList;
+    _dirtyRowMin;
+    _dirtyRowMax;
+    _changeTag;
+    constructor(){
+        super();
+        this._texture = new DRef();
+        this._height = INITIAL_HEIGHT;
+        this._data = new Float32Array(ATLAS_WIDTH * this._height * 4);
+        this._freeList = [
+            {
+                base: 0,
+                count: this.slotCapacity
+            }
+        ];
+        this._dirtyRowMin = Number.MAX_SAFE_INTEGER;
+        this._dirtyRowMax = -1;
+        this._changeTag = 0;
+    }
+    /** The atlas of the current device, created on first use */ static get instance() {
+        if (!this._instance || this._instance.disposed) {
+            this._instance = new SkinPaletteAtlas();
+        }
+        return this._instance;
+    }
+    /** Upload the pending writes of the atlas, if one has been created, then notify upload listeners */ static flushPending() {
+        if (this._instance && !this._instance.disposed) {
+            const uploaded = this._instance.flush();
+            for (const listener of this._uploadListeners){
+                listener(uploaded);
+            }
+        }
+    }
+    /**
+   * Register a callback run by every {@link flushPending}, told whether rows were uploaded.
+   *
+   * @remarks
+   * For writers of the atlas texture other than the CPU mirror, whose slots an upload of the mirror
+   * rows covering them overwrites.
+   */ static addUploadListener(listener) {
+        this._uploadListeners.push(listener);
+    }
+    /**
+   * Register a callback run each time the atlas grows and replaces its texture.
+   *
+   * @remarks
+   * For consumers holding the texture that are not refreshed every frame, such as skinned meshes
+   * sleeping while an animation bank track poses them.
+   */ static addTextureReplacedListener(listener) {
+        this._replaceListeners.push(listener);
+    }
+    /** Atlas texture, created on first use and replaced when the atlas grows */ get texture() {
+        let texture = this._texture.get();
+        if (!texture) {
+            const device = getDevice();
+            texture = device.createTexture2D('rgba32f', ATLAS_WIDTH, this._height, {
+                // Animation bank tracks evaluate their palettes in compute passes on WebGPU
+                writable: device.type === 'webgpu',
+                mipmapping: false,
+                samplerOptions: {
+                    magFilter: 'nearest',
+                    minFilter: 'nearest',
+                    mipFilter: 'none'
+                }
+            });
+            this._texture.set(texture);
+            this.markDirtyRows(0, this._height - 1);
+        }
+        return texture;
+    }
+    /** Width of the atlas in texels */ get width() {
+        return ATLAS_WIDTH;
+    }
+    /** Height of the atlas in texels */ get height() {
+        return this._height;
+    }
+    /** Increased each time the atlas texture is replaced */ get changeTag() {
+        return this._changeTag;
+    }
+    /** Number of slots the atlas holds at its current size */ get slotCapacity() {
+        return ATLAS_WIDTH * this._height / TEXELS_PER_SLOT;
+    }
+    /**
+   * Allocate a block of consecutive slots, growing the atlas when no free range is large enough.
+   *
+   * @param count - Number of slots
+   * @returns The allocated block
+   */ allocate(count) {
+        count = Math.max(1, Math.ceil(count));
+        for(;;){
+            for(let i = 0; i < this._freeList.length; i++){
+                const range = this._freeList[i];
+                if (range.count >= count) {
+                    const block = {
+                        base: range.base,
+                        count
+                    };
+                    range.base += count;
+                    range.count -= count;
+                    if (range.count === 0) {
+                        this._freeList.splice(i, 1);
+                    }
+                    return block;
+                }
+            }
+            this.grow(count);
+        }
+    }
+    /**
+   * Return a block to the free list, merging it with adjacent free ranges.
+   *
+   * @param block - Block returned by {@link allocate}
+   */ free(block) {
+        let i = 0;
+        while(i < this._freeList.length && this._freeList[i].base < block.base){
+            i++;
+        }
+        const prev = i > 0 ? this._freeList[i - 1] : null;
+        const next = i < this._freeList.length ? this._freeList[i] : null;
+        if (prev && prev.base + prev.count === block.base) {
+            prev.count += block.count;
+            if (next && prev.base + prev.count === next.base) {
+                prev.count += next.count;
+                this._freeList.splice(i, 1);
+            }
+        } else if (next && block.base + block.count === next.base) {
+            next.base = block.base;
+            next.count += block.count;
+        } else {
+            this._freeList.splice(i, 0, {
+                base: block.base,
+                count: block.count
+            });
+        }
+    }
+    /**
+   * Write consecutive slots to the CPU-side mirror and mark their rows dirty.
+   *
+   * @param slot - Index of the first slot
+   * @param values - Slot contents, 16 floats per slot
+   * @param slotCount - Number of slots to write, defaults to all slots in `values`
+   */ writeSlots(slot, values, slotCount) {
+        slotCount = slotCount ?? Math.floor(values.length / FLOATS_PER_SLOT);
+        const floatCount = slotCount * FLOATS_PER_SLOT;
+        const offset = slot * FLOATS_PER_SLOT;
+        if (values.length === floatCount) {
+            this._data.set(values, offset);
+        } else {
+            for(let i = 0; i < floatCount; i++){
+                this._data[offset + i] = values[i];
+            }
+        }
+        this.markDirtySlots(slot, slotCount);
+    }
+    /**
+   * Upload the rows written since the last flush to the atlas texture.
+   *
+   * @returns Whether any rows were uploaded
+   */ flush() {
+        if (this._dirtyRowMax < 0) {
+            return false;
+        }
+        const texture = this.texture;
+        const rowFloats = ATLAS_WIDTH * 4;
+        const rowMin = this._dirtyRowMin;
+        const rowCount = this._dirtyRowMax - rowMin + 1;
+        texture.update(this._data.subarray(rowMin * rowFloats, (rowMin + rowCount) * rowFloats), 0, rowMin, ATLAS_WIDTH, rowCount);
+        this._dirtyRowMin = Number.MAX_SAFE_INTEGER;
+        this._dirtyRowMax = -1;
+        return true;
+    }
+    /** @internal */ onDispose() {
+        super.onDispose();
+        this._texture.dispose();
+        if (SkinPaletteAtlas._instance === this) {
+            SkinPaletteAtlas._instance = null;
+        }
+    }
+    /** Mark the rows covering a range of slots dirty */ markDirtySlots(slot, slotCount) {
+        if (slotCount > 0) {
+            const slotsPerRow = ATLAS_WIDTH / TEXELS_PER_SLOT;
+            this.markDirtyRows(Math.floor(slot / slotsPerRow), Math.floor((slot + slotCount - 1) / slotsPerRow));
+        }
+    }
+    markDirtyRows(rowMin, rowMax) {
+        this._dirtyRowMin = Math.min(this._dirtyRowMin, rowMin);
+        this._dirtyRowMax = Math.max(this._dirtyRowMax, rowMax);
+    }
+    /** Double the height until a block of the given slot count fits at the end */ grow(count) {
+        const maxHeight = Math.min(getDevice().getDeviceCaps().textureCaps.maxTextureSize, MAX_TEXELS / ATLAS_WIDTH);
+        const last = this._freeList[this._freeList.length - 1];
+        const tailFree = last && last.base + last.count === this.slotCapacity ? last.count : 0;
+        let height = this._height;
+        while((height - this._height) * ATLAS_WIDTH / TEXELS_PER_SLOT + tailFree < count){
+            height *= 2;
+            if (height > maxHeight) {
+                throw new Error(`SkinPaletteAtlas: cannot allocate ${count} slots, atlas is full`);
+            }
+        }
+        const oldCapacity = this.slotCapacity;
+        const data = new Float32Array(ATLAS_WIDTH * height * 4);
+        data.set(this._data);
+        this._data = data;
+        this._height = height;
+        this.free({
+            base: oldCapacity,
+            count: this.slotCapacity - oldCapacity
+        });
+        this._texture.set(null);
+        this.markDirtyRows(0, height - 1);
+        this._changeTag++;
+        for (const listener of SkinPaletteAtlas._replaceListeners){
+            listener();
+        }
+    }
+}
+
+export { SkinPaletteAtlas };
+//# sourceMappingURL=skin_palette_atlas.js.map

package/dist/animation/skin_palette_atlas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skin_palette_atlas.js","sources":["../../src/animation/skin_palette_atlas.ts"],"sourcesContent":["import { DRef, Disposable } from '@zephyr3d/base';\r\nimport type { Nullable } from '@zephyr3d/base';\r\nimport type { Texture2D } from '@zephyr3d/device';\r\nimport { getDevice } from '../app/api';\r\n\r\n/** Floats in one slot: a 4x4 matrix stored as 4 rgba32f texels on one row */\r\nconst FLOATS_PER_SLOT = 16;\r\n/** Texels in one slot */\r\nconst TEXELS_PER_SLOT = 4;\r\n/** Atlas width in texels, a multiple of TEXELS_PER_SLOT so no slot straddles two rows */\r\nconst ATLAS_WIDTH = 1024;\r\n/** Initial atlas height in rows */\r\nconst INITIAL_HEIGHT = 64;\r\n/**\r\n * Shaders compute texel indices as floats, which stay exact below 2^24, so the atlas never holds\r\n * more texels than that\r\n */\r\nconst MAX_TEXELS = 1 << 24;\r\n\r\n/**\r\n * A range of slots allocated in the skin palette atlas.\r\n *\r\n * @internal\r\n */\r\nexport interface SkinPaletteBlock {\r\n  /** Index of the first slot */\r\n  readonly base: number;\r\n  /** Number of slots */\r\n  readonly count: number;\r\n}\r\n\r\n/**\r\n * Shared rgba32f texture holding the skinning matrix palettes of all skinned meshes.\r\n *\r\n * @remarks\r\n * The atlas is addressed in slots of 4 texels (one 4x4 matrix, one row per texel), so the\r\n * shader fetches a matrix the same way it fetched one from a per-skeleton joint texture.\r\n * Blocks are allocated first-fit from a free list and keep their place until released, so the\r\n * slot index of a block can be stored in instance data without being rewritten every frame.\r\n *\r\n * Writes go to a CPU-side mirror and the dirty rows are uploaded once per frame by {@link flush}.\r\n * Growing the atlas replaces its texture; {@link changeTag} tells consumers holding the old one.\r\n * The old texture is only released, so a consumer still holding a reference keeps it alive until\r\n * it switches over.\r\n *\r\n * @internal\r\n */\r\nexport class SkinPaletteAtlas extends Disposable {\r\n  private static _instance: Nullable<SkinPaletteAtlas> = null;\r\n  private static readonly _uploadListeners: ((uploaded: boolean) => void)[] = [];\r\n  private static readonly _replaceListeners: (() => void)[] = [];\r\n  private readonly _texture: DRef<Texture2D>;\r\n  private _data: Float32Array<ArrayBuffer>;\r\n  private _height: number;\r\n  /** Free slot ranges sorted by base, never adjacent to each other */\r\n  private readonly _freeList: { base: number; count: number }[];\r\n  private _dirtyRowMin: number;\r\n  private _dirtyRowMax: number;\r\n  private _changeTag: number;\r\n  private constructor() {\r\n    super();\r\n    this._texture = new DRef();\r\n    this._height = INITIAL_HEIGHT;\r\n    this._data = new Float32Array(ATLAS_WIDTH * this._height * 4);\r\n    this._freeList = [{ base: 0, count: this.slotCapacity }];\r\n    this._dirtyRowMin = Number.MAX_SAFE_INTEGER;\r\n    this._dirtyRowMax = -1;\r\n    this._changeTag = 0;\r\n  }\r\n  /** The atlas of the current device, created on first use */\r\n  static get instance() {\r\n    if (!this._instance || this._instance.disposed) {\r\n      this._instance = new SkinPaletteAtlas();\r\n    }\r\n    return this._instance;\r\n  }\r\n  /** Upload the pending writes of the atlas, if one has been created, then notify upload listeners */\r\n  static flushPending() {\r\n    if (this._instance && !this._instance.disposed) {\r\n      const uploaded = this._instance.flush();\r\n      for (const listener of this._uploadListeners) {\r\n        listener(uploaded);\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * Register a callback run by every {@link flushPending}, told whether rows were uploaded.\r\n   *\r\n   * @remarks\r\n   * For writers of the atlas texture other than the CPU mirror, whose slots an upload of the mirror\r\n   * rows covering them overwrites.\r\n   */\r\n  static addUploadListener(listener: (uploaded: boolean) => void) {\r\n    this._uploadListeners.push(listener);\r\n  }\r\n  /**\r\n   * Register a callback run each time the atlas grows and replaces its texture.\r\n   *\r\n   * @remarks\r\n   * For consumers holding the texture that are not refreshed every frame, such as skinned meshes\r\n   * sleeping while an animation bank track poses them.\r\n   */\r\n  static addTextureReplacedListener(listener: () => void) {\r\n    this._replaceListeners.push(listener);\r\n  }\r\n  /** Atlas texture, created on first use and replaced when the atlas grows */\r\n  get texture() {\r\n    let texture = this._texture.get();\r\n    if (!texture) {\r\n      const device = getDevice();\r\n      texture = device.createTexture2D('rgba32f', ATLAS_WIDTH, this._height, {\r\n        // Animation bank tracks evaluate their palettes in compute passes on WebGPU\r\n        writable: device.type === 'webgpu',\r\n        mipmapping: false,\r\n        samplerOptions: {\r\n          magFilter: 'nearest',\r\n          minFilter: 'nearest',\r\n          mipFilter: 'none'\r\n        }\r\n      })!;\r\n      this._texture.set(texture);\r\n      this.markDirtyRows(0, this._height - 1);\r\n    }\r\n    return texture;\r\n  }\r\n  /** Width of the atlas in texels */\r\n  get width() {\r\n    return ATLAS_WIDTH;\r\n  }\r\n  /** Height of the atlas in texels */\r\n  get height() {\r\n    return this._height;\r\n  }\r\n  /** Increased each time the atlas texture is replaced */\r\n  get changeTag() {\r\n    return this._changeTag;\r\n  }\r\n  /** Number of slots the atlas holds at its current size */\r\n  get slotCapacity() {\r\n    return (ATLAS_WIDTH * this._height) / TEXELS_PER_SLOT;\r\n  }\r\n  /**\r\n   * Allocate a block of consecutive slots, growing the atlas when no free range is large enough.\r\n   *\r\n   * @param count - Number of slots\r\n   * @returns The allocated block\r\n   */\r\n  allocate(count: number): SkinPaletteBlock {\r\n    count = Math.max(1, Math.ceil(count));\r\n    for (;;) {\r\n      for (let i = 0; i < this._freeList.length; i++) {\r\n        const range = this._freeList[i];\r\n        if (range.count >= count) {\r\n          const block = { base: range.base, count };\r\n          range.base += count;\r\n          range.count -= count;\r\n          if (range.count === 0) {\r\n            this._freeList.splice(i, 1);\r\n          }\r\n          return block;\r\n        }\r\n      }\r\n      this.grow(count);\r\n    }\r\n  }\r\n  /**\r\n   * Return a block to the free list, merging it with adjacent free ranges.\r\n   *\r\n   * @param block - Block returned by {@link allocate}\r\n   */\r\n  free(block: SkinPaletteBlock) {\r\n    let i = 0;\r\n    while (i < this._freeList.length && this._freeList[i].base < block.base) {\r\n      i++;\r\n    }\r\n    const prev = i > 0 ? this._freeList[i - 1] : null;\r\n    const next = i < this._freeList.length ? this._freeList[i] : null;\r\n    if (prev && prev.base + prev.count === block.base) {\r\n      prev.count += block.count;\r\n      if (next && prev.base + prev.count === next.base) {\r\n        prev.count += next.count;\r\n        this._freeList.splice(i, 1);\r\n      }\r\n    } else if (next && block.base + block.count === next.base) {\r\n      next.base = block.base;\r\n      next.count += block.count;\r\n    } else {\r\n      this._freeList.splice(i, 0, { base: block.base, count: block.count });\r\n    }\r\n  }\r\n  /**\r\n   * Write consecutive slots to the CPU-side mirror and mark their rows dirty.\r\n   *\r\n   * @param slot - Index of the first slot\r\n   * @param values - Slot contents, 16 floats per slot\r\n   * @param slotCount - Number of slots to write, defaults to all slots in `values`\r\n   */\r\n  writeSlots(slot: number, values: ArrayLike<number>, slotCount?: number) {\r\n    slotCount = slotCount ?? Math.floor(values.length / FLOATS_PER_SLOT);\r\n    const floatCount = slotCount * FLOATS_PER_SLOT;\r\n    const offset = slot * FLOATS_PER_SLOT;\r\n    if (values.length === floatCount) {\r\n      this._data.set(values, offset);\r\n    } else {\r\n      for (let i = 0; i < floatCount; i++) {\r\n        this._data[offset + i] = values[i];\r\n      }\r\n    }\r\n    this.markDirtySlots(slot, slotCount);\r\n  }\r\n  /**\r\n   * Upload the rows written since the last flush to the atlas texture.\r\n   *\r\n   * @returns Whether any rows were uploaded\r\n   */\r\n  flush() {\r\n    if (this._dirtyRowMax < 0) {\r\n      return false;\r\n    }\r\n    const texture = this.texture;\r\n    const rowFloats = ATLAS_WIDTH * 4;\r\n    const rowMin = this._dirtyRowMin;\r\n    const rowCount = this._dirtyRowMax - rowMin + 1;\r\n    texture.update(\r\n      this._data.subarray(rowMin * rowFloats, (rowMin + rowCount) * rowFloats),\r\n      0,\r\n      rowMin,\r\n      ATLAS_WIDTH,\r\n      rowCount\r\n    );\r\n    this._dirtyRowMin = Number.MAX_SAFE_INTEGER;\r\n    this._dirtyRowMax = -1;\r\n    return true;\r\n  }\r\n  /** @internal */\r\n  protected onDispose() {\r\n    super.onDispose();\r\n    this._texture.dispose();\r\n    if (SkinPaletteAtlas._instance === this) {\r\n      SkinPaletteAtlas._instance = null;\r\n    }\r\n  }\r\n  /** Mark the rows covering a range of slots dirty */\r\n  private markDirtySlots(slot: number, slotCount: number) {\r\n    if (slotCount > 0) {\r\n      const slotsPerRow = ATLAS_WIDTH / TEXELS_PER_SLOT;\r\n      this.markDirtyRows(Math.floor(slot / slotsPerRow), Math.floor((slot + slotCount - 1) / slotsPerRow));\r\n    }\r\n  }\r\n  private markDirtyRows(rowMin: number, rowMax: number) {\r\n    this._dirtyRowMin = Math.min(this._dirtyRowMin, rowMin);\r\n    this._dirtyRowMax = Math.max(this._dirtyRowMax, rowMax);\r\n  }\r\n  /** Double the height until a block of the given slot count fits at the end */\r\n  private grow(count: number) {\r\n    const maxHeight = Math.min(\r\n      getDevice().getDeviceCaps().textureCaps.maxTextureSize,\r\n      MAX_TEXELS / ATLAS_WIDTH\r\n    );\r\n    const last = this._freeList[this._freeList.length - 1];\r\n    const tailFree = last && last.base + last.count === this.slotCapacity ? last.count : 0;\r\n    let height = this._height;\r\n    while (((height - this._height) * ATLAS_WIDTH) / TEXELS_PER_SLOT + tailFree < count) {\r\n      height *= 2;\r\n      if (height > maxHeight) {\r\n        throw new Error(`SkinPaletteAtlas: cannot allocate ${count} slots, atlas is full`);\r\n      }\r\n    }\r\n    const oldCapacity = this.slotCapacity;\r\n    const data = new Float32Array(ATLAS_WIDTH * height * 4);\r\n    data.set(this._data);\r\n    this._data = data;\r\n    this._height = height;\r\n    this.free({ base: oldCapacity, count: this.slotCapacity - oldCapacity });\r\n    this._texture.set(null);\r\n    this.markDirtyRows(0, height - 1);\r\n    this._changeTag++;\r\n    for (const listener of SkinPaletteAtlas._replaceListeners) {\r\n      listener();\r\n    }\r\n  }\r\n}\r\n"],"names":["FLOATS_PER_SLOT","TEXELS_PER_SLOT","ATLAS_WIDTH","INITIAL_HEIGHT","MAX_TEXELS","SkinPaletteAtlas","Disposable","_instance","_uploadListeners","_replaceListeners","_texture","_data","_height","_dirtyRowMin","_dirtyRowMax","_changeTag","DRef","Float32Array","_freeList","base","count","slotCapacity","Number","MAX_SAFE_INTEGER","instance","disposed","flushPending","uploaded","flush","listener","addUploadListener","push","addTextureReplacedListener","texture","get","device","getDevice","createTexture2D","writable","type","mipmapping","samplerOptions","magFilter","minFilter","mipFilter","set","markDirtyRows","width","height","changeTag","allocate","Math","max","ceil","i","length","range","block","splice","grow","free","prev","next","writeSlots","slot","values","slotCount","floor","floatCount","offset","markDirtySlots","rowFloats","rowMin","rowCount","update","subarray","onDispose","dispose","slotsPerRow","rowMax","min","maxHeight","getDeviceCaps","textureCaps","maxTextureSize","last","tailFree","Error","oldCapacity","data"],"mappings":"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"}