@meimu/mutracer 0.1.5 → 0.2.0

package/lib/scene/TextureState.js

@@ -0,0 +1,35 @@
+export function textureWrapIndex(mode) {
+    return mode === 'clamp-to-edge' ? 1 : mode === 'mirrored-repeat' ? 2 : 0;
+}
+// Pixel/image storage belongs to the platform adapter. Shared code only needs
+// dimensions, identity and sampling metadata; it never owns a browser image.
+export default class TextureState {
+    image;
+    version = 0;
+    /** Flip the image vertically when uploading. Default `false`. */
+    flipY = false;
+    /** UV repeat applied before sampling this texture. Default `[1, 1]`. */
+    uvScale = [1, 1];
+    /** UV translation applied after repeat and before wrapping. Default `[0, 0]`. */
+    uvOffset = [0, 0];
+    /** Horizontal material-texture addressing after UV scale/offset. Default `'repeat'`. */
+    wrapS = 'repeat';
+    /** Vertical material-texture addressing after UV scale/offset. Default `'repeat'`. */
+    wrapT = 'repeat';
+    /** Material color encoding. Default undefined: sRGB for images/bytes, linear for float/integer HDR data. Data-map channels ignore this option. */
+    colorSpace;
+    /** Geometry UV set used by this texture (Three.js Texture.channel). Default `0`. */
+    uvChannel = 0;
+    constructor(image) { this.image = image; }
+    /**
+     * Call after editing image pixels or UV array elements in place. Increments
+     * version so the next render refreshes all materials, lights and backgrounds
+     * using this texture. Assigning a new image, UV array, flipY, wrapS, wrapT, colorSpace or
+     * uvChannel is detected automatically.
+     */
+    markUpdated() {
+        this.version++;
+        return this;
+    }
+}
+//# sourceMappingURL=TextureState.js.map

package/lib/scene/TextureState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureState.js","sourceRoot":"","sources":["../../src/scene/TextureState.ts"],"names":[],"mappings":"AAMA,MAAM,UAAU,gBAAgB,CAAC,IAAqB;IACpD,OAAO,IAAI,KAAK,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3E,CAAC;AAID,8EAA8E;AAC9E,6EAA6E;AAC7E,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,KAAK,CAAmB;IACxB,OAAO,GAAG,CAAC,CAAC;IACZ,iEAAiE;IACjE,KAAK,GAAY,KAAK,CAAC;IACvB,wEAAwE;IACxE,OAAO,GAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnC,iFAAiF;IACjF,QAAQ,GAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpC,wFAAwF;IACxF,KAAK,GAAoB,QAAQ,CAAC;IAClC,sFAAsF;IACtF,KAAK,GAAoB,QAAQ,CAAC;IAClC,kJAAkJ;IAClJ,UAAU,CAAqB;IAC/B,oFAAoF;IACpF,SAAS,GAAU,CAAC,CAAC;IACrB,YAAY,KAAuB,IAAI,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC;IAE5D;;;;;OAKG;IACH,WAAW;QACT,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["/** Transfer function for material color slots; data-map channels remain linear. */\nexport type TextureColorSpace = 'srgb' | 'linear';\n\n/** Addressing of coordinates outside a material texture's [0, 1] range. */\nexport type TextureWrapMode = 'repeat' | 'clamp-to-edge' | 'mirrored-repeat';\n\nexport function textureWrapIndex(mode: TextureWrapMode): number {\n  return mode === 'clamp-to-edge' ? 1 : mode === 'mirrored-repeat' ? 2 : 0;\n}\n\nexport interface TextureImageSize { width: number; height: number; }\n\n// Pixel/image storage belongs to the platform adapter. Shared code only needs\n// dimensions, identity and sampling metadata; it never owns a browser image.\nexport default class TextureState {\n  image: TextureImageSize;\n  version = 0;\n  /** Flip the image vertically when uploading. Default `false`. */\n  flipY: boolean = false;\n  /** UV repeat applied before sampling this texture. Default `[1, 1]`. */\n  uvScale: [number, number] = [1, 1];\n  /** UV translation applied after repeat and before wrapping. Default `[0, 0]`. */\n  uvOffset: [number, number] = [0, 0];\n  /** Horizontal material-texture addressing after UV scale/offset. Default `'repeat'`. */\n  wrapS: TextureWrapMode = 'repeat';\n  /** Vertical material-texture addressing after UV scale/offset. Default `'repeat'`. */\n  wrapT: TextureWrapMode = 'repeat';\n  /** Material color encoding. Default undefined: sRGB for images/bytes, linear for float/integer HDR data. Data-map channels ignore this option. */\n  colorSpace?: TextureColorSpace;\n  /** Geometry UV set used by this texture (Three.js Texture.channel). Default `0`. */\n  uvChannel: 0 | 1 = 0;\n  constructor(image: TextureImageSize) { this.image = image; }\n\n  /**\n   * Call after editing image pixels or UV array elements in place. Increments\n   * version so the next render refreshes all materials, lights and backgrounds\n   * using this texture. Assigning a new image, UV array, flipY, wrapS, wrapT, colorSpace or\n   * uvChannel is detected automatically.\n   */\n  markUpdated() {\n    this.version++;\n    return this;\n  }\n}\n"]}

