babylonjs-editor 5.5.0 → 5.5.1-alpha.1

package/declaration/src/editor/layout/inspector/light/components/volumetric.d.ts

@@ -0,0 +1,11 @@
+import { Light } from "babylonjs";
+import { Editor } from "../../../../main";
+export interface IEditorLightVolumetricInspectorProps {
+    light: Light;
+    editor: Editor;
+}
+/**
+ * Draws the "Volumetric Lighting" section of the inspector of a light. Each light of the scene, including
+ * the ones that live inside a clustered light container, is configured individually here.
+ */
+export declare function EditorLightVolumetricInspector(props: IEditorLightVolumetricInspectorProps): import("react/jsx-runtime").JSX.Element | null;

package/declaration/src/editor/layout/inspector/scene/scene.d.ts

@@ -18,11 +18,14 @@ export declare class EditorSceneInspector extends Component<IEditorInspectorImpl
     get scene(): Scene;
     get isPlaying(): boolean;
     private _getPhysicsComponent;
+    private _getVolumetricLightingComponent;
     private _getDefaultRenderingPipelineComponent;
     private _getTAARenderingPipelineComponent;
     private _getSSAO2RenderingPipelineComponent;
     private _getMotionBlurPostProcessComponent;
     private _getSSRPipelineComponent;
+    private _volumetricAmbientColor;
+    private _getVolumetricAmbientColorObject;
     private _getVLSComponent;
     private _handleDragOverVlsMesh;
     private _handleDropVlsMesh;

package/declaration/src/editor/layout/inspector/script/tools.d.ts

