@fps-games/editor 0.1.8 → 0.2.0-beta.2

package/node_modules/@fps-games/editor-playable-sdk/dist/product/ground-decal.js

@@ -0,0 +1,1263 @@
+import { createEditorSceneReadonlyInspectorProperty, } from '../inspector/index.js';
+import { findEditorSceneTransform, } from '../document/index.js';
+export const PLAYABLE_GROUND_DECAL_TEXTURE_TINT = { r: 1, g: 1, b: 1, a: 1 };
+export function createPlayableGroundDecalDocumentServices(input) {
+    return { ...input };
+}
+export function createPlayableGroundDecalDocumentBridge(input) {
+    const services = createPlayableGroundDecalDocumentServices(input);
+    return {
+        services,
+        normalizeLayoutPatchValue: value => normalizePlayableGroundDecalLayoutPatchValue(value, services),
+        isLayoutPatchCompatibleWithDecal: (decal, patches) => (isPlayableGroundDecalLayoutPatchCompatibleWithDecal(decal, patches, services)),
+        canPatchMultiField: (document, targetId, path, value) => (canPatchPlayableEditorSceneGroundDecalMultiField(document, targetId, path, value, services)),
+        patchLayout: (document, targetId, value) => (patchPlayableEditorSceneGroundDecalLayout(document, targetId, value, services)),
+        patchKind: (document, targetId, value) => (patchPlayableEditorSceneGroundDecalKind(document, targetId, value, services)),
+        patchInspectorField: (document, targetId, path, value) => (patchPlayableEditorSceneGroundDecalInspectorField(document, targetId, path, value, services)),
+        normalizeGameObject: gameObject => normalizePlayableEditorSceneGroundDecalGameObject(gameObject, services),
+        replaceUi: (document, targetId, groundDecal) => (replacePlayableEditorSceneGroundDecalUi(document, targetId, groundDecal, services)),
+        normalizeScaleAfterFieldPatch: (document, targetId, path, value) => (normalizePlayableGroundDecalUiScaleAfterFieldPatch(document, targetId, path, value, services)),
+        normalizeScalesForCommand: (document, command) => (normalizePlayableGroundDecalUiScalesForCommand(document, command, services)),
+        normalizeScales: (document, targetId, uniformOverride) => (normalizePlayableGroundDecalUiScales(document, services, targetId, uniformOverride)),
+        mergeDefaults: groundDecal => mergePlayableGroundDecalDefaults(groundDecal, services.createDefaultGroundDecal, services),
+    };
+}
+export function createPlayableGroundDecalInspectorServices(input) {
+    return {
+        ...input.policy,
+        createDocumentInspectorProperty: input.createDocumentInspectorProperty,
+        normalizeValue: input.normalizeValue,
+        findTarget: input.findTarget,
+        getTargetId: input.getTargetId,
+        getTargetNodeKind: input.getTargetNodeKind,
+        getTargetGroundDecal: input.getTargetGroundDecal,
+        canShowTarget: input.canShowTarget,
+        isUiTarget: input.isUiTarget,
+        canPatchMultiField: input.canPatchMultiField,
+        findTextureAsset: input.findTextureAsset,
+        resolveTextureAssetUrl: input.resolveTextureAssetUrl,
+        getMaterialText: input.getMaterialText,
+        createTexturePickerControlOptions: input.createTexturePickerControlOptions,
+    };
+}
+const PLAYABLE_GROUND_DECAL_UI_EDITOR_PROGRESS_PERCENT = 75;
+export function resolvePlayableGroundDecalUiInspectorScale(path, value) {
+    if (path === 'transform.scale') {
+        const scale = value;
+        if (!scale || typeof scale !== 'object')
+            return null;
+        return resolvePlayableGroundDecalUniformScaleFromVec3({
+            x: typeof scale.x === 'number' ? scale.x : 1,
+            y: typeof scale.y === 'number' ? scale.y : 1,
+            z: typeof scale.z === 'number' ? scale.z : 1,
+        });
+    }
+    if (!/^transform\.scale\.(x|y|z)$/.test(path))
+        return null;
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    return Math.max(0.001, Math.abs(value));
+}
+export function normalizePlayableGroundDecalLayoutPatchValue(value, options = {}) {
+    const source = readPlayableGroundDecalRecord(value);
+    const layers = Array.isArray(value)
+        ? value
+        : source && Array.isArray(source.layers)
+            ? source.layers
+            : null;
+    if (!layers)
+        return null;
+    const normalized = layers
+        .map((layer, index) => normalizePlayableGroundDecalLayoutLayerPatch(layer, index, options))
+        .filter((layer) => !!layer);
+    return normalized.length > 0 ? normalized : null;
+}
+export function normalizePlayableGroundDecalLayoutLayerPatch(value, index, options = {}) {
+    const source = readPlayableGroundDecalRecord(value);
+    if (!source)
+        return null;
+    if (!isPlayableGroundDecalLayoutEditableLayer(source, options))
+        return null;
+    const id = readPlayableGroundDecalString(source.id) ?? `layer_${index}`;
+    const rect = normalizePlayableGroundDecalLayoutRect(source.rect);
+    return rect ? { id, rect } : null;
+}
+export function normalizePlayableGroundDecalLayoutRect(value) {
+    const source = readPlayableGroundDecalRecord(value);
+    if (!source)
+        return null;
+    const x = readPlayableGroundDecalFiniteNumber(source.x);
+    const z = readPlayableGroundDecalFiniteNumber(source.z);
+    const width = readPlayableGroundDecalPositiveFiniteNumber(source.width);
+    const depth = readPlayableGroundDecalPositiveFiniteNumber(source.depth);
+    return x == null || z == null || width == null || depth == null
+        ? null
+        : { x, z, width, depth };
+}
+export function readPlayableGroundDecalFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+export function readPlayableGroundDecalPositiveFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+}
+export function validatePlayableGroundDecalInspectorField(path, value) {
+    if (isPlayableGroundDecalLayerRectPath(path)) {
+        return normalizePlayableGroundDecalLayoutRect(value)
+            ? { ok: true, value }
+            : { ok: false, message: `Invalid value for scene node field: ${path}.` };
+    }
+    if (isPlayableGroundDecalLayerTexturePath(path)) {
+        return typeof value === 'string' && value.trim().length > 0
+            ? { ok: true, value: value.trim() }
+            : { ok: false, message: `Invalid value for scene node field: ${path}.` };
+    }
+    if (isPlayableGroundDecalLayerTextValuePath(path)) {
+        return typeof value === 'string'
+            ? { ok: true, value }
+            : { ok: false, message: `Invalid value for scene node field: ${path}.` };
+    }
+    if (isPlayableGroundDecalLayerColorPath(path)
+        || isPlayableGroundDecalLayerTextureTintPath(path)
+        || isPlayableGroundDecalLayerTextColorPath(path)) {
+        const color = normalizePlayableGroundDecalColorValue(value);
+        return color
+            ? { ok: true, value: color }
+            : { ok: false, message: `Invalid value for scene node field: ${path}.` };
+    }
+    if (isPlayableGroundDecalLayerColorAlphaPath(path)
+        || isPlayableGroundDecalLayerTextureTintAlphaPath(path)
+        || isPlayableGroundDecalLayerTextColorAlphaPath(path)) {
+        const alpha = normalizePlayableGroundDecalAlphaValue(value);
+        return alpha !== null
+            ? { ok: true, value: alpha }
+            : { ok: false, message: `Invalid value for scene node field: ${path}.` };
+    }
+    if (isPlayableGroundDecalLayerProgressPreviewPercentPath(path)) {
+        const percent = normalizePlayableGroundDecalProgressPreviewPercentValue(value);
+        return percent !== null
+            ? { ok: true, value: percent }
+            : { ok: false, message: `Invalid value for scene node field: ${path}.` };
+    }
+    if (isPlayableGroundDecalRenderingTextureDimensionPath(path)) {
+        const dimension = normalizePlayableGroundDecalTextureDimension(value);
+        return dimension !== null
+            ? { ok: true, value: dimension }
+            : { ok: false, message: `Invalid value for scene node field: ${path}.` };
+    }
+    return null;
+}
+export function parsePlayableGroundDecalLayerPatchPath(path) {
+    const match = path.match(/^groundDecal\.layers\.(\d+)\.(rect|textureId|text\.value|color|color\.a|tint|tint\.a|text\.color|text\.color\.a|editorPreviewPercent)$/);
+    if (!match)
+        return null;
+    const index = Number(match[1]);
+    if (!Number.isInteger(index) || index < 0)
+        return null;
+    return { index, field: match[2] };
+}
+export function isPlayableGroundDecalLayerRectPath(path) {
+    return /^groundDecal\.layers\.\d+\.rect$/.test(path);
+}
+export function isPlayableGroundDecalLayerTexturePath(path) {
+    return /^groundDecal\.layers\.\d+\.textureId$/.test(path);
+}
+export function isPlayableGroundDecalLayerColorPath(path) {
+    return /^groundDecal\.layers\.\d+\.color$/.test(path);
+}
+export function isPlayableGroundDecalLayerColorAlphaPath(path) {
+    return /^groundDecal\.layers\.\d+\.color\.a$/.test(path);
+}
+export function isPlayableGroundDecalLayerTextValuePath(path) {
+    return /^groundDecal\.layers\.\d+\.text\.value$/.test(path);
+}
+export function isPlayableGroundDecalLayerTextColorPath(path) {
+    return /^groundDecal\.layers\.\d+\.text\.color$/.test(path);
+}
+export function isPlayableGroundDecalLayerTextColorAlphaPath(path) {
+    return /^groundDecal\.layers\.\d+\.text\.color\.a$/.test(path);
+}
+export function isPlayableGroundDecalLayerTextureTintPath(path) {
+    return /^groundDecal\.layers\.\d+\.tint$/.test(path);
+}
+export function isPlayableGroundDecalLayerTextureTintAlphaPath(path) {
+    return /^groundDecal\.layers\.\d+\.tint\.a$/.test(path);
+}
+export function isPlayableGroundDecalLayerProgressPreviewPercentPath(path) {
+    return /^groundDecal\.layers\.\d+\.editorPreviewPercent$/.test(path);
+}
+export function isPlayableGroundDecalRenderingTextureDimensionPath(path) {
+    return path === 'groundDecal.rendering.textureWidth' || path === 'groundDecal.rendering.textureHeight';
+}
+export function isPlayableGroundDecalInspectorPatchPath(path) {
+    return !!parsePlayableGroundDecalLayerPatchPath(path) || isPlayableGroundDecalRenderingTextureDimensionPath(path);
+}
+export function isPlayableGroundDecalSerializedMultiFieldPath(path) {
+    return path === 'groundDecal.size.width'
+        || path === 'groundDecal.size.depth'
+        || path === 'groundDecal.layers'
+        || isPlayableGroundDecalInspectorPatchPath(path);
+}
+export function canPatchPlayableGroundDecalLayerField(layer, field, services = {}) {
+    if (field === 'rect')
+        return isPlayableGroundDecalLayoutEditableLayer(layer, services);
+    if (field === 'textureId' || field === 'tint' || field === 'tint.a')
+        return isPlayableGroundDecalEditableTextureLayer(layer, services);
+    if (field === 'text.value' || field === 'text.color' || field === 'text.color.a')
+        return isPlayableGroundDecalEditableTextLayer(layer, services);
+    if (field === 'color' || field === 'color.a')
+        return isPlayableGroundDecalEditableColorLayer(layer, services);
+    if (field === 'editorPreviewPercent')
+        return layer.kind === 'progress' && isPlayableGroundDecalEditableColorLayer(layer, services);
+    return false;
+}
+export function isPlayableGroundDecalProjectEditableLayer(layer, services = {}) {
+    return services.isProjectEditableLayer?.(layer) ?? layer.enabled !== false;
+}
+export function isPlayableGroundDecalLayoutEditableLayer(layer, services = {}) {
+    return services.isLayoutEditableLayer?.(layer) ?? layer.enabled !== false;
+}
+export function isPlayableGroundDecalEditableTextureLayer(layer, services = {}) {
+    return services.isEditableTextureLayer?.(layer) ?? layer.kind === 'texture';
+}
+export function isPlayableGroundDecalEditableColorLayer(layer, services = {}) {
+    return services.isEditableColorLayer?.(layer) ?? (layer.kind === 'color' || layer.kind === 'progress');
+}
+export function isPlayableGroundDecalEditableTextLayer(layer, services = {}) {
+    return services.isEditableTextLayer?.(layer) ?? layer.kind === 'text';
+}
+export function isPlayableGroundDecalLayoutPatchCompatibleWithDecal(decal, patches, services = {}) {
+    const editableLayers = decal.layers.filter(layer => isPlayableGroundDecalLayoutEditableLayer(layer, services));
+    if (patches.length !== editableLayers.length)
+        return false;
+    return editableLayers.every((layer, index) => patches[index]?.id === layer.id);
+}
+export function normalizePlayableGroundDecalColorValue(value) {
+    const source = readPlayableGroundDecalRecord(value);
+    if (!source)
+        return null;
+    const r = readPlayableGroundDecalFiniteNumber(source.r);
+    const g = readPlayableGroundDecalFiniteNumber(source.g);
+    const b = readPlayableGroundDecalFiniteNumber(source.b);
+    if (r == null || g == null || b == null)
+        return null;
+    const a = readPlayableGroundDecalFiniteNumber(source.a);
+    return {
+        r: roundPlayableGroundDecalFieldValue(Math.max(0, Math.min(1, r))),
+        g: roundPlayableGroundDecalFieldValue(Math.max(0, Math.min(1, g))),
+        b: roundPlayableGroundDecalFieldValue(Math.max(0, Math.min(1, b))),
+        ...(a == null ? {} : { a: roundPlayableGroundDecalFieldValue(Math.max(0, Math.min(1, a))) }),
+    };
+}
+export function normalizePlayableGroundDecalAlphaValue(value) {
+    const numeric = readPlayableGroundDecalFiniteNumber(value);
+    return numeric == null ? null : roundPlayableGroundDecalFieldValue(Math.max(0, Math.min(1, numeric)));
+}
+export function normalizePlayableGroundDecalProgressPreviewPercentValue(value) {
+    const numeric = readPlayableGroundDecalFiniteNumber(value);
+    return numeric == null ? null : Math.round(Math.max(0, Math.min(100, numeric)));
+}
+export function normalizePlayableGroundDecalTextureDimension(value) {
+    const numeric = readPlayableGroundDecalFiniteNumber(value);
+    if (numeric == null || numeric <= 0)
+        return null;
+    return Math.max(64, Math.min(2048, Math.round(numeric)));
+}
+export function roundPlayableGroundDecalFieldValue(value) {
+    return Math.round(value * 1000) / 1000;
+}
+export function normalizePlayableGroundDecalInspectorFieldValue(path, value) {
+    if (path === 'groundDecal.layers') {
+        return normalizePlayableGroundDecalLayoutPatchValue(value) ?? value;
+    }
+    if (isPlayableGroundDecalLayerRectPath(path)) {
+        return normalizePlayableGroundDecalLayoutRect(value) ?? value;
+    }
+    if (isPlayableGroundDecalLayerTexturePath(path) && typeof value === 'string') {
+        return value.trim();
+    }
+    if (isPlayableGroundDecalLayerTextValuePath(path) && typeof value === 'string') {
+        return value;
+    }
+    if (isPlayableGroundDecalLayerColorPath(path)
+        || isPlayableGroundDecalLayerTextureTintPath(path)
+        || isPlayableGroundDecalLayerTextColorPath(path)) {
+        return normalizePlayableGroundDecalColorValue(value) ?? value;
+    }
+    if (isPlayableGroundDecalLayerColorAlphaPath(path)
+        || isPlayableGroundDecalLayerTextureTintAlphaPath(path)
+        || isPlayableGroundDecalLayerTextColorAlphaPath(path)) {
+        return normalizePlayableGroundDecalAlphaValue(value) ?? value;
+    }
+    if (isPlayableGroundDecalLayerProgressPreviewPercentPath(path)) {
+        return normalizePlayableGroundDecalProgressPreviewPercentValue(value) ?? value;
+    }
+    if (isPlayableGroundDecalRenderingTextureDimensionPath(path)) {
+        return normalizePlayableGroundDecalTextureDimension(value) ?? value;
+    }
+    return value;
+}
+export function patchPlayableGroundDecalLayer(layer, field, value) {
+    if (field === 'rect') {
+        const rect = normalizePlayableGroundDecalLayoutRect(value);
+        if (!rect)
+            return null;
+        if (playableGroundDecalRectsEqual(layer.rect, rect))
+            return layer;
+        return { ...layer, rect };
+    }
+    if (field === 'textureId') {
+        if (layer.kind !== 'texture' || typeof value !== 'string' || !value.trim())
+            return null;
+        const textureId = value.trim();
+        if (layer.textureId === textureId)
+            return layer;
+        return { ...layer, textureId };
+    }
+    if (field === 'text.value') {
+        if (layer.kind !== 'text' || typeof value !== 'string')
+            return null;
+        if (layer.text.value === value)
+            return layer;
+        return { ...layer, text: { ...layer.text, value } };
+    }
+    if (field === 'color') {
+        if (layer.kind !== 'color' && layer.kind !== 'progress')
+            return null;
+        const color = normalizePlayableGroundDecalColorValue(value);
+        if (!color)
+            return null;
+        const nextColor = {
+            ...color,
+            ...(color.a == null && layer.color.a != null ? { a: layer.color.a } : {}),
+        };
+        if (playableGroundDecalColorsEqual(layer.color, nextColor))
+            return layer;
+        return { ...layer, color: nextColor };
+    }
+    if (field === 'color.a') {
+        if (layer.kind !== 'color' && layer.kind !== 'progress')
+            return null;
+        const alpha = normalizePlayableGroundDecalAlphaValue(value);
+        if (alpha === null)
+            return null;
+        const nextColor = { ...layer.color, a: alpha };
+        if (playableGroundDecalColorsEqual(layer.color, nextColor))
+            return layer;
+        return { ...layer, color: nextColor };
+    }
+    if (field === 'editorPreviewPercent') {
+        if (layer.kind !== 'progress')
+            return null;
+        const percent = normalizePlayableGroundDecalProgressPreviewPercentValue(value);
+        if (percent === null)
+            return null;
+        if (layer.editorPreviewPercent === percent)
+            return layer;
+        return { ...layer, editorPreviewPercent: percent };
+    }
+    if (field === 'tint') {
+        if (layer.kind !== 'texture')
+            return null;
+        const tint = normalizePlayableGroundDecalColorValue(value);
+        if (!tint)
+            return null;
+        const nextTint = {
+            ...tint,
+            ...(tint.a == null && layer.tint?.a != null ? { a: layer.tint.a } : {}),
+        };
+        if (playableGroundDecalColorsEqual(layer.tint ?? PLAYABLE_GROUND_DECAL_TEXTURE_TINT, nextTint))
+            return layer;
+        return { ...layer, tint: nextTint };
+    }
+    if (field === 'tint.a') {
+        if (layer.kind !== 'texture')
+            return null;
+        const alpha = normalizePlayableGroundDecalAlphaValue(value);
+        if (alpha === null)
+            return null;
+        const nextTint = { ...PLAYABLE_GROUND_DECAL_TEXTURE_TINT, ...(layer.tint ?? {}), a: alpha };
+        if (playableGroundDecalColorsEqual(layer.tint ?? PLAYABLE_GROUND_DECAL_TEXTURE_TINT, nextTint))
+            return layer;
+        return { ...layer, tint: nextTint };
+    }
+    if (field === 'text.color') {
+        if (layer.kind !== 'text')
+            return null;
+        const color = normalizePlayableGroundDecalColorValue(value);
+        if (!color)
+            return null;
+        const nextColor = {
+            ...color,
+            ...(color.a == null && layer.text.color.a != null ? { a: layer.text.color.a } : {}),
+        };
+        if (playableGroundDecalColorsEqual(layer.text.color, nextColor))
+            return layer;
+        return { ...layer, text: { ...layer.text, color: nextColor } };
+    }
+    if (field === 'text.color.a') {
+        if (layer.kind !== 'text')
+            return null;
+        const alpha = normalizePlayableGroundDecalAlphaValue(value);
+        if (alpha === null)
+            return null;
+        const nextColor = { ...layer.text.color, a: alpha };
+        if (playableGroundDecalColorsEqual(layer.text.color, nextColor))
+            return layer;
+        return { ...layer, text: { ...layer.text, color: nextColor } };
+    }
+    return null;
+}
+export function mergePlayableGroundDecalDefaults(groundDecal, createDefault, options = {}) {
+    const source = groundDecal && typeof groundDecal === 'object' && !Array.isArray(groundDecal)
+        ? groundDecal
+        : null;
+    const sourceUiKind = typeof source?.uiKind === 'string' ? source.uiKind.trim() : '';
+    const uiKind = sourceUiKind && (options.isKnownUiKind?.(sourceUiKind) ?? true)
+        ? sourceUiKind
+        : options.defaultUiKind ?? 'default';
+    const defaults = createDefault(uiKind);
+    if (!source)
+        return defaults;
+    return {
+        ...defaults,
+        ...structuredClone(source),
+        uiKind,
+        size: {
+            ...defaults.size,
+            ...(source.size && typeof source.size === 'object' ? source.size : {}),
+        },
+        layers: Array.isArray(source.layers) && source.layers.length > 0
+            ? structuredClone(source.layers)
+            : defaults.layers,
+        mask: source.mask && typeof source.mask === 'object'
+            ? { ...(defaults.mask ?? {}), ...source.mask }
+            : defaults.mask,
+        rendering: source.rendering && typeof source.rendering === 'object'
+            ? { ...(defaults.rendering ?? {}), ...source.rendering }
+            : defaults.rendering,
+    };
+}
+export function playableGroundDecalColorsEqual(left, right) {
+    return left.r === right.r
+        && left.g === right.g
+        && left.b === right.b
+        && (left.a ?? 1) === (right.a ?? 1);
+}
+export function playableGroundDecalRectsEqual(left, right) {
+    return left.x === right.x
+        && left.z === right.z
+        && left.width === right.width
+        && left.depth === right.depth;
+}
+export function resolvePlayableGroundDecalUniformScaleFromVec3(scale) {
+    const values = [scale.x, scale.y, scale.z].filter(value => Number.isFinite(value));
+    if (values.length === 0)
+        return 1;
+    const uniform = values.reduce((best, value) => Math.abs(value - 1) > Math.abs(best - 1) ? value : best, values[0]);
+    return Math.max(0.001, Math.abs(uniform));
+}
+export function canPatchPlayableEditorSceneGroundDecalMultiField(document, targetId, path, value, services) {
+    if (!isPlayableGroundDecalSerializedMultiFieldPath(path))
+        return false;
+    const gameObject = findPlayableGroundDecalGameObject(document, targetId);
+    if (!gameObject || !services.canShowGroundDecalInspector(gameObject))
+        return false;
+    const decal = mergePlayableGroundDecalDefaults(gameObject.groundDecal, services.createDefaultGroundDecal, services);
+    if (path === 'groundDecal.size.width' || path === 'groundDecal.size.depth' || isPlayableGroundDecalRenderingTextureDimensionPath(path)) {
+        return true;
+    }
+    if (path === 'groundDecal.layers') {
+        const patches = normalizePlayableGroundDecalLayoutPatchValue(value, services);
+        if (!patches)
+            return false;
+        return isPlayableGroundDecalLayoutPatchCompatibleWithDecal(decal, patches, services);
+    }
+    const parsed = parsePlayableGroundDecalLayerPatchPath(path);
+    if (!parsed)
+        return false;
+    const layer = decal.layers[parsed.index];
+    return !!layer && isPlayableGroundDecalProjectEditableLayer(layer, services) && canPatchPlayableGroundDecalLayerField(layer, parsed.field, services);
+}
+export function patchPlayableEditorSceneGroundDecalLayout(document, targetId, value, services) {
+    const patches = normalizePlayableGroundDecalLayoutPatchValue(value, services);
+    if (!patches)
+        return document;
+    return mapPlayableGroundDecalGameObjects(document, (entry) => (entry.id === targetId ? patchPlayableEditorSceneGroundDecalLayoutGameObject(entry, patches, services) : entry));
+}
+export function patchPlayableEditorSceneGroundDecalKind(document, targetId, value, services) {
+    if (typeof value !== 'string' || !value.trim())
+        return document;
+    const uiKind = value.trim();
+    if (services.isKnownUiKind && !services.isKnownUiKind(uiKind))
+        return document;
+    return mapPlayableGroundDecalGameObjects(document, (entry) => (entry.id === targetId ? patchPlayableEditorSceneGroundDecalKindGameObject(entry, uiKind, services) : entry));
+}
+export function patchPlayableEditorSceneGroundDecalInspectorField(document, targetId, path, value, services) {
+    if (isPlayableGroundDecalRenderingTextureDimensionPath(path)) {
+        return patchPlayableEditorSceneGroundDecalRenderingDimension(document, targetId, path, value, services);
+    }
+    const parsed = parsePlayableGroundDecalLayerPatchPath(path);
+    if (!parsed)
+        return null;
+    let changed = false;
+    const normalizedValue = normalizePlayableGroundDecalInspectorFieldValue(path, value);
+    const gameObjects = document.scene.gameObjects.map((entry) => {
+        if (entry.id !== targetId || !services.canShowGroundDecalInspector(entry))
+            return entry;
+        const decal = mergePlayableGroundDecalDefaults(entry.groundDecal, services.createDefaultGroundDecal, services);
+        const layer = decal.layers[parsed.index];
+        if (!layer || !isPlayableGroundDecalProjectEditableLayer(layer, services))
+            return entry;
+        if (parsed.field === 'rect' && !isPlayableGroundDecalLayoutEditableLayer(layer, services))
+            return entry;
+        const patchedLayer = patchPlayableGroundDecalLayer(layer, parsed.field, normalizedValue);
+        if (!patchedLayer || patchedLayer === layer)
+            return entry;
+        const layers = [...decal.layers];
+        layers[parsed.index] = patchedLayer;
+        changed = true;
+        return normalizePlayableEditorSceneGroundDecalGameObject({
+            ...entry,
+            groundDecal: {
+                ...decal,
+                layers,
+            },
+        }, services);
+    });
+    return changed ? { ...document, scene: { ...document.scene, gameObjects } } : document;
+}
+export function patchPlayableEditorSceneGroundDecalRenderingDimension(document, targetId, path, value, services) {
+    const dimension = normalizePlayableGroundDecalTextureDimension(value);
+    if (dimension === null)
+        return document;
+    const key = path === 'groundDecal.rendering.textureWidth' ? 'textureWidth' : 'textureHeight';
+    let changed = false;
+    const gameObjects = document.scene.gameObjects.map((entry) => {
+        if (entry.id !== targetId || !services.canShowGroundDecalInspector(entry))
+            return entry;
+        const decal = mergePlayableGroundDecalDefaults(entry.groundDecal, services.createDefaultGroundDecal, services);
+        if (decal.rendering?.[key] === dimension)
+            return entry;
+        changed = true;
+        return normalizePlayableEditorSceneGroundDecalGameObject({
+            ...entry,
+            groundDecal: {
+                ...decal,
+                rendering: {
+                    ...decal.rendering,
+                    [key]: dimension,
+                },
+            },
+        }, services);
+    });
+    return changed ? { ...document, scene: { ...document.scene, gameObjects } } : document;
+}
+export function replacePlayableEditorSceneGroundDecalUi(document, targetId, groundDecal, services) {
+    if (!services.isGroundDecalConfig(groundDecal))
+        return document;
+    let changed = false;
+    const gameObjects = document.scene.gameObjects.map((entry) => {
+        if (entry.id !== targetId)
+            return entry;
+        if (!services.isGroundDecalUiGameObject(entry) || entry.groundDecal.uiKind !== groundDecal.uiKind)
+            return entry;
+        changed = true;
+        return normalizePlayableEditorSceneGroundDecalGameObject({
+            ...entry,
+            kind: 'transform',
+            transformType: 'groundDecal',
+            groundDecal: mergePlayableGroundDecalDefaults(groundDecal, services.createDefaultGroundDecal, services),
+        }, services);
+    });
+    return changed ? { ...document, scene: { ...document.scene, gameObjects } } : document;
+}
+export function normalizePlayableGroundDecalUiScaleAfterFieldPatch(document, targetId, path, value, services) {
+    if (!path.startsWith('transform.scale'))
+        return document;
+    return normalizePlayableGroundDecalUiScales(document, services, targetId, resolvePlayableGroundDecalUiInspectorScale(path, value));
+}
+export function normalizePlayableGroundDecalUiScalesForCommand(document, command, services) {
+    if (command.type === 'document.replace')
+        return normalizePlayableGroundDecalUiScales(document, services);
+    const patch = command.patch;
+    if (patch.kind === 'game-object.field') {
+        return normalizePlayableGroundDecalUiScaleAfterFieldPatch(document, String(patch.targetId ?? ''), String(patch.path ?? ''), patch.value, services);
+    }
+    if (patch.kind === 'game-object.field-batch') {
+        if (Array.isArray(patch.fields)) {
+            return patch.fields.reduce((nextDocument, field) => {
+                const record = readPlayableGroundDecalRecord(field);
+                return normalizePlayableGroundDecalUiScaleAfterFieldPatch(nextDocument, String(record?.targetId ?? ''), String(record?.path ?? ''), record?.value, services);
+            }, document);
+        }
+        if (Array.isArray(patch.targetIds)) {
+            return patch.targetIds.reduce((nextDocument, targetId) => (normalizePlayableGroundDecalUiScaleAfterFieldPatch(nextDocument, String(targetId), String(patch.path ?? ''), patch.value, services)), document);
+        }
+        return document;
+    }
+    return normalizePlayableGroundDecalUiScales(document, services);
+}
+export function normalizePlayableGroundDecalUiScales(document, services, targetId, uniformOverride) {
+    let changed = false;
+    const gameObjects = document.scene.gameObjects.map((gameObject) => {
+        if ((targetId && gameObject.id !== targetId) || !services.isGroundDecalUiGameObject(gameObject))
+            return gameObject;
+        const transform = findEditorSceneTransform(gameObject);
+        if (!transform || !isPlayableGroundDecalTrsTransformComponent(transform) || !transform.scale)
+            return gameObject;
+        const uniform = uniformOverride ?? resolvePlayableGroundDecalUniformScaleFromVec3(transform.scale);
+        if (Math.abs(transform.scale.x - uniform) < 0.000001
+            && Math.abs(transform.scale.y - uniform) < 0.000001
+            && Math.abs(transform.scale.z - uniform) < 0.000001) {
+            return gameObject;
+        }
+        changed = true;
+        return {
+            ...gameObject,
+            components: gameObject.components.map((component) => component === transform
+                ? { ...component, scale: { x: uniform, y: uniform, z: uniform } }
+                : component),
+        };
+    });
+    return changed ? { ...document, scene: { ...document.scene, gameObjects } } : document;
+}
+export function normalizePlayableEditorSceneGroundDecalGameObject(gameObject, services) {
+    const next = ensurePlayableGroundDecalTransformComponent({
+        ...gameObject,
+        kind: 'transform',
+        transformType: 'groundDecal',
+        groundDecal: mergePlayableGroundDecalDefaults(gameObject.groundDecal, services.createDefaultGroundDecal, services),
+    });
+    delete next.camera;
+    delete next.light;
+    delete next.primitive;
+    return next;
+}
+export function isPlayableEditorSceneGroundDecalProjectionPath(path) {
+    return path === 'groundDecal' || path.startsWith('groundDecal.');
+}
+function patchPlayableEditorSceneGroundDecalLayoutGameObject(gameObject, patches, services) {
+    const patchById = new Map(patches.map(patch => [patch.id, patch]));
+    const decal = mergePlayableGroundDecalDefaults(gameObject.groundDecal, services.createDefaultGroundDecal, services);
+    return normalizePlayableEditorSceneGroundDecalGameObject({
+        ...gameObject,
+        kind: 'transform',
+        transformType: 'groundDecal',
+        groundDecal: {
+            ...decal,
+            layers: decal.layers.map((layer, index) => {
+                if (!isPlayableGroundDecalLayoutEditableLayer(layer, services))
+                    return layer;
+                const patch = patchById.get(layer.id) ?? patches[index];
+                return patch ? { ...layer, rect: patch.rect } : layer;
+            }),
+        },
+    }, services);
+}
+function patchPlayableEditorSceneGroundDecalKindGameObject(gameObject, uiKind, services) {
+    const previous = mergePlayableGroundDecalDefaults(gameObject.groundDecal, services.createDefaultGroundDecal, services);
+    const defaults = services.createDefaultGroundDecal(uiKind);
+    return normalizePlayableEditorSceneGroundDecalGameObject({
+        ...gameObject,
+        kind: 'transform',
+        transformType: 'groundDecal',
+        groundDecal: {
+            ...defaults,
+            size: previous.size,
+            mask: previous.mask ?? defaults.mask,
+            rendering: previous.rendering ?? defaults.rendering,
+        },
+    }, services);
+}
+function ensurePlayableGroundDecalTransformComponent(gameObject) {
+    if (gameObject.components.some(component => component.type === 'Transform'))
+        return gameObject;
+    return {
+        ...gameObject,
+        components: [createPlayableGroundDecalIdentityTransformComponent(), ...gameObject.components],
+    };
+}
+function createPlayableGroundDecalIdentityTransformComponent() {
+    return {
+        type: 'Transform',
+        position: { x: 0, y: 0, z: 0 },
+        rotation: { x: 0, y: 0, z: 0 },
+        scale: { x: 1, y: 1, z: 1 },
+    };
+}
+function isPlayableGroundDecalTrsTransformComponent(component) {
+    return component.type === 'Transform' && component.mode !== 'matrix';
+}
+function findPlayableGroundDecalGameObject(document, gameObjectId) {
+    if (!gameObjectId)
+        return null;
+    return document.scene.gameObjects.find(gameObject => gameObject.id === gameObjectId) ?? null;
+}
+function mapPlayableGroundDecalGameObjects(document, mapGameObject) {
+    return {
+        ...document,
+        scene: {
+            ...document.scene,
+            gameObjects: document.scene.gameObjects.map(mapGameObject),
+        },
+    };
+}
+export function createPlayableGroundDecalInspectorProperties(nodeKind, groundDecal, options = {}, services) {
+    const decal = mergePlayableGroundDecalDefaults(groundDecal, services.createDefaultGroundDecal, services);
+    const properties = [
+        createPlayableReadonlyInspectorProperty('groundDecal.uiKind', 'Type', services.createUiKindLabel?.(decal.uiKind) ?? decal.uiKind, 0),
+        services.createDocumentInspectorProperty(null, nodeKind, {
+            path: 'groundDecal.size.width',
+            label: 'Width',
+            valueType: 'number',
+            control: 'number',
+            value: decal.size.width,
+            commitMode: 'live',
+            order: 1,
+            min: 0.001,
+            step: 0.1,
+        }),
+        services.createDocumentInspectorProperty(null, nodeKind, {
+            path: 'groundDecal.size.depth',
+            label: 'Depth',
+            valueType: 'number',
+            control: 'number',
+            value: decal.size.depth,
+            commitMode: 'live',
+            order: 2,
+            min: 0.001,
+            step: 0.1,
+        }),
+        services.createDocumentInspectorProperty(null, nodeKind, {
+            path: 'groundDecal.rendering.textureWidth',
+            label: 'Texture Width',
+            valueType: 'number',
+            control: 'number',
+            value: decal.rendering?.textureWidth ?? 512,
+            commitMode: 'change',
+            order: 3,
+            min: 64,
+            max: 2048,
+            step: 64,
+        }),
+        services.createDocumentInspectorProperty(null, nodeKind, {
+            path: 'groundDecal.rendering.textureHeight',
+            label: 'Texture Height',
+            valueType: 'number',
+            control: 'number',
+            value: decal.rendering?.textureHeight ?? 512,
+            commitMode: 'change',
+            order: 4,
+            min: 64,
+            max: 2048,
+            step: 64,
+        }),
+        services.createDocumentInspectorProperty(null, nodeKind, {
+            path: 'groundDecal.layers',
+            label: 'Layout',
+            valueType: 'object',
+            control: 'custom',
+            customControl: 'ground-decal-layout',
+            value: createPlayableGroundDecalLayoutInspectorValue(decal, options, services),
+            commitMode: 'live',
+            order: 5,
+            coerce: (value) => services.normalizeValue('groundDecal.layers', value),
+            controlOptions: {
+                aspectRatio: resolvePlayableGroundDecalLayoutAspectRatio(decal),
+            },
+        }),
+    ];
+    let order = 10;
+    if (options.enableGroundDecalUiActions && (services.canShowLayerPairActions?.(decal) ?? false) && services.layerPairActions) {
+        const pairCount = services.getLayerPairs?.(decal).length ?? 0;
+        const canAddPair = services.canAddLayerPair?.(decal) ?? false;
+        const canRemovePair = services.canRemoveLayerPair?.(decal) ?? false;
+        properties.push(createPlayableInspectorActionProperty({
+            path: services.layerPairActions.addPath ?? 'groundDecal.layerPairs.add',
+            label: services.layerPairActions.addLabel ?? 'Add item',
+            actionId: services.layerPairActions.addActionId,
+            order,
+            icon: 'asset',
+            tooltip: services.layerPairActions.addTooltip ?? 'Add an item.',
+            params: {},
+            disabled: !canAddPair,
+            disabledReason: canAddPair ? undefined : services.createLayerPairDisabledReason?.({ decal, action: 'add', pairCount }),
+            effect: canAddPair ? 'active' : 'unsupported',
+        }));
+        order += 1;
+        properties.push(createPlayableInspectorActionProperty({
+            path: services.layerPairActions.removePath ?? 'groundDecal.layerPairs.remove',
+            label: services.layerPairActions.removeLabel ?? 'Remove item',
+            actionId: services.layerPairActions.removeActionId,
+            order,
+            icon: 'asset',
+            tooltip: services.layerPairActions.removeTooltip ?? 'Remove an item.',
+            params: {},
+            disabled: !canRemovePair,
+            disabledReason: canRemovePair ? undefined : services.createLayerPairDisabledReason?.({ decal, action: 'remove', pairCount }),
+            effect: canRemovePair ? 'active' : 'unsupported',
+        }));
+        order += 1;
+    }
+    for (let index = 0; index < decal.layers.length; index += 1) {
+        const layer = decal.layers[index];
+        if (!layer || !isPlayableGroundDecalProjectEditableLayer(layer, services))
+            continue;
+        const label = createPlayableGroundDecalLayerLabel(layer, services);
+        if (isPlayableGroundDecalEditableTextureLayer(layer, services)) {
+            properties.push(createPlayableGroundDecalTextureInspectorProperty(nodeKind, options, layer, index, label, order, services));
+            order += 1;
+            properties.push(createPlayableGroundDecalTextureTintInspectorProperty(nodeKind, layer, index, label, order, services));
+            order += 1;
+            properties.push(createPlayableGroundDecalTextureTintAlphaInspectorProperty(nodeKind, layer, index, label, order, services));
+            order += 1;
+        }
+        if (layer.kind === 'progress' && isPlayableGroundDecalEditableColorLayer(layer, services)) {
+            properties.push(createPlayableGroundDecalProgressPreviewInspectorProperty(nodeKind, layer, index, label, order, services));
+            order += 1;
+        }
+        if (isPlayableGroundDecalEditableColorLayer(layer, services)) {
+            properties.push(createPlayableGroundDecalColorInspectorProperty(nodeKind, layer, index, label, order, services));
+            order += 1;
+            properties.push(createPlayableGroundDecalColorAlphaInspectorProperty(nodeKind, layer, index, label, order, services));
+            order += 1;
+        }
+        if (isPlayableGroundDecalEditableTextLayer(layer, services)) {
+            properties.push(services.createDocumentInspectorProperty(null, nodeKind, {
+                path: `groundDecal.layers.${index}.text.value`,
+                label: `${label} Text`,
+                valueType: 'string',
+                control: 'string',
+                value: layer.text.value,
+                commitMode: 'blur',
+                order,
+                tags: ['GroundDecalUI', 'Text'],
+            }));
+            order += 1;
+            properties.push(createPlayableGroundDecalTextColorInspectorProperty(nodeKind, layer, index, label, order, services));
+            order += 1;
+            properties.push(createPlayableGroundDecalTextColorAlphaInspectorProperty(nodeKind, layer, index, label, order, services));
+            order += 1;
+        }
+    }
+    appendPlayableReadonlyInspectorProperty(properties, {
+        path: 'groundDecal.raw',
+        label: 'Raw Ground Decal',
+        value: groundDecal ?? decal,
+        order,
+        source: 'Document',
+        tags: ['Raw'],
+    });
+    return properties;
+}
+export function createPlayableGroundDecalInspectorSection(target, nodeKind, context, services) {
+    const groundDecal = services.getTargetGroundDecal(target);
+    return {
+        id: 'groundDecal',
+        title: 'Ground Decal',
+        order: 40,
+        placement: 'body',
+        summary: groundDecal ? 'Configured' : 'Defaults',
+        persistence: 'document',
+        collapsedByDefault: true,
+        properties: createPlayableGroundDecalInspectorProperties(nodeKind, groundDecal, {
+            ...context,
+            enableGroundDecalUiActions: services.isUiTarget?.(target) ?? false,
+        }, services),
+    };
+}
+export function createPlayableGroundDecalMultiInspectorSection(document, targetIds, activeId, context, services) {
+    const targets = resolvePlayableGroundDecalMultiInspectorTargets(document, targetIds, services);
+    if (targets.length <= 1)
+        return null;
+    const activeTarget = targets.find(target => services.getTargetId(target.target) === activeId) ?? targets[0];
+    if (!activeTarget)
+        return null;
+    const compatibleLayerSignature = haveCompatiblePlayableGroundDecalLayerSignatures(targets.map(target => target.decal), services);
+    const nodeKind = services.getTargetNodeKind(activeTarget.target);
+    const properties = createPlayableGroundDecalInspectorProperties(nodeKind, activeTarget.decal, {
+        ...context,
+        enableGroundDecalUiActions: false,
+    }, services)
+        .filter(property => isPlayableGroundDecalMultiInspectorProperty(property, compatibleLayerSignature))
+        .filter(property => targets.every(target => (property.readOnly
+        || services.canPatchMultiField(document, services.getTargetId(target.target), property.path, property.value))))
+        .map(property => ({
+        ...property,
+        mixed: isPlayableGroundDecalMultiInspectorPropertyMixed(targets, property.path, context, services),
+    }));
+    if (properties.length === 0)
+        return null;
+    const mixedKind = targets.some(target => target.decal.uiKind !== activeTarget.decal.uiKind);
+    return {
+        id: 'groundDecal',
+        title: 'Ground Decal',
+        order: 40,
+        placement: 'body',
+        summary: mixedKind ? 'Mixed' : `${targets.length} ${services.createUiKindLabel?.(activeTarget.decal.uiKind) ?? activeTarget.decal.uiKind} UIs`,
+        persistence: 'document',
+        collapsedByDefault: false,
+        properties,
+    };
+}
+export function resolvePlayableGroundDecalMultiInspectorTargetIds(document, targetIds, services) {
+    return resolvePlayableGroundDecalMultiInspectorTargets(document, targetIds, services)
+        .map(target => services.getTargetId(target.target));
+}
+function resolvePlayableGroundDecalMultiInspectorTargets(document, targetIds, services) {
+    const seen = new Set();
+    const targets = [];
+    for (const targetId of targetIds) {
+        if (!targetId || seen.has(targetId))
+            continue;
+        seen.add(targetId);
+        const target = services.findTarget(document, targetId);
+        if (!target || !services.canShowTarget(target))
+            continue;
+        targets.push({
+            target,
+            decal: mergePlayableGroundDecalDefaults(services.getTargetGroundDecal(target), services.createDefaultGroundDecal, services),
+        });
+    }
+    return targets;
+}
+function haveCompatiblePlayableGroundDecalLayerSignatures(decals, services = {}) {
+    if (decals.length === 0)
+        return false;
+    const [firstSignature, ...rest] = decals.map(decal => createPlayableGroundDecalEditableLayerSignature(decal, services));
+    return rest.every(signature => signature === firstSignature);
+}
+function createPlayableGroundDecalEditableLayerSignature(decal, services = {}) {
+    return decal.layers
+        .map((layer, index) => ({ layer, index }))
+        .filter(entry => isPlayableGroundDecalProjectEditableLayer(entry.layer, services))
+        .map(({ layer, index }) => `${index}:${layer.id}:${layer.role}:${layer.kind}`)
+        .join('|');
+}
+function isPlayableGroundDecalMultiInspectorProperty(property, compatibleLayerSignature) {
+    if (property.path === 'groundDecal.raw')
+        return false;
+    if (property.path === 'groundDecal.uiKind')
+        return true;
+    if (property.path === 'groundDecal.size.width' || property.path === 'groundDecal.size.depth')
+        return true;
+    if (isPlayableGroundDecalRenderingTextureDimensionPath(property.path))
+        return true;
+    if (property.path === 'groundDecal.layers' || parsePlayableGroundDecalLayerPatchPath(property.path)) {
+        return compatibleLayerSignature;
+    }
+    return false;
+}
+function isPlayableGroundDecalMultiInspectorPropertyMixed(targets, path, context, services) {
+    if (targets.length <= 1)
+        return false;
+    const [first, ...rest] = targets.map(target => (JSON.stringify(readPlayableGroundDecalMultiInspectorComparableValue(target.decal, path, context, services))));
+    return rest.some(value => value !== first);
+}
+function readPlayableGroundDecalMultiInspectorComparableValue(decal, path, context, services) {
+    if (path === 'groundDecal.uiKind')
+        return decal.uiKind;
+    if (path === 'groundDecal.size.width')
+        return decal.size.width;
+    if (path === 'groundDecal.size.depth')
+        return decal.size.depth;
+    if (path === 'groundDecal.rendering.textureWidth')
+        return decal.rendering?.textureWidth ?? 512;
+    if (path === 'groundDecal.rendering.textureHeight')
+        return decal.rendering?.textureHeight ?? 512;
+    if (path === 'groundDecal.layers') {
+        return createPlayableGroundDecalLayoutInspectorValue(decal, context, services).layers;
+    }
+    const parsed = parsePlayableGroundDecalLayerPatchPath(path);
+    if (!parsed)
+        return undefined;
+    const layer = decal.layers[parsed.index];
+    if (!layer)
+        return undefined;
+    return readPlayableGroundDecalLayerPatchFieldValue(layer, parsed.field);
+}
+function readPlayableGroundDecalLayerPatchFieldValue(layer, field) {
+    if (field === 'rect')
+        return layer.rect;
+    if (field === 'textureId')
+        return layer.kind === 'texture' ? layer.textureId : undefined;
+    if (field === 'text.value')
+        return layer.kind === 'text' ? layer.text.value : undefined;
+    if (field === 'color')
+        return layer.kind === 'color' || layer.kind === 'progress' ? layer.color : undefined;
+    if (field === 'color.a')
+        return layer.kind === 'color' || layer.kind === 'progress' ? layer.color.a ?? 1 : undefined;
+    if (field === 'tint')
+        return layer.kind === 'texture' ? layer.tint ?? PLAYABLE_GROUND_DECAL_TEXTURE_TINT : undefined;
+    if (field === 'tint.a')
+        return layer.kind === 'texture' ? layer.tint?.a ?? 1 : undefined;
+    if (field === 'text.color')
+        return layer.kind === 'text' ? layer.text.color : undefined;
+    if (field === 'text.color.a')
+        return layer.kind === 'text' ? layer.text.color.a ?? 1 : undefined;
+    if (field === 'editorPreviewPercent')
+        return layer.kind === 'progress' ? resolvePlayableGroundDecalEditorPreviewProgressPercent(layer) : undefined;
+    return undefined;
+}
+function createPlayableGroundDecalLayoutInspectorValue(decal, context, services) {
+    const layoutEditableLayers = decal.layers
+        .map((layer, index) => ({ layer, index }))
+        .filter(entry => isPlayableGroundDecalLayoutEditableLayer(entry.layer, services));
+    return {
+        textureSize: {
+            width: decal.rendering?.textureWidth ?? 512,
+            height: decal.rendering?.textureHeight ?? 512,
+        },
+        mask: decal.mask,
+        layers: layoutEditableLayers.map(({ layer, index }) => createPlayableGroundDecalLayoutInspectorLayer(context, layer, index, services)),
+        previewLayers: decal.layers.map((layer, index) => createPlayableGroundDecalLayoutInspectorLayer(context, layer, index, services)),
+    };
+}
+function createPlayableGroundDecalLayoutInspectorLayer(context, layer, index, services) {
+    return {
+        index,
+        id: layer.id,
+        role: layer.role,
+        kind: layer.kind,
+        label: createPlayableGroundDecalLayerLabel(layer, services),
+        rect: layer.rect,
+        enabled: layer.enabled !== false,
+        editable: isPlayableGroundDecalLayoutEditableLayer(layer, services),
+        zOrder: layer.zOrder,
+        ...(typeof layer.opacity === 'number' ? { opacity: layer.opacity } : {}),
+        ...(services.useUniformLayoutScaleMode?.(layer) ? { scaleMode: 'uniform' } : {}),
+        preview: createPlayableGroundDecalLayerPreview(context, layer, services),
+    };
+}
+export function createPlayableGroundDecalLayerLabel(layer, services = {}) {
+    const label = services.createLayerLabel?.(layer);
+    if (label)
+        return label;
+    return layer.role.charAt(0).toUpperCase() + layer.role.slice(1);
+}
+function createPlayableGroundDecalLayerPreview(context, layer, services) {
+    if (layer.kind === 'texture') {
+        const textureAsset = services.findTextureAsset?.(context, layer.textureId) ?? null;
+        const url = textureAsset?.url ?? services.resolveTextureAssetUrl?.(layer.textureId);
+        return url
+            ? {
+                kind: 'image',
+                url,
+                alt: textureAsset?.label ?? layer.textureId,
+                ...(layer.tint ? { tint: layer.tint } : {}),
+            }
+            : undefined;
+    }
+    if (layer.kind === 'color') {
+        return { kind: 'color', color: layer.color };
+    }
+    if (layer.kind === 'progress') {
+        return {
+            kind: 'progress',
+            value: resolvePlayableGroundDecalEditorPreviewProgressValue(layer),
+            direction: layer.direction,
+            color: layer.color,
+        };
+    }
+    if (layer.kind === 'text') {
+        return {
+            kind: 'text',
+            text: layer.text.value,
+            fontFamily: layer.text.fontFamily,
+            fontSize: layer.text.fontSize,
+            fontWeight: layer.text.fontWeight,
+            color: layer.text.color,
+            strokeColor: layer.text.strokeColor,
+            strokeWidth: layer.text.strokeWidth,
+            align: layer.text.align,
+            baseline: layer.text.baseline,
+        };
+    }
+    return undefined;
+}
+function resolvePlayableGroundDecalEditorPreviewProgressPercent(layer) {
+    const percent = typeof layer.editorPreviewPercent === 'number' && Number.isFinite(layer.editorPreviewPercent)
+        ? layer.editorPreviewPercent
+        : PLAYABLE_GROUND_DECAL_UI_EDITOR_PROGRESS_PERCENT;
+    return Math.round(Math.max(0, Math.min(100, percent)));
+}
+function resolvePlayableGroundDecalEditorPreviewProgressValue(layer) {
+    return resolvePlayableGroundDecalEditorPreviewProgressPercent(layer) / 100;
+}
+function createPlayableGroundDecalTextureInspectorProperty(nodeKind, context, layer, layerIndex, label, order, services) {
+    const text = services.getMaterialText?.('zh');
+    const currentTexture = services.findTextureAsset?.(context, layer.textureId) ?? null;
+    const path = `groundDecal.layers.${layerIndex}.textureId`;
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path,
+        label: `${label} PNG`,
+        valueType: 'string',
+        control: 'custom',
+        customControl: 'asset-picker-card',
+        value: layer.textureId,
+        commitMode: 'change',
+        order,
+        tags: ['GroundDecalUI', 'TextureAsset'],
+        controlOptions: services.createTexturePickerControlOptions?.(context, text, layer.textureId, currentTexture) ?? {
+            currentTextureId: layer.textureId,
+            currentTexture,
+        },
+        coerce: (value) => services.normalizeValue(path, value),
+    });
+}
+function createPlayableGroundDecalColorInspectorProperty(nodeKind, layer, layerIndex, label, order, services) {
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path: `groundDecal.layers.${layerIndex}.color`,
+        label: `${label} Color`,
+        valueType: 'color',
+        control: 'color',
+        value: layer.color,
+        commitMode: 'immediate',
+        order,
+        tags: ['GroundDecalUI', 'Color'],
+    });
+}
+function createPlayableGroundDecalColorAlphaInspectorProperty(nodeKind, layer, layerIndex, label, order, services) {
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path: `groundDecal.layers.${layerIndex}.color.a`,
+        label: `${label} Alpha`,
+        valueType: 'number',
+        control: 'number',
+        value: layer.color.a ?? 1,
+        commitMode: 'live',
+        order,
+        min: 0,
+        max: 1,
+        step: 0.01,
+        tags: ['GroundDecalUI', 'Color'],
+    });
+}
+function createPlayableGroundDecalProgressPreviewInspectorProperty(nodeKind, layer, layerIndex, label, order, services) {
+    const path = `groundDecal.layers.${layerIndex}.editorPreviewPercent`;
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path,
+        label: `${label} Preview %`,
+        valueType: 'number',
+        control: 'number',
+        value: resolvePlayableGroundDecalEditorPreviewProgressPercent(layer),
+        commitMode: 'blur',
+        order,
+        min: 0,
+        max: 100,
+        step: 1,
+        tags: ['GroundDecalUI', 'Progress'],
+        coerce: (value) => services.normalizeValue(path, value),
+    });
+}
+function createPlayableGroundDecalTextureTintInspectorProperty(nodeKind, layer, layerIndex, label, order, services) {
+    const tint = layer.tint ?? PLAYABLE_GROUND_DECAL_TEXTURE_TINT;
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path: `groundDecal.layers.${layerIndex}.tint`,
+        label: `${label} Tint Color`,
+        valueType: 'color',
+        control: 'color',
+        value: tint,
+        commitMode: 'immediate',
+        order,
+        tags: ['GroundDecalUI', 'Color'],
+    });
+}
+function createPlayableGroundDecalTextureTintAlphaInspectorProperty(nodeKind, layer, layerIndex, label, order, services) {
+    const tint = layer.tint ?? PLAYABLE_GROUND_DECAL_TEXTURE_TINT;
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path: `groundDecal.layers.${layerIndex}.tint.a`,
+        label: `${label} Tint Alpha`,
+        valueType: 'number',
+        control: 'number',
+        value: tint.a ?? 1,
+        commitMode: 'live',
+        order,
+        min: 0,
+        max: 1,
+        step: 0.01,
+        tags: ['GroundDecalUI', 'Color'],
+    });
+}
+function createPlayableGroundDecalTextColorInspectorProperty(nodeKind, layer, layerIndex, label, order, services) {
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path: `groundDecal.layers.${layerIndex}.text.color`,
+        label: `${label} Text Color`,
+        valueType: 'color',
+        control: 'color',
+        value: layer.text.color,
+        commitMode: 'immediate',
+        order,
+        tags: ['GroundDecalUI', 'Color'],
+    });
+}
+function createPlayableGroundDecalTextColorAlphaInspectorProperty(nodeKind, layer, layerIndex, label, order, services) {
+    return services.createDocumentInspectorProperty(null, nodeKind, {
+        path: `groundDecal.layers.${layerIndex}.text.color.a`,
+        label: `${label} Text Alpha`,
+        valueType: 'number',
+        control: 'number',
+        value: layer.text.color.a ?? 1,
+        commitMode: 'live',
+        order,
+        min: 0,
+        max: 1,
+        step: 0.01,
+        tags: ['GroundDecalUI', 'Color'],
+    });
+}
+function resolvePlayableGroundDecalLayoutAspectRatio(decal) {
+    const sourceLayer = decal.layers.find(layer => layer.id === decal.aspectSourceLayerId);
+    const sourceRect = sourceLayer?.rect;
+    if (sourceRect && sourceRect.width > 0 && sourceRect.depth > 0)
+        return sourceRect.width / sourceRect.depth;
+    return decal.size.width > 0 && decal.size.depth > 0 ? decal.size.width / decal.size.depth : 1;
+}
+function appendPlayableReadonlyInspectorProperty(properties, input) {
+    const property = createEditorSceneReadonlyInspectorProperty(input);
+    if (property)
+        properties.push(property);
+}
+function createPlayableReadonlyInspectorProperty(path, label, value, order, tooltip) {
+    return createEditorSceneReadonlyInspectorProperty({
+        path,
+        label,
+        value,
+        order,
+        persistence: 'readonly',
+        source: 'Document',
+        tooltip,
+    });
+}
+function createPlayableInspectorActionProperty(input) {
+    const params = Object.fromEntries(Object.entries(input.params).filter((entry) => typeof entry[1] === 'string' && entry[1].length > 0));
+    return {
+        path: input.path,
+        label: input.label,
+        valueType: 'string',
+        control: 'custom',
+        customControl: 'inspector-action-button',
+        controlOptions: {
+            actionId: input.actionId,
+            label: input.label,
+            icon: input.icon,
+            params,
+            ...(input.disabled ? { disabled: true } : {}),
+            ...(input.disabledReason ? { disabledReason: input.disabledReason } : {}),
+        },
+        value: input.actionId,
+        readOnly: false,
+        persistence: 'readonly',
+        commitMode: 'immediate',
+        order: input.order,
+        tooltip: input.disabledReason ?? input.tooltip,
+        effect: input.effect,
+        disabledReason: input.disabled ? input.disabledReason : undefined,
+    };
+}
+function readPlayableGroundDecalRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function readPlayableGroundDecalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+//# sourceMappingURL=ground-decal.js.map