@zephyr3d/scene 0.6.1 → 0.7.0

package/dist/material/meshmaterial.js.map

@@ -1 +1 @@
-{"version":3,"file":"meshmaterial.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"meshmaterial.js","sources":["../../src/material/meshmaterial.ts"],"sourcesContent":["import type {\r\n  BindGroup,\r\n  FaceMode,\r\n  GPUProgram,\r\n  PBFunctionScope,\r\n  PBInsideFunctionScope,\r\n  PBShaderExp,\r\n  RenderStateSet\r\n} from '@zephyr3d/device';\r\nimport { ProgramBuilder } from '@zephyr3d/device';\r\nimport {\r\n  MaterialVaryingFlags,\r\n  QUEUE_OPAQUE,\r\n  QUEUE_TRANSPARENT,\r\n  RENDER_PASS_TYPE_DEPTH,\r\n  RENDER_PASS_TYPE_LIGHT,\r\n  RENDER_PASS_TYPE_OBJECT_COLOR,\r\n  RENDER_PASS_TYPE_SHADOWMAP\r\n} from '../values';\r\nimport { Material } from './material';\r\nimport type { DepthPass } from '../render';\r\nimport { type DrawContext, type ShadowMapPass } from '../render';\r\nimport { encodeNormalizedFloatToRGBA } from '../shaders/misc';\r\nimport { ShaderHelper } from './shader/helper';\r\nimport type { Clonable } from '@zephyr3d/base';\r\nimport { Vector2, Vector3, Vector4, applyMixins, DRef } from '@zephyr3d/base';\r\nimport { RenderBundleWrapper } from '../render/renderbundle_wrapper';\r\nimport { getDevice } from '../app/api';\r\n\r\n/**\r\n * Blending mode for mesh materials.\r\n *\r\n * - `none`: No blending (opaque).\r\n * - `blend`: Standard alpha blending (srcAlpha, 1 - srcAlpha).\r\n * - `additive`: Additive blending (1, 1), commonly for glow/FX.\r\n *\r\n * May be combined with alpha-to-coverage and alpha test.\r\n * @public\r\n */\r\nexport type BlendMode = 'none' | 'blend' | 'additive';\r\n\r\n/**\r\n * Extracts the return type of a mixin function.\r\n * @public\r\n */\r\nexport type ExtractMixinReturnType<M> = M extends (target: infer A) => infer R ? R : never;\r\n\r\n/**\r\n * Produces the intersection type of multiple mixins’ return types.\r\n * @public\r\n */\r\nexport type ExtractMixinType<M> = M extends [infer First]\r\n  ? ExtractMixinReturnType<First>\r\n  : M extends [infer First, ...infer Rest]\r\n    ? ExtractMixinReturnType<First> & ExtractMixinType<[...Rest]>\r\n    : never;\r\n\r\n/**\r\n * Apply material mixins to a target material class.\r\n *\r\n * Useful for composing optional capabilities (e.g., base color, normal map, PBR terms).\r\n *\r\n * @param target - The material class (constructor or prototype).\r\n * @param mixins - One or more mixin functions.\r\n * @returns The target class augmented with the mixins (intersection type).\r\n *\r\n * @example\r\n * class MyMaterial extends MeshMaterial \\{\\}\r\n * const Mixed = applyMaterialMixins(MyMaterial, WithBaseColor, WithNormalMap);\r\n * const m = new Mixed();\r\n * @public\r\n */\r\nexport function applyMaterialMixins<M extends ((target: any) => any)[], T>(\r\n  target: T,\r\n  ...mixins: M\r\n): ExtractMixinType<M> & T {\r\n  return applyMixins(target, ...mixins);\r\n}\r\n\r\nlet FEATURE_ALPHATEST = 0;\r\nlet FEATURE_ALPHABLEND = 0;\r\nlet FEATURE_ALPHATOCOVERAGE = 0;\r\nlet FEATURE_DISABLE_TAA = 0;\r\n\r\n/** @internal */\r\nexport type InstanceUniformType = 'float' | 'vec2' | 'vec3' | 'vec4' | 'rgb' | 'rgba';\r\n\r\n/**\r\n * Base class for mesh materials.\r\n *\r\n * Key responsibilities:\r\n * - Defines feature-based shader variants (alpha test, blending, alpha-to-coverage, TAA toggle, etc.).\r\n * - Provides a material instancing mechanism (per-instance uniforms via a shared core material).\r\n * - Implements the base shader scaffolding for multiple render passes (LIGHT, DEPTH, OBJECT_COLOR, SHADOWMAP).\r\n * - Updates render states depending on pass and features (blending, depth, culling).\r\n * - Submits material uniforms and cooperates with OIT/TAA/SSR/motion vectors.\r\n *\r\n * Variant system:\r\n * - Features are stored in `_featureStates` and hashed into `_createHash()`.\r\n * - Changing features calls `useFeature(...)` which triggers `optionChanged(true)` to rebuild programs.\r\n *\r\n * Instancing:\r\n * - `defineInstanceUniform` registers per-instance fields with packed layout.\r\n * - `createInstance()` returns a lightweight instance that shares the core’s GPU programs and updates\r\n *   instance uniform buffer only. This improves batching/instancing support.\r\n *\r\n * Shader hooks:\r\n * - `vertexShader(scope)` and `fragmentShader(scope)` provide per-pass hook points to implement the\r\n *   material’s vertex/fragment logic. The base class wires up common I/O (skin, morph, instancing).\r\n * - `outputFragmentColor(...)` centralizes final color output across passes, handling OIT and alpha ops.\r\n *\r\n * Render states and queues:\r\n * - `updateRenderStates(...)` sets depth/blend/cull states based on blending, alpha-to-coverage,\r\n *   depth equality optimizations, pass type, and optional OIT overrides.\r\n * - `getQueueType()` chooses between opaque and transparent queues.\r\n *\r\n * Extending:\r\n * - Override `vertexShader`, `fragmentShader`, and optionally `outputFragmentColor`.\r\n * - Override `supportLighting`, `isTransparentPass`, `needFragmentColor`, etc., as needed.\r\n * - Use `uniformChanged()` when changing uniform-only values that do not alter shader variants.\r\n * - Use `useFeature()` when toggling options that affect shader variants.\r\n *\r\n * @public\r\n */\r\nexport class MeshMaterial extends Material implements Clonable<MeshMaterial> {\r\n  /**\r\n   * Registered instance uniforms for this material class.\r\n   *\r\n   * Each entry defines property name, type, and packed offset (float-aligned).\r\n   * @internal\r\n   */\r\n  static INSTANCE_UNIFORMS: { prop: string; type: InstanceUniformType; offset: number; name: string }[] = [];\r\n  /**\r\n   * Next free feature index for subclasses to define their own feature toggles.\r\n   * @internal\r\n   */\r\n  static NEXT_FEATURE_INDEX = 3;\r\n  /**\r\n   * Built-in per-instance uniform: object color (rgba), used for GPU picking/object-ID pass.\r\n   * @internal\r\n   */\r\n  static OBJECT_COLOR_UNIFORM = this.defineInstanceUniform('objectColor', 'rgba');\r\n  /**\r\n   * Built-in per-instance uniform: opacity (float), used in transparent passes.\r\n   * @internal\r\n   */\r\n  static OPACITY_UNIFORM = this.defineInstanceUniform('opacity', 'float', 'Opacity');\r\n  /** @internal Feature state array (indexed by feature indices). */\r\n  private _featureStates: unknown[];\r\n  /** @internal Alpha test cutoff in [0, 1]. */\r\n  private _alphaCutoff: number;\r\n  /** @internal Blending mode. */\r\n  private _blendMode: BlendMode;\r\n  /** @internal Face culling mode. */\r\n  private _cullMode: FaceMode;\r\n  /** @internal Opacity in [0, 1]. */\r\n  private _opacity: number;\r\n  /**\r\n   * @internal TAA strength in [0, 1], where higher value typically means stronger accumulation\r\n   * (here used inversely when mapping to motion vector output).\r\n   */\r\n  private _taaStrength: number;\r\n  /** @internal Per-object color for object picking pass. */\r\n  private readonly _objectColor: Vector4;\r\n  /** @internal Last draw context used for shader creation. */\r\n  private _ctx: DrawContext;\r\n  /** @internal Current material pass index during program building. */\r\n  private _materialPass: number;\r\n  /**\r\n   * Create a MeshMaterial with default opaque settings.\r\n   *\r\n   * Defaults:\r\n   * - `blendMode = 'none'`\r\n   * - `cullMode = 'back'`\r\n   * - `opacity = 1`\r\n   * - `alphaCutoff = 0`\r\n   * - `taaStrength = 1 - 1/16`\r\n   */\r\n  constructor() {\r\n    super();\r\n    this._featureStates = [];\r\n    this._alphaCutoff = 0;\r\n    this._blendMode = 'none';\r\n    this._cullMode = 'back';\r\n    this._opacity = 1;\r\n    this._taaStrength = 1 - 1 / 16;\r\n    this._objectColor = Vector4.one();\r\n    this._ctx = null;\r\n    this._materialPass = -1;\r\n    this.useFeature(FEATURE_ALPHABLEND, this._blendMode);\r\n  }\r\n  /**\r\n   * Create a shallow clone of this material.\r\n   * Subclasses should override to copy custom fields.\r\n   */\r\n  clone(): MeshMaterial {\r\n    const other = new MeshMaterial();\r\n    other.copyFrom(this);\r\n    return other;\r\n  }\r\n  /**\r\n   * Copy common MeshMaterial properties from another material.\r\n   * Call `super.copyFrom(other)` first when overriding in subclasses.\r\n   *\r\n   * @param other - Source material.\r\n   */\r\n  copyFrom(other: this): void {\r\n    super.copyFrom(other);\r\n    this.alphaCutoff = other.alphaCutoff;\r\n    this.blendMode = other.blendMode;\r\n    this.cullMode = other.cullMode;\r\n    this.opacity = other.opacity;\r\n    this.objectColor = other.objectColor;\r\n  }\r\n  /**\r\n   * Mark uniform-only changes so uniforms are re-uploaded on next apply, without\r\n   * rebuilding shader programs.\r\n   */\r\n  uniformChanged() {\r\n    this.optionChanged(false);\r\n  }\r\n  /**\r\n   * Define a new feature bit/index for shader variants.\r\n   * Subclasses may use this to add their own switches.\r\n   */\r\n  static defineFeature(): number {\r\n    const val = this.NEXT_FEATURE_INDEX;\r\n    this.NEXT_FEATURE_INDEX++;\r\n    return val;\r\n  }\r\n  /** @internal Helper: get number of scalar components for a given instance uniform type. */\r\n  private static getNumComponents(type: InstanceUniformType) {\r\n    if (type === 'float') {\r\n      return 1;\r\n    }\r\n    if (type === 'vec2') {\r\n      return 2;\r\n    }\r\n    if (type === 'rgb' || type === 'vec3') {\r\n      return 3;\r\n    }\r\n    if (type === 'rgba' || type === 'vec4') {\r\n      return 4;\r\n    }\r\n    return 0;\r\n  }\r\n  /**\r\n   * Define a per-instance uniform for this class.\r\n   *\r\n   * Returns a compact index encoding the vector index and component offset, which can be\r\n   * used in shader code via `getInstancedUniform(...)`.\r\n   *\r\n   * @param prop - Property name exposed on instances.\r\n   * @param type - Uniform data type.\r\n   * @returns Encoded index for use in `getInstancedUniform`.\r\n   *\r\n   * @throws If the property is already defined or type is invalid.\r\n   */\r\n  static defineInstanceUniform(prop: string, type: InstanceUniformType, name = ''): number {\r\n    if (this.INSTANCE_UNIFORMS.findIndex((val) => val.prop === prop) >= 0) {\r\n      throw new Error(`${this.name}.defineInstanceUniform(): ${prop} was already defined`);\r\n    }\r\n    const numComponents = this.getNumComponents(type);\r\n    if (numComponents === 0) {\r\n      throw new Error(`${this.name}.defineInstanceUniform(): invalid uniform type ${type}`);\r\n    }\r\n    let index = this.INSTANCE_UNIFORMS.length;\r\n    let offset = 0;\r\n    if (this.INSTANCE_UNIFORMS.length > 0) {\r\n      const lastUniform = this.INSTANCE_UNIFORMS[this.INSTANCE_UNIFORMS.length - 1];\r\n      const finalOffset = (lastUniform.offset + 4) & ~3;\r\n      offset = finalOffset;\r\n      for (let i = 0; i < this.INSTANCE_UNIFORMS.length; i++) {\r\n        const offset1 = this.INSTANCE_UNIFORMS[i].offset;\r\n        const numComps1 = this.getNumComponents(this.INSTANCE_UNIFORMS[i].type);\r\n        const offset2 =\r\n          i === this.INSTANCE_UNIFORMS.length - 1 ? finalOffset : this.INSTANCE_UNIFORMS[i + 1].offset;\r\n        if (offset1 + numComps1 + numComponents <= offset2) {\r\n          index = i + 1;\r\n          offset = offset1 + numComps1;\r\n          if (offset + numComponents === offset2) {\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    this.INSTANCE_UNIFORMS = this.INSTANCE_UNIFORMS.slice();\r\n    this.INSTANCE_UNIFORMS.splice(index, 0, { prop, offset, type, name });\r\n    return (offset << 2) | (numComponents - 1);\r\n  }\r\n  /**\r\n   * Read an encoded per-instance uniform in shader code.\r\n   *\r\n   * Encoded index packs: vector index, component offset, and component count.\r\n   *\r\n   * @param scope - Inside-function shader scope.\r\n   * @param uniformIndex - Encoded index from `defineInstanceUniform`.\r\n   * @returns The shader expression reading the selected components.\r\n   */\r\n  getInstancedUniform(scope: PBInsideFunctionScope, uniformIndex: number): PBShaderExp {\r\n    const pb = scope.$builder;\r\n    const instanceID = scope.$builtins.instanceIndex;\r\n    const uniformName = ShaderHelper.getInstanceDataUniformName();\r\n    const strideName = ShaderHelper.getInstanceDataStrideUniformName();\r\n    const offsetName = ShaderHelper.getInstanceDataOffsetUniformName();\r\n    const numComponents = (uniformIndex & 3) + 1;\r\n    const vecIndex = uniformIndex >> 4;\r\n    const vecOffset = (uniformIndex >> 2) & 3;\r\n    const u = scope[uniformName].at(\r\n      pb.add(\r\n        pb.mul(scope[strideName], instanceID),\r\n        ShaderHelper.MATERIAL_INSTANCE_DATA_OFFSET + vecIndex,\r\n        scope[offsetName]\r\n      )\r\n    );\r\n    const m = ['x', 'y', 'z', 'w'].slice(vecOffset, vecOffset + numComponents).join('');\r\n    return u[m];\r\n  }\r\n  /**\r\n   * Get the list of per-instance uniforms for this material class.\r\n   */\r\n  getInstancedUniforms() {\r\n    return (this.constructor as typeof MeshMaterial).INSTANCE_UNIFORMS;\r\n  }\r\n  /**\r\n   * Create a material instance (preferred for GPU instancing).\r\n   *\r\n   * - On WebGL1 (or when instancing unsupported), falls back to cloning.\r\n   * - Otherwise, returns a proxy instance that shares GPU programs and\r\n   *   stores per-instance uniforms in a compact Float32Array.\r\n   *\r\n   * The returned instance:\r\n   * - Exposes properties defined by `defineInstanceUniform` with getter/setter\r\n   *   that read/write the packed buffer and notify `RenderBundleWrapper`.\r\n   * - Delegates methods to the core material via prototype chain.\r\n   */\r\n  createInstance(): this {\r\n    if (this.$isInstance) {\r\n      return this.coreMaterial.createInstance();\r\n    }\r\n    const isWebGL1 = getDevice().type === 'webgl';\r\n    if (isWebGL1 || !this.supportInstancing()) {\r\n      return this.clone() as this;\r\n    }\r\n    const instanceUniforms = this.getInstancedUniforms();\r\n    const uniformsHolder =\r\n      instanceUniforms.length > 0\r\n        ? new Float32Array((instanceUniforms[instanceUniforms.length - 1].offset + 4) & ~3)\r\n        : null;\r\n    const instance = {} as any;\r\n    const that = this;\r\n    const coreMaterial = new DRef(that);\r\n    let disposed = false;\r\n    instance.isBatchable = () => true; //!isWebGL1 && that.supportInstancing();\r\n    instance.dispose = () => {\r\n      if (!disposed) {\r\n        disposed = true;\r\n        coreMaterial.dispose();\r\n      }\r\n    };\r\n    instance.$instanceUniforms = uniformsHolder;\r\n    instance.$isInstance = true;\r\n    Object.defineProperty(instance, 'coreMaterial', {\r\n      get: function () {\r\n        return coreMaterial.get();\r\n      }\r\n    });\r\n\r\n    // Copy original uniform values\r\n    for (let i = 0; i < instanceUniforms.length; i++) {\r\n      const { prop, offset, type } = instanceUniforms[i];\r\n      const value = that[prop];\r\n      switch (type) {\r\n        case 'float': {\r\n          uniformsHolder[offset] = Number(value);\r\n          Object.defineProperty(instance, prop, {\r\n            get() {\r\n              return uniformsHolder[offset];\r\n            },\r\n            set(value) {\r\n              uniformsHolder[offset] = value;\r\n              RenderBundleWrapper.materialUniformsChanged(instance);\r\n            }\r\n          });\r\n          break;\r\n        }\r\n        case 'vec2': {\r\n          if (!(value instanceof Vector2)) {\r\n            throw new Error(`Instance uniform property ${prop} must be of type Vector2`);\r\n          }\r\n          uniformsHolder[offset] = value.x;\r\n          uniformsHolder[offset + 1] = value.y;\r\n          Object.defineProperty(instance, prop, {\r\n            get() {\r\n              return new Vector2(uniformsHolder[offset], uniformsHolder[offset + 1]);\r\n            },\r\n            set(value) {\r\n              if (!(value instanceof Vector2)) {\r\n                throw new Error(`Instance uniform property ${prop} must be of type Vector2`);\r\n              }\r\n              uniformsHolder[offset] = value.x;\r\n              uniformsHolder[offset + 1] = value.y;\r\n              RenderBundleWrapper.materialUniformsChanged(instance);\r\n            }\r\n          });\r\n          break;\r\n        }\r\n        case 'vec3':\r\n        case 'rgb': {\r\n          if (!(value instanceof Vector3)) {\r\n            throw new Error(`Instance uniform property ${prop} must be of type Vector3`);\r\n          }\r\n          uniformsHolder[offset] = value.x;\r\n          uniformsHolder[offset + 1] = value.y;\r\n          uniformsHolder[offset + 2] = value.z;\r\n          Object.defineProperty(instance, prop, {\r\n            get() {\r\n              return new Vector3(\r\n                uniformsHolder[offset],\r\n                uniformsHolder[offset + 1],\r\n                uniformsHolder[offset + 2]\r\n              );\r\n            },\r\n            set(value) {\r\n              if (!(value instanceof Vector3)) {\r\n                throw new Error(`Instance uniform property ${prop} must be of type Vector3`);\r\n              }\r\n              uniformsHolder[offset] = value.x;\r\n              uniformsHolder[offset + 1] = value.y;\r\n              uniformsHolder[offset + 2] = value.z;\r\n              RenderBundleWrapper.materialUniformsChanged(instance);\r\n            }\r\n          });\r\n          break;\r\n        }\r\n        case 'vec4':\r\n        case 'rgba': {\r\n          if (!(value instanceof Vector4)) {\r\n            throw new Error(`Instance uniform property ${prop} must be of type Vector4`);\r\n          }\r\n          uniformsHolder[offset] = value.x;\r\n          uniformsHolder[offset + 1] = value.y;\r\n          uniformsHolder[offset + 2] = value.z;\r\n          uniformsHolder[offset + 3] = value.w;\r\n          Object.defineProperty(instance, prop, {\r\n            get() {\r\n              return new Vector4(\r\n                uniformsHolder[offset],\r\n                uniformsHolder[offset + 1],\r\n                uniformsHolder[offset + 2],\r\n                uniformsHolder[offset + 3]\r\n              );\r\n            },\r\n            set(value) {\r\n              if (!(value instanceof Vector4)) {\r\n                throw new Error(`Instance uniform property ${prop} must be of type Vector4`);\r\n              }\r\n              uniformsHolder[offset] = value.x;\r\n              uniformsHolder[offset + 1] = value.y;\r\n              uniformsHolder[offset + 2] = value.z;\r\n              uniformsHolder[offset + 3] = value.w;\r\n              RenderBundleWrapper.materialUniformsChanged(instance);\r\n            }\r\n          });\r\n          break;\r\n        }\r\n      }\r\n    }\r\n    Object.setPrototypeOf(instance, that);\r\n    return instance;\r\n  }\r\n  /**\r\n   * Draw context captured during program creation, available inside shader hooks.\r\n   *\r\n   * @returns The last `DrawContext` used to build or apply this material.\r\n   */\r\n  get drawContext(): DrawContext {\r\n    return this._ctx;\r\n  }\r\n  /**\r\n   * Current material pass index during program building.\r\n   * Typically used inside shader hooks to select per-pass logic.\r\n   *\r\n   * @returns The active pass index while building the program, or -1 when idle.\r\n   * @internal\r\n   */\r\n  get pass(): number {\r\n    return this._materialPass;\r\n  }\r\n  /**\r\n   * Alpha test cutoff in [0, 1].\r\n   * - 0 disables alpha testing.\r\n   * - \\> 0 discards fragments with alpha \\< cutoff.\r\n   * Changing this marks uniforms dirty (no shader rebuild).\r\n   */\r\n  get alphaCutoff(): number {\r\n    return this._alphaCutoff;\r\n  }\r\n  set alphaCutoff(val: number) {\r\n    if (this._alphaCutoff !== val) {\r\n      this.useFeature(FEATURE_ALPHATEST, val > 0);\r\n      this._alphaCutoff = val;\r\n      this.uniformChanged();\r\n    }\r\n  }\r\n  /**\r\n   * Whether TAA is disabled for this material.\r\n   * - When true, motion vectors encode a large sentinel to skip TAA accumulation.\r\n   * - Managed via an internal feature toggle.\r\n   */\r\n  get TAADisabled(): boolean {\r\n    return !!this.featureUsed(FEATURE_DISABLE_TAA);\r\n  }\r\n  set TAADisabled(val: boolean) {\r\n    this.useFeature(FEATURE_DISABLE_TAA, !!val);\r\n  }\r\n  /**\r\n   * TAA strength in [0, 1].\r\n   * - Higher values generally imply stronger accumulation.\r\n   * - The value is mapped when writing motion-vector outputs during depth pass.\r\n   */\r\n  get TAAStrength(): number {\r\n    return this._taaStrength;\r\n  }\r\n  set TAAStrength(val: number) {\r\n    val = val > 1 ? 1 : val < 0 ? 0 : val;\r\n    if (this._taaStrength !== val) {\r\n      this._taaStrength = val;\r\n      this.uniformChanged();\r\n    }\r\n  }\r\n  /**\r\n   * Alpha-to-coverage toggle.\r\n   * - Useful to approximate transparency for MSAA targets.\r\n   * - Managed as a shader feature; toggling rebuilds variants.\r\n   */\r\n  get alphaToCoverage(): boolean {\r\n    return this.featureUsed(FEATURE_ALPHATOCOVERAGE);\r\n  }\r\n  set alphaToCoverage(val: boolean) {\r\n    this.useFeature(FEATURE_ALPHATOCOVERAGE, !!val);\r\n  }\r\n  /**\r\n   * Blending mode of this material.\r\n   * - 'none' for opaque, 'blend' for standard alpha, 'additive' for emissive FX.\r\n   * - Changing the mode toggles an internal feature and rebuilds variants.\r\n   */\r\n  get blendMode(): BlendMode {\r\n    return this._blendMode;\r\n  }\r\n  set blendMode(val: BlendMode) {\r\n    if (this._blendMode !== val) {\r\n      this._blendMode = val;\r\n      this.useFeature(FEATURE_ALPHABLEND, this._blendMode);\r\n    }\r\n  }\r\n  /**\r\n   * Face culling mode: 'none' | 'front' | 'back'.\r\n   * - Does not force shader rebuild; affects rasterizer state.\r\n   */\r\n  get cullMode(): FaceMode {\r\n    return this._cullMode;\r\n  }\r\n  set cullMode(val: FaceMode) {\r\n    this._cullMode = val;\r\n  }\r\n  /**\r\n   * Material opacity in [0, 1].\r\n   * - Used in transparent passes. Changing marks uniforms dirty only.\r\n   */\r\n  get opacity(): number {\r\n    return this._opacity;\r\n  }\r\n  set opacity(val: number) {\r\n    val = val < 0 ? 0 : val > 1 ? 1 : val;\r\n    if (this._opacity !== val) {\r\n      this._opacity = val;\r\n      this.uniformChanged();\r\n    }\r\n  }\r\n  /**\r\n   * Per-object color used for GPU picking/object-ID pass.\r\n   * - Changing marks uniforms dirty only.\r\n   */\r\n  get objectColor(): Vector4 {\r\n    return this._objectColor;\r\n  }\r\n  set objectColor(val: Vector4) {\r\n    if (val !== this._objectColor) {\r\n      this._objectColor.set(val ?? Vector4.one());\r\n      this.uniformChanged();\r\n    }\r\n  }\r\n  /**\r\n   * Whether this material responds to scene lighting.\r\n   * Override to return false for unlit materials.\r\n   *\r\n   * @returns True if lighting affects this material; otherwise false.\r\n   */\r\n  supportLighting(): boolean {\r\n    return true;\r\n  }\r\n  /**\r\n   * Update render states per pass and draw context.\r\n   * Sets blending, alpha-to-coverage, depth test/write, cull mode, color mask, and cooperates with OIT.\r\n   *\r\n   * @param pass - Current material pass index.\r\n   * @param stateSet - Render state set to update.\r\n   * @param ctx - Current draw context.\r\n   * @returns void\r\n   */\r\n  protected updateRenderStates(pass: number, stateSet: RenderStateSet, ctx: DrawContext): void {\r\n    const isObjectColorPass = ctx.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR;\r\n    const blending =\r\n      !isObjectColorPass && (this.featureUsed<BlendMode>(FEATURE_ALPHABLEND) !== 'none' || ctx.lightBlending);\r\n    const a2c = !isObjectColorPass && this.featureUsed<boolean>(FEATURE_ALPHATOCOVERAGE);\r\n    const ztestEq = ctx.queue === QUEUE_OPAQUE && !!ctx.depthTexture && !ctx.sceneColorTexture;\r\n    if (blending || a2c) {\r\n      const blendingState = stateSet.useBlendingState();\r\n      if (blending) {\r\n        blendingState.enable(true);\r\n        blendingState.setBlendFuncAlpha('zero', 'one');\r\n        blendingState.setBlendEquation('add', 'add');\r\n        if (this._blendMode === 'additive' || ctx.lightBlending) {\r\n          blendingState.setBlendFuncRGB('one', 'one');\r\n        } else {\r\n          blendingState.setBlendFuncRGB('one', 'inv-src-alpha');\r\n        }\r\n      } else {\r\n        blendingState.enable(false);\r\n      }\r\n      blendingState.enableAlphaToCoverage(a2c);\r\n      if (ztestEq) {\r\n        stateSet.useDepthState().setCompareFunc('eq').enableTest(true).enableWrite(false);\r\n      } else if (blendingState.enabled) {\r\n        stateSet.useDepthState().enableTest(true).enableWrite(false);\r\n      } else {\r\n        stateSet.defaultDepthState();\r\n      }\r\n    } else {\r\n      stateSet.defaultBlendingState();\r\n      if (ztestEq) {\r\n        stateSet.useDepthState().setCompareFunc('eq').enableTest(true).enableWrite(false);\r\n      } else {\r\n        stateSet.defaultDepthState();\r\n      }\r\n    }\r\n    if (ctx.forceCullMode || this._cullMode !== 'back') {\r\n      stateSet.useRasterizerState().cullMode = ctx.forceCullMode || this._cullMode;\r\n    } else if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {\r\n      stateSet.useRasterizerState().cullMode = 'none';\r\n    } else {\r\n      stateSet.defaultRasterizerState();\r\n    }\r\n    if (ctx.forceColorState) {\r\n      stateSet.useColorState(ctx.forceColorState);\r\n    } else {\r\n      stateSet.defaultColorState();\r\n    }\r\n    stateSet.defaultStencilState();\r\n    if (ctx.oit) {\r\n      ctx.oit.setRenderStates(stateSet);\r\n    }\r\n  }\r\n  /**\r\n   * Submit material uniforms/resources to the material bind group (set 2).\r\n   * Handles alpha cutoff, opacity (non-instanced transparent), OIT, object color, and TAA strength.\r\n   *\r\n   * @param bindGroup - The material bind group to write into.\r\n   * @param ctx - Current draw context.\r\n   * @param pass - Current material pass index.\r\n   * @returns void\r\n   */\r\n  applyUniformValues(bindGroup: BindGroup, ctx: DrawContext, pass: number): void {\r\n    if (this.featureUsed(FEATURE_ALPHATEST)) {\r\n      bindGroup.setValue('zAlphaCutoff', this._alphaCutoff);\r\n    }\r\n    if (\r\n      this.isTransparentPass(pass) &&\r\n      ctx.renderPass.type === RENDER_PASS_TYPE_LIGHT &&\r\n      !(ctx.materialFlags & MaterialVaryingFlags.INSTANCING)\r\n    ) {\r\n      bindGroup.setValue('zOpacity', this._opacity);\r\n    }\r\n    if (ctx.oit) {\r\n      ctx.oit.applyUniforms(ctx, bindGroup);\r\n    }\r\n    if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH && ctx.motionVectors) {\r\n      bindGroup.setValue('zTAAStrength', (1 - this._taaStrength) * 50000);\r\n    }\r\n  }\r\n  /**\r\n   * Determine the render queue for this material.\r\n   * Transparent materials are queued as `QUEUE_TRANSPARENT`, otherwise `QUEUE_OPAQUE`.\r\n   *\r\n   * @returns The queue type constant.\r\n   */\r\n  getQueueType(): number {\r\n    return this.isTransparentPass(0) ? QUEUE_TRANSPARENT : QUEUE_OPAQUE;\r\n  }\r\n  /**\r\n   * Whether the given pass is transparent.\r\n   * Default returns true when `blendMode !== 'none'`.\r\n   *\r\n   * @param pass - Material pass index.\r\n   * @returns True if the pass is transparent; otherwise false.\r\n   */\r\n  isTransparentPass(_pass: number): boolean {\r\n    return this.featureUsed<BlendMode>(FEATURE_ALPHABLEND) !== 'none';\r\n  }\r\n  /**\r\n   * Create the GPU program for a given pass and draw context.\r\n   * Enables depth-clamp emulation for shadow map passes when required by the light, then delegates to `_createProgram`.\r\n   *\r\n   * @param ctx - Current draw context.\r\n   * @param pass - Material pass index.\r\n   * @returns The created `GPUProgram`.\r\n   * @internal\r\n   */\r\n  protected createProgram(ctx: DrawContext, pass: number): GPUProgram {\r\n    const pb = new ProgramBuilder(ctx.device);\r\n    if (ctx.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP) {\r\n      const shadowMapParams = ctx.shadowMapInfo.get((ctx.renderPass as ShadowMapPass).light);\r\n      pb.emulateDepthClamp = !!shadowMapParams.depthClampEnabled;\r\n    }\r\n    return this._createProgram(pb, ctx, pass);\r\n  }\r\n  /**\r\n   * Query a feature flag’s current value.\r\n   *\r\n   * @typeParam T - Expected value type.\r\n   * @param feature - The feature index.\r\n   * @returns The current value for the feature, typed as `T`.\r\n   */\r\n  featureUsed<T = unknown>(feature: number): T {\r\n    return this._featureStates[feature] as T;\r\n  }\r\n  /**\r\n   * Enable or disable a feature and trigger variant rebuild when changed.\r\n   * Calls `optionChanged(true)` internally on change.\r\n   *\r\n   * @param feature - The feature index to set.\r\n   * @param use - The new feature value (typed by convention).\r\n   * @returns void\r\n   */\r\n  useFeature(feature: number, use: unknown) {\r\n    if (this._featureStates[feature] !== use) {\r\n      this._featureStates[feature] = use;\r\n      this.optionChanged(true);\r\n    }\r\n  }\r\n  /**\r\n   * Create the material-specific hash fragment from feature state.\r\n   * Contributes to program variant hashing.\r\n   *\r\n   * @returns The hash fragment string.\r\n   * @internal\r\n   */\r\n  protected _createHash(): string {\r\n    return this._featureStates.map((val) => (val === undefined ? '' : val)).join('|');\r\n  }\r\n  /**\r\n   * Apply material uniforms to the bind group (set 2).\r\n   * Default implementation delegates to `applyUniformValues`.\r\n   *\r\n   * @param bindGroup - The material bind group to update.\r\n   * @param ctx - Current draw context.\r\n   * @param pass - Current material pass index.\r\n   * @returns void\r\n   * @internal\r\n   */\r\n  protected _applyUniforms(bindGroup: BindGroup, ctx: DrawContext, pass: number): void {\r\n    this.applyUniformValues(bindGroup, ctx, pass);\r\n  }\r\n  /**\r\n   * Whether the fragment shader needs to compute color.\r\n   * Returns true for LIGHT pass, or when alpha test or alpha-to-coverage is enabled.\r\n   * Override if the material writes color in other passes.\r\n   *\r\n   * @param ctx - Optional draw context; defaults to the last captured `drawContext`.\r\n   * @returns True if fragment color computation is needed; otherwise false.\r\n   */\r\n  needFragmentColor(ctx?: DrawContext): boolean {\r\n    return (\r\n      (ctx ?? this.drawContext).renderPass.type === RENDER_PASS_TYPE_LIGHT ||\r\n      this._alphaCutoff > 0 ||\r\n      this.alphaToCoverage\r\n    );\r\n  }\r\n  /**\r\n   * Vertex shader hook.\r\n   * Prepares common inputs (skin/morph/instancing), varyings, and pass-dependent outputs.\r\n   * Override to implement per-vertex logic; use `ShaderHelper` as needed.\r\n   *\r\n   * @param scope - Vertex shader function scope.\r\n   * @returns void\r\n   */\r\n  vertexShader(scope: PBFunctionScope): void {\r\n    const pb = scope.$builder;\r\n    ShaderHelper.prepareVertexShader(pb, this.drawContext);\r\n    if (this.drawContext.materialFlags & MaterialVaryingFlags.SKIN_ANIMATION) {\r\n      scope.$inputs.zBlendIndices = pb.vec4().attrib('blendIndices');\r\n      scope.$inputs.zBlendWeights = pb.vec4().attrib('blendWeights');\r\n      ShaderHelper.prepareSkinAnimation(scope);\r\n    }\r\n    if (\r\n      this.drawContext.materialFlags & MaterialVaryingFlags.MORPH_ANIMATION &&\r\n      this.drawContext.device.type === 'webgl'\r\n    ) {\r\n      scope.$inputs.zFakeVertexID = pb.float().attrib('texCoord7');\r\n    }\r\n    if (this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING) {\r\n      if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {\r\n        scope.$outputs.zObjectColor = this.getInstancedUniform(scope, MeshMaterial.OBJECT_COLOR_UNIFORM);\r\n      }\r\n      if (this.isTransparentPass(this.pass)) {\r\n        scope.$outputs.zOpacity = this.getInstancedUniform(scope, MeshMaterial.OPACITY_UNIFORM);\r\n      }\r\n    } else {\r\n      if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {\r\n        scope.$outputs.zObjectColor = scope[ShaderHelper.getObjectColorUniformName()];\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * Fragment shader hook.\r\n   * Declares pass-dependent uniforms (e.g., opacity, objectColor, alphaCutoff).\r\n   * Override to implement per-fragment logic, and call `outputFragmentColor` to finalize writes.\r\n   *\r\n   * @param scope - Fragment shader function scope.\r\n   * @returns void\r\n   */\r\n  fragmentShader(scope: PBFunctionScope): void {\r\n    const pb = scope.$builder;\r\n    ShaderHelper.prepareFragmentShader(pb, this.drawContext);\r\n    if (this._alphaCutoff > 0) {\r\n      scope.zAlphaCutoff = pb.float().uniform(2);\r\n    }\r\n    if (this.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {\r\n      if (\r\n        this.isTransparentPass(this.pass) &&\r\n        !(this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING)\r\n      ) {\r\n        scope.zOpacity = pb.float().uniform(2);\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * Build and return the GPU program for this pass.\r\n   * Wires `vertexShader` and `fragmentShader`; sets up pass-dependent outputs (OIT, SSR, motion vectors, distance/object color).\r\n   *\r\n   * @param pb - Program builder.\r\n   * @param ctx - Current draw context.\r\n   * @param pass - Material pass index.\r\n   * @returns The created `GPUProgram`.\r\n   * @internal\r\n   */\r\n  protected _createProgram(pb: ProgramBuilder, ctx: DrawContext, pass: number): GPUProgram {\r\n    const that = this;\r\n    this._ctx = ctx;\r\n    this._materialPass = pass;\r\n    const program = pb.buildRenderProgram({\r\n      vertex(pb) {\r\n        pb.main(function () {\r\n          that.vertexShader(this);\r\n        });\r\n      },\r\n      fragment(pb) {\r\n        if (that.drawContext.oit) {\r\n          that.drawContext.oit.setupFragmentOutput(this);\r\n        } else {\r\n          this.$outputs.zFragmentOutput = pb.vec4();\r\n          if (ctx.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {\r\n            this.$outputs.zSSRRoughness = pb.vec4();\r\n            this.$outputs.zSSRNormal = pb.vec4();\r\n          }\r\n          if (ctx.renderPass.type === RENDER_PASS_TYPE_DEPTH && ctx.motionVectors) {\r\n            this.$outputs.zMotionVector = pb.vec4();\r\n            this.zTAAStrength = pb.float().uniform(2);\r\n          }\r\n          if (ctx.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {\r\n            this.$outputs.zDistance = pb.vec4();\r\n          }\r\n        }\r\n        pb.main(function () {\r\n          that.fragmentShader(this);\r\n        });\r\n      }\r\n    });\r\n    return program;\r\n  }\r\n  /**\r\n   * Centralized final color write and per-pass output composition.\r\n   *\r\n   * Behavior by pass:\r\n   * - LIGHT: clipping, alpha handling, optional OIT integration, fog application, color output encoding.\r\n   * - DEPTH: encoded depth; optional motion vectors (TAA enabled/disabled handling).\r\n   * - OBJECT_COLOR: object color and distance output (linear depth or world-pos + distance).\r\n   * - SHADOWMAP: writes shadow depth via light’s shadow implementation.\r\n   *\r\n   * Also writes SSR roughness/normal buffers when requested via material flags.\r\n   *\r\n   * @param scope - Inside-function shader scope.\r\n   * @param worldPos - Fragment world-space position expression.\r\n   * @param color - Lit fragment color expression; may be undefined for depth-only paths.\r\n   * @param ssrRoughness - Optional SSR roughness output expression.\r\n   * @param ssrNormal - Optional SSR normal output expression.\r\n   * @returns void\r\n   */\r\n  outputFragmentColor(\r\n    scope: PBInsideFunctionScope,\r\n    worldPos: PBShaderExp,\r\n    color: PBShaderExp,\r\n    ssrRoughness?: PBShaderExp,\r\n    ssrNormal?: PBShaderExp\r\n  ) {\r\n    const pb = scope.$builder;\r\n    const that = this;\r\n    const funcName = 'Z_outputFragmentColor';\r\n    pb.func(funcName, color ? [pb.vec3('worldPos'), pb.vec4('color')] : [pb.vec3('worldPos')], function () {\r\n      this.$l.outColor = color ? this.color : pb.vec4();\r\n      if (that.drawContext.renderPass.type === RENDER_PASS_TYPE_LIGHT) {\r\n        ShaderHelper.discardIfClipped(this, this.worldPos);\r\n        let output = true;\r\n        if (!that.isTransparentPass(that.pass) && !that.alphaToCoverage) {\r\n          this.outColor.a = 1;\r\n        } else if (that.isTransparentPass(that.pass)) {\r\n          const opacity =\r\n            that.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING\r\n              ? this.$inputs.zOpacity\r\n              : this.zOpacity;\r\n          this.outColor.a = pb.mul(this.outColor.a, opacity);\r\n        }\r\n        if (that.isTransparentPass(that.pass)) {\r\n          if (this.zAlphaCutoff) {\r\n            this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function () {\r\n              pb.discard();\r\n            });\r\n          }\r\n          if (!that.drawContext.oit || that.drawContext.oit.wantsPremultipliedAlpha()) {\r\n            this.outColor = pb.vec4(\r\n              pb.mul(this.outColor.rgb, this.outColor.a),\r\n              that.featureUsed<BlendMode>(FEATURE_ALPHABLEND) === 'additive' ? 0 : this.outColor.a\r\n            );\r\n          }\r\n          output = !that.drawContext.oit || !that.drawContext.oit.outputFragmentColor(this, this.outColor);\r\n        }\r\n        if (output) {\r\n          ShaderHelper.applyFog(this, this.worldPos, this.outColor, that.drawContext);\r\n          this.$outputs.zFragmentOutput = ShaderHelper.encodeColorOutput(this, this.outColor);\r\n        }\r\n      } else if (that.drawContext.renderPass.type === RENDER_PASS_TYPE_DEPTH) {\r\n        if (color) {\r\n          if (this.zAlphaCutoff) {\r\n            this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function () {\r\n              pb.discard();\r\n            });\r\n          }\r\n        }\r\n        ShaderHelper.discardIfClipped(this, this.worldPos);\r\n        const depthPass = that.drawContext.renderPass as DepthPass;\r\n        this.$l.depth = ShaderHelper.nonLinearDepthToLinearNormalized(this, this.$builtins.fragCoord.z);\r\n        if (depthPass.encodeDepth) {\r\n          this.$outputs.zFragmentOutput = encodeNormalizedFloatToRGBA(this, this.depth);\r\n        } else if (depthPass.renderBackface) {\r\n          this.$outputs.zFragmentOutput = pb.vec4(0, this.depth, 0, 1);\r\n        } else {\r\n          this.$outputs.zFragmentOutput = pb.vec4(this.depth, 0, 0, 1);\r\n        }\r\n        if (that.drawContext.motionVectors) {\r\n          if (that.featureUsed(FEATURE_DISABLE_TAA)) {\r\n            this.$outputs.zMotionVector = pb.vec4(6e4, 6e4, 1, 1);\r\n          } else {\r\n            if (this.$inputs.zMotionVectorPosCurrent && this.$inputs.zMotionVectorPosPrev) {\r\n              this.$outputs.zMotionVector = pb.vec4(\r\n                pb.mul(\r\n                  pb.sub(\r\n                    pb.div(this.$inputs.zMotionVectorPosCurrent.xy, this.$inputs.zMotionVectorPosCurrent.w),\r\n                    pb.div(this.$inputs.zMotionVectorPosPrev.xy, this.$inputs.zMotionVectorPosPrev.w)\r\n                  ),\r\n                  0.5\r\n                ),\r\n                this.zTAAStrength,\r\n                1\r\n              );\r\n            } else {\r\n              this.$outputs.zMotionVector = pb.vec4(0, 0, 1, 1);\r\n            }\r\n          }\r\n        }\r\n      } else if (that.drawContext.renderPass.type === RENDER_PASS_TYPE_OBJECT_COLOR) {\r\n        if (color) {\r\n          this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function () {\r\n            pb.discard();\r\n          });\r\n        }\r\n        ShaderHelper.discardIfClipped(this, this.worldPos);\r\n        this.$outputs.zFragmentOutput = scope.$inputs.zObjectColor;\r\n        if (that.drawContext.device.type === 'webgl') {\r\n          this.$l.linearDepth = ShaderHelper.nonLinearDepthToLinearNormalized(\r\n            this,\r\n            this.$builtins.fragCoord.z\r\n          );\r\n          this.$outputs.zDistance = encodeNormalizedFloatToRGBA(this, this.linearDepth);\r\n        } else {\r\n          this.$outputs.zDistance = pb.vec4(\r\n            this.worldPos,\r\n            pb.distance(ShaderHelper.getCameraPosition(this), this.worldPos)\r\n          );\r\n        }\r\n      } /*if (that.drawContext.renderPass.type === RENDER_PASS_TYPE_SHADOWMAP)*/ else {\r\n        if (color) {\r\n          this.$if(pb.lessThan(this.outColor.a, this.zAlphaCutoff), function () {\r\n            pb.discard();\r\n          });\r\n        }\r\n        ShaderHelper.discardIfClipped(this, this.worldPos);\r\n        const shadowMapParams = that.drawContext.shadowMapInfo.get(\r\n          (that.drawContext.renderPass as ShadowMapPass).light\r\n        );\r\n        this.$outputs.zFragmentOutput = shadowMapParams.impl.computeShadowMapDepth(\r\n          shadowMapParams,\r\n          this,\r\n          this.worldPos\r\n        );\r\n      }\r\n    });\r\n    if (color) {\r\n      pb.getGlobalScope()[funcName](worldPos, color);\r\n    } else {\r\n      pb.getGlobalScope()[funcName](worldPos);\r\n    }\r\n    if (that.drawContext.materialFlags & MaterialVaryingFlags.SSR_STORE_ROUGHNESS) {\r\n      scope.$outputs.zSSRRoughness = ssrRoughness ?? pb.vec4(1, 0, 0, 1);\r\n      scope.$outputs.zSSRNormal = ssrNormal ?? pb.vec4(0);\r\n    }\r\n  }\r\n}\r\nFEATURE_ALPHATEST = MeshMaterial.defineFeature();\r\nFEATURE_ALPHABLEND = MeshMaterial.defineFeature();\r\nFEATURE_ALPHATOCOVERAGE = MeshMaterial.defineFeature();\r\nFEATURE_DISABLE_TAA = MeshMaterial.defineFeature();\r\n"],"names":["applyMaterialMixins","target","mixins","applyMixins","FEATURE_ALPHATEST","FEATURE_ALPHABLEND","FEATURE_ALPHATOCOVERAGE","FEATURE_DISABLE_TAA","MeshMaterial","Material","INSTANCE_UNIFORMS","NEXT_FEATURE_INDEX","OBJECT_COLOR_UNIFORM","defineInstanceUniform","OPACITY_UNIFORM","_featureStates","_alphaCutoff","_blendMode","_cullMode","_opacity","_taaStrength","_objectColor","Vector4","one","_ctx","_materialPass","useFeature","clone","other","copyFrom","alphaCutoff","blendMode","cullMode","opacity","objectColor","uniformChanged","optionChanged","defineFeature","val","getNumComponents","type","prop","name","findIndex","Error","numComponents","index","length","offset","lastUniform","finalOffset","i","offset1","numComps1","offset2","slice","splice","getInstancedUniform","scope","uniformIndex","pb","$builder","instanceID","$builtins","instanceIndex","uniformName","ShaderHelper","getInstanceDataUniformName","strideName","getInstanceDataStrideUniformName","offsetName","getInstanceDataOffsetUniformName","vecIndex","vecOffset","u","at","add","mul","MATERIAL_INSTANCE_DATA_OFFSET","m","join","getInstancedUniforms","createInstance","$isInstance","coreMaterial","isWebGL1","getDevice","supportInstancing","instanceUniforms","uniformsHolder","Float32Array","instance","that","DRef","disposed","isBatchable","dispose","$instanceUniforms","Object","defineProperty","get","value","Number","set","RenderBundleWrapper","materialUniformsChanged","Vector2","x","y","Vector3","z","w","setPrototypeOf","drawContext","pass","TAADisabled","featureUsed","TAAStrength","alphaToCoverage","supportLighting","stateSet","ctx","isObjectColorPass","renderPass","RENDER_PASS_TYPE_OBJECT_COLOR","blending","lightBlending","a2c","ztestEq","queue","QUEUE_OPAQUE","depthTexture","sceneColorTexture","blendingState","useBlendingState","enable","setBlendFuncAlpha","setBlendEquation","setBlendFuncRGB","enableAlphaToCoverage","useDepthState","setCompareFunc","enableTest","enableWrite","enabled","defaultDepthState","defaultBlendingState","forceCullMode","useRasterizerState","RENDER_PASS_TYPE_SHADOWMAP","defaultRasterizerState","forceColorState","useColorState","defaultColorState","defaultStencilState","oit","setRenderStates","applyUniformValues","bindGroup","setValue","isTransparentPass","RENDER_PASS_TYPE_LIGHT","materialFlags","MaterialVaryingFlags","INSTANCING","applyUniforms","RENDER_PASS_TYPE_DEPTH","motionVectors","getQueueType","QUEUE_TRANSPARENT","_pass","createProgram","ProgramBuilder","device","shadowMapParams","shadowMapInfo","light","emulateDepthClamp","depthClampEnabled","_createProgram","feature","use","map","undefined","needFragmentColor","vertexShader","prepareVertexShader","SKIN_ANIMATION","$inputs","zBlendIndices","vec4","attrib","zBlendWeights","prepareSkinAnimation","MORPH_ANIMATION","zFakeVertexID","float","$outputs","zObjectColor","zOpacity","getObjectColorUniformName","fragmentShader","prepareFragmentShader","zAlphaCutoff","uniform","program","buildRenderProgram","vertex","main","fragment","setupFragmentOutput","zFragmentOutput","SSR_STORE_ROUGHNESS","zSSRRoughness","zSSRNormal","zMotionVector","zTAAStrength","zDistance","outputFragmentColor","worldPos","color","ssrRoughness","ssrNormal","funcName","func","vec3","$l","outColor","discardIfClipped","output","a","$if","lessThan","discard","wantsPremultipliedAlpha","rgb","applyFog","encodeColorOutput","depthPass","depth","nonLinearDepthToLinearNormalized","fragCoord","encodeDepth","encodeNormalizedFloatToRGBA","renderBackface","zMotionVectorPosCurrent","zMotionVectorPosPrev","sub","div","xy","linearDepth","distance","getCameraPosition","impl","computeShadowMapDepth","getGlobalScope"],"mappings":"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"}

package/dist/material/mixins/albedocolor.js

@@ -14,7 +14,7 @@ import { MaterialVaryingFlags } from '../../values.js';
         return BaseCls;
     }
     const S = applyMaterialMixins(BaseCls, mixinTextureProps('albedo'));
-    const ALBEDO_COLOR_UNIFORM = S.defineInstanceUniform('albedoColor', 'vec4');
+    const ALBEDO_COLOR_UNIFORM = S.defineInstanceUniform('albedoColor', 'rgba', 'AlbedoColor');
     return class extends S {
         static albedoColorMixed = true;
         _albedoColor;
@@ -22,6 +22,10 @@ import { MaterialVaryingFlags } from '../../values.js';
             super();
             this._albedoColor = Vector4.one();
         }
+        copyFrom(other) {
+            super.copyFrom(other);
+            this.albedoColor = other.albedoColor;
+        }
         /** Albedo color */ get albedoColor() {
             return this._albedoColor;
         }

package/dist/material/mixins/albedocolor.js.map

@@ -1 +1 @@
-{"version":3,"file":"albedocolor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"albedocolor.js","sources":["../../../src/material/mixins/albedocolor.ts"],"sourcesContent":["import { Vector4 } from '@zephyr3d/base';\r\nimport type { MeshMaterial } from '../meshmaterial';\r\nimport { applyMaterialMixins } from '../meshmaterial';\r\nimport type { BindGroup, PBFunctionScope, PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\r\nimport type { DrawContext } from '../../render';\r\nimport type { TextureMixinInstanceTypes } from './texture';\r\nimport { mixinTextureProps } from './texture';\r\nimport { MaterialVaryingFlags } from '../../values';\r\n\r\n/**\r\n * Interface for albedo color mixin\r\n * @public\r\n */\r\nexport type IMixinAlbedoColor = {\r\n  albedoColor: Vector4;\r\n  calculateAlbedoColor(scope: PBInsideFunctionScope, uv?: PBShaderExp): PBShaderExp;\r\n} & TextureMixinInstanceTypes<['albedo']>;\r\n\r\n/**\r\n * Albedo color mixin\r\n * @param BaseCls - Class to mix in\r\n * @returns Mixed class\r\n *\r\n * @public\r\n */\r\nfunction mixinAlbedoColor<T extends typeof MeshMaterial>(BaseCls: T) {\r\n  if ((BaseCls as any).albedoColorMixed) {\r\n    return BaseCls as T & { new (...args: any[]): IMixinAlbedoColor };\r\n  }\r\n  const S = applyMaterialMixins(BaseCls, mixinTextureProps('albedo'));\r\n  const ALBEDO_COLOR_UNIFORM = S.defineInstanceUniform('albedoColor', 'rgba', 'AlbedoColor');\r\n  return class extends S {\r\n    static albedoColorMixed = true;\r\n    private readonly _albedoColor: Vector4;\r\n    constructor() {\r\n      super();\r\n      this._albedoColor = Vector4.one();\r\n    }\r\n    copyFrom(other: this): void {\r\n      super.copyFrom(other);\r\n      this.albedoColor = other.albedoColor;\r\n    }\r\n    /** Albedo color */\r\n    get albedoColor(): Vector4 {\r\n      return this._albedoColor;\r\n    }\r\n    set albedoColor(val: Vector4) {\r\n      this._albedoColor.set(val);\r\n      this.uniformChanged();\r\n    }\r\n    getUniformValueAlbedoColor(scope: PBInsideFunctionScope): PBShaderExp {\r\n      return this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING\r\n        ? scope.$inputs.zAlbedo\r\n        : scope.zAlbedo;\r\n    }\r\n    calculateAlbedoColor(scope: PBInsideFunctionScope, uv?: PBShaderExp): PBShaderExp {\r\n      const pb = scope.$builder;\r\n      if (!this.needFragmentColor()) {\r\n        console.warn(\r\n          'mixinAlbedoColor.calculateAlbedoColor(): No need to calculate albedo color, make sure needFragmentColor() returns true'\r\n        );\r\n        return pb.vec4(1);\r\n      }\r\n      let color = this.getUniformValueAlbedoColor(scope);\r\n      if (this.albedoTexture) {\r\n        color = pb.mul(color, this.sampleAlbedoTexture(scope, uv));\r\n      }\r\n      return color;\r\n    }\r\n    vertexShader(scope: PBFunctionScope): void {\r\n      super.vertexShader(scope);\r\n      if (this.needFragmentColor()) {\r\n        if (this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING) {\r\n          scope.$outputs.zAlbedo = this.getInstancedUniform(scope, ALBEDO_COLOR_UNIFORM);\r\n        }\r\n      }\r\n    }\r\n    fragmentShader(scope: PBFunctionScope): void {\r\n      super.fragmentShader(scope);\r\n      if (this.needFragmentColor() && !(this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING)) {\r\n        const pb = scope.$builder;\r\n        scope.zAlbedo = pb.vec4().uniform(2);\r\n      }\r\n    }\r\n    applyUniformValues(bindGroup: BindGroup, ctx: DrawContext, pass: number): void {\r\n      super.applyUniformValues(bindGroup, ctx, pass);\r\n      if (this.needFragmentColor(ctx) && !(ctx.materialFlags & MaterialVaryingFlags.INSTANCING)) {\r\n        bindGroup.setValue('zAlbedo', this._albedoColor);\r\n      }\r\n    }\r\n  } as unknown as T & { new (...args: any[]): IMixinAlbedoColor };\r\n}\r\n\r\nexport { mixinAlbedoColor };\r\n"],"names":["mixinAlbedoColor","BaseCls","albedoColorMixed","S","applyMaterialMixins","mixinTextureProps","ALBEDO_COLOR_UNIFORM","defineInstanceUniform","_albedoColor","Vector4","one","copyFrom","other","albedoColor","val","set","uniformChanged","getUniformValueAlbedoColor","scope","drawContext","materialFlags","MaterialVaryingFlags","INSTANCING","$inputs","zAlbedo","calculateAlbedoColor","uv","pb","$builder","needFragmentColor","console","warn","vec4","color","albedoTexture","mul","sampleAlbedoTexture","vertexShader","$outputs","getInstancedUniform","fragmentShader","uniform","applyUniformValues","bindGroup","ctx","pass","setValue"],"mappings":"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"}

package/dist/material/mixins/foliage.js

@@ -11,8 +11,8 @@
     }
     return class extends BaseCls {
         static foliageMixed = true;
-        constructor(...args){
-            super(...args);
+        constructor(){
+            super();
             this.cullMode = 'none';
         }
         calculateFoliageAlbedo(scope, albedoColor, texelCoord) {
@@ -32,7 +32,7 @@
                 pb.vec4('albedo'),
                 pb.vec2('coord')
             ], function() {
-                this.$l.a = pb.mul(this.albedo.a, pb.add(1, pb.mul(pb.max(0, scope[funcNameCalcMipLevel](this.coord)), 0.25)));
+                this.$l.a = pb.mul(this.albedo.a, pb.add(1, pb.mul(pb.max(0, scope[funcNameCalcMipLevel](this.coord)), 0.5)));
                 if (that.alphaToCoverage) {
                     this.a = pb.add(pb.div(pb.sub(this.a, 0.4), pb.max(pb.fwidth(this.albedo.a), 0.0001)), 0.5);
                 }

package/dist/material/mixins/foliage.js.map

@@ -1 +1 @@
-{"version":3,"file":"foliage.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"foliage.js","sources":["../../../src/material/mixins/foliage.ts"],"sourcesContent":["import type { PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\r\nimport type { MeshMaterial } from '../meshmaterial';\r\n\r\n/**\r\n * Interface for foliage mixin\r\n * @public\r\n */\r\nexport interface IMixinFoliage {\r\n  calculateFoliageAlbedo(\r\n    scope: PBInsideFunctionScope,\r\n    albedoColor: PBShaderExp,\r\n    texelCoord: PBShaderExp\r\n  ): PBShaderExp;\r\n}\r\n\r\n/**\r\n * Foliage mixin\r\n *\r\n * @param BaseCls - Class to mix in\r\n * @returns Mixed class\r\n *\r\n * @public\r\n */\r\nfunction mixinFoliage<T extends typeof MeshMaterial>(BaseCls: T) {\r\n  if ((BaseCls as any).foliageMixed) {\r\n    return BaseCls as T & { new (...args: any[]): IMixinFoliage };\r\n  }\r\n  return class extends (BaseCls as typeof MeshMaterial) {\r\n    static foliageMixed = true;\r\n    constructor() {\r\n      super();\r\n      this.cullMode = 'none';\r\n    }\r\n    calculateFoliageAlbedo(\r\n      scope: PBInsideFunctionScope,\r\n      albedoColor: PBShaderExp,\r\n      texelCoord: PBShaderExp\r\n    ): PBShaderExp {\r\n      const pb = scope.$builder;\r\n      const that = this;\r\n      const funcNameCalcMipLevel = 'Z_CalcFoliageMipLevel';\r\n      pb.func(funcNameCalcMipLevel, [pb.vec2('coord')], function () {\r\n        this.$l.dx = pb.dpdx(this.coord);\r\n        this.$l.dy = pb.dpdy(this.coord);\r\n        this.$l.deltaMaxSqr = pb.max(pb.dot(this.dx, this.dx), pb.dot(this.dy, this.dy));\r\n        this.$return(pb.max(0, pb.mul(pb.log2(this.deltaMaxSqr), 0.5)));\r\n      });\r\n      const funcNameCalcFoliageAlbedo = 'Z_calcFoliageAlbedo';\r\n      pb.func(funcNameCalcFoliageAlbedo, [pb.vec4('albedo'), pb.vec2('coord')], function () {\r\n        this.$l.a = pb.mul(\r\n          this.albedo.a,\r\n          pb.add(1, pb.mul(pb.max(0, scope[funcNameCalcMipLevel](this.coord)), 0.5))\r\n        );\r\n        if (that.alphaToCoverage) {\r\n          this.a = pb.add(pb.div(pb.sub(this.a, 0.4), pb.max(pb.fwidth(this.albedo.a), 0.0001)), 0.5);\r\n        }\r\n        this.$return(pb.vec4(this.albedo.rgb, this.a));\r\n      });\r\n      return pb.getGlobalScope()[funcNameCalcFoliageAlbedo](albedoColor, texelCoord);\r\n    }\r\n  } as unknown as T & { new (...args: any[]): IMixinFoliage };\r\n}\r\n\r\nexport { mixinFoliage };\r\n"],"names":["mixinFoliage","BaseCls","foliageMixed","cullMode","calculateFoliageAlbedo","scope","albedoColor","texelCoord","pb","$builder","that","funcNameCalcMipLevel","func","vec2","$l","dx","dpdx","coord","dy","dpdy","deltaMaxSqr","max","dot","$return","mul","log2","funcNameCalcFoliageAlbedo","vec4","a","albedo","add","alphaToCoverage","div","sub","fwidth","rgb","getGlobalScope"],"mappings":"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"}

package/dist/material/mixins/lightmodel/blinnphong.js

@@ -1,6 +1,7 @@
 import { applyMaterialMixins } from '../../meshmaterial.js';
 import { mixinLight } from '../lit.js';
 import { ShaderHelper } from '../../shader/helper.js';
+import { MaterialVaryingFlags } from '../../../values.js';
 
 /**
  * Blinn-phong lighting model mixin
@@ -12,6 +13,7 @@ import { ShaderHelper } from '../../shader/helper.js';
         return BaseCls;
     }
     const S = applyMaterialMixins(BaseCls, mixinLight);
+    const SHININESS_UNIFORM = S.defineInstanceUniform('shininess', 'float', 'Shininess');
     return class extends S {
         static blinnPhongMixed = true;
         _shininess;
@@ -19,6 +21,10 @@ import { ShaderHelper } from '../../shader/helper.js';
             super();
             this._shininess = 32;
         }
+        copyFrom(other) {
+            super.copyFrom(other);
+            this.shininess = other.shininess;
+        }
         /** Shininess */ get shininess() {
             return this._shininess;
         }
@@ -28,16 +34,22 @@ import { ShaderHelper } from '../../shader/helper.js';
                 this.uniformChanged();
             }
         }
+        vertexShader(scope) {
+            super.vertexShader(scope);
+            if (this.needFragmentColor() && this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING) {
+                scope.$outputs.zShininess = this.getInstancedUniform(scope, SHININESS_UNIFORM);
+            }
+        }
         fragmentShader(scope) {
             super.fragmentShader(scope);
             const pb = scope.$builder;
-            if (this.needFragmentColor()) {
+            if (this.needFragmentColor() && !(this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING)) {
                 scope.zShininess = pb.float().uniform(2);
             }
         }
         applyUniformValues(bindGroup, ctx, pass) {
             super.applyUniformValues(bindGroup, ctx, pass);
-            if (this.needFragmentColor(ctx)) {
+            if (this.needFragmentColor(ctx) && !(ctx.materialFlags & MaterialVaryingFlags.INSTANCING)) {
                 bindGroup.setValue('zShininess', this._shininess);
             }
         }
@@ -57,6 +69,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                 if (!that.needFragmentColor()) {
                     this.$return(this.albedo.rgb);
                 } else {
+                    const shininess = that.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING ? this.$inputs.zShininess : this.zShininess;
                     if (that.needCalculateEnvLight() && !outRoughness) {
                         this.$l.diffuseColor = that.getEnvLightIrradiance(this, this.normal);
                     } else {
@@ -70,8 +83,8 @@ import { ShaderHelper } from '../../shader/helper.js';
                         this.$l.halfVec = pb.normalize(pb.add(this.viewVec, this.lightDir));
                         this.$l.NoH = pb.clamp(pb.dot(this.normal, this.halfVec), 0, 1);
                         this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);
-                        this.$l.diffuse = pb.mul(this.lightColor, this.NoL);
-                        this.$l.specular = pb.mul(this.lightColor, pb.pow(this.NoH, this.zShininess));
+                        this.$l.diffuse = pb.mul(this.lightColor, 1 / Math.PI, this.NoL);
+                        this.$l.specular = pb.mul(this.lightColor, pb.pow(this.NoH, shininess));
                         if (shadow) {
                             this.$if(pb.greaterThan(this.NoL, 0), function() {
                                 this.$l.shadow = pb.vec3(that.calculateShadow(this, this.worldPos, this.NoL));
@@ -84,7 +97,7 @@ import { ShaderHelper } from '../../shader/helper.js';
                     });
                     this.$l.litColor = pb.add(pb.mul(this.albedo.rgb, this.diffuseColor), this.specularColor);
                     if (outRoughness) {
-                        this.$l.roughness = pb.sqrt(pb.div(2, pb.add(this.zShininess, 2)));
+                        this.$l.roughness = pb.sqrt(pb.div(2, pb.add(shininess, 2)));
                         this.outRoughness = pb.vec4(pb.mul(this.albedo.rgb, pb.sub(1, this.roughness)), pb.mul(this.roughness, ShaderHelper.getCameraRoughnessFactor(this)));
                     }
                     this.$return(this.litColor);

package/dist/material/mixins/lightmodel/blinnphong.js.map

@@ -1 +1 @@
-{"version":3,"file":"blinnphong.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"blinnphong.js","sources":["../../../../src/material/mixins/lightmodel/blinnphong.ts"],"sourcesContent":["import type { BindGroup, PBFunctionScope, PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\r\nimport type { MeshMaterial } from '../../meshmaterial';\r\nimport { applyMaterialMixins } from '../../meshmaterial';\r\nimport type { IMixinLight } from '../lit';\r\nimport { mixinLight } from '../lit';\r\nimport type { DrawContext } from '../../../render';\r\nimport { ShaderHelper } from '../../shader/helper';\r\nimport { MaterialVaryingFlags } from '../../../values';\r\n\r\n/**\r\n * Interface for blinn-phong lighting model mixin\r\n * @public\r\n */\r\nexport type IMixinBlinnPhong = {\r\n  shininess: number;\r\n  blinnPhongLight(\r\n    scope: PBInsideFunctionScope,\r\n    worldPos: PBShaderExp,\r\n    normal: PBShaderExp,\r\n    viewVec: PBShaderExp,\r\n    albedo: PBShaderExp,\r\n    outRoughness?: PBShaderExp\r\n  ): PBShaderExp;\r\n} & IMixinLight;\r\n\r\n/**\r\n * Blinn-phong lighting model mixin\r\n * @param BaseCls - Class to mix in\r\n * @returns Mixed class\r\n * @public\r\n */\r\nexport function mixinBlinnPhong<T extends typeof MeshMaterial>(BaseCls: T) {\r\n  if ((BaseCls as any).blinnPhongMixed) {\r\n    return BaseCls as T & { new (...args: any[]): IMixinBlinnPhong };\r\n  }\r\n  const S = applyMaterialMixins(BaseCls, mixinLight);\r\n  const SHININESS_UNIFORM = S.defineInstanceUniform('shininess', 'float', 'Shininess');\r\n  return class extends S {\r\n    protected static blinnPhongMixed = true;\r\n    private _shininess: number;\r\n    constructor() {\r\n      super();\r\n      this._shininess = 32;\r\n    }\r\n    copyFrom(other: this): void {\r\n      super.copyFrom(other);\r\n      this.shininess = other.shininess;\r\n    }\r\n    /** Shininess */\r\n    get shininess(): number {\r\n      return this._shininess;\r\n    }\r\n    set shininess(val: number) {\r\n      if (val !== this._shininess) {\r\n        this._shininess = val;\r\n        this.uniformChanged();\r\n      }\r\n    }\r\n    vertexShader(scope: PBFunctionScope): void {\r\n      super.vertexShader(scope);\r\n      if (this.needFragmentColor() && this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING) {\r\n        scope.$outputs.zShininess = this.getInstancedUniform(scope, SHININESS_UNIFORM);\r\n      }\r\n    }\r\n    fragmentShader(scope: PBFunctionScope): void {\r\n      super.fragmentShader(scope);\r\n      const pb = scope.$builder;\r\n      if (this.needFragmentColor() && !(this.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING)) {\r\n        scope.zShininess = pb.float().uniform(2);\r\n      }\r\n    }\r\n    applyUniformValues(bindGroup: BindGroup, ctx: DrawContext, pass: number): void {\r\n      super.applyUniformValues(bindGroup, ctx, pass);\r\n      if (this.needFragmentColor(ctx) && !(ctx.materialFlags & MaterialVaryingFlags.INSTANCING)) {\r\n        bindGroup.setValue('zShininess', this._shininess);\r\n      }\r\n    }\r\n    blinnPhongLight(\r\n      scope: PBInsideFunctionScope,\r\n      worldPos: PBShaderExp,\r\n      normal: PBShaderExp,\r\n      viewVec: PBShaderExp,\r\n      albedo: PBShaderExp,\r\n      outRoughness?: PBShaderExp\r\n    ): PBShaderExp {\r\n      const pb = scope.$builder;\r\n      const funcName = 'Z_blinnPhongLight';\r\n      const that = this;\r\n      pb.func(\r\n        funcName,\r\n        [\r\n          pb.vec3('worldPos'),\r\n          pb.vec3('normal'),\r\n          pb.vec3('viewVec'),\r\n          pb.vec4('albedo'),\r\n          ...(outRoughness ? [pb.vec4('outRoughness').out()] : [])\r\n        ],\r\n        function () {\r\n          if (!that.needFragmentColor()) {\r\n            this.$return(this.albedo.rgb);\r\n          } else {\r\n            const shininess =\r\n              that.drawContext.materialFlags & MaterialVaryingFlags.INSTANCING\r\n                ? this.$inputs.zShininess\r\n                : this.zShininess;\r\n            if (that.needCalculateEnvLight() && !outRoughness) {\r\n              this.$l.diffuseColor = that.getEnvLightIrradiance(this, this.normal);\r\n            } else {\r\n              this.$l.diffuseColor = pb.vec3(0);\r\n            }\r\n            this.$l.specularColor = pb.vec3(0);\r\n            that.forEachLight(this, function (type, posRange, dirCutoff, colorIntensity, shadow) {\r\n              this.$l.lightAtten = that.calculateLightAttenuation(\r\n                this,\r\n                type,\r\n                this.worldPos,\r\n                posRange,\r\n                dirCutoff\r\n              );\r\n              this.$l.lightDir = that.calculateLightDirection(this, type, this.worldPos, posRange, dirCutoff);\r\n              this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);\r\n              this.$l.halfVec = pb.normalize(pb.add(this.viewVec, this.lightDir));\r\n              this.$l.NoH = pb.clamp(pb.dot(this.normal, this.halfVec), 0, 1);\r\n              this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);\r\n              this.$l.diffuse = pb.mul(this.lightColor, 1 / Math.PI, this.NoL);\r\n              this.$l.specular = pb.mul(this.lightColor, pb.pow(this.NoH, shininess));\r\n              if (shadow) {\r\n                this.$if(pb.greaterThan(this.NoL, 0), function () {\r\n                  this.$l.shadow = pb.vec3(that.calculateShadow(this, this.worldPos, this.NoL));\r\n                  this.diffuse = pb.mul(this.diffuse, this.shadow);\r\n                  this.specular = pb.mul(this.specular, this.shadow);\r\n                });\r\n              }\r\n              this.diffuseColor = pb.add(this.diffuseColor, this.diffuse);\r\n              this.specularColor = pb.add(this.specularColor, this.specular);\r\n            });\r\n            this.$l.litColor = pb.add(pb.mul(this.albedo.rgb, this.diffuseColor), this.specularColor);\r\n            if (outRoughness) {\r\n              this.$l.roughness = pb.sqrt(pb.div(2, pb.add(shininess, 2)));\r\n              this.outRoughness = pb.vec4(\r\n                pb.mul(this.albedo.rgb, pb.sub(1, this.roughness)),\r\n                pb.mul(this.roughness, ShaderHelper.getCameraRoughnessFactor(this))\r\n              );\r\n            }\r\n            this.$return(this.litColor);\r\n          }\r\n        }\r\n      );\r\n      return outRoughness\r\n        ? pb.getGlobalScope()[funcName](worldPos, normal, viewVec, albedo, outRoughness)\r\n        : pb.getGlobalScope()[funcName](worldPos, normal, viewVec, albedo);\r\n    }\r\n  } as unknown as T & { new (...args: any[]): IMixinBlinnPhong };\r\n}\r\n"],"names":["mixinBlinnPhong","BaseCls","blinnPhongMixed","S","applyMaterialMixins","mixinLight","SHININESS_UNIFORM","defineInstanceUniform","_shininess","copyFrom","other","shininess","val","uniformChanged","vertexShader","scope","needFragmentColor","drawContext","materialFlags","MaterialVaryingFlags","INSTANCING","$outputs","zShininess","getInstancedUniform","fragmentShader","pb","$builder","float","uniform","applyUniformValues","bindGroup","ctx","pass","setValue","blinnPhongLight","worldPos","normal","viewVec","albedo","outRoughness","funcName","that","func","vec3","vec4","out","$return","rgb","$inputs","needCalculateEnvLight","$l","diffuseColor","getEnvLightIrradiance","specularColor","forEachLight","type","posRange","dirCutoff","colorIntensity","shadow","lightAtten","calculateLightAttenuation","lightDir","calculateLightDirection","NoL","clamp","dot","halfVec","normalize","add","NoH","lightColor","mul","a","diffuse","Math","PI","specular","pow","$if","greaterThan","calculateShadow","litColor","roughness","sqrt","div","sub","ShaderHelper","getCameraRoughnessFactor","getGlobalScope"],"mappings":";;;;;AAyBA;;;;;IAMO,SAASA,eAAAA,CAA+CC,OAAU,EAAA;IACvE,IAAKA,OAAgBC,CAAAA,eAAe,EAAE;QACpC,OAAOD,OAAAA;AACT;IACA,MAAME,CAAAA,GAAIC,oBAAoBH,OAASI,EAAAA,UAAAA,CAAAA;AACvC,IAAA,MAAMC,iBAAoBH,GAAAA,CAAAA,CAAEI,qBAAqB,CAAC,aAAa,OAAS,EAAA,WAAA,CAAA;AACxE,IAAA,OAAO,cAAcJ,CAAAA,CAAAA;AACnB,QAAA,OAAiBD,kBAAkB,IAAK;QAChCM,UAAmB;QAC3B,WAAc,EAAA;YACZ,KAAK,EAAA;YACL,IAAI,CAACA,UAAU,GAAG,EAAA;AACpB;AACAC,QAAAA,QAAAA,CAASC,KAAW,EAAQ;AAC1B,YAAA,KAAK,CAACD,QAASC,CAAAA,KAAAA,CAAAA;AACf,YAAA,IAAI,CAACC,SAAS,GAAGD,KAAAA,CAAMC,SAAS;AAClC;yBAEA,IAAIA,SAAoB,GAAA;YACtB,OAAO,IAAI,CAACH,UAAU;AACxB;QACA,IAAIG,SAAAA,CAAUC,GAAW,EAAE;AACzB,YAAA,IAAIA,GAAQ,KAAA,IAAI,CAACJ,UAAU,EAAE;gBAC3B,IAAI,CAACA,UAAU,GAAGI,GAAAA;AAClB,gBAAA,IAAI,CAACC,cAAc,EAAA;AACrB;AACF;AACAC,QAAAA,YAAAA,CAAaC,KAAsB,EAAQ;AACzC,YAAA,KAAK,CAACD,YAAaC,CAAAA,KAAAA,CAAAA;AACnB,YAAA,IAAI,IAAI,CAACC,iBAAiB,EAAA,IAAM,IAAI,CAACC,WAAW,CAACC,aAAa,GAAGC,oBAAqBC,CAAAA,UAAU,EAAE;gBAChGL,KAAMM,CAAAA,QAAQ,CAACC,UAAU,GAAG,IAAI,CAACC,mBAAmB,CAACR,KAAOT,EAAAA,iBAAAA,CAAAA;AAC9D;AACF;AACAkB,QAAAA,cAAAA,CAAeT,KAAsB,EAAQ;AAC3C,YAAA,KAAK,CAACS,cAAeT,CAAAA,KAAAA,CAAAA;YACrB,MAAMU,EAAAA,GAAKV,MAAMW,QAAQ;AACzB,YAAA,IAAI,IAAI,CAACV,iBAAiB,EAAA,IAAM,EAAE,IAAI,CAACC,WAAW,CAACC,aAAa,GAAGC,oBAAqBC,CAAAA,UAAU,CAAG,EAAA;AACnGL,gBAAAA,KAAAA,CAAMO,UAAU,GAAGG,EAAAA,CAAGE,KAAK,EAAA,CAAGC,OAAO,CAAC,CAAA,CAAA;AACxC;AACF;AACAC,QAAAA,kBAAAA,CAAmBC,SAAoB,EAAEC,GAAgB,EAAEC,IAAY,EAAQ;YAC7E,KAAK,CAACH,kBAAmBC,CAAAA,SAAAA,EAAWC,GAAKC,EAAAA,IAAAA,CAAAA;AACzC,YAAA,IAAI,IAAI,CAAChB,iBAAiB,CAACe,GAAQ,CAAA,IAAA,EAAEA,GAAAA,CAAIb,aAAa,GAAGC,oBAAqBC,CAAAA,UAAU,CAAG,EAAA;AACzFU,gBAAAA,SAAAA,CAAUG,QAAQ,CAAC,YAAc,EAAA,IAAI,CAACzB,UAAU,CAAA;AAClD;AACF;QACA0B,eACEnB,CAAAA,KAA4B,EAC5BoB,QAAqB,EACrBC,MAAmB,EACnBC,OAAoB,EACpBC,MAAmB,EACnBC,YAA0B,EACb;YACb,MAAMd,EAAAA,GAAKV,MAAMW,QAAQ;AACzB,YAAA,MAAMc,QAAW,GAAA,mBAAA;AACjB,YAAA,MAAMC,OAAO,IAAI;YACjBhB,EAAGiB,CAAAA,IAAI,CACLF,QACA,EAAA;AACEf,gBAAAA,EAAAA,CAAGkB,IAAI,CAAC,UAAA,CAAA;AACRlB,gBAAAA,EAAAA,CAAGkB,IAAI,CAAC,QAAA,CAAA;AACRlB,gBAAAA,EAAAA,CAAGkB,IAAI,CAAC,SAAA,CAAA;AACRlB,gBAAAA,EAAAA,CAAGmB,IAAI,CAAC,QAAA,CAAA;mBACJL,YAAe,GAAA;oBAACd,EAAGmB,CAAAA,IAAI,CAAC,cAAA,CAAA,CAAgBC,GAAG;AAAG,iBAAA,GAAG;aACtD,EACD,WAAA;gBACE,IAAI,CAACJ,IAAKzB,CAAAA,iBAAiB,EAAI,EAAA;AAC7B,oBAAA,IAAI,CAAC8B,OAAO,CAAC,IAAI,CAACR,MAAM,CAACS,GAAG,CAAA;iBACvB,MAAA;AACL,oBAAA,MAAMpC,YACJ8B,IAAKxB,CAAAA,WAAW,CAACC,aAAa,GAAGC,oBAAqBC,CAAAA,UAAU,GAC5D,IAAI,CAAC4B,OAAO,CAAC1B,UAAU,GACvB,IAAI,CAACA,UAAU;AACrB,oBAAA,IAAImB,IAAKQ,CAAAA,qBAAqB,EAAM,IAAA,CAACV,YAAc,EAAA;AACjD,wBAAA,IAAI,CAACW,EAAE,CAACC,YAAY,GAAGV,IAAAA,CAAKW,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAChB,MAAM,CAAA;qBAC9D,MAAA;AACL,wBAAA,IAAI,CAACc,EAAE,CAACC,YAAY,GAAG1B,EAAAA,CAAGkB,IAAI,CAAC,CAAA,CAAA;AACjC;AACA,oBAAA,IAAI,CAACO,EAAE,CAACG,aAAa,GAAG5B,EAAAA,CAAGkB,IAAI,CAAC,CAAA,CAAA;AAChCF,oBAAAA,IAAAA,CAAKa,YAAY,CAAC,IAAI,EAAE,SAAUC,IAAI,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,cAAc,EAAEC,MAAM,EAAA;AACjF,wBAAA,IAAI,CAACT,EAAE,CAACU,UAAU,GAAGnB,IAAKoB,CAAAA,yBAAyB,CACjD,IAAI,EACJN,IACA,EAAA,IAAI,CAACpB,QAAQ,EACbqB,QACAC,EAAAA,SAAAA,CAAAA;AAEF,wBAAA,IAAI,CAACP,EAAE,CAACY,QAAQ,GAAGrB,IAAKsB,CAAAA,uBAAuB,CAAC,IAAI,EAAER,IAAM,EAAA,IAAI,CAACpB,QAAQ,EAAEqB,QAAUC,EAAAA,SAAAA,CAAAA;AACrF,wBAAA,IAAI,CAACP,EAAE,CAACc,GAAG,GAAGvC,EAAAA,CAAGwC,KAAK,CAACxC,EAAAA,CAAGyC,GAAG,CAAC,IAAI,CAAC9B,MAAM,EAAE,IAAI,CAAC0B,QAAQ,GAAG,CAAG,EAAA,CAAA,CAAA;AAC9D,wBAAA,IAAI,CAACZ,EAAE,CAACiB,OAAO,GAAG1C,GAAG2C,SAAS,CAAC3C,EAAG4C,CAAAA,GAAG,CAAC,IAAI,CAAChC,OAAO,EAAE,IAAI,CAACyB,QAAQ,CAAA,CAAA;AACjE,wBAAA,IAAI,CAACZ,EAAE,CAACoB,GAAG,GAAG7C,EAAAA,CAAGwC,KAAK,CAACxC,EAAAA,CAAGyC,GAAG,CAAC,IAAI,CAAC9B,MAAM,EAAE,IAAI,CAAC+B,OAAO,GAAG,CAAG,EAAA,CAAA,CAAA;AAC7D,wBAAA,IAAI,CAACjB,EAAE,CAACqB,UAAU,GAAG9C,GAAG+C,GAAG,CAACd,cAAeX,CAAAA,GAAG,EAAEW,cAAee,CAAAA,CAAC,EAAE,IAAI,CAACb,UAAU,CAAA;AACjF,wBAAA,IAAI,CAACV,EAAE,CAACwB,OAAO,GAAGjD,EAAAA,CAAG+C,GAAG,CAAC,IAAI,CAACD,UAAU,EAAE,CAAII,GAAAA,IAAAA,CAAKC,EAAE,EAAE,IAAI,CAACZ,GAAG,CAAA;AAC/D,wBAAA,IAAI,CAACd,EAAE,CAAC2B,QAAQ,GAAGpD,EAAAA,CAAG+C,GAAG,CAAC,IAAI,CAACD,UAAU,EAAE9C,EAAGqD,CAAAA,GAAG,CAAC,IAAI,CAACR,GAAG,EAAE3D,SAAAA,CAAAA,CAAAA;AAC5D,wBAAA,IAAIgD,MAAQ,EAAA;4BACV,IAAI,CAACoB,GAAG,CAACtD,EAAGuD,CAAAA,WAAW,CAAC,IAAI,CAAChB,GAAG,EAAE,CAAI,CAAA,EAAA,WAAA;AACpC,gCAAA,IAAI,CAACd,EAAE,CAACS,MAAM,GAAGlC,EAAAA,CAAGkB,IAAI,CAACF,IAAAA,CAAKwC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC9C,QAAQ,EAAE,IAAI,CAAC6B,GAAG,CAAA,CAAA;AAC3E,gCAAA,IAAI,CAACU,OAAO,GAAGjD,EAAAA,CAAG+C,GAAG,CAAC,IAAI,CAACE,OAAO,EAAE,IAAI,CAACf,MAAM,CAAA;AAC/C,gCAAA,IAAI,CAACkB,QAAQ,GAAGpD,EAAAA,CAAG+C,GAAG,CAAC,IAAI,CAACK,QAAQ,EAAE,IAAI,CAAClB,MAAM,CAAA;AACnD,6BAAA,CAAA;AACF;AACA,wBAAA,IAAI,CAACR,YAAY,GAAG1B,EAAAA,CAAG4C,GAAG,CAAC,IAAI,CAAClB,YAAY,EAAE,IAAI,CAACuB,OAAO,CAAA;AAC1D,wBAAA,IAAI,CAACrB,aAAa,GAAG5B,EAAAA,CAAG4C,GAAG,CAAC,IAAI,CAAChB,aAAa,EAAE,IAAI,CAACwB,QAAQ,CAAA;AAC/D,qBAAA,CAAA;oBACA,IAAI,CAAC3B,EAAE,CAACgC,QAAQ,GAAGzD,EAAG4C,CAAAA,GAAG,CAAC5C,EAAAA,CAAG+C,GAAG,CAAC,IAAI,CAAClC,MAAM,CAACS,GAAG,EAAE,IAAI,CAACI,YAAY,CAAA,EAAG,IAAI,CAACE,aAAa,CAAA;AACxF,oBAAA,IAAId,YAAc,EAAA;AAChB,wBAAA,IAAI,CAACW,EAAE,CAACiC,SAAS,GAAG1D,EAAG2D,CAAAA,IAAI,CAAC3D,EAAAA,CAAG4D,GAAG,CAAC,CAAA,EAAG5D,EAAG4C,CAAAA,GAAG,CAAC1D,SAAW,EAAA,CAAA,CAAA,CAAA,CAAA;AACxD,wBAAA,IAAI,CAAC4B,YAAY,GAAGd,EAAAA,CAAGmB,IAAI,CACzBnB,EAAAA,CAAG+C,GAAG,CAAC,IAAI,CAAClC,MAAM,CAACS,GAAG,EAAEtB,EAAAA,CAAG6D,GAAG,CAAC,CAAG,EAAA,IAAI,CAACH,SAAS,IAChD1D,EAAG+C,CAAAA,GAAG,CAAC,IAAI,CAACW,SAAS,EAAEI,YAAaC,CAAAA,wBAAwB,CAAC,IAAI,CAAA,CAAA,CAAA;AAErE;AACA,oBAAA,IAAI,CAAC1C,OAAO,CAAC,IAAI,CAACoC,QAAQ,CAAA;AAC5B;AACF,aAAA,CAAA;YAEF,OAAO3C,YAAAA,GACHd,GAAGgE,cAAc,EAAE,CAACjD,QAAS,CAAA,CAACL,UAAUC,MAAQC,EAAAA,OAAAA,EAASC,QAAQC,YACjEd,CAAAA,GAAAA,EAAAA,CAAGgE,cAAc,EAAE,CAACjD,SAAS,CAACL,QAAAA,EAAUC,QAAQC,OAASC,EAAAA,MAAAA,CAAAA;AAC/D;AACF,KAAA;AACF;;;;"}

package/dist/material/mixins/lightmodel/lambert.js

@@ -1,11 +1,11 @@
 import { applyMaterialMixins } from '../../meshmaterial.js';
 import { mixinLight } from '../lit.js';
 
-/**
- * Lambert lighting model mixin
- * @param BaseCls - Class to mix in
- * @returns Mixed class
- * @public
+/**
+ * Lambert lighting model mixin
+ * @param BaseCls - Class to mix in
+ * @returns Mixed class
+ * @public
  */ function mixinLambert(BaseCls) {
     if (BaseCls.lambertMixed) {
         return BaseCls;
@@ -38,7 +38,7 @@ import { mixinLight } from '../lit.js';
                         this.$l.lightDir = that.calculateLightDirection(this, type, this.worldPos, posRange, dirCutoff);
                         this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);
                         this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);
-                        this.$l.diffuse = pb.mul(this.lightColor, this.NoL);
+                        this.$l.diffuse = pb.mul(this.lightColor, 1 / Math.PI, this.NoL);
                         if (shadow) {
                             this.$l.shadow = pb.vec3(that.calculateShadow(this, this.worldPos, this.NoL));
                             this.diffuse = pb.mul(this.diffuse, this.shadow);

package/dist/material/mixins/lightmodel/lambert.js.map

@@ -1 +1 @@
-{"version":3,"file":"lambert.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"lambert.js","sources":["../../../../src/material/mixins/lightmodel/lambert.ts"],"sourcesContent":["import type { PBInsideFunctionScope, PBShaderExp } from '@zephyr3d/device';\r\nimport type { MeshMaterial } from '../../meshmaterial';\r\nimport { applyMaterialMixins } from '../../meshmaterial';\r\nimport type { IMixinLight } from '../lit';\r\nimport { mixinLight } from '../lit';\r\n\r\n/**\r\n * Interface of lambert lighting model mixin\r\n * @public\r\n */\r\nexport type IMixinLambert = {\r\n  lambertLight(\r\n    scope: PBInsideFunctionScope,\r\n    worldPos: PBShaderExp,\r\n    normal: PBShaderExp,\r\n    albedo: PBShaderExp\r\n  ): PBShaderExp;\r\n} & IMixinLight;\r\n\r\n/**\r\n * Lambert lighting model mixin\r\n * @param BaseCls - Class to mix in\r\n * @returns Mixed class\r\n * @public\r\n */\r\nexport function mixinLambert<T extends typeof MeshMaterial>(BaseCls: T) {\r\n  if ((BaseCls as any).lambertMixed) {\r\n    return BaseCls as T & { new (...args: any[]): IMixinLambert };\r\n  }\r\n  const S = applyMaterialMixins(BaseCls, mixinLight);\r\n  return class extends S {\r\n    protected static lambertMixed = true;\r\n    constructor() {\r\n      super();\r\n    }\r\n    lambertLight(\r\n      scope: PBInsideFunctionScope,\r\n      worldPos: PBShaderExp,\r\n      normal: PBShaderExp,\r\n      albedo: PBShaderExp\r\n    ): PBShaderExp {\r\n      const pb = scope.$builder;\r\n      const funcName = 'Z_lambertLight';\r\n      const that = this;\r\n      pb.func(funcName, [pb.vec3('worldPos'), pb.vec3('normal'), pb.vec4('albedo')], function () {\r\n        if (!that.needFragmentColor()) {\r\n          this.$return(this.albedo.rgb);\r\n        } else {\r\n          if (that.needCalculateEnvLight()) {\r\n            this.$l.diffuseColor = that.getEnvLightIrradiance(this, this.normal);\r\n          } else {\r\n            this.$l.diffuseColor = pb.vec3(0);\r\n          }\r\n          that.forEachLight(this, function (type, posRange, dirCutoff, colorIntensity, shadow) {\r\n            this.$l.lightAtten = that.calculateLightAttenuation(\r\n              this,\r\n              type,\r\n              this.worldPos,\r\n              posRange,\r\n              dirCutoff\r\n            );\r\n            this.$l.lightDir = that.calculateLightDirection(this, type, this.worldPos, posRange, dirCutoff);\r\n            this.$l.NoL = pb.clamp(pb.dot(this.normal, this.lightDir), 0, 1);\r\n            this.$l.lightColor = pb.mul(colorIntensity.rgb, colorIntensity.a, this.lightAtten);\r\n            this.$l.diffuse = pb.mul(this.lightColor, 1 / Math.PI, this.NoL);\r\n            if (shadow) {\r\n              this.$l.shadow = pb.vec3(that.calculateShadow(this, this.worldPos, this.NoL));\r\n              this.diffuse = pb.mul(this.diffuse, this.shadow);\r\n            }\r\n            this.diffuseColor = pb.add(this.diffuseColor, this.diffuse);\r\n          });\r\n          this.$l.litColor = pb.mul(this.albedo.rgb, this.diffuseColor);\r\n          this.$return(this.litColor);\r\n        }\r\n      });\r\n      return pb.getGlobalScope()[funcName](worldPos, normal, albedo);\r\n    }\r\n  } as unknown as T & { new (...args: any[]): IMixinLambert };\r\n}\r\n"],"names":["mixinLambert","BaseCls","lambertMixed","S","applyMaterialMixins","mixinLight","lambertLight","scope","worldPos","normal","albedo","pb","$builder","funcName","that","func","vec3","vec4","needFragmentColor","$return","rgb","needCalculateEnvLight","$l","diffuseColor","getEnvLightIrradiance","forEachLight","type","posRange","dirCutoff","colorIntensity","shadow","lightAtten","calculateLightAttenuation","lightDir","calculateLightDirection","NoL","clamp","dot","lightColor","mul","a","diffuse","Math","PI","calculateShadow","add","litColor","getGlobalScope"],"mappings":"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"}