@@ -6,6 +6,7 @@ export type VisibleInInspectorDecoratorObject = {
 };
 export type VisibleInInspectorDecoratorConfiguration = {
     type: string;
+    group?: string;
     description?: string;
     min?: number;
     max?: number;

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

@@ -8,4 +8,3 @@ export declare function configureImportedTexture<T extends Texture | CubeTexture
 export declare function configureEmbeddedTexture(texture: Texture, absolutePath: string): Promise<void | boolean>;
 export declare function cleanTexture(texture: Texture, filename: string): void;
 export declare function loadImportedMaterial(scene: Scene, absolutePath: string): Promise<Material | null>;
-export declare function cleanImportedGltf(result: ISceneLoaderAsyncResult): void;

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

@@ -132,6 +132,8 @@ export declare class EditorPreview extends Component<IEditorPreviewProps, IEdito
     setCameraPreviewActive(camera: Camera | null): void;
     private _onGotIconsRef;
     private _onGotCanvasRef;
+    private _twgsl;
+    private _glslang;
     private _createWebgpuEngine;
     /** @internal */
     _handleMouseLeave(): void;

package/declaration/src/editor/layout/ragdoll/inspector.d.ts

@@ -19,6 +19,7 @@ export declare class RagdollEditorInspector extends Component<IRagdollEditorInsp
     constructor(props: IRagdollEditorInspectorProps);
     render(): ReactNode;
     private _getRagdollInspector;
+    private _handleApplyMixamoTemplate;
     private _handleApplyOrStopRagdollPreview;
     private _getConfigurationListInspector;
     private _handleAddConfiguration;

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

@@ -1,5 +1,5 @@
 import { Component, ReactNode } from "react";
-import { Engine, Scene, ArcRotateCamera, Ragdoll, GroundMesh, TransformNode } from "babylonjs";
+import { Engine, Scene, ArcRotateCamera, Ragdoll, GroundMesh, TransformNode, AssetContainer } from "babylonjs";
 import { Editor } from "../../main";
 import { RagdollEditor } from "./editor";
 export interface IRagdollEditorPreviewProps {
@@ -15,6 +15,7 @@ export declare class RagdollEditorPreview extends Component<IRagdollEditorPrevie
     camera: ArcRotateCamera;
     ground: GroundMesh;
     scalingNode: TransformNode;
+    container: AssetContainer | null;
     ragdoll: Ragdoll | null;
     private _light;
     private _viewer;

package/declaration/src/editor/rendering/volumetric-lighting.d.ts

@@ -0,0 +1,22 @@
+import { Camera } from "babylonjs";
+import { Editor } from "../main";
+import { VolumetricLightingRenderingPipeline } from "babylonjs-editor-tools";
+/**
+ * Defines the configuration of the volumetric lighting rendering pipeline per camera.
+ */
+export declare const volumetricLightingRenderingPipelineCameraConfigurations: Map<Camera, any>;
+export declare function getVolumetricLightingRenderingPipeline(): VolumetricLightingRenderingPipeline | null;
+/**
+ * Returns wether or not the volumetric lighting rendering pipeline is supported by the engine used by the editor.
+ * @param editor defines the reference to the editor.
+ */
+export declare function isVolumetricLightingSupported(editor: Editor): boolean;
+export declare function disposeVolumetricLightingRenderingPipeline(): void;
+export declare function createVolumetricLightingRenderingPipeline(editor: Editor): VolumetricLightingRenderingPipeline;
+export declare function serializeVolumetricLightingRenderingPipeline(): any;
+export declare function parseVolumetricLightingRenderingPipeline(editor: Editor, data: any): VolumetricLightingRenderingPipeline;
+/**
+ * Marks the list of lights contributing to the volumetric lighting as dirty. Called when the volumetric
+ * configuration of a light is edited so the effect updates without waiting for the next selection pass.
+ */
+export declare function markVolumetricLightsDirty(): void;

package/declaration/src/export.d.ts

@@ -50,6 +50,7 @@ export * from "./editor/rendering/vls";
 export * from "./editor/rendering/ssao";
 export * from "./editor/rendering/motion-blur";
 export * from "./editor/rendering/default-pipeline";
+export * from "./editor/rendering/volumetric-lighting";
 export * from "./ui/spinner";
 export * from "./ui/color-picker";
 export * from "./ui/dialog";

package/declaration/src/tools/light/volumetric.d.ts

@@ -0,0 +1,47 @@
+import { Color3, Light } from "babylonjs";
+import { IVolumetricLightConfiguration } from "babylonjs-editor-tools";
+import { Editor } from "../../editor/main";
+/**
+ * Returns wether or not the given light can take part in the volumetric lighting.
+ * @param light defines the reference to the light to check.
+ */
+export declare function isVolumetricLightingAvailable(light: Light): boolean;
+export declare function getVolumetricLightConfigurationProxy(light: Light): IVolumetricLightConfiguration;
+/**
+ * Creates a Color3 whose three channels are accessors over the given array instead of plain values.
+ *
+ * The color field of the inspector mutates a Color3 in place, and its per-channel number fields register
+ * their own undo/redo that writes straight into that Color3, bypassing every callback. Binding the channels
+ * to the array makes all of those paths, including undo and redo, update the configuration itself.
+ * @param read defines the function returning the array backing the color.
+ * @param write defines the function storing the new array.
+ */
+export declare function createArrayBoundColor3(read: () => number[], write: (value: number[]) => void): Color3;
+/**
+ * Returns a stable object holding the custom volumetric color of the given light as a Color3 bound to the
+ * array stored in its configuration, so the inspector can edit it like any other color.
+ * @param light defines the reference to the light to get its custom volumetric color.
+ */
+export declare function getVolumetricLightColorObject(light: Light): {
+    color: Color3;
+};
+/**
+ * Returns how the light shafts of the given light are occluded by the geometry of the scene, and explains it.
+ *
+ * A light that renders a shadow map is occluded by it, which is exact. Any other light, including every light
+ * of a clustered light container, falls back on the depth buffer of the scene, which is an approximation but
+ * is what stops its shafts from showing through the walls that stand between it and the camera.
+ * @param light defines the reference to the light to check.
+ * @param editor defines the reference to the editor.
+ */
+export declare function getVolumetricLightOcclusionMode(light: Light, editor: Editor): {
+    usesShadowMap: boolean;
+    reason: string;
+};
+/**
+ * Returns a human readable description of what the given light currently does in the volumetric lighting
+ * rendering pipeline, drawn under the fields of the inspector.
+ * @param light defines the reference to the light to describe.
+ * @param editor defines the reference to the editor.
+ */
+export declare function getVolumetricLightStatusLabel(light: Light, editor: Editor): string;

package/declaration/src/tools/node/metadata.d.ts

@@ -1,4 +1,5 @@
 import { Node } from "babylonjs";
+import { IVolumetricLightConfiguration } from "babylonjs-editor-tools";
 export interface INodeMetadata {
     /**
      * Defines wether or not the object is locked.
@@ -12,6 +13,10 @@ export interface INodeMetadata {
      * Defines wether or not the object is visible in the graph panel in the editor.
      */
     notVisibleInGraph?: boolean;
+    /**
+     * Defines the configuration of the volumetric lighting for the light. @see IVolumetricLightConfiguration
+     */
+    volumetricLighting?: IVolumetricLightConfiguration;
 }
 /**
  * Ensures that metadata exists for the given node.

package/declaration/src/tools/scene/gltf.d.ts

@@ -0,0 +1,14 @@
+import { ISceneLoaderAsyncResult, AssetContainer } from "babylonjs";
+/**
+ * Converts everything the glTF loader created under its "__root__" node to the left handed system Babylon.js uses.
+ *
+ * In a left handed scene, the glTF loader keeps all the data as authored (right handed) and compensates using a
+ * negative scaling (and a rotation) on the "__root__" node. This works for rendering, but every tool relying on the
+ * world matrices having a positive determinant (ragdolls, physics, etc.) breaks.
+ *
+ * The mirror of the root is baked into the data instead: the geometries are mirrored and every transform, skeleton
+ * and animation is conjugated by the mirror. The world transforms and the rendering of the loaded hierarchy are
+ * exactly preserved, but the root doesn't have a negative scaling anymore.
+ * @param result defines the result of the scene loader containing the loaded glTF.
+ */
+export declare function convertGltfToLeftHanded(result: ISceneLoaderAsyncResult | AssetContainer): void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "babylonjs-editor",
-	"version": "5.5.0",
+	"version": "5.5.1-alpha.1",
 	"description": "Babylon.js Editor is a Web Application helping artists to work with Babylon.js",
 	"productName": "Babylon.js Editor",
 	"main": "build/src/index.js",
@@ -37,7 +37,7 @@
 		"postcss-import": "16.1.0",
 		"tailwindcss": "3.4.4",
 		"typescript": "7.0.2",
-		"vitest": "4.1.0"
+		"vitest": "4.1.11"
 	},
 	"dependencies": {
 		"@adobe/spz": "0.2.2",