@skenora/editor 0.1.2

package/dist/properties/property-descriptors.js

@@ -0,0 +1,832 @@
+import { DEFAULT_ATMOSPHERE_SKY_PARAMETERS, getMaterialBindingsForEntity, } from "@skenora/contracts";
+import { duplicateEntityTreeCommand, removeEntityCommand, renameEntityCommand, reparentEntityCommand, setEntityEnabledCommand, setEntityVisibleCommand, setPropertyCommand, } from "../core/commands.js";
+export const MIXED_VALUE = Object.freeze({ kind: "mixed" });
+export class EditFacade {
+    #session;
+    #providers = new Set();
+    constructor(session) {
+        this.#session = session;
+    }
+    registerPropertyProvider(provider) {
+        this.#providers.add(provider);
+        return () => this.#providers.delete(provider);
+    }
+    describe(entityId) {
+        const entity = this.#session.snapshot.entities[entityId];
+        if (!entity)
+            return [];
+        return [
+            ...createCoreEntityDescriptors(entity),
+            ...createTypedEntityDescriptors(entity),
+            ...createMaterialDescriptors(this.#session.snapshot, entity),
+            ...[...this.#providers].flatMap((provider) => provider(this.#session.snapshot, entity)),
+        ];
+    }
+    describeMany(entityIds) {
+        const targets = [...new Set(entityIds)].filter((entityId) => this.#session.snapshot.entities[entityId]);
+        if (targets.length === 0)
+            return [];
+        const descriptorSets = targets.map((entityId) => this.describe(entityId));
+        const first = descriptorSets[0] ?? [];
+        return first.flatMap((descriptor) => {
+            const matches = descriptorSets.map((descriptors) => descriptors.find((candidate) => candidate.id === descriptor.id &&
+                candidate.kind === descriptor.kind &&
+                candidate.group === descriptor.group));
+            if (matches.some((candidate) => !candidate))
+                return [];
+            const values = matches.map((candidate) => candidate?.value);
+            const value = values.every((candidate) => propertyValuesEqual(candidate, values[0]))
+                ? descriptor.value
+                : MIXED_VALUE;
+            return [
+                {
+                    ...descriptor,
+                    paths: matches.flatMap((candidate) => candidate ? [candidate.path] : []),
+                    value,
+                },
+            ];
+        });
+    }
+    describeScene() {
+        const document = this.#session.snapshot;
+        const skybox = document.environment.background.skybox;
+        const atmosphere = skybox?.source.kind === "procedural"
+            ? skybox.source.parameters
+            : undefined;
+        const skyboxDescriptors = skybox
+            ? [
+                {
+                    id: "skybox-rotation",
+                    label: "Sky rotation",
+                    group: "environment",
+                    kind: "number",
+                    path: ["environment", "background", "skybox", "rotationY"],
+                    value: skybox.rotationY ?? 0,
+                    step: 0.01,
+                },
+                {
+                    id: "skybox-blur",
+                    label: "Sky blur",
+                    group: "environment",
+                    kind: "number",
+                    path: ["environment", "background", "skybox", "blur"],
+                    value: skybox.blur ?? 0,
+                    min: 0,
+                    max: 1,
+                    step: 0.01,
+                },
+                {
+                    id: "skybox-fog-participation",
+                    label: "Sky fog participation",
+                    group: "environment",
+                    kind: "select",
+                    path: ["environment", "background", "skybox", "fogParticipation"],
+                    value: skybox.fogParticipation ?? "disabled",
+                    options: [
+                        { label: "Disabled", value: "disabled" },
+                        { label: "Inherit scene fog", value: "inherit" },
+                    ],
+                },
+            ]
+            : [];
+        const atmosphereDescriptors = atmosphere
+            ? createAtmosphereDescriptors(atmosphere)
+            : skybox?.source.kind === "procedural"
+                ? createAtmosphereDescriptors({})
+                : [];
+        return [
+            {
+                id: "environment-intensity",
+                label: "Environment intensity",
+                group: "environment",
+                kind: "number",
+                path: ["environment", "intensity"],
+                value: document.environment.intensity,
+                min: 0,
+                step: 0.05,
+            },
+            {
+                id: "environment-rotation",
+                label: "Environment rotation",
+                group: "environment",
+                kind: "number",
+                path: ["environment", "rotationY"],
+                value: document.environment.rotationY,
+                step: 0.01,
+            },
+            {
+                id: "background-color",
+                label: "Background",
+                group: "environment",
+                kind: "color",
+                path: ["environment", "background", "color"],
+                value: document.environment.background.color,
+            },
+            ...skyboxDescriptors,
+            ...atmosphereDescriptors,
+            {
+                id: "camera-fov",
+                label: "Camera FOV",
+                group: "general",
+                kind: "number",
+                path: ["camera", "fov"],
+                value: document.camera.fov ?? 0.8,
+                min: 0.1,
+                max: Math.PI - 0.1,
+                step: 0.01,
+            },
+            {
+                id: "post-bloom",
+                label: "Bloom",
+                group: "environment",
+                kind: "boolean",
+                path: ["postProcess", "bloom"],
+                value: document.postProcess.bloom,
+            },
+            {
+                id: "post-enabled",
+                label: "Post processing",
+                group: "environment",
+                kind: "boolean",
+                path: ["postProcess", "enabled"],
+                value: document.postProcess.enabled,
+            },
+            {
+                id: "post-exposure",
+                label: "Exposure",
+                group: "environment",
+                kind: "number",
+                path: ["postProcess", "exposure"],
+                value: document.postProcess.exposure,
+                min: 0,
+                step: 0.05,
+            },
+            {
+                id: "post-contrast",
+                label: "Contrast",
+                group: "environment",
+                kind: "number",
+                path: ["postProcess", "contrast"],
+                value: document.postProcess.contrast,
+                min: 0,
+                step: 0.05,
+            },
+            {
+                id: "fog-enabled",
+                label: "Fog",
+                group: "environment",
+                kind: "boolean",
+                path: ["fog", "enabled"],
+                value: document.fog.enabled,
+            },
+            {
+                id: "fog-mode",
+                label: "Fog mode",
+                group: "environment",
+                kind: "select",
+                path: ["fog", "mode"],
+                value: document.fog.mode,
+                options: [
+                    { label: "Linear", value: "linear" },
+                    { label: "Exponential", value: "exp" },
+                    { label: "Exponential squared", value: "exp2" },
+                ],
+            },
+            {
+                id: "fog-color",
+                label: "Fog color",
+                group: "environment",
+                kind: "color",
+                path: ["fog", "color"],
+                value: document.fog.color,
+            },
+            {
+                id: "fog-density",
+                label: "Fog density",
+                group: "environment",
+                kind: "number",
+                path: ["fog", "density"],
+                value: document.fog.density,
+                min: 0,
+                step: 0.001,
+            },
+            {
+                id: "weather-enabled",
+                label: "Weather",
+                group: "environment",
+                kind: "boolean",
+                path: ["weather", "enabled"],
+                value: document.weather.enabled,
+            },
+            {
+                id: "weather-type",
+                label: "Weather type",
+                group: "environment",
+                kind: "select",
+                path: ["weather", "type"],
+                value: document.weather.type,
+                options: [
+                    { label: "Rain", value: "rain" },
+                    { label: "Snow", value: "snow" },
+                ],
+            },
+            {
+                id: "weather-intensity",
+                label: "Weather intensity",
+                group: "environment",
+                kind: "number",
+                path: ["weather", "intensity"],
+                value: document.weather.intensity,
+                min: 0,
+                step: 10,
+            },
+            {
+                id: "weather-wind",
+                label: "Weather wind",
+                group: "environment",
+                kind: "vector2",
+                path: ["weather", "wind"],
+                value: document.weather.wind,
+                step: 0.1,
+            },
+            {
+                id: "ground-enabled",
+                label: "Ground",
+                group: "environment",
+                kind: "boolean",
+                path: ["ground", "enabled"],
+                value: document.ground.enabled,
+            },
+            {
+                id: "ground-size",
+                label: "Ground size",
+                group: "environment",
+                kind: "number",
+                path: ["ground", "size"],
+                value: document.ground.size,
+                min: 0.01,
+                step: 0.5,
+            },
+            {
+                id: "ground-mode",
+                label: "Ground mode",
+                group: "environment",
+                kind: "select",
+                path: ["ground", "mode"],
+                value: document.ground.mode,
+                options: [
+                    { label: "Solid", value: "solid" },
+                    { label: "Shadow catcher", value: "shadow-catcher" },
+                ],
+            },
+            {
+                id: "ground-color",
+                label: "Ground color",
+                group: "environment",
+                kind: "color",
+                path: ["ground", "color"],
+                value: document.ground.color,
+            },
+        ];
+    }
+    edit(request) {
+        if (request.expectedRevision !== undefined &&
+            request.expectedRevision !== this.#session.revision) {
+            throw new Error(`Editor revision mismatch: expected ${request.expectedRevision}, current ${this.#session.revision}`);
+        }
+        const paths = request.paths?.length ? request.paths : [request.path];
+        const commands = paths.map((path) => setPropertyCommand(path, request.value, request.label ?? "Edit property"));
+        if (!request.mergeKey && commands.length === 1) {
+            const command = commands[0];
+            return command ? this.#session.execute(command) : null;
+        }
+        const transaction = this.#session.beginTransaction({
+            label: request.label ?? "Edit property",
+            ...(request.mergeKey === undefined ? {} : { mergeKey: request.mergeKey }),
+            ...(request.mergeWindowMs === undefined
+                ? {}
+                : { mergeWindowMs: request.mergeWindowMs }),
+        });
+        try {
+            for (const command of commands)
+                transaction.execute(command);
+            return transaction.commit();
+        }
+        catch (error) {
+            if (transaction.active)
+                transaction.cancel();
+            throw error;
+        }
+    }
+    rename(entityIds, name) {
+        return this.#session.transaction("Rename entities", entityIds.map((entityId) => renameEntityCommand(entityId, name)));
+    }
+    setEnabled(entityIds, enabled) {
+        return this.#session.transaction(enabled ? "Enable entities" : "Disable entities", entityIds.map((entityId) => setEntityEnabledCommand(entityId, enabled)));
+    }
+    setVisible(entityIds, visible) {
+        return this.#session.transaction(visible ? "Show entities" : "Hide entities", entityIds.map((entityId) => setEntityVisibleCommand(entityId, visible)));
+    }
+    setPosition(entityIds, position) {
+        return this.#setTransformPart(entityIds, "position", position);
+    }
+    setRotation(entityIds, rotation) {
+        return this.#setTransformPart(entityIds, "rotation", rotation);
+    }
+    setScale(entityIds, scaling) {
+        return this.#setTransformPart(entityIds, "scaling", scaling);
+    }
+    setParent(entityIds, parentId) {
+        return this.#session.transaction("Reparent entities", entityIds.map((entityId) => reparentEntityCommand(entityId, parentId)));
+    }
+    duplicate(entityIds) {
+        return this.#session.transaction("Duplicate entities", entityIds.map((entityId) => duplicateEntityTreeCommand(entityId)));
+    }
+    remove(entityIds) {
+        return this.#session.transaction("Remove entities", entityIds.map((entityId) => removeEntityCommand(entityId)));
+    }
+    #setTransformPart(entityIds, part, value) {
+        return this.#session.transaction(`Set entity ${part}`, entityIds.map((entityId) => setPropertyCommand(["entities", entityId, "transform", part], value, `Set ${part}`)));
+    }
+}
+export function isMixedValue(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        value.kind === "mixed");
+}
+function propertyValuesEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left === null ||
+        right === null ||
+        typeof left !== "object" ||
+        typeof right !== "object") {
+        return false;
+    }
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function createTypedEntityDescriptors(entity) {
+    const root = ["entities", entity.id, "properties"];
+    if (entity.type === "camera") {
+        const value = entity.properties;
+        return [
+            {
+                id: "camera-projection",
+                label: "Projection",
+                group: "camera",
+                kind: "select",
+                path: [...root, "projection"],
+                value: value.projection ?? "perspective",
+                options: [
+                    { label: "Perspective", value: "perspective" },
+                    { label: "Orthographic", value: "orthographic" },
+                ],
+            },
+            numberDescriptor("camera-fov", "FOV", "camera", [...root, "fov"], value.fov ?? 0.8, 0.01, Math.PI - 0.01, 0.01),
+            numberDescriptor("camera-near", "Near clip", "camera", [...root, "minZ"], value.minZ ?? 0.01, 0.0001, undefined, 0.01),
+            numberDescriptor("camera-far", "Far clip", "camera", [...root, "maxZ"], value.maxZ ?? 10_000, 0.01, undefined, 1),
+            numberDescriptor("camera-speed", "Control speed", "camera", [...root, "speed"], value.speed ?? 1, 0, undefined, 0.1),
+            ...(value.projection === "orthographic"
+                ? [
+                    numberDescriptor("camera-orthographic-size", "Orthographic size", "camera", [...root, "orthographicSize"], value.orthographicSize ?? 10, 0.01, undefined, 0.1),
+                ]
+                : []),
+        ];
+    }
+    if (entity.type === "particle") {
+        const value = entity.properties;
+        return [
+            {
+                id: "particle-emitter",
+                label: "Emitter",
+                group: "particle",
+                kind: "select",
+                path: [...root, "emitter"],
+                value: value.emitter ?? "point",
+                options: [
+                    "point",
+                    "box",
+                    "sphere",
+                    "directed-sphere",
+                    "hemisphere",
+                    "cone",
+                    "directed-cone",
+                    "cylinder",
+                    "directed-cylinder",
+                ].map((item) => ({ label: item, value: item })),
+            },
+            numberDescriptor("particle-capacity", "Capacity", "particle", [...root, "capacity"], value.capacity ?? 2_000, 1, undefined, 100),
+            numberDescriptor("particle-rate", "Emit rate", "particle", [...root, "emitRate"], value.emitRate ?? 100, 0, undefined, 10),
+            numberDescriptor("particle-life-min", "Minimum lifetime", "particle", [...root, "minLifeTime"], value.minLifeTime ?? 0.5, 0, undefined, 0.1),
+            numberDescriptor("particle-life-max", "Maximum lifetime", "particle", [...root, "maxLifeTime"], value.maxLifeTime ?? 2, 0, undefined, 0.1),
+            numberDescriptor("particle-size-min", "Minimum size", "particle", [...root, "minSize"], value.minSize ?? 0.05, 0, undefined, 0.01),
+            numberDescriptor("particle-size-max", "Maximum size", "particle", [...root, "maxSize"], value.maxSize ?? 0.15, 0, undefined, 0.01),
+            {
+                id: "particle-gravity",
+                label: "Gravity",
+                group: "particle",
+                kind: "vector3",
+                path: [...root, "gravity"],
+                value: value.gravity ?? { x: 0, y: 0, z: 0 },
+            },
+            {
+                id: "particle-auto-start",
+                label: "Auto start",
+                group: "particle",
+                kind: "boolean",
+                path: [...root, "autoStart"],
+                value: value.autoStart ?? true,
+            },
+        ];
+    }
+    if (entity.type === "shape") {
+        const value = entity.properties;
+        return [
+            {
+                id: "shape-kind",
+                label: "Shape",
+                group: "shape",
+                kind: "select",
+                path: [...root, "shape"],
+                value: value.shape ?? "polygon",
+                options: [
+                    "rectangle",
+                    "circle",
+                    "polygon",
+                    "polyline",
+                    "tube",
+                    "wall",
+                    "box",
+                ].map((item) => ({ label: item, value: item })),
+            },
+            {
+                id: "shape-closed",
+                label: "Closed",
+                group: "shape",
+                kind: "boolean",
+                path: [...root, "closed"],
+                value: value.closed ?? true,
+            },
+            {
+                id: "shape-fill",
+                label: "Fill color",
+                group: "shape",
+                kind: "color",
+                path: [...root, "fillColor"],
+                value: value.fillColor ?? { r: 0.2, g: 0.55, b: 1 },
+            },
+            numberDescriptor("shape-alpha", "Fill alpha", "shape", [...root, "fillAlpha"], value.fillAlpha ?? 0.35, 0, 1, 0.01),
+            {
+                id: "shape-stroke",
+                label: "Stroke color",
+                group: "shape",
+                kind: "color",
+                path: [...root, "strokeColor"],
+                value: value.strokeColor ?? { r: 0.3, g: 0.7, b: 1 },
+            },
+            ...(value.shape === "tube"
+                ? [
+                    numberDescriptor("shape-tube-radius", "Tube radius", "shape", [...root, "tubeRadius"], value.tubeRadius ?? 0.05, 0.001, undefined, 0.01),
+                ]
+                : []),
+            ...(value.shape === "wall"
+                ? [
+                    numberDescriptor("shape-wall-height", "Wall height", "shape", [...root, "wallHeight"], value.wallHeight ?? 1, 0.001, undefined, 0.1),
+                ]
+                : []),
+        ];
+    }
+    if (entity.type === "annotation") {
+        const value = entity.properties;
+        return [
+            {
+                id: "annotation-text",
+                label: "Text",
+                group: "annotation",
+                kind: "string",
+                path: [...root, "text"],
+                value: value.text ?? "",
+            },
+            {
+                id: "annotation-color",
+                label: "Color",
+                group: "annotation",
+                kind: "color",
+                path: [...root, "color"],
+                value: value.color ?? "#ffffff",
+            },
+            {
+                id: "annotation-offset",
+                label: "Offset",
+                group: "annotation",
+                kind: "vector3",
+                path: [...root, "offset"],
+                value: value.offset ?? { x: 0, y: 0, z: 0 },
+            },
+            numberDescriptor("annotation-priority", "Priority", "annotation", [...root, "priority"], value.priority ?? 0, undefined, undefined, 1),
+        ];
+    }
+    if (entity.type === "primitive") {
+        const value = entity.properties ?? {};
+        return [
+            {
+                id: "primitive-kind",
+                label: "Primitive",
+                group: "custom",
+                kind: "select",
+                path: [...root, "primitive"],
+                value: value.primitive ?? "box",
+                options: ["box", "sphere", "plane", "cylinder", "torus"].map((item) => ({ label: item, value: item })),
+            },
+            numberDescriptor("primitive-size", "Size", "custom", [...root, "size"], typeof value.size === "number" ? value.size : 1, 0.001, undefined, 0.1),
+            {
+                id: "primitive-color",
+                label: "Color",
+                group: "custom",
+                kind: "color",
+                path: [...root, "color"],
+                value: value.color ?? { r: 0.7, g: 0.72, b: 0.76 },
+            },
+        ];
+    }
+    if (entity.type === "procedural") {
+        const value = entity.properties;
+        return [
+            {
+                id: "procedural-color",
+                label: "Fallback color",
+                group: "custom",
+                kind: "color",
+                path: [...root, "color"],
+                value: value.color ?? { r: 0.7, g: 0.72, b: 0.76 },
+            },
+        ];
+    }
+    return [];
+}
+function numberDescriptor(id, label, group, path, value, min, max, step) {
+    return {
+        id,
+        label,
+        group,
+        kind: "number",
+        path,
+        value,
+        ...(min === undefined ? {} : { min }),
+        ...(max === undefined ? {} : { max }),
+        ...(step === undefined ? {} : { step }),
+    };
+}
+export function createMaterialDescriptors(document, entity) {
+    return getMaterialBindingsForEntity(document, entity.id).flatMap((binding) => {
+        const materialId = binding.materialId;
+        const material = document.materials[materialId];
+        if (!material)
+            return [];
+        const root = ["materials", materialId];
+        return [
+            ...(material.baseColor
+                ? [
+                    {
+                        id: `${materialId}-baseColor`,
+                        label: `${binding.targetName ?? materialId} color`,
+                        group: "material",
+                        kind: "color",
+                        path: [...root, "baseColor"],
+                        value: material.baseColor,
+                    },
+                ]
+                : []),
+            {
+                id: `${materialId}-metallic`,
+                label: "Metallic",
+                group: "material",
+                kind: "number",
+                path: [...root, "metallic"],
+                value: material.metallic ?? 0,
+                min: 0,
+                max: 1,
+                step: 0.01,
+            },
+            {
+                id: `${materialId}-roughness`,
+                label: "Roughness",
+                group: "material",
+                kind: "number",
+                path: [...root, "roughness"],
+                value: material.roughness ?? 1,
+                min: 0,
+                max: 1,
+                step: 0.01,
+            },
+            {
+                id: `${materialId}-alpha`,
+                label: "Alpha",
+                group: "material",
+                kind: "number",
+                path: [...root, "alpha"],
+                value: material.alpha ?? 1,
+                min: 0,
+                max: 1,
+                step: 0.01,
+            },
+            {
+                id: `${materialId}-emissive-intensity`,
+                label: "Emissive intensity",
+                group: "material",
+                kind: "number",
+                path: [...root, "emissiveIntensity"],
+                value: material.emissiveIntensity ?? 1,
+                min: 0,
+                step: 0.05,
+            },
+            {
+                id: `${materialId}-double-sided`,
+                label: "Double sided",
+                group: "material",
+                kind: "boolean",
+                path: [...root, "doubleSided"],
+                value: material.doubleSided ?? false,
+            },
+            ...(material.clearCoat
+                ? [
+                    {
+                        id: `${materialId}-clear-coat`,
+                        label: "Clear coat",
+                        group: "material",
+                        kind: "boolean",
+                        path: [...root, "clearCoat", "enabled"],
+                        value: material.clearCoat.enabled,
+                    },
+                    {
+                        id: `${materialId}-clear-coat-intensity`,
+                        label: "Clear coat intensity",
+                        group: "material",
+                        kind: "number",
+                        path: [...root, "clearCoat", "intensity"],
+                        value: material.clearCoat.intensity,
+                        min: 0,
+                        max: 1,
+                        step: 0.01,
+                    },
+                ]
+                : []),
+        ];
+    });
+}
+function createAtmosphereDescriptors(parameters) {
+    const values = { ...DEFAULT_ATMOSPHERE_SKY_PARAMETERS, ...parameters };
+    const path = [
+        "environment",
+        "background",
+        "skybox",
+        "source",
+        "parameters",
+    ];
+    return [
+        {
+            id: "sky-luminance",
+            label: "Sky luminance",
+            group: "environment",
+            kind: "number",
+            path: [...path, "luminance"],
+            value: values.luminance,
+            min: 0,
+            max: 10,
+            step: 0.05,
+        },
+        {
+            id: "sky-turbidity",
+            label: "Sky turbidity",
+            group: "environment",
+            kind: "number",
+            path: [...path, "turbidity"],
+            value: values.turbidity,
+            min: 0,
+            max: 100,
+            step: 0.1,
+        },
+        {
+            id: "sky-rayleigh",
+            label: "Sky Rayleigh scattering",
+            group: "environment",
+            kind: "number",
+            path: [...path, "rayleigh"],
+            value: values.rayleigh,
+            min: 0,
+            max: 10,
+            step: 0.05,
+        },
+        {
+            id: "sky-mie-coefficient",
+            label: "Sky Mie coefficient",
+            group: "environment",
+            kind: "number",
+            path: [...path, "mieCoefficient"],
+            value: values.mieCoefficient,
+            min: 0,
+            max: 0.1,
+            step: 0.001,
+        },
+        {
+            id: "sky-mie-direction",
+            label: "Sky Mie direction",
+            group: "environment",
+            kind: "number",
+            path: [...path, "mieDirectionalG"],
+            value: values.mieDirectionalG,
+            min: 0,
+            max: 1,
+            step: 0.01,
+        },
+        {
+            id: "sky-sun-disc-direction",
+            label: "Sky sun-disc direction",
+            group: "environment",
+            kind: "vector3",
+            path: [...path, "sunDiskDirection"],
+            value: values.sunDiskDirection,
+            step: 0.01,
+        },
+        {
+            id: "sky-horizon-offset",
+            label: "Sky horizon offset",
+            group: "environment",
+            kind: "number",
+            path: [...path, "horizonOffset"],
+            value: values.horizonOffset,
+            step: 0.1,
+        },
+        {
+            id: "sky-up",
+            label: "Sky up axis",
+            group: "environment",
+            kind: "vector3",
+            path: [...path, "up"],
+            value: values.up,
+            step: 0.01,
+        },
+        {
+            id: "sky-dithering",
+            label: "Sky dithering",
+            group: "environment",
+            kind: "boolean",
+            path: [...path, "dithering"],
+            value: values.dithering,
+        },
+    ];
+}
+export function createCoreEntityDescriptors(entity) {
+    const root = ["entities", entity.id];
+    return [
+        {
+            id: "name",
+            label: "Name",
+            group: "general",
+            kind: "string",
+            path: [...root, "name"],
+            value: entity.name,
+        },
+        {
+            id: "enabled",
+            label: "Enabled",
+            group: "general",
+            kind: "boolean",
+            path: [...root, "enabled"],
+            value: entity.enabled,
+        },
+        {
+            id: "visible",
+            label: "Visible",
+            group: "general",
+            kind: "boolean",
+            path: [...root, "visible"],
+            value: entity.visible,
+        },
+        {
+            id: "position",
+            label: "Position",
+            group: "transform",
+            kind: "vector3",
+            path: [...root, "transform", "position"],
+            value: entity.transform.position,
+        },
+        {
+            id: "rotation",
+            label: "Rotation",
+            group: "transform",
+            kind: "vector3",
+            path: [...root, "transform", "rotation"],
+            value: entity.transform.rotation,
+        },
+        {
+            id: "scaling",
+            label: "Scaling",
+            group: "transform",
+            kind: "vector3",
+            path: [...root, "transform", "scaling"],
+            value: entity.transform.scaling,
+        },
+    ];
+}
+//# sourceMappingURL=property-descriptors.js.map