@babylonjs/loaders 9.26.0 → 9.26.1

package/FBX/interpreter/materialModel.js

@@ -0,0 +1,622 @@
+var Flag;
+(function (Flag) {
+    Flag[Flag["DefaultW1"] = 1] = "DefaultW1";
+    Flag[Flag["WidenToRgb"] = 2] = "WidenToRgb";
+    Flag[Flag["MultiplyValue"] = 4] = "MultiplyValue";
+})(Flag || (Flag = {}));
+var Transform;
+(function (Transform) {
+    Transform[Transform["None"] = 0] = "None";
+    Transform[Transform["InvertX"] = 1] = "InvertX";
+    Transform[Transform["UnknownShininess"] = 2] = "UnknownShininess";
+})(Transform || (Transform = {}));
+var FeatureFlag;
+(function (FeatureFlag) {
+    FeatureFlag[FeatureFlag["Inverted"] = 1] = "Inverted";
+    FeatureFlag[FeatureFlag["IfExists"] = 2] = "IfExists";
+    FeatureFlag[FeatureFlag["IfTexture"] = 4] = "IfTexture";
+    FeatureFlag[FeatureFlag["IfAround1"] = 8] = "IfAround1";
+})(FeatureFlag || (FeatureFlag = {}));
+const BASE_FBX = [
+    ["diffuseColor", 1 /* Flag.DefaultW1 */, 0, "Diffuse"],
+    ["diffuseColor", 1 /* Flag.DefaultW1 */, 0, "DiffuseColor"],
+    ["diffuseFactor", 0, 0, "DiffuseFactor"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "Specular"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "SpecularColor"],
+    ["specularFactor", 0, 0, "SpecularFactor"],
+    ["specularExponent", 0, 0, "Shininess"],
+    ["specularExponent", 0, 0, "ShininessExponent"],
+    ["reflectionColor", 1 /* Flag.DefaultW1 */, 0, "Reflection"],
+    ["reflectionColor", 1 /* Flag.DefaultW1 */, 0, "ReflectionColor"],
+    ["reflectionFactor", 0, 0, "ReflectionFactor"],
+    ["transparencyColor", 1 /* Flag.DefaultW1 */, 0, "Transparent"],
+    ["transparencyColor", 1 /* Flag.DefaultW1 */, 0, "TransparentColor"],
+    ["transparencyFactor", 0, 0, "TransparentFactor"],
+    ["transparencyFactor", 0, 0, "TransparencyFactor"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "Emissive"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "EmissiveColor"],
+    ["emissionFactor", 0, 0, "EmissiveFactor"],
+    ["ambientColor", 1 /* Flag.DefaultW1 */, 0, "Ambient"],
+    ["ambientColor", 1 /* Flag.DefaultW1 */, 0, "AmbientColor"],
+    ["ambientFactor", 0, 0, "AmbientFactor"],
+    ["normalMap", 0, 0, "NormalMap"],
+    ["bump", 0, 0, "Bump"],
+    ["bumpFactor", 0, 0, "BumpFactor"],
+    ["displacement", 0, 0, "Displacement"],
+    ["displacementFactor", 0, 0, "DisplacementFactor"],
+    ["vectorDisplacement", 0, 0, "VectorDisplacement"],
+    ["vectorDisplacementFactor", 0, 0, "VectorDisplacementFactor"],
+];
+const LAMBERT_PBR = [
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "Diffuse"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "DiffuseColor"],
+    ["baseFactor", 0, 0, "DiffuseFactor"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "Transparent"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "TransparentColor"],
+    ["transmissionFactor", 0, 0, "TransparentFactor"],
+    ["transmissionFactor", 0, 0, "TransparencyFactor"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "Emissive"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "EmissiveColor"],
+    ["emissionFactor", 0, 0, "EmissiveFactor"],
+    ["normalMap", 0, 0, "NormalMap"],
+];
+const PHONG_PBR = [
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "Diffuse"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "DiffuseColor"],
+    ["baseFactor", 0, 0, "DiffuseFactor"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "Specular"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "SpecularColor"],
+    ["specularFactor", 0, 0, "SpecularFactor"],
+    ["roughness", 0, 2 /* Transform.UnknownShininess */, "Shininess"],
+    ["roughness", 0, 2 /* Transform.UnknownShininess */, "ShininessExponent"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "Transparent"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "TransparentColor"],
+    ["transmissionFactor", 0, 0, "TransparentFactor"],
+    ["transmissionFactor", 0, 0, "TransparencyFactor"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "Emissive"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "EmissiveColor"],
+    ["emissionFactor", 0, 0, "EmissiveFactor"],
+    ["normalMap", 0, 0, "NormalMap"],
+];
+const OSL_PBR = [
+    ["baseFactor", 0, 0, "base"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "base_color"],
+    ["roughness", 0, 0, "specular_roughness"],
+    ["diffuseRoughness", 0, 0, "diffuse_roughness"],
+    ["metalness", 0, 0, "metalness"],
+    ["specularFactor", 0, 0, "specular"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "specular_color"],
+    ["specularIor", 0, 0, "specular_IOR"],
+    ["specularAnisotropy", 0, 0, "specular_anisotropy"],
+    ["specularRotation", 0, 0, "specular_rotation"],
+    ["transmissionFactor", 0, 0, "transmission"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "transmission_color"],
+    ["transmissionDepth", 0, 0, "transmission_depth"],
+    ["transmissionScatter", 2 /* Flag.WidenToRgb */, 0, "transmission_scatter"],
+    ["transmissionScatterAnisotropy", 0, 0, "transmission_scatter_anisotropy"],
+    ["transmissionDispersion", 0, 0, "transmission_dispersion"],
+    ["transmissionExtraRoughness", 0, 0, "transmission_extra_roughness"],
+    ["subsurfaceFactor", 0, 0, "subsurface"],
+    ["subsurfaceColor", 1 /* Flag.DefaultW1 */, 0, "subsurface_color"],
+    ["subsurfaceRadius", 2 /* Flag.WidenToRgb */, 0, "subsurface_radius"],
+    ["subsurfaceScale", 0, 0, "subsurface_scale"],
+    ["subsurfaceAnisotropy", 0, 0, "subsurface_anisotropy"],
+    ["sheenFactor", 0, 0, "sheen"],
+    ["sheenColor", 1 /* Flag.DefaultW1 */, 0, "sheen_color"],
+    ["sheenRoughness", 0, 0, "sheen_roughness"],
+    ["coatFactor", 0, 0, "coat"],
+    ["coatColor", 1 /* Flag.DefaultW1 */, 0, "coat_color"],
+    ["coatRoughness", 0, 0, "coat_roughness"],
+    ["coatIor", 0, 0, "coat_IOR"],
+    ["coatAnisotropy", 0, 0, "coat_anisotropy"],
+    ["coatRotation", 0, 0, "coat_rotation"],
+    ["coatNormal", 0, 0, "coat_normal"],
+    ["coatAffectBaseColor", 1 /* Flag.DefaultW1 */, 0, "coat_affect_color"],
+    ["coatAffectBaseRoughness", 0, 0, "coat_affect_roughness"],
+    ["thinFilmThickness", 0, 0, "thin_film_thickness"],
+    ["thinFilmIor", 0, 0, "thin_film_IOR"],
+    ["emissionFactor", 0, 0, "emission"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "emission_color"],
+    ["opacity", 2 /* Flag.WidenToRgb */, 0, "opacity"],
+    ["normalMap", 0, 0, "NormalMap"],
+    ["normalMap", 0, 0, "normalCamera"],
+    ["tangentMap", 0, 0, "tangent"],
+];
+const OSL_FEATURES = [["thinWalled", 0, "thin_walled"]];
+const ARNOLD_PBR = [
+    ["baseFactor", 0, 0, "base"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "baseColor"],
+    ["roughness", 0, 0, "specularRoughness"],
+    ["diffuseRoughness", 0, 0, "diffuseRoughness"],
+    ["metalness", 0, 0, "metalness"],
+    ["specularFactor", 0, 0, "specular"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "specularColor"],
+    ["specularIor", 0, 0, "specularIOR"],
+    ["specularAnisotropy", 0, 0, "specularAnisotropy"],
+    ["specularRotation", 0, 0, "specularRotation"],
+    ["transmissionFactor", 0, 0, "transmission"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "transmissionColor"],
+    ["transmissionDepth", 0, 0, "transmissionDepth"],
+    ["transmissionScatter", 2 /* Flag.WidenToRgb */, 0, "transmissionScatter"],
+    ["transmissionScatterAnisotropy", 0, 0, "transmissionScatterAnisotropy"],
+    ["transmissionDispersion", 0, 0, "transmissionDispersion"],
+    ["transmissionExtraRoughness", 0, 0, "transmissionExtraRoughness"],
+    ["subsurfaceFactor", 0, 0, "subsurface"],
+    ["subsurfaceColor", 1 /* Flag.DefaultW1 */, 0, "subsurfaceColor"],
+    ["subsurfaceRadius", 2 /* Flag.WidenToRgb */, 0, "subsurfaceRadius"],
+    ["subsurfaceScale", 0, 0, "subsurfaceScale"],
+    ["subsurfaceAnisotropy", 0, 0, "subsurfaceAnisotropy"],
+    ["sheenFactor", 0, 0, "sheen"],
+    ["sheenColor", 1 /* Flag.DefaultW1 */, 0, "sheenColor"],
+    ["sheenRoughness", 0, 0, "sheenRoughness"],
+    ["coatFactor", 0, 0, "coat"],
+    ["coatColor", 1 /* Flag.DefaultW1 */, 0, "coatColor"],
+    ["coatRoughness", 0, 0, "coatRoughness"],
+    ["coatIor", 0, 0, "coatIOR"],
+    ["coatAnisotropy", 0, 0, "coatAnisotropy"],
+    ["coatRotation", 0, 0, "coatRotation"],
+    ["coatNormal", 0, 0, "coatNormal"],
+    ["thinFilmThickness", 0, 0, "thinFilmThickness"],
+    ["thinFilmIor", 0, 0, "thinFilmIOR"],
+    ["emissionFactor", 0, 0, "emission"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "emissionColor"],
+    ["opacity", 2 /* Flag.WidenToRgb */, 0, "opacity"],
+    ["indirectDiffuse", 0, 0, "indirectDiffuse"],
+    ["indirectSpecular", 0, 0, "indirectSpecular"],
+    ["normalMap", 0, 0, "NormalMap"],
+    ["normalMap", 0, 0, "normalCamera"],
+    ["tangentMap", 0, 0, "tangent"],
+    ["matteColor", 1 /* Flag.DefaultW1 */, 0, "aiMatteColor"],
+    ["matteFactor", 0, 0, "aiMatteColorA"],
+    ["subsurfaceType", 0, 0, "subsurfaceType"],
+    ["transmissionPriority", 0, 0, "dielectricPriority"],
+    ["transmissionEnableInAov", 0, 0, "transmitAovs"],
+];
+const ARNOLD_FEATURES = [
+    ["matte", 0, "aiEnableMatte"],
+    ["thinWalled", 0, "thinWalled"],
+    ["caustics", 0, "caustics"],
+    ["internalReflections", 0, "internalReflections"],
+    ["exitToBackground", 0, "exitToBackground"],
+];
+const MAX_PHYSICAL_PBR = [
+    ["baseFactor", 0, 0, "base_weight"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "base_color"],
+    ["roughness", 0, 0, "roughness"],
+    ["diffuseRoughness", 0, 0, "diff_rough"],
+    ["diffuseRoughness", 0, 0, "diff_roughness"],
+    ["metalness", 0, 0, "metalness"],
+    ["specularFactor", 0, 0, "reflectivity"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "refl_color"],
+    ["specularAnisotropy", 0, 0, "anisotropy"],
+    ["specularRotation", 0, 0, "aniso_angle"],
+    ["specularRotation", 0, 0, "anisoangle"],
+    ["specularIor", 0, 0, "trans_ior"],
+    ["transmissionFactor", 0, 0, "transparency"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "trans_color"],
+    ["transmissionDepth", 0, 0, "trans_depth"],
+    ["transmissionRoughness", 0, 0, "trans_rough"],
+    ["transmissionRoughness", 0, 0, "trans_roughness"],
+    ["subsurfaceFactor", 0, 0, "scattering"],
+    ["subsurfaceTintColor", 1 /* Flag.DefaultW1 */, 0, "sss_color"],
+    ["subsurfaceColor", 1 /* Flag.DefaultW1 */, 0, "sss_scatter_color"],
+    ["subsurfaceRadius", 2 /* Flag.WidenToRgb */, 0, "sss_depth"],
+    ["subsurfaceScale", 0, 0, "sss_scale"],
+    ["coatFactor", 0, 0, "coat"],
+    ["coatFactor", 0, 0, "coating"],
+    ["coatColor", 1 /* Flag.DefaultW1 */, 0, "coat_color"],
+    ["coatRoughness", 0, 0, "coat_rough"],
+    ["coatRoughness", 0, 0, "coat_roughness"],
+    ["coatIor", 0, 0, "coat_ior"],
+    ["coatNormal", 0, 0, "coat_bump"],
+    ["coatNormal", 0, 0, "clearcoat_bump_map_amt"],
+    ["coatAffectBaseColor", 1 /* Flag.DefaultW1 */, 0, "coat_affect_color"],
+    ["coatAffectBaseRoughness", 0, 0, "coat_affect_roughness"],
+    ["emissionFactor", 0, 0, "emission"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "emit_color"],
+    ["opacity", 2 /* Flag.WidenToRgb */, 0, "cutout"],
+    ["normalMap", 0, 0, "bump"],
+    ["normalMap", 0, 0, "bump_map_amt"],
+    ["displacementMap", 0, 0, "displacement"],
+    ["displacementMap", 0, 0, "displacement_map_amt"],
+    ["subsurfaceType", 0, 0, "subsurfaceType"],
+];
+const MAX_PHYSICAL_FEATURES = [
+    ["thinWalled", 0, "thin_walled"],
+    ["specular", 0, "material_mode"],
+    ["diffuseRoughness", 0, "material_mode"],
+    ["transmissionRoughness", 1 /* FeatureFlag.Inverted */, "trans_roughness_lock"],
+    ["roughnessAsGlossiness", 0, "roughness_inv"],
+    ["transmissionRoughnessAsGlossiness", 0, "trans_roughness_inv"],
+    ["coatRoughnessAsGlossiness", 0, "coat_roughness_inv"],
+];
+const GLTF_PBR = [
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "main|baseColor"],
+    ["roughness", 0, 0, "main|roughness"],
+    ["metalness", 0, 0, "main|metalness"],
+    ["normalMap", 0, 0, "main|normal"],
+    ["ambientOcclusion", 0, 0, "main|ambientOcclusion"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "main|emission"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "main|emissionColor"],
+    ["opacity", 2 /* Flag.WidenToRgb */, 0, "main|Alpha"],
+    ["coatFactor", 0, 0, "extension|clearcoat"],
+    ["coatRoughness", 0, 0, "extension|clearcoatRoughness"],
+    ["coatNormal", 0, 0, "extension|clearcoatNormal"],
+    ["sheenColor", 1 /* Flag.DefaultW1 */, 0, "extension|sheenColor"],
+    ["sheenRoughness", 0, 0, "extension|sheenRoughness"],
+    ["specularFactor", 0, 0, "extension|specular"],
+    ["specularFactor", 0, 0, "extension|Specular"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "extension|specularcolor"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "extension|specularColor"],
+    ["transmissionFactor", 0, 0, "extension|transmission"],
+    ["specularIor", 0, 0, "extension|indexOfRefraction"],
+];
+const GLTF_FEATURES = [
+    ["doubleSided", 0, "main|DoubleSided"],
+    ["sheen", 0, "extension|enableSheen"],
+    ["coat", 0, "extension|enableClearCoat"],
+    ["transmission", 0, "extension|enableTransmission"],
+    ["ior", 0, "extension|enableIndexOfRefraction"],
+    ["specular", 0, "extension|enableSpecular"],
+    ["unlit", 0, "extension|unlit"],
+];
+const OPENPBR_PBR = [
+    ["baseFactor", 0, 0, "base_weight"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "base_color"],
+    ["roughness", 0, 0, "specular_roughness"],
+    ["diffuseRoughness", 0, 0, "base_diffuse_roughness"],
+    ["metalness", 0, 0, "base_metalness"],
+    ["specularFactor", 0, 0, "specular_weight"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "specular_color"],
+    ["specularAnisotropy", 0, 0, "specular_roughness_anisotropy"],
+    ["specularIor", 0, 0, "specular_ior"],
+    ["transmissionFactor", 0, 0, "transmission_weight"],
+    ["transmissionColor", 1 /* Flag.DefaultW1 */, 0, "transmission_color"],
+    ["transmissionDepth", 0, 0, "transmission_depth"],
+    ["transmissionScatter", 2 /* Flag.WidenToRgb */, 0, "transmission_scatter"],
+    ["transmissionScatterAnisotropy", 0, 0, "transmission_scatter_anisotropy"],
+    ["transmissionDispersion", 0, 0, "transmission_dispersion_scale"],
+    ["subsurfaceFactor", 0, 0, "subsurface_weight"],
+    ["subsurfaceColor", 1 /* Flag.DefaultW1 */, 0, "subsurface_color"],
+    ["subsurfaceRadius", 2 /* Flag.WidenToRgb */, 0, "subsurface_radius_scale"],
+    ["subsurfaceScale", 0, 0, "subsurface_radius"],
+    ["subsurfaceAnisotropy", 0, 0, "subsurface_scatter_anisotropy"],
+    ["coatFactor", 0, 0, "coat_weight"],
+    ["coatColor", 1 /* Flag.DefaultW1 */, 0, "coat_color"],
+    ["coatRoughness", 0, 0, "coat_roughness"],
+    ["coatAnisotropy", 0, 0, "coat_roughness_anisotropy"],
+    ["coatIor", 0, 0, "coat_ior"],
+    ["coatNormal", 0, 0, "coat_normal_map"],
+    ["sheenFactor", 0, 0, "fuzz_weight"],
+    ["sheenColor", 1 /* Flag.DefaultW1 */, 0, "fuzz_color"],
+    ["sheenRoughness", 0, 0, "fuzz_roughness"],
+    ["emissionFactor", 0, 0, "emission_weight"],
+    ["emissionFactor", 4 /* Flag.MultiplyValue */, 0, "emission_luminance"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "emission_color"],
+    ["thinFilmFactor", 0, 0, "thin_film_weight"],
+    ["thinFilmThickness", 0, 0, "thin_film_thickness"],
+    ["thinFilmIor", 0, 0, "thin_film_ior"],
+    ["normalMap", 0, 0, "bump"],
+    ["normalMap", 0, 0, "bump_map_amt"],
+    ["displacementMap", 0, 0, "displacement"],
+    ["displacementMap", 0, 0, "displacement_map_amt"],
+    ["coatNormal", 0, 0, "coat_bump"],
+    ["coatNormal", 0, 0, "coat_bump_map_amt"],
+    ["tangentMap", 0, 0, "geometry_tangent_map"],
+    ["opacity", 2 /* Flag.WidenToRgb */, 0, "geometry_opacity"],
+];
+const OPENPBR_FEATURES = [["thinWalled", 0, "geometry_thin_walled"]];
+const MAX_METAL_ROUGH_PBR = [
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "base_color"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "baseColor"],
+    ["roughness", 0, 0, "roughness"],
+    ["roughness", 0, 0, "Roughness_Map"],
+    ["metalness", 0, 0, "metalness"],
+    ["ambientOcclusion", 0, 0, "ao"],
+    ["normalMap", 0, 0, "norm"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "emit_color"],
+    ["displacementMap", 0, 0, "displacement"],
+    ["displacementMap", 0, 0, "displacement_amt"],
+    ["opacity", 2 /* Flag.WidenToRgb */, 0, "opacity"],
+];
+const MAX_SPEC_GLOSS_PBR = [
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "base_color"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "baseColor"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "Specular"],
+    ["specularColor", 1 /* Flag.DefaultW1 */, 0, "specular"],
+    ["roughness", 0, 0, "glossiness"],
+    ["ambientOcclusion", 0, 0, "ao"],
+    ["normalMap", 0, 0, "norm"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "emit_color"],
+    ["displacementMap", 0, 0, "displacement"],
+    ["displacementMap", 0, 0, "displacement_amt"],
+    ["opacity", 2 /* Flag.WidenToRgb */, 0, "opacity"],
+];
+const MAX_PBR_FEATURES = [["roughnessAsGlossiness", 8 /* FeatureFlag.IfAround1 */, "useGlossiness"]];
+const SHADERFX_PBR = [
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "color"],
+    ["baseColor", 1 /* Flag.DefaultW1 */, 0, "base_color"],
+    ["roughness", 0, 0, "roughness"],
+    ["metalness", 0, 0, "metallic"],
+    ["normalMap", 0, 0, "normal"],
+    ["emissionFactor", 0, 0, "emissive_intensity"],
+    ["emissionColor", 1 /* Flag.DefaultW1 */, 0, "emissive"],
+    ["ambientOcclusion", 0, 0, "ao"],
+];
+const PBR_COMMON = ["pbr", "metalness", "diffuse", "specular", "coat", "sheen", "transmission", "opacity", "ior", "diffuseRoughness"];
+const SHADER_TABLES = {
+    unknown: { maps: PHONG_PBR, features: [], defaultFeatures: ["diffuse", "specular", "emission", "transmission"] },
+    fbxLambert: { maps: LAMBERT_PBR, features: [], defaultFeatures: ["diffuse", "emission", "transmission"] },
+    fbxPhong: { maps: PHONG_PBR, features: [], defaultFeatures: ["diffuse", "specular", "emission", "transmission"] },
+    oslStandardSurface: { maps: OSL_PBR, features: OSL_FEATURES, defaultFeatures: PBR_COMMON },
+    arnoldStandardSurface: { maps: ARNOLD_PBR, features: ARNOLD_FEATURES, defaultFeatures: PBR_COMMON },
+    "3dsMaxPhysicalMaterial": {
+        maps: MAX_PHYSICAL_PBR,
+        features: MAX_PHYSICAL_FEATURES,
+        defaultFeatures: ["pbr", "metalness", "diffuse", "coat", "sheen", "transmission", "opacity", "ior"],
+        textureSuffix: "_map",
+        textureEnabledSuffix: "_map_on",
+    },
+    "3dsMaxPbrMetalRough": { maps: MAX_METAL_ROUGH_PBR, features: MAX_PBR_FEATURES, defaultFeatures: ["pbr", "metalness", "diffuse", "opacity"], textureSuffix: "_map" },
+    "3dsMaxPbrSpecGloss": { maps: MAX_SPEC_GLOSS_PBR, features: MAX_PBR_FEATURES, defaultFeatures: ["pbr", "specular", "diffuse", "opacity"], textureSuffix: "_map" },
+    gltfMaterial: {
+        maps: GLTF_PBR,
+        features: GLTF_FEATURES,
+        defaultFeatures: ["pbr", "metalness", "diffuse", "emission", "opacity", "ambientOcclusion"],
+        textureSuffix: "Map",
+    },
+    openPbrMaterial: { maps: OPENPBR_PBR, features: OPENPBR_FEATURES, defaultFeatures: PBR_COMMON, textureSuffix: "_map", textureEnabledSuffix: "_map_on" },
+    shaderFxGraph: {
+        maps: SHADERFX_PBR,
+        features: [],
+        defaultFeatures: ["pbr", "metalness", "diffuse", "emission", "ambientOcclusion"],
+        texturePrefix: "TEX_",
+        textureSuffix: "_map",
+        textureEnabledPrefix: "use_",
+        textureEnabledSuffix: "_map",
+    },
+};
+/** Shader types whose parameters are physically based; the loader emits PBR materials for them by default. */
+export function isPbrShaderType(type) {
+    return type !== "unknown" && type !== "fbxLambert" && type !== "fbxPhong";
+}
+function applyTransform(transform, v) {
+    switch (transform) {
+        case 1 /* Transform.InvertX */:
+            v[0] = 1 - v[0];
+            break;
+        case 2 /* Transform.UnknownShininess */:
+            // Roughness from a Phong exponent, the same heuristic the FBX SDK / ufbx uses.
+            if (v[0] >= 0) {
+                v[0] = 1 - Math.sqrt(v[0]) * 0.1;
+                if (v[0] < 0) {
+                    v[0] = 0;
+                }
+            }
+            break;
+        default:
+            break;
+    }
+}
+function numericValues(values) {
+    const out = [];
+    for (const v of values) {
+        if (typeof v === "number") {
+            out.push(v);
+        }
+        else if (typeof v === "boolean") {
+            out.push(v ? 1 : 0);
+        }
+        else {
+            break;
+        }
+    }
+    return out;
+}
+/** Detects the shader flavour of a material from its shading model name, connected shader and 3ds Max class ids. */
+export function detectShaderType(source) {
+    let shaderType = "unknown";
+    const model = source.shadingModelName.toLowerCase();
+    if (model === "lambert") {
+        shaderType = "fbxLambert";
+    }
+    else if (model === "phong") {
+        shaderType = "fbxPhong";
+    }
+    if (source.shader) {
+        switch (source.shader.renderApi) {
+            case "ARNOLD_SHADER_ID":
+                return { shaderType: "arnoldStandardSurface", shaderPropPrefix: "" };
+            case "OSL":
+                return { shaderType: "oslStandardSurface", shaderPropPrefix: "" };
+            case "SFX_PBS_SHADER":
+                return { shaderType: "shaderFxGraph", shaderPropPrefix: "" };
+            default:
+                return { shaderType: "unknown", shaderPropPrefix: "" };
+        }
+    }
+    if (shaderType === "unknown") {
+        const a = (numericValues(source.props.get("3dsMax|ClassIDa")?.values ?? [])[0] ?? 0) >>> 0;
+        const b = (numericValues(source.props.get("3dsMax|ClassIDb")?.values ?? [])[0] ?? 0) >>> 0;
+        if (a === 0x3d6b1cec && b === 0xdeadc001) {
+            return { shaderType: "3dsMaxPhysicalMaterial", shaderPropPrefix: "3dsMax|Parameters|" };
+        }
+        if (a === 0xf1551e33 && b === 0x37fb1337) {
+            return { shaderType: "openPbrMaterial", shaderPropPrefix: "3dsMax|Parameters|" };
+        }
+        if (a === 0x38420192 && b === 0x45fe4e1b) {
+            return { shaderType: "gltfMaterial", shaderPropPrefix: "3dsMax|" };
+        }
+        if (a === 0xd00f1e00 && b === 0xbe77e500) {
+            return { shaderType: "3dsMaxPbrMetalRough", shaderPropPrefix: "3dsMax|main|" };
+        }
+        if (a === 0xd00f1e00 && b === 0x01dbad33) {
+            return { shaderType: "3dsMaxPbrSpecGloss", shaderPropPrefix: "3dsMax|main|" };
+        }
+    }
+    return { shaderType, shaderPropPrefix: "" };
+}
+/**
+ * Resolves the unified material model from raw material data.
+ */
+export function resolveMaterialModel(source) {
+    var _a;
+    const { shaderType, shaderPropPrefix } = detectShaderType(source);
+    const table = SHADER_TABLES[shaderType];
+    const model = { shaderType, shaderPropPrefix, fbx: {}, pbr: {}, features: {} };
+    for (const f of table.defaultFeatures) {
+        model.features[f] = { enabled: true, explicit: false };
+    }
+    const materialPropsFor = (semantic) => {
+        const bound = source.shader?.bindings.get(semantic);
+        return bound && bound.length > 0 ? bound : [semantic];
+    };
+    const prefix = source.shader ? "" : shaderPropPrefix;
+    const fetch = (entries, target, prefix2, suffix, wantValue, wantTexture, wantEnabled) => {
+        for (const [mapName, flags, transform, prop] of entries) {
+            const semantic = prefix + prefix2 + prop + suffix;
+            for (const name of materialPropsFor(semantic)) {
+                const entry = source.props.get(name);
+                const map = (target[mapName] ?? (target[mapName] = { valueComponents: 0, textureEnabled: false }));
+                if (wantValue && entry && entry.type !== "Reference") {
+                    const nums = numericValues(entry.values);
+                    if (nums.length > 0) {
+                        const v = nums.slice(0, 4);
+                        if (flags & 4 /* Flag.MultiplyValue */) {
+                            v[0] *= map.value?.[0] ?? 1;
+                            map.value = [v[0], ...(map.value?.slice(1) ?? [])];
+                        }
+                        else {
+                            map.value = v;
+                        }
+                        applyTransform(transform, map.value);
+                        const components = nums.length >= 4 ? 4 : nums.length === 3 ? 3 : nums.length === 2 ? 2 : 1;
+                        if (flags & 1 /* Flag.DefaultW1 */ && components < 4) {
+                            map.value[3] = 1;
+                        }
+                        if (flags & 2 /* Flag.WidenToRgb */ && components === 1) {
+                            map.value[1] = map.value[0];
+                            map.value[2] = map.value[0];
+                        }
+                        map.valueComponents = components;
+                    }
+                }
+                if (wantTexture) {
+                    const texture = source.texturesByProp.get(name);
+                    if (texture) {
+                        map.texture = texture;
+                        map.textureEnabled = true;
+                    }
+                }
+                if (wantEnabled && entry) {
+                    const nums = numericValues(entry.values);
+                    if (nums.length > 0) {
+                        map.textureEnabled = nums[0] !== 0;
+                    }
+                }
+            }
+        }
+    };
+    // Classic Lambert/Phong parameters are always read.
+    fetch(BASE_FBX, model.fbx, "", "", true, true, false);
+    // Shader specific parameters, textures with vendor prefix/suffix, and texture toggles.
+    if (table.texturePrefix || table.textureSuffix) {
+        fetch(table.maps, model.pbr, table.texturePrefix ?? "", table.textureSuffix ?? "", false, true, false);
+    }
+    fetch(table.maps, model.pbr, "", "", true, true, false);
+    if (table.textureEnabledPrefix || table.textureEnabledSuffix) {
+        fetch(table.maps, model.pbr, table.textureEnabledPrefix ?? "", table.textureEnabledSuffix ?? "", false, false, true);
+    }
+    // Feature toggles
+    for (const [feature, flags, prop] of table.features) {
+        const semantic = prefix + prop;
+        for (const name of materialPropsFor(semantic)) {
+            const entry = source.props.get(name);
+            const info = ((_a = model.features)[feature] ?? (_a[feature] = { enabled: false, explicit: false }));
+            if (entry && entry.type !== "Reference") {
+                const nums = numericValues(entry.values);
+                if (nums.length > 0) {
+                    info.enabled = nums[0] !== 0;
+                    info.explicit = true;
+                    if (flags & 8 /* FeatureFlag.IfAround1 */) {
+                        info.enabled = nums[0] >= 0.5 && nums[0] <= 1.5;
+                    }
+                    if (flags & 1 /* FeatureFlag.Inverted */) {
+                        info.enabled = !info.enabled;
+                    }
+                    if (flags & 2 /* FeatureFlag.IfExists */) {
+                        info.enabled = true;
+                    }
+                }
+            }
+            if (flags & 4 /* FeatureFlag.IfTexture */ && source.texturesByProp.has(name)) {
+                info.enabled = true;
+            }
+        }
+    }
+    // Factors default to 1 when the matching colour is set and non-zero, 0 otherwise.
+    const updateFactor = (target, factorName, colorName) => {
+        const factor = (target[factorName] ?? (target[factorName] = { valueComponents: 0, textureEnabled: false }));
+        if (factor.value) {
+            return;
+        }
+        const color = target[colorName];
+        const nonZero = color?.value && color.value.some((c) => c !== 0);
+        factor.value = [nonZero ? 1 : 0];
+        factor.valueComponents = 1;
+    };
+    updateFactor(model.fbx, "diffuseFactor", "diffuseColor");
+    updateFactor(model.fbx, "specularFactor", "specularColor");
+    updateFactor(model.fbx, "reflectionFactor", "reflectionColor");
+    updateFactor(model.fbx, "transparencyFactor", "transparencyColor");
+    updateFactor(model.fbx, "emissionFactor", "emissionColor");
+    updateFactor(model.fbx, "ambientFactor", "ambientColor");
+    updateFactor(model.pbr, "baseFactor", "baseColor");
+    updateFactor(model.pbr, "specularFactor", "specularColor");
+    updateFactor(model.pbr, "emissionFactor", "emissionColor");
+    updateFactor(model.pbr, "sheenFactor", "sheenColor");
+    updateFactor(model.pbr, "thinFilmFactor", "thinFilmThickness");
+    updateFactor(model.pbr, "transmissionFactor", "transmissionColor");
+    if (!model.pbr.transmissionRoughness?.value && model.pbr.roughness?.value && model.pbr.transmissionExtraRoughness?.value) {
+        model.pbr.transmissionRoughness = {
+            value: [model.pbr.roughness.value[0] + model.pbr.transmissionExtraRoughness.value[0]],
+            valueComponents: 1,
+            textureEnabled: false,
+        };
+    }
+    // Roughness <-> glossiness
+    const remaps = [
+        ["roughnessAsGlossiness", "roughness", "glossiness"],
+        ["coatRoughnessAsGlossiness", "coatRoughness", "coatGlossiness"],
+        ["transmissionRoughnessAsGlossiness", "transmissionRoughness", "transmissionGlossiness"],
+    ];
+    for (const [feature, roughName, glossName] of remaps) {
+        const rough = model.pbr[roughName];
+        if (model.features[feature]?.enabled) {
+            if (rough) {
+                model.pbr[glossName] = rough;
+                model.pbr[roughName] = rough.value ? { value: [1 - rough.value[0]], valueComponents: 1, textureEnabled: false } : { valueComponents: 0, textureEnabled: false };
+            }
+        }
+        else if (rough?.value) {
+            model.pbr[glossName] = { value: [1 - rough.value[0]], valueComponents: 1, textureEnabled: false };
+        }
+    }
+    return model;
+}
+/** Colour (first three components) of a map, or undefined. */
+export function mapColor(map) {
+    if (!map?.value) {
+        return undefined;
+    }
+    const v = map.value;
+    if (map.valueComponents === 1) {
+        return [v[0], v[0], v[0]];
+    }
+    return [v[0], v[1] ?? v[0], v[2] ?? v[0]];
+}
+/** Scalar (first component) of a map, or undefined. */
+export function mapScalar(map) {
+    return map?.value ? map.value[0] : undefined;
+}
+//# sourceMappingURL=materialModel.js.map