package/lib/scene/attributeData.d.ts

@@ -0,0 +1,4 @@
+export type AttributeData = Float32Array | Uint16Array | Uint32Array | Int32Array;
+export declare function indexStorage(array: Uint16Array | Uint32Array): Uint32Array;
+export declare function attributeValue(array: AttributeData, index: number): number;
+export declare function attributeLength(array: AttributeData): number;

package/lib/scene/attributeData.js

@@ -0,0 +1,10 @@
+export function indexStorage(array) {
+    return array instanceof Uint32Array ? array : new Uint32Array(array);
+}
+export function attributeValue(array, index) {
+    return array[index];
+}
+export function attributeLength(array) {
+    return array.length;
+}
+//# sourceMappingURL=attributeData.js.map

package/lib/scene/attributeData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributeData.js","sourceRoot":"","sources":["../../src/scene/attributeData.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,YAAY,CAAC,KAAgC;IAC3D,OAAO,KAAK,YAAY,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC;AACvE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,KAAoB,EAAE,KAAa;IAChE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;AACtB,CAAC;AACD,MAAM,UAAU,eAAe,CAAC,KAAoB;IAClD,OAAO,KAAK,CAAC,MAAM,CAAC;AACtB,CAAC","sourcesContent":["export type AttributeData = Float32Array | Uint16Array | Uint32Array | Int32Array;\n\nexport function indexStorage(array: Uint16Array | Uint32Array): Uint32Array {\n  return array instanceof Uint32Array ? array : new Uint32Array(array);\n}\n\nexport function attributeValue(array: AttributeData, index: number): number {\n  return array[index];\n}\nexport function attributeLength(array: AttributeData): number {\n  return array.length;\n}\n"]}

package/lib/scene/lightState.d.ts

@@ -0,0 +1,8 @@
+import type AmbientLight from './AmbientLight.js';
+import type DirectionalLight from './DirectionalLight.js';
+import type EnvironmentLightState from './EnvironmentLightState.js';
+import type RectLightState from './RectLightState.js';
+import type SphereLight from './SphereLight.js';
+import type SpotLight from './SpotLight.js';
+export type AnalyticLightState = RectLightState | SphereLight | SpotLight | DirectionalLight;
+export type SceneLightState = AmbientLight | EnvironmentLightState | AnalyticLightState;

package/lib/scene/lightState.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lightState.js.map

package/lib/scene/lightState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightState.js","sourceRoot":"","sources":["../../src/scene/lightState.ts"],"names":[],"mappings":"","sourcesContent":["import type AmbientLight from './AmbientLight.js';\nimport type DirectionalLight from './DirectionalLight.js';\nimport type EnvironmentLightState from './EnvironmentLightState.js';\nimport type RectLightState from './RectLightState.js';\nimport type SphereLight from './SphereLight.js';\nimport type SpotLight from './SpotLight.js';\nexport type AnalyticLightState = RectLightState | SphereLight | SpotLight | DirectionalLight;\nexport type SceneLightState = AmbientLight | EnvironmentLightState | AnalyticLightState;\n"]}

