babylonjs-editor 5.4.2-alpha.2 → 5.4.2-alpha.3

package/declaration/src/editor/layout/assets-browser/items/javascript-item.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from "react";
+import { AssetsBrowserItem } from "./item";
+export declare class AssetBrowserJavaScriptItem extends AssetsBrowserItem {
+    /**
+     * @override
+     */
+    protected getIcon(): ReactNode;
+    /**
+     * @override
+     */
+    protected getContextMenuContent(): ReactNode;
+    private _runScript;
+}

package/declaration/src/editor/layout/inspector/material/pbr.d.ts

@@ -1,8 +1,10 @@
 import { Component, ReactNode } from "react";
 import { PBRMaterial, AbstractMesh } from "babylonjs";
+import { Editor } from "../../../main";
 export interface IEditorPBRMaterialInspectorProps {
     mesh?: AbstractMesh;
     material: PBRMaterial;
+    editor: Editor;
 }
 export interface IEditorPBRMaterialInspectorState {
     subSurfaceEnabled: boolean;
@@ -11,4 +13,6 @@ export declare class EditorPBRMaterialInspector extends Component<IEditorPBRMate
     constructor(props: IEditorPBRMaterialInspectorProps);
     render(): ReactNode;
     private _handleSubSurfaceEnabledChange;
+    private _getMaterialTexturesOptimizations;
+    private _createAndAssignORMTexture;
 }

package/declaration/src/editor/layout/marketplace.d.ts

@@ -32,6 +32,18 @@ export declare class EditorMarketplaceBrowser extends Component<IMarketplaceBrow
     private _handleNextPage;
     private _handleAssetClicked;
     setSearchQuery(query: string): void;
+    /**
+     * Returns the registered marketplace provider matching the given source id (e.g. "polyhaven").
+     * @param source defines the id of the provider to retrieve.
+     */
+    getProviderBySource(source: string): MarketplaceProvider | undefined;
+    /**
+     * Selects the marketplace provider matching the given source id and optionally runs a search.
+     * Used by the MCP integration so downloads/searches are driven through the visible browser.
+     * @param source defines the id of the provider to select.
+     * @param query defines the optional query to search for once the provider is selected.
+     */
+    selectProviderAndSearch(source: string, query?: string): Promise<boolean>;
     private _handleSearch;
     private _getDefaultFilters;
 }

package/declaration/src/editor/layout/preview/play.d.ts

@@ -76,7 +76,7 @@ export declare class EditorPreviewPlayComponent extends Component<IEditorPreview
     /**
      * The script that is required and executed is a bundled version of the "src/scripts.ts" file.
      * Here we use esbuild to bundle the scripts and transform the imports to use the correct paths.
-     * @see compilePlayScript for more information.
+     * @see compileScript for more information.
      */
     private _compileScripts;
     private _createAndLoadScene;

package/declaration/src/editor/layout/preview.d.ts

@@ -145,7 +145,14 @@ export declare class EditorPreview extends Component<IEditorPreviewProps, IEdito
     private _getToolbar;
     updateGizmoSnapPreferences(prefs: IGizmoSnapPreferences): void;
     private _getEditToolbar;
-    private _switchToCamera;
+    /**
+     * Makes the given camera the editor's active camera, saving the rendering configurations of the
+     * previously active camera and restoring those associated to the new one. This is the supported way
+     * to switch cameras so that per-camera post-processes are set up correctly (and exported for runtime).
+     * @param camera defines the reference to the camera to activate.
+     */
+    switchToCamera(camera: Camera): void;
+    private _switchToCameraById;
     /**
      * Sets the currently active gizmo. Set "none" to deactivate the gizmo.
      * @param gizmo defines the type of gizmo to activate.

package/declaration/src/loader/animation.d.ts

@@ -1,2 +1,14 @@
 import { AssimpJSRuntime } from "./types";
+/**
+ * Parses the animations of the file into Babylon.js `AnimationGroup`s.
+ *
+ * Each Assimp animation becomes one `AnimationGroup`. Every channel targets a node by name and animates its
+ * `position`, `rotationQuaternion` and `scaling`. Because bones are linked to their transform nodes (see
+ * `skeleton.ts`), animating the transform nodes drives the skeleton as well — so skinned and non-skinned animations
+ * are handled the exact same way, and a node animation does not require the file to have a skeleton at all.
+ *
+ * Key times are expressed in Assimp ticks, which map directly to Babylon frames; setting the animation frame rate to
+ * `tickspersecond` plays the animation back at the correct real-time speed.
+ * @param runtime defines the current import runtime.
+ */
 export declare function parseAnimations(runtime: AssimpJSRuntime): void;

