@babylonjs/inspector 9.30.0 → 9.31.0

package/lib/lite/pbrMaterialProperties-jfJddBxY.js

@@ -0,0 +1,614 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { getMaterialFamily, isMaterialView, getMaterialSource, getPbrUnlit, getShadowOnly, isPbrGammaAlbedo, isPbrSkybox, getPbrTransmission, getPbrSubsurface, getPbrAnisotropy, getPbrIridescence, getPbrSheen, getPbrClearCoat, getPbrMetallicReflectance, getPbrEmissiveColor, getPbrAlphaCutoff, markMaterialUboDirty, rebuildMaterial, enablePbrLightmap, setPbrLightmap, getTextureMetadata, enableMaterialStencil, setPbrDispersion, setPbrEmissive, setPbrAlphaCutoff, setPbrMetallicReflectance, setPbrClearCoat, setPbrSheen, setPbrIridescence, setPbrAnisotropy, setPbrSubsurface, setPbrTransmission } from '@babylonjs/lite';
+import { Body1 } from '@fluentui/react-components';
+import { useCallback } from 'react';
+import { o as useObservableState, p as usePropertyChangedNotifier, T as TextPropertyLine, C as ComputedProperty, D as DerivedProperty, k as TextInputPropertyLine, q as GetMaterialOwningScenes, n as StringDropdownPropertyLine, N as NumberInputPropertyLine, f as SwitchPropertyLine, l as Color3PropertyLine, V as Vector2PropertyLine, m as NumberDropdownPropertyLine, r as Color4PropertyLine } from './index-Cy8gzpYG.js';
+import { u as useLatestAsyncOperation } from './useLatestAsyncOperation-k59AgA3B.js';
+import { D as DirectTextureBinding } from './directTextureBinding-C5MB2OV2.js';
+import '@babylonjs/core/Misc/observable.js';
+import '@fluentui/react-icons';
+import '@babylonjs/core/Misc/dataStorage.js';
+import '@babylonjs/core/Misc/asyncLock.js';
+import '@babylonjs/core/Misc/deferred.js';
+import '@fluentui-contrib/react-resize-handle';
+import '@fluentui/react-motion-components-preview';
+import '@babylonjs/core/Misc/logger.js';
+import 'react-dom/client';
+import '@fluentui-contrib/react-virtualizer';
+import '@babylonjs/core/Misc/uniqueIdGenerator.js';
+import '@babylonjs/core/Maths/math.color.js';
+import '@babylonjs/core/Maths/math.vector.js';
+
+const Rebuild = (apply, frameGraphParticipationChanged = false) => ({ mutation: "R", apply, frameGraphParticipationChanged });
+const Uniform = (apply) => ({ mutation: "U", apply });
+function Require(value, name) {
+    if (value == null) {
+        throw new Error(`${name} is no longer configured.`);
+    }
+    return value;
+}
+function ValidateNumber(value, id, min, max, integer = false) {
+    if (typeof value !== "number" || !Number.isFinite(value) || (integer && !Number.isInteger(value))) {
+        throw new TypeError(`Property "${id}" requires a finite${integer ? " integer" : ""} number.`);
+    }
+    if (min !== undefined && value < min) {
+        throw new RangeError(`Property "${id}" must be at least ${min}.`);
+    }
+    if (max !== undefined && value > max) {
+        throw new RangeError(`Property "${id}" must be at most ${max}.`);
+    }
+}
+function CopyTuple(value, length, id) {
+    if (!Array.isArray(value) || value.length !== length || value.some((component) => typeof component !== "number" || !Number.isFinite(component))) {
+        throw new TypeError(`Property "${id}" requires a ${length}-component finite tuple.`);
+    }
+    return [...value];
+}
+function SameValue(a, b) {
+    return Array.isArray(a) && Array.isArray(b) ? a.length === b.length && a.every((value, index) => Object.is(value, b[index])) : Object.is(a, b);
+}
+const TextureSlots = [
+    { id: "pbr.baseColor", label: "Base Color Texture", section: "textures", read: (m) => m.baseColorTexture },
+    { id: "pbr.normal", label: "Normal Texture", section: "textures", read: (m) => m.normalTexture },
+    { id: "pbr.orm", label: "ORM Texture", section: "textures", read: (m) => m.ormTexture },
+    { id: "pbr.occlusion", label: "Occlusion Texture", section: "textures", read: (m) => m.occlusionTexture },
+    { id: "pbr.emissive", label: "Emissive Texture", section: "textures", read: (m) => m.emissiveTexture },
+    { id: "pbr.specGloss", label: "Specular-Glossiness Texture", section: "textures", read: (m) => m.specGlossTexture },
+    { id: "pbr.lightmap", label: "Lightmap Texture", section: "lightmap", read: (m) => m.lightmapTexture, canClear: false, visible: (m) => !!m.lightmapTexture },
+    {
+        id: "pbr.metallicReflectance",
+        label: "Metallic Reflectance Texture",
+        section: "metallic-reflectance",
+        read: (m) => getPbrMetallicReflectance(m)?.texture,
+        canClear: false,
+        visible: (m) => !!getPbrMetallicReflectance(m),
+    },
+    {
+        id: "pbr.reflectance",
+        label: "Reflectance Texture",
+        section: "metallic-reflectance",
+        read: (m) => getPbrMetallicReflectance(m)?.reflectanceTexture,
+        canClear: false,
+        visible: (m) => !!getPbrMetallicReflectance(m),
+    },
+    { id: "pbr.clearCoat", label: "Clear Coat Texture", section: "clear-coat", read: (m) => getPbrClearCoat(m)?.texture, visible: (m) => !!getPbrClearCoat(m) },
+    {
+        id: "pbr.clearCoatRoughness",
+        label: "Clear Coat Roughness Texture",
+        section: "clear-coat",
+        read: (m) => getPbrClearCoat(m)?.roughnessTexture,
+        visible: (m) => !!getPbrClearCoat(m),
+    },
+    {
+        id: "pbr.clearCoatBump",
+        label: "Clear Coat Bump Texture",
+        section: "clear-coat",
+        read: (m) => getPbrClearCoat(m)?.bumpTexture,
+        visible: (m) => !!getPbrClearCoat(m),
+    },
+    { id: "pbr.sheen", label: "Sheen Color Texture", section: "sheen", read: (m) => getPbrSheen(m)?.texture, visible: (m) => !!getPbrSheen(m) },
+    { id: "pbr.sheenRoughness", label: "Sheen Roughness Texture", section: "sheen", read: (m) => getPbrSheen(m)?.roughnessTexture, visible: (m) => !!getPbrSheen(m) },
+    { id: "pbr.iridescence", label: "Iridescence Texture", section: "iridescence", read: (m) => getPbrIridescence(m)?.texture, visible: (m) => !!getPbrIridescence(m) },
+    {
+        id: "pbr.iridescenceThickness",
+        label: "Iridescence Thickness Texture",
+        section: "iridescence",
+        read: (m) => getPbrIridescence(m)?.thicknessTexture,
+        visible: (m) => !!getPbrIridescence(m),
+    },
+    { id: "pbr.anisotropy", label: "Anisotropy Texture", section: "anisotropy", read: (m) => getPbrAnisotropy(m)?.texture, visible: (m) => !!getPbrAnisotropy(m) },
+    {
+        id: "pbr.translucencyColor",
+        label: "Translucency Color Texture",
+        section: "subsurface-translucency",
+        read: (m) => getPbrSubsurface(m)?.translucency?.colorTexture,
+        visible: (m) => !!getPbrSubsurface(m)?.translucency,
+    },
+    {
+        id: "pbr.translucencyIntensity",
+        label: "Translucency Intensity Texture",
+        section: "subsurface-translucency",
+        read: (m) => getPbrSubsurface(m)?.translucency?.intensityTexture,
+        visible: (m) => !!getPbrSubsurface(m)?.translucency,
+    },
+    {
+        id: "pbr.thickness",
+        label: "Thickness Texture",
+        section: "subsurface-thickness",
+        read: (m) => getPbrSubsurface(m)?.thickness?.texture,
+        visible: (m) => !!getPbrSubsurface(m)?.thickness,
+    },
+    {
+        id: "pbr.transmission",
+        label: "Transmission Texture",
+        section: "transmission",
+        read: (m) => getPbrTransmission(m)?.texture,
+        visible: (m) => !!getPbrTransmission(m),
+    },
+];
+function MatchesTexture2d(texture) {
+    return getTextureMetadata(texture)?.kind === "2d";
+}
+async function SetPbrTexture(material, id, texture) {
+    if (texture && !MatchesTexture2d(texture)) {
+        throw new TypeError(`Texture binding "${id}" requires a Texture2D value.`);
+    }
+    const value = (texture ?? undefined);
+    switch (id) {
+        case "pbr.baseColor":
+            material.baseColorTexture = value;
+            return;
+        case "pbr.normal":
+            material.normalTexture = value;
+            return;
+        case "pbr.orm":
+            material.ormTexture = value;
+            return;
+        case "pbr.occlusion":
+            material.occlusionTexture = value;
+            return;
+        case "pbr.emissive":
+            material.emissiveTexture = value;
+            return;
+        case "pbr.specGloss":
+            material.specGlossTexture = value;
+            return;
+        case "pbr.lightmap": {
+            const lightmap = Require(value, "PBR lightmap texture");
+            Require(material.lightmapTexture, "PBR lightmap");
+            const options = {
+                level: material.lightmapLevel ?? 1,
+                coordIndex: material.lightmapCoordIndex ?? 1,
+                useAsShadowmap: material.useLightmapAsShadowmap ?? false,
+                gamma: material.gammaLightmap ?? false,
+            };
+            await enablePbrLightmap();
+            setPbrLightmap(material, lightmap, options);
+            return;
+        }
+        case "pbr.metallicReflectance":
+            await MetallicPlan(material, { texture: Require(value, "PBR metallic reflectance texture") }).apply();
+            return;
+        case "pbr.reflectance":
+            await MetallicPlan(material, { reflectanceTexture: Require(value, "PBR reflectance texture") }).apply();
+            return;
+        case "pbr.clearCoat":
+            await ClearCoatPlan(material, { texture: value }).apply();
+            return;
+        case "pbr.clearCoatRoughness":
+            await ClearCoatPlan(material, { roughnessTexture: value }).apply();
+            return;
+        case "pbr.clearCoatBump":
+            await ClearCoatPlan(material, { bumpTexture: value }).apply();
+            return;
+        case "pbr.sheen":
+            await SheenPlan(material, { texture: value }).apply();
+            return;
+        case "pbr.sheenRoughness":
+            await SheenPlan(material, { roughnessTexture: value }).apply();
+            return;
+        case "pbr.iridescence":
+            await IridescencePlan(material, { texture: value }).apply();
+            return;
+        case "pbr.iridescenceThickness":
+            await IridescencePlan(material, { thicknessTexture: value }).apply();
+            return;
+        case "pbr.anisotropy":
+            await AnisotropyPlan(material, { texture: value }).apply();
+            return;
+        case "pbr.translucencyColor":
+            await SubsurfacePlan(material, "translucency", { colorTexture: value }).apply();
+            return;
+        case "pbr.translucencyIntensity":
+            await SubsurfacePlan(material, "translucency", { intensityTexture: value }).apply();
+            return;
+        case "pbr.thickness":
+            await SubsurfacePlan(material, "thickness", { texture: value }).apply();
+            return;
+        case "pbr.transmission":
+            await TransmissionPlan(material, { texture: value }).apply();
+            return;
+    }
+}
+const StencilCompareOptions = [
+    { value: "never", label: "Never" },
+    { value: "less", label: "Less" },
+    { value: "equal", label: "Equal" },
+    { value: "less-equal", label: "Less or Equal" },
+    { value: "greater", label: "Greater" },
+    { value: "not-equal", label: "Not Equal" },
+    { value: "greater-equal", label: "Greater or Equal" },
+    { value: "always", label: "Always" },
+];
+const StencilOperationOptions = [
+    { value: "keep", label: "Keep" },
+    { value: "zero", label: "Zero" },
+    { value: "replace", label: "Replace" },
+    { value: "invert", label: "Invert" },
+    { value: "increment-clamp", label: "Increment Clamp" },
+    { value: "decrement-clamp", label: "Decrement Clamp" },
+    { value: "increment-wrap", label: "Increment Wrap" },
+    { value: "decrement-wrap", label: "Decrement Wrap" },
+];
+const CoordinatesOptions = [
+    { value: 0, label: "UV1" },
+    { value: 1, label: "UV2" },
+];
+const PbrRows = (props) => {
+    const { target, commit, operations, section } = props;
+    const row = (id, label, control) => {
+        const operation = operations[id];
+        return (jsxs("div", { "aria-busy": operation?.pending, children: [control, operation?.pending ? jsx(Body1, { role: "status", children: `Applying ${label}…` }) : undefined, operation?.error ? jsx(Body1, { role: "alert", children: operation.error }) : undefined] }, id));
+    };
+    const common = (id, label) => ({
+        label,
+        uniqueId: id,
+        disabled: operations[id]?.pending,
+        description: operations[id]?.error ? `Error: ${operations[id].error}` : undefined,
+    });
+    const number = (id, label, read, prepare, min, max, integer = false) => row(id, label, jsx(DerivedProperty, { component: NumberInputPropertyLine, target: target, getValue: read, setValue: (_, value) => commit(id, read, value, prepare, (next) => ValidateNumber(next, id, min, max, integer)), ...common(id, label), min: min, max: max, step: integer ? 1 : undefined }));
+    const toggle = (id, label, read, prepare) => row(id, label, jsx(DerivedProperty, { component: SwitchPropertyLine, target: target, getValue: read, setValue: (_, value) => commit(id, read, value, prepare, (next) => {
+            if (typeof next !== "boolean") {
+                throw new TypeError(`Property "${id}" requires a boolean.`);
+            }
+        }), ...common(id, label) }));
+    const color3 = (id, label, read, prepare) => row(id, label, jsx(DerivedProperty, { component: Color3PropertyLine, target: target, getValue: read, setValue: (_, value) => commit(id, read, ("r" in value ? [value.r, value.g, value.b] : value), prepare, (next) => CopyTuple(next, 3, id)), ...common(id, label), isLinearMode: true }));
+    const color4 = (id, label, read, prepare) => row(id, label, jsx(DerivedProperty, { component: Color4PropertyLine, target: target, getValue: read, setValue: (_, value) => commit(id, read, ("r" in value ? [value.r, value.g, value.b, value.a] : value), prepare, (next) => CopyTuple(next, 4, id)), ...common(id, label), isLinearMode: true }));
+    const vector2 = (id, label, read, prepare) => row(id, label, jsx(DerivedProperty, { component: Vector2PropertyLine, target: target, getValue: read, setValue: (_, value) => commit(id, read, ("x" in value ? [value.x, value.y] : value), prepare, (next) => CopyTuple(next, 2, id)), ...common(id, label) }));
+    const choice = (id, label, read, prepare) => row(id, label, jsx(DerivedProperty, { component: NumberDropdownPropertyLine, target: target, getValue: read, setValue: (_, value) => commit(id, read, value, prepare, (next) => {
+            if (!CoordinatesOptions.some((option) => option.value === next)) {
+                throw new RangeError(`Property "${id}" does not accept enum value "${next}".`);
+            }
+        }), ...common(id, label), options: CoordinatesOptions }));
+    const stencil = (id, label, key, options) => target.stencil
+        ? row(id, label, jsx(DerivedProperty, { component: StringDropdownPropertyLine, target: target, getValue: (material) => material.stencil?.[key] ?? (key === "compare" ? "always" : "keep"), setValue: (_, value) => commit(id, (material) => material.stencil?.[key] ?? (key === "compare" ? "always" : "keep"), value, (material, next) => {
+                const current = Require(material.stencil, "PBR stencil");
+                return Rebuild(() => {
+                    enableMaterialStencil();
+                    material.stencil = { ...current, [key]: next };
+                });
+            }, (next) => {
+                if (!options.some((option) => option.value === next)) {
+                    throw new RangeError(`Property "${id}" does not accept enum value "${next}".`);
+                }
+            }), ...common(id, label), options: options }))
+        : row(id, label, jsx(ComputedProperty, { component: TextPropertyLine, target: target, getValue: () => "Not configured", label: label, uniqueId: id }));
+    const stencilMask = (id, label, key) => target.stencil
+        ? number(id, label, (material) => material.stencil?.[key] ?? 0xff, (material, value) => {
+            const current = Require(material.stencil, "PBR stencil");
+            return Rebuild(() => {
+                enableMaterialStencil();
+                material.stencil = { ...current, [key]: value };
+            });
+        }, 0, 0xffffffff, true)
+        : row(id, label, jsx(ComputedProperty, { component: TextPropertyLine, target: target, getValue: () => "Not configured", label: label, uniqueId: id }));
+    const readOnly = (id, label, read, reason) => row(id, label, jsx(ComputedProperty, { component: TextPropertyLine, target: target, getValue: (material) => {
+            const value = read(material);
+            return Array.isArray(value) ? `[${value.join(", ")}]` : String(value);
+        }, label: label, uniqueId: id, description: `${reason} is a one-way public mode and has no reversible setter.` }));
+    switch (section) {
+        case "general":
+            return (jsxs(Fragment, { children: [row("material.name", "Name", jsx(DerivedProperty, { component: TextInputPropertyLine, target: target, getValue: (m) => m.name ?? "", setValue: (_, value) => commit("material.name", (m) => m.name ?? "", value, (m, next) => ({ mutation: "A", apply: () => (m.name = next) }), (next) => {
+                            if (typeof next !== "string") {
+                                throw new TypeError('Property "material.name" requires a string.');
+                            }
+                        }), ...common("material.name", "Name") })), toggle("pbr.doubleSided", "Double Sided", (m) => m.doubleSided ?? false, (m, v) => Rebuild(() => (m.doubleSided = v))), toggle("pbr.alphaBlend", "Alpha Blend", (m) => m.alphaBlend ?? false, (m, v) => Rebuild(() => (m.alphaBlend = v))), toggle("pbr.enableSpecularAA", "Specular Anti-Aliasing", (m) => m.enableSpecularAA ?? false, (m, v) => Rebuild(() => (m.enableSpecularAA = v)))] }));
+        case "transparency":
+            return (jsxs(Fragment, { children: [number("pbr.alpha", "Alpha", (m) => m.alpha ?? 1, (m, v) => {
+                        const cutoff = getPbrAlphaCutoff(m) ?? 0;
+                        return ((m.alpha ?? 1) < 1 && cutoff <= 0) === (v < 1 && cutoff <= 0) ? Uniform(() => (m.alpha = v)) : Rebuild(() => (m.alpha = v));
+                    }, 0, 1), getPbrAlphaCutoff(target) === undefined
+                        ? row("pbr.alphaCutOff", "Alpha Cutoff", jsx(ComputedProperty, { component: TextPropertyLine, target: target, getValue: () => "Not configured", label: "Alpha Cutoff", uniqueId: "pbr.alphaCutOff" }))
+                        : number("pbr.alphaCutOff", "Alpha Cutoff", (m) => getPbrAlphaCutoff(m) ?? 0, (m, v) => ((getPbrAlphaCutoff(m) ?? 0) > 0 === v > 0 ? Uniform(() => setPbrAlphaCutoff(m, v)) : Rebuild(() => setPbrAlphaCutoff(m, v))))] }));
+        case "lighting-colors":
+            return (jsxs(Fragment, { children: [target.baseColorFactor
+                        ? color4("pbr.baseColorFactor", "Base Color Factor", (m) => m.baseColorFactor ?? [1, 1, 1, 1], (m, v) => (m.baseColorFactor === undefined ? Rebuild(() => (m.baseColorFactor = [...v])) : Uniform(() => (m.baseColorFactor = [...v]))))
+                        : row("pbr.baseColorFactor", "Base Color Factor", jsx(ComputedProperty, { component: TextPropertyLine, target: target, getValue: () => "Not configured", label: "Base Color Factor", uniqueId: "pbr.baseColorFactor" })), getPbrEmissiveColor(target)
+                        ? color3("pbr.emissiveColor", "Emissive Color", (m) => getPbrEmissiveColor(m) ?? [0, 0, 0], (m, v) => (getPbrEmissiveColor(m) === undefined ? Rebuild(() => setPbrEmissive(m, [...v])) : Uniform(() => setPbrEmissive(m, [...v]))))
+                        : row("pbr.emissiveColor", "Emissive Color", jsx(ComputedProperty, { component: TextPropertyLine, target: target, getValue: () => "Not configured", label: "Emissive Color", uniqueId: "pbr.emissiveColor" })), number("pbr.environmentIntensity", "Environment Intensity", (m) => m.environmentIntensity ?? 1, (m, v) => Uniform(() => (m.environmentIntensity = v))), number("pbr.directIntensity", "Direct Intensity", (m) => m.directIntensity ?? 1, (m, v) => Uniform(() => (m.directIntensity = v))), number("pbr.reflectance", "Reflectance", (m) => m.reflectance ?? 0.04, (m, v) => Uniform(() => (m.reflectance = v))), number("pbr.metallicFactor", "Metallic Factor", (m) => m.metallicFactor ?? 1, (m, v) => Uniform(() => (m.metallicFactor = v))), number("pbr.roughnessFactor", "Roughness Factor", (m) => m.roughnessFactor ?? 1, (m, v) => Uniform(() => (m.roughnessFactor = v))), number("pbr.normalTextureScale", "Normal Texture Scale", (m) => m.normalTextureScale ?? 1, (m, v) => Uniform(() => (m.normalTextureScale = v))), toggle("pbr.usePhysicalLightFalloff", "Use Physical Light Falloff", (m) => m.usePhysicalLightFalloff ?? true, (m, v) => Uniform(() => (m.usePhysicalLightFalloff = v)))] }));
+        case "occlusion":
+            return (jsxs(Fragment, { children: [number("pbr.occlusionStrength", "Occlusion Strength", (m) => m.occlusionStrength ?? 1, (m, v) => Uniform(() => (m.occlusionStrength = v)), 0, 1), row("pbr.occlusionTexCoord", "Occlusion Coordinates", jsx(ComputedProperty, { component: TextPropertyLine, target: target, getValue: (m) => String(m.occlusionTexCoord ?? 0), label: "Occlusion Coordinates", uniqueId: "pbr.occlusionTexCoord", description: "Changing the occlusion UV set requires a public setter that maintains the UV2 claim." }))] }));
+        case "lightmap":
+            if (!target.lightmapTexture) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [number("pbr.lightmapLevel", "Level", (m) => m.lightmapLevel ?? 1, (m, v) => LightmapPlan(m, { level: v })), choice("pbr.lightmapCoordIndex", "Coordinates", (m) => m.lightmapCoordIndex ?? 1, (m, v) => LightmapPlan(m, { coordIndex: v })), toggle("pbr.useLightmapAsShadowmap", "Use as Shadowmap", (m) => m.useLightmapAsShadowmap ?? false, (m, v) => LightmapPlan(m, { useAsShadowmap: v })), toggle("pbr.gammaLightmap", "Gamma Decode", (m) => m.gammaLightmap ?? false, (m, v) => LightmapPlan(m, { gamma: v }))] }));
+        case "metallic-reflectance":
+            if (!getPbrMetallicReflectance(target)) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [color3("pbr.metallicReflectanceColor", "Metallic Reflectance Color", (m) => getPbrMetallicReflectance(m)?.color ?? [1, 1, 1], (m, v) => MetallicPlan(m, { color: [...v] })), number("pbr.metallicF0Factor", "Metallic F0 Factor", (m) => getPbrMetallicReflectance(m)?.f0Factor ?? 1, (m, v) => MetallicPlan(m, { f0Factor: v })), number("pbr.specularWeight", "Specular Weight", (m) => getPbrMetallicReflectance(m)?.specularWeight ?? getPbrMetallicReflectance(m)?.f0Factor ?? 1, (m, v) => MetallicPlan(m, { specularWeight: v })), toggle("pbr.useOnlyMetallicFromTexture", "Use Only Metallic From Texture", (m) => getPbrMetallicReflectance(m)?.useOnlyMetallicFromTexture ?? false, (m, v) => MetallicPlan(m, { useOnlyMetallicFromTexture: v }))] }));
+        case "clear-coat":
+            if (!getPbrClearCoat(target)) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [toggle("pbr.clearCoat.enabled", "Enabled", (m) => getPbrClearCoat(m)?.isEnabled ?? false, (m, v) => ClearCoatPlan(m, { isEnabled: v })), number("pbr.clearCoat.intensity", "Intensity", (m) => getPbrClearCoat(m)?.intensity ?? 1, (m, v) => ClearCoatPlan(m, { intensity: v }), 0, 1), number("pbr.clearCoat.roughness", "Roughness", (m) => getPbrClearCoat(m)?.roughness ?? 0, (m, v) => ClearCoatPlan(m, { roughness: v }), 0, 1), number("pbr.clearCoat.indexOfRefraction", "Index of Refraction", (m) => getPbrClearCoat(m)?.indexOfRefraction ?? 1.5, (m, v) => ClearCoatPlan(m, { indexOfRefraction: v })), toggle("pbr.clearCoat.useF0Remap", "F0 Remap", (m) => getPbrClearCoat(m)?.useF0Remap ?? true, (m, v) => ClearCoatPlan(m, { useF0Remap: v })), number("pbr.clearCoat.bumpTextureScale", "Bump Texture Scale", (m) => getPbrClearCoat(m)?.bumpTextureScale ?? 1, (m, v) => ClearCoatPlan(m, { bumpTextureScale: v }))] }));
+        case "sheen":
+            if (!getPbrSheen(target)) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [toggle("pbr.sheen.enabled", "Enabled", (m) => getPbrSheen(m)?.isEnabled ?? false, (m, v) => SheenPlan(m, { isEnabled: v })), color3("pbr.sheen.color", "Color", (m) => getPbrSheen(m)?.color ?? [1, 1, 1], (m, v) => SheenPlan(m, { color: [...v] })), number("pbr.sheen.roughness", "Roughness", (m) => getPbrSheen(m)?.roughness ?? 0, (m, v) => SheenPlan(m, { roughness: v }), 0, 1), number("pbr.sheen.intensity", "Intensity", (m) => getPbrSheen(m)?.intensity ?? 1, (m, v) => SheenPlan(m, { intensity: v }), 0, 1), toggle("pbr.sheen.albedoScaling", "Albedo Scaling", (m) => getPbrSheen(m)?.albedoScaling ?? false, (m, v) => SheenPlan(m, { albedoScaling: v }))] }));
+        case "iridescence":
+            if (!getPbrIridescence(target)) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [toggle("pbr.iridescence.enabled", "Enabled", (m) => getPbrIridescence(m)?.isEnabled ?? false, (m, v) => IridescencePlan(m, { isEnabled: v })), number("pbr.iridescence.intensity", "Intensity", (m) => getPbrIridescence(m)?.intensity ?? 1, (m, v) => IridescencePlan(m, { intensity: v }), 0, 1), number("pbr.iridescence.indexOfRefraction", "Index of Refraction", (m) => getPbrIridescence(m)?.indexOfRefraction ?? 1.3, (m, v) => IridescencePlan(m, { indexOfRefraction: v })), number("pbr.iridescence.minimumThickness", "Minimum Thickness", (m) => getPbrIridescence(m)?.minimumThickness ?? 100, (m, v) => IridescencePlan(m, { minimumThickness: v })), number("pbr.iridescence.maximumThickness", "Maximum Thickness", (m) => getPbrIridescence(m)?.maximumThickness ?? 400, (m, v) => IridescencePlan(m, { maximumThickness: v }))] }));
+        case "anisotropy":
+            if (!getPbrAnisotropy(target)) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [toggle("pbr.anisotropy.enabled", "Enabled", (m) => getPbrAnisotropy(m)?.isEnabled ?? false, (m, v) => AnisotropyPlan(m, { isEnabled: v })), number("pbr.anisotropy.intensity", "Intensity", (m) => getPbrAnisotropy(m)?.intensity ?? 1, (m, v) => AnisotropyPlan(m, { intensity: v }), 0, 1), vector2("pbr.anisotropy.direction", "Direction", (m) => getPbrAnisotropy(m)?.direction ?? [1, 0], (m, v) => AnisotropyPlan(m, { direction: [...v] }))] }));
+        case "subsurface-translucency":
+            if (!getPbrSubsurface(target)?.translucency) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [number("pbr.translucency.intensity", "Intensity", (m) => getPbrSubsurface(m)?.translucency?.intensity ?? 1, (m, v) => SubsurfacePlan(m, "translucency", { intensity: v }), 0, 1), color3("pbr.translucency.color", "Color", (m) => getPbrSubsurface(m)?.translucency?.color ?? [1, 1, 1], (m, v) => SubsurfacePlan(m, "translucency", { color: [...v] })), color3("pbr.translucency.diffusionDistance", "Diffusion Distance", (m) => getPbrSubsurface(m)?.translucency?.diffusionDistance ?? [1, 1, 1], (m, v) => SubsurfacePlan(m, "translucency", { diffusionDistance: [...v] }))] }));
+        case "subsurface-thickness":
+            if (!getPbrSubsurface(target)?.thickness) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [number("pbr.thickness.min", "Minimum", (m) => getPbrSubsurface(m)?.thickness?.min ?? 0, (m, v) => SubsurfacePlan(m, "thickness", { min: v })), number("pbr.thickness.max", "Maximum", (m) => getPbrSubsurface(m)?.thickness?.max ?? 1, (m, v) => SubsurfacePlan(m, "thickness", { max: v })), toggle("pbr.thickness.useGlTFChannel", "Use glTF Channel", (m) => getPbrSubsurface(m)?.thickness?.useGlTFChannel ?? false, 
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    (m, v) => SubsurfacePlan(m, "thickness", { useGlTFChannel: v }))] }));
+        case "subsurface-tint":
+            if (!getPbrSubsurface(target)?.tint) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [color3("pbr.tint.color", "Color", (m) => getPbrSubsurface(m)?.tint?.color ?? [1, 1, 1], (m, v) => SubsurfacePlan(m, "tint", { color: [...v] })), number("pbr.tint.atDistance", "Distance", (m) => getPbrSubsurface(m)?.tint?.atDistance ?? 1, (m, v) => SubsurfacePlan(m, "tint", { atDistance: v }))] }));
+        case "transmission":
+            if (!getPbrTransmission(target)) {
+                return null;
+            }
+            return (jsxs(Fragment, { children: [number("pbr.transmission.intensity", "Intensity", (m) => getPbrTransmission(m)?.intensity ?? 0, (m, v) => TransmissionPlan(m, { intensity: v }), 0, 1), number("pbr.transmission.indexOfRefraction", "Index of Refraction", (m) => getPbrTransmission(m)?.indexOfRefraction ?? 1.5, (m, v) => TransmissionPlan(m, { indexOfRefraction: v })), toggle("pbr.transmission.useThicknessAsDepth", "Use Thickness as Depth", (m) => getPbrTransmission(m)?.useThicknessAsDepth ?? false, (m, v) => TransmissionPlan(m, { useThicknessAsDepth: v })), getPbrTransmission(target)?.dispersion !== undefined
+                        ? number("pbr.transmission.dispersion", "Dispersion", (m) => getPbrTransmission(m)?.dispersion ?? 0, (m, v) => {
+                            Require(getPbrTransmission(m)?.dispersion, "PBR dispersion");
+                            return Rebuild(() => setPbrDispersion(m, v));
+                        })
+                        : null] }));
+        case "special-modes": {
+            const unlit = getPbrUnlit(target);
+            const shadowOnly = getShadowOnly(target);
+            return (jsxs(Fragment, { children: [unlit ? readOnly("pbr.mode.unlit", "Unlit", () => true, "Unlit") : null, unlit ? readOnly("pbr.mode.unlitColor", "Unlit Color", (m) => getPbrUnlit(m) ?? [0, 0, 0], "Unlit tint") : null, isPbrGammaAlbedo(target) ? readOnly("pbr.mode.gammaAlbedo", "Gamma Albedo", () => true, "Gamma albedo") : null, isPbrSkybox(target) ? readOnly("pbr.mode.skybox", "Skybox", () => true, "Skybox") : null, shadowOnly ? readOnly("pbr.mode.shadowOnly", "Shadow Only", () => true, "Shadow-only") : null, shadowOnly ? readOnly("pbr.mode.shadowOnlyColor", "Shadow Color", (m) => getShadowOnly(m)?.color ?? [0, 0, 0], "Shadow-only color") : null, shadowOnly ? readOnly("pbr.mode.shadowOnlyOpacity", "Shadow Opacity", (m) => getShadowOnly(m)?.opacity ?? 0, "Shadow-only opacity") : null, shadowOnly ? readOnly("pbr.mode.shadowOnlyFalloff", "Shadow Falloff", (m) => getShadowOnly(m)?.falloff ?? 0, "Shadow-only falloff") : null] }));
+        }
+        case "stencil":
+            return (jsxs(Fragment, { children: [stencil("pbr.stencil.compare", "Stencil Compare", "compare", StencilCompareOptions), stencil("pbr.stencil.passOp", "Stencil Pass Operation", "passOp", StencilOperationOptions), stencil("pbr.stencil.failOp", "Stencil Fail Operation", "failOp", StencilOperationOptions), stencil("pbr.stencil.depthFailOp", "Stencil Depth Fail Operation", "depthFailOp", StencilOperationOptions), stencilMask("pbr.stencil.readMask", "Stencil Read Mask", "readMask"), stencilMask("pbr.stencil.writeMask", "Stencil Write Mask", "writeMask")] }));
+        default:
+            return null;
+    }
+};
+function LightmapPlan(material, patch) {
+    const texture = Require(material.lightmapTexture, "PBR lightmap");
+    const options = {
+        level: material.lightmapLevel ?? 1,
+        coordIndex: material.lightmapCoordIndex ?? 1,
+        useAsShadowmap: material.useLightmapAsShadowmap ?? false,
+        gamma: material.gammaLightmap ?? false,
+        ...patch,
+    };
+    return Rebuild(async () => {
+        await enablePbrLightmap();
+        setPbrLightmap(material, texture, options);
+    });
+}
+function MetallicPlan(material, patch) {
+    const current = Require(getPbrMetallicReflectance(material), "PBR metallic reflectance");
+    return Rebuild(() => setPbrMetallicReflectance(material, {
+        color: [...(current.color ?? [1, 1, 1])],
+        texture: current.texture,
+        reflectanceTexture: current.reflectanceTexture,
+        f0Factor: current.f0Factor ?? 1,
+        specularWeight: current.specularWeight ?? current.f0Factor ?? 1,
+        useOnlyMetallicFromTexture: current.useOnlyMetallicFromTexture ?? false,
+        ...patch,
+    }));
+}
+function ClearCoatPlan(material, patch) {
+    const current = Require(getPbrClearCoat(material), "PBR clear coat");
+    return Rebuild(() => setPbrClearCoat(material, {
+        isEnabled: current.isEnabled ?? false,
+        intensity: current.intensity ?? 1,
+        roughness: current.roughness ?? 0,
+        indexOfRefraction: current.indexOfRefraction ?? 1.5,
+        texture: current.texture,
+        roughnessTexture: current.roughnessTexture,
+        bumpTexture: current.bumpTexture,
+        bumpTextureScale: current.bumpTextureScale ?? 1,
+        useF0Remap: current.useF0Remap ?? true,
+        ...patch,
+    }));
+}
+function SheenPlan(material, patch) {
+    const current = Require(getPbrSheen(material), "PBR sheen");
+    return Rebuild(() => setPbrSheen(material, {
+        isEnabled: current.isEnabled ?? false,
+        color: [...(current.color ?? [1, 1, 1])],
+        roughness: current.roughness ?? 0,
+        intensity: current.intensity ?? 1,
+        texture: current.texture,
+        roughnessTexture: current.roughnessTexture,
+        albedoScaling: current.albedoScaling ?? false,
+        ...patch,
+    }));
+}
+function IridescencePlan(material, patch) {
+    const current = Require(getPbrIridescence(material), "PBR iridescence");
+    return Rebuild(() => setPbrIridescence(material, {
+        isEnabled: current.isEnabled ?? false,
+        intensity: current.intensity ?? 1,
+        indexOfRefraction: current.indexOfRefraction ?? 1.3,
+        minimumThickness: current.minimumThickness ?? 100,
+        maximumThickness: current.maximumThickness ?? 400,
+        texture: current.texture,
+        thicknessTexture: current.thicknessTexture,
+        ...patch,
+    }));
+}
+function AnisotropyPlan(material, patch) {
+    const current = Require(getPbrAnisotropy(material), "PBR anisotropy");
+    return Rebuild(() => setPbrAnisotropy(material, {
+        isEnabled: current.isEnabled ?? false,
+        intensity: current.intensity ?? 1,
+        direction: [...(current.direction ?? [1, 0])],
+        texture: current.texture,
+        ...patch,
+    }));
+}
+function SubsurfacePlan(material, key, patch) {
+    const current = Require(getPbrSubsurface(material), "PBR subsurface");
+    Require(current[key], `PBR ${key}`);
+    const subsurface = {
+        translucency: current.translucency
+            ? {
+                intensity: current.translucency.intensity ?? 1,
+                color: [...(current.translucency.color ?? [1, 1, 1])],
+                colorTexture: current.translucency.colorTexture,
+                intensityTexture: current.translucency.intensityTexture,
+                diffusionDistance: [...(current.translucency.diffusionDistance ?? [1, 1, 1])],
+            }
+            : undefined,
+        scattering: current.scattering ? { ...current.scattering } : undefined,
+        thickness: current.thickness
+            ? {
+                texture: current.thickness.texture,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                useGlTFChannel: current.thickness.useGlTFChannel ?? false,
+                min: current.thickness.min ?? 0,
+                max: current.thickness.max ?? 1,
+            }
+            : undefined,
+        tint: current.tint ? { color: [...(current.tint.color ?? [1, 1, 1])], atDistance: current.tint.atDistance } : undefined,
+        refraction: current.refraction ? { ...current.refraction } : undefined,
+    };
+    Object.assign(subsurface[key], patch);
+    return Rebuild(() => setPbrSubsurface(material, subsurface));
+}
+function TransmissionPlan(material, patch) {
+    const current = Require(getPbrTransmission(material), "PBR transmission");
+    const next = {
+        intensity: current.intensity ?? 0,
+        texture: current.texture,
+        indexOfRefraction: current.indexOfRefraction ?? 1.5,
+        useThicknessAsDepth: current.useThicknessAsDepth ?? false,
+        dispersion: current.dispersion,
+        ...patch,
+    };
+    const active = (current.intensity ?? 0) > 0;
+    return Rebuild(() => setPbrTransmission(material, next), active !== next.intensity > 0);
+}
+/**
+ * Renders PBR property rows and texture bindings directly from Lite.
+ * @param props The selected PBR material, section, and instance services.
+ * @returns The PBR property rows for the requested section.
+ */
+const PbrMaterialAdapter = (props) => {
+    const { material, section, resourceIndexService, selectionService } = props;
+    const getSource = () => {
+        try {
+            return getMaterialSource(material);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const source = getSource();
+    const getRecord = useCallback(() => (source && !resourceIndexService.isDisposed ? resourceIndexService.getMaterialRecord(source) : undefined), [source, resourceIndexService]);
+    const record = useObservableState(getRecord, resourceIndexService.onChanged);
+    const isDisposed = useCallback(() => resourceIndexService.isDisposed, [resourceIndexService]);
+    const [operations, runLatestOperation] = useLatestAsyncOperation(material, [resourceIndexService.onDisposed, selectionService.onSelectedEntityChanged], isDisposed);
+    const notifyPropertyChanged = usePropertyChangedNotifier();
+    const target = material;
+    const commit = (id, read, value, prepare, validate) => {
+        runLatestOperation({
+            id,
+            operationAsync: async () => {
+                validate?.(value);
+                const current = getRecord();
+                if (!current || current.family !== "pbr" || !source) {
+                    throw new Error("This material is no longer available in an inspected scene.");
+                }
+                const scenes = GetMaterialOwningScenes(current, material);
+                if (!scenes.length) {
+                    throw new Error("This material is no longer reachable from an inspected scene.");
+                }
+                const oldValue = read(target);
+                const plan = prepare(target, value);
+                if (SameValue(oldValue, value)) {
+                    return { changed: false, oldValue };
+                }
+                await plan.apply();
+                if (plan.mutation === "U") {
+                    markMaterialUboDirty(target);
+                }
+                else if (plan.mutation === "R") {
+                    await Promise.all(scenes.map(async (scene) => {
+                        await rebuildMaterial(scene, target, { rebuildViews: true, rebuildFrameGraph: plan.frameGraphParticipationChanged === true });
+                    }));
+                }
+                return { changed: true, oldValue };
+            },
+            onSuccess: ({ changed, oldValue }) => {
+                if (changed && source) {
+                    const key = id === "material.name" ? "name" : id.slice(id.lastIndexOf(".") + 1);
+                    notifyPropertyChanged(material, Reflect.has(material, key) ? key : id, oldValue, value);
+                }
+                resourceIndexService.refresh();
+            },
+            getErrorMessage: (error) => (error instanceof Error ? error.message : "The material change failed."),
+        });
+    };
+    const commitTexture = (change) => {
+        const { id, oldValue, newValue, apply, invalidate, rebuildFrameGraph } = change;
+        runLatestOperation({
+            id,
+            operationAsync: async () => {
+                const current = getRecord();
+                if (!current || current.family !== "pbr" || !source) {
+                    throw new Error("This material is no longer available in an inspected scene.");
+                }
+                const scenes = GetMaterialOwningScenes(current, material);
+                if (!scenes.length) {
+                    throw new Error("This material is no longer reachable from an inspected scene.");
+                }
+                if (SameValue(oldValue, newValue)) {
+                    return false;
+                }
+                await apply();
+                if (invalidate === "ubo") {
+                    markMaterialUboDirty(target);
+                }
+                else if (invalidate === "rebuild") {
+                    await Promise.all(scenes.map(async (scene) => {
+                        await rebuildMaterial(scene, target, { rebuildViews: true, rebuildFrameGraph: rebuildFrameGraph === true });
+                    }));
+                }
+                return true;
+            },
+            onSuccess: (changed) => {
+                if (changed && source) {
+                    const key = `${id.slice("pbr.".length)}Texture`;
+                    notifyPropertyChanged(material, id.startsWith("pbr.") && Reflect.has(material, key) ? key : id, oldValue, newValue);
+                }
+                resourceIndexService.refresh();
+            },
+            getErrorMessage: (error) => (error instanceof Error ? error.message : "The material texture change failed."),
+        });
+    };
+    if (!record || !source) {
+        return jsx(TextPropertyLine, { label: "Error", value: "This material is no longer available in an inspected scene." });
+    }
+    if (record.family !== "pbr" || getMaterialFamily(source) !== "pbr") {
+        return jsx(TextPropertyLine, { label: "Error", value: `The material family changed from pbr to ${record.family ?? "unknown"}.` });
+    }
+    return (jsxs(Fragment, { children: [section === "general" ? (jsxs(Fragment, { children: [jsx(TextPropertyLine, { label: "Family", value: "pbr" }), jsx(TextPropertyLine, { label: "Selection", value: isMaterialView(material) ? "MaterialView" : "Material" }), isMaterialView(material) ? jsx(TextPropertyLine, { label: "Source", value: record.displayName }) : undefined] })) : undefined, jsx(PbrRows, { target: target, section: section, operations: operations, commit: commit }), TextureSlots.filter((slot) => slot.section === section && (!("visible" in slot) || slot.visible(target))).map((slot) => {
+                const value = slot.read(target);
+                return (jsx(DirectTextureBinding, { id: slot.id, label: slot.label, record: record, resourceIndexService: resourceIndexService, selectionService: selectionService, operations: operations, commit: commitTexture, value: value, read: () => slot.read(target), acceptedKinds: ["2d"], canClear: !("canClear" in slot) || slot.canClear, invalidate: "rebuild", apply: async (texture) => {
+                        if ((slot.read(target) ?? null) !== (value ?? null)) {
+                            throw new Error(`Texture binding "${slot.id}" is stale.`);
+                        }
+                        await SetPbrTexture(target, slot.id, texture);
+                    } }, slot.id));
+            })] }));
+};
+
+export { PbrMaterialAdapter };
+//# sourceMappingURL=pbrMaterialProperties-jfJddBxY.js.map