package/lib/scene/openPbrSchema.d.ts

@@ -1,4 +1,4 @@
-import type { default as OpenPBRMaterial, OpenPBRMaterialParams } from './OpenPBRMaterial.js';
+import type { default as MaterialState, MaterialStateParams } from './MaterialState.js';
 export declare const materialAliases: {
     readonly specularRoughnessAnisotropy: "specularAnisotropy";
     readonly coatRoughnessAnisotropy: "coatAnisotropy";
@@ -6,8 +6,8 @@ export declare const materialAliases: {
     readonly geometryOpacity: "opacity";
     readonly geometryThinWalled: "thinWalled";
 };
-type MaterialKey = Exclude<keyof OpenPBRMaterial, keyof typeof materialAliases>;
-export declare function normalizeMaterialParams(params: OpenPBRMaterialParams | Record<string, unknown>): Record<string, unknown>;
+type MaterialKey = Exclude<keyof MaterialState, keyof typeof materialAliases>;
+export declare function normalizeMaterialParams(params: MaterialStateParams | Record<string, unknown>): Record<string, unknown>;
 export declare const openPbrSchema: readonly [{
     readonly key: "baseWeight";
     readonly type: "float";
@@ -389,17 +389,12 @@ export declare const openPbrSchema: readonly [{
     readonly default: 0;
     readonly category: "geometry";
 }];
-type Keys<T extends readonly {
-    key: PropertyKey;
-}[]> = {
-    readonly [I in keyof T]: T[I]['key'];
-};
-export declare const materialKeys: Keys<typeof openPbrSchema>;
+export declare const materialKeys: readonly ["baseWeight", "baseColor", "baseDiffuseRoughness", "baseMetalness", "specularWeight", "specularColor", "specularRoughness", "specularIor", "specularAnisotropy", "transmissionWeight", "transmissionColor", "transmissionDepth", "transmissionScatter", "transmissionScatterAnisotropy", "transmissionDispersionScale", "transmissionDispersionAbbeNumber", "subsurfaceWeight", "subsurfaceColor", "subsurfaceRadius", "subsurfaceRadiusScale", "subsurfaceAnisotropy", "fuzzWeight", "fuzzColor", "fuzzRoughness", "coatWeight", "coatColor", "coatRoughness", "coatAnisotropy", "coatIor", "coatDarkening", "thinFilmWeight", "thinFilmThickness", "thinFilmIor", "emissionColor", "emissionLuminance", "opacity", "thinWalled", "doubleSided", "map", "alphaMap", "alphaMode", "alphaCutoff", "emissiveMap", "normalMap", "normalScale", "metallicRoughnessMap", "roughnessMap", "metalnessMap", "transmissionMap", "thinFilmMap", "shadowCatcher", "unlit", "bevelSize", "mapAlphaUsage", "uvProjection", "uvProjectionScale", "displacementUvProjection", "displacementUvProjectionScale", "displacementMap", "displacementScale", "displacementStepSize", "thinFilmThicknessMinimum", "thinFilmMapChannel", "coatWeightMap", "coatRoughnessMap", "fuzzColorMap", "fuzzRoughnessMap", "specularWeightMap", "specularColorMap", "anisotropyMap", "specularAnisotropyRotation", "coatAnisotropyRotation", "specularAnisotropyModel", "coatNormalMap", "coatNormalScale", "displacementBias"];
 export declare const materialTextureKeys: readonly ["map", "alphaMap", "emissiveMap", "normalMap", "metallicRoughnessMap", "roughnessMap", "metalnessMap", "transmissionMap", "thinFilmMap", "displacementMap", "coatWeightMap", "coatRoughnessMap", "fuzzColorMap", "fuzzRoughnessMap", "specularWeightMap", "specularColorMap", "anisotropyMap", "coatNormalMap"];
 export declare const materialGeometryKeys: readonly ["displacementUvProjection", "displacementUvProjectionScale", "displacementScale", "displacementStepSize", "displacementBias"];
 export declare const materialParamKeys: readonly ["baseWeight", "baseColor", "baseDiffuseRoughness", "baseMetalness", "specularWeight", "specularColor", "specularRoughness", "specularIor", "specularAnisotropy", "transmissionWeight", "transmissionColor", "transmissionDepth", "transmissionScatter", "transmissionScatterAnisotropy", "transmissionDispersionScale", "transmissionDispersionAbbeNumber", "subsurfaceWeight", "subsurfaceColor", "subsurfaceRadius", "subsurfaceRadiusScale", "subsurfaceAnisotropy", "fuzzWeight", "fuzzColor", "fuzzRoughness", "coatWeight", "coatColor", "coatRoughness", "coatAnisotropy", "coatIor", "coatDarkening", "thinFilmWeight", "thinFilmThickness", "thinFilmIor", "emissionColor", "emissionLuminance", "opacity", "thinWalled", "doubleSided", "alphaMode", "alphaCutoff", "normalScale", "shadowCatcher", "unlit", "bevelSize", "mapAlphaUsage", "uvProjection", "uvProjectionScale", "thinFilmThicknessMinimum", "thinFilmMapChannel", "specularAnisotropyRotation", "coatAnisotropyRotation", "specularAnisotropyModel", "coatNormalScale"];
-export declare function materialDefault<K extends MaterialKey>(key: K): OpenPBRMaterial[K];
-export declare function applyMaterialParams(material: OpenPBRMaterial, input: OpenPBRMaterialParams): void;
+export declare function materialDefault<K extends MaterialKey>(key: K): MaterialState[K];
+export declare function applyMaterialParams(material: MaterialState, input: MaterialStateParams): void;
 export declare function resetMaterialTextureId(): void;
-export declare function getMaterialHashKey(material: OpenPBRMaterial): string;
+export declare function getMaterialHashKey(material: MaterialState): string;
 export {};

package/lib/scene/openPbrSchema.js

@@ -1,4 +1,3 @@
-import Texture from './Texture.js';
 import { specularAnisotropyModelIndex } from './anisotropyParameters.js';
 import { thinFilmMapChannelIndex } from './thinFilmParameters.js';
 export const materialAliases = {
@@ -104,14 +103,23 @@ export const openPbrSchema = [
 ];
 const textureNamesMatch = true;
 void textureNamesMatch;
-export const materialKeys = openPbrSchema.map(field => field.key);
-function categoryKeys(category) {
-    return openPbrSchema.filter(field => field.category === category).map(field => field.key);
-}
-export const materialTextureKeys = categoryKeys('texture');
-export const materialGeometryKeys = categoryKeys('geometry');
-export const materialParamKeys = categoryKeys('param');
-const defaults = new Map(openPbrSchema.map(field => [field.key, field.default]));
+// Fixed tuple literals preserve the typed key-order contract in native builds;
+// satisfies checks every position against the schema at compile time.
+export const materialKeys = [
+    'baseWeight', 'baseColor', 'baseDiffuseRoughness', 'baseMetalness', 'specularWeight', 'specularColor', 'specularRoughness', 'specularIor', 'specularAnisotropy', 'transmissionWeight', 'transmissionColor', 'transmissionDepth', 'transmissionScatter', 'transmissionScatterAnisotropy', 'transmissionDispersionScale', 'transmissionDispersionAbbeNumber', 'subsurfaceWeight', 'subsurfaceColor', 'subsurfaceRadius', 'subsurfaceRadiusScale', 'subsurfaceAnisotropy', 'fuzzWeight', 'fuzzColor', 'fuzzRoughness', 'coatWeight', 'coatColor', 'coatRoughness', 'coatAnisotropy', 'coatIor', 'coatDarkening', 'thinFilmWeight', 'thinFilmThickness', 'thinFilmIor', 'emissionColor', 'emissionLuminance', 'opacity', 'thinWalled', 'doubleSided', 'map', 'alphaMap', 'alphaMode', 'alphaCutoff', 'emissiveMap', 'normalMap', 'normalScale', 'metallicRoughnessMap', 'roughnessMap', 'metalnessMap', 'transmissionMap', 'thinFilmMap', 'shadowCatcher', 'unlit', 'bevelSize', 'mapAlphaUsage', 'uvProjection', 'uvProjectionScale', 'displacementUvProjection', 'displacementUvProjectionScale', 'displacementMap', 'displacementScale', 'displacementStepSize', 'thinFilmThicknessMinimum', 'thinFilmMapChannel', 'coatWeightMap', 'coatRoughnessMap', 'fuzzColorMap', 'fuzzRoughnessMap', 'specularWeightMap', 'specularColorMap', 'anisotropyMap', 'specularAnisotropyRotation', 'coatAnisotropyRotation', 'specularAnisotropyModel', 'coatNormalMap', 'coatNormalScale', 'displacementBias'
+];
+export const materialTextureKeys = [
+    'map', 'alphaMap', 'emissiveMap', 'normalMap', 'metallicRoughnessMap', 'roughnessMap', 'metalnessMap', 'transmissionMap', 'thinFilmMap', 'displacementMap', 'coatWeightMap', 'coatRoughnessMap', 'fuzzColorMap', 'fuzzRoughnessMap', 'specularWeightMap', 'specularColorMap', 'anisotropyMap', 'coatNormalMap'
+];
+export const materialGeometryKeys = [
+    'displacementUvProjection', 'displacementUvProjectionScale', 'displacementScale', 'displacementStepSize', 'displacementBias'
+];
+export const materialParamKeys = [
+    'baseWeight', 'baseColor', 'baseDiffuseRoughness', 'baseMetalness', 'specularWeight', 'specularColor', 'specularRoughness', 'specularIor', 'specularAnisotropy', 'transmissionWeight', 'transmissionColor', 'transmissionDepth', 'transmissionScatter', 'transmissionScatterAnisotropy', 'transmissionDispersionScale', 'transmissionDispersionAbbeNumber', 'subsurfaceWeight', 'subsurfaceColor', 'subsurfaceRadius', 'subsurfaceRadiusScale', 'subsurfaceAnisotropy', 'fuzzWeight', 'fuzzColor', 'fuzzRoughness', 'coatWeight', 'coatColor', 'coatRoughness', 'coatAnisotropy', 'coatIor', 'coatDarkening', 'thinFilmWeight', 'thinFilmThickness', 'thinFilmIor', 'emissionColor', 'emissionLuminance', 'opacity', 'thinWalled', 'doubleSided', 'alphaMode', 'alphaCutoff', 'normalScale', 'shadowCatcher', 'unlit', 'bevelSize', 'mapAlphaUsage', 'uvProjection', 'uvProjectionScale', 'thinFilmThicknessMinimum', 'thinFilmMapChannel', 'specularAnisotropyRotation', 'coatAnisotropyRotation', 'specularAnisotropyModel', 'coatNormalScale'
+];
+const defaults = new Map();
+for (const field of openPbrSchema)
+    defaults.set(field.key, field.default);
 export function materialDefault(key) {
     const value = defaults.get(key);
     return (Array.isArray(value) ? value.slice() : value);
@@ -122,29 +130,266 @@ export function applyMaterialParams(material, input) {
         thinFilmMapChannelIndex(params.thinFilmMapChannel);
     if (params.specularAnisotropyModel !== undefined)
         specularAnisotropyModelIndex(params.specularAnisotropyModel);
-    for (const { key } of openPbrSchema) {
-        if (params[key] !== undefined)
-            Object.assign(material, { [key]: params[key] });
-    }
+    // Literal fields preserve assignment order without native class reflection.
+    if (params.baseWeight !== undefined)
+        material.baseWeight = params.baseWeight;
+    if (params.baseColor !== undefined)
+        material.baseColor = params.baseColor;
+    if (params.baseDiffuseRoughness !== undefined)
+        material.baseDiffuseRoughness = params.baseDiffuseRoughness;
+    if (params.baseMetalness !== undefined)
+        material.baseMetalness = params.baseMetalness;
+    if (params.specularWeight !== undefined)
+        material.specularWeight = params.specularWeight;
+    if (params.specularColor !== undefined)
+        material.specularColor = params.specularColor;
+    if (params.specularRoughness !== undefined)
+        material.specularRoughness = params.specularRoughness;
+    if (params.specularIor !== undefined)
+        material.specularIor = params.specularIor;
+    if (params.specularAnisotropy !== undefined)
+        material.specularAnisotropy = params.specularAnisotropy;
+    if (params.transmissionWeight !== undefined)
+        material.transmissionWeight = params.transmissionWeight;
+    if (params.transmissionColor !== undefined)
+        material.transmissionColor = params.transmissionColor;
+    if (params.transmissionDepth !== undefined)
+        material.transmissionDepth = params.transmissionDepth;
+    if (params.transmissionScatter !== undefined)
+        material.transmissionScatter = params.transmissionScatter;
+    if (params.transmissionScatterAnisotropy !== undefined)
+        material.transmissionScatterAnisotropy = params.transmissionScatterAnisotropy;
+    if (params.transmissionDispersionScale !== undefined)
+        material.transmissionDispersionScale = params.transmissionDispersionScale;
+    if (params.transmissionDispersionAbbeNumber !== undefined)
+        material.transmissionDispersionAbbeNumber = params.transmissionDispersionAbbeNumber;
+    if (params.subsurfaceWeight !== undefined)
+        material.subsurfaceWeight = params.subsurfaceWeight;
+    if (params.subsurfaceColor !== undefined)
+        material.subsurfaceColor = params.subsurfaceColor;
+    if (params.subsurfaceRadius !== undefined)
+        material.subsurfaceRadius = params.subsurfaceRadius;
+    if (params.subsurfaceRadiusScale !== undefined)
+        material.subsurfaceRadiusScale = params.subsurfaceRadiusScale;
+    if (params.subsurfaceAnisotropy !== undefined)
+        material.subsurfaceAnisotropy = params.subsurfaceAnisotropy;
+    if (params.fuzzWeight !== undefined)
+        material.fuzzWeight = params.fuzzWeight;
+    if (params.fuzzColor !== undefined)
+        material.fuzzColor = params.fuzzColor;
+    if (params.fuzzRoughness !== undefined)
+        material.fuzzRoughness = params.fuzzRoughness;
+    if (params.coatWeight !== undefined)
+        material.coatWeight = params.coatWeight;
+    if (params.coatColor !== undefined)
+        material.coatColor = params.coatColor;
+    if (params.coatRoughness !== undefined)
+        material.coatRoughness = params.coatRoughness;
+    if (params.coatAnisotropy !== undefined)
+        material.coatAnisotropy = params.coatAnisotropy;
+    if (params.coatIor !== undefined)
+        material.coatIor = params.coatIor;
+    if (params.coatDarkening !== undefined)
+        material.coatDarkening = params.coatDarkening;
+    if (params.thinFilmWeight !== undefined)
+        material.thinFilmWeight = params.thinFilmWeight;
+    if (params.thinFilmThickness !== undefined)
+        material.thinFilmThickness = params.thinFilmThickness;
+    if (params.thinFilmIor !== undefined)
+        material.thinFilmIor = params.thinFilmIor;
+    if (params.emissionColor !== undefined)
+        material.emissionColor = params.emissionColor;
+    if (params.emissionLuminance !== undefined)
+        material.emissionLuminance = params.emissionLuminance;
+    if (params.opacity !== undefined)
+        material.opacity = params.opacity;
+    if (params.thinWalled !== undefined)
+        material.thinWalled = params.thinWalled;
+    if (params.doubleSided !== undefined)
+        material.doubleSided = params.doubleSided;
+    if (params.map !== undefined)
+        material.map = params.map;
+    if (params.alphaMap !== undefined)
+        material.alphaMap = params.alphaMap;
+    if (params.alphaMode !== undefined)
+        material.alphaMode = params.alphaMode;
+    if (params.alphaCutoff !== undefined)
+        material.alphaCutoff = params.alphaCutoff;
+    if (params.emissiveMap !== undefined)
+        material.emissiveMap = params.emissiveMap;
+    if (params.normalMap !== undefined)
+        material.normalMap = params.normalMap;
+    if (params.normalScale !== undefined)
+        material.normalScale = params.normalScale;
+    if (params.metallicRoughnessMap !== undefined)
+        material.metallicRoughnessMap = params.metallicRoughnessMap;
+    if (params.roughnessMap !== undefined)
+        material.roughnessMap = params.roughnessMap;
+    if (params.metalnessMap !== undefined)
+        material.metalnessMap = params.metalnessMap;
+    if (params.transmissionMap !== undefined)
+        material.transmissionMap = params.transmissionMap;
+    if (params.thinFilmMap !== undefined)
+        material.thinFilmMap = params.thinFilmMap;
+    if (params.shadowCatcher !== undefined)
+        material.shadowCatcher = params.shadowCatcher;
+    if (params.unlit !== undefined)
+        material.unlit = params.unlit;
+    if (params.bevelSize !== undefined)
+        material.bevelSize = params.bevelSize;
+    if (params.mapAlphaUsage !== undefined)
+        material.mapAlphaUsage = params.mapAlphaUsage;
+    if (params.uvProjection !== undefined)
+        material.uvProjection = params.uvProjection;
+    if (params.uvProjectionScale !== undefined)
+        material.uvProjectionScale = params.uvProjectionScale;
+    if (params.displacementUvProjection !== undefined)
+        material.displacementUvProjection = params.displacementUvProjection;
+    if (params.displacementUvProjectionScale !== undefined)
+        material.displacementUvProjectionScale = params.displacementUvProjectionScale;
+    if (params.displacementMap !== undefined)
+        material.displacementMap = params.displacementMap;
+    if (params.displacementScale !== undefined)
+        material.displacementScale = params.displacementScale;
+    if (params.displacementBias !== undefined)
+        material.displacementBias = params.displacementBias;
+    if (params.displacementStepSize !== undefined)
+        material.displacementStepSize = params.displacementStepSize;
+    if (params.thinFilmThicknessMinimum !== undefined)
+        material.thinFilmThicknessMinimum = params.thinFilmThicknessMinimum;
+    if (params.thinFilmMapChannel !== undefined)
+        material.thinFilmMapChannel = params.thinFilmMapChannel;
+    if (params.coatWeightMap !== undefined)
+        material.coatWeightMap = params.coatWeightMap;
+    if (params.coatRoughnessMap !== undefined)
+        material.coatRoughnessMap = params.coatRoughnessMap;
+    if (params.fuzzColorMap !== undefined)
+        material.fuzzColorMap = params.fuzzColorMap;
+    if (params.fuzzRoughnessMap !== undefined)
+        material.fuzzRoughnessMap = params.fuzzRoughnessMap;
+    if (params.specularWeightMap !== undefined)
+        material.specularWeightMap = params.specularWeightMap;
+    if (params.specularColorMap !== undefined)
+        material.specularColorMap = params.specularColorMap;
+    if (params.anisotropyMap !== undefined)
+        material.anisotropyMap = params.anisotropyMap;
+    if (params.specularAnisotropyRotation !== undefined)
+        material.specularAnisotropyRotation = params.specularAnisotropyRotation;
+    if (params.coatAnisotropyRotation !== undefined)
+        material.coatAnisotropyRotation = params.coatAnisotropyRotation;
+    if (params.specularAnisotropyModel !== undefined)
+        material.specularAnisotropyModel = params.specularAnisotropyModel;
+    if (params.coatNormalMap !== undefined)
+        material.coatNormalMap = params.coatNormalMap;
+    if (params.coatNormalScale !== undefined)
+        material.coatNormalScale = params.coatNormalScale;
 }
 let textureId = 1;
 const textureWeakMap = new WeakMap();
 export function resetMaterialTextureId() { textureId = 1; }
+function hashScalar(value) {
+    return value == null ? '$' : String(value);
+}
+function hashColor(value) {
+    return value == null ? '$' : [value[0], value[1], value[2]].join('_');
+}
+function hashVec2(value) {
+    if (value == null)
+        return '$';
+    if (value instanceof Float32Array) {
+        const values = [];
+        for (let i = 0; i < value.length; i++)
+            values.push(value[i]);
+        return values.join('_');
+    }
+    return [value[0], value[1]].join('_');
+}
+function hashTexture(value) {
+    if (!value)
+        return '$';
+    if (!textureWeakMap.has(value))
+        textureWeakMap.set(value, textureId++);
+    return `${textureWeakMap.get(value)}@${value.version}`;
+}
 export function getMaterialHashKey(material) {
-    return openPbrSchema.map(({ key }) => {
-        const value = material[key];
-        if (value == null)
-            return '$';
-        if (value instanceof Texture) {
-            if (!textureWeakMap.has(value))
-                textureWeakMap.set(value, textureId++);
-            return `${textureWeakMap.get(value)}@${value.version}`;
-        }
-        if (typeof value === 'string')
-            return value;
-        if (typeof value === 'object' && 'length' in value)
-            return Array.from(value).join('_');
-        return value;
-    }).join('_');
+    // Match schema order without constructing a heterogeneous native value union.
+    return [
+        hashScalar(material.baseWeight),
+        hashColor(material.baseColor),
+        hashScalar(material.baseDiffuseRoughness),
+        hashScalar(material.baseMetalness),
+        hashScalar(material.specularWeight),
+        hashColor(material.specularColor),
+        hashScalar(material.specularRoughness),
+        hashScalar(material.specularIor),
+        hashScalar(material.specularAnisotropy),
+        hashScalar(material.transmissionWeight),
+        hashColor(material.transmissionColor),
+        hashScalar(material.transmissionDepth),
+        hashColor(material.transmissionScatter),
+        hashScalar(material.transmissionScatterAnisotropy),
+        hashScalar(material.transmissionDispersionScale),
+        hashScalar(material.transmissionDispersionAbbeNumber),
+        hashScalar(material.subsurfaceWeight),
+        hashColor(material.subsurfaceColor),
+        hashScalar(material.subsurfaceRadius),
+        hashColor(material.subsurfaceRadiusScale),
+        hashScalar(material.subsurfaceAnisotropy),
+        hashScalar(material.fuzzWeight),
+        hashColor(material.fuzzColor),
+        hashScalar(material.fuzzRoughness),
+        hashScalar(material.coatWeight),
+        hashColor(material.coatColor),
+        hashScalar(material.coatRoughness),
+        hashScalar(material.coatAnisotropy),
+        hashScalar(material.coatIor),
+        hashScalar(material.coatDarkening),
+        hashScalar(material.thinFilmWeight),
+        hashScalar(material.thinFilmThickness),
+        hashScalar(material.thinFilmIor),
+        hashColor(material.emissionColor),
+        hashScalar(material.emissionLuminance),
+        hashScalar(material.opacity),
+        hashScalar(material.thinWalled),
+        hashScalar(material.doubleSided),
+        hashTexture(material.map),
+        hashTexture(material.alphaMap),
+        hashScalar(material.alphaMode),
+        hashScalar(material.alphaCutoff),
+        hashTexture(material.emissiveMap),
+        hashTexture(material.normalMap),
+        hashVec2(material.normalScale),
+        hashTexture(material.metallicRoughnessMap),
+        hashTexture(material.roughnessMap),
+        hashTexture(material.metalnessMap),
+        hashTexture(material.transmissionMap),
+        hashTexture(material.thinFilmMap),
+        hashScalar(material.shadowCatcher),
+        hashScalar(material.unlit),
+        hashScalar(material.bevelSize),
+        hashScalar(material.mapAlphaUsage),
+        hashScalar(material.uvProjection),
+        hashVec2(material.uvProjectionScale),
+        hashScalar(material.displacementUvProjection),
+        hashScalar(material.displacementUvProjectionScale),
+        hashTexture(material.displacementMap),
+        hashScalar(material.displacementScale),
+        hashScalar(material.displacementStepSize),
+        hashScalar(material.thinFilmThicknessMinimum),
+        hashScalar(material.thinFilmMapChannel),
+        hashTexture(material.coatWeightMap),
+        hashTexture(material.coatRoughnessMap),
+        hashTexture(material.fuzzColorMap),
+        hashTexture(material.fuzzRoughnessMap),
+        hashTexture(material.specularWeightMap),
+        hashTexture(material.specularColorMap),
+        hashTexture(material.anisotropyMap),
+        hashScalar(material.specularAnisotropyRotation),
+        hashScalar(material.coatAnisotropyRotation),
+        hashScalar(material.specularAnisotropyModel),
+        hashTexture(material.coatNormalMap),
+        hashVec2(material.coatNormalScale),
+        hashScalar(material.displacementBias),
+    ].join('_');
 }
 //# sourceMappingURL=openPbrSchema.js.map