package/declaration/src/loader/convert.d.ts

@@ -0,0 +1,28 @@
+import { Matrix, Quaternion, Vector3 } from "babylonjs";
+/**
+ * Converts an Assimp transformation matrix (flat array of 16 numbers) to a Babylon.js matrix.
+ *
+ * Two conversions are applied:
+ * - Assimp matrices are **row-major** whereas Babylon.js stores matrices **column-major**, so the raw array is transposed.
+ * - Assimp data is **right-handed** whereas Babylon.js is **left-handed**, so the matrix is mirrored along Z (`F * M * F`).
+ *
+ * @param transformation defines the flat 16-number transformation array as exported by Assimp.
+ */
+export declare function assimpMatrixToBabylon(transformation?: number[]): Matrix;
+/**
+ * Converts an Assimp position keyframe value `[x, y, z]` (right-handed) to a left-handed Babylon.js vector.
+ * @param value defines the position array as exported by Assimp.
+ */
+export declare function convertPositionKey(value: number[]): Vector3;
+/**
+ * Converts an Assimp scaling keyframe value `[x, y, z]` to a Babylon.js vector. Scaling is invariant to the Z mirror.
+ * @param value defines the scaling array as exported by Assimp.
+ */
+export declare function convertScalingKey(value: number[]): Vector3;
+/**
+ * Converts an Assimp rotation keyframe value to a left-handed Babylon.js quaternion.
+ * Assimp exports quaternions in `[w, x, y, z]` order in a right-handed system. Mirroring the rotation along Z turns
+ * the quaternion `(w, x, y, z)` into `(w, -x, -y, z)`, which is `(-x, -y, z, w)` in Babylon's `(x, y, z, w)` order.
+ * @param value defines the rotation array as exported by Assimp (`[w, x, y, z]`).
+ */
+export declare function convertRotationKey(value: number[]): Quaternion;

package/declaration/src/loader/mesh.d.ts

@@ -1,3 +1,8 @@
-import { Mesh } from "babylonjs";
-import { AssimpJSRuntime, IAssimpJSNodeData } from "./types";
-export declare function parseMesh(runtime: AssimpJSRuntime, data: IAssimpJSNodeData): Mesh;
+import { AssimpJSRuntime, IAssimpMeshNode } from "./types";
+/**
+ * Builds the geometry (and skinning data) of a mesh node. This is the second pass of the import: it runs after the
+ * skeleton has been created so the per-vertex bone indices can be resolved to the final skeleton bone indices.
+ * @param runtime defines the current import runtime.
+ * @param meshNode defines the mesh node (Babylon mesh + Assimp data) to build the geometry for.
+ */
+export declare function buildMeshGeometry(runtime: AssimpJSRuntime, meshNode: IAssimpMeshNode): void;

package/declaration/src/loader/node.d.ts

@@ -1,4 +1,17 @@
-import { Bone, TransformNode } from "babylonjs";
+import { Matrix, TransformNode } from "babylonjs";
 import { AssimpJSRuntime, IAssimpJSNodeData } from "./types";
-export declare function parseNodes(runtime: AssimpJSRuntime, nodes: IAssimpJSNodeData[], parent: TransformNode | null): void;
-export declare function parseNodeTransform(node: TransformNode | Bone, transformation: number[]): void;
+/**
+ * Builds the Babylon.js node hierarchy from the Assimp node tree.
+ *
+ * This is the first pass of the import: every *real* Assimp node becomes either a `Mesh` (geometry is built later, once
+ * the skeleton is available) or a `TransformNode`. The `$AssimpFbx$` helper nodes are collapsed into the next real
+ * descendant (their transforms are accumulated into `pending`). The local transform of each node is converted to
+ * Babylon.js' left-handed/column-major convention and the hierarchy is recorded so that skeletons and animations can be
+ * resolved afterwards.
+ * @param runtime defines the current import runtime.
+ * @param nodes defines the Assimp nodes to parse at the current level.
+ * @param parent defines the Babylon.js parent (real) node (or null at the root).
+ * @param parentName defines the Assimp name of the parent (real) node (or null at the root).
+ * @param pending defines the accumulated transform of the `$AssimpFbx$` helper nodes collapsed so far (identity by default).
+ */
+export declare function buildNodeGraph(runtime: AssimpJSRuntime, nodes: IAssimpJSNodeData[], parent: TransformNode | null, parentName: string | null, pending?: Matrix): void;

