@zephyr3d/scene 0.6.0 → 0.7.0

package/dist/material/material.js

@@ -1,36 +1,153 @@
 import { ProgramBuilder } from '@zephyr3d/device';
 import { QUEUE_OPAQUE } from '../values.js';
 import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
+import { Disposable } from '@zephyr3d/base';
+import { getEngine } from '../app/api.js';
 
 /**
- * Base class for any kind of materials
+ * Base class for all materials.
+ *
+ * Responsibilities:
+ * - Defines a multi-pass rendering interface (`numPasses`, `apply`, `bind`, `draw`, `drawPrimitive`).
+ * - Builds and caches GPU shader programs per pass and per-render-context hash.
+ * - Manages a per-material bind group (typically at index 2) for uniforms and resources.
+ * - Updates render states per pass (`updateRenderStates`) and uploads uniforms (`_applyUniforms`).
+ * - Tracks "option" changes that affect shader variant hashing and render bundles.
+ *
+ * Caching and hashing:
+ * - `createHash(pass)` produces a stable hash representing shader variant options for a pass.
+ *   Override `_createHash()` in subclasses to encode feature toggles (defines, keywords, macros).
+ * - The global hash used to key `MaterialState` also includes `ctx.materialFlags` and
+ *   `ctx.renderPassHash`, allowing context-sensitive variants (e.g., MSAA, MRT layout).
+ * - GPU programs are additionally memoized in a global static `_programCache` across materials
+ *   by `constructor.name` + hash, to avoid recompilation of identical variants.
+ *
+ * Bind groups and uniforms:
+ * - If a program declares a bind group layout at index 2 (i.e., `bindGroupLayouts.length > 2`),
+ *   `apply()` will allocate the group and keep it in the state. Subclasses should fill it in
+ *   `_applyUniforms()`.
+ * - `applyUniforms()` only calls `_applyUniforms()` when `needUpdate` is true, based on
+ *   `_optionTag` changes (see `optionChanged()`).
+ *
+ * Lifecycle:
+ * - Constructed materials register a persistent ID into a global registry for serialization.
+ * - `apply(ctx)` prepares all passes: creates/gets state, programs, bind groups, render states,
+ *   and uploads uniforms as needed.
+ * - `bind(device, pass)` binds the program, bind group (index 2), and render states.
+ * - `draw(primitive, ctx, numInstances)` runs all passes, calling `bind()` and `drawPrimitive()`.
+ * - `onDispose()` releases bind groups and registry entries.
+ *
+ * Extending:
+ * - Override `_createProgram(pb, ctx, pass)` to build a shader.
+ * - Override `_applyUniforms(bindGroup, ctx, pass)` to upload uniforms and resources.
+ * - Override `updateRenderStates(pass, renderStates, ctx)` to set depth, blend, cull, etc.
+ * - Override `_createHash()` to encode options that affect program compilation.
+ * - Override `supportLighting`, `supportInstancing`, `isTransparentPass`, `getQueueType`, etc.
+ *
+ * Thread-safety:
+ * - Intended for main-thread use in a renderer driving WebGPU/WebGL-like devices.
  *
  * @public
- */ class Material {
-    /** @internal */ static _nextId = 0;
-    /** @internal */ static _programCache = {};
-    /** @internal */ _states;
-    /** @internal */ _numPasses;
-    /** @internal */ _hash;
-    /** @internal */ _optionTag;
-    /** @internal */ _id;
-    /** @internal */ _currentHash;
-    /**
-   * Creates an instance of material
+ */ class Material extends Disposable {
+    /**
+   * Monotonic instance ID counter.
+   * @internal
+   */ static _nextId = 0;
+    /**
+   * Per-material state cache keyed by global hash (material + context + pass).
+   * @internal
+   */ _states;
+    /**
+   * Number of rendering passes.
+   * Subclasses can increase this to implement multi-pass rendering.
+   * @internal
+   */ _numPasses;
+    /**
+   * Per-pass hash cached results. Length scales with `numPasses`.
+   * @internal
+   */ _hash;
+    /**
+   * Incremented each time options change (via `optionChanged`), used to decide whether
+   * uniforms need update on next `apply()`.
+   * @internal
+   */ _optionTag;
+    /**
+   * Unique runtime instance ID.
+   * @internal
+   */ _id;
+    /**
+   * Latest computed global hash per pass, set during `apply()`, read in `bind()`.
+   * @internal
+   */ _currentHash;
+    /**
+   * Incremented when material states affecting render bundles change (e.g., bind group id changes
+   * or `optionChanged(true)`), used to trigger re-recording of render bundles.
+   * @internal
+   */ _changeTag;
+    /**
+   * Unique program id counter for naming compiled programs.
+   * @internal
+   */ _nextProgramId = 0;
+    /**
+   * Create a new material instance.
+   *
+   * - Initializes one pass by default.
+   * - Prepares per-pass hash storage and change tracking.
+   * - Registers a persistent ID in the global registry.
    */ constructor(){
+        super();
         this._id = ++Material._nextId;
+        this._nextProgramId = 0;
         this._states = {};
         this._numPasses = 1;
         this._hash = [
             null
         ];
         this._optionTag = 0;
+        this._changeTag = 0;
         this._currentHash = [];
     }
-    /** Unique identifier of the material */ get instanceId() {
+    /**
+   * Create a shallow clone of this material.
+   *
+   * Note: The base implementation returns a base `Material`. Subclasses should
+   * override to return their own type and copy custom fields.
+   */ clone() {
+        const other = new Material();
+        other.copyFrom(this);
+        return other;
+    }
+    /**
+   * Copy basic properties from another material.
+   *
+   * Disposes existing bind groups/states, copies `numPasses`. Subclasses should
+   * extend this to copy their own fields and call `optionChanged(true)` if
+   * shader-affecting options differ.
+   *
+   * @param other - Source material.
+   */ copyFrom(other) {
+        this.clearCache();
+        this._numPasses = other._numPasses;
+        getEngine().resourceManager.setAssetId(this, getEngine().resourceManager.getAssetId(other.coreMaterial));
+    }
+    /**
+   * Incremented when the material’s GPU-relevant state changes and render bundles
+   * may need to be rebuilt.
+   */ get changeTag() {
+        return this._changeTag;
+    }
+    /**
+   * Runtime-unique numeric identifier for the material instance.
+   */ get instanceId() {
         return this._id;
     }
-    get numPasses() {
+    /**
+   * Number of rendering passes this material uses.
+   *
+   * Increasing this will expand the per-pass hash cache; make sure to implement
+   * `createHash(pass)`, `_createProgram(pb, ctx, pass)`, and `updateRenderStates(pass, ...)`
+   * accordingly for each pass.
+   */ get numPasses() {
         return this._numPasses;
     }
     set numPasses(val) {
@@ -39,52 +156,98 @@ import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
         }
         this._numPasses = val;
     }
-    /** @internal */ getHash(pass) {
+    /**
+   * Get or compute the per-pass shader hash used for program caching.
+   *
+   * Calls `createHash(pass)` lazily and caches the result.
+   * @internal
+   */ getHash(pass) {
         if (this._hash[pass] === null) {
             this._hash[pass] = this.createHash(pass);
         }
         return this._hash[pass];
     }
-    getQueueType() {
+    /**
+   * Return the queue type to which this material belongs.
+   *
+   * Override this in transparent or special materials (e.g., post-process).
+   */ getQueueType() {
         return QUEUE_OPAQUE;
     }
-    /** Returns true if given pass is transparent */ isTransparentPass(pass) {
+    /**
+   * Whether the given pass is transparent.
+   *
+   * Used to place draw calls into appropriate render queues and set blending states.
+   */ isTransparentPass(_pass) {
         return false;
     }
-    /** Returns true if shading of the material will be affected by lights  */ supportLighting() {
+    /**
+   * Whether this material's shading is affected by scene lights.
+   *
+   * Override and return `false` for unlit materials.
+   */ supportLighting() {
         return true;
     }
-    /** Returns true if this material supports geometry instancing  */ supportInstancing() {
+    /**
+   * Whether this material supports hardware instancing.
+   *
+   * Override and return `false` if per-instance data is not supported in the shader.
+   */ supportInstancing() {
         return true;
     }
-    /** Returns true if this material supports geometry instancing  */ isBatchable() {
+    /** Returns true if this is a instance of material */ isBatchable() {
+        return false;
+    }
+    /**
+   * Whether this material requires the scene color texture (e.g., for refraction).
+   */ needSceneColor() {
         return false;
     }
-    /** Return true if this material requires the scene color texture */ needSceneColor() {
+    /**
+   * Whether this material requires the linear scene depth texture (e.g., for depth-aware effects).
+   */ needSceneDepth() {
         return false;
     }
-    /** @internal */ get coreMaterial() {
+    /**
+   * Create a material instance (instance-uniform-driven variant).
+   *
+   * Base returns `null`. Subclasses that support instancing can return a lightweight instance.
+   */ createInstance() {
+        return null;
+    }
+    /**
+   * Returns the core material that owns GPU state.
+   *
+   * Instances may delegate to a shared core to reuse compiled programs and caches.
+   * @internal
+   */ get coreMaterial() {
         return this;
     }
     /**
-   * Apply material
-   * @param ctx - Draw context
-   * @returns true if no error, otherwise false
+   * Prepare the material for drawing across all passes for the given draw context.
+   *
+   * Steps per pass:
+   * - Compute global hash (material variant + context).
+   * - Retrieve or build the GPU program, cache in `_programCache`.
+   * - Create per-material bind group (index 2) if the program exposes it.
+   * - Update uniforms if `_optionTag` indicates changes since last apply.
+   * - Update and cache render states for the pass.
+   * - Detect bind group GPU ID changes to bump `changeTag` and notify `RenderBundleWrapper`.
+   *
+   * @param ctx - Draw context (device, flags, pass hash, instance data, etc.).
+   * @returns `true` if successful; `false` if any pass lacks a valid program.
    */ apply(ctx) {
         for(let pass = 0; pass < this._numPasses; pass++){
             const hash = this.calcGlobalHash(ctx, pass);
             let state = this._states[hash];
             if (!state) {
-                const programHash = `${this.constructor.name}:${hash}`;
-                let program = Material._programCache[programHash];
-                if (!program) {
-                    program = this.createProgram(ctx, pass) ?? null;
-                    Material._programCache[programHash] = program;
-                }
+                const program = this.createProgram(ctx, pass) ?? null;
+                program.name = `@${this.constructor.name}_program_${this._nextProgramId++}`;
                 const bindGroup = program.bindGroupLayouts.length > 2 ? ctx.device.createBindGroup(program.bindGroupLayouts[2]) : null;
                 state = {
                     program,
                     bindGroup,
+                    bindGroupTag: bindGroup?.getGPUId() ?? '',
                     renderStateSet: ctx.device.createRenderStateSet(),
                     materialTag: -1
                 };
@@ -97,9 +260,26 @@ import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
             state.materialTag = this._optionTag;
             this.updateRenderStates(pass, state.renderStateSet, ctx);
             this._currentHash[pass] = hash;
+            if (state.bindGroup) {
+                const id = state.bindGroup.getGPUId();
+                if (id !== state.bindGroupTag) {
+                    state.bindGroupTag = id;
+                    this._changeTag++;
+                    RenderBundleWrapper.materialChanged(this.coreMaterial);
+                }
+            }
         }
     }
-    /** @internal */ bind(device, pass) {
+    /**
+   * Bind the program, bind group, and render states for the specified pass.
+   *
+   * Must be called after `apply(ctx)` for the same pass.
+   *
+   * @param device - Rendering device.
+   * @param pass - Pass index to bind.
+   * @returns `true` on success; `false` if state or program missing.
+   * @internal
+   */ bind(device, pass) {
         const hash = this._currentHash[pass];
         const state = this._states[hash];
         if (!state) {
@@ -113,16 +293,27 @@ import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
         device.setBindGroup(2, state.bindGroup);
         device.setRenderStates(state.renderStateSet);
     }
-    /** @internal */ calcGlobalHash(ctx, pass) {
+    /**
+   * Compute the global hash for the given pass and draw context.
+   *
+   * Includes:
+   * - Per-pass material hash from `getHash(pass)`.
+   * - `ctx.materialFlags` for context-dependent toggles.
+   * - `ctx.renderPassHash` for framebuffer/attachment layout variants.
+   * @internal
+   */ calcGlobalHash(ctx, pass) {
         return `${this.getHash(pass)}:${ctx.materialFlags}:${ctx.renderPassHash}`;
     }
     /**
-   * Draws a primitive using this material
-   * @internal
+   * Draw a primitive for all passes using this material.
+   *
+   * Calls `bind()` then `drawPrimitive()` per pass. If `numInstances` is zero,
+   * and `ctx.instanceData` exists, uses `ctx.instanceData.numInstances`.
    *
-   * @param primitive - The prmitive to be drawn
-   * @param ctx - The context of current drawing task
-   * @param numInstances - How many instances should be drawn. if zero, the instance count will be automatically detected.
+   * @param primitive - Geometry to draw.
+   * @param ctx - Draw context.
+   * @param numInstances - Instance count; 0 means auto-detect from context.
+   * @internal
    */ draw(primitive, ctx, numInstances = 0) {
         for(let pass = 0; pass < this._numPasses; pass++){
             this.bind(ctx.device, pass);
@@ -130,39 +321,78 @@ import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
         }
     }
     /**
-   * Sets all uniform values to the bind group of the material if needed
-   * @param bindGroup - The bind group of the material
-   * @param ctx - The context of current drawing task
-   * @param needUpdate - true if the uniform values needs to update
+   * Conditionally update uniforms/resources into the material bind group.
+   *
+   * Delegates to `_applyUniforms()` when `needUpdate` is true (based on `_optionTag` check).
+   *
+   * @param bindGroup - Material bind group at index 2 (may be `null` if program has no layout).
+   * @param ctx - Draw context.
+   * @param needUpdate - Whether uniforms need to be refreshed.
+   * @param pass - Pass index.
    */ applyUniforms(bindGroup, ctx, needUpdate, pass) {
         if (needUpdate) {
             this._applyUniforms(bindGroup, ctx, pass);
         }
     }
-    /** @internal */ optionChanged(changeHash) {
+    /**
+   * Notify the material that some option changed.
+   *
+   * - Always increments `_optionTag`. This will trigger uniforms update on next `apply()`.
+   * - If `changeHash` is true, clears per-pass hashes so programs/states will be rebuilt,
+   *   increments `_changeTag`, and notifies `RenderBundleWrapper` to regenerate recorded bundles.
+   *
+   * @param changeHash - Set true if the change affects shader compilation or render states.
+   * @internal
+   */ optionChanged(changeHash) {
         this._optionTag++;
         if (changeHash) {
             for(let i = 0; i < this._numPasses; i++){
                 this._hash[i] = null;
             }
-            RenderBundleWrapper.materialChanged(this);
+            this._changeTag++;
+            RenderBundleWrapper.materialChanged(this.coreMaterial);
         }
     }
+    clearCache() {
+        for(const k in this._states){
+            this._states[k]?.bindGroup?.dispose();
+            this._states[k]?.program?.dispose();
+        }
+        this._states = {};
+    }
     /**
-   * Convert pass to hash
-   * @param pass - pass number
-   * @returns String hash
+   * Convert a pass index to a hash seed string.
+   *
+   * Subclasses may override to encode per-pass role (e.g., "depth", "forward", "shadow").
+   *
+   * @param pass - Pass number.
+   * @returns String used when building full hash.
    */ passToHash(pass) {
         return String(pass);
     }
-    /** @internal */ createHash(pass) {
+    /**
+   * Build the material hash for a pass (excluding context-dependent parts).
+   *
+   * Default formula: `${constructor.name}|${pass}|${_createHash()}`
+   *
+   * @param pass - Pass number.
+   * @returns Hash string used in program caching.
+   * @internal
+   */ createHash(pass) {
         return `${this.constructor.name}|${pass}|${this._createHash()}`;
     }
     /**
-   * Draw primitve
+   * Issue the actual draw call for a pass.
    *
-   * @param primitive - Primitive to be drawn
-   * @param ctx - Draw context
+   * Override for custom per-pass draw behavior if necessary. The default implementation:
+   * - Draws instanced if `numInstances > 0`.
+   * - Else uses `ctx.instanceData.numInstances` if available.
+   * - Else issues a non-instanced draw.
+   *
+   * @param pass - Pass number.
+   * @param primitive - Primitive to draw.
+   * @param ctx - Draw context.
+   * @param numInstances - Explicit instance count (0 = auto).
    */ drawPrimitive(pass, primitive, ctx, numInstances) {
         if (numInstances > 0) {
             primitive.drawInstanced(numInstances);
@@ -172,46 +402,89 @@ import { RenderBundleWrapper } from '../render/renderbundle_wrapper.js';
             primitive.draw();
         }
     }
-    /** @internal */ createProgram(ctx, pass) {
+    /**
+   * Dispose the material and release GPU-side resource references.
+   *
+   * - Unregisters from the global registry.
+   * - Disposes the per-material bind groups kept in `_states`.
+   */ onDispose() {
+        super.onDispose();
+        this.clearCache();
+    }
+    /**
+   * Build the GPU program for a pass.
+   *
+   * Default creates a `ProgramBuilder` and calls `_createProgram(pb, ctx, pass)`.
+   * Subclasses should override `_createProgram` instead of this method unless
+   * they need to replace builder instantiation.
+   *
+   * @param ctx - Draw context.
+   * @param pass - Pass number.
+   * @returns The compiled `GPUProgram`, or `null` on failure.
+   * @internal
+   */ createProgram(ctx, pass) {
         const pb = new ProgramBuilder(ctx.device);
         return this._createProgram(pb, ctx, pass);
     }
     /**
-   * Creates the shader program
-   * @param pb - The program builder
-   * @param ctx - The drawing context
-   * @param func - The material func
-   * @returns The created shader program
-   */ _createProgram(pb, ctx, pass) {
+   * Create and compile the shader program for this material/pass.
+   *
+   * Implement in subclasses:
+   * - Define shader stages, entry points, macros/defines, and resource layouts.
+   * - Return a compiled `GPUProgram`.
+   *
+   * @param pb - Program builder.
+   * @param ctx - Draw context.
+   * @param _pass - Pass number.
+   * @returns The created program, or `null` on failure.
+   */ _createProgram(_pb, _ctx, _pass) {
         return null;
     }
     /**
-   * Applies uniform values
-   * @param bindGroup - The bind group
-   * @param ctx - The drawing context
-   */ _applyUniforms(bindGroup, ctx, pass) {}
+   * Upload uniforms and bind resources to the per-material bind group (index 2).
+   *
+   * Implement in subclasses to:
+   * - Write uniform buffers/textures/samplers to the `bindGroup`.
+   * - Respect the current `pass` and `ctx`.
+   *
+   * @param _bindGroup - The bind group to populate.
+   * @param _ctx - Draw context.
+   * @param _pass - Pass number.
+   */ _applyUniforms(_bindGroup, _ctx, _pass) {}
     /**
-   * Update render states according to draw context and current material pass
-   * @param pass - Current material pass
-   * @param renderStates - Render state set to be updated
-   * @param ctx - Draw context
-   */ updateRenderStates(pass, renderStates, ctx) {}
+   * Update render states (depth/stencil, blending, rasterization) for the pass.
+   *
+   * Implement in subclasses based on transparency, double-sidedness, depth writes/tests,
+   * color mask, stencil ops, etc., and any context flags in `ctx`.
+   *
+   * @param _pass - Current pass index.
+   * @param _renderStates - Render state set to mutate.
+   * @param _ctx - Draw context.
+   */ updateRenderStates(_pass, _renderStates, _ctx) {}
     /**
-   * Calculates the hash code of the shader program
-   * @returns The hash code
+   * Compute the material-specific portion of the shader hash for the current options.
+   *
+   * Subclasses should override to include macro/define sets that influence program compilation.
+   * Example return: `"USE_NORMALMAP=1;ALPHA_MODE=BLEND;RECEIVE_SHADOWS=1"`.
+   *
+   * @returns Hash fragment string (no context/pass info).
    */ _createHash() {
         return '';
     }
     /**
-   * True if this is a material instance
+   * Whether this is a lightweight instance of a core material.
+   *
+   * Instances typically share GPU programs with a core and only override instance uniforms.
    * @internal
-   **/ get $isInstance() {
+   */ get $isInstance() {
         return false;
     }
     /**
-   * Returns the instance uniforms if this is a material instance
+   * Instance-uniform buffer for material instances, if supported.
+   *
+   * Returned as a typed Float32 view over a backing ArrayBuffer.
    * @internal
-   **/ get $instanceUniforms() {
+   */ get $instanceUniforms() {
         return null;
     }
 }

package/dist/material/material.js.map

@@ -1 +1 @@
-{"version":3,"file":"material.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"material.js","sources":["../../src/material/material.ts"],"sourcesContent":["import type { AbstractDevice, BindGroup, GPUProgram, RenderStateSet } from '@zephyr3d/device';\r\nimport { ProgramBuilder } from '@zephyr3d/device';\r\nimport type { Primitive } from '../render/primitive';\r\nimport type { DrawContext } from '../render/drawable';\r\nimport { QUEUE_OPAQUE } from '../values';\r\nimport { RenderBundleWrapper } from '../render/renderbundle_wrapper';\r\nimport { Disposable } from '@zephyr3d/base';\r\nimport type { Clonable, IDisposable } from '@zephyr3d/base';\r\nimport { getEngine } from '../app/api';\r\n\r\ntype MaterialState = {\r\n  program: GPUProgram;\r\n  bindGroup: BindGroup;\r\n  bindGroupTag: string;\r\n  renderStateSet: RenderStateSet;\r\n  materialTag: number;\r\n};\r\n\r\n/**\r\n * Base class for all materials.\r\n *\r\n * Responsibilities:\r\n * - Defines a multi-pass rendering interface (`numPasses`, `apply`, `bind`, `draw`, `drawPrimitive`).\r\n * - Builds and caches GPU shader programs per pass and per-render-context hash.\r\n * - Manages a per-material bind group (typically at index 2) for uniforms and resources.\r\n * - Updates render states per pass (`updateRenderStates`) and uploads uniforms (`_applyUniforms`).\r\n * - Tracks \"option\" changes that affect shader variant hashing and render bundles.\r\n *\r\n * Caching and hashing:\r\n * - `createHash(pass)` produces a stable hash representing shader variant options for a pass.\r\n *   Override `_createHash()` in subclasses to encode feature toggles (defines, keywords, macros).\r\n * - The global hash used to key `MaterialState` also includes `ctx.materialFlags` and\r\n *   `ctx.renderPassHash`, allowing context-sensitive variants (e.g., MSAA, MRT layout).\r\n * - GPU programs are additionally memoized in a global static `_programCache` across materials\r\n *   by `constructor.name` + hash, to avoid recompilation of identical variants.\r\n *\r\n * Bind groups and uniforms:\r\n * - If a program declares a bind group layout at index 2 (i.e., `bindGroupLayouts.length > 2`),\r\n *   `apply()` will allocate the group and keep it in the state. Subclasses should fill it in\r\n *   `_applyUniforms()`.\r\n * - `applyUniforms()` only calls `_applyUniforms()` when `needUpdate` is true, based on\r\n *   `_optionTag` changes (see `optionChanged()`).\r\n *\r\n * Lifecycle:\r\n * - Constructed materials register a persistent ID into a global registry for serialization.\r\n * - `apply(ctx)` prepares all passes: creates/gets state, programs, bind groups, render states,\r\n *   and uploads uniforms as needed.\r\n * - `bind(device, pass)` binds the program, bind group (index 2), and render states.\r\n * - `draw(primitive, ctx, numInstances)` runs all passes, calling `bind()` and `drawPrimitive()`.\r\n * - `onDispose()` releases bind groups and registry entries.\r\n *\r\n * Extending:\r\n * - Override `_createProgram(pb, ctx, pass)` to build a shader.\r\n * - Override `_applyUniforms(bindGroup, ctx, pass)` to upload uniforms and resources.\r\n * - Override `updateRenderStates(pass, renderStates, ctx)` to set depth, blend, cull, etc.\r\n * - Override `_createHash()` to encode options that affect program compilation.\r\n * - Override `supportLighting`, `supportInstancing`, `isTransparentPass`, `getQueueType`, etc.\r\n *\r\n * Thread-safety:\r\n * - Intended for main-thread use in a renderer driving WebGPU/WebGL-like devices.\r\n *\r\n * @public\r\n */\r\nexport class Material extends Disposable implements Clonable<Material>, IDisposable {\r\n  /**\r\n   * Monotonic instance ID counter.\r\n   * @internal\r\n   */\r\n  private static _nextId = 0;\r\n  /**\r\n   * Per-material state cache keyed by global hash (material + context + pass).\r\n   * @internal\r\n   */\r\n  private _states: { [hash: string]: MaterialState };\r\n  /**\r\n   * Number of rendering passes.\r\n   * Subclasses can increase this to implement multi-pass rendering.\r\n   * @internal\r\n   */\r\n  protected _numPasses: number;\r\n  /**\r\n   * Per-pass hash cached results. Length scales with `numPasses`.\r\n   * @internal\r\n   */\r\n  protected _hash: string[];\r\n  /**\r\n   * Incremented each time options change (via `optionChanged`), used to decide whether\r\n   * uniforms need update on next `apply()`.\r\n   * @internal\r\n   */\r\n  private _optionTag: number;\r\n  /**\r\n   * Unique runtime instance ID.\r\n   * @internal\r\n   */\r\n  protected readonly _id: number;\r\n  /**\r\n   * Latest computed global hash per pass, set during `apply()`, read in `bind()`.\r\n   * @internal\r\n   */\r\n  private _currentHash: string[];\r\n  /**\r\n   * Incremented when material states affecting render bundles change (e.g., bind group id changes\r\n   * or `optionChanged(true)`), used to trigger re-recording of render bundles.\r\n   * @internal\r\n   */\r\n  private _changeTag: number;\r\n  /**\r\n   * Unique program id counter for naming compiled programs.\r\n   * @internal\r\n   */\r\n  private _nextProgramId = 0;\r\n  /**\r\n   * Create a new material instance.\r\n   *\r\n   * - Initializes one pass by default.\r\n   * - Prepares per-pass hash storage and change tracking.\r\n   * - Registers a persistent ID in the global registry.\r\n   */\r\n  constructor() {\r\n    super();\r\n    this._id = ++Material._nextId;\r\n    this._nextProgramId = 0;\r\n    this._states = {};\r\n    this._numPasses = 1;\r\n    this._hash = [null];\r\n    this._optionTag = 0;\r\n    this._changeTag = 0;\r\n    this._currentHash = [];\r\n  }\r\n  /**\r\n   * Create a shallow clone of this material.\r\n   *\r\n   * Note: The base implementation returns a base `Material`. Subclasses should\r\n   * override to return their own type and copy custom fields.\r\n   */\r\n  clone(): Material {\r\n    const other = new Material();\r\n    other.copyFrom(this);\r\n    return other;\r\n  }\r\n  /**\r\n   * Copy basic properties from another material.\r\n   *\r\n   * Disposes existing bind groups/states, copies `numPasses`. Subclasses should\r\n   * extend this to copy their own fields and call `optionChanged(true)` if\r\n   * shader-affecting options differ.\r\n   *\r\n   * @param other - Source material.\r\n   */\r\n  copyFrom(other: this) {\r\n    this.clearCache();\r\n    this._numPasses = other._numPasses;\r\n    getEngine().resourceManager.setAssetId(this, getEngine().resourceManager.getAssetId(other.coreMaterial));\r\n  }\r\n  /**\r\n   * Incremented when the material’s GPU-relevant state changes and render bundles\r\n   * may need to be rebuilt.\r\n   */\r\n  get changeTag() {\r\n    return this._changeTag;\r\n  }\r\n  /**\r\n   * Runtime-unique numeric identifier for the material instance.\r\n   */\r\n  get instanceId(): number {\r\n    return this._id;\r\n  }\r\n  /**\r\n   * Number of rendering passes this material uses.\r\n   *\r\n   * Increasing this will expand the per-pass hash cache; make sure to implement\r\n   * `createHash(pass)`, `_createProgram(pb, ctx, pass)`, and `updateRenderStates(pass, ...)`\r\n   * accordingly for each pass.\r\n   */\r\n  get numPasses(): number {\r\n    return this._numPasses;\r\n  }\r\n  set numPasses(val: number) {\r\n    while (this._hash.length < val) {\r\n      this._hash.push(null);\r\n    }\r\n    this._numPasses = val;\r\n  }\r\n  /**\r\n   * Get or compute the per-pass shader hash used for program caching.\r\n   *\r\n   * Calls `createHash(pass)` lazily and caches the result.\r\n   * @internal\r\n   */\r\n  protected getHash(pass: number): string {\r\n    if (this._hash[pass] === null) {\r\n      this._hash[pass] = this.createHash(pass);\r\n    }\r\n    return this._hash[pass];\r\n  }\r\n  /**\r\n   * Return the queue type to which this material belongs.\r\n   *\r\n   * Override this in transparent or special materials (e.g., post-process).\r\n   */\r\n  getQueueType(): number {\r\n    return QUEUE_OPAQUE;\r\n  }\r\n  /**\r\n   * Whether the given pass is transparent.\r\n   *\r\n   * Used to place draw calls into appropriate render queues and set blending states.\r\n   */\r\n  isTransparentPass(_pass: number): boolean {\r\n    return false;\r\n  }\r\n  /**\r\n   * Whether this material's shading is affected by scene lights.\r\n   *\r\n   * Override and return `false` for unlit materials.\r\n   */\r\n  supportLighting(): boolean {\r\n    return true;\r\n  }\r\n  /**\r\n   * Whether this material supports hardware instancing.\r\n   *\r\n   * Override and return `false` if per-instance data is not supported in the shader.\r\n   */\r\n  supportInstancing(): boolean {\r\n    return true;\r\n  }\r\n  /** Returns true if this is a instance of material */\r\n  isBatchable(): boolean {\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Whether this material requires the scene color texture (e.g., for refraction).\r\n   */\r\n  needSceneColor(): boolean {\r\n    return false;\r\n  }\r\n  /**\r\n   * Whether this material requires the linear scene depth texture (e.g., for depth-aware effects).\r\n   */\r\n  needSceneDepth(): boolean {\r\n    return false;\r\n  }\r\n  /**\r\n   * Create a material instance (instance-uniform-driven variant).\r\n   *\r\n   * Base returns `null`. Subclasses that support instancing can return a lightweight instance.\r\n   */\r\n  createInstance(): this {\r\n    return null;\r\n  }\r\n  /**\r\n   * Returns the core material that owns GPU state.\r\n   *\r\n   * Instances may delegate to a shared core to reuse compiled programs and caches.\r\n   * @internal\r\n   */\r\n  get coreMaterial(): this {\r\n    return this;\r\n  }\r\n  /**\r\n   * Prepare the material for drawing across all passes for the given draw context.\r\n   *\r\n   * Steps per pass:\r\n   * - Compute global hash (material variant + context).\r\n   * - Retrieve or build the GPU program, cache in `_programCache`.\r\n   * - Create per-material bind group (index 2) if the program exposes it.\r\n   * - Update uniforms if `_optionTag` indicates changes since last apply.\r\n   * - Update and cache render states for the pass.\r\n   * - Detect bind group GPU ID changes to bump `changeTag` and notify `RenderBundleWrapper`.\r\n   *\r\n   * @param ctx - Draw context (device, flags, pass hash, instance data, etc.).\r\n   * @returns `true` if successful; `false` if any pass lacks a valid program.\r\n   */\r\n  apply(ctx: DrawContext): boolean {\r\n    for (let pass = 0; pass < this._numPasses; pass++) {\r\n      const hash = this.calcGlobalHash(ctx, pass);\r\n      let state = this._states[hash];\r\n      if (!state) {\r\n        const program = this.createProgram(ctx, pass) ?? null;\r\n        program.name = `@${this.constructor.name}_program_${this._nextProgramId++}`;\r\n        const bindGroup =\r\n          program.bindGroupLayouts.length > 2\r\n            ? ctx.device.createBindGroup(program.bindGroupLayouts[2])\r\n            : null;\r\n        state = {\r\n          program,\r\n          bindGroup,\r\n          bindGroupTag: bindGroup?.getGPUId() ?? '',\r\n          renderStateSet: ctx.device.createRenderStateSet(),\r\n          materialTag: -1\r\n        };\r\n        this._states[hash] = state;\r\n      }\r\n      if (!state.program) {\r\n        return false;\r\n      }\r\n      this.applyUniforms(state.bindGroup, ctx, state.materialTag !== this._optionTag, pass);\r\n      state.materialTag = this._optionTag;\r\n      this.updateRenderStates(pass, state.renderStateSet, ctx);\r\n      this._currentHash[pass] = hash;\r\n      if (state.bindGroup) {\r\n        const id = state.bindGroup.getGPUId();\r\n        if (id !== state.bindGroupTag) {\r\n          state.bindGroupTag = id;\r\n          this._changeTag++;\r\n          RenderBundleWrapper.materialChanged(this.coreMaterial);\r\n        }\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * Bind the program, bind group, and render states for the specified pass.\r\n   *\r\n   * Must be called after `apply(ctx)` for the same pass.\r\n   *\r\n   * @param device - Rendering device.\r\n   * @param pass - Pass index to bind.\r\n   * @returns `true` on success; `false` if state or program missing.\r\n   * @internal\r\n   */\r\n  bind(device: AbstractDevice, pass: number): boolean {\r\n    const hash = this._currentHash[pass];\r\n    const state = this._states[hash];\r\n    if (!state) {\r\n      console.error('Material.bind() failed: state not found');\r\n      return false;\r\n    }\r\n    if (!state.program) {\r\n      return false;\r\n    }\r\n    device.setProgram(state.program);\r\n    device.setBindGroup(2, state.bindGroup);\r\n    device.setRenderStates(state.renderStateSet);\r\n  }\r\n  /**\r\n   * Compute the global hash for the given pass and draw context.\r\n   *\r\n   * Includes:\r\n   * - Per-pass material hash from `getHash(pass)`.\r\n   * - `ctx.materialFlags` for context-dependent toggles.\r\n   * - `ctx.renderPassHash` for framebuffer/attachment layout variants.\r\n   * @internal\r\n   */\r\n  private calcGlobalHash(ctx: DrawContext, pass: number): string {\r\n    return `${this.getHash(pass)}:${ctx.materialFlags}:${ctx.renderPassHash}`;\r\n  }\r\n  /**\r\n   * Draw a primitive for all passes using this material.\r\n   *\r\n   * Calls `bind()` then `drawPrimitive()` per pass. If `numInstances` is zero,\r\n   * and `ctx.instanceData` exists, uses `ctx.instanceData.numInstances`.\r\n   *\r\n   * @param primitive - Geometry to draw.\r\n   * @param ctx - Draw context.\r\n   * @param numInstances - Instance count; 0 means auto-detect from context.\r\n   * @internal\r\n   */\r\n  draw(primitive: Primitive, ctx: DrawContext, numInstances = 0) {\r\n    for (let pass = 0; pass < this._numPasses; pass++) {\r\n      this.bind(ctx.device, pass);\r\n      this.drawPrimitive(pass, primitive, ctx, numInstances);\r\n    }\r\n  }\r\n  /**\r\n   * Conditionally update uniforms/resources into the material bind group.\r\n   *\r\n   * Delegates to `_applyUniforms()` when `needUpdate` is true (based on `_optionTag` check).\r\n   *\r\n   * @param bindGroup - Material bind group at index 2 (may be `null` if program has no layout).\r\n   * @param ctx - Draw context.\r\n   * @param needUpdate - Whether uniforms need to be refreshed.\r\n   * @param pass - Pass index.\r\n   */\r\n  applyUniforms(bindGroup: BindGroup, ctx: DrawContext, needUpdate: boolean, pass: number): void {\r\n    if (needUpdate) {\r\n      this._applyUniforms(bindGroup, ctx, pass);\r\n    }\r\n  }\r\n  /**\r\n   * Notify the material that some option changed.\r\n   *\r\n   * - Always increments `_optionTag`. This will trigger uniforms update on next `apply()`.\r\n   * - If `changeHash` is true, clears per-pass hashes so programs/states will be rebuilt,\r\n   *   increments `_changeTag`, and notifies `RenderBundleWrapper` to regenerate recorded bundles.\r\n   *\r\n   * @param changeHash - Set true if the change affects shader compilation or render states.\r\n   * @internal\r\n   */\r\n  optionChanged(changeHash: boolean) {\r\n    this._optionTag++;\r\n    if (changeHash) {\r\n      for (let i = 0; i < this._numPasses; i++) {\r\n        this._hash[i] = null;\r\n      }\r\n      this._changeTag++;\r\n      RenderBundleWrapper.materialChanged(this.coreMaterial);\r\n    }\r\n  }\r\n  clearCache() {\r\n    for (const k in this._states) {\r\n      this._states[k]?.bindGroup?.dispose();\r\n      this._states[k]?.program?.dispose();\r\n    }\r\n    this._states = {};\r\n  }\r\n  /**\r\n   * Convert a pass index to a hash seed string.\r\n   *\r\n   * Subclasses may override to encode per-pass role (e.g., \"depth\", \"forward\", \"shadow\").\r\n   *\r\n   * @param pass - Pass number.\r\n   * @returns String used when building full hash.\r\n   */\r\n  passToHash(pass: number): string {\r\n    return String(pass);\r\n  }\r\n  /**\r\n   * Build the material hash for a pass (excluding context-dependent parts).\r\n   *\r\n   * Default formula: `${constructor.name}|${pass}|${_createHash()}`\r\n   *\r\n   * @param pass - Pass number.\r\n   * @returns Hash string used in program caching.\r\n   * @internal\r\n   */\r\n  createHash(pass: number): string {\r\n    return `${this.constructor.name}|${pass}|${this._createHash()}`;\r\n  }\r\n  /**\r\n   * Issue the actual draw call for a pass.\r\n   *\r\n   * Override for custom per-pass draw behavior if necessary. The default implementation:\r\n   * - Draws instanced if `numInstances > 0`.\r\n   * - Else uses `ctx.instanceData.numInstances` if available.\r\n   * - Else issues a non-instanced draw.\r\n   *\r\n   * @param pass - Pass number.\r\n   * @param primitive - Primitive to draw.\r\n   * @param ctx - Draw context.\r\n   * @param numInstances - Explicit instance count (0 = auto).\r\n   */\r\n  drawPrimitive(pass: number, primitive: Primitive, ctx: DrawContext, numInstances: number): void {\r\n    if (numInstances > 0) {\r\n      primitive.drawInstanced(numInstances);\r\n    } else if (ctx.instanceData) {\r\n      primitive.drawInstanced(ctx.instanceData.numInstances);\r\n    } else {\r\n      primitive.draw();\r\n    }\r\n  }\r\n  /**\r\n   * Dispose the material and release GPU-side resource references.\r\n   *\r\n   * - Unregisters from the global registry.\r\n   * - Disposes the per-material bind groups kept in `_states`.\r\n   */\r\n  protected onDispose() {\r\n    super.onDispose();\r\n    this.clearCache();\r\n  }\r\n  /**\r\n   * Build the GPU program for a pass.\r\n   *\r\n   * Default creates a `ProgramBuilder` and calls `_createProgram(pb, ctx, pass)`.\r\n   * Subclasses should override `_createProgram` instead of this method unless\r\n   * they need to replace builder instantiation.\r\n   *\r\n   * @param ctx - Draw context.\r\n   * @param pass - Pass number.\r\n   * @returns The compiled `GPUProgram`, or `null` on failure.\r\n   * @internal\r\n   */\r\n  protected createProgram(ctx: DrawContext, pass: number): GPUProgram {\r\n    const pb = new ProgramBuilder(ctx.device);\r\n    return this._createProgram(pb, ctx, pass);\r\n  }\r\n  /**\r\n   * Create and compile the shader program for this material/pass.\r\n   *\r\n   * Implement in subclasses:\r\n   * - Define shader stages, entry points, macros/defines, and resource layouts.\r\n   * - Return a compiled `GPUProgram`.\r\n   *\r\n   * @param pb - Program builder.\r\n   * @param ctx - Draw context.\r\n   * @param _pass - Pass number.\r\n   * @returns The created program, or `null` on failure.\r\n   */\r\n  protected _createProgram(_pb: ProgramBuilder, _ctx: DrawContext, _pass: number): GPUProgram {\r\n    return null;\r\n  }\r\n  /**\r\n   * Upload uniforms and bind resources to the per-material bind group (index 2).\r\n   *\r\n   * Implement in subclasses to:\r\n   * - Write uniform buffers/textures/samplers to the `bindGroup`.\r\n   * - Respect the current `pass` and `ctx`.\r\n   *\r\n   * @param _bindGroup - The bind group to populate.\r\n   * @param _ctx - Draw context.\r\n   * @param _pass - Pass number.\r\n   */\r\n  protected _applyUniforms(_bindGroup: BindGroup, _ctx: DrawContext, _pass: number) {}\r\n  /**\r\n   * Update render states (depth/stencil, blending, rasterization) for the pass.\r\n   *\r\n   * Implement in subclasses based on transparency, double-sidedness, depth writes/tests,\r\n   * color mask, stencil ops, etc., and any context flags in `ctx`.\r\n   *\r\n   * @param _pass - Current pass index.\r\n   * @param _renderStates - Render state set to mutate.\r\n   * @param _ctx - Draw context.\r\n   */\r\n  protected updateRenderStates(_pass: number, _renderStates: RenderStateSet, _ctx: DrawContext): void {}\r\n  /**\r\n   * Compute the material-specific portion of the shader hash for the current options.\r\n   *\r\n   * Subclasses should override to include macro/define sets that influence program compilation.\r\n   * Example return: `\"USE_NORMALMAP=1;ALPHA_MODE=BLEND;RECEIVE_SHADOWS=1\"`.\r\n   *\r\n   * @returns Hash fragment string (no context/pass info).\r\n   */\r\n  protected _createHash(): string {\r\n    return '';\r\n  }\r\n  /**\r\n   * Whether this is a lightweight instance of a core material.\r\n   *\r\n   * Instances typically share GPU programs with a core and only override instance uniforms.\r\n   * @internal\r\n   */\r\n  get $isInstance() {\r\n    return false;\r\n  }\r\n  /**\r\n   * Instance-uniform buffer for material instances, if supported.\r\n   *\r\n   * Returned as a typed Float32 view over a backing ArrayBuffer.\r\n   * @internal\r\n   */\r\n  get $instanceUniforms(): Float32Array<ArrayBuffer> {\r\n    return null;\r\n  }\r\n}\r\n"],"names":["Material","Disposable","_nextId","_nextProgramId","_id","_states","_numPasses","_hash","_optionTag","_changeTag","_currentHash","clone","other","copyFrom","clearCache","getEngine","resourceManager","setAssetId","getAssetId","coreMaterial","changeTag","instanceId","numPasses","val","length","push","getHash","pass","createHash","getQueueType","QUEUE_OPAQUE","isTransparentPass","_pass","supportLighting","supportInstancing","isBatchable","needSceneColor","needSceneDepth","createInstance","apply","ctx","hash","calcGlobalHash","state","program","createProgram","name","bindGroup","bindGroupLayouts","device","createBindGroup","bindGroupTag","getGPUId","renderStateSet","createRenderStateSet","materialTag","applyUniforms","updateRenderStates","id","RenderBundleWrapper","materialChanged","bind","console","error","setProgram","setBindGroup","setRenderStates","materialFlags","renderPassHash","draw","primitive","numInstances","drawPrimitive","needUpdate","_applyUniforms","optionChanged","changeHash","i","k","dispose","passToHash","String","_createHash","drawInstanced","instanceData","onDispose","pb","ProgramBuilder","_createProgram","_pb","_ctx","_bindGroup","_renderStates","$isInstance","$instanceUniforms"],"mappings":"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"}