|
@@ -1,978 +1,23 @@
|
|
|
-/*BabylonJS Inspector*/
|
|
|
+/*Babylon.js Inspector*/
|
|
|
// Dependencies for this module:
|
|
|
// ../../../../Tools/Gulp/babylonjs
|
|
|
declare module INSPECTOR {
|
|
|
}
|
|
|
declare module INSPECTOR {
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class Tools {
|
|
|
- static LookForItem(item: any, selectedEntity: any): boolean;
|
|
|
- static SortAndFilter(items: any[]): any[];
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
-}
|
|
|
-export declare class Inspector {
|
|
|
- /** The HTML document relative to this inspector (the window or the popup depending on its mode) */
|
|
|
- static DOCUMENT: HTMLDocument;
|
|
|
- /** The HTML window. In popup mode, it's the popup itself. Otherwise, it's the current tab */
|
|
|
- static WINDOW: Window;
|
|
|
- onGUILoaded: BABYLON.Observable<any>;
|
|
|
- static GUIObject: any;
|
|
|
- /** The inspector is created with the given engine.
|
|
|
- * If the parameter 'popup' is false, the inspector is created as a right panel on the main window.
|
|
|
- * If the parameter 'popup' is true, the inspector is created in another popup.
|
|
|
- */
|
|
|
- constructor(scene: BABYLON.Scene, popup?: boolean, initialTab?: number | string, parentElement?: BABYLON.Nullable<HTMLElement>, newColors?: {
|
|
|
- backgroundColor?: string;
|
|
|
- backgroundColorLighter?: string;
|
|
|
- backgroundColorLighter2?: string;
|
|
|
- backgroundColorLighter3?: string;
|
|
|
- color?: string;
|
|
|
- colorTop?: string;
|
|
|
- colorBot?: string;
|
|
|
- });
|
|
|
- readonly scene: BABYLON.Scene;
|
|
|
- readonly popupMode: boolean;
|
|
|
- /**
|
|
|
- * Filter the list of item present in the tree.
|
|
|
- * All item returned should have the given filter contained in the item id.
|
|
|
- */
|
|
|
- filterItem(filter: string): void;
|
|
|
- /** Display the mesh tab on the given object */
|
|
|
- displayObjectDetails(mesh: BABYLON.AbstractMesh): void;
|
|
|
- /** Clean the whole tree of item and rebuilds it */
|
|
|
- refresh(): void;
|
|
|
- /** Remove the inspector panel when it's built as a right panel:
|
|
|
- * remove the right panel and remove the wrapper
|
|
|
- */
|
|
|
- dispose(): void;
|
|
|
- /** Open the inspector in a new popup
|
|
|
- * Set 'firstTime' to true if there is no inspector created beforehands
|
|
|
- */
|
|
|
- openPopup(firstTime?: boolean): void;
|
|
|
- getActiveTabIndex(): number;
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export const PROPERTIES: {
|
|
|
- /** Format the given object :
|
|
|
- * If a format function exists, returns the result of this function.
|
|
|
- * If this function doesn't exists, return the object type instead
|
|
|
- */
|
|
|
- format: (obj: any) => any;
|
|
|
- 'type_not_defined': {
|
|
|
- properties: any[];
|
|
|
- format: () => string;
|
|
|
- };
|
|
|
- 'Vector2': {
|
|
|
- type: typeof BABYLON.Vector2;
|
|
|
- format: (vec: BABYLON.Vector2) => string;
|
|
|
- };
|
|
|
- 'Vector3': {
|
|
|
- type: typeof BABYLON.Vector3;
|
|
|
- format: (vec: BABYLON.Vector3) => string;
|
|
|
- };
|
|
|
- 'Color3': {
|
|
|
- type: typeof BABYLON.Color3;
|
|
|
- format: (color: BABYLON.Color3) => string;
|
|
|
- slider: {
|
|
|
- r: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- g: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- b: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- };
|
|
|
- };
|
|
|
- 'Color4': {
|
|
|
- type: typeof BABYLON.Color4;
|
|
|
- format: (color: BABYLON.Color4) => string;
|
|
|
- slider: {
|
|
|
- r: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- g: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- b: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- };
|
|
|
- };
|
|
|
- 'Quaternion': {
|
|
|
- type: typeof BABYLON.Quaternion;
|
|
|
- };
|
|
|
- 'Size': {
|
|
|
- type: typeof BABYLON.Size;
|
|
|
- format: (size: BABYLON.Size) => string;
|
|
|
- };
|
|
|
- 'Texture': {
|
|
|
- type: typeof BABYLON.Texture;
|
|
|
- format: (tex: BABYLON.Texture) => string;
|
|
|
- };
|
|
|
- 'RenderTargetTexture': {
|
|
|
- type: typeof BABYLON.RenderTargetTexture;
|
|
|
- };
|
|
|
- 'DynamicTexture': {
|
|
|
- type: typeof BABYLON.DynamicTexture;
|
|
|
- };
|
|
|
- 'BaseTexture': {
|
|
|
- type: typeof BABYLON.BaseTexture;
|
|
|
- };
|
|
|
- 'CubeTexture': {
|
|
|
- type: typeof BABYLON.CubeTexture;
|
|
|
- };
|
|
|
- 'HDRCubeTexture': {
|
|
|
- type: typeof BABYLON.HDRCubeTexture;
|
|
|
- };
|
|
|
- 'Sound': {
|
|
|
- type: typeof BABYLON.Sound;
|
|
|
- };
|
|
|
- 'ArcRotateCamera': {
|
|
|
- type: typeof BABYLON.ArcRotateCamera;
|
|
|
- slider: {
|
|
|
- alpha: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- beta: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- fov: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- };
|
|
|
- };
|
|
|
- 'FreeCamera': {
|
|
|
- type: typeof BABYLON.FreeCamera;
|
|
|
- slider: {
|
|
|
- fov: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- };
|
|
|
- };
|
|
|
- 'Scene': {
|
|
|
- type: typeof BABYLON.Scene;
|
|
|
- };
|
|
|
- 'TransformNode': {
|
|
|
- type: typeof BABYLON.TransformNode;
|
|
|
- format: (m: BABYLON.TransformNode) => string;
|
|
|
- };
|
|
|
- 'AbstractMesh': {
|
|
|
- type: typeof BABYLON.AbstractMesh;
|
|
|
- format: (m: BABYLON.AbstractMesh) => string;
|
|
|
- };
|
|
|
- 'Mesh': {
|
|
|
- type: typeof BABYLON.Mesh;
|
|
|
- format: (m: BABYLON.Mesh) => string;
|
|
|
- slider: {
|
|
|
- visibility: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- };
|
|
|
- };
|
|
|
- 'StandardMaterial': {
|
|
|
- type: typeof BABYLON.StandardMaterial;
|
|
|
- format: (mat: BABYLON.StandardMaterial) => string;
|
|
|
- slider: {
|
|
|
- alpha: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- };
|
|
|
- };
|
|
|
- 'PBRMaterial': {
|
|
|
- type: typeof BABYLON.PBRMaterial;
|
|
|
- slider: {
|
|
|
- alpha: {
|
|
|
- min: number;
|
|
|
- max: number;
|
|
|
- step: number;
|
|
|
- };
|
|
|
- };
|
|
|
- };
|
|
|
- 'PhysicsImpostor': {
|
|
|
- type: typeof BABYLON.PhysicsImpostor;
|
|
|
- };
|
|
|
- 'ImageProcessingConfiguration': {
|
|
|
- type: typeof BABYLON.ImageProcessingConfiguration;
|
|
|
- };
|
|
|
- 'ColorCurves': {
|
|
|
- type: typeof BABYLON.ColorCurves;
|
|
|
- };
|
|
|
- };
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export type GUITyping = any;
|
|
|
- export let guiLoaded: boolean;
|
|
|
- /**
|
|
|
- * Function that add gui objects properties to the variable PROPERTIES
|
|
|
- */
|
|
|
- export function loadGUIProperties(GUI: GUITyping): void;
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export abstract class Adapter {
|
|
|
- protected _obj: any;
|
|
|
- constructor(obj: any);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- abstract id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- abstract type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- abstract getProperties(): Array<PropertyLine>;
|
|
|
- /** Returns true if the given object correspond to this */
|
|
|
- correspondsTo(obj: any): boolean;
|
|
|
- /** Returns the adapter unique name */
|
|
|
- readonly name: string;
|
|
|
- /**
|
|
|
- * Returns the actual object used for this adapter
|
|
|
- */
|
|
|
- readonly object: any;
|
|
|
- /** Returns the list of tools available for this adapter */
|
|
|
- abstract getTools(): Array<AbstractTreeTool>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class CameraAdapter extends Adapter implements ICameraPOV {
|
|
|
- constructor(obj: BABYLON.Camera);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- setPOV(): void;
|
|
|
- getCurrentActiveCamera(): string;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class GUIAdapter extends Adapter implements IToolVisible {
|
|
|
- constructor(obj: any);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- setVisible(b: boolean): void;
|
|
|
- isVisible(): boolean;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class LightAdapter extends Adapter implements IToolVisible {
|
|
|
- constructor(obj: BABYLON.Light);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- setVisible(b: boolean): void;
|
|
|
- isVisible(): boolean;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class MaterialAdapter extends Adapter {
|
|
|
- constructor(obj: BABYLON.Material);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- /** No tools for a material adapter */
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class MeshAdapter extends Adapter implements IToolVisible, IToolDebug, IToolBoundingBox, IToolInfo {
|
|
|
- constructor(mesh: BABYLON.Node);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- setVisible(b: boolean): void;
|
|
|
- isVisible(): boolean;
|
|
|
- isBoxVisible(): boolean;
|
|
|
- setBoxVisible(b: boolean): boolean;
|
|
|
- debug(enable: boolean): void;
|
|
|
- /** Returns some information about this mesh */
|
|
|
- getInfo(): string;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class PhysicsImpostorAdapter extends Adapter implements IToolVisible {
|
|
|
- constructor(obj: BABYLON.PhysicsImpostor, viewer: any);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- setVisible(b: boolean): void;
|
|
|
- isVisible(): boolean;
|
|
|
+ export class Inspector {
|
|
|
+ static OnSelectionChangeObservable: BABYLON.Observable<string>;
|
|
|
+ static OnPropertyChangedObservable: BABYLON.Observable<PropertyChangedEvent>;
|
|
|
+ static readonly IsVisible: boolean;
|
|
|
+ static EarlyAttachToLoader(): void;
|
|
|
+ static Show(scene: BABYLON.Scene, userOptions: Partial<BABYLON.IInspectorOptions>): void;
|
|
|
+ static Hide(): void;
|
|
|
}
|
|
|
}
|
|
|
declare module INSPECTOR {
|
|
|
- export class SoundAdapter extends Adapter implements ISoundInteractions {
|
|
|
- constructor(obj: BABYLON.Sound);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- setPlaying(callback: Function): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class TextureAdapter extends Adapter {
|
|
|
- constructor(obj: BABYLON.BaseTexture);
|
|
|
- /** Returns the name displayed in the tree */
|
|
|
- id(): string;
|
|
|
- /** Returns the type of this object - displayed in the tree */
|
|
|
- type(): string;
|
|
|
- /** Returns the list of properties to be displayed for this adapter */
|
|
|
- getProperties(): Array<PropertyLine>;
|
|
|
- getTools(): Array<AbstractTreeTool>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export interface SortDirection {
|
|
|
- [property: string]: number;
|
|
|
- }
|
|
|
- export class DetailPanel extends BasicElement {
|
|
|
- constructor(dr?: Array<PropertyLine>);
|
|
|
- details: Array<PropertyLine>;
|
|
|
- protected _build(): void;
|
|
|
- /** Updates the HTML of the detail panel */
|
|
|
- update(_items?: Array<PropertyLine>): void;
|
|
|
- /** Search an element by name */
|
|
|
- searchByName(searchName: string): void;
|
|
|
- /**
|
|
|
- * Removes all data in the detail panel but keep the header row
|
|
|
- */
|
|
|
- clean(): void;
|
|
|
- /**
|
|
|
- * Clean the rows only
|
|
|
- */
|
|
|
- cleanRow(): void;
|
|
|
- /** Overrides basicelement.dispose */
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * A property is a link between a data (string) and an object.
|
|
|
- */
|
|
|
- export class Property {
|
|
|
- constructor(prop: string, obj: any, parentObj?: any);
|
|
|
- readonly name: string;
|
|
|
+ export class PropertyChangedEvent {
|
|
|
+ object: any;
|
|
|
+ property: string;
|
|
|
value: any;
|
|
|
- readonly type: string;
|
|
|
- obj: any;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class PropertyFormatter {
|
|
|
- /**
|
|
|
- * Format the value of the given property of the given object.
|
|
|
- */
|
|
|
- static format(obj: any, prop: string): string;
|
|
|
- }
|
|
|
- /**
|
|
|
- * A property line represents a line in the detail panel. This line is composed of :
|
|
|
- * - a name (the property name)
|
|
|
- * - a value if this property is of a type 'simple' : string, number, boolean, color, texture
|
|
|
- * - the type of the value if this property is of a complex type (Vector2, BABYLON.Size, ...)
|
|
|
- * - a ID if defined (otherwise an empty string is displayed)
|
|
|
- * The original object is sent to the value object who will update it at will.
|
|
|
- *
|
|
|
- * A property line can contain OTHER property line objects in the case of a complex type.
|
|
|
- * If this instance has no link to other instances, its type is ALWAYS a simple one (see above).
|
|
|
- *
|
|
|
- */
|
|
|
- export class PropertyLine {
|
|
|
- constructor(prop: Property, parent?: BABYLON.Nullable<PropertyLine>, level?: number);
|
|
|
- validateInput(value: any, forceupdate?: boolean): void;
|
|
|
- /** Retrieve the correct object from its parent.
|
|
|
- * If no parent exists, returns the property value.
|
|
|
- * This method is used at each update in case the property object is removed from the original object
|
|
|
- * (example : mesh.position = new BABYLON.Vector3 ; the original vector3 object is deleted from the mesh).
|
|
|
- */
|
|
|
- updateObject(): any;
|
|
|
- readonly name: string;
|
|
|
- readonly value: any;
|
|
|
- readonly type: string;
|
|
|
- /** Delete properly this property line.
|
|
|
- * Removes itself from the scheduler.
|
|
|
- * Dispose all viewer element (color, texture...)
|
|
|
- */
|
|
|
- dispose(): void;
|
|
|
- /**
|
|
|
- * Update the property division with the new property value.
|
|
|
- * If this property is complex, update its child, otherwise update its text content
|
|
|
- */
|
|
|
- update(): void;
|
|
|
- toHtml(): HTMLElement;
|
|
|
- closeDetails(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * Represents a html div element.
|
|
|
- * The div is built when an instance of BasicElement is created.
|
|
|
- */
|
|
|
- export abstract class BasicElement {
|
|
|
- protected _div: HTMLDivElement;
|
|
|
- constructor();
|
|
|
- /**
|
|
|
- * Returns the div element
|
|
|
- */
|
|
|
- toHtml(): HTMLDivElement;
|
|
|
- /**
|
|
|
- * Build the html element
|
|
|
- */
|
|
|
- protected _build(): void;
|
|
|
- abstract update(data?: any): void;
|
|
|
- /** Default dispose method if needed */
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * Display a very small div corresponding to the given color
|
|
|
- */
|
|
|
- export class ColorElement extends BasicElement {
|
|
|
- constructor(color: BABYLON.Color4 | BABYLON.Color3);
|
|
|
- update(color?: BABYLON.Color4 | BABYLON.Color3): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * Represents a html div element.
|
|
|
- * The div is built when an instance of BasicElement is created.
|
|
|
- */
|
|
|
- export class ColorPickerElement extends BasicElement {
|
|
|
- protected _input: HTMLInputElement;
|
|
|
- constructor(color: BABYLON.Color4 | BABYLON.Color3, propertyLine: PropertyLine);
|
|
|
- update(color?: BABYLON.Color4 | BABYLON.Color3): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * Display a very small div. A new canvas is created, with a new js scene, containing only the
|
|
|
- * cube texture in a cube
|
|
|
- */
|
|
|
- export class CubeTextureElement extends BasicElement {
|
|
|
- protected _scene: BABYLON.Scene;
|
|
|
- protected _cube: BABYLON.Mesh;
|
|
|
- protected _textureUrl: string;
|
|
|
- /** The texture given as a parameter should be cube. */
|
|
|
- constructor(tex: BABYLON.Texture);
|
|
|
- update(tex?: BABYLON.Texture): void;
|
|
|
- /** Creates the box */
|
|
|
- protected _populateScene(): void;
|
|
|
- /** Removes properly the babylon engine */
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * Display a very small div. A new canvas is created, with a new js scene, containing only the
|
|
|
- * cube texture in a cube
|
|
|
- */
|
|
|
- export class HDRCubeTextureElement extends CubeTextureElement {
|
|
|
- /** The texture given as a parameter should be cube. */
|
|
|
- constructor(tex: BABYLON.Texture);
|
|
|
- /** Creates the box */
|
|
|
- protected _populateScene(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * A search bar can be used to filter elements in the tree panel.
|
|
|
- * At each keypress on the input, the treepanel will be filtered.
|
|
|
- */
|
|
|
- export class SearchBar extends BasicElement {
|
|
|
- constructor(tab: PropertyTab);
|
|
|
- /** Delete all characters typped in the input element */
|
|
|
- reset(): void;
|
|
|
- update(): void;
|
|
|
- }
|
|
|
- export class SearchBarDetails extends BasicElement {
|
|
|
- constructor(tab: DetailPanel);
|
|
|
- /** Delete all characters typped in the input element */
|
|
|
- reset(): void;
|
|
|
- update(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * Display a very small div corresponding to the given texture. On mouse over, display the full image
|
|
|
- */
|
|
|
- export class TextureElement extends BasicElement {
|
|
|
- constructor(tex: BABYLON.Texture);
|
|
|
- update(tex?: BABYLON.Texture): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * Creates a tooltip for the parent of the given html element
|
|
|
- */
|
|
|
- export class Tooltip {
|
|
|
- constructor(elem: HTMLElement, tip: string, attachTo?: BABYLON.Nullable<HTMLElement>);
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class Helpers {
|
|
|
- /**
|
|
|
- * Returns the type of the given object. First
|
|
|
- * uses getClassName. If nothing is returned, used the type of the constructor
|
|
|
- */
|
|
|
- static GET_TYPE(obj: any): string;
|
|
|
- /**
|
|
|
- * Returns true if the user browser is edge.
|
|
|
- */
|
|
|
- static IsBrowserEdge(): boolean;
|
|
|
- /**
|
|
|
- * Returns true if the user browser is IE.
|
|
|
- */
|
|
|
- static IsBrowserIE(): boolean;
|
|
|
- /** Send the event which name is given in parameter to the window */
|
|
|
- static SEND_EVENT(eventName: string): void;
|
|
|
- /** Returns the given number with 2 decimal number max if a decimal part exists */
|
|
|
- static Trunc(nb: number): number;
|
|
|
- /**
|
|
|
- * Useful function used to create a div
|
|
|
- */
|
|
|
- static CreateDiv(className?: BABYLON.Nullable<string>, parent?: HTMLElement, tooltip?: string): HTMLDivElement;
|
|
|
- /**
|
|
|
- * Useful function used to create a input
|
|
|
- */
|
|
|
- static CreateInput(className?: string, parent?: HTMLElement, tooltip?: string): HTMLInputElement;
|
|
|
- static CreateElement(element: string, className?: BABYLON.Nullable<string>, parent?: HTMLElement, tooltip?: string): HTMLElement;
|
|
|
- /**
|
|
|
- * Removes all children of the given div.
|
|
|
- */
|
|
|
- static CleanDiv(div: HTMLElement): void;
|
|
|
- /**
|
|
|
- * Returns the true value of the given CSS Attribute from the given element (in percentage or in pixel, as it was specified in the css)
|
|
|
- */
|
|
|
- static Css(elem: HTMLElement, cssAttribute: string): string;
|
|
|
- static LoadScript(): void;
|
|
|
- static IsSystemName(name: string): boolean;
|
|
|
- /**
|
|
|
- * Return an array of PropertyLine for an obj
|
|
|
- * @param obj
|
|
|
- */
|
|
|
- static GetAllLinesProperties(obj: any): Array<PropertyLine>;
|
|
|
- /**
|
|
|
- * Returns an array of string corresponding to tjhe list of properties of the object to be displayed
|
|
|
- * @param obj
|
|
|
- */
|
|
|
- static GetAllLinesPropertiesAsString(obj: any, dontTakeThis?: Array<string>): Array<string>;
|
|
|
- static Capitalize(str: string): string;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class Scheduler {
|
|
|
- /** Is this scheduler in pause ? */
|
|
|
- pause: boolean;
|
|
|
- /** All properties are refreshed every 250ms */
|
|
|
- static REFRESH_TIME: number;
|
|
|
- constructor();
|
|
|
- static getInstance(): Scheduler;
|
|
|
- /** Add a property line to be updated every X ms */
|
|
|
- add(prop: PropertyLine): void;
|
|
|
- /** Removes the given property from the list of properties to update */
|
|
|
- remove(prop: PropertyLine): void;
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class CameraTab extends PropertyTab {
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- protected _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * The console tab will have two features :
|
|
|
- * - hook all console.log call and display them in this panel (and in the browser console as well)
|
|
|
- * - display all Babylon logs (called with Tools.Log...)
|
|
|
- */
|
|
|
- export class ConsoleTab extends Tab {
|
|
|
- constructor(tabbar: TabBar, insp: Inspector);
|
|
|
- /** Overrides super.dispose */
|
|
|
- dispose(): void;
|
|
|
- active(b: boolean): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class GLTFTab extends Tab {
|
|
|
- static readonly IsSupported: boolean;
|
|
|
- /** @hidden */
|
|
|
- static _Initialize(): void;
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- dispose(): void;
|
|
|
- /** @hidden */
|
|
|
- static _GetLoaderDefaultsAsync(): Promise<any>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class GUITab extends PropertyTab {
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- protected _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class LightTab extends PropertyTab {
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- protected _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class MaterialTab extends PropertyTab {
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- protected _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class MeshTab extends PropertyTab {
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- protected _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class PhysicsTab extends PropertyTab {
|
|
|
- viewer: any;
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- protected _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * A Property tab can creates two panels:
|
|
|
- * a tree panel and a detail panel,
|
|
|
- * in which properties will be displayed.
|
|
|
- * Both panels are separated by a resize bar
|
|
|
- */
|
|
|
- export abstract class PropertyTab extends Tab {
|
|
|
- protected _inspector: Inspector;
|
|
|
- /** The panel containing a list of items */
|
|
|
- protected _treePanel: HTMLDivElement;
|
|
|
- /** The panel containing a list if properties corresponding to an item */
|
|
|
- protected _detailsPanel: DetailPanel;
|
|
|
- protected _treeItems: Array<TreeItem>;
|
|
|
- protected _searchBar: SearchBar;
|
|
|
- constructor(tabbar: TabBar, name: string, insp: Inspector);
|
|
|
- /** Overrides dispose */
|
|
|
- dispose(): void;
|
|
|
- update(_items?: Array<TreeItem>): void;
|
|
|
- /** Display the details of the given item */
|
|
|
- displayDetails(item: TreeItem): void;
|
|
|
- /** Select an item in the tree */
|
|
|
- select(item: TreeItem): void;
|
|
|
- /** Set the given item as active in the tree */
|
|
|
- activateNode(item: TreeItem): void;
|
|
|
- /** Returns the treeitem corersponding to the given obj, null if not found */
|
|
|
- getItemFor(_obj: any): BABYLON.Nullable<TreeItem>;
|
|
|
- filter(filter: string): void;
|
|
|
- /** Builds the tree panel */
|
|
|
- protected abstract _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class SceneTab extends Tab {
|
|
|
- constructor(tabbar: TabBar, insp: Inspector);
|
|
|
- /** Overrides super.dispose */
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class SoundTab extends PropertyTab {
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- protected _getTree(): Array<TreeItem>;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class StatsTab extends Tab {
|
|
|
- constructor(tabbar: TabBar, insp: Inspector);
|
|
|
- dispose(): void;
|
|
|
- active(b: boolean): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export abstract class Tab extends BasicElement {
|
|
|
- protected _tabbar: TabBar;
|
|
|
- name: string;
|
|
|
- protected _isActive: boolean;
|
|
|
- protected _panel: HTMLDivElement;
|
|
|
- constructor(tabbar: TabBar, name: string);
|
|
|
- /** True if the tab is active, false otherwise */
|
|
|
- isActive(): boolean;
|
|
|
- protected _build(): void;
|
|
|
- /** Set this tab as active or not, depending on the current state */
|
|
|
- active(b: boolean): void;
|
|
|
- update(): void;
|
|
|
- /** Creates the tab panel for this tab. */
|
|
|
- getPanel(): HTMLElement;
|
|
|
- /** Add this in the propertytab with the searchbar */
|
|
|
- filter(str: string): void;
|
|
|
- /** Dispose properly this tab */
|
|
|
- abstract dispose(): void;
|
|
|
- /** Select an item in the tree */
|
|
|
- select(item: TreeItem): void;
|
|
|
- /**
|
|
|
- * Returns the total width in pixel of this tab, 0 by default
|
|
|
- */
|
|
|
- getPixelWidth(): number;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /**
|
|
|
- * A tab bar will contains each view the inspector can have : Canvas2D, Meshes...
|
|
|
- * The default active tab is the first one of the list.
|
|
|
- */
|
|
|
- export class TabBar extends BasicElement {
|
|
|
- constructor(inspector: Inspector, initialTab?: number | string);
|
|
|
- update(): void;
|
|
|
- protected _build(): void;
|
|
|
- /** Dispose the current tab, set the given tab as active, and refresh the treeview */
|
|
|
- switchTab(tab: Tab): void;
|
|
|
- /** Display the mesh tab.
|
|
|
- * If a parameter is given, the given mesh details are displayed
|
|
|
- */
|
|
|
- switchMeshTab(mesh?: BABYLON.AbstractMesh): void;
|
|
|
- /** Returns the active tab */
|
|
|
- getActiveTab(): BABYLON.Nullable<Tab>;
|
|
|
- getActiveTabIndex(): number;
|
|
|
- getTabIndex(name: string): number;
|
|
|
- readonly inspector: Inspector;
|
|
|
- /**
|
|
|
- * Returns the total width in pixel of the tabbar,
|
|
|
- * that corresponds to the sum of the width of each visible tab + toolbar width
|
|
|
- */
|
|
|
- getPixelWidth(): number;
|
|
|
- /** Display the remaining icon or not depending on the tabbar width.
|
|
|
- * This function should be called each time the inspector width is updated
|
|
|
- */
|
|
|
- updateWidth(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class TextureTab extends Tab {
|
|
|
- static DDSPreview: DDSPreview;
|
|
|
- /** The panel containing a list of items */
|
|
|
- protected _treePanel: HTMLElement;
|
|
|
- protected _treeItems: Array<TreeItem>;
|
|
|
- constructor(tabbar: TabBar, inspector: Inspector);
|
|
|
- dispose(): void;
|
|
|
- update(_items?: Array<TreeItem>): void;
|
|
|
- /** Display the details of the given item */
|
|
|
- displayDetails(item: TreeItem): void;
|
|
|
- /** Select an item in the tree */
|
|
|
- select(item: TreeItem): void;
|
|
|
- /** Set the given item as active in the tree */
|
|
|
- activateNode(item: TreeItem): void;
|
|
|
- }
|
|
|
- class DDSPreview {
|
|
|
- canvas: HTMLCanvasElement | null;
|
|
|
- constructor(AdapterItem: TextureAdapter);
|
|
|
- insertPreview(AdapterItem: TextureAdapter): void;
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class ToolsTab extends Tab {
|
|
|
- constructor(tabbar: TabBar, insp: Inspector);
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export class TreeItem extends BasicElement {
|
|
|
- children: Array<TreeItem>;
|
|
|
- constructor(tab: Tab, obj: Adapter);
|
|
|
- /** Returns the item ID == its adapter ID */
|
|
|
- readonly id: string;
|
|
|
- /** Add the given item as a child of this one */
|
|
|
- add(child: TreeItem): void;
|
|
|
- /**
|
|
|
- * Returns the original adapter
|
|
|
- */
|
|
|
- readonly adapter: Adapter;
|
|
|
- /**
|
|
|
- * Function used to compare this item to another tree item.
|
|
|
- * Returns the alphabetical sort of the adapter ID
|
|
|
- */
|
|
|
- compareTo(item: TreeItem): number;
|
|
|
- /** Returns true if the given obj correspond to the adapter linked to this tree item */
|
|
|
- correspondsTo(obj: any): boolean;
|
|
|
- /** hide all children of this item */
|
|
|
- fold(): void;
|
|
|
- /** Show all children of this item */
|
|
|
- unfold(): void;
|
|
|
- /** Build the HTML of this item */
|
|
|
- protected _build(): void;
|
|
|
- /**
|
|
|
- * Returns one HTML element (.details) containing all details of this primitive
|
|
|
- */
|
|
|
- getDetails(): Array<PropertyLine>;
|
|
|
- update(): void;
|
|
|
- /**
|
|
|
- * Add an event listener on the item :
|
|
|
- * - one click display details
|
|
|
- */
|
|
|
- protected _addEvent(): void;
|
|
|
- /** Set this item as active (background lighter) in the tree panel */
|
|
|
- active(b: boolean): void;
|
|
|
- getDiv(): HTMLDivElement;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export abstract class AbstractTreeTool {
|
|
|
- protected _elem: HTMLElement;
|
|
|
- /** Is the tool enabled ? */
|
|
|
- protected _on: boolean;
|
|
|
- constructor();
|
|
|
- toHtml(): HTMLElement;
|
|
|
- protected _addEvents(): void;
|
|
|
- /**
|
|
|
- * Action launched when clicked on this element
|
|
|
- * Should be overrided
|
|
|
- */
|
|
|
- protected action(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /** Any object implementing this interface should
|
|
|
- * provide methods to toggle its bounding box
|
|
|
- */
|
|
|
- export interface IToolBoundingBox {
|
|
|
- isBoxVisible: () => boolean;
|
|
|
- setBoxVisible: (b: boolean) => void;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Checkbox to display/hide the primitive
|
|
|
- */
|
|
|
- export class BoundingBox extends AbstractTreeTool {
|
|
|
- constructor(obj: IToolBoundingBox);
|
|
|
- protected action(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export interface ICameraPOV {
|
|
|
- setPOV: () => void;
|
|
|
- getCurrentActiveCamera: () => string;
|
|
|
- id: () => string;
|
|
|
- }
|
|
|
- /**
|
|
|
- *
|
|
|
- */
|
|
|
- export class CameraPOV extends AbstractTreeTool {
|
|
|
- constructor(camera: ICameraPOV);
|
|
|
- protected action(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /** Any object implementing this interface should
|
|
|
- * provide methods to toggle its visibility
|
|
|
- */
|
|
|
- export interface IToolVisible {
|
|
|
- isVisible: () => boolean;
|
|
|
- setVisible: (b: boolean) => void;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Checkbox to display/hide the primitive
|
|
|
- */
|
|
|
- export class Checkbox extends AbstractTreeTool {
|
|
|
- constructor(obj: IToolVisible);
|
|
|
- protected action(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /** Any object implementing this interface should
|
|
|
- * provide methods to toggle a debug area
|
|
|
- */
|
|
|
- export interface IToolDebug {
|
|
|
- debug: (b: boolean) => void;
|
|
|
- }
|
|
|
- export class DebugArea extends AbstractTreeTool {
|
|
|
- constructor(obj: IToolDebug);
|
|
|
- protected action(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- /** Any object implementing this interface should
|
|
|
- * provide methods to retrieve its info
|
|
|
- */
|
|
|
- export interface IToolInfo {
|
|
|
- getInfo: () => string;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Checkbox to display/hide the primitive
|
|
|
- */
|
|
|
- export class Info extends AbstractTreeTool {
|
|
|
- constructor(obj: IToolInfo);
|
|
|
- protected action(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-declare module INSPECTOR {
|
|
|
- export interface ISoundInteractions {
|
|
|
- setPlaying: (callback: Function) => void;
|
|
|
- }
|
|
|
- /**
|
|
|
- *
|
|
|
- */
|
|
|
- export class SoundInteractions extends AbstractTreeTool {
|
|
|
- constructor(playSound: ISoundInteractions);
|
|
|
- protected action(): void;
|
|
|
+ initialValue: any;
|
|
|
}
|
|
|
}
|