package/declaration/src/loader/skeleton.d.ts

@@ -0,0 +1,17 @@
+import { AssimpJSRuntime } from "./types";
+/**
+ * Builds the skeleton (if the file contains skinned meshes) from the previously parsed node hierarchy.
+ *
+ * Assimp/FBX encodes bone offsets in intermediate `$AssimpFbx$` helper nodes that sit *between* the actual bones in the
+ * node tree (translation, pre-rotation, etc.). To keep the bind pose correct, every node on the path from a skinning
+ * bone up to the common root is turned into a Babylon.js bone. The bones referenced by the meshes' vertex weights are a
+ * subset of those bones; the helper bones simply carry the in-between transforms so the absolute (world) bind matrices
+ * match the mesh's bind pose.
+ *
+ * Each bone is linked to its corresponding `TransformNode`. Animating those transform nodes (see `animation.ts`) makes
+ * the skeleton follow along, which also unifies skinned and non-skinned animation handling.
+ *
+ * On return, `runtime.skeleton` and `runtime.boneIndexByName` are populated.
+ * @param runtime defines the current import runtime.
+ */
+export declare function buildSkeleton(runtime: AssimpJSRuntime): void;

package/declaration/src/loader/types.d.ts

@@ -1,4 +1,30 @@
-import { AssetContainer, PBRMaterial, Scene, VertexData } from "babylonjs";
+import { AssetContainer, Matrix, Mesh, PBRMaterial, Scene, Skeleton, TransformNode, VertexData } from "babylonjs";
+/**
+ * Defines the data associated to a node that has been parsed into a Babylon.js node.
+ * Stored so that skeletons and animations can be resolved once the entire hierarchy is available.
+ */
+export interface IAssimpParsedNode {
+    name: string;
+    /**
+     * The Babylon.js node created for this Assimp node (a `Mesh` for mesh nodes, a `TransformNode` otherwise).
+     */
+    node: TransformNode;
+    /**
+     * The local transformation matrix, already converted to Babylon.js' left-handed/column-major convention.
+     */
+    localMatrix: Matrix;
+    /**
+     * The name of the parent node in the Assimp hierarchy, or `null` for the root node.
+     */
+    parentName: string | null;
+}
+/**
+ * Defines a mesh node whose geometry is built once the skeleton (if any) is available.
+ */
+export interface IAssimpMeshNode {
+    mesh: Mesh;
+    data: IAssimpJSNodeData;
+}
 export type AssimpJSRuntime = {
     data: IAssimpJSRootData;
     scene: Scene;
@@ -6,6 +32,26 @@ export type AssimpJSRuntime = {
     container: AssetContainer;
     geometries: Record<number, VertexData>;
     materials: Record<number, PBRMaterial>;
+    /**
+     * All parsed nodes indexed by their Assimp name.
+     */
+    nodes: Map<string, IAssimpParsedNode>;
+    /**
+     * Names of the parsed nodes in depth-first order (parents always appear before their children).
+     */
+    orderedNodeNames: string[];
+    /**
+     * Mesh nodes whose geometry is built in a second pass, once the skeleton is available.
+     */
+    meshNodes: IAssimpMeshNode[];
+    /**
+     * The skeleton shared by all skinned meshes of this file, or `null` if the file has no bones.
+     */
+    skeleton: Skeleton | null;
+    /**
+     * Maps a bone name to its index in `skeleton.bones` (used to fill the meshes' matrices indices).
+     */
+    boneIndexByName: Map<string, number>;
 };
 export interface IAssimpJSNodeData {
     name: string;

package/declaration/src/mcp/action.d.ts

@@ -0,0 +1,4 @@
+import { Editor } from "../editor/main";
+export interface IMCPActionOptions {
+    editor: Editor;
+}

package/declaration/src/mcp/animations/animations.d.ts

@@ -0,0 +1,23 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Lists the scene's animation groups (imported clips + authored ones).
+ */
+export declare function listAnimationGroups(scene: Scene): any;
+/**
+ * Plays an animation group in the editor preview (e.g. to preview a character's idle clip).
+ */
+export declare function playAnimationGroup(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Stops a playing animation group, or all groups when no name is provided.
+ */
+export declare function stopAnimationGroup(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Authors a keyframe `AnimationGroup` targeting a node property (e.g. a door opening animates `rotation.y`).
+ * Builds a Babylon `Animation` from the provided keys, wraps it in a named `AnimationGroup` and adds it to the scene.
+ */
+export declare function createAnimation(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Removes an animation group from the scene (disposes it).
+ */
+export declare function deleteAnimationGroup(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/batch.d.ts

@@ -0,0 +1,17 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "./action";
+/**
+ * Defines the shape of a single action in an execute_batch request.
+ */
+export interface IMCPBatchAction {
+    endpoint: string;
+    data: any;
+}
+/**
+ * Executes an ordered list of actions in a single round-trip.
+ * Each action runs the same handler as its standalone endpoint.
+ * Stops on the first error unless `continueOnError` is true.
+ * A single graph + assets refresh is performed at the end for performance.
+ * @param endpoints defines the map of all registered MCP endpoints.
+ */
+export declare function createBatchHandler(endpoints: Record<string, (scene: Scene, data: any, options: IMCPActionOptions) => any>): (scene: Scene, data: any, options: IMCPActionOptions) => Promise<any>;

package/declaration/src/mcp/cameras/cameras.d.ts

@@ -0,0 +1,10 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Creates a camera in the scene reusing the editor's "add" functions where available.
+ */
+export declare function createCamera(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Sets the scene's active camera.
+ */
+export declare function setActiveCamera(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/lights/lights.d.ts

@@ -0,0 +1,29 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Creates a light in the scene reusing the editor's "add" functions.
+ */
+export declare function createLight(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Enables/disables a shadow generator on a light and configures it.
+ */
+export declare function setLightShadows(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Removes the shadow generator (if any) from a light, so it stops casting shadows.
+ * After this, a non-shadow light can be moved into the ClusteredLightContainer for performance.
+ */
+export declare function removeLightShadows(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Creates the scene's ClusteredLightContainer (or returns the existing one).
+ * The container is always present in the editor preview, so this returns its summary.
+ */
+export declare function createClusteredLightContainer(_scene: Scene, _data: any, options: IMCPActionOptions): any;
+/**
+ * Moves a non-shadow light into the scene's ClusteredLightContainer.
+ */
+export declare function addLightToClusteredContainer(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Removes a light from the scene's ClusteredLightContainer.
+ * The light is automatically added back to the scene as a regular light.
+ */
+export declare function removeLightFromClusteredContainer(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/marketplace/marketplace.d.ts

@@ -0,0 +1,19 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Opens the marketplace browser tab in the editor.
+ */
+export declare function openMarketplaceAndSelectAsset(_: Scene, data: any, options: IMCPActionOptions): Promise<any>;
+/**
+ * Searches a marketplace, driven through the editor's marketplace browser so it is visible.
+ */
+export declare function openMarketplaceAndSearch(_: Scene, data: any, options: IMCPActionOptions): Promise<any>;
+/**
+ * Triggers a visible download into the project through the editor marketplace browser.
+ *
+ * TODO: The per-asset quality/type selection normally happens in the marketplace asset inspector UI.
+ * Here we pick the first available quality/type from the asset's download options. To make the
+ * selection itself visible in the inspector, the marketplace asset inspector would need to expose a
+ * public "downloadSelectedAsset" method that the MCP server could drive directly.
+ */
+export declare function downloadMarketplaceAsset(_scene: Scene, data: any, options: IMCPActionOptions): Promise<any>;

package/declaration/src/mcp/materials/materials.d.ts

@@ -0,0 +1,27 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Lists all the materials available in the scene/project.
+ */
+export declare function listMaterials(scene: Scene): any;
+/**
+ * Lists the material types the editor can create (including the Materials Library) and their key
+ * controllable properties, so the agent knows what is available and how to tune each one.
+ */
+export declare function listMaterialTypes(): any;
+/**
+ * Creates a material and persists it as a `.material` asset so it appears in the assets browser.
+ */
+export declare function createMaterial(scene: Scene, data: any, options: IMCPActionOptions): Promise<any>;
+/**
+ * Sets deep properties on a material using dotted property paths.
+ */
+export declare function setMaterialProperties(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Loads a texture asset and assigns it to a material channel.
+ */
+export declare function assignTextureToMaterial(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Sets the scene environment/skybox texture from a `.env`/`.hdr` cube texture asset.
+ */
+export declare function setEnvironmentTexture(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/mcp.d.ts

@@ -0,0 +1,23 @@
+import { Scene } from "babylonjs";
+import { Editor } from "../editor/main";
+import { IMCPActionOptions } from "./action";
+export interface IEditorMCPDataType {
+    endpoint: string;
+    [index: string]: any;
+}
+/**
+ * The port the editor MCP HTTP server listens on.
+ */
+export declare const MCPServerPort = 3712;
+/**
+ * Map of all the MCP endpoints to their handler.
+ * Each handler has the signature `(scene, data, options) => any | Promise<any>`.
+ */
+export declare const MCPEndpoints: Record<string, (scene: Scene, data: any, options: IMCPActionOptions) => any>;
+/**
+ * Initializes the editor MCP HTTP server.
+ * Resilient: if the port is already in use (e.g. a second editor window), the error is caught
+ * and logged in the editor console instead of crashing the application.
+ * @param editor defines the reference to the editor.
+ */
+export declare function initializeMcpServer(editor: Editor): void;

package/declaration/src/mcp/meshes/meshes.d.ts

@@ -0,0 +1,37 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Creates a primitive mesh in the scene reusing the editor's "add" functions.
+ */
+export declare function createPrimitiveMesh(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Creates one or more InstancedMesh from a source mesh.
+ * Uses the editor's `createMeshInstance` helper so each instance gets a proper id/uniqueId, copied
+ * transform/visibility/enabled state, and is correctly wired into collision meshes and shadow maps
+ * (this is what the editor inspector relies on to display the instance's properties).
+ * By default each instance shares the source mesh's parent so the scene hierarchy stays easy to read.
+ */
+export declare function createInstance(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Clones a mesh. When `cloneGeometry` is false (default), the geometry is shared with the source.
+ */
+export declare function cloneMesh(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Assigns an existing material to a mesh.
+ */
+export declare function setMeshMaterial(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Toggles the visibility/enabled state of a mesh.
+ */
+export declare function setMeshVisibility(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Enables, disables and configures the Havok physics body of a mesh (mass, motion type, shape, friction, restitution).
+ * This is the way to give a mesh real gameplay physics (gravity, collisions, impulses at runtime).
+ */
+export declare function setMeshPhysics(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Returns the bounding information of a mesh, in local and world space, plus the world-space bounds of
+ * its whole hierarchy (children included). Useful to scatter objects without overlap (e.g. forests) and
+ * to place meshes on the ground precisely.
+ */
+export declare function getMeshBoundingInfo(scene: Scene, data: any): any;

package/declaration/src/mcp/nodes/nodes.d.ts

@@ -0,0 +1,38 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Returns the full details of a node, including transform, camera and light specific properties.
+ */
+export declare function getNode(scene: Scene, data: any): any;
+/**
+ * Sets the transform of a node. Supports meshes/transform nodes (position/rotation/scaling),
+ * lights (position/direction) and cameras (position/rotation/target). Only the provided and
+ * supported properties are applied.
+ */
+export declare function setNodeTransform(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Sets generic deep properties on a node using dotted property paths.
+ */
+export declare function setNodeProperties(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Reparents a node, preserving its world transform by default.
+ * When reparenting a non-shadow light into a ClusteredLightContainer, uses `addLight`.
+ */
+export declare function setNodeParent(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Renames a node.
+ */
+export declare function renameNode(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Removes a node (and its descendants) from the scene.
+ */
+export declare function deleteNode(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Selects/focuses a node in the editor (UX only).
+ */
+export declare function selectNode(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Returns the nodes currently selected by the user in the editor's graph (scene tree).
+ * Useful to act on "the selected node" requested by the user (e.g. instantiate it many times to build a forest).
+ */
+export declare function getSelectedNodes(_scene: Scene, _data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/particles/particles.d.ts

@@ -0,0 +1,10 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Lists all the `.npss` node particle system assets in the project.
+ */
+export declare function listParticleAssets(): Promise<any>;
+/**
+ * Instantiates a `.npss` asset into the scene, or creates a default particle system.
+ */
+export declare function instantiateParticleSystem(scene: Scene, data: any, options: IMCPActionOptions): Promise<any>;

package/declaration/src/mcp/rendering/post-process.d.ts

@@ -0,0 +1,13 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Returns the post-process / rendering pipeline configurations associated to the given camera.
+ * When the camera is the active one, the live configurations are serialized; otherwise the
+ * configurations saved for that camera are returned (null when the post-process is disabled).
+ */
+export declare function getCameraPostProcesses(scene: Scene, data: any): any;
+/**
+ * Enables/disables and customizes a per-camera post-process in realtime. The editor's active camera is
+ * switched to the target camera first so the pipeline is attached to it and will be available at runtime.
+ */
+export declare function setCameraPostProcess(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/scene/hierarchy.d.ts

@@ -0,0 +1,8 @@
+import { Scene } from "babylonjs";
+/**
+ * Returns the hierarchy of the scene nodes as a tree.
+ * Each node is described by its id, name, type (class name) and its children.
+ * @param scene defines the reference to the scene to get the hierarchy from.
+ * @param rootNodeName defines the optional name of the root node to start from.
+ */
+export declare function getSceneHierarchy(scene: Scene, rootNodeName?: string): any;

package/declaration/src/mcp/scene/scene.d.ts

@@ -0,0 +1,22 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Lists all the `.scene` assets available in the project.
+ */
+export declare function listScenes(_scene: Scene, _data: any, options: IMCPActionOptions): Promise<any>;
+/**
+ * Returns the name/path of the currently edited scene with entity counts.
+ */
+export declare function getActiveScene(scene: Scene, _data: any, options: IMCPActionOptions): any;
+/**
+ * Saves the current scene/project.
+ */
+export declare function saveScene(_scene: Scene, _data: any, options: IMCPActionOptions): Promise<any>;
+/**
+ * Returns the current scene-level settings.
+ */
+export declare function getSceneSettings(scene: Scene): any;
+/**
+ * Sets scene-level settings using dotted property paths.
+ */
+export declare function setSceneSettings(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/screenshot.d.ts

@@ -0,0 +1,14 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "./action";
+/**
+ * Takes a screenshot of the preview for visual verification.
+ */
+export declare function getScreenshot(scene: Scene, data: any): Promise<any>;
+/**
+ * Frames the editor camera on a node to help screenshots.
+ */
+export declare function focusNode(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Starts the project dev/run process.
+ */
+export declare function runProject(_scene: Scene, _data: any, options: IMCPActionOptions): Promise<any>;

package/declaration/src/mcp/scripts/editor-scripts.d.ts

@@ -0,0 +1,22 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Writes (or overwrites) a `.js` automation script into the project's "agentdata" folder.
+ * The script must export `main(editor)`. It can later be executed with `run_agent_script`.
+ */
+export declare function writeAgentScript(_scene: Scene, data: any): Promise<any>;
+/**
+ * Lists the `.js` automation scripts available in the project's "agentdata" folder.
+ */
+export declare function listAgentScripts(): Promise<any>;
+/**
+ * Compiles and executes an "agentdata" automation script by calling its `main(editor)` export.
+ * Accepts either an existing script `name`, or inline `content` (written first, then executed).
+ * The script runs with full access to the `editor` mediator; see `get_editor_api`.
+ */
+export declare function runAgentScript(_scene: Scene, data: any, options: IMCPActionOptions): Promise<any>;
+/**
+ * Returns a reference describing the `editor` mediator object available to agent scripts, so the agent
+ * knows what it can do. Derived from the editor sources under /editor/src/editor.
+ */
+export declare function getEditorApi(): any;

package/declaration/src/mcp/scripts/scripts.d.ts

@@ -0,0 +1,34 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Lists all the TypeScript scripts under the project "src" directory.
+ */
+export declare function listScripts(): Promise<any>;
+/**
+ * Creates a new TypeScript script with the editor's default skeleton under "src/".
+ */
+export declare function createScript(_scene: Scene, data: any): Promise<any>;
+/**
+ * Reads a script's content.
+ */
+export declare function readScript(_scene: Scene, data: any): Promise<any>;
+/**
+ * Overwrites/updates a script's content.
+ */
+export declare function writeScript(_scene: Scene, data: any): Promise<any>;
+/**
+ * Attaches a script file to a node, writing the node script metadata as the inspector does.
+ */
+export declare function attachScript(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Lists the scripts attached to a node and their exported values.
+ */
+export declare function listAttachedScripts(scene: Scene, data: any): any;
+/**
+ * Sets an exported/inspector value of an attached script on a node.
+ */
+export declare function setScriptExportedValue(scene: Scene, data: any, options: IMCPActionOptions): any;
+/**
+ * Removes an attached script from a node.
+ */
+export declare function detachScript(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/sounds/sounds.d.ts

@@ -0,0 +1,16 @@
+import { Scene } from "babylonjs";
+import { IMCPActionOptions } from "../action";
+/**
+ * Lists all the `.mp3`, `.ogg` and `.wav` sound assets in the project.
+ */
+export declare function listSoundAssets(): Promise<any>;
+/**
+ * Creates a `SoundNode` in the scene from a sound asset and loads it.
+ * Use `spatial: true` (default) with `parentId`/`parentName`/`position` for 3D positional ambience,
+ * or `spatial: false` for a global 2D ambience/music bed.
+ */
+export declare function createSound(scene: Scene, data: any, options: IMCPActionOptions): Promise<any>;
+/**
+ * Updates the properties of an existing `SoundNode`. Only the provided fields are applied.
+ */
+export declare function setSoundProperties(scene: Scene, data: any, options: IMCPActionOptions): any;

package/declaration/src/mcp/tools/resolve.d.ts

@@ -0,0 +1,73 @@
+import { Scene, Node, Material, Color3, Vector3 } from "babylonjs";
+/**
+ * Defines the shape of the options used to resolve a node from the scene.
+ */
+export interface IResolveNodeOptions {
+    scene: Scene;
+    nodeId?: string;
+    nodeName?: string;
+}
+/**
+ * Defines the shape of the options used to resolve a material from the scene.
+ */
+export interface IResolveMaterialOptions {
+    scene: Scene;
+    materialId?: string;
+    materialName?: string;
+}
+/**
+ * Defines the shape of a node summary as defined by the MCP tools contract.
+ */
+export interface INodeSummary {
+    id: string;
+    name: string;
+    className: string;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    scaling?: [number, number, number];
+    direction?: [number, number, number];
+    parentId?: string | null;
+    materialId?: string | null;
+    isEnabled: boolean;
+    isVisible?: boolean;
+}
+/**
+ * Resolves a node from the given scene using its id first, then its name.
+ * @param options defines the scene and the id/name to resolve the node from.
+ */
+export declare function resolveNode(options: IResolveNodeOptions): Node;
+/**
+ * Resolves a material from the given scene using its id first, then its name.
+ * @param options defines the scene and the id/name to resolve the material from.
+ */
+export declare function resolveMaterial(options: IResolveMaterialOptions): Material;
+/**
+ * Produces the contract's node-summary shape for the given node.
+ * @param node defines the reference to the node to summarize.
+ */
+export declare function toNodeSummary(node: Node): INodeSummary;
+/**
+ * Coerces the given value to a Color3 instance.
+ * @param value defines the value to coerce ([r,g,b] array or Color3).
+ */
+export declare function toColor3(value: any): Color3;
+/**
+ * Coerces the given value to a Vector3 instance.
+ * @param value defines the value to coerce ([x,y,z] array or Vector3).
+ */
+export declare function toVector3(value: any): Vector3;
+/**
+ * Deeply sets a property on the given target using a dotted path (e.g. "material.albedoColor").
+ * Arrays are coerced to Color3/Vector3/Color4/Vector2/Vector4 based on the existing property type.
+ * @param target defines the root object on which to set the property.
+ * @param path defines the dotted path to the property to set.
+ * @param value defines the value to set.
+ */
+export declare function deepSet(target: any, path: string, value: any): void;
+/**
+ * Coerces the given value to match the type of the existing property value when relevant
+ * (Color3/Color4/Vector2/Vector3/Vector4). Otherwise returns the value as-is.
+ * @param existing defines the current value of the property.
+ * @param value defines the new value to coerce.
+ */
+export declare function coerceValueForExistingProperty(existing: any, value: any): any;

package/declaration/src/tools/compile.d.ts

@@ -0,0 +1,7 @@
+export declare function compileScriptFromAssets(absolutePath: string): Promise<string>;
+export interface ICompilePlayScriptOptions {
+    entryPoints: string[];
+    outfile: string;
+    onTransformSource?: (path: string) => void;
+}
+export declare function compileScript(options: ICompilePlayScriptOptions): Promise<void>;

package/declaration/src/tools/marketplaces/types.d.ts

@@ -27,6 +27,7 @@ export interface IMarketplaceAsset {
     marketplaceActionLabel?: string;
     isDownloadable?: boolean;
     downloadOptions?: IDownloadOptions;
+    [extraKey: string]: any;
 }
 export interface IMarketplaceSearchResult {
     assets: IMarketplaceAsset[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "babylonjs-editor",
-	"version": "5.4.2-alpha.2",
+	"version": "5.4.2-alpha.3",
 	"description": "Babylon.js Editor is a Web Application helping artists to work with Babylon.js",
 	"productName": "Babylon.js Editor",
 	"main": "build/src/index.js",
@@ -40,10 +40,10 @@
 		"vitest": "4.0.17"
 	},
 	"dependencies": {
-		"@babylonjs/addons": "9.9.1",
-		"@babylonjs/core": "9.9.1",
+		"@babylonjs/addons": "9.12.1",
+		"@babylonjs/core": "9.12.1",
 		"@babylonjs/havok": "1.3.12",
-		"@babylonjs/ktx2decoder": "9.9.1",
+		"@babylonjs/ktx2decoder": "9.12.1",
 		"@blueprintjs/core": "^5.10.0",
 		"@blueprintjs/select": "^5.1.2",
 		"@emotion/react": "^11.13.3",
@@ -76,19 +76,19 @@
 		"@xterm/xterm": "6.1.0-beta.22",
 		"assimpjs": "0.0.10",
 		"axios": "1.16.1",
-		"babylonjs": "9.9.1",
-		"babylonjs-addons": "9.9.1",
+		"babylonjs": "9.12.1",
+		"babylonjs-addons": "9.12.1",
 		"babylonjs-editor-cli": "latest",
 		"babylonjs-editor-tools": "latest",
-		"babylonjs-gui": "9.9.1",
-		"babylonjs-gui-editor": "9.9.1",
-		"babylonjs-ktx2decoder": "9.9.1",
-		"babylonjs-loaders": "9.9.1",
-		"babylonjs-materials": "9.9.1",
-		"babylonjs-node-editor": "9.9.1",
-		"babylonjs-node-particle-editor": "9.9.1",
-		"babylonjs-post-process": "9.9.1",
-		"babylonjs-procedural-textures": "9.9.1",
+		"babylonjs-gui": "9.12.1",
+		"babylonjs-gui-editor": "9.12.1",
+		"babylonjs-ktx2decoder": "9.12.1",
+		"babylonjs-loaders": "9.12.1",
+		"babylonjs-materials": "9.12.1",
+		"babylonjs-node-editor": "9.12.1",
+		"babylonjs-node-particle-editor": "9.12.1",
+		"babylonjs-post-process": "9.12.1",
+		"babylonjs-procedural-textures": "9.12.1",
 		"chokidar": "^4.0.3",
 		"class-variance-authority": "^0.7.0",
 		"clsx": "^2.1.0",

package/declaration/src/tools/scene/play/compile.d.ts

@@ -1,4 +0,0 @@
-export interface ICompilePlayScriptOptions {
-    onTransformSource?: (path: string) => void;
-}
-export declare function compilePlayScript(temporaryDirectory: string, options?: ICompilePlayScriptOptions): Promise<void>;