@babylonjs/inspector 8.33.1-preview → 8.33.2-preview

package/lib/index.d.ts

@@ -59038,9 +59038,20 @@ interface AbstractEngineOptions {
      */
     doNotHandleTouchAction?: boolean;
     /**
-     * Make the matrix computations to be performed in 64 bits instead of 32 bits. False by default
+     * Make the matrix computations to be performed in 64 bits instead of 32 bits. False by default.
+     * Note that setting useLargeWorldRendering will also set high precision matrices
      */
     useHighPrecisionMatrix?: boolean;
+    /**
+     * @experimental
+     * LargeWorldRendering helps avoid floating point imprecision of rendering large worlds by
+     * 1. Forcing highPrecisionMatrices (matrix computations in 64 bits instead of 32)
+     * 2. Enabling floatingOriginMode in all scenes -- offsetting position-related uniform and attribute values before passing to shader so that active camera is centered at origin and world is offset by active camera position
+     *
+     * NOTE that if this mode is set during engineCreation, all scenes will have floatingOrigin offset and you do not need to send floatingOriginMode option to each scene creation.
+     * If you'd like to have only specific scenes using the offset logic, you can set the flag on those scenes directly -- however, to achieve proper large world rendering, you must also set the useHighPrecisionMatrix option on engine.
+     */
+    readonly useLargeWorldRendering?: boolean;
     /**
      * Defines whether to adapt to the device's viewport characteristics (default: false)
      */
@@ -59980,6 +59991,7 @@ declare abstract class AbstractEngine {
     protected _creationOptions: AbstractEngineOptions;
     /**
      * Gets the options used for engine creation
+     * NOTE that modifying the object after engine creation will have no effect
      * @returns EngineOptions object
      */
     getCreationOptions(): AbstractEngineOptions;
@@ -66812,15 +66824,17 @@ interface SceneOptions {
      * It will improve performance when the number of mesh becomes important, but might consume a bit more memory
      */
     useClonedMeshMap?: boolean;
-    /** Defines if the creation of the scene should impact the engine (Eg. UtilityLayer's scene) */
-    virtual?: boolean;
     /**
      * @experimental
-     * FloatingOriginMode helps avoid floating point imprecision of rendering large worlds by
-     * 1. Forcing the engine to use doublePrecision mode
-     * 2. Offsetting uniform values before passing to shader so that camera is centered at origin and world is offset by camera position
+     * When enabled, the scene can handle large world coordinate rendering without jittering caused by floating point imprecision on the GPU.
+     * This mode offsets matrices and position-related attribute values before passing to shaders, centering camera at origin and offsetting other scene objects by camera active position.
+     *
+     * IMPORTANT: Only use this scene-level option if you intend to enable floating origin on a per-scene basis. Must use in conjunction with engine creation option 'useHighPrecisionMatrix' to fix CPU-side floating point imprecision.
+     * HOWEVER if you want largeWorldRendering on ALL scenes, set the useLargeWorldRendering flag on the engine instead of this scene-level flag. Doing so will automatically set useHighPrecisionMatrix on the engine as well.
      */
-    floatingOriginMode?: boolean;
+    useFloatingOrigin?: boolean;
+    /** Defines if the creation of the scene should impact the engine (Eg. UtilityLayer's scene) */
+    virtual?: boolean;
 }
 /**
  * Define how the scene should favor performance over ease of use
@@ -66891,6 +66905,7 @@ declare class Scene implements IAnimatable, IClipPlanesHolder, IAssetContainer {
      */
     autoClearDepthAndStencil: boolean;
     private _clearColor;
+    private _tempVect4;
     /**
      * Observable triggered when the performance priority is changed
      */
@@ -68316,12 +68331,11 @@ declare class Scene implements IAnimatable, IClipPlanesHolder, IAssetContainer {
      * @param ubo the ubo to set for the scene
      */
     setSceneUniformBuffer(ubo: UniformBuffer): void;
-    private _floatingOriginMode;
+    private _floatingOriginScene;
     /**
      * @experimental
-     * When true, enables floatingOriginMode which helps avoid floating point imprecision when using huge coordinate system by
-     * 1. Forcing the engine to use doublePrecision mode
-     * 2. Offsetting uniform values before passing to shader so that camera is centered at origin and world is offset by camera position
+     * True if floatingOriginMode was passed to engine or this scene creation otions.
+     * This mode avoids floating point imprecision in huge coordinate system by offsetting uniform values before passing to shader, centering camera at origin and displacing rest of scene by camera position
      */
     get floatingOriginMode(): boolean;
     private _floatingOriginOffsetDefault;
@@ -68975,6 +68989,7 @@ declare class Scene implements IAnimatable, IClipPlanesHolder, IAssetContainer {
      * @internal
      */
     _renderRenderTarget(renderTarget: RenderTargetTexture, activeCamera: Nullable<Camera>, useCameraPostProcess?: boolean, dumpForDebug?: boolean): void;
+    private _getFloatingOriginScene;
     /**
      * Render the scene
      * @param updateCameras defines a boolean indicating if cameras must update according to their inputs (true by default)

package/lib/index.js

@@ -4752,6 +4752,9 @@ const QuaternionPropertyLine = (props) => {
     const min = props.useDegrees ? 0 : undefined;
     const max = props.useDegrees ? 360 : undefined;
     const [quat, setQuat] = useState(props.value);
+    useEffect(() => {
+        setQuat(props.value);
+    }, [props.value]);
     // Extract only the properties that exist on QuaternionPropertyLineProps
     const { useDegrees, ...restProps } = props;
     const onQuatChange = (val) => {
@@ -4760,10 +4763,9 @@ const QuaternionPropertyLine = (props) => {
     };
     const onEulerChange = (val) => {
         const quat = Quaternion.FromEulerAngles(val.x, val.y, val.z);
-        setQuat(quat);
-        props.onChange(quat);
+        onQuatChange(quat);
     };
-    return useDegrees ? (jsx(Vector3PropertyLine, { ...restProps, nullable: false, ignoreNullable: false, value: quat.toEulerAngles(), valueConverter: ToDegreesConverter, min: min, max: max, onChange: onEulerChange, unit: "deg" })) : (jsx(QuaternionPropertyLineInternal, { ...props, unit: "rad", nullable: false, value: quat, min: min, max: max, onChange: onQuatChange }));
+    return useDegrees ? (jsx(Vector3PropertyLine, { ...restProps, nullable: false, ignoreNullable: false, value: quat.toEulerAngles(), valueConverter: ToDegreesConverter, min: min, max: max, onChange: onEulerChange, unit: "deg" })) : (jsx(QuaternionPropertyLineInternal, { ...props, nullable: false, value: quat, min: min, max: max, onChange: onQuatChange }));
 };
 const Vector2PropertyLine = TensorPropertyLine;
 const Vector3PropertyLine = TensorPropertyLine;