declare module "babylonjs-inspector/tools" { export class Tools { static LookForItem(item: any, selectedEntity: any): boolean; private static _RecursiveRemoveHiddenMeshesAndHoistChildren; static GetNameString(obj: any): any; static SortAndFilter(parent: any, items: any[]): any[]; } } declare module "babylonjs-inspector/textureHelper" { import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { GlobalState } from "babylonjs-inspector/components/globalState"; /** * Defines which channels of the texture to retrieve with {@link TextureHelper.GetTextureDataAsync}. */ export interface TextureChannelsToDisplay { /** * True if the red channel should be included. */ R: boolean; /** * True if the green channel should be included. */ G: boolean; /** * True if the blue channel should be included. */ B: boolean; /** * True if the alpha channel should be included. */ A: boolean; } /** * Helper class for retrieving texture data. */ export class TextureHelper { /** * Gets the data of the specified texture by rendering it to an intermediate RGBA texture and retrieving the bytes from it. * This is convienent to get 8-bit RGBA values for a texture in a GPU compressed format. * @param texture the source texture * @param width the width of the result, which does not have to match the source texture width * @param height the height of the result, which does not have to match the source texture height * @param face if the texture has multiple faces, the face index to use for the source * @param channels a filter for which of the RGBA channels to return in the result * @param globalState the global state to use for rendering the texture * @param lod if the texture has multiple LODs, the lod index to use for the source * @returns the 8-bit texture data */ static GetTextureDataAsync(texture: BaseTexture, width: number, height: number, face: number, channels: TextureChannelsToDisplay, globalState?: GlobalState, lod?: number): Promise; } } declare module "babylonjs-inspector/inspector" { import * as React from "react"; import { IInspectorOptions } from "babylonjs/Debug/debugLayer"; import { Observable } from "babylonjs/Misc/observable"; import { Scene } from "babylonjs/scene"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { IPopupComponentProps } from "babylonjs-inspector/components/popupComponent"; export interface IPersistentPopupConfiguration { props: IPopupComponentProps; children: React.ReactNode; closeWhenSceneExplorerCloses?: boolean; closeWhenActionTabsCloses?: boolean; } export class Inspector { private static _SceneExplorerHost; private static _ActionTabsHost; private static _EmbedHost; private static _PersistentPopupHost; private static _SceneExplorerRoot; private static _ActionTabsRoot; private static _EmbedHostRoot; private static _PersistentPopupRoot; private static _NewCanvasContainer; private static _SceneExplorerWindow; private static _ActionTabsWindow; private static _EmbedHostWindow; private static _Scene; private static _OpenedPane; private static _OnBeforeRenderObserver; private static _OnSceneExplorerClosedObserver; private static _OnActionTabsClosedObserver; static OnSelectionChangeObservable: Observable; static OnPropertyChangedObservable: Observable; private static _GlobalState; static MarkLineContainerTitleForHighlighting(title: string): void; static MarkMultipleLineContainerTitlesForHighlighting(titles: string[]): void; private static _SceneExplorerOptions; private static _InspectorOptions; private static _EmbedOptions; static PopupEmbed(): void; static PopupSceneExplorer(): void; static PopupInspector(): void; private static _CreateSceneExplorer; private static _CreateActionTabs; private static _CreateEmbedHost; static get IsVisible(): boolean; static EarlyAttachToLoader(): void; static Show(scene: Scene, userOptions: Partial): void; static _SetNewScene(scene: Scene): void; static _CreateCanvasContainer(parentControl: HTMLElement): void; private static _DestroyCanvasContainer; private static _Cleanup; private static _RemoveElementFromDOM; static Hide(): void; static _CreatePersistentPopup(config: IPersistentPopupConfiguration, hostElement: HTMLElement): void; static _ClosePersistentPopup(): void; } } declare module "babylonjs-inspector/index" { export * from "babylonjs-inspector/inspector"; export * from "babylonjs-inspector/components/sceneExplorer/entities/gui/guiTools"; } declare module "babylonjs-inspector/legacy/legacy" { export * from "babylonjs-inspector/index"; } declare module "babylonjs-inspector/components/replayRecorder" { import { Scene } from "babylonjs/scene"; export class ReplayRecorder { private _sceneRecorder; private _isRecording; get isRecording(): boolean; cancel(): void; trackScene(scene: Scene): void; applyDelta(json: any, scene: Scene): void; export(): void; } } declare module "babylonjs-inspector/components/propertyChangedEvent" { export class PropertyChangedEvent { object: any; property: string; value: any; initialValue: any; allowNullValue?: boolean; } } declare module "babylonjs-inspector/components/popupComponent" { import * as React from "react"; import { PropsWithChildren } from "react"; export interface IPopupComponentProps { id: string; title: string; size: { width: number; height: number; }; onOpen?: (window: Window) => void; onClose: (window: Window) => void; onResize?: (window: Window) => void; onKeyUp?: (evt: KeyboardEvent) => void; onKeyDown?: (evt: KeyboardEvent) => void; } export class PopupComponent extends React.Component, { isComponentMounted: boolean; blockedByBrowser: boolean; }> { private _container; private _window; private _host; constructor(props: IPopupComponentProps); componentDidMount(): void; onBeforeUnloadListener: () => void; openPopup(): void; componentWillUnmount(): void; getWindow(): Window | null; render(): React.ReactPortal | null; } } declare module "babylonjs-inspector/components/headerComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; export interface IHeaderComponentProps { title: string; handleBack?: boolean; noExpand?: boolean; noClose?: boolean; noCommands?: boolean; onPopup: () => void; onClose: () => void; onSelectionChangedObservable?: Observable; } export class HeaderComponent extends React.Component { private _backStack; private _onSelectionChangeObserver; constructor(props: IHeaderComponentProps); componentDidMount(): void; componentWillUnmount(): void; goBack(): void; } } declare module "babylonjs-inspector/components/globalState" { import { IGLTFValidationResults } from "babylonjs-gltf2interface"; import { Nullable } from "babylonjs/types"; import { Observer } from "babylonjs/Misc/observable"; import { Observable } from "babylonjs/Misc/observable"; import { ISceneLoaderPlugin, ISceneLoaderPluginAsync } from "babylonjs/Loading/sceneLoader"; import { Scene } from "babylonjs/scene"; import { Light } from "babylonjs/Lights/light"; import { Camera } from "babylonjs/Cameras/camera"; import { LightGizmo } from "babylonjs/Gizmos/lightGizmo"; import { CameraGizmo } from "babylonjs/Gizmos/cameraGizmo"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { ReplayRecorder } from "babylonjs-inspector/components/replayRecorder"; import { IGLTFLoaderExtension, GLTFFileLoader } from "babylonjs-loaders/glTF/index"; export class GlobalState { onSelectionChangedObservable: Observable; onPropertyChangedObservable: Observable; onInspectorClosedObservable: Observable; onTabChangedObservable: Observable; onSelectionRenamedObservable: Observable; onPluginActivatedObserver: Nullable>; onNewSceneObservable: Observable; sceneImportDefaults: { [key: string]: any; }; validationResults: Nullable; onValidationResultsUpdatedObservable: Observable>; onExtensionLoadedObservable: Observable; glTFLoaderOverrideExtensionsConfig: boolean; glTFLoaderExtensionDefaults: { [name: string]: { [key: string]: any; }; }; glTFLoaderOverrideConfig: boolean; glTFLoaderDefaults: { [key: string]: any; }; glTFLoaderExtensions: { [key: string]: IGLTFLoaderExtension; }; blockMutationUpdates: boolean; selectedLineContainerTitles: Array; selectedLineContainerTitlesNoFocus: Array; recorder: ReplayRecorder; private _onlyUseEulers; get onlyUseEulers(): boolean; set onlyUseEulers(value: boolean); private _ignoreBackfacesForPicking; get ignoreBackfacesForPicking(): boolean; set ignoreBackfacesForPicking(value: boolean); init(propertyChangedObservable: Observable): void; prepareGLTFPlugin(loader: GLTFFileLoader): void; resetGLTFValidationResults(): void; lightGizmos: Array; enableLightGizmo(light: Light, enable?: boolean, gizmoCamera?: Nullable): void; cameraGizmos: Array; enableCameraGizmo(camera: Camera, enable?: boolean, gizmoCamera?: Nullable): void; onSceneExplorerClosedObservable: Observable; onActionTabsClosedObservable: Observable; } } declare module "babylonjs-inspector/components/sceneExplorer/treeNodeDebugger" { export function setDebugNode(node: any): void; } declare module "babylonjs-inspector/components/sceneExplorer/treeItemSpecializedComponent" { import { Camera } from "babylonjs/Cameras/camera"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ITreeItemSpecializedComponentProps { label: string; entity?: any; extensibilityGroups?: IExplorerExtensibilityGroup[]; globalState: GlobalState; gizmoCamera?: Camera; onClick?: () => void; } export class TreeItemSpecializedComponent extends React.Component { constructor(props: ITreeItemSpecializedComponentProps); onClick(): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/treeItemSelectableComponent" { import { Nullable } from "babylonjs/types"; import { Camera } from "babylonjs/Cameras/camera"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; export interface ITreeItemSelectableComponentProps { entity: any; selectedEntity?: any; mustExpand?: boolean; offset: number; globalState: GlobalState; gizmoCamera?: Camera; extensibilityGroups?: IExplorerExtensibilityGroup[]; filter: Nullable; } export class TreeItemSelectableComponent extends React.Component { private _wasSelected; private _thisRef; constructor(props: ITreeItemSelectableComponentProps); switchExpandedState(mustExpand: boolean): void; shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: { isExpanded: boolean; isSelected: boolean; }): boolean; scrollIntoView(): void; componentDidMount(): void; componentDidUpdate(): void; onSelect(): void; } } declare module "babylonjs-inspector/components/sceneExplorer/treeItemLabelComponent" { import * as React from "react"; interface ITreeItemLabelComponentProps { label: string; onClick?: () => void; icon?: any; iconBase64?: string; color: string; } export class TreeItemLabelComponent extends React.Component { constructor(props: ITreeItemLabelComponentProps); onClick(): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/treeItemComponent" { import * as React from "react"; import { Nullable } from "babylonjs/types"; import { IInspectorContextMenuItem, IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Camera } from "babylonjs/Cameras/camera"; export interface ITreeItemComponentProps { items?: Nullable; label: string; offset: number; filter: Nullable; forceSubitems?: boolean; globalState: GlobalState; gizmoCamera?: Camera; entity?: any; selectedEntity: any; extensibilityGroups?: IExplorerExtensibilityGroup[]; contextMenuItems?: IInspectorContextMenuItem[]; } export class TreeItemComponent extends React.Component { static _ContextMenuUniqueIdGenerator: number; constructor(props: ITreeItemComponentProps); switchExpandedState(): void; shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: { isExpanded: boolean; }): boolean; expandAll(expand: boolean): void; } } declare module "babylonjs-inspector/components/sceneExplorer/sceneExplorerComponent" { import * as React from "react"; import { Nullable } from "babylonjs/types"; import { IExplorerAdditionalNode, IExplorerExtensibilityGroup, IInspectorOptions } from "babylonjs/Debug/debugLayer"; import { Scene } from "babylonjs/scene"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Camera } from "babylonjs/Cameras/camera"; import "babylonjs/Sprites/spriteSceneComponent"; import "babylonjs/Audio/audioSceneComponent"; import "babylonjs/PostProcesses/RenderPipeline/postProcessRenderPipelineManagerSceneComponent"; import "babylonjs-inspector/components/sceneExplorer/sceneExplorer.scss"; interface ISceneExplorerFilterComponentProps { onFilter: (filter: string) => void; } export class SceneExplorerFilterComponent extends React.Component { constructor(props: ISceneExplorerFilterComponentProps); } interface ISceneExplorerComponentProps { scene: Scene; contextMenu?: IInspectorOptions["contextMenu"]; contextMenuOverride?: IInspectorOptions["contextMenuOverride"]; gizmoCamera?: Camera; noCommands?: boolean; noHeader?: boolean; noExpand?: boolean; noClose?: boolean; extensibilityGroups?: IExplorerExtensibilityGroup[]; additionalNodes?: IExplorerAdditionalNode[]; globalState: GlobalState; popupMode?: boolean; onPopup?: () => void; onClose?: () => void; } export class SceneExplorerComponent extends React.Component; selectedEntity: any; scene: Scene; }> { private _onSelectionChangeObserver; private _onSelectionRenamedObserver; private _onNewSceneAddedObserver; private _onNewSceneObserver; private _sceneExplorerRef; private _mutationTimeout; private _once; private _hooked; private _sceneMutationFunc; constructor(props: ISceneExplorerComponentProps); processMutation(): void; componentDidMount(): void; componentWillUnmount(): void; filterContent(filter: string): void; findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: { previousOne?: any; found?: boolean; }): boolean; processKeys(keyEvent: React.KeyboardEvent, allNodes: any[]): void; private _getPipelineContextMenus; private _getNodeContextMenus; private _getMaterialsContextMenus; private _getSpriteManagersContextMenus; private _getParticleSystemsContextMenus; private _getFrameGraphsContextMenus; onClose(): void; onPopup(): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/extensionsComponent" { import * as React from "react"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; interface IExtensionsComponentProps { target: any; extensibilityGroups?: IExplorerExtensibilityGroup[]; } export class ExtensionsComponent extends React.Component { private _popup; private _extensionRef; constructor(props: IExtensionsComponentProps); showPopup(): void; componentDidMount(): void; componentDidUpdate(): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/transformNodeTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { TransformNode } from "babylonjs/Meshes/transformNode"; import * as React from "react"; interface ITransformNodeItemComponentProps { transformNode: TransformNode; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class TransformNodeItemComponent extends React.Component { constructor(props: ITransformNodeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/textureTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { Texture } from "babylonjs/Materials/Textures/texture"; import * as React from "react"; interface ITextureTreeItemComponentProps { texture: Texture; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class TextureTreeItemComponent extends React.Component { constructor(props: ITextureTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/targetedAnimationTreeItemComponent" { import { TargetedAnimation } from "babylonjs/Animations/animationGroup"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; interface ITargetedAnimationItemComponentProps { targetedAnimation: TargetedAnimation; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class TargetedAnimationItemComponent extends React.Component { constructor(props: ITargetedAnimationItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/spriteTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { Sprite } from "babylonjs/Sprites/sprite"; interface ISpriteTreeItemComponentProps { sprite: Sprite; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class SpriteTreeItemComponent extends React.Component { constructor(props: ISpriteTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/spriteManagerTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { SpriteManager } from "babylonjs/Sprites/spriteManager"; interface ISpriteManagerTreeItemComponentProps { spriteManager: SpriteManager; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class SpriteManagerTreeItemComponent extends React.Component { constructor(props: ISpriteManagerTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/soundTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { Sound } from "babylonjs/Audio/sound"; interface ISoundTreeItemComponentProps { sound: Sound; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class SoundTreeItemComponent extends React.Component { constructor(props: ISoundTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/skeletonTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { Skeleton } from "babylonjs/Bones/skeleton"; interface ISkeletonTreeItemComponentProps { skeleton: Skeleton; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class SkeletonTreeItemComponent extends React.Component { constructor(props: ISkeletonTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/sceneTreeItemComponent" { import { Nullable } from "babylonjs/types"; import { Observable } from "babylonjs/Misc/observable"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { Scene } from "babylonjs/scene"; import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Camera } from "babylonjs/Cameras/camera"; import { FrameGraph } from "babylonjs/FrameGraph/frameGraph"; interface ISceneTreeItemComponentProps { scene: Scene; gizmoCamera?: Camera; onRefresh: () => void; selectedEntity?: any; extensibilityGroups?: IExplorerExtensibilityGroup[]; onSelectionChangedObservable?: Observable; globalState: GlobalState; } export class SceneTreeItemComponent extends React.Component { private _gizmoLayerOnPointerObserver; private _gizmoLayerRenderObserver; private _onPointerObserver; private _onSelectionChangeObserver; private _selectedEntity; private _posDragEnd; private _scaleDragEnd; private _rotateDragEnd; constructor(props: ISceneTreeItemComponentProps); shouldComponentUpdate(nextProps: ISceneTreeItemComponentProps, nextState: { isSelected: boolean; isInPickingMode: boolean; }): boolean; updateGizmoAutoPicking(isInPickingMode: boolean): void; componentDidMount(): void; private _getMeshFromBone; componentWillUnmount(): void; onSelect(): void; onCoordinatesMode(): void; onPickingMode(): void; findCameraFromFrameGraph(frameGraph: FrameGraph): Nullable; setGizmoMode(mode: number): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/renderingPipelineTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { PostProcessRenderPipeline } from "babylonjs/PostProcesses/RenderPipeline/postProcessRenderPipeline"; import * as React from "react"; interface IRenderPipelineItemComponenttProps { renderPipeline: PostProcessRenderPipeline; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class RenderingPipelineItemComponent extends React.Component { constructor(props: IRenderPipelineItemComponenttProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/postProcessTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { PostProcess } from "babylonjs/PostProcesses/postProcess"; import * as React from "react"; interface IPostProcessItemComponentProps { postProcess: PostProcess; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class PostProcessItemComponent extends React.Component { constructor(props: IPostProcessItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/particleSystemTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { IParticleSystem } from "babylonjs/Particles/IParticleSystem"; interface IParticleSystemTreeItemComponentProps { system: IParticleSystem; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class ParticleSystemTreeItemComponent extends React.Component { constructor(props: IParticleSystemTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/meshTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { AbstractMesh } from "babylonjs/Meshes/abstractMesh"; import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import "babylonjs/Rendering/boundingBoxRenderer"; interface IMeshTreeItemComponentProps { mesh: AbstractMesh; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; globalState: GlobalState; } export class MeshTreeItemComponent extends React.Component { constructor(props: IMeshTreeItemComponentProps); showBoundingBox(): void; switchVisibility(): void; private _getNameForLabel; private _editGeometry; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/materialTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { Material } from "babylonjs/Materials/material"; import * as React from "react"; import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial"; interface IMaterialTreeItemComponentProps { material: Material | NodeMaterial; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class MaterialTreeItemComponent extends React.Component { constructor(props: IMaterialTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/lightTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { Light } from "babylonjs/Lights/light"; import { Camera } from "babylonjs/Cameras/camera"; import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ILightTreeItemComponentProps { light: Light; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; globalState: GlobalState; gizmoCamera?: Camera; } export class LightTreeItemComponent extends React.Component { constructor(props: ILightTreeItemComponentProps); switchIsEnabled(): void; toggleGizmo(): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/frameGraphTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { FrameGraph } from "babylonjs/FrameGraph/frameGraph"; interface IFrameGraphItemComponenttProps { frameGraph: FrameGraph; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class FrameGraphTreeItemComponent extends React.Component { constructor(props: IFrameGraphItemComponenttProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/effectLayerPipelineTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { EffectLayer } from "babylonjs/Layers/effectLayer"; interface IEffectLayerItemComponenttProps { layer: EffectLayer; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class EffectLayerItemComponent extends React.Component { constructor(props: IEffectLayerItemComponenttProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/cameraTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { Camera } from "babylonjs/Cameras/camera"; import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICameraTreeItemComponentProps { camera: Camera; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; globalState: GlobalState; gizmoCamera?: Camera; } export class CameraTreeItemComponent extends React.Component { private _onBeforeRenderObserver; constructor(props: ICameraTreeItemComponentProps); setActive(): void; componentDidMount(): void; componentWillUnmount(): void; toggleGizmo(): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/boneTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; import { Bone } from "babylonjs/Bones/bone"; interface IBoneTreeItemComponentProps { bone: Bone; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class BoneTreeItemComponent extends React.Component { constructor(props: IBoneTreeItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/animationGroupTreeItemComponent" { import { AnimationGroup } from "babylonjs/Animations/animationGroup"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import * as React from "react"; interface IAnimationGroupItemComponentProps { animationGroup: AnimationGroup; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class AnimationGroupItemComponent extends React.Component { constructor(props: IAnimationGroupItemComponentProps); } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/gui/guiTools" { import { AdvancedDynamicTexture } from "babylonjs-gui/2D/advancedDynamicTexture"; /** * Used to pass in the gui-editor package. * @param guiEditorPackage */ export function InjectGUIEditor(guiEditorPackage: any): void; /** * Change the URL that the GUI editor loads from * @param guiEditorURL */ export function SetGUIEditorURL(guiEditorURL: string): void; /** * Opens an ADT in the GUI editor * if you are in an ES6 environment, you must first call InjectGUIEditor to provide the gui-editor package * If you are in a UMD environment, it will load the package from a URL * @param adt * @param embed defines whether editor is being opened from the Playground * @returns a promise that resolves when the editor is opened */ export function EditAdvancedDynamicTexture(adt: AdvancedDynamicTexture, embed?: boolean): Promise; } declare module "babylonjs-inspector/components/sceneExplorer/entities/gui/controlTreeItemComponent" { import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { Control } from "babylonjs-gui/2D/controls/control"; import * as React from "react"; interface IControlTreeItemComponentProps { control: Control; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class ControlTreeItemComponent extends React.Component { constructor(props: IControlTreeItemComponentProps); highlight(): void; switchVisibility(): void; } export {}; } declare module "babylonjs-inspector/components/sceneExplorer/entities/gui/advancedDynamicTextureTreeItemComponent" { import { Observable } from "babylonjs/Misc/observable"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { AdvancedDynamicTexture } from "babylonjs-gui/2D/advancedDynamicTexture"; import * as React from "react"; interface IAdvancedDynamicTextureTreeItemComponentProps { texture: AdvancedDynamicTexture; extensibilityGroups?: IExplorerExtensibilityGroup[]; onSelectionChangedObservable?: Observable; onClick: () => void; } export class AdvancedDynamicTextureTreeItemComponent extends React.Component { private _onControlPickedObserver; constructor(props: IAdvancedDynamicTextureTreeItemComponentProps); componentWillUnmount(): void; onPickingMode(): void; } export {}; } declare module "babylonjs-inspector/components/graph/graphSupportingTypes" { import { IPerfDatasets } from "babylonjs/Misc/interfaces/iPerfViewer"; import { Observable } from "babylonjs/Misc/observable"; /** * Defines a structure to hold max, min and a optional current. */ export interface IPerfMinMax { min: number; max: number; current?: number; } /** * Defines structure of the object which contains information related to panning. */ export interface IPerfMousePanningPosition { xPos: number; delta: number; } /** * Defines structure of the object which contains information regarding the bounds of each dataset we want to consider. */ export interface IPerfIndexBounds { start: number; end: number; } export interface IPerfLayoutSize { width: number; height: number; } /** * Defines the structure of the meta object for the tooltip that appears when hovering over a performance graph! */ export interface IPerfTooltip { text: string; color: string; } /** * Defines the structure of a cache object used to store the result of measureText(). */ export interface IPerfTextMeasureCache { text: string; width: number; } /** * Defines a structure defining the available space in a drawable area. */ export interface IGraphDrawableArea { top: number; left: number; bottom: number; right: number; } /** * Defines the structure representing necessary ticker information. */ export interface IPerfTicker extends IPerfMinMax { id: string; text: string; } export interface IVisibleRangeChangedObservableProps { valueMap: Map; } /** * Defines what settings our canvas graphing service accepts */ export interface ICanvasGraphServiceSettings { datasets: IPerfDatasets; onVisibleRangeChangedObservable?: Observable; } /** * Defines the structure representing the preprocessable tooltip information. */ export interface ITooltipPreprocessedInformation { xForActualTimestamp: number; numberOfTooltipItems: number; longestText: string; focusedId: string; } export interface IPerfTooltipHoverPosition { xPos: number; yPos: number; } /** * Defines the supported timestamp units. */ export enum TimestampUnit { Milliseconds = 0, Seconds = 1, Minutes = 2, Hours = 3 } } declare module "babylonjs-inspector/components/graph/canvasGraphService" { import { ICanvasGraphServiceSettings, IPerfLayoutSize } from "babylonjs-inspector/components/graph/graphSupportingTypes"; import { IPerfDatasets, IPerfMetadata } from "babylonjs/Misc/interfaces/iPerfViewer"; export class CanvasGraphService { private _ctx; private _width; private _height; private _sizeOfWindow; private _ticks; private _panPosition; private _position; private _datasetBounds; private _globalTimeMinMax; private _hoverPosition; private _drawableArea; private _axisHeight; private _tooltipItems; private _tooltipTextCache; private _tickerTextCache; private _tickerItems; private _preprocessedTooltipInfo; private _numberOfTickers; private _onVisibleRangeChangedObservable?; private readonly _addonFontLineHeight; private readonly _defaultLineHeight; readonly datasets: IPerfDatasets; metadata: Map; /** * Creates an instance of CanvasGraphService. * * @param canvas a pointer to the canvas dom element we would like to write to. * @param settings settings for our service. */ constructor(canvas: HTMLCanvasElement, settings: ICanvasGraphServiceSettings); /** * This method lets the service know it should get ready to update what it is displaying. */ update: (...args: any[]) => void; /** * Update the canvas graph service with the new height and width of the canvas. * @param size The new size of the canvas. */ resize(size: IPerfLayoutSize): void; /** * Force resets the position in the data, effectively returning to the most current data. */ resetDataPosition(): void; private _prevPointById; private _prevValueById; /** * This method draws the data and sets up the appropriate scales. */ private _draw; private _drawTickers; /** * Returns the index of the closest time for the datasets. * Uses a modified binary search to get value. * * @param targetTime the time we want to get close to. * @returns index of the item with the closest time to the targetTime */ private _getClosestPointToTimestamp; /** * This is a convenience method to get the number of collected slices. * @returns the total number of collected slices. */ private _getNumberOfSlices; /** * Draws the time axis, adjusts the drawable area for the graph. * * @param timeMinMax the minimum and maximum for the time axis. * @param drawableArea the current allocated drawable area. */ private _drawTimeAxis; /** * Given a timestamp (should be the maximum timestamp in view), this function returns the maximum unit the timestamp contains. * This information can be used for formatting purposes. * @param timestamp the maximum timestamp to find the maximum timestamp unit for. * @returns The maximum unit the timestamp has. */ private _getTimestampUnit; /** * Given a timestamp and the interval unit, this function will parse the timestamp to the appropriate format. * @param timestamp The timestamp to parse * @param intervalUnit The maximum unit of the maximum timestamp in an interval. * @returns a string representing the parsed timestamp. */ private _parseTimestamp; /** * Generates a list of ticks given the min and max of the axis, and the space available in the axis. * * @param minMax the minimum and maximum values of the axis * @param spaceAvailable the total amount of space we have allocated to our axis */ private _generateTicks; /** * Nice number algorithm based on psueudo code defined in "Graphics Gems" by Andrew S. Glassner. * This will find a "nice" number approximately equal to num. * * @param num The number we want to get close to. * @param shouldRound if true we will round the number, otherwise we will get the ceiling. * @returns a "nice" number approximately equal to num. */ private _niceNumber; /** * Gets the min and max as a single object from an array of numbers. * @param bounds * @param offset * @returns the min and max of the array. */ private _getMinMax; /** * Converts a single number to a pixel coordinate in a single axis by normalizing the data to a [0, 1] scale using the minimum and maximum values. * * @param num the number we want to get the pixel coordinate for * @param minMax the min and max of the dataset in the axis we want the pixel coordinate for. * @param startingPixel the starting pixel coordinate (this means it takes account for any offset). * @param spaceAvailable the total space available in this axis. * @param shouldFlipValue if we should use a [1, 0] scale instead of a [0, 1] scale. * @returns the pixel coordinate of the value in a single axis. */ private _getPixelForNumber; /** * Add in any necessary event listeners. * * @param canvas The canvas we want to attach listeners to. */ private _attachEventListeners; /** * We remove all event listeners we added. * * @param canvas The canvas we want to remove listeners from. */ private _removeEventListeners; /** * Handles what to do when we are hovering over the canvas and not panning. * * @param event A reference to the event to be handled. */ private _handleDataHover; /** * Debounced processing and drawing of tooltip. */ private _debouncedTooltip; /** * Handles what to do when we stop hovering over the canvas. */ private _handleStopHover; /** * Given a line defined by P1: (x1, y1) and P2: (x2, y2) get the distance of P0 (x0, y0) from the line. * https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_two_points * @param x1 x position of point P1 * @param y1 y position of point P1 * @param x2 x position of point P2 * @param y2 y position of point P2 * @param x0 x position of point P0 * @param y0 y position of point P0 * @returns distance of P0 from the line defined by P1 and P2 */ private _getDistanceFromLine; /** * This method does preprocessing calculations for the tooltip. * @param pos the position of our mouse. * @param drawableArea the remaining drawable area. */ private _preprocessTooltip; /** * Draws the tooltip given the area it is allowed to draw in and the current pixel position. * * @param pos the position of the mouse cursor in pixels (x, y). * @param drawableArea the available area we can draw in. */ private _drawTooltip; /** * Gets the number from a pixel position given the minimum and maximum value in range, and the starting pixel and the ending pixel. * * @param pixel current pixel position we want to get the number for. * @param minMax the minimum and maximum number in the range. * @param startingPixel position of the starting pixel in range. * @param endingPixel position of ending pixel in range. * @param shouldFlip if we should use a [1, 0] scale instead of a [0, 1] scale. * @returns number corresponding to pixel position */ private _getNumberFromPixel; /** * The handler for when we want to zoom in and out of the graph. * * @param event a mouse wheel event. */ private _handleZoom; /** * Initializes the panning object and attaches appropriate listener. * * @param event the mouse event containing positional information. */ private _handlePanStart; /** * While panning this event will keep track of the delta and update the "positions". * * @param event The mouse event that contains positional information. */ private _handlePan; /** * Clears the panning object and removes the appropriate listener. */ private _handlePanStop; /** * Method which returns true if the data should become realtime, false otherwise. * * @returns if the data should become realtime or not. */ private _shouldBecomeRealtime; /** * Will generate a playhead with a futurebox that takes up (1-scalefactor)*100% of the canvas. * * @param drawableArea The remaining drawable area. * @param scaleFactor The Percentage between 0.0 and 1.0 of the canvas the data gets drawn on. */ private _drawPlayheadRegion; /** * Method to do cleanup when the object is done being used. * */ destroy(): void; /** * This method clears the canvas */ clear(): void; } } declare module "babylonjs-inspector/components/graph/canvasGraphComponent" { import { PerformanceViewerCollector } from "babylonjs/Misc/PerformanceViewer/performanceViewerCollector"; import { Observable } from "babylonjs/Misc/observable"; import * as React from "react"; import { IPerfLayoutSize, IVisibleRangeChangedObservableProps } from "babylonjs-inspector/components/graph/graphSupportingTypes"; import { Scene } from "babylonjs/scene"; interface ICanvasGraphComponentProps { id: string; scene: Scene; collector: PerformanceViewerCollector; layoutObservable?: Observable; returnToPlayheadObservable?: Observable; onVisibleRangeChangedObservable?: Observable; initialGraphSize?: { width: number; height: number; }; } export const CanvasGraphComponent: React.FC; export {}; } declare module "babylonjs-inspector/components/embedHost/embedHostComponent" { import * as React from "react"; import { Scene } from "babylonjs/scene"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { IExplorerExtensibilityGroup, DebugLayerTab, IExplorerAdditionalNode } from "babylonjs/Debug/debugLayer"; import "babylonjs-inspector/components/embedHost/embedHost.scss"; interface IEmbedHostComponentProps { scene: Scene; globalState: GlobalState; popupMode: boolean; noClose?: boolean; noExpand?: boolean; onClose: () => void; onPopup: () => void; extensibilityGroups?: IExplorerExtensibilityGroup[]; additionalNodes?: IExplorerAdditionalNode[]; initialTab?: DebugLayerTab; } export class EmbedHostComponent extends React.Component { private _once; private _splitRef; private _topPartRef; private _bottomPartRef; constructor(props: IEmbedHostComponentProps); componentDidMount(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabsComponent" { import * as React from "react"; import { PaneComponent } from "babylonjs-inspector/components/actionTabs/paneComponent"; interface ITabsComponentProps { children: any[]; selectedIndex: number; onSelectedIndexChange: (value: number) => void; } export class TabsComponent extends React.Component { constructor(props: ITabsComponentProps); onSelect(index: number): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/paneComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Scene } from "babylonjs/scene"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { GlobalState } from "babylonjs-inspector/components/globalState"; export interface IPaneComponentProps { title: string; icon: any; scene: Scene; selectedEntity?: any; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; globalState: GlobalState; } export class PaneComponent extends React.Component { constructor(props: IPaneComponentProps); render(): JSX.Element | null; } } declare module "babylonjs-inspector/components/actionTabs/actionTabsComponent" { import * as React from "react"; import { Scene } from "babylonjs/scene"; import { DebugLayerTab } from "babylonjs/Debug/debugLayer"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import "babylonjs-inspector/components/actionTabs/actionTabs.scss"; interface IActionTabsComponentProps { scene?: Scene; noCommands?: boolean; noHeader?: boolean; noExpand?: boolean; noClose?: boolean; popupMode?: boolean; onPopup?: () => void; onClose?: () => void; globalState?: GlobalState; initialTab?: DebugLayerTab; } export class ActionTabsComponent extends React.Component { private _onSelectionChangeObserver; private _onTabChangedObserver; private _once; constructor(props: IActionTabsComponentProps); componentDidMount(): void; componentWillUnmount(): void; changeSelectedTab(index: number): void; onClose(): void; onPopup(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/toolsTabComponent" { import { IPaneComponentProps } from "babylonjs-inspector/components/actionTabs/paneComponent"; import { PaneComponent } from "babylonjs-inspector/components/actionTabs/paneComponent"; export class ToolsTabComponent extends PaneComponent { private _lockObject; private _videoRecorder; private _screenShotSize; private _gifOptions; private _useWidthHeight; private _isExportingGltf; private _gltfExportOptions; private _gifWorkerBlob; private _gifRecorder; private _previousRenderingScale; private _crunchingGIF; private _reflectorHostname; private _reflectorPort; private _reflector; private _envOptions; constructor(props: IPaneComponentProps); componentDidMount(): void; componentWillUnmount(): void; captureScreenshot(): void; captureEquirectangular(): void; captureRender(): void; recordVideo(): void; recordGIFInternal(): void; recordGIF(): void; importAnimations(event: any): void; exportGLTF(): void; exportBabylon(): void; createEnvTexture(): void; exportReplay(): void; startRecording(): void; applyDelta(file: File): void; connectReflector(): void; } } declare module "babylonjs-inspector/components/actionTabs/tabs/statisticsTabComponent" { import { IPaneComponentProps } from "babylonjs-inspector/components/actionTabs/paneComponent"; import { PaneComponent } from "babylonjs-inspector/components/actionTabs/paneComponent"; export class StatisticsTabComponent extends PaneComponent { private _sceneInstrumentation; private _engineInstrumentation; private _timerIntervalId; constructor(props: IPaneComponentProps); componentWillUnmount(): void; } } declare module "babylonjs-inspector/components/actionTabs/tabs/settingsTabComponent" { import { IPaneComponentProps } from "babylonjs-inspector/components/actionTabs/paneComponent"; import { PaneComponent } from "babylonjs-inspector/components/actionTabs/paneComponent"; export class SettingsTabComponent extends PaneComponent { constructor(props: IPaneComponentProps); } } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGridTabComponent" { import { IPaneComponentProps } from "babylonjs-inspector/components/actionTabs/paneComponent"; import { PaneComponent } from "babylonjs-inspector/components/actionTabs/paneComponent"; export class PropertyGridTabComponent extends PaneComponent { private _timerIntervalId; private _lockObject; constructor(props: IPaneComponentProps); timerRefresh(): void; componentDidMount(): void; componentWillUnmount(): void; } } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyComponentProps" { import { GlobalState } from "babylonjs-inspector/components/globalState"; import { NodeMaterialBlock } from "babylonjs/Materials/Node/nodeMaterialBlock"; export interface IPropertyComponentProps { globalState: GlobalState; block: NodeMaterialBlock; } } declare module "babylonjs-inspector/components/actionTabs/tabs/gradientStepComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { GradientBlockColorStep } from "babylonjs/Materials/Node/Blocks/gradientBlock"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IGradientStepComponentProps { globalState: GlobalState; step: GradientBlockColorStep; lineIndex: number; lockObject?: LockObject; onDelete: () => void; onUpdateStep: () => void; onCheckForReOrder: () => void; onCopy?: () => void; } export class GradientStepComponent extends React.Component { constructor(props: IGradientStepComponentProps); updateColor(color: string): void; updateStep(gradient: number): void; onPointerUp(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/gradientNodePropertyComponent" { import * as React from "react"; import { GradientBlockColorStep } from "babylonjs/Materials/Node/Blocks/gradientBlock"; import { IPropertyComponentProps } from "babylonjs-inspector/components/actionTabs/tabs/propertyComponentProps"; export class GradientPropertyTabComponent extends React.Component { private _gradientBlock; constructor(props: IPropertyComponentProps); forceRebuild(): void; deleteStep(step: GradientBlockColorStep): void; copyStep(step: GradientBlockColorStep): void; addNewStep(): void; checkForReOrder(): void; } } declare module "babylonjs-inspector/components/actionTabs/tabs/debugTabComponent" { import { IPaneComponentProps } from "babylonjs-inspector/components/actionTabs/paneComponent"; import { PaneComponent } from "babylonjs-inspector/components/actionTabs/paneComponent"; import "babylonjs/Physics/physicsEngineComponent"; import "babylonjs/Physics/v1/physicsEngineComponent"; import "babylonjs/Physics/v2/physicsEngineComponent"; export class DebugTabComponent extends PaneComponent { private _physicsViewersEnabled; private _namesViewerEnabled; constructor(props: IPaneComponentProps); switchPhysicsViewers(): void; switchNameViewerAsync(): Promise; } } declare module "babylonjs-inspector/components/actionTabs/tabs/tools/gltfComponent" { import * as React from "react"; import { Scene } from "babylonjs/scene"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IGLTFComponentProps { scene: Scene; globalState: GlobalState; lockObject: LockObject; } interface IGLTFComponentState { showGLTFLoaderOptions: boolean; showGLTFExtensionOptions: boolean; } export class GLTFComponent extends React.Component { private _onValidationResultsUpdatedObserver; constructor(props: IGLTFComponentProps); openValidationDetails(): void; prepareText(singularForm: string, count: number): string; componentDidMount(): void; componentWillUnmount(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/variantsPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IVariantsPropertyGridComponentProps { globalState: GlobalState; host: any; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class VariantsPropertyGridComponent extends React.Component { constructor(props: IVariantsPropertyGridComponentProps); private _getVariantsExtension; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/scenePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Vector3 } from "babylonjs/Maths/math.vector"; import { Scene } from "babylonjs/scene"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import "babylonjs/Physics/physicsEngineComponent"; import "babylonjs/Physics/v1/physicsEngineComponent"; import "babylonjs/Physics/v1/physicsEngineComponent"; interface IScenePropertyGridComponentProps { globalState: GlobalState; scene: Scene; lockObject: LockObject; onPropertyChangedObservable?: Observable; onSelectionChangedObservable?: Observable; } export class ScenePropertyGridComponent extends React.Component { private _storedEnvironmentTexture; private _renderingModeGroupObservable; constructor(props: IScenePropertyGridComponentProps); setRenderingModes(point: boolean, wireframe: boolean): void; switchIBL(): void; updateEnvironmentTexture(file: File): void; updateGravity(newValue: Vector3): void; updateTimeStep(newValue: number): void; normalizeScene(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/renderGridPropertyGridComponent" { import * as React from "react"; import { Scene } from "babylonjs/scene"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IRenderGridPropertyGridComponentProps { globalState: GlobalState; scene: Scene; } export class RenderGridPropertyGridComponent extends React.Component { private _gridMesh; constructor(props: IRenderGridPropertyGridComponentProps); componentDidMount(): void; addOrRemoveGrid(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/parentPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Node } from "babylonjs/node"; interface IParentPropertyGridComponentProps { globalState: GlobalState; lockObject: LockObject; node: Node; onPropertyChangedObservable?: Observable; } export class ParentPropertyGridComponent extends React.Component { constructor(props: IParentPropertyGridComponentProps); private _getNameForSortingAndDisplay; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/fogPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Scene } from "babylonjs/scene"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IFogPropertyGridComponentProps { globalState: GlobalState; scene: Scene; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class FogPropertyGridComponent extends React.Component { constructor(props: IFogPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/emptyPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IEmptyPropertyGridComponentProps { globalState: GlobalState; item: { inspectableCustomProperties: any; }; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class EmptyPropertyGridComponent extends React.Component { constructor(props: IEmptyPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/customPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { IInspectable } from "babylonjs/Misc/iInspectable"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface ICustomPropertyGridComponentProps { globalState: GlobalState; target: any; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CustomPropertyGridComponent extends React.Component { constructor(props: ICustomPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/commonPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICommonPropertyGridComponentProps { globalState: GlobalState; host: { metadata: any; }; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonPropertyGridComponent extends React.Component { constructor(props: ICommonPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/sprites/spritePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Sprite } from "babylonjs/Sprites/sprite"; interface ISpritePropertyGridComponentProps { globalState: GlobalState; sprite: Sprite; lockObject: LockObject; onPropertyChangedObservable?: Observable; onSelectionChangedObservable?: Observable; } export class SpritePropertyGridComponent extends React.Component { private _canvasRef; private _imageData; private _cachedCellIndex; constructor(props: ISpritePropertyGridComponentProps); onManagerLink(): void; switchPlayStopState(): void; disposeSprite(): void; componentDidMount(): void; componentDidUpdate(): void; shouldComponentUpdate(nextProps: ISpritePropertyGridComponentProps): boolean; updatePreview(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/sprites/spriteManagerPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { SpriteManager } from "babylonjs/Sprites/spriteManager"; interface ISpriteManagerPropertyGridComponentProps { globalState: GlobalState; spriteManager: SpriteManager; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class SpriteManagerPropertyGridComponent extends React.Component { private _snippetUrl; constructor(props: ISpriteManagerPropertyGridComponentProps); addNewSprite(): void; disposeManager(): void; saveToFile(): void; loadFromFile(file: File): void; loadFromSnippet(): void; saveToSnippet(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/sounds/soundPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Sound } from "babylonjs/Audio/sound"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; interface ISoundPropertyGridComponentProps { globalState: GlobalState; sound: Sound; extensibilityGroups?: IExplorerExtensibilityGroup[]; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class SoundPropertyGridComponent extends React.Component { constructor(props: ISoundPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/ssrRenderingPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { SSRRenderingPipeline } from "babylonjs/PostProcesses/RenderPipeline/Pipelines/ssrRenderingPipeline"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ISSRRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: SSRRenderingPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class SSRRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ISSRRenderingPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/ssaoRenderingPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { SSAORenderingPipeline } from "babylonjs/PostProcesses/RenderPipeline/Pipelines/ssaoRenderingPipeline"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ISSAORenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: SSAORenderingPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class SSAORenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ISSAORenderingPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/ssao2RenderingPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { SSAO2RenderingPipeline } from "babylonjs/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ISSAO2RenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: SSAO2RenderingPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class SSAO2RenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ISSAO2RenderingPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/renderingPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PostProcessRenderPipeline } from "babylonjs/PostProcesses/RenderPipeline/postProcessRenderPipeline"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: PostProcessRenderPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class RenderingPipelinePropertyGridComponent extends React.Component { constructor(props: IRenderingPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/postProcessPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PostProcess } from "babylonjs/PostProcesses/postProcess"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IPostProcessPropertyGridComponentProps { globalState: GlobalState; postProcess: PostProcess; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class PostProcessPropertyGridComponent extends React.Component { constructor(props: IPostProcessPropertyGridComponentProps); edit(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/lensRenderingPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { LensRenderingPipeline } from "babylonjs/PostProcesses/RenderPipeline/Pipelines/lensRenderingPipeline"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ILenstRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: LensRenderingPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class LensRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ILenstRenderingPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/iblShadowsRenderPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { IblShadowsRenderPipeline } from "babylonjs/Rendering/IBLShadows/iblShadowsRenderPipeline"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IIblShadowsRenderPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: IblShadowsRenderPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class IblShadowsRenderPipelinePropertyGridComponent extends React.Component { constructor(props: IIblShadowsRenderPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/defaultRenderingPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { DefaultRenderingPipeline } from "babylonjs/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IDefaultRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: DefaultRenderingPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class DefaultRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: IDefaultRenderingPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/commonRenderingPipelinePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { PostProcessRenderPipeline } from "babylonjs/PostProcesses/RenderPipeline/postProcessRenderPipeline"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICommonRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: PostProcessRenderPipeline; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ICommonRenderingPipelinePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/postProcesses/commonPostProcessPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { PostProcess } from "babylonjs/PostProcesses/postProcess"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICommonPostProcessPropertyGridComponentProps { globalState: GlobalState; postProcess: PostProcess; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonPostProcessPropertyGridComponent extends React.Component { constructor(props: ICommonPostProcessPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/valueGradientGridComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { IValueGradient } from "babylonjs/Misc/gradients"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Nullable } from "babylonjs/types"; import { IParticleSystem } from "babylonjs/Particles/IParticleSystem"; export enum GradientGridMode { Factor = 0, Color3 = 1, Color4 = 2 } interface IValueGradientGridComponent { globalState: GlobalState; label: string; gradients: Nullable>; lockObject: LockObject; docLink?: string; mode: GradientGridMode; host: IParticleSystem; codeRecorderPropertyName: string; onCreateRequired: () => void; onRemoveRequired: (step: IValueGradient) => void; } export class ValueGradientGridComponent extends React.Component { constructor(props: IValueGradientGridComponent); deleteStep(step: IValueGradient): void; addNewStep(): void; checkForReOrder(): void; updateAndSync(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/sphereEmitterGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { SphereParticleEmitter } from "babylonjs/Particles/EmitterTypes/sphereParticleEmitter"; interface ISphereEmitterGridComponentProps { globalState: GlobalState; emitter: SphereParticleEmitter; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class SphereEmitterGridComponent extends React.Component { constructor(props: ISphereEmitterGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/pointEmitterGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { PointParticleEmitter } from "babylonjs/Particles/EmitterTypes/pointParticleEmitter"; interface IPointEmitterGridComponentProps { globalState: GlobalState; emitter: PointParticleEmitter; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class PointEmitterGridComponent extends React.Component { constructor(props: IPointEmitterGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/particleSystemPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { IParticleSystem } from "babylonjs/Particles/IParticleSystem"; interface IParticleSystemPropertyGridComponentProps { globalState: GlobalState; system: IParticleSystem; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class ParticleSystemPropertyGridComponent extends React.Component { private _snippetUrl; constructor(props: IParticleSystemPropertyGridComponentProps); raiseOnPropertyChanged(property: string, newValue: any, previousValue: any): void; saveToFile(): void; loadFromFile(file: File): void; loadFromSnippet(): void; saveToSnippet(): void; updateTexture(file: File): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/meshEmitterGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { MeshParticleEmitter } from "babylonjs/Particles/EmitterTypes/meshParticleEmitter"; import { Scene } from "babylonjs/scene"; interface IMeshEmitterGridComponentProps { globalState: GlobalState; emitter: MeshParticleEmitter; scene: Scene; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class MeshEmitterGridComponent extends React.Component { constructor(props: IMeshEmitterGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/hemisphericEmitterGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { HemisphericParticleEmitter } from "babylonjs/Particles/EmitterTypes/hemisphericParticleEmitter"; interface IHemisphericEmitterGridComponentProps { globalState: GlobalState; emitter: HemisphericParticleEmitter; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class HemisphericEmitterGridComponent extends React.Component { constructor(props: IHemisphericEmitterGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/factorGradientStepGridComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { FactorGradient } from "babylonjs/Misc/gradients"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { IParticleSystem } from "babylonjs/Particles/IParticleSystem"; interface IFactorGradientStepGridComponent { globalState: GlobalState; gradient: FactorGradient; lockObject: LockObject; lineIndex: number; onDelete: () => void; onUpdateGradient: () => void; onCheckForReOrder: () => void; host: IParticleSystem; codeRecorderPropertyName: string; } export class FactorGradientStepGridComponent extends React.Component { constructor(props: IFactorGradientStepGridComponent); shouldComponentUpdate(nextProps: IFactorGradientStepGridComponent, nextState: { gradient: number; factor1: string; factor2?: string; }): boolean; updateFactor1(valueString: string): void; updateFactor2(valueString: string): void; updateGradient(gradient: number): void; onPointerUp(): void; lock(): void; unlock(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/cylinderEmitterGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { CylinderParticleEmitter } from "babylonjs/Particles/EmitterTypes/cylinderParticleEmitter"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface ICylinderEmitterGridComponentProps { globalState: GlobalState; emitter: CylinderParticleEmitter; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CylinderEmitterGridComponent extends React.Component { constructor(props: ICylinderEmitterGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/coneEmitterGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { ConeParticleEmitter } from "babylonjs/Particles/EmitterTypes/coneParticleEmitter"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IConeEmitterGridComponentProps { globalState: GlobalState; emitter: ConeParticleEmitter; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class ConeEmitterGridComponent extends React.Component { constructor(props: IConeEmitterGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/colorGradientStepGridComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { ColorGradient, Color3Gradient } from "babylonjs/Misc/gradients"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { IParticleSystem } from "babylonjs/Particles/IParticleSystem"; interface IColorGradientStepGridComponent { globalState: GlobalState; gradient: ColorGradient | Color3Gradient; lockObject: LockObject; lineIndex: number; isColor3: boolean; onDelete: () => void; onUpdateGradient: () => void; onCheckForReOrder: () => void; host: IParticleSystem; codeRecorderPropertyName: string; } export class ColorGradientStepGridComponent extends React.Component { constructor(props: IColorGradientStepGridComponent); updateColor1(color: string): void; updateColor2(color: string): void; updateGradient(gradient: number): void; onPointerUp(): void; lock(): void; unlock(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/boxEmitterGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { BoxParticleEmitter } from "babylonjs/Particles/EmitterTypes/boxParticleEmitter"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IBoxEmitterGridComponentProps { globalState: GlobalState; emitter: BoxParticleEmitter; onPropertyChangedObservable?: Observable; lockObject: LockObject; } export class BoxEmitterGridComponent extends React.Component { constructor(props: IBoxEmitterGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/attractorsGridComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { ParticleSystem } from "babylonjs/Particles/particleSystem"; import { Attractor } from "babylonjs/Particles/attractor"; import { Color3 } from "babylonjs/Maths/math.color"; interface IAttractorsGridComponent { globalState: GlobalState; lockObject: LockObject; docLink?: string; host: ParticleSystem; } export class AttractorsGridComponent extends React.Component { private _impostorMaterial; private _gizmoManager; private _sceneOnAfterRenderObserver; private _fontAsset; constructor(props: IAttractorsGridComponent); addNewAttractor(): void; updateImpostorScale(value: number): void; removeImpostor(attractor: Attractor): void; addImpostor(attractor: Attractor, index: number): void; addLabelAsync(attractor: Attractor, index: number): Promise; controlImpostor(attractor: Attractor, index: number): void; shouldComponentUpdate(nextProps: Readonly, nextState: Readonly<{ impostorScale: number; color: Color3; }>, nextContext: any): boolean; componentWillUnmount(): void; cleanup(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/particleSystems/attractorGridComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { IParticleSystem } from "babylonjs/Particles/IParticleSystem"; import { Attractor } from "babylonjs/Particles/attractor"; interface IAttractorGridComponent { globalState: GlobalState; attractor: Attractor; lockObject: LockObject; lineIndex: number; host: IParticleSystem; codeRecorderPropertyName: string; onDelete: (attractor: Attractor) => void; removeImpostor: (attractor: Attractor) => void; addImpostor: (attractor: Attractor, index: number) => void; onControl: (attractor: Attractor, index: number) => void; isControlled: (attractor: Attractor) => boolean; } export class AttractorGridComponent extends React.Component { constructor(props: IAttractorGridComponent); lock(): void; unlock(): void; updateStrength(strength: number): void; onView(): void; onControl(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/metadata/metadataPropertyGridComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/metadata/metadataPropertyGrid.scss"; interface IMetadataComponentProps { globalState: GlobalState; entity: any; } enum MetadataTypes { UNDEFINED = "undefined", NULL = "null", STRING = "string", OBJECT = "Object", JSON = "JSON" } /** Metadata Grid Component */ export class MetadataGridComponent extends React.Component { private readonly _textAreaHost; /** * @param props - component props */ constructor(props: IMetadataComponentProps); /** @ignorenaming */ componentDidMount(): void; /** * @param prevProps - previous component props */ componentDidUpdate(prevProps: Readonly): void; /** on entity refresh */ refreshSelected(): void; /** * @param disabled - is disabled */ setTextAreaDisabled(disabled: boolean): void; /** * @returns class name */ getClassName(): string; /** * Determines the Metadata type * @param entity Picked entity * @returns MetadataTypes */ getEntityType(entity: any): MetadataTypes; /** * @param input - any input * @returns is string */ isString(input: any): boolean; /** * @param object - any object * @returns is parsable */ parsableJson(object: object): boolean; /** * @param string - any string * @returns parsable string */ parsableString(string: string): JSON | null; /** * @param validJson - a valid json * @param metadata - any metadata * @returns parsed metadata */ parseMetaObject(validJson: boolean, metadata: any): any; /** * Recurse through an object to check for any Functions, returns False if found at least one * @param o Any Object, String or number * @returns Boolean */ objectCanSafelyStringify(o: object | string | number | boolean): boolean; copyToClipboard(): void; /** Safely checks if valid JSON then appends necessary props without overwriting existing */ populateGltfExtras(): void; /** render * @returns the component */ } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/meshes/transformNodePropertyGridComponent" { import * as React from "react"; import { TransformNode } from "babylonjs/Meshes/transformNode"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ITransformNodePropertyGridComponentProps { globalState: GlobalState; transformNode: TransformNode; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class TransformNodePropertyGridComponent extends React.Component { constructor(props: ITransformNodePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/meshes/skeletonPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Skeleton } from "babylonjs/Bones/skeleton"; interface ISkeletonPropertyGridComponentProps { globalState: GlobalState; skeleton: Skeleton; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class SkeletonPropertyGridComponent extends React.Component { private _skeletonViewersEnabled; private _skeletonViewerDisplayOptions; private _skeletonViewers; constructor(props: ISkeletonPropertyGridComponentProps); switchSkeletonViewers(): void; checkSkeletonViewerState(props: ISkeletonPropertyGridComponentProps): void; changeDisplayMode(): void; changeDisplayOptions(option: string, value: number): void; shouldComponentUpdate(nextProps: ISkeletonPropertyGridComponentProps): boolean; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/meshes/meshPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Mesh } from "babylonjs/Meshes/mesh"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import "babylonjs/Physics/physicsEngineComponent"; import "babylonjs/Physics/v1/physicsEngineComponent"; interface IMeshPropertyGridComponentProps { globalState: GlobalState; mesh: Mesh; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class MeshPropertyGridComponent extends React.Component { constructor(props: IMeshPropertyGridComponentProps); renderWireframeOver(): void; renderNormalVectors(): void; displayNormals(): void; displayVertexColors(): void; displayBoneWeights(): void; displaySkeletonMap(): void; onBoneDisplayIndexChange(value: number): void; onMaterialLink(): void; onSourceMeshLink(): void; onSkeletonLink(): void; convertPhysicsTypeToString(): string; private _getIdForDisplay; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/meshes/bonePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Bone } from "babylonjs/Bones/bone"; interface IBonePropertyGridComponentProps { globalState: GlobalState; bone: Bone; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class BonePropertyGridComponent extends React.Component { constructor(props: IBonePropertyGridComponentProps); onTransformNodeLink(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/meshes/physics/physicsMaterialGridComponent" { import { Observable } from "babylonjs/Misc/observable"; import { PhysicsBody } from "babylonjs/Physics/v2/physicsBody"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; /** * Properties of the physics material grid component. */ export interface IPhysicsMaterialGridComponentProps { /** * Lock object */ lockObject: LockObject; /** * Callback raised on the property changed event */ onPropertyChangedObservable?: Observable; /** * Physics body to edit */ body: PhysicsBody; /** * Global state */ globalState: GlobalState; } /** * Component that displays the physic material properties of a physics body. * @param props the component props * @returns the component */ } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/meshes/physics/physicsMassPropertiesGridComponent" { import { Observable } from "babylonjs/Misc/observable"; import { PhysicsBody } from "babylonjs/Physics/v2/physicsBody"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; /** * Properties of the physics mass properties grid component. */ export interface IPhysicsMassPropertiesGridComponentProps { /** * Lock object */ lockObject: LockObject; /** * Callback raised on the property changed event */ onPropertyChangedObservable?: Observable; /** * Physics body to edit */ body: PhysicsBody; /** * Global state */ globalState: GlobalState; /** * Index of the instance to edit */ instanceIndex?: number; } /** * Component that displays the mass properties of a physics body. * @param props the component props * @returns the component */ } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/meshes/physics/physicsBodyGridComponent" { import { Observable } from "babylonjs/Misc/observable"; import { PhysicsBody } from "babylonjs/Physics/v2/physicsBody"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; /** * Properties of the physics body grid component. */ export interface IPhysicsBodyGridComponentProps { /** * Lock object */ lockObject: LockObject; /** * Callback raised on the property changed event */ onPropertyChangedObservable?: Observable; /** * Physics body to edit */ body: PhysicsBody; /** * Global state */ globalState: GlobalState; } /** * Component that allows displaying and tweaking a physics body's properties. * @param props the component props * @returns the component */ } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/texturePropertyGridComponent" { import * as React from "react"; import { Nullable } from "babylonjs/types"; import { Observable } from "babylonjs/Misc/observable"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ITexturePropertyGridComponentProps { texture: BaseTexture; lockObject: LockObject; globalState: GlobalState; onPropertyChangedObservable?: Observable; } interface ITexturePropertyGridComponentState { isTextureEditorOpen: boolean; textureEditing: Nullable; } export class TexturePropertyGridComponent extends React.Component { private _adtInstrumentation; private _popoutWindowRef; private _textureLineRef; private _textureInspectorSize; constructor(props: ITexturePropertyGridComponentProps); componentWillUnmount(): void; updateTexture(file: File): void; openTextureEditor(): void; onOpenTextureEditor(): void; onCloseTextureEditor(callback?: { (): void; }): void; forceRefresh(): void; findTextureFormat(format: number): { label: string; normalizable: number; value: number; hideType?: undefined; compressed?: undefined; } | { label: string; normalizable: number; hideType: boolean; value: number; compressed?: undefined; } | { label: string; normalizable: number; compressed: boolean; value: number; hideType?: undefined; } | null; findTextureType(type: number): { label: string; normalizable: number; value: number; } | null; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/standardMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { StandardMaterial } from "babylonjs/Materials/standardMaterial"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import "babylonjs/Materials/material.decalMap"; interface IStandardMaterialPropertyGridComponentProps { globalState: GlobalState; material: StandardMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class StandardMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IStandardMaterialPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/skyMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { SkyMaterial } from "babylonjs-materials/sky/skyMaterial"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ISkyMaterialPropertyGridComponentProps { globalState: GlobalState; material: SkyMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } /** * Property grid component for the SkyMaterial */ export class SkyMaterialPropertyGridComponent extends React.Component { constructor(props: ISkyMaterialPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/pbrSpecularGlossinessMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PBRSpecularGlossinessMaterial } from "babylonjs/Materials/PBR/pbrSpecularGlossinessMaterial"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IPBRSpecularGlossinessMaterialPropertyGridComponentProps { globalState: GlobalState; material: PBRSpecularGlossinessMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class PBRSpecularGlossinessMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IPBRSpecularGlossinessMaterialPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/pbrMetallicRoughnessMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PBRMetallicRoughnessMaterial } from "babylonjs/Materials/PBR/pbrMetallicRoughnessMaterial"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IPBRMetallicRoughnessMaterialPropertyGridComponentProps { globalState: GlobalState; material: PBRMetallicRoughnessMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class PBRMetallicRoughnessMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IPBRMetallicRoughnessMaterialPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/pbrMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PBRMaterial } from "babylonjs/Materials/PBR/pbrMaterial"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { TextureLinkLineComponent } from "babylonjs-inspector/components/actionTabs/lines/textureLinkLineComponent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import "babylonjs/Materials/material.decalMap"; import "babylonjs/Rendering/prePassRendererSceneComponent"; import "babylonjs/Rendering/subSurfaceSceneComponent"; interface IPBRMaterialPropertyGridComponentProps { globalState: GlobalState; material: PBRMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } /** * @internal */ export class PBRMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IPBRMaterialPropertyGridComponentProps); switchAmbientMode(state: boolean): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/nodeMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { InputBlock } from "babylonjs/Materials/Node/Blocks/Input/inputBlock"; interface INodeMaterialPropertyGridComponentProps { globalState: GlobalState; material: NodeMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class NodeMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: INodeMaterialPropertyGridComponentProps); edit(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/multiMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Material } from "babylonjs/Materials/material"; import { MultiMaterial } from "babylonjs/Materials/multiMaterial"; interface IMultiMaterialPropertyGridComponentProps { globalState: GlobalState; material: MultiMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class MultiMaterialPropertyGridComponent extends React.Component { constructor(props: IMultiMaterialPropertyGridComponentProps); onMaterialLink(mat: Material): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/materialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Material } from "babylonjs/Materials/material"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IMaterialPropertyGridComponentProps { globalState: GlobalState; material: Material; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class MaterialPropertyGridComponent extends React.Component { constructor(props: IMaterialPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/commonMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Material } from "babylonjs/Materials/material"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICommonMaterialPropertyGridComponentProps { globalState: GlobalState; material: Material; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonMaterialPropertyGridComponent extends React.Component { constructor(props: ICommonMaterialPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/backgroundMaterialPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { BackgroundMaterial } from "babylonjs/Materials/Background/backgroundMaterial"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IBackgroundMaterialPropertyGridComponentProps { globalState: GlobalState; material: BackgroundMaterial; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class BackgroundMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IBackgroundMaterialPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/toolSettings" { import * as React from "react"; import { ITool } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/toolBar"; interface IToolSettingsProps { tool: ITool | undefined; } export class ToolSettings extends React.Component { } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/toolBar" { import * as React from "react"; import { IToolData, IToolType, IMetadata } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent"; import { Color4 } from "babylonjs/Maths/math.color"; export interface ITool extends IToolData { instance: IToolType; } interface IToolBarProps { tools: ITool[]; addTool(url: string): void; changeTool(toolIndex: number): void; activeToolIndex: number; metadata: IMetadata; setMetadata(data: any): void; pickerOpen: boolean; setPickerOpen(open: boolean): void; pickerRef: React.RefObject; hasAlpha: boolean; } interface IToolBarState { toolURL: string; addOpen: boolean; } export class ToolBar extends React.Component { private _lockObject; constructor(props: IToolBarProps); computeRGBAColor(): Color4; shouldComponentUpdate(nextProps: IToolBarProps): boolean; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent" { import * as React from "react"; import { IPixelData } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureCanvasManager"; import { ITool } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/toolBar"; import { IChannel } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/channelsBar"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { Scene } from "babylonjs/scene"; import { ISize } from "babylonjs/Maths/math.size"; import { Vector2 } from "babylonjs/Maths/math.vector"; import { PointerInfo } from "babylonjs/Events/pointerEvents"; import { PopupComponent } from "babylonjs-inspector/components/popupComponent"; import "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditor.scss"; interface ITextureEditorComponentProps { texture: BaseTexture; url: string; window: React.RefObject; onUpdate: () => void; } interface ITextureEditorComponentState { tools: ITool[]; activeToolIndex: number; metadata: IMetadata; channels: IChannel[]; pixelData: IPixelData; face: number; mipLevel: number; pickerOpen: boolean; } export interface IToolParameters { /** The visible scene in the editor. Useful for adding pointer and keyboard events. */ scene: Scene; /** The 2D canvas which you can sample pixel data from. Tools should not paint directly on this canvas. */ canvas2D: HTMLCanvasElement; /** The 3D scene which tools can add post processes to. */ scene3D: Scene; /** The size of the texture. */ size: ISize; /** Pushes the editor texture back to the original scene. This should be called every time a tool makes any modification to a texture. */ updateTexture: () => void; /** The metadata object which is shared between all tools. Feel free to store any information here. Do not set this directly: instead call setMetadata. */ metadata: IMetadata; /** Call this when you want to mutate the metadata. */ setMetadata: (data: any) => void; /** Returns the texture coordinates under the cursor */ getMouseCoordinates: (pointerInfo: PointerInfo) => Vector2; /** Provides a canvas that you can use the canvas API to paint on. */ startPainting: () => Promise; /** After you have painted on your canvas, call this method to push the updates back to the texture. */ updatePainting: () => void; /** Call this when you are finished painting. */ stopPainting: () => void; /** Returns whether the tool should be allowed to interact */ interactionEnabled: () => boolean; } export interface IToolGUIProps { instance: IToolType; } /** An interface representing the definition of a tool */ export interface IToolData { /** Name to display on the toolbar */ name: string; /** A class definition for the tool including setup and cleanup methods */ type: IToolConstructable; /** An SVG icon encoded in Base64 */ icon: string; /** Whether the tool uses postprocesses */ is3D?: boolean; cursor?: string; settingsComponent?: React.ComponentType; } export interface IToolType { /** Called when the tool is selected. */ setup: () => void; /** Called when the tool is deselected. */ cleanup: () => void; /** Optional. Called when the user resets the texture or uploads a new texture. Tools may want to reset their state when this happens. */ onReset?: () => void; } /** For constructable types, TS requires that you define a separate interface which constructs your actual interface */ interface IToolConstructable { new (getParameters: () => IToolParameters): IToolType; } export interface IMetadata { color: string; alpha: number; select: { x1: number; y1: number; x2: number; y2: number; }; [key: string]: any; } export class TextureEditorComponent extends React.Component { private _textureCanvasManager; private _uiCanvas; private _2DCanvas; private _3DCanvas; private _pickerRef; private _timer; private static _PREVIEW_UPDATE_DELAY_MS; constructor(props: ITextureEditorComponentProps); componentDidMount(): void; componentDidUpdate(): void; componentWillUnmount(): void; textureDidUpdate(): void; loadToolFromURL(url: string): void; addTools(tools: IToolData[]): void; getToolParameters(): IToolParameters; changeTool(index: number): void; setMetadata(newMetadata: any): void; setPickerOpen(open: boolean): void; onPointerDown(evt: React.PointerEvent): void; saveTexture(): void; resetTexture(): void; resizeTexture(width: number, height: number): void; uploadTexture(file: File): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureCanvasManager" { import { Scene } from "babylonjs/scene"; import { Vector2 } from "babylonjs/Maths/math.vector"; import { Nullable } from "babylonjs/types"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { ISize } from "babylonjs/Maths/math.size"; import { PointerInfo } from "babylonjs/Events/pointerEvents"; import { ITool } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/toolBar"; import { IChannel } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/channelsBar"; import { IMetadata } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent"; export interface IPixelData { x?: number; y?: number; r?: number; g?: number; b?: number; a?: number; } export class TextureCanvasManager { private _engine; private _scene; private _camera; private _cameraPos; private _scale; private _isPanning; private _mouseX; private _mouseY; private _uiCanvas; private _size; /** The canvas we paint onto using the canvas API */ private _2DCanvas; /** The canvas we apply post processes to */ private _3DCanvas; /** The canvas which handles channel filtering */ private _channelsTexture; private _3DEngine; private _3DPlane; private _3DCanvasTexture; private _3DScene; private _channels; private _face; private _mipLevel; /** The texture from the original engine that we invoked the editor on */ private _originalTexture; /** This is a hidden texture which is only responsible for holding the actual texture memory in the original engine */ private _target; private _originalTextureProperties; /** Keeps track of whether we have modified the texture */ private _didEdit; private _plane; private _planeMaterial; /** Tracks which keys are currently pressed */ private _keyMap; /** Tracks which mouse buttons are currently pressed */ private _buttonsPressed; private readonly ZOOM_MOUSE_SPEED; private readonly ZOOM_KEYBOARD_SPEED; private readonly ZOOM_IN_KEY; private readonly ZOOM_OUT_KEY; private readonly PAN_SPEED; private readonly PAN_KEY; private readonly MIN_SCALE; private readonly GRID_SCALE; private readonly MAX_SCALE; private readonly SELECT_ALL_KEY; private readonly SAVE_KEY; private readonly RESET_KEY; private readonly DESELECT_KEY; /** The number of milliseconds between texture updates */ private readonly PUSH_FREQUENCY; private _tool; private _setPixelData; private _setMipLevel; private _window; private _metadata; private _editing3D; private _onUpdate; private _setMetadata; private _imageData; private _canPush; private _shouldPush; private _paintCanvas; constructor(texture: BaseTexture, window: Window, canvasUI: HTMLCanvasElement, canvas2D: HTMLCanvasElement, canvas3D: HTMLCanvasElement, setPixelData: (pixelData: IPixelData) => void, metadata: IMetadata, onUpdate: () => void, setMetadata: (metadata: any) => void, setMipLevel: (level: number) => void); updateTexture(): Promise; private pushTexture; startPainting(): Promise; updatePainting(): void; stopPainting(): void; private updateDisplay; set channels(channels: IChannel[]); paintPixelsOnCanvas(pixelData: Uint8Array, canvas: HTMLCanvasElement): void; grabOriginalTexture(): Promise>; getMouseCoordinates(pointerInfo: PointerInfo): Vector2; get scene(): Scene; get canvas2D(): HTMLCanvasElement; get size(): ISize; set tool(tool: Nullable); get tool(): Nullable; set face(face: number); set mipLevel(mipLevel: number); /** Returns the 3D scene used for postprocesses */ get scene3D(): Scene; set metadata(metadata: IMetadata); private makePlane; reset(): void; resize(newSize: ISize): Promise; setSize(size: ISize): void; upload(file: File): void; saveTexture(): void; toolInteractionEnabled(): boolean; dispose(): void; } } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureCanvasComponent" { import * as React from "react"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; interface ITextureCanvasComponentProps { canvasUI: React.RefObject; canvas2D: React.RefObject; canvas3D: React.RefObject; texture: BaseTexture; } export class TextureCanvasComponent extends React.Component { } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/propertiesBar" { import * as React from "react"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { IPixelData } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureCanvasManager"; import { ISize } from "babylonjs/Maths/math.size"; interface IPropertiesBarProps { texture: BaseTexture; size: ISize; saveTexture(): void; pixelData: IPixelData; face: number; setFace(face: number): void; resetTexture(): void; resizeTexture(width: number, height: number): void; uploadTexture(file: File): void; mipLevel: number; setMipLevel: (mipLevel: number) => void; } interface IPropertiesBarState { width: number; height: number; } export class PropertiesBar extends React.PureComponent { private _faces; constructor(props: IPropertiesBarProps); private _pixelData; private _getNewDimension; componentWillUpdate(nextProps: IPropertiesBarProps): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/channelsBar" { import * as React from "react"; export interface IChannel { visible: boolean; editable: boolean; name: string; id: "R" | "G" | "B" | "A"; icon: any; } interface IChannelsBarProps { channels: IChannel[]; setChannels(channelState: IChannel[]): void; } export class ChannelsBar extends React.PureComponent { } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/canvasShader" { export const canvasShader: { path: { vertexSource: string; fragmentSource: string; }; options: { attributes: string[]; uniforms: string[]; }; }; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/bottomBar" { import * as React from "react"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; interface IBottomBarProps { texture: BaseTexture; mipLevel: number; } export class BottomBar extends React.PureComponent { } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/defaultTools/rectangleSelect" { import { IToolData } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent"; export const RectangleSelect: IToolData; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/defaultTools/paintbrush" { import { IToolData } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent"; export const Paintbrush: IToolData; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/defaultTools/floodfill" { import { IToolData } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent"; export const Floodfill: IToolData; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/defaultTools/eyedropper" { import { IToolData } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent"; export const Eyedropper: IToolData; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/defaultTools/defaultTools" { const _default: import("babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent").IToolData[]; export default _default; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/defaultTools/contrast" { import { IToolData } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent"; export const Contrast: IToolData; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lights/spotLightPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { SpotLight } from "babylonjs/Lights/spotLight"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ISpotLightPropertyGridComponentProps { globalState: GlobalState; light: SpotLight; lockObject: LockObject; onPropertyChangedObservable?: Observable; onSelectionChangedObservable?: Observable; } export class SpotLightPropertyGridComponent extends React.Component { constructor(props: ISpotLightPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lights/rectAreaLightPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { RectAreaLight } from "babylonjs/Lights/rectAreaLight"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IRectAreaLightPropertyGridComponentProps { globalState: GlobalState; light: RectAreaLight; lockObject: LockObject; onPropertyChangedObservable?: Observable; onSelectionChangedObservable?: Observable; } export class RectAreaLightPropertyGridComponent extends React.Component { constructor(props: IRectAreaLightPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lights/pointLightPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PointLight } from "babylonjs/Lights/pointLight"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IPointLightPropertyGridComponentProps { globalState: GlobalState; light: PointLight; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class PointLightPropertyGridComponent extends React.Component { constructor(props: IPointLightPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lights/hemisphericLightPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { HemisphericLight } from "babylonjs/Lights/hemisphericLight"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IHemisphericLightPropertyGridComponentProps { globalState: GlobalState; light: HemisphericLight; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class HemisphericLightPropertyGridComponent extends React.Component { constructor(props: IHemisphericLightPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lights/directionalLightPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { DirectionalLight } from "babylonjs/Lights/directionalLight"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IDirectionalLightPropertyGridComponentProps { globalState: GlobalState; light: DirectionalLight; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class DirectionalLightPropertyGridComponent extends React.Component { constructor(props: IDirectionalLightPropertyGridComponentProps); displayFrustum(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lights/commonShadowLightPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { IShadowLight } from "babylonjs/Lights/shadowLight"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICommonShadowLightPropertyGridComponentProps { globalState: GlobalState; light: IShadowLight; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonShadowLightPropertyGridComponent extends React.Component { private _internals; constructor(props: ICommonShadowLightPropertyGridComponentProps); createShadowGenerator(): void; disposeShadowGenerator(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lights/commonLightPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Light } from "babylonjs/Lights/light"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICommonLightPropertyGridComponentProps { globalState: GlobalState; light: Light; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonLightPropertyGridComponent extends React.Component { constructor(props: ICommonLightPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/layers/layerPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { EffectLayer } from "babylonjs/Layers/effectLayer"; interface ILayerPropertyGridComponentProps { globalState: GlobalState; layer: EffectLayer; extensibilityGroups?: IExplorerExtensibilityGroup[]; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class LayerPropertyGridComponent extends React.Component { constructor(props: ILayerPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/frameGraphs/frameGraphPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { FrameGraph } from "babylonjs/FrameGraph/frameGraph"; interface IFrameGraphPropertyGridComponentProps { globalState: GlobalState; frameGraph: FrameGraph; extensibilityGroups?: IExplorerExtensibilityGroup[]; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class FrameGraphPropertyGridComponent extends React.Component { constructor(props: IFrameGraphPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/cameras/freeCameraPropertyGridComponent" { import * as React from "react"; import { FreeCamera } from "babylonjs/Cameras/freeCamera"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IFreeCameraPropertyGridComponentProps { globalState: GlobalState; camera: FreeCamera; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class FreeCameraPropertyGridComponent extends React.Component { constructor(props: IFreeCameraPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/cameras/followCameraPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { FollowCamera } from "babylonjs/Cameras/followCamera"; interface IFollowCameraPropertyGridComponentProps { globalState: GlobalState; camera: FollowCamera; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class FollowCameraPropertyGridComponent extends React.Component { constructor(props: IFollowCameraPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/cameras/commonCameraPropertyGridComponent" { import * as React from "react"; import { Camera } from "babylonjs/Cameras/camera"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ICommonCameraPropertyGridComponentProps { globalState: GlobalState; camera: Camera; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonCameraPropertyGridComponent extends React.Component { constructor(props: ICommonCameraPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/cameras/arcRotateCameraPropertyGridComponent" { import * as React from "react"; import { ArcRotateCamera } from "babylonjs/Cameras/arcRotateCamera"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IArcRotateCameraPropertyGridComponentProps { globalState: GlobalState; camera: ArcRotateCamera; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class ArcRotateCameraPropertyGridComponent extends React.Component { constructor(props: IArcRotateCameraPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/targetedAnimationPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { TargetedAnimation } from "babylonjs/Animations/animationGroup"; import { Scene } from "babylonjs/scene"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface ITargetedAnimationGridComponentProps { globalState: GlobalState; targetedAnimation: TargetedAnimation; scene: Scene; lockObject: LockObject; onSelectionChangedObservable?: Observable; onPropertyChangedObservable?: Observable; } export class TargetedAnimationGridComponent extends React.Component { private _animationGroup; private _animationCurveEditorContext; constructor(props: ITargetedAnimationGridComponentProps); findAnimationGroup: () => void; playOrPause: () => void; deleteAnimation: () => void; updateContextFromProps: () => void; componentDidMount(): void; componentDidUpdate(prevProps: Readonly, prevState: Readonly<{}>, snapshot?: any): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Scene } from "babylonjs/scene"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { IAnimatable } from "babylonjs/Animations/animatable.interface"; interface IAnimationGridComponentProps { globalState: GlobalState; animatable: IAnimatable; scene: Scene; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class AnimationGridComponent extends React.Component { private _animations; private _ranges; private _mainAnimatable; private _onBeforeRenderObserver; private _isPlaying; private _timelineRef; private _animationCurveEditorContext; private _animationControl; constructor(props: IAnimationGridComponentProps); playOrPause(): void; componentDidMount(): void; componentWillUnmount(): void; onCurrentFrameChange(value: number): void; onChangeFromOrTo(): void; componentDidUpdate(prevProps: IAnimationGridComponentProps): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationGroupPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { AnimationGroup } from "babylonjs/Animations/animationGroup"; import { Scene } from "babylonjs/scene"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { GlobalState } from "babylonjs-inspector/components/globalState"; interface IAnimationGroupGridComponentProps { globalState: GlobalState; animationGroup: AnimationGroup; scene: Scene; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class AnimationGroupGridComponent extends React.Component { private _onAnimationGroupPlayObserver; private _onAnimationGroupPauseObserver; private _onBeforeRenderObserver; private _timelineRef; private _animationCurveEditorContext; constructor(props: IAnimationGroupGridComponentProps); componentDidMount(): void; disconnect(animationGroup: AnimationGroup): void; connect(animationGroup: AnimationGroup): void; updateCurrentFrame(animationGroup: AnimationGroup): void; shouldComponentUpdate(nextProps: IAnimationGroupGridComponentProps): boolean; componentWillUnmount(): void; playOrPause(): void; onCurrentFrameChange(value: number): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/topBarComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/scss/topBar.scss"; interface ITopBarComponentProps { globalState: GlobalState; context: Context; } interface ITopBarComponentState { keyFrameValue: string; keyValue: string; frameControlEnabled: boolean; valueControlEnabled: boolean; } export class TopBarComponent extends React.Component { private _onFrameSetObserver; private _onValueSetObserver; private _onActiveAnimationChangedObserver; private _onActiveKeyPointChanged; constructor(props: ITopBarComponentProps); componentWillUnmount(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context" { import { Nullable } from "babylonjs/types"; import { Animation } from "babylonjs/Animations/animation"; import { Observable } from "babylonjs/Misc/observable"; import { KeyPointComponent } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/keyPoint"; import { Scene } from "babylonjs/scene"; import { IAnimatable } from "babylonjs/Animations/animatable.interface"; import { AnimationGroup, TargetedAnimation } from "babylonjs/Animations/animationGroup"; import { AnimationKeyInterpolation } from "babylonjs/Animations/animationKey"; export interface IActiveAnimationChangedOptions { evaluateKeys?: boolean; frame?: boolean; range?: boolean; } export class Context { title: string; animations: Nullable; scene: Scene; target: Nullable; rootAnimationGroup: Nullable; activeAnimations: Animation[]; activeChannels: { [key: number]: string; }; activeKeyPoints: Nullable; mainKeyPoint: Nullable; snippetId: string; useTargetAnimations: boolean; activeFrame: number; fromKey: number; toKey: number; useExistingPlayRange: boolean; forwardAnimation: boolean; isPlaying: boolean; clipLength: number; referenceMinFrame: number; referenceMaxFrame: number; focusedInput: boolean; onActiveAnimationChanged: Observable; onActiveKeyPointChanged: Observable; onHostWindowResized: Observable; onSelectAllKeys: Observable; onActiveKeyFrameChanged: Observable; onFrameSet: Observable; onFrameManuallyEntered: Observable; onMainKeyPointSet: Observable; onMainKeyPointMoved: Observable; onValueSet: Observable; onValueManuallyEntered: Observable; onFrameRequired: Observable; onCreateOrUpdateKeyPointRequired: Observable; onFlattenTangentRequired: Observable; onLinearTangentRequired: Observable; onBreakTangentRequired: Observable; onUnifyTangentRequired: Observable; onStepTangentRequired: Observable; onDeleteAnimation: Observable; onGraphMoved: Observable; onGraphScaled: Observable; onRangeUpdated: Observable; onMoveToFrameRequired: Observable; onAnimationStateChanged: Observable; onDeleteKeyActiveKeyPoints: Observable; onSelectionRectangleMoved: Observable; onAnimationsLoaded: Observable; onEditAnimationRequired: Observable; onEditAnimationUIClosed: Observable; onClipLengthIncreased: Observable; onClipLengthDecreased: Observable; onInterpolationModeSet: Observable<{ keyId: number; value: AnimationKeyInterpolation; }>; onSelectToActivated: Observable<{ from: number; to: number; }>; onRangeFrameBarResized: Observable; onPlayheadMoved: Observable; lockLastFrameValue: boolean; lockLastFrameFrame: boolean; onActiveKeyDataChanged: Observable; prepare(): void; play(forward: boolean): void; stop(): void; moveToFrame(frame: number): void; refreshTarget(): void; clearSelection(): void; enableChannel(animation: Animation, color: string): void; disableChannel(animation: Animation): void; isChannelEnabled(animation: Animation, color: string): boolean; getActiveChannel(animation: Animation): string; resetAllActiveChannels(): void; getAnimationSortIndex(animation: Animation): number; getPrevKey(): Nullable; getNextKey(): Nullable; /** * If any current active animation has a key at the received frameNumber, * return the index of the animation in the active animation array, and * the index of the frame on the animation. * @param frameNumber the frame number to look for * @returns null if no key was found, or an object with the animation index and key index */ getKeyAtAnyFrameIndex(frameNumber: number): { animationIndex: number; keyIndex: number; } | null; /** * @returns true if any active animation has a quaternion animation */ hasActiveQuaternionAnimationKeyPoints(): boolean; } } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/animationCurveEditorComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/scss/curveEditor.scss"; interface IAnimationCurveEditorComponentProps { globalState: GlobalState; context: Context; } interface IAnimationCurveEditorComponentState { isOpen: boolean; } export class AnimationCurveEditorComponent extends React.Component { constructor(props: IAnimationCurveEditorComponentProps); onCloseAnimationCurveEditor(window: Window | null): void; shouldComponentUpdate(newProps: IAnimationCurveEditorComponentProps, newState: IAnimationCurveEditorComponentState): boolean; private _onKeyDown; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/sideBarComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/scss/sideBar.scss"; interface ISideBarComponentProps { globalState: GlobalState; context: Context; } interface ISideBarComponentState { mode: Mode; } enum Mode { Edit = 0, Add = 1, Load = 2, Save = 3 } export class SideBarComponent extends React.Component { constructor(props: ISideBarComponentProps); private _onAddAnimation; private _onLoadAnimation; private _onSaveAnimation; private _onEditAnimation; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/saveAnimationComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface ISaveAnimationComponentProps { globalState: GlobalState; context: Context; } interface ISaveAnimationComponentState { } export class SaveAnimationComponent extends React.Component { private _selectedAnimations; private _root; constructor(props: ISaveAnimationComponentProps); private _getJson; saveToSnippetServer(): void; saveToFile(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/loadAnimationComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface ILoadAnimationComponentProps { globalState: GlobalState; context: Context; } interface ILoadAnimationComponentState { } export class LoadAnimationComponent extends React.Component { private _root; private _textInput; constructor(props: ILoadAnimationComponentProps); loadFromFile(evt: React.ChangeEvent): void; loadFromSnippetServer(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/editAnimationComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import { Animation } from "babylonjs/Animations/animation"; import { Nullable } from "babylonjs/types"; interface IEditAnimationComponentProps { globalState: GlobalState; context: Context; } interface IEditAnimationComponentState { isVisible: boolean; animation: Nullable; } export class EditAnimationComponent extends React.Component { private _root; private _displayName; private _property; private _loopModeElement; private _onEditAnimationRequiredObserver; constructor(props: IEditAnimationComponentProps); componentWillUnmount(): void; close(): void; validate(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/animationSubEntryComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import { Animation } from "babylonjs/Animations/animation"; interface IAnimationSubEntryComponentProps { globalState: GlobalState; context: Context; animation: Animation; color: string; subName: string; } interface IAnimationSubEntryComponentState { isSelected: boolean; } export class AnimationSubEntryComponent extends React.Component { private _onActiveAnimationChangedObserver; private _onActiveKeyPointChangedObserver; constructor(props: IAnimationSubEntryComponentProps); componentWillUnmount(): void; private _activate; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/animationListComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IAnimationListComponentProps { globalState: GlobalState; context: Context; } interface IAnimationListComponentState { isVisible: boolean; } export class AnimationListComponent extends React.Component { private _onEditAnimationRequiredObserver; private _onEditAnimationUIClosedObserver; private _onDeleteAnimationObserver; constructor(props: IAnimationListComponentProps); componentWillUnmount(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/animationEntryComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import { Animation } from "babylonjs/Animations/animation"; interface IAnimationEntryComponentProps { globalState: GlobalState; context: Context; animation: Animation; } interface IAnimationEntryComponentState { isExpanded: boolean; isSelected: boolean; } export class AnimationEntryComponent extends React.Component { private _onActiveAnimationChangedObserver; private _onActiveKeyPointChangedObserver; private _onSelectToActivatedObserver; private _unmount; constructor(props: IAnimationEntryComponentProps); private _onGear; private _onDelete; componentWillUnmount(): void; private _activate; private _expandOrCollapse; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/sideBar/addAnimationComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IAddAnimationComponentProps { globalState: GlobalState; context: Context; } interface IAddAnimationComponentState { customPropertyMode: boolean; } export class AddAnimationComponent extends React.Component { private _root; private _displayName; private _property; private _typeElement; private _propertylement; private _loopModeElement; constructor(props: IAddAnimationComponentProps); createNew(): void; getInferredType(activeProperty?: string): any; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/rangeFrameBarComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IRangeFrameBarComponentProps { globalState: GlobalState; context: Context; } interface IRangeFrameBarComponentState { } export class RangeFrameBarComponent extends React.Component { private _svgHost; private _viewWidth; private _offsetX; private _isMounted; private _onActiveAnimationChangedObserver; private _onPlayheadMovedObserver; private _onFrameManuallyEnteredObserver; constructor(props: IRangeFrameBarComponentProps); componentDidMount(): void; componentWillUnmount(): void; private _computeSizes; private _dropKeyFrames; private _buildActiveFrame; private _buildFrames; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/playHeadComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IPlayHeadComponentProps { globalState: GlobalState; context: Context; } interface IPlayHeadComponentState { } export class PlayHeadComponent extends React.Component { private readonly _graphAbsoluteWidth; private _playHead; private _playHeadCircle; private _onBeforeRenderObserver; private _onActiveAnimationChangedObserver; private _onRangeFrameBarResizedObserver; private _onMoveToFrameRequiredObserver; private _onGraphMovedObserver; private _onGraphScaledObserver; private _viewScale; private _offsetX; private _offsetRange; private _viewWidth; private readonly _rangeWidthToPlayheadWidth; private _pointerIsDown; constructor(props: IPlayHeadComponentProps); private _moveHead; private _frameToPixel; private _pixelToFrame; componentWillUnmount(): void; private _getPixelValues; private _onPointerDown; private _onPointerMove; private _onPointerUp; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/keyPoint" { import { Nullable } from "babylonjs/types"; import * as React from "react"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import { Curve } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/curve"; interface IKeyPointComponentProps { x: number; y: number; getPreviousX: () => Nullable; getNextX: () => Nullable; invertX: (x: number) => number; invertY: (y: number) => number; convertX: (x: number) => number; convertY: (y: number) => number; nextX?: number; scale: number; keyId: number; curve: Curve; context: Context; channel: string; onFrameValueChanged: (value: number) => void; onKeyValueChanged: (value: number) => void; } interface IKeyPointComponentState { selectedState: SelectionState; tangentSelectedIndex: number; x: number; y: number; } export enum SelectionState { None = 0, Selected = 1, Siblings = 2 } export class KeyPointComponent extends React.Component { private _onActiveKeyPointChangedObserver; private _onActiveKeyFrameChangedObserver; private _onFrameManuallyEnteredObserver; private _onValueManuallyEnteredObserver; private _onMainKeyPointSetObserver; private _onMainKeyPointMovedObserver; private _onSelectionRectangleMovedObserver; private _onFlattenTangentRequiredObserver; private _onLinearTangentRequiredObserver; private _onBreakTangentRequiredObserver; private _onUnifyTangentRequiredObserver; private _onStepTangentRequiredObserver; private _onSelectAllKeysObserver; private _pointerIsDown; private _sourcePointerX; private _sourcePointerY; private _offsetXToMain; private _offsetYToMain; private _svgHost; private _keyPointSVG; private _controlMode; private _storedLengthIn; private _storedLengthOut; private _inVec; private _outVec; private _lockX; private _lockY; private _accumulatedX; private _accumulatedY; constructor(props: IKeyPointComponentProps); componentWillUnmount(): void; shouldComponentUpdate(newProps: IKeyPointComponentProps, newState: IKeyPointComponentState): boolean; private _breakTangent; private _unifyTangent; private _flattenTangent; private _linearTangent; private _stepTangent; private _select; private _onPointerDown; private _extractSlope; private _processTangentMove; private _onPointerMove; private _onPointerUp; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/graphComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IGraphComponentProps { globalState: GlobalState; context: Context; } interface IGraphComponentState { } export class GraphComponent extends React.Component { private readonly _minScale; private readonly _maxScale; private readonly _graphAbsoluteWidth; private readonly _graphAbsoluteHeight; private _viewWidth; private _viewCurveWidth; private _viewHeight; private _viewScale; private _offsetX; private _offsetY; private _inSelectionMode; private _graphOffsetX; private _minValue; private _maxValue; private _minFrame; private _maxFrame; private _svgHost; private _svgHost2; private _selectionRectangle; private _curves; private _pointerIsDown; private _sourcePointerX; private _sourcePointerY; private _selectionMade; private _selectionStartX; private _selectionStartY; private _onActiveAnimationChangedObserver; constructor(props: IGraphComponentProps); componentWillUnmount(): void; private _computeSizes; private _setDefaultInTangent; private _setDefaultOutTangent; private _evaluateKeys; private _extractValuesFromKeys; private _convertX; private _invertX; private _convertY; private _invertY; private _buildFrameIntervalAxis; private _buildYAxis; private _frameFromActiveKeys; private _dropKeyFrames; private _onPointerDown; private _onPointerMove; private _onPointerUp; private _onWheel; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/frameBarComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IFrameBarComponentProps { globalState: GlobalState; context: Context; } interface IFrameBarComponentState { } export class FrameBarComponent extends React.Component { private readonly _graphAbsoluteWidth; private _svgHost; private _viewWidth; private _viewScale; private _offsetX; private _onActiveAnimationChangedObserver; constructor(props: IFrameBarComponentProps); componentWillUnmount(): void; private _computeSizes; private _buildFrames; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/curveComponent" { import * as React from "react"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import { Curve } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/curve"; interface ICurveComponentProps { curve: Curve; convertX: (x: number) => number; convertY: (x: number) => number; context: Context; } interface ICurveComponentState { isSelected: boolean; } export class CurveComponent extends React.Component { private _onDataUpdatedObserver; private _onActiveAnimationChangedObserver; private _onInterpolationModeSetObserver; constructor(props: ICurveComponentProps); componentWillUnmount(): void; componentDidUpdate(): boolean; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/curve" { import { Animation } from "babylonjs/Animations/animation"; import { AnimationKeyInterpolation } from "babylonjs/Animations/animationKey"; import { Observable } from "babylonjs/Misc/observable"; export interface KeyEntry { frame: number; value: number; inTangent?: number; outTangent?: number; lockedTangent: boolean; interpolation?: AnimationKeyInterpolation; } export class Curve { static readonly SampleRate: number; keys: KeyEntry[]; animation: Animation; color: string; onDataUpdatedObservable: Observable; property?: string; tangentBuilder?: () => any; setDefaultInTangent?: (keyId: number) => any; setDefaultOutTangent?: (keyId: number) => any; static readonly TangentLength: number; constructor(color: string, animation: Animation, property?: string, tangentBuilder?: () => any, setDefaultInTangent?: (keyId: number) => any, setDefaultOutTangent?: (keyId: number) => any); getPathData(convertX: (x: number) => number, convertY: (y: number) => number): string; updateLockedTangentMode(keyIndex: number, enabled: boolean): void; updateInterpolationMode(keyIndex: number, interpolationMode: AnimationKeyInterpolation): void; getInControlPoint(keyIndex: number): number | undefined; getOutControlPoint(keyIndex: number): number | undefined; hasDefinedOutTangent(keyIndex: number): boolean; evaluateOutTangent(keyIndex: number): number; hasDefinedInTangent(keyIndex: number): boolean; evaluateInTangent(keyIndex: number): number; storeDefaultInTangent(keyIndex: number): void; storeDefaultOutTangent(keyIndex: number): void; updateInTangentFromControlPoint(keyId: number, slope: number): void; updateOutTangentFromControlPoint(keyId: number, slope: number): void; updateKeyFrame(keyId: number, frame: number): void; updateKeyValue(keyId: number, value: number): void; } } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/graph/canvasComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/scss/canvas.scss"; interface ICanvasComponentProps { globalState: GlobalState; context: Context; } interface ICanvasComponentState { } export class CanvasComponent extends React.Component { private _onActiveAnimationChangedObserver; constructor(props: ICanvasComponentProps); componentWillUnmount(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/controls/textInputComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface ITextInputComponentProps { globalState: GlobalState; context: Context; id?: string; className?: string; tooltip?: string; value: string; isNumber?: boolean; complement?: string; onValueAsNumberChanged?: (value: number, isFocused: boolean) => void; disabled?: boolean; } interface ITextInputComponentState { value: string; isFocused: boolean; } export class TextInputComponent extends React.Component { private _lastKnownGoodValue; constructor(props: ITextInputComponentProps); private _onChange; private _onBlur; private _onFocus; shouldComponentUpdate(newProps: ITextInputComponentProps, newState: ITextInputComponentState): boolean; private _onKeyPress; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/controls/pushButtonComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IPushButtonComponentProps { globalState: GlobalState; context: Context; icon: string; id?: string; className?: string; isPushed?: boolean; onClick: (state: boolean) => void; tooltip?: string; } interface IPushButtonComponentState { isPushed: boolean; } export class PushButtonComponent extends React.Component { constructor(props: IPushButtonComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/controls/controlButtonComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IControlButtonComponentProps { globalState: GlobalState; context: Context; icon: string; hoverIcon: string; id?: string; className?: string; onClick: () => void; tooltip?: string; } interface IControlButtonComponentState { } export class ControlButtonComponent extends React.Component { constructor(props: IControlButtonComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/controls/actionButtonComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IActionButtonComponentProps { globalState: GlobalState; context: Context; icon: string; id?: string; className?: string; isActive?: boolean; onClick: () => void; tooltip?: string; } interface IActionButtonComponentState { } export class ActionButtonComponent extends React.Component { constructor(props: IActionButtonComponentProps); } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/bottomBar/rangeSelectorComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IRangeSelectorComponentProps { globalState: GlobalState; context: Context; } interface IRangeSelectorComponentState { } export class RangeSelectorComponent extends React.Component { private _rangeHost; private _rangeScrollbarHost; private _viewWidth; private _pointerIsDown; private _minFrame; private _maxFrame; private _leftHandleIsActive; private _bothHandleIsActive; private _currentOffset; private _currentFrom; private _currentTo; constructor(props: IRangeSelectorComponentProps); private _computeSizes; private _onPointerDown; private _onPointerMove; private _updateLimits; private _onPointerUp; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/bottomBar/mediaPlayerComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; interface IMediaPlayerComponentProps { globalState: GlobalState; context: Context; } interface IMediaPlayerComponentState { } export class MediaPlayerComponent extends React.Component { private _isMounted; constructor(props: IMediaPlayerComponentProps); componentDidMount(): void; componentWillUnmount(): void; private _onFirstKey; private _onPrevKey; private _onRewind; private _onForward; private _onPrevFrame; private _onNextFrame; private _onNextKey; private _onEndKey; private _onStop; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/bottomBar/bottomBarComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Context } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/context"; import "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/curveEditor/scss/bottomBar.scss"; interface IBottomBarComponentProps { globalState: GlobalState; context: Context; } interface IBottomBarComponentState { clipLength: string; } export class BottomBarComponent extends React.Component { private _onAnimationsLoadedObserver; private _onActiveAnimationChangedObserver; private _onClipLengthIncreasedObserver; private _onClipLengthDecreasedObserver; constructor(props: IBottomBarComponentProps); private _changeClipLength; componentWillUnmount(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/performanceViewer/performanceViewerSidebarComponent" { import { PerformanceViewerCollector } from "babylonjs/Misc/PerformanceViewer/performanceViewerCollector"; import { Observable } from "babylonjs/Misc/observable"; import { IVisibleRangeChangedObservableProps } from "babylonjs-inspector/components/graph/graphSupportingTypes"; interface IPerformanceViewerSidebarComponentProps { collector: PerformanceViewerCollector; onVisibleRangeChangedObservable?: Observable; } export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/performanceViewer/performanceViewerPopupComponent" { import * as React from "react"; import { Scene } from "babylonjs/scene"; import { Observable } from "babylonjs/Misc/observable"; import { PerformanceViewerCollector } from "babylonjs/Misc/PerformanceViewer/performanceViewerCollector"; import { IPerfLayoutSize } from "babylonjs-inspector/components/graph/graphSupportingTypes"; interface IPerformanceViewerPopupComponentProps { scene: Scene; layoutObservable: Observable; returnToLiveObservable: Observable; performanceCollector: PerformanceViewerCollector; initialGraphSize?: { width: number; height: number; }; } export const PerformanceViewerPopupComponent: React.FC; export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/performanceViewer/performanceViewerComponent" { import { Scene } from "babylonjs/scene"; import * as React from "react"; import "babylonjs/Misc/PerformanceViewer/performanceViewerSceneExtension"; import "babylonjs-inspector/components/actionTabs/tabs/performanceViewer/scss/performanceViewer.scss"; interface IPerformanceViewerComponentProps { scene: Scene; } export enum IPerfMetadataCategory { Count = "Count", FrameSteps = "Frame Steps Duration" } export const PerformanceViewerComponent: React.FC; export {}; } declare module "babylonjs-inspector/components/actionTabs/tabs/performanceViewer/performancePlayheadButtonComponent" { import { Observable } from "babylonjs/Misc/observable"; import * as React from "react"; interface IPerformancePlayheadButtonProps { returnToPlayhead: Observable; } export const PerformancePlayheadButtonComponent: React.FC; export {}; } declare module "babylonjs-inspector/components/actionTabs/lines/textureLinkLineComponent" { import * as React from "react"; import { Nullable } from "babylonjs/types"; import { Observable } from "babylonjs/Misc/observable"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { Material } from "babylonjs/Materials/material"; import { Scene } from "babylonjs/scene"; export interface ITextureLinkLineComponentProps { label: string; texture: Nullable; material?: Material; texturedObject?: { getScene: () => Scene; }; onSelectionChangedObservable?: Observable; onDebugSelectionChangeObservable?: Observable; propertyName?: string; onTextureCreated?: (texture: BaseTexture) => void; customDebugAction?: (state: boolean) => void; onTextureRemoved?: () => void; fileFormats?: string; cubeOnly?: boolean; } export class TextureLinkLineComponent extends React.Component { private _onDebugSelectionChangeObserver; constructor(props: ITextureLinkLineComponentProps); componentDidMount(): void; componentWillUnmount(): void; debugTexture(): void; onLink(): void; onLinkTexture(texture: BaseTexture): void; updateTexture(file: File): void; removeTexture(): void; } } declare module "babylonjs-inspector/components/actionTabs/lines/textureLineComponent" { import * as React from "react"; import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { TextureChannelsToDisplay } from "babylonjs-inspector/textureHelper"; interface ITextureLineComponentProps { texture: BaseTexture; width: number; height: number; globalState?: GlobalState; hideChannelSelect?: boolean; } export class TextureLineComponent extends React.Component { private _canvasRef; private static _TextureChannelStates; constructor(props: ITextureLineComponentProps); shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: { channels: TextureChannelsToDisplay; face: number; }): boolean; componentDidMount(): void; componentDidUpdate(): void; updatePreview(): Promise; } export {}; } declare module "babylonjs-inspector/components/actionTabs/lines/quaternionLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Quaternion, Vector3 } from "babylonjs/Maths/math.vector"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IQuaternionLineComponentProps { label: string; target: any; useEuler?: boolean; propertyName: string; onPropertyChangedObservable?: Observable; lockObject: LockObject; } export class QuaternionLineComponent extends React.Component { private _localChange; constructor(props: IQuaternionLineComponentProps); _checkRoundCircle(a: number, b: number): boolean; shouldComponentUpdate(nextProps: IQuaternionLineComponentProps, nextState: { isExpanded: boolean; value: Quaternion; eulerValue: Vector3; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(currentValue: Quaternion, previousValue: Quaternion): void; updateQuaternion(): void; updateStateX(value: number): void; updateStateY(value: number): void; updateStateZ(value: number): void; updateStateW(value: number): void; updateQuaternionFromEuler(): void; updateStateEulerX(value: number): void; updateStateEulerY(value: number): void; updateStateEulerZ(value: number): void; onCopyClick(): void; } export {}; } declare module "babylonjs-inspector/components/actionTabs/lines/meshPickerComponent" { import * as React from "react"; import { GlobalState } from "babylonjs-inspector/components/globalState"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent"; import { Scene } from "babylonjs/scene"; interface IMeshPickerComponentProps { globalState: GlobalState; target: any; property: string; scene: Scene; label: string; onPropertyChangedObservable?: Observable; } export class MeshPickerComponent extends React.Component { constructor(props: IMeshPickerComponentProps); } export {}; } declare module "babylonjs-inspector/styleHelper" { /** * Copy all styles from a document to another document or shadow root * @param source document to copy styles from * @param target document or shadow root to copy styles to */ export function CopyStyles(source: Document, target: DocumentOrShadowRoot): void; /** * Merges classNames by array of strings or conditions * @param classNames Array of className strings or truthy conditions * @returns A concatenated string, suitable for the className attribute */ export function MergeClassNames(classNames: ClassNameCondition[]): string; /** * className (replicating React type) or a tuple with the second member being any truthy value ["className", true] */ type ClassNameCondition = string | undefined | [string, any]; export {}; } declare module "babylonjs-inspector/stringTools" { export class StringTools { private static _SaveAs; private static _Click; /** * Download a string into a file that will be saved locally by the browser * @param document * @param content defines the string to download locally as a file * @param filename */ static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void; } } declare module "babylonjs-inspector/propertyChangedEvent" { export class PropertyChangedEvent { object: any; property: string; value: any; initialValue: any; allowNullValue?: boolean; } } declare module "babylonjs-inspector/popupHelper" { /** * Create a popup window * @param title default title for the popup * @param options options for the popup * @returns the parent control of the popup */ export function CreatePopup(title: string, options: Partial<{ onParentControlCreateCallback?: (parentControl: HTMLDivElement) => void; onWindowCreateCallback?: (newWindow: Window) => void; width?: number; height?: number; }>): HTMLDivElement | null; } declare module "babylonjs-inspector/historyStack" { import { IDisposable } from "babylonjs/scene"; /** * Class handling undo / redo operations */ export class HistoryStack implements IDisposable { private _historyStack; private _redoStack; private _activeData; private readonly _maxHistoryLength; private _locked; private _dataProvider; private _applyUpdate; /** * Gets or sets a boolean indicating if the stack is enabled */ isEnabled: boolean; /** * Constructor * @param dataProvider defines the data provider function * @param applyUpdate defines the code to execute when undo/redo operation is required */ constructor(dataProvider: () => any, applyUpdate: (data: any) => void); /** * Process key event to handle undo / redo * @param evt defines the keyboard event to process * @returns true if the event was processed */ processKeyEvent(evt: KeyboardEvent): boolean; /** * Resets the stack */ reset(): void; /** * Remove the n-1 element of the stack */ collapseLastTwo(): void; private _generateJSONDiff; private _applyJSONDiff; private _copy; /** * Stores the current state */ store(): void; /** * Undo the latest operation */ undo(): void; /** * Redo the latest undo operation */ redo(): void; /** * Disposes the stack */ dispose(): void; } } declare module "babylonjs-inspector/copyCommandToClipboard" { export function copyCommandToClipboard(strCommand: string): void; export function getClassNameWithNamespace(obj: any): { className: string; babylonNamespace: string; }; } declare module "babylonjs-inspector/constToOptionsMaps" { /** * Used by both particleSystem and alphaBlendModes */ export const CommonBlendModes: { label: string; value: number; }[]; /** * Used to populated the blendMode dropdown in our various tools (Node Editor, Inspector, etc.) * The below ParticleSystem consts were defined before new Engine alpha blend modes were added, so we have to reference * the ParticleSystem.FOO consts explicitly (as the underlying const values are different - they get mapped to engine consts within baseParticleSystem.ts) */ export const BlendModeOptions: { label: string; value: number; }[]; /** * Used to populated the alphaMode dropdown in our various tools (Node Editor, Inspector, etc.) */ export const AlphaModeOptions: { label: string; value: number; }[]; } declare module "babylonjs-inspector/tabs/propertyGrids/lockObject" { /** * Class used to provide lock mechanism */ export class LockObject { /** * Gets or set if the lock is engaged */ lock: boolean; } } declare module "babylonjs-inspector/tabs/propertyGrids/gui/textBlockPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { TextBlock } from "babylonjs-gui/2D/controls/textBlock"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface ITextBlockPropertyGridComponentProps { textBlock: TextBlock; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class TextBlockPropertyGridComponent extends React.Component { constructor(props: ITextBlockPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { StackPanel } from "babylonjs-gui/2D/controls/stackPanel"; interface IStackPanelPropertyGridComponentProps { stackPanel: StackPanel; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class StackPanelPropertyGridComponent extends React.Component { constructor(props: IStackPanelPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/sliderPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Slider } from "babylonjs-gui/2D/controls/sliders/slider"; interface ISliderPropertyGridComponentProps { slider: Slider; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class SliderPropertyGridComponent extends React.Component { constructor(props: ISliderPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { ScrollViewer } from "babylonjs-gui/2D/controls/scrollViewers/scrollViewer"; interface IScrollViewerPropertyGridComponentProps { scrollViewer: ScrollViewer; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class ScrollViewerPropertyGridComponent extends React.Component { constructor(props: IScrollViewerPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/rectanglePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Rectangle } from "babylonjs-gui/2D/controls/rectangle"; interface IRectanglePropertyGridComponentProps { rectangle: Rectangle; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class RectanglePropertyGridComponent extends React.Component { constructor(props: IRectanglePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { RadioButton } from "babylonjs-gui/2D/controls/radioButton"; interface IRadioButtonPropertyGridComponentProps { radioButtons: RadioButton[]; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class RadioButtonPropertyGridComponent extends React.Component { constructor(props: IRadioButtonPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/linePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Line } from "babylonjs-gui/2D/controls/line"; interface ILinePropertyGridComponentProps { line: Line; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class LinePropertyGridComponent extends React.Component { constructor(props: ILinePropertyGridComponentProps); onDashChange(value: string): void; } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/inputTextPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { InputText } from "babylonjs-gui/2D/controls/inputText"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IInputTextPropertyGridComponentProps { inputText: InputText; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class InputTextPropertyGridComponent extends React.Component { constructor(props: IInputTextPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/imagePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Image } from "babylonjs-gui/2D/controls/image"; interface IImagePropertyGridComponentProps { image: Image; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class ImagePropertyGridComponent extends React.Component { constructor(props: IImagePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { ImageBasedSlider } from "babylonjs-gui/2D/controls/sliders/imageBasedSlider"; interface IImageBasedSliderPropertyGridComponentProps { imageBasedSlider: ImageBasedSlider; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class ImageBasedSliderPropertyGridComponent extends React.Component { constructor(props: IImageBasedSliderPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/gridPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Grid } from "babylonjs-gui/2D/controls/grid"; interface IGridPropertyGridComponentProps { grid: Grid; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class GridPropertyGridComponent extends React.Component { constructor(props: IGridPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/ellipsePropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Ellipse } from "babylonjs-gui/2D/controls/ellipse"; interface IEllipsePropertyGridComponentProps { ellipse: Ellipse; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class EllipsePropertyGridComponent extends React.Component { constructor(props: IEllipsePropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/controlPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { Control } from "babylonjs-gui/2D/controls/control"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IControlPropertyGridComponentProps { control: Control; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class ControlPropertyGridComponent extends React.Component { constructor(props: IControlPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/commonControlPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { Control } from "babylonjs-gui/2D/controls/control"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface ICommonControlPropertyGridComponentProps { controls?: Control[]; control?: Control; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CommonControlPropertyGridComponent extends React.Component { constructor(props: ICommonControlPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { ColorPicker } from "babylonjs-gui/2D/controls/colorpicker"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IColorPickerPropertyGridComponentProps { colorPicker: ColorPicker; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class ColorPickerPropertyGridComponent extends React.Component { constructor(props: IColorPickerPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/tabs/propertyGrids/gui/checkboxPropertyGridComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import { Checkbox } from "babylonjs-gui/2D/controls/checkbox"; interface ICheckboxPropertyGridComponentProps { checkbox: Checkbox; lockObject: LockObject; onPropertyChangedObservable?: Observable; } export class CheckboxPropertyGridComponent extends React.Component { constructor(props: ICheckboxPropertyGridComponentProps); } export {}; } declare module "babylonjs-inspector/split/splitter" { import { ControlledSize } from "babylonjs-inspector/split/splitContext"; /** * Splitter component properties */ export interface ISplitterProps { /** * Unique identifier */ id?: string; /** * Splitter size */ size: number; /** * Minimum size for the controlled element */ minSize?: number; /** * Maximum size for the controlled element */ maxSize?: number; /** * Initial size for the controlled element */ initialSize?: number; /** * Defines the controlled side */ controlledSide: ControlledSize; /** * refObject to the splitter element */ refObject?: React.RefObject; } /** * Creates a splitter component * @param props defines the splitter properties * @returns the splitter component */ export const Splitter: React.FC; } declare module "babylonjs-inspector/split/splitContext" { export enum ControlledSize { First = 0, Second = 1 } export enum SplitDirection { Horizontal = 0, Vertical = 1 } /** * Context used to share data with splitters */ export interface ISplitContext { /** * Split direction */ direction: SplitDirection; /** * Function called by splitters to update the offset * @param offset new offet * @param source source element * @param controlledSide defined controlled element */ drag: (offset: number, source: HTMLElement, controlledSide: ControlledSize) => void; /** * Function called by splitters to begin dragging */ beginDrag: () => void; /** * Function called by splitters to end dragging */ endDrag: () => void; /** * Sync sizes for the elements * @param source source element * @param controlledSide defined controlled element * @param size size of the controlled element * @param minSize minimum size for the controlled element * @param maxSize maximum size for the controlled element */ sync: (source: HTMLElement, controlledSide: ControlledSize, size?: number, minSize?: number, maxSize?: number) => void; } export const SplitContext: import("react").Context; } declare module "babylonjs-inspector/split/splitContainer" { import { PropsWithChildren } from "react"; import { SplitDirection } from "babylonjs-inspector/split/splitContext"; /** * Split container properties */ export interface ISplitContainerProps { /** * Unique identifier */ id?: string; /** * Split direction */ direction: SplitDirection; /** * Minimum size for the floating elements */ floatingMinSize?: number; /** * RefObject to the root div element */ containerRef?: React.RefObject; /** * Optional class name */ className?: string; /** * Pointer down * @param event pointer events */ onPointerDown?: (event: React.PointerEvent) => void; /** * Pointer move * @param event pointer events */ onPointerMove?: (event: React.PointerEvent) => void; /** * Pointer up * @param event pointer events */ onPointerUp?: (event: React.PointerEvent) => void; /** * Drop * @param event drag events */ onDrop?: (event: React.DragEvent) => void; /** * Drag over * @param event drag events */ onDragOver?: (event: React.DragEvent) => void; } /** * Creates a split container component * @param props defines the split container properties * @returns the split container component */ export const SplitContainer: React.FC>; } declare module "babylonjs-inspector/nodeGraphSystem/typeLedger" { import { INodeContainer } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeContainer"; import { INodeData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData"; import { IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; import { NodePort } from "babylonjs-inspector/nodeGraphSystem/nodePort"; export class TypeLedger { static PortDataBuilder: (port: NodePort, nodeContainer: INodeContainer) => IPortData; static NodeDataBuilder: (data: any, nodeContainer: INodeContainer) => INodeData; } } declare module "babylonjs-inspector/nodeGraphSystem/tools" { import { GraphCanvasComponent } from "babylonjs-inspector/nodeGraphSystem/graphCanvas"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { NodeLink } from "babylonjs-inspector/nodeGraphSystem/nodeLink"; import { FramePortData } from "babylonjs-inspector/nodeGraphSystem/types/framePortData"; export const IsFramePortData: (variableToCheck: any) => variableToCheck is FramePortData; export const RefreshNode: (node: GraphNode, visitedNodes?: Set, visitedLinks?: Set, canvas?: GraphCanvasComponent) => void; export const BuildFloatUI: (container: HTMLDivElement, document: Document, displayName: string, isInteger: boolean, source: any, propertyName: string, onChange: () => void, min?: number, max?: number, visualPropertiesRefresh?: Array<() => void>, additionalClassName?: string) => void; export function GetListOfAcceptedTypes>(types: T, allValue: number, autoDetectValue: number, port: { acceptedConnectionPointTypes: number[]; excludedConnectionPointTypes: number[]; type: number; }, skips?: number[]): string[]; export function GetConnectionErrorMessage>(sourceType: number, types: T, allValue: number, autoDetectValue: number, port: { acceptedConnectionPointTypes: number[]; excludedConnectionPointTypes: number[]; type: number; }, skips?: number[]): string; } declare module "babylonjs-inspector/nodeGraphSystem/stateManager" { import { Vector2 } from "babylonjs/Maths/math.vector"; import { Observable } from "babylonjs/Misc/observable"; import { Nullable } from "babylonjs/types"; import { FrameNodePort } from "babylonjs-inspector/nodeGraphSystem/frameNodePort"; import { GraphFrame } from "babylonjs-inspector/nodeGraphSystem/graphFrame"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { INodeContainer } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeContainer"; import { INodeData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData"; import { IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; import { ISelectionChangedOptions } from "babylonjs-inspector/nodeGraphSystem/interfaces/selectionChangedOptions"; import { NodePort } from "babylonjs-inspector/nodeGraphSystem/nodePort"; import { HistoryStack } from "babylonjs-inspector/historyStack"; import { Scene } from "babylonjs/scene"; export class StateManager { data: any; hostDocument: Document; lockObject: any; modalIsDisplayed: boolean; historyStack: HistoryStack; onSearchBoxRequiredObservable: Observable<{ x: number; y: number; }>; onSelectionChangedObservable: Observable>; onFrameCreatedObservable: Observable; onUpdateRequiredObservable: Observable; onGraphNodeRemovalObservable: Observable; onSelectionBoxMoved: Observable; onCandidateLinkMoved: Observable>; onCandidatePortSelectedObservable: Observable>; onNewNodeCreatedObservable: Observable; onRebuildRequiredObservable: Observable; onNodeMovedObservable: Observable; onErrorMessageDialogRequiredObservable: Observable; onExposePortOnFrameObservable: Observable; onGridSizeChanged: Observable; onNewBlockRequiredObservable: Observable<{ type: string; targetX: number; targetY: number; needRepositioning?: boolean; smartAdd?: boolean; }>; onHighlightNodeObservable: Observable<{ data: any; active: boolean; }>; onPreviewCommandActivated: Observable; exportData: (data: any, frame?: Nullable) => string; isElbowConnectionAllowed: (nodeA: FrameNodePort | NodePort, nodeB: FrameNodePort | NodePort) => boolean; isDebugConnectionAllowed: (nodeA: FrameNodePort | NodePort, nodeB: FrameNodePort | NodePort) => boolean; applyNodePortDesign: (data: IPortData, element: HTMLElement, imgHost: HTMLImageElement, pip: HTMLDivElement) => boolean; getPortColor: (portData: IPortData) => string; storeEditorData: (serializationObject: any, frame?: Nullable) => void; getEditorDataMap: () => { [key: number]: number; }; getScene?: () => Scene; createDefaultInputData: (rootData: any, portData: IPortData, nodeContainer: INodeContainer) => Nullable<{ data: INodeData; name: string; }>; private _isRebuildQueued; queueRebuildCommand(): void; } } declare module "babylonjs-inspector/nodeGraphSystem/searchBox" { import * as React from "react"; import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; import "babylonjs-inspector/nodeGraphSystem/searchBox.scss"; export interface ISearchBoxComponentProps { stateManager: StateManager; } /** * The search box component. */ export class SearchBoxComponent extends React.Component { private _handleEscKey; private _targetX; private _targetY; private _nodes; constructor(props: ISearchBoxComponentProps); hide(): void; onFilterChange(evt: React.ChangeEvent): void; onNewNodeRequested(name: string): void; onKeyDown(evt: React.KeyboardEvent): void; } } declare module "babylonjs-inspector/nodeGraphSystem/propertyLedger" { import { ComponentClass } from "react"; import { IPropertyComponentProps } from "babylonjs-inspector/nodeGraphSystem/interfaces/propertyComponentProps"; export class PropertyLedger { static DefaultControl: ComponentClass; static RegisteredControls: { [key: string]: ComponentClass; }; } } declare module "babylonjs-inspector/nodeGraphSystem/nodePort" { import { Nullable } from "babylonjs/types"; import { Observer } from "babylonjs/Misc/observable"; import { Vector2 } from "babylonjs/Maths/math.vector"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; import { ISelectionChangedOptions } from "babylonjs-inspector/nodeGraphSystem/interfaces/selectionChangedOptions"; import { FrameNodePort } from "babylonjs-inspector/nodeGraphSystem/frameNodePort"; import { IDisplayManager } from "babylonjs-inspector/nodeGraphSystem/interfaces/displayManager"; import { type IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; export class NodePort { portData: IPortData; node: GraphNode; protected _element: HTMLDivElement; protected _portContainer: HTMLElement; protected _imgHost: HTMLImageElement; protected _pip: HTMLDivElement; protected _stateManager: StateManager; protected _portLabelElement: Element; protected _onCandidateLinkMovedObserver: Nullable>>; protected _onSelectionChangedObserver: Nullable>>; protected _exposedOnFrame: boolean; protected _portUIcontainer?: HTMLDivElement; delegatedPort: Nullable; get element(): HTMLDivElement; get container(): HTMLElement; get portName(): string; set portName(newName: string); get disabled(): boolean; hasLabel(): boolean; get exposedOnFrame(): boolean; set exposedOnFrame(value: boolean); get exposedPortPosition(): number; set exposedPortPosition(value: number); private _isConnectedToNodeOutsideOfFrame; refresh(): void; constructor(portContainer: HTMLElement, portData: IPortData, node: GraphNode, stateManager: StateManager, portUIcontainer?: HTMLDivElement); dispose(): void; static CreatePortElement(portData: IPortData, node: GraphNode, root: HTMLElement, displayManager: Nullable, stateManager: StateManager): NodePort; } } declare module "babylonjs-inspector/nodeGraphSystem/nodeLink" { import { Observable } from "babylonjs/Misc/observable"; import { FrameNodePort } from "babylonjs-inspector/nodeGraphSystem/frameNodePort"; import { NodePort } from "babylonjs-inspector/nodeGraphSystem/nodePort"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { GraphCanvasComponent } from "babylonjs-inspector/nodeGraphSystem/graphCanvas"; export class NodeLink { private _graphCanvas; private _portA; private _portB?; private _nodeA; private _nodeB?; private _path; private _selectionPath; private _onSelectionChangedObserver; private _isVisible; private _isTargetCandidate; private _gradient; onDisposedObservable: Observable; get isTargetCandidate(): boolean; set isTargetCandidate(value: boolean); get isVisible(): boolean; set isVisible(value: boolean); get portA(): FrameNodePort | NodePort; get portB(): FrameNodePort | NodePort | undefined; get nodeA(): GraphNode; get nodeB(): GraphNode | undefined; intersectsWith(rect: DOMRect): boolean; update(endX?: number, endY?: number, straight?: boolean): void; get path(): SVGPathElement; get selectionPath(): SVGPathElement; constructor(graphCanvas: GraphCanvasComponent, portA: NodePort, nodeA: GraphNode, portB?: NodePort, nodeB?: GraphNode); onClick(evt: MouseEvent): void; dispose(notify?: boolean): void; } } declare module "babylonjs-inspector/nodeGraphSystem/nodeLedger" { export class NodeLedger { static RegisteredNodeNames: string[]; static NameFormatter: (name: string) => string; } } declare module "babylonjs-inspector/nodeGraphSystem/graphNode" { import { Nullable } from "babylonjs/types"; import { GraphCanvasComponent } from "babylonjs-inspector/nodeGraphSystem/graphCanvas"; import { NodePort } from "babylonjs-inspector/nodeGraphSystem/nodePort"; import { GraphFrame } from "babylonjs-inspector/nodeGraphSystem/graphFrame"; import { NodeLink } from "babylonjs-inspector/nodeGraphSystem/nodeLink"; import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; import { INodeData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData"; import { IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; import { IEditablePropertyOption } from "babylonjs/Decorators/nodeDecorator"; export class GraphNode { content: INodeData; private static _IdGenerator; private _visual; private _headerContainer; private _headerIcon; private _headerIconImg; private _headerCollapseImg; private _header; private _headerCollapse; private _connections; private _optionsContainer; private _inputsContainer; private _outputsContainer; private _content; private _comments; private _executionTime; private _selectionBorder; private _inputPorts; private _outputPorts; private _links; private _x; private _y; private _gridAlignedX; private _gridAlignedY; private _mouseStartPointX; private _mouseStartPointY; private _stateManager; private _onSelectionChangedObserver; private _onSelectionBoxMovedObserver; private _onFrameCreatedObserver; private _onUpdateRequiredObserver; private _onHighlightNodeObserver; private _ownerCanvas; private _displayManager; private _isVisible; private _enclosingFrameId; private _visualPropertiesRefresh; private _lastClick; addClassToVisual(className: string): void; removeClassFromVisual(className: string): void; get isCollapsed(): boolean; get isVisible(): boolean; set isVisible(value: boolean); private _upateNodePortNames; get outputPorts(): NodePort[]; get inputPorts(): NodePort[]; get links(): NodeLink[]; get gridAlignedX(): number; get gridAlignedY(): number; get x(): number; set x(value: number); get y(): number; set y(value: number); get width(): number; get height(): number; get id(): number; get name(): string; get enclosingFrameId(): number; set enclosingFrameId(value: number); setIsSelected(value: boolean, marqueeSelection: boolean): void; get rootElement(): HTMLDivElement; constructor(content: INodeData, stateManager: StateManager); isOverlappingFrame(frame: GraphFrame): boolean; getPortForPortData(portData: IPortData): NodePort | null; getPortDataForPortDataContent(data: any): IPortData | null; getLinksForPortDataContent(data: any): NodeLink[]; getLinksForPortData(portData: IPortData): NodeLink[]; private _refreshFrames; _refreshLinks(): void; refresh(): void; private _expand; private _searchMiddle; private _onDown; cleanAccumulation(useCeil?: boolean): void; private _onUp; private _onMove; renderProperties(): Nullable; _forceRebuild(source: any, propertyName: string, notifiers?: IEditablePropertyOption["notifiers"]): void; private _isCollapsed; /** * Collapse the node */ collapse(): void; /** * Expand the node */ expand(): void; private _portUICount; private _buildInputPorts; appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void; dispose(): void; } } declare module "babylonjs-inspector/nodeGraphSystem/graphFrame" { import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { GraphCanvasComponent } from "babylonjs-inspector/nodeGraphSystem/graphCanvas"; import { Nullable } from "babylonjs/types"; import { Observable } from "babylonjs/Misc/observable"; import { Color3 } from "babylonjs/Maths/math.color"; import { FrameNodePort } from "babylonjs-inspector/nodeGraphSystem/frameNodePort"; import { IFrameData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeLocationInfo"; export enum FramePortPosition { Top = 0, Middle = 1, Bottom = 2 } export class GraphFrame { private readonly _collapsedWidth; private static _FrameCounter; private static _FramePortCounter; private _name; private _color; private _x; private _y; private _gridAlignedX; private _gridAlignedY; private _width; private _height; element: HTMLDivElement; private _borderElement; private _headerElement; private _headerTextElement; private _headerCollapseElement; private _headerCloseElement; private _headerFocusElement; private _commentsElement; private _portContainer; private _outputPortContainer; private _inputPortContainer; private _nodes; private _ownerCanvas; private _mouseStartPointX; private _mouseStartPointY; private _onSelectionChangedObserver; private _onGraphNodeRemovalObserver; private _onExposePortOnFrameObserver; private _onNodeLinkDisposedObservers; private _isCollapsed; private _frameInPorts; private _frameOutPorts; private _controlledPorts; private _exposedInPorts; private _exposedOutPorts; private _id; private _comments; private _frameIsResizing; private _resizingDirection; private _minFrameHeight; private _minFrameWidth; private _mouseXLimit; onExpandStateChanged: Observable; private readonly _closeSVG; private readonly _expandSVG; private readonly _collapseSVG; private readonly _focusSVG; get id(): number; get isCollapsed(): boolean; private _createInputPort; private _markFramePortPositions; private _createFramePorts; private _removePortFromExposedWithNode; private _removePortFromExposedWithLink; private _createInputPorts; private _createOutputPorts; redrawFramePorts(): void; set isCollapsed(value: boolean); get nodes(): GraphNode[]; get ports(): FrameNodePort[]; get name(): string; set name(value: string); get color(): Color3; set color(value: Color3); get x(): number; set x(value: number); get y(): number; set y(value: number); get width(): number; set width(value: number); get height(): number; set height(value: number); get comments(): string; set comments(comments: string); constructor(candidate: Nullable, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean); private _isFocused; /** * Enter/leave focus mode */ switchFocusMode(): void; refresh(): void; addNode(node: GraphNode): void; removeNode(node: GraphNode): void; syncNode(node: GraphNode): void; cleanAccumulation(): void; private _onDown; move(newX: number, newY: number, align?: boolean): void; private _onUp; _moveFrame(offsetX: number, offsetY: number): void; private _onMove; moveFramePortUp(nodePort: FrameNodePort): void; private _movePortUp; moveFramePortDown(nodePort: FrameNodePort): void; private _movePortDown; private _initResizing; private _cleanUpResizing; private _updateMinHeightWithComments; private _isResizingTop; private _isResizingRight; private _isResizingBottom; private _isResizingLeft; private _onRightHandlePointerDown; private _onRightHandlePointerMove; private _moveRightHandle; private _onRightHandlePointerUp; private _onBottomHandlePointerDown; private _onBottomHandlePointerMove; private _moveBottomHandle; private _onBottomHandlePointerUp; private _onLeftHandlePointerDown; private _onLeftHandlePointerMove; private _moveLeftHandle; private _onLeftHandlePointerUp; private _onTopHandlePointerDown; private _onTopHandlePointerMove; private _moveTopHandle; private _onTopHandlePointerUp; private _onTopRightHandlePointerDown; private _onTopRightHandlePointerMove; private _moveTopRightHandle; private _onTopRightHandlePointerUp; private _onBottomRightHandlePointerDown; private _onBottomRightHandlePointerMove; private _moveBottomRightHandle; private _onBottomRightHandlePointerUp; private _onBottomLeftHandlePointerDown; private _onBottomLeftHandlePointerMove; private _moveBottomLeftHandle; private _onBottomLeftHandlePointerUp; private _onTopLeftHandlePointerDown; private _onTopLeftHandlePointerMove; private _moveTopLeftHandle; private _onTopLeftHandlePointerUp; private _expandLeft; private _expandTop; private _expandRight; private _expandBottom; dispose(): void; private _serializePortData; serialize(saveCollapsedState: boolean): IFrameData; export(): void; adjustPorts(): void; static Parse(serializationData: IFrameData, canvas: GraphCanvasComponent, map?: { [key: number]: number; }): GraphFrame; } } declare module "babylonjs-inspector/nodeGraphSystem/graphCanvas" { import * as React from "react"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { Nullable } from "babylonjs/types"; import { NodeLink } from "babylonjs-inspector/nodeGraphSystem/nodeLink"; import { NodePort } from "babylonjs-inspector/nodeGraphSystem/nodePort"; import { GraphFrame } from "babylonjs-inspector/nodeGraphSystem/graphFrame"; import { IEditorData, IFrameData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeLocationInfo"; import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; import { INodeData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData"; import { IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; import { INodeContainer } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeContainer"; export interface IGraphCanvasComponentProps { stateManager: StateManager; onEmitNewNode: (nodeData: INodeData) => GraphNode; } export class GraphCanvasComponent extends React.Component implements INodeContainer { static readonly NodeWidth: number; private readonly _minZoom; private readonly _maxZoom; private _hostCanvasRef; private _hostCanvas; private _graphCanvasRef; private _graphCanvas; private _selectionContainerRef; private _selectionContainer; private _frameContainerRef; private _frameContainer; private _svgCanvasRef; private _svgCanvas; private _rootContainerRef; private _rootContainer; private _nodes; private _links; private _mouseStartPointX; private _mouseStartPointY; private _dropPointX; private _dropPointY; private _selectionStartX; private _selectionStartY; private _candidateLinkedHasMoved; private _x; private _y; private _lastx; private _lasty; private _zoom; private _selectedNodes; private _selectedLink; private _selectedPort; private _candidateLink; private _candidatePort; private _gridSize; private _selectionBox; private _selectedFrames; private _frameCandidate; private _frames; private _nodeDataContentList; private _altKeyIsPressed; private _shiftKeyIsPressed; private _multiKeyIsPressed; private _oldY; _frameIsMoving: boolean; _isLoading: boolean; _targetLinkCandidate: Nullable; private _copiedNodes; private _copiedFrames; get gridSize(): number; set gridSize(value: number); get stateManager(): StateManager; get nodes(): GraphNode[]; get links(): NodeLink[]; get frames(): GraphFrame[]; get zoom(): number; set zoom(value: number); get x(): number; set x(value: number); get y(): number; set y(value: number); get selectedNodes(): GraphNode[]; get selectedLink(): Nullable; get selectedFrames(): GraphFrame[]; get selectedPort(): Nullable; get canvasContainer(): HTMLDivElement; get hostCanvas(): HTMLDivElement; get svgCanvas(): HTMLElement; get selectionContainer(): HTMLDivElement; get frameContainer(): HTMLDivElement; private _selectedFrameAndNodesConflict; constructor(props: IGraphCanvasComponentProps); populateConnectedEntriesBeforeRemoval(item: GraphNode, items: GraphNode[], inputs: Nullable[], outputs: Nullable[]): void; automaticRewire(inputs: Nullable[], outputs: Nullable[], firstOnly?: boolean): void; smartAddOverLink(node: GraphNode, link: NodeLink): void; smartAddOverNode(node: GraphNode, source: GraphNode): void; deleteSelection(onRemove: (nodeData: INodeData) => void, autoReconnect?: boolean): void; handleKeyDown(evt: KeyboardEvent, onRemove: (nodeData: INodeData) => void, mouseLocationX: number, mouseLocationY: number, dataGenerator: (nodeData: INodeData) => any, rootElement: HTMLDivElement): void; pasteSelection(copiedNodes: GraphNode[], currentX: number, currentY: number, dataGenerator: (nodeData: INodeData) => any, selectNew?: boolean): GraphNode[]; reconnectNewNodes(nodeIndex: number, newNodes: GraphNode[], sourceNodes: GraphNode[], done: boolean[]): void; getCachedData(): any[]; removeDataFromCache(data: any): void; createNodeFromObject(nodeData: INodeData, onNodeCreated: (data: any) => void, recursion?: boolean): GraphNode; getGridPosition(position: number, useCeil?: boolean): number; getGridPositionCeil(position: number): number; updateTransform(): void; onKeyUp(): void; findNodeFromData(data: any): GraphNode; reset(): void; connectPorts(pointA: IPortData, pointB: IPortData): void; removeLink(link: NodeLink): void; appendNode(nodeData: INodeData): GraphNode; distributeGraph(): void; componentDidMount(): void; onMove(evt: React.PointerEvent): void; onDown(evt: React.PointerEvent): void; onUp(evt: React.PointerEvent): void; onWheel(evt: React.WheelEvent): void; zoomToFit(): void; processCandidatePort(): void; connectNodes(nodeA: GraphNode, pointA: IPortData, nodeB: GraphNode, pointB: IPortData): void; drop(newNode: GraphNode, targetX: number, targetY: number, offsetX: number, offsetY: number): void; processEditorData(editorData: IEditorData): void; reOrganize(editorData?: Nullable, isImportingAFrame?: boolean): void; addFrame(frameData: IFrameData): void; } } declare module "babylonjs-inspector/nodeGraphSystem/frameNodePort" { import { IDisplayManager } from "babylonjs-inspector/nodeGraphSystem/interfaces/displayManager"; import { Observable } from "babylonjs/Misc/observable"; import { Nullable } from "babylonjs/types"; import { IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; import { NodePort } from "babylonjs-inspector/nodeGraphSystem/nodePort"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { FramePortPosition } from "babylonjs-inspector/nodeGraphSystem/graphFrame"; import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; export class FrameNodePort extends NodePort { portData: IPortData; node: GraphNode; private _parentFrameId; private _isInput; private _framePortPosition; private _framePortId; private _onFramePortPositionChangedObservable; get parentFrameId(): number; get onFramePortPositionChangedObservable(): Observable; get isInput(): boolean; get framePortId(): number; get framePortPosition(): FramePortPosition; set framePortPosition(position: FramePortPosition); constructor(portContainer: HTMLElement, portData: IPortData, node: GraphNode, stateManager: StateManager, isInput: boolean, framePortId: number, parentFrameId: number); static CreateFrameNodePortElement(portData: IPortData, node: GraphNode, root: HTMLElement, displayManager: Nullable, stateManager: StateManager, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort; } } declare module "babylonjs-inspector/nodeGraphSystem/displayLedger" { export class DisplayLedger { static RegisteredControls: { [key: string]: any; }; } } declare module "babylonjs-inspector/nodeGraphSystem/automaticProperties" { import { IEditablePropertyOption } from "babylonjs/Decorators/nodeDecorator"; import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; /** * Function used to force a rebuild of the node system * @param source source object * @param stateManager defines the state manager to use * @param propertyName name of the property that has been changed * @param notifiers list of notifiers to use */ export function ForceRebuild(source: any, stateManager: StateManager, propertyName: string, notifiers?: IEditablePropertyOption["notifiers"]): void; } declare module "babylonjs-inspector/nodeGraphSystem/types/framePortData" { import { GraphFrame } from "babylonjs-inspector/nodeGraphSystem/graphFrame"; import { FrameNodePort } from "babylonjs-inspector/nodeGraphSystem/frameNodePort"; export type FramePortData = { frame: GraphFrame; port: FrameNodePort; }; } declare module "babylonjs-inspector/nodeGraphSystem/interfaces/selectionChangedOptions" { import { Nullable } from "babylonjs/types"; import { GraphFrame } from "babylonjs-inspector/nodeGraphSystem/graphFrame"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { NodeLink } from "babylonjs-inspector/nodeGraphSystem/nodeLink"; import { NodePort } from "babylonjs-inspector/nodeGraphSystem/nodePort"; import { FramePortData } from "babylonjs-inspector/nodeGraphSystem/types/framePortData"; export interface ISelectionChangedOptions { selection: Nullable; forceKeepSelection?: boolean; marqueeSelection?: boolean; } } declare module "babylonjs-inspector/nodeGraphSystem/interfaces/propertyComponentProps" { import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; import { INodeData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData"; export interface IPropertyComponentProps { stateManager: StateManager; nodeData: INodeData; } } declare module "babylonjs-inspector/nodeGraphSystem/interfaces/portData" { import { Nullable } from "babylonjs/types"; import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; export enum PortDataDirection { /** Input */ Input = 0, /** Output */ Output = 1 } export enum PortDirectValueTypes { Float = 0, Int = 1 } export interface IPortDirectValueDefinition { /** * Gets the source object */ source: any; /** * Gets the property name used to store the value */ propertyName: string; /** * Gets or sets the min value accepted for this point if nothing is connected */ valueMin: Nullable; /** * Gets or sets the max value accepted for this point if nothing is connected */ valueMax: Nullable; /** * Gets or sets the type of the value */ valueType: PortDirectValueTypes; } export interface IPortData { data: any; name: string; internalName: string; isExposedOnFrame: boolean; exposedPortPosition: number; isConnected: boolean; direction: PortDataDirection; ownerData: any; connectedPort: Nullable; needDualDirectionValidation: boolean; hasEndpoints: boolean; endpoints: Nullable; directValueDefinition?: IPortDirectValueDefinition; updateDisplayName: (newName: string) => void; canConnectTo: (port: IPortData) => boolean; connectTo: (port: IPortData) => void; disconnectFrom: (port: IPortData) => void; checkCompatibilityState(port: IPortData): number; getCompatibilityIssueMessage(issue: number, targetNode: GraphNode, targetPort: IPortData): string; } } declare module "babylonjs-inspector/nodeGraphSystem/interfaces/nodeLocationInfo" { export interface INodeLocationInfo { blockId: number; x: number; y: number; isCollapsed: boolean; } export interface IFrameData { x: number; y: number; width: number; height: number; color: number[]; name: string; isCollapsed: boolean; blocks: number[]; comments: string; } export interface IEditorData { locations: INodeLocationInfo[]; x: number; y: number; zoom: number; frames?: IFrameData[]; map?: { [key: number]: number; }; } } declare module "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData" { import { Nullable } from "babylonjs/types"; import { IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; export interface INodeData { data: any; name: string; uniqueId: number; isInput: boolean; comments: string; executionTime?: number; refreshCallback?: () => void; prepareHeaderIcon: (iconDiv: HTMLDivElement, img: HTMLImageElement) => void; getClassName: () => string; dispose: () => void; getPortByName: (name: string) => Nullable; inputs: IPortData[]; outputs: IPortData[]; invisibleEndpoints?: Nullable; isConnectedToOutput?: () => boolean; isActive?: boolean; setIsActive?: (value: boolean) => void; canBeActivated?: boolean; onInputCountChanged?: () => void; } } declare module "babylonjs-inspector/nodeGraphSystem/interfaces/nodeContainer" { import { GraphNode } from "babylonjs-inspector/nodeGraphSystem/graphNode"; import { INodeData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData"; export interface INodeContainer { nodes: GraphNode[]; appendNode(data: INodeData): GraphNode; } } declare module "babylonjs-inspector/nodeGraphSystem/interfaces/displayManager" { import { Nullable } from "babylonjs/types"; import { StateManager } from "babylonjs-inspector/nodeGraphSystem/stateManager"; import { INodeData } from "babylonjs-inspector/nodeGraphSystem/interfaces/nodeData"; import { IPortData } from "babylonjs-inspector/nodeGraphSystem/interfaces/portData"; export interface VisualContentDescription { [key: string]: HTMLElement; } export interface IDisplayManager { getHeaderClass(data: INodeData): string; shouldDisplayPortLabels(data: IPortData): boolean; updatePreviewContent(data: INodeData, contentArea: HTMLDivElement): void; updateFullVisualContent?(data: INodeData, visualContent: VisualContentDescription): void; getBackgroundColor(data: INodeData): string; getHeaderText(data: INodeData): string; onSelectionChanged?(data: INodeData, selectedData: Nullable, manager: StateManager): void; onDispose?(nodeData: INodeData, manager: StateManager): void; } } declare module "babylonjs-inspector/lines/vector4LineComponent" { import * as React from "react"; import { Vector4 } from "babylonjs/Maths/math.vector"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IVector4LineComponentProps { label: string; target?: any; propertyName?: string; step?: number; onChange?: (newvalue: Vector4) => void; useEuler?: boolean; onPropertyChangedObservable?: Observable; icon?: string; iconLabel?: string; value?: Vector4; lockObject: LockObject; } export class Vector4LineComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: IVector4LineComponentProps); getCurrentValue(): any; shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: { isExpanded: boolean; value: Vector4; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(previousValue: Vector4): void; updateVector4(): void; updateStateX(value: number): void; updateStateY(value: number): void; updateStateZ(value: number): void; updateStateW(value: number): void; } export {}; } declare module "babylonjs-inspector/lines/vector3LineComponent" { import * as React from "react"; import { Vector3 } from "babylonjs/Maths/math.vector"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IVector3LineComponentProps { label: string; target?: any; propertyName?: string; step?: number; onChange?: (newvalue: Vector3) => void; useEuler?: boolean; onPropertyChangedObservable?: Observable; noSlider?: boolean; icon?: string; iconLabel?: string; lockObject: LockObject; directValue?: Vector3; additionalCommands?: JSX.Element[]; } export class Vector3LineComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: IVector3LineComponentProps); getCurrentValue(): any; shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: { isExpanded: boolean; value: Vector3; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(previousValue: Vector3): void; updateVector3(): void; updateStateX(value: number): void; updateStateY(value: number): void; updateStateZ(value: number): void; onCopyClick(): string; } export {}; } declare module "babylonjs-inspector/lines/vector2LineComponent" { import * as React from "react"; import { Vector2 } from "babylonjs/Maths/math.vector"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IVector2LineComponentProps { label: string; target: any; propertyName: string; step?: number; onChange?: (newvalue: Vector2) => void; onPropertyChangedObservable?: Observable; icon?: string; iconLabel?: string; lockObject: LockObject; } export class Vector2LineComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: IVector2LineComponentProps); shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: { isExpanded: boolean; value: Vector2; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(previousValue: Vector2): void; updateStateX(value: number): void; updateStateY(value: number): void; } export {}; } declare module "babylonjs-inspector/lines/valueLineComponent" { import * as React from "react"; interface IValueLineComponentProps { label: string; value: number; color?: string; fractionDigits?: number; units?: string; icon?: string; iconLabel?: string; } export class ValueLineComponent extends React.Component { constructor(props: IValueLineComponentProps); } export {}; } declare module "babylonjs-inspector/lines/unitButton" { interface IUnitButtonProps { unit: string; locked?: boolean; onClick?: (unit: string) => void; } export {}; } declare module "babylonjs-inspector/lines/textureButtonLineComponent" { import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture"; import { Scene } from "babylonjs/scene"; import * as React from "react"; interface ITextureButtonLineProps { label: string; scene: Scene; onClick: (file: File) => void; onLink: (texture: BaseTexture) => void; accept: string; } interface ITextureButtonLineState { isOpen: boolean; } export class TextureButtonLine extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: ITextureButtonLineProps); onChange(evt: any): void; } export {}; } declare module "babylonjs-inspector/lines/textLineComponent" { import * as React from "react"; interface ITextLineComponentProps { label?: string; value?: string; color?: string; underline?: boolean; onLink?: () => void; url?: string; ignoreValue?: boolean; additionalClass?: string; icon?: string; iconLabel?: string; tooltip?: string; onCopy?: true | (() => string); } export class TextLineComponent extends React.Component { constructor(props: ITextLineComponentProps); onLink(): void; copyFn(): (() => string) | undefined; } export {}; } declare module "babylonjs-inspector/lines/textInputLineComponent" { import { ReactNode, KeyboardEvent } from "react"; import { Component } from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface ITextInputLineComponentProps { label?: string; lockObject?: LockObject; target?: any; propertyName?: string; value?: string; onChange?: (value: string) => void; onPropertyChangedObservable?: Observable; icon?: string; iconLabel?: string; noUnderline?: boolean; numbersOnly?: boolean; delayInput?: boolean; arrows?: boolean; arrowsIncrement?: (amount: number) => void; step?: number; numeric?: boolean; roundValues?: boolean; min?: number; max?: number; placeholder?: string; unit?: ReactNode; validator?: (value: string) => boolean; multilines?: boolean; throttlePropertyChangedNotification?: boolean; throttlePropertyChangedNotificationDelay?: number; disabled?: boolean; } export class TextInputLineComponent extends Component { private _localChange; constructor(props: ITextInputLineComponentProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: { value: string; dragging: boolean; }): boolean; raiseOnPropertyChanged(newValue: string, previousValue: string): void; getCurrentNumericValue(value: string): number; updateValue(value: string, valueToValidate?: string): void; incrementValue(amount: number): void; onKeyDown(event: KeyboardEvent): void; } } declare module "babylonjs-inspector/lines/targetsProxy" { import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { Observable } from "babylonjs/Misc/observable"; export const conflictingValuesPlaceholder = "\u2014"; /** * * @param targets a list of selected targets * @param onPropertyChangedObservable * @param getProperty * @returns a proxy object that can be passed as a target into the input */ export function makeTargetsProxy(targets: Type[], onPropertyChangedObservable?: Observable, getProperty?: (target: Type, property: keyof Type) => any): any; } declare module "babylonjs-inspector/lines/sliderLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface ISliderLineComponentProps { label: string; target?: any; propertyName?: string; minimum: number; maximum: number; step: number; directValue?: number; useEuler?: boolean; onChange?: (value: number) => void; onInput?: (value: number) => void; onPropertyChangedObservable?: Observable; decimalCount?: number; margin?: boolean; icon?: string; iconLabel?: string; lockObject: LockObject; unit?: React.ReactNode; allowOverflow?: boolean; } export class SliderLineComponent extends React.Component { private _localChange; constructor(props: ISliderLineComponentProps); shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: { value: number; }): boolean; onChange(newValueString: any): void; onInput(newValueString: any): void; prepareDataToRead(value: number): number; onCopyClick(): void; } export {}; } declare module "babylonjs-inspector/lines/radioLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; interface IRadioButtonLineComponentProps { onSelectionChangedObservable: Observable; label: string; isSelected: () => boolean; onSelect: () => void; icon?: string; iconLabel?: string; } export class RadioButtonLineComponent extends React.Component { private _onSelectionChangedObserver; constructor(props: IRadioButtonLineComponentProps); componentDidMount(): void; componentWillUnmount(): void; onChange(): void; } export {}; } declare module "babylonjs-inspector/lines/optionsLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { IInspectableOptions } from "babylonjs/Misc/iInspectable"; export const Null_Value: number; export interface IOptionsLineProps { label: string; target: any; propertyName: string; options: IInspectableOptions[]; noDirectUpdate?: boolean; onSelect?: (value: number | string) => void; extractValue?: (target: any) => number | string; onPropertyChangedObservable?: Observable; allowNullValue?: boolean; icon?: string; iconLabel?: string; className?: string; valuesAreStrings?: boolean; defaultIfNull?: number; } export class OptionsLine extends React.Component { private _localChange; private _remapValueIn; private _remapValueOut; private _getValue; constructor(props: IOptionsLineProps); shouldComponentUpdate(nextProps: IOptionsLineProps, nextState: { value: number; }): boolean; raiseOnPropertyChanged(newValue: number, previousValue: number): void; setValue(value: string | number): void; updateValue(valueString: string): void; onCopyClickStr(): string; private _renderFluent; private _renderOriginal; } } declare module "babylonjs-inspector/lines/numericInputComponent" { import * as React from "react"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface INumericInputProps { label: string; labelTooltip?: string; value: number; step?: number; onChange: (value: number) => void; precision?: number; icon?: string; iconLabel?: string; lockObject: LockObject; } export class NumericInput extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: INumericInputProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: INumericInputProps, nextState: { value: string; }): boolean; updateValue(valueString: string): void; onBlur(): void; incrementValue(amount: number): void; onKeyDown(evt: React.KeyboardEvent): void; } export {}; } declare module "babylonjs-inspector/lines/messageLineComponent" { import * as React from "react"; interface IMessageLineComponentProps { text: string; color?: string; icon?: any; } export class MessageLineComponent extends React.Component { constructor(props: IMessageLineComponentProps); } export {}; } declare module "babylonjs-inspector/lines/matrixLineComponent" { import * as React from "react"; import { Vector3, Vector4 } from "babylonjs/Maths/math.vector"; import { Matrix } from "babylonjs/Maths/math.vector"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IMatrixLineComponentProps { label: string; target: any; propertyName: string; step?: number; onChange?: (newValue: Matrix) => void; onModeChange?: (mode: number) => void; onPropertyChangedObservable?: Observable; mode?: number; lockObject: LockObject; } export class MatrixLineComponent extends React.Component { private _localChange; constructor(props: IMatrixLineComponentProps); shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: { value: Matrix; mode: number; angle: number; }): boolean; raiseOnPropertyChanged(previousValue: Vector3): void; updateMatrix(): void; updateRow(value: Vector4, row: number): void; updateBasedOnMode(value: number): void; } export {}; } declare module "babylonjs-inspector/lines/linkButtonComponent" { import * as React from "react"; interface ILinkButtonComponentProps { label: string; buttonLabel: string; url?: string; onClick: () => void; icon?: any; onIconClick?: () => void; } export class LinkButtonComponent extends React.Component { constructor(props: ILinkButtonComponentProps); onLink(): void; } export {}; } declare module "babylonjs-inspector/lines/lineWithFileButtonComponent" { import * as React from "react"; interface ILineWithFileButtonComponentProps { title: string; closed?: boolean; multiple?: boolean; label: string; iconImage: any; onIconClick: (file: File) => void; accept: string; uploadName?: string; } export class LineWithFileButtonComponent extends React.Component { private _uploadRef; constructor(props: ILineWithFileButtonComponentProps); onChange(evt: any): void; switchExpandedState(): void; } export {}; } declare module "babylonjs-inspector/lines/lineContainerComponent" { import * as React from "react"; import { ISelectedLineContainer } from "babylonjs-inspector/lines/iSelectedLineContainer"; interface ILineContainerComponentProps { selection?: ISelectedLineContainer; title: string; children: any[] | any; closed?: boolean; } export class LineContainerComponent extends React.Component { constructor(props: ILineContainerComponentProps); switchExpandedState(): void; componentDidMount(): void; } export {}; } declare module "babylonjs-inspector/lines/inputArrowsComponent" { import * as React from "react"; interface IInputArrowsComponentProps { incrementValue: (amount: number) => void; setDragging: (dragging: boolean) => void; } export class InputArrowsComponent extends React.Component { private _arrowsRef; private _drag; private _releaseListener; private _lockChangeListener; } export {}; } declare module "babylonjs-inspector/lines/indentedTextLineComponent" { import * as React from "react"; interface IIndentedTextLineComponentProps { value?: string; color?: string; underline?: boolean; onLink?: () => void; url?: string; additionalClass?: string; } export class IndentedTextLineComponent extends React.Component { constructor(props: IIndentedTextLineComponentProps); onLink(): void; } export {}; } declare module "babylonjs-inspector/lines/iconComponent" { import * as React from "react"; interface IIconComponentProps { icon: string; label?: string; } export class IconComponent extends React.Component { } export {}; } declare module "babylonjs-inspector/lines/iconButtonLineComponent" { import * as React from "react"; export interface IIconButtonLineComponentProps { icon: string; onClick: () => void; tooltip: string; active?: boolean; } export class IconButtonLineComponent extends React.Component { constructor(props: IIconButtonLineComponentProps); } } declare module "babylonjs-inspector/lines/iSelectedLineContainer" { export interface ISelectedLineContainer { selectedLineContainerTitles: Array; selectedLineContainerTitlesNoFocus: Array; } } declare module "babylonjs-inspector/lines/hexLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IHexLineComponentProps { label: string; target: any; propertyName: string; lockObject?: LockObject; onChange?: (newValue: number) => void; isInteger?: boolean; replaySourceReplacement?: string; onPropertyChangedObservable?: Observable; additionalClass?: string; step?: string; digits?: number; useEuler?: boolean; min?: number; icon?: string; iconLabel?: string; } export class HexLineComponent extends React.Component { private _localChange; private _store; private _propertyChange; constructor(props: IHexLineComponentProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: IHexLineComponentProps, nextState: { value: string; }): boolean; raiseOnPropertyChanged(newValue: number, previousValue: number): void; convertToHexString(valueString: string): string; updateValue(valueString: string, raisePropertyChanged: boolean): void; lock(): void; unlock(): void; } export {}; } declare module "babylonjs-inspector/lines/floatLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface IFloatLineComponentProps { label: string; target: any; propertyName: string; lockObject: LockObject; onChange?: (newValue: number) => void; isInteger?: boolean; onPropertyChangedObservable?: Observable; additionalClass?: string; step?: string; digits?: number; useEuler?: boolean; min?: number; max?: number; smallUI?: boolean; onEnter?: (newValue: number) => void; icon?: string; iconLabel?: string; defaultValue?: number; arrows?: boolean; unit?: React.ReactNode; onDragStart?: (newValue: number) => void; onDragStop?: (newValue: number) => void; disabled?: boolean; } export class FloatLineComponent extends React.Component { private _localChange; private _store; constructor(props: IFloatLineComponentProps); componentWillUnmount(): void; getValueString(value: any, props: IFloatLineComponentProps): string; shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: { value: string; dragging: boolean; }): boolean; raiseOnPropertyChanged(newValue: number, previousValue: number): void; updateValue(valueString: string): void; lock(): void; unlock(): void; incrementValue(amount: number, processStep?: boolean): void; onKeyDown(event: React.KeyboardEvent): void; onCopyClick(): void; } export {}; } declare module "babylonjs-inspector/lines/fileMultipleButtonLineComponent" { import * as React from "react"; interface IFileMultipleButtonLineComponentProps { label: string; onClick: (event: any) => void; accept: string; icon?: string; iconLabel?: string; } export class FileMultipleButtonLineComponent extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: IFileMultipleButtonLineComponentProps); onChange(evt: any): void; } export {}; } declare module "babylonjs-inspector/lines/fileButtonLineComponent" { import * as React from "react"; interface IFileButtonLineProps { label: string; onClick: (file: File) => void; accept: string; icon?: string; iconLabel?: string; } export class FileButtonLine extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: IFileButtonLineProps); onChange(evt: any): void; } export {}; } declare module "babylonjs-inspector/lines/draggableLineWithButtonComponent" { import * as React from "react"; export interface IDraggableLineWithButtonComponent { format: string; data: string; tooltip: string; iconImage: any; onIconClick: (value: string) => void; iconTitle: string; lenSuffixToRemove?: number; } export class DraggableLineWithButtonComponent extends React.Component { constructor(props: IDraggableLineWithButtonComponent); } } declare module "babylonjs-inspector/lines/draggableLineComponent" { import * as React from "react"; export interface IButtonLineComponentProps { format: string; data: string; tooltip: string; } export class DraggableLineComponent extends React.Component { constructor(props: IButtonLineComponentProps); } } declare module "babylonjs-inspector/lines/colorPickerComponent" { import * as React from "react"; import { Color4, Color3 } from "babylonjs/Maths/math.color"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColorPickerLineProps { value: Color4 | Color3; linearHint?: boolean; onColorChanged: (newOne: string) => void; icon?: string; iconLabel?: string; shouldPopRight?: boolean; lockObject?: LockObject; } interface IColorPickerComponentState { pickerEnabled: boolean; color: Color3 | Color4; hex: string; } export class ColorPickerLine extends React.Component { private _floatRef; private _floatHostRef; constructor(props: IColorPickerLineProps); syncPositions(): void; shouldComponentUpdate(nextProps: IColorPickerLineProps, nextState: IColorPickerComponentState): boolean; getHexString(props?: Readonly): string; componentDidUpdate(): void; componentDidMount(): void; } export {}; } declare module "babylonjs-inspector/lines/colorLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Color4 } from "babylonjs/Maths/math.color"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColorLineProps { label: string; target?: any; propertyName: string; onPropertyChangedObservable?: Observable; onChange?: () => void; isLinear?: boolean; icon?: string; iconLabel?: string; disableAlpha?: boolean; lockObject: LockObject; } interface IColorLineComponentState { isExpanded: boolean; color: Color4; } export class ColorLine extends React.Component { constructor(props: IColorLineProps); shouldComponentUpdate(nextProps: IColorLineProps, nextState: IColorLineComponentState): boolean; getValue(props?: Readonly): Color4; setColorFromString(colorString: string): void; setColor(newColor: Color4): void; switchExpandState(): void; updateStateR(value: number): void; updateStateG(value: number): void; updateStateB(value: number): void; updateStateA(value: number): void; private _convertToColor; private _toColor3; onCopyClick(): void; } export {}; } declare module "babylonjs-inspector/lines/color4LineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColor4LineComponentProps { label: string; target?: any; propertyName: string; onPropertyChangedObservable?: Observable; onChange?: () => void; isLinear?: boolean; icon?: string; iconLabel?: string; lockObject: LockObject; } export class Color4LineComponent extends React.Component { } } declare module "babylonjs-inspector/lines/color3LineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColor3LineComponentProps { label: string; target: any; propertyName: string; onPropertyChangedObservable?: Observable; isLinear?: boolean; icon?: string; lockObject: LockObject; iconLabel?: string; onChange?: () => void; } export class Color3LineComponent extends React.Component { } } declare module "babylonjs-inspector/lines/checkBoxLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; export interface ICheckBoxLineComponentProps { label?: string; target?: any; propertyName?: string; isSelected?: boolean | (() => boolean); onSelect?: (value: boolean) => void; onValueChanged?: () => void; onPropertyChangedObservable?: Observable; disabled?: boolean; icon?: string; iconLabel?: string; faIcons?: { enabled: any; disabled: any; }; large?: boolean; } export class CheckBoxLineComponent extends React.Component { private _localChange; constructor(props: ICheckBoxLineComponentProps); shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: { isSelected: boolean; isDisabled: boolean; isConflict: boolean; }): boolean; onChange(): void; onCopyClick(): void; } } declare module "babylonjs-inspector/lines/buttonLineComponent" { import * as React from "react"; export interface IButtonLineComponentProps { label: string; onClick: () => void; icon?: string; iconLabel?: string; isDisabled?: boolean; } export class ButtonLineComponent extends React.Component { constructor(props: IButtonLineComponentProps); } } declare module "babylonjs-inspector/lines/booleanLineComponent" { import * as React from "react"; export interface IBooleanLineComponentProps { label: string; value: boolean; icon?: string; iconLabel?: string; } export class BooleanLineComponent extends React.Component { constructor(props: IBooleanLineComponentProps); } } declare module "babylonjs-inspector/fluent/primitives/textarea" { import { FunctionComponent } from "react"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; export type TextareaProps = BaseComponentProps & { placeholder?: string; }; /** * This is a texarea box that stops propagation of change/keydown events * @param props * @returns */ export const Textarea: FunctionComponent; } declare module "babylonjs-inspector/fluent/primitives/syncedSlider" { import { FunctionComponent } from "react"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; export type SyncedSliderProps = BaseComponentProps & { min?: number; max?: number; step?: number; }; /** * Component which synchronizes a slider and an input field, allowing the user to change a value using either control * @param props * @returns SyncedSlider component */ export const SyncedSliderInput: FunctionComponent; } declare module "babylonjs-inspector/fluent/primitives/switch" { import { FunctionComponent } from "react"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; export type SwitchProps = BaseComponentProps; /** * This is a primitive fluent boolean switch component whose only knowledge is the shared styling across all tools * @param props * @returns Switch component */ export const Switch: FunctionComponent; } declare module "babylonjs-inspector/fluent/primitives/spinButton" { import { FunctionComponent } from "react"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; export type SpinButtonProps = BaseComponentProps; export const SpinButton: FunctionComponent; } declare module "babylonjs-inspector/fluent/primitives/link" { } declare module "babylonjs-inspector/fluent/primitives/input" { import { FunctionComponent } from "react"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; export type InputProps = BaseComponentProps & { step?: number; placeholder?: string; min?: number; max?: number; }; /** * This is an input text box that stops propagation of change events and sets its width based on the type of input (text or number) * @param props * @returns */ export const Input: FunctionComponent>; } declare module "babylonjs-inspector/fluent/primitives/dropdown" { import { FunctionComponent } from "react"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { Nullable } from "babylonjs/types"; type DropdownOptionValue = string | number; export type AcceptedDropdownValue = Nullable | undefined; export type DropdownOption = { /** * Defines the visible part of the option */ label: string; /** * Defines the value part of the option */ value: DropdownOptionValue; }; export type DropdownProps = BaseComponentProps & { options: DropdownOption[]; includeNullAs?: "null" | "undefined"; }; /** * Renders a fluent UI dropdown component for the options passed in, and an additional 'Not Defined' option if null is set to true * This component can handle both null and undefined values * @param props * @returns dropdown component */ export const Dropdown: FunctionComponent>; export {}; } declare module "babylonjs-inspector/fluent/primitives/colorPicker" { import { FunctionComponent } from "react"; import { Color3, Color4 } from "babylonjs/Maths/math.color"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; export type ColorPickerProps = { isLinearMode?: boolean; } & BaseComponentProps; export const ColorPickerPopup: FunctionComponent>; type HsvKey = "h" | "s" | "v"; export type InputHexProps = BaseComponentProps & { label?: string; linearHex?: boolean; isLinearMode?: boolean; }; /** * Component which displays the passed in color's HEX value, either in linearSpace (if linearHex is true) or in gamma space * When the hex color is changed by user, component calculates the new Color3/4 value and calls onChange * * Component uses the isLinearMode boolean to display an informative label regarding linear / gamma space * @param props - The properties for the InputHexField component. * @returns */ export const InputHexField: FunctionComponent; type InputHsvFieldProps = { color: Color3 | Color4; label: string; hsvKey: HsvKey; onChange: (color: Color3 | Color4) => void; max: number; scale?: number; }; /** * In the HSV (Hue, Saturation, Value) color model, Hue (H) ranges from 0 to 360 degrees, representing the color's position on the color wheel. * Saturation (S) ranges from 0 to 100%, indicating the intensity or purity of the color, with 0 being shades of gray and 100 being a fully saturated color. * Value (V) ranges from 0 to 100%, representing the brightness of the color, with 0 being black and 100 being the brightest. * @param props - The properties for the InputHsvField component. */ export const InputHsvField: FunctionComponent; export {}; } declare module "babylonjs-inspector/fluent/primitives/checkbox" { import { FunctionComponent } from "react"; import { BaseComponentProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; export type CheckboxProps = BaseComponentProps; /** * This is a primitive fluent checkbox that can both read and write checked state * @param props * @returns Checkbox component */ export const Checkbox: FunctionComponent; } declare module "babylonjs-inspector/fluent/primitives/accordion" { import { FunctionComponent, PropsWithChildren } from "react"; export type AccordionSectionProps = { title: string; collapseByDefault?: boolean; }; export const AccordionSection: FunctionComponent>; export const Accordion: FunctionComponent; } declare module "babylonjs-inspector/fluent/hoc/vectorPropertyLine" { import { FunctionComponent } from "react"; import { BaseComponentProps, PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { Quaternion, Vector4 } from "babylonjs/Maths/math.vector"; import { Vector3 } from "babylonjs/Maths/math.vector"; export type TensorPropertyLineProps = BaseComponentProps & PropertyLineProps & { /** * If passed, all sliders will use this for the min value */ min?: number; /** * If passed, all sliders will use this for the max value */ max?: number; /** * If passed, the UX will use the conversion functions to display/update values */ valueConverter?: { /** * Will call from(val) before displaying in the UX */ from: (val: number) => number; /** * Will call to(val) before calling onChange */ to: (val: number) => number; }; }; type RotationVectorPropertyLineProps = TensorPropertyLineProps & { /** * Display angles as degrees instead of radians */ useDegrees?: boolean; }; export const RotationVectorPropertyLine: FunctionComponent; type QuaternionPropertyLineProps = TensorPropertyLineProps & { /** * Display angles as degrees instead of radians */ useDegrees?: boolean; }; export const QuaternionPropertyLine: FunctionComponent; export const Vector3PropertyLine: FunctionComponent>; export const Vector4PropertyLine: FunctionComponent>; export {}; } declare module "babylonjs-inspector/fluent/hoc/textPropertyLine" { import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { FunctionComponent } from "react"; type TextProps = { value: string; tooltip?: string; }; /** * Wraps text in a property line * @param props - PropertyLineProps and TextProps * @returns property-line wrapped text */ export const TextPropertyLine: FunctionComponent; export {}; } declare module "babylonjs-inspector/fluent/hoc/syncedSliderLine" { import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { SyncedSliderProps } from "babylonjs-inspector/fluent/primitives/syncedSlider"; import { FunctionComponent } from "react"; type SyncedSliderLineProps = SyncedSliderProps & PropertyLineProps; /** * Renders a simple wrapper around the SyncedSliderInput * @param props * @returns */ export const SyncedSliderLine: FunctionComponent; export {}; } declare module "babylonjs-inspector/fluent/hoc/switchPropertyLine" { import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { FunctionComponent } from "react"; import { SwitchProps } from "babylonjs-inspector/fluent/primitives/switch"; /** * Wraps a switch in a property line * @param props - The properties for the switch and property line * @returns A React element representing the property line with a switch */ export const SwitchPropertyLine: FunctionComponent; } declare module "babylonjs-inspector/fluent/hoc/propertyLine" { import { FunctionComponent } from "react"; export type PropertyLineProps = { /** * The name of the property to display in the property line. */ label: string; /** * Optional description for the property, shown on hover of the info icon */ description?: string; /** * Optional function returning a string to copy to clipboard. */ onCopy?: () => string; /** * If supplied, an 'expand' icon will be shown which, when clicked, renders this component within the property line. */ expandedContent?: JSX.Element; /** * Link to the documentation for this property, available from the info icon either linked from the description (if provided) or defalt 'docs' text */ docLink?: string; }; export const LineContainer: import("react").ForwardRefExoticComponent<{ children?: import("react").ReactNode | undefined; } & import("react").RefAttributes>; export type BaseComponentProps = { /** * The value of the property to be displayed and modified. */ value: T; /** * Callback function to handle changes to the value */ onChange: (value: T) => void; /** * Optional flag to disable the component, preventing any interaction. */ disabled?: boolean; /** * Optional class name to apply custom styles to the component. */ className?: string; }; /** * A reusable component that renders a property line with a label and child content, and an optional description, copy button, and expandable section. * * @param props - The properties for the PropertyLine component. * @returns A React element representing the property line. * */ export const PropertyLine: import("react").ForwardRefExoticComponent>; export const PlaceholderPropertyLine: FunctionComponent & PropertyLineProps>; } declare module "babylonjs-inspector/fluent/hoc/linkPropertyLine" { import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { FunctionComponent } from "react"; type LinkProps = { value: string; tooltip?: string; onLink?: () => void; url?: string; }; /** * Wraps a link in a property line * @param props - PropertyLineProps and LinkProps * @returns property-line wrapped link */ export const LinkPropertyLine: FunctionComponent; export {}; } declare module "babylonjs-inspector/fluent/hoc/inputPropertyLine" { import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { FunctionComponent } from "react"; import { InputProps } from "babylonjs-inspector/fluent/primitives/input"; export const TextInputPropertyLine: FunctionComponent & PropertyLineProps>; export const FloatInputPropertyLine: FunctionComponent & PropertyLineProps>; } declare module "babylonjs-inspector/fluent/hoc/hexLineComponent" { import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { FunctionComponent } from "react"; import { InputHexProps } from "babylonjs-inspector/fluent/primitives/colorPicker"; /** * Wraps a hex input in a property line * @param props - PropertyLineProps and InputHexProps * @returns property-line wrapped input hex component */ export const HexPropertyLine: FunctionComponent; } declare module "babylonjs-inspector/fluent/hoc/fluentToolWrapper" { import { PropsWithChildren, FunctionComponent } from "react"; export type ToolHostProps = { /** * Allows host to pass in a theme */ customTheme?: any; /** * Can be set to true to disable the copy button in the tool's property lines. Default is false (copy enabled) */ disableCopy?: boolean; }; export const ToolContext: import("react").Context<{ readonly useFluent: boolean; readonly disableCopy: boolean; }>; /** * For tools which are ready to move over the fluent, wrap the root of the tool (or the panel which you want fluentized) with this component * Today we will only enable fluent if the URL has the `newUX` query parameter is truthy * @param props * @returns */ export const FluentToolWrapper: FunctionComponent>; } declare module "babylonjs-inspector/fluent/hoc/fileUploadLine" { import { FunctionComponent } from "react"; import { ButtonLineProps } from "babylonjs-inspector/fluent/hoc/buttonLine"; type FileUploadLineProps = Omit & { onClick: (file: File) => void; accept: string; }; export const FileUploadLine: FunctionComponent; export {}; } declare module "babylonjs-inspector/fluent/hoc/dropdownPropertyLine" { import { Nullable } from "babylonjs/types"; import { AcceptedDropdownValue, DropdownProps } from "babylonjs-inspector/fluent/primitives/dropdown"; import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { FunctionComponent } from "react"; type DropdownPropertyLineProps = Omit, "includeNullAs"> & PropertyLineProps; export const NullableDropdownPropertyLine: FunctionComponent>; /** * Dropdown component for explicitly defined number values. * If value can be undefined, use OptionalNumberDropdownPropertyLine instead. * If value can be null, use NullableNumberDropdownPropertyLine instead. */ export const NumberDropdownPropertyLine: FunctionComponent>; /** * Dropdown component for explicitly defined string values. * If value can be undefined, use OptionalStringDropdownPropertyLine instead. * If value can be null, use NullableStringDropdownPropertyLine instead. */ export const StringDropdownPropertyLine: FunctionComponent>; /** * Dropdown component for Nullable values. */ export const NullableNumberDropdownPropertyLine: FunctionComponent>>; /** * Dropdown component for Nullable values. */ export const NullableStringDropdownPropertyLine: FunctionComponent>>; /** * Dropdown component for number | undefined values */ export const OptionalNumberDropdownPropertyLine: FunctionComponent>; /** * Dropdown component for string | undefined values */ export const OptionalStringDropdownPropertyLine: FunctionComponent>; export {}; } declare module "babylonjs-inspector/fluent/hoc/colorPropertyLine" { import { FunctionComponent } from "react"; import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { Color3 } from "babylonjs/Maths/math.color"; import { Color4 } from "babylonjs/Maths/math.color"; import { ColorPickerProps } from "babylonjs-inspector/fluent/primitives/colorPicker"; export type ColorPropertyLineProps = ColorPickerProps & PropertyLineProps; export const Color3PropertyLine: FunctionComponent & PropertyLineProps>; export const Color4PropertyLine: FunctionComponent & PropertyLineProps>; } declare module "babylonjs-inspector/fluent/hoc/checkboxPropertyLine" { import { PropertyLineProps } from "babylonjs-inspector/fluent/hoc/propertyLine"; import { FunctionComponent } from "react"; import { CheckboxProps } from "babylonjs-inspector/fluent/primitives/checkbox"; /** * Wraps a checkbox in a property line * @param props - PropertyLineProps and CheckboxProps * @returns property-line wrapped checkbox */ export const CheckboxPropertyLine: FunctionComponent; } declare module "babylonjs-inspector/fluent/hoc/buttonLine" { import { FunctionComponent } from "react"; export type ButtonLineProps = { label: string; onClick: () => void; disabled?: boolean; icon?: string; title?: string; }; /** * Wraps a button with a label in a line container * @param props Button props plus a label * @returns A button inside a line */ export const ButtonLine: FunctionComponent; } declare module "babylonjs-inspector/components/classNames" { export function ClassNames(names: any, styleObject: any): string; export function JoinClassNames(styleObject: any, ...names: string[]): string; } declare module "babylonjs-inspector/components/Toggle" { export type ToggleProps = { toggled: "on" | "mixed" | "off"; onToggle?: () => void; padded?: boolean; color?: "dark" | "light"; }; export const Toggle: React.FC; } declare module "babylonjs-inspector/components/TextInputWithSubmit" { export interface ITextInputProps { label?: string; placeholder?: string; submitValue: (newValue: string) => void; validateValue?: (value: string) => boolean; cancelSubmit?: () => void; } /** * This component represents a text input that can be submitted or cancelled on buttons * @param props properties * @returns TextInputWithSubmit element */ } declare module "babylonjs-inspector/components/MessageDialog" { import * as React from "react"; export interface MessageDialogProps { message: string; isError: boolean; onClose?: () => void; } export const MessageDialog: React.FC; } declare module "babylonjs-inspector/components/Label" { import { ReactChild } from "react"; export type LabelProps = { text: string; children?: ReactChild; color?: "dark" | "light"; }; export const Label: React.FC; } declare module "babylonjs-inspector/components/Icon" { export type IconProps = { color?: "dark" | "light"; icon: string; }; export const Icon: React.FC; } declare module "babylonjs-inspector/components/Button" { import { PropsWithChildren } from "react"; export type ButtonProps = { disabled?: boolean; active?: boolean; onClick?: () => void; color: "light" | "dark"; size: "default" | "small" | "wide" | "smaller"; title?: string; backgroundColor?: string; }; export const Button: React.FC>; } declare module "babylonjs-inspector/components/reactGraphSystem/useGraphContext" { /** * utility hook to assist using the graph context * @returns */ export const useGraphContext: () => import("babylonjs-inspector/components/reactGraphSystem/GraphContextManager").IGraphContext; } declare module "babylonjs-inspector/components/reactGraphSystem/NodeRenderer" { import { ComponentType, PropsWithChildren } from "react"; import { Nullable } from "babylonjs/types"; export type IVisualRecordsType = Record; export type IConnectionType = { id: string; sourceId: string; targetId: string; }; export type ICustomDataType = { type: string; value: any; }; export type INodeType = { id: string; label: string; customData?: ICustomDataType; }; /** * props for the node renderer */ export interface INodeRendererProps { /** * array of connections between nodes */ connections: IConnectionType[]; /** * function called when a new connection is created */ updateConnections: (sourceId: string, targetId: string) => void; /** * function called when a connection is deleted */ deleteLine: (lineId: string) => void; /** * function called when a node is deleted */ deleteNode: (nodeId: string) => void; /** * array of all nodes */ nodes: INodeType[]; /** * id of the node to highlight */ highlightedNode?: Nullable; /** * function to be called if a node is selected */ selectNode?: (nodeId: Nullable) => void; /** * id of this renderer */ id: string; /** * optional list of custom components to be rendered inside nodes of * a certain type */ customComponents?: Record>; } /** * This component is a bridge between the app logic related to the graph, and the actual rendering * of it. It manages the nodes' positions and selection states. * @param props * @returns */ } declare module "babylonjs-inspector/components/reactGraphSystem/GraphNodesContainer" { import { FC, PropsWithChildren } from "react"; export interface IGraphContainerProps { onNodeMoved: (id: string, x: number, y: number) => void; id: string; } /** * This component contains all the nodes and handles their dragging * @param props properties * @returns graph node container element */ export const GraphNodesContainer: FC>; } declare module "babylonjs-inspector/components/reactGraphSystem/GraphNode" { import { FC, PropsWithChildren } from "react"; export interface IGraphNodeProps { id: string; name: string; x: number; y: number; selected?: boolean; width?: number; height?: number; highlighted?: boolean; parentContainerId: string; } export const SingleGraphNode: FC>; } declare module "babylonjs-inspector/components/reactGraphSystem/GraphLinesContainer" { import { FC, PropsWithChildren } from "react"; /** * props for the GraphLineContainer */ export interface IGraphLinesContainerProps { /** * id of the container */ id: string; } /** * this component handles the dragging of new connections * @param props * @returns */ export const GraphLinesContainer: FC>; } declare module "babylonjs-inspector/components/reactGraphSystem/GraphLine" { import { FC } from "react"; /** * props for the GraphLine component */ export interface IGraphLineProps { /** * id of the line. temporary lines can have no id */ id?: string; /** * starting x pos of the line */ x1: number; /** * ending x pos of the line */ x2: number; /** * starting y pos of the line */ y1: number; /** * ending y pos of the line */ y2: number; /** * is the line selected */ selected?: boolean; /** * does the line have a direction */ directional?: boolean; } export const MarkerArrowId = "arrow"; /** * This component draws a SVG line between two points, with an optional marker * indicating direction * @param props properties * @returns graph line element */ export const GraphLine: FC; } declare module "babylonjs-inspector/components/reactGraphSystem/GraphContextManager" { /** * this context is used to pass callbacks to the graph nodes and connections */ export interface IGraphContext { onNodesConnected?: (sourceId: string, targetId: string) => void; onLineSelected?: (lineId: string) => void; onNodeSelected?: (nodeId: string) => void; } export const GraphContextManager: import("react").Context; } declare module "babylonjs-inspector/components/reactGraphSystem/GraphContainer" { import { FC, PropsWithChildren } from "react"; export interface IGraphContainerProps { } /** * This component is just a simple container to keep the nodes and lines containers * together * @param props * @returns */ export const GraphContainer: FC>; } declare module "babylonjs-inspector/components/reactGraphSystem/GraphConnectorHandle" { import { FC, PropsWithChildren } from "react"; /** * Props for the connector */ export interface IGraphConnectorHandlerProps { /** * id of the parent node */ parentId: string; /** * x position of the parent node */ parentX: number; /** * y position of the parent node */ parentY: number; /** * x position of the connector relative to the parent node */ offsetX?: number; /** * y position of the connector relative to the parent node */ offsetY?: number; /** * width of the parent node */ parentWidth: number; /** * height of the parent node */ parentHeight: number; /** * id of the container where its parent node is */ parentContainerId: string; } /** * This component is used to initiate a connection between two nodes. Simply * drag the handle in a node and drop it in another node to create a connection. * @returns connector element */ export const GraphConnectorHandler: FC>; } declare module "babylonjs-inspector/components/lines/OptionsLineComponent" { /** * This components represents an options menu with optional * customizable properties. Option IDs should be unique. */ export interface IOption { label: string; value: string; id: string; } export interface IOptionsLineComponentProps { options: IOption[]; addOptionPlaceholder?: string; onOptionAdded?: (newOption: IOption) => void; onOptionSelected: (selectedOptionValue: string) => void; selectedOptionValue: string; validateNewOptionValue?: (newOptionValue: string) => boolean; addOptionText?: string; } } declare module "babylonjs-inspector/components/lines/NumericInputComponent" { import * as React from "react"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; interface INumericInputComponentProps { label: string; labelTooltip?: string; value: number; step?: number; onChange: (value: number) => void; precision?: number; icon?: string; iconLabel?: string; lockObject: LockObject; } export class NumericInputComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: INumericInputComponentProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: { value: string; }): boolean; updateValue(valueString: string): void; onBlur(): void; incrementValue(amount: number): void; onKeyDown(evt: React.KeyboardEvent): void; } export {}; } declare module "babylonjs-inspector/components/lines/FileButtonLineComponent" { import * as React from "react"; export interface IFileButtonLineComponentProps { label: string; onClick: (file: File) => void; accept: string; icon?: string; iconLabel?: string; } export class FileButtonLineComponent extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: IFileButtonLineComponentProps); onChange(evt: any): void; } } declare module "babylonjs-inspector/components/lines/ColorPickerLineComponent" { import * as React from "react"; import { Color4, Color3 } from "babylonjs/Maths/math.color"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColorPickerLineComponentProps { value: Color4 | Color3; linearHint?: boolean; onColorChanged: (newOne: string) => void; icon?: string; iconLabel?: string; shouldPopRight?: boolean; lockObject?: LockObject; backgroundColor?: string; } interface IColorPickerComponentState { pickerEnabled: boolean; color: Color3 | Color4; hex: string; } export class ColorPickerLineComponent extends React.Component { private _floatRef; private _floatHostRef; private _coverRef; constructor(props: IColorPickerLineComponentProps); syncPositions(): void; shouldComponentUpdate(nextProps: IColorPickerLineComponentProps, nextState: IColorPickerComponentState): boolean; getHexString(props?: Readonly): string; componentDidUpdate(): void; componentDidMount(): void; } export {}; } declare module "babylonjs-inspector/components/lines/ColorLineComponent" { import * as React from "react"; import { Observable } from "babylonjs/Misc/observable"; import { Color4 } from "babylonjs/Maths/math.color"; import { PropertyChangedEvent } from "babylonjs-inspector/propertyChangedEvent"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColorLineComponentProps { label: string; target: any; propertyName: string; onPropertyChangedObservable: Observable; onChange?: () => void; isLinear?: boolean; icon?: string; iconLabel?: string; disableAlpha?: boolean; lockObject: LockObject; } interface IColorLineComponentState { isExpanded: boolean; color: Color4; } export class ColorLineComponent extends React.Component { constructor(props: IColorLineComponentProps); shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean; getValue(props?: Readonly): Color4; setColorFromString(colorString: string): void; setColor(newColor: Color4): void; switchExpandState(): void; updateStateR(value: number): void; updateStateG(value: number): void; updateStateB(value: number): void; updateStateA(value: number): void; copyToClipboard(): void; private _convertToColor; private _toColor3; } export {}; } declare module "babylonjs-inspector/components/layout/utils" { import { Layout, LayoutColumn, LayoutTabsRow } from "babylonjs-inspector/components/layout/types"; /** * Given a column and row number in the layout, return the corresponding column/row * @param layout * @param column * @param row * @returns */ export const getPosInLayout: (layout: Layout, column: number, row?: number) => LayoutColumn | LayoutTabsRow; /** * Remove a row in position row, column from the layout, and redistribute heights of remaining rows * @param layout * @param column * @param row */ export const removeLayoutRowAndRedistributePercentages: (layout: Layout, column: number, row: number) => void; /** * Add a percentage string to a number * @param p1 the percentage string * @param p2 the number * @returns the sum of the percentage string and the number */ export const addPercentageStringToNumber: (p1: string, p2: number) => number; /** * Parses a percentage string into a number * @param p the percentage string * @returns the parsed number */ export const parsePercentage: (p: string) => number; } declare module "babylonjs-inspector/components/layout/types" { import { ReactElement } from "react"; export type LayoutTab = { /** * Tab id */ id: string; /** * React component rendered by tab */ component: ReactElement; /** * Tab title */ title: string; }; export type LayoutTabsRow = { /** * row id */ id: string; /** * row height in its containing column */ height: string; /** * selected tab in row */ selectedTab: string; /** * list of tabs contained in row */ tabs: LayoutTab[]; }; export type LayoutColumn = { /** * column id */ id: string; /** * column width in the grid */ width: string; /** * column rows */ rows: LayoutTabsRow[]; }; export type Layout = { /** * layout columns */ columns?: LayoutColumn[]; }; export type TabDrag = { /** * row number of the tab being dragged */ rowNumber: number; /** * column number of the tab being dragged */ columnNumber: number; /** * the tabs being dragged */ tabs: { /** * id of tab being dragged */ id: string; }[]; }; export enum ElementTypes { RESIZE_BAR = "0", TAB = "1", TAB_GROUP = "2", NONE = "2" } export enum ResizeDirections { ROW = "row", COLUMN = "column" } } declare module "babylonjs-inspector/components/layout/LayoutContext" { import { Layout } from "babylonjs-inspector/components/layout/types"; export const LayoutContext: import("react").Context<{ /** * The layout object */ layout: Layout; /** * Function to set the layout object in the context */ setLayout: (layout: Layout) => void; }>; } declare module "babylonjs-inspector/components/layout/FlexibleTabsContainer" { import { FC } from "react"; import { LayoutTab } from "babylonjs-inspector/components/layout/types"; /** * Arguments for the TabsContainer component. */ export interface IFlexibleTabsContainerProps { /** * The tabs to display */ tabs: LayoutTab[]; /** * Row index of component in layout */ rowIndex: number; /** * Column index of component in layout */ columnIndex: number; /** * Which tab is selected in the layout */ selectedTab?: string; } /** * This component contains a set of tabs of which only one is visible at a time. * The tabs can also be dragged from and to different containers. * @param props properties * @returns tabs container element */ export const FlexibleTabsContainer: FC; } declare module "babylonjs-inspector/components/layout/FlexibleTab" { import { FC } from "react"; import { TabDrag } from "babylonjs-inspector/components/layout/types"; /** * Arguments for the FlexibleTab component. */ export interface IFlexibleTabProps { /** * The tab's title. */ title: string; /** * If the tab is currently selected or not */ selected: boolean; /** * What happens when the user clicks on the tab */ onClick: () => void; /** * The object that will be sent to the drag event */ item: TabDrag; /** * What happens when the user drops another tab after this one */ onTabDroppedAction: (item: TabDrag) => void; } /** * A component that renders a tab that the user can click * to activate or drag to reorder. It also listens for * drop events if the user wants to drop another tab * after it. * @param props properties * @returns FlexibleTab element */ export const FlexibleTab: FC; } declare module "babylonjs-inspector/components/layout/FlexibleResizeBar" { import { FC } from "react"; import { ResizeDirections } from "babylonjs-inspector/components/layout/types"; /** * Arguments for the ResizeBar component. */ export interface IFlexibleRowResizerProps { /** * Row number of the component that is being resized */ rowNumber: number; /** * Column number of the component being resized */ columnNumber: number; /** * If the resizing happens in row or column direction */ direction: ResizeDirections; } /** * The item that will be sent to the drag event */ export type ResizeItem = { /** * If the resizing happens in row or column direction */ direction: ResizeDirections; /** * The row number of the component that is being resized */ rowNumber: number; /** * the column number of the component being resized */ columnNumber: number; }; /** * A component that renders a bar that the user can drag to resize. * @param props properties * @returns resize bar element */ export const FlexibleResizeBar: FC; } declare module "babylonjs-inspector/components/layout/FlexibleGridLayout" { import { FC } from "react"; import { Layout } from "babylonjs-inspector/components/layout/types"; /** * Arguments for the Layout component. */ export interface IFlexibleGridLayoutProps { /** * A definition of the layout which can be changed by the user */ layoutDefinition: Layout; } /** * This component represents a grid layout that can be resized and rearranged * by the user. * @param props properties * @returns layout element */ export const FlexibleGridLayout: FC; } declare module "babylonjs-inspector/components/layout/FlexibleGridContainer" { import { FC } from "react"; /** * Arguments for the GridContainer component. */ export interface IFlexibleGridContainerProps { } /** * Component responsible for mapping the layout to the actual components * @returns GridContainer element */ export const FlexibleGridContainer: FC; } declare module "babylonjs-inspector/components/layout/FlexibleDropZone" { import { FC, PropsWithChildren } from "react"; /** * Arguments for the FlexibleDropZone component. */ export interface IFlexibleDropZoneProps { /** * The row number of the component in the layout */ rowNumber: number; /** * The column number of the component in the layout */ columnNumber: number; } /** * This component contains the drag and drop zone for the resize bars that * allow redefining width and height of layout elements * @param props properties * @returns drop zone element */ export const FlexibleDropZone: FC>; } declare module "babylonjs-inspector/components/layout/FlexibleDragHandler" { import { FC, PropsWithChildren } from "react"; /** * Arguments for the DragHandler component. */ export interface IFlexibleDragHandlerProps { /** * The size of the containing element. Used to calculate the percentage of * space occupied by the component */ containerSize: { width: number; height: number; }; } /** * This component receives the drop events and updates the layout accordingly * @param props properties * @returns DragHandler element */ export const FlexibleDragHandler: FC>; } declare module "babylonjs-inspector/components/layout/FlexibleColumn" { import { FC, PropsWithChildren } from "react"; /** * Arguments for the Column component. */ export interface IFlexibleColumnProps { /** * Width of column */ width: string; } /** * This component represents a single column in the layout. It receives a width * that it occupies and the content to display * @param props * @returns */ export const FlexibleColumn: FC>; } declare module "babylonjs-inspector/components/layout/DraggableIcon" { import { FC } from "react"; import { ElementTypes, TabDrag } from "babylonjs-inspector/components/layout/types"; /** * Arguments for the DraggableIcon component. */ export interface IDraggableIconProps { /** * Icon source */ src: string; /** * Object that will be passed to the drag event */ item: TabDrag; /** * Type of drag event */ type: ElementTypes; } /** * An icon that can be dragged by the user * @param props properties * @returns draggable icon element */ export const DraggableIcon: FC; } declare module "babylonjs-inspector/components/colorPicker/HexColor" { import * as React from "react"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IHexColorProps { value: string; expectedLength: number; onChange: (value: string) => void; lockObject: LockObject; } export class HexColorComponent extends React.Component { constructor(props: IHexColorProps); shouldComponentUpdate(nextProps: IHexColorProps, nextState: { hex: string; }): boolean; lock(): void; unlock(): void; updateHexValue(valueString: string): void; } } declare module "babylonjs-inspector/components/colorPicker/ColorPicker" { import * as React from "react"; import { Color3, Color4 } from "babylonjs/Maths/math.color"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; /** * Interface used to specify creation options for color picker */ export interface IColorPickerComponentProps { color: Color3 | Color4; linearhint?: boolean; debugMode?: boolean; onColorChanged?: (color: Color3 | Color4) => void; lockObject: LockObject; backgroundColor?: string; } /** * Interface used to specify creation options for color picker */ export interface IColorPickerState { color: Color3; alpha: number; } /** * Class used to create a color picker */ export class ColorPickerComponent extends React.Component { private _saturationRef; private _hueRef; private _isSaturationPointerDown; private _isHuePointerDown; constructor(props: IColorPickerComponentProps); shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerState): boolean; onSaturationPointerDown(evt: React.PointerEvent): void; onSaturationPointerUp(evt: React.PointerEvent): void; onSaturationPointerMove(evt: React.PointerEvent): void; onHuePointerDown(evt: React.PointerEvent): void; onHuePointerUp(evt: React.PointerEvent): void; onHuePointerMove(evt: React.PointerEvent): void; private _evaluateSaturation; private _evaluateHue; componentDidUpdate(): void; raiseOnColorChanged(): void; } } declare module "babylonjs-inspector/components/colorPicker/ColorComponentEntry" { import * as React from "react"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColorComponentEntryProps { value: number; label: string; max?: number; min?: number; onChange: (value: number) => void; disabled?: boolean; lockObject: LockObject; } export class ColorComponentComponentEntry extends React.Component { constructor(props: IColorComponentEntryProps); updateValue(valueString: string): void; lock(): void; unlock(): void; } } declare module "babylonjs-inspector/components/bars/CommandDropdownComponent" { import * as React from "react"; interface ICommandDropdownComponentProps { icon?: string; tooltip: string; defaultValue?: string; items: { label: string; icon?: string; fileButton?: boolean; onClick?: () => void; onCheck?: (value: boolean) => void; storeKey?: string; isActive?: boolean; defaultValue?: boolean | string; subItems?: string[]; }[]; toRight?: boolean; } export class CommandDropdownComponent extends React.Component { constructor(props: ICommandDropdownComponentProps); } export {}; } declare module "babylonjs-inspector/components/bars/CommandButtonComponent" { import * as React from "react"; export interface ICommandButtonComponentProps { tooltip: string; shortcut?: string; icon: string; iconLabel?: string; isActive: boolean; onClick: () => void; disabled?: boolean; } export const CommandButtonComponent: React.FC; } declare module "babylonjs-inspector/components/bars/CommandBarComponent" { import { FC, PropsWithChildren } from "react"; export interface ICommandBarComponentProps { onSaveButtonClicked?: () => void; onSaveToSnippetButtonClicked?: () => void; onLoadFromSnippetButtonClicked?: () => void; onHelpButtonClicked?: () => void; onGiveFeedbackButtonClicked?: () => void; onSelectButtonClicked?: () => void; onPanButtonClicked?: () => void; onZoomButtonClicked?: () => void; onFitButtonClicked?: () => void; onArtboardColorChanged?: (newColor: string) => void; artboardColor?: string; artboardColorPickerColor?: string; } export const CommandBarComponent: FC>; } declare module "babylonjs-inspector/colorPicker/hexColor" { import * as React from "react"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IHexColorProps { value: string; expectedLength: number; onChange: (value: string) => void; lockObject: LockObject; } export class HexColor extends React.Component { constructor(props: IHexColorProps); shouldComponentUpdate(nextProps: IHexColorProps, nextState: { hex: string; }): boolean; lock(): void; unlock(): void; updateHexValue(valueString: string): void; } } declare module "babylonjs-inspector/colorPicker/colorPicker" { import * as React from "react"; import { Color3, Color4 } from "babylonjs/Maths/math.color"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; import "babylonjs-inspector/colorPicker/colorPicker.scss"; /** * Interface used to specify creation options for color picker */ export interface IColorPickerProps { color: Color3 | Color4; linearhint?: boolean; debugMode?: boolean; onColorChanged?: (color: Color3 | Color4) => void; lockObject: LockObject; } /** * Interface used to specify creation options for color picker */ export interface IColorPickerState { color: Color3; alpha: number; } /** * Class used to create a color picker */ export class ColorPicker extends React.Component { private _saturationRef; private _hueRef; private _isSaturationPointerDown; private _isHuePointerDown; constructor(props: IColorPickerProps); shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean; onSaturationPointerDown(evt: React.PointerEvent): void; onSaturationPointerUp(evt: React.PointerEvent): void; onSaturationPointerMove(evt: React.PointerEvent): void; onHuePointerDown(evt: React.PointerEvent): void; onHuePointerUp(evt: React.PointerEvent): void; onHuePointerMove(evt: React.PointerEvent): void; private _evaluateSaturation; private _evaluateHue; componentDidUpdate(): void; raiseOnColorChanged(): void; } } declare module "babylonjs-inspector/colorPicker/colorComponentEntry" { import * as React from "react"; import { LockObject } from "babylonjs-inspector/tabs/propertyGrids/lockObject"; export interface IColorComponentEntryProps { value: number; label: string; max?: number; min?: number; onChange: (value: number) => void; disabled?: boolean; lockObject: LockObject; } export class ColorComponentEntry extends React.Component { constructor(props: IColorComponentEntryProps); updateValue(valueString: string): void; lock(): void; unlock(): void; } } declare module "babylonjs-inspector" { export * from "babylonjs-inspector/legacy/legacy"; } declare module INSPECTOR { export class Tools { static LookForItem(item: any, selectedEntity: any): boolean; private static _RecursiveRemoveHiddenMeshesAndHoistChildren; static GetNameString(obj: any): any; static SortAndFilter(parent: any, items: any[]): any[]; } /** * Defines which channels of the texture to retrieve with {@link TextureHelper.GetTextureDataAsync}. */ export interface TextureChannelsToDisplay { /** * True if the red channel should be included. */ R: boolean; /** * True if the green channel should be included. */ G: boolean; /** * True if the blue channel should be included. */ B: boolean; /** * True if the alpha channel should be included. */ A: boolean; } /** * Helper class for retrieving texture data. */ export class TextureHelper { /** * Gets the data of the specified texture by rendering it to an intermediate RGBA texture and retrieving the bytes from it. * This is convienent to get 8-bit RGBA values for a texture in a GPU compressed format. * @param texture the source texture * @param width the width of the result, which does not have to match the source texture width * @param height the height of the result, which does not have to match the source texture height * @param face if the texture has multiple faces, the face index to use for the source * @param channels a filter for which of the RGBA channels to return in the result * @param globalState the global state to use for rendering the texture * @param lod if the texture has multiple LODs, the lod index to use for the source * @returns the 8-bit texture data */ static GetTextureDataAsync(texture: BABYLON.BaseTexture, width: number, height: number, face: number, channels: TextureChannelsToDisplay, globalState?: GlobalState, lod?: number): Promise; } export interface IPersistentPopupConfiguration { props: IPopupComponentProps; children: React.ReactNode; closeWhenSceneExplorerCloses?: boolean; closeWhenActionTabsCloses?: boolean; } export class Inspector { private static _SceneExplorerHost; private static _ActionTabsHost; private static _EmbedHost; private static _PersistentPopupHost; private static _SceneExplorerRoot; private static _ActionTabsRoot; private static _EmbedHostRoot; private static _PersistentPopupRoot; private static _NewCanvasContainer; private static _SceneExplorerWindow; private static _ActionTabsWindow; private static _EmbedHostWindow; private static _Scene; private static _OpenedPane; private static _OnBeforeRenderObserver; private static _OnSceneExplorerClosedObserver; private static _OnActionTabsClosedObserver; static OnSelectionChangeObservable: BABYLON.Observable; static OnPropertyChangedObservable: BABYLON.Observable; private static _GlobalState; static MarkLineContainerTitleForHighlighting(title: string): void; static MarkMultipleLineContainerTitlesForHighlighting(titles: string[]): void; private static _SceneExplorerOptions; private static _InspectorOptions; private static _EmbedOptions; static PopupEmbed(): void; static PopupSceneExplorer(): void; static PopupInspector(): void; private static _CreateSceneExplorer; private static _CreateActionTabs; private static _CreateEmbedHost; static get IsVisible(): boolean; static EarlyAttachToLoader(): void; static Show(scene: BABYLON.Scene, userOptions: Partial): void; static _SetNewScene(scene: BABYLON.Scene): void; static _CreateCanvasContainer(parentControl: HTMLElement): void; private static _DestroyCanvasContainer; private static _Cleanup; private static _RemoveElementFromDOM; static Hide(): void; static _CreatePersistentPopup(config: IPersistentPopupConfiguration, hostElement: HTMLElement): void; static _ClosePersistentPopup(): void; } export class ReplayRecorder { private _sceneRecorder; private _isRecording; get isRecording(): boolean; cancel(): void; trackScene(scene: BABYLON.Scene): void; applyDelta(json: any, scene: BABYLON.Scene): void; export(): void; } export class PropertyChangedEvent { object: any; property: string; value: any; initialValue: any; allowNullValue?: boolean; } export interface IPopupComponentProps { id: string; title: string; size: { width: number; height: number; }; onOpen?: (window: Window) => void; onClose: (window: Window) => void; onResize?: (window: Window) => void; onKeyUp?: (evt: KeyboardEvent) => void; onKeyDown?: (evt: KeyboardEvent) => void; } export class PopupComponent extends React.Component, { isComponentMounted: boolean; blockedByBrowser: boolean; }> { private _container; private _window; private _host; constructor(props: IPopupComponentProps); componentDidMount(): void; onBeforeUnloadListener: () => void; openPopup(): void; componentWillUnmount(): void; getWindow(): Window | null; render(): React.ReactPortal | null; } export interface IHeaderComponentProps { title: string; handleBack?: boolean; noExpand?: boolean; noClose?: boolean; noCommands?: boolean; onPopup: () => void; onClose: () => void; onSelectionChangedObservable?: BABYLON.Observable; } export class HeaderComponent extends React.Component { private _backStack; private _onSelectionChangeObserver; constructor(props: IHeaderComponentProps); componentDidMount(): void; componentWillUnmount(): void; goBack(): void; renderLogo(): import("react/jsx-runtime").JSX.Element | null; render(): import("react/jsx-runtime").JSX.Element; } export class GlobalState { onSelectionChangedObservable: BABYLON.Observable; onPropertyChangedObservable: BABYLON.Observable; onInspectorClosedObservable: BABYLON.Observable; onTabChangedObservable: BABYLON.Observable; onSelectionRenamedObservable: BABYLON.Observable; onPluginActivatedObserver: BABYLON.Nullable>; onNewSceneObservable: BABYLON.Observable; sceneImportDefaults: { [key: string]: any; }; validationResults: BABYLON.Nullable; onValidationResultsUpdatedObservable: BABYLON.Observable>; onExtensionLoadedObservable: BABYLON.Observable; glTFLoaderOverrideExtensionsConfig: boolean; glTFLoaderExtensionDefaults: { [name: string]: { [key: string]: any; }; }; glTFLoaderOverrideConfig: boolean; glTFLoaderDefaults: { [key: string]: any; }; glTFLoaderExtensions: { [key: string]: BABYLON.IGLTFLoaderExtension; }; blockMutationUpdates: boolean; selectedLineContainerTitles: Array; selectedLineContainerTitlesNoFocus: Array; recorder: ReplayRecorder; private _onlyUseEulers; get onlyUseEulers(): boolean; set onlyUseEulers(value: boolean); private _ignoreBackfacesForPicking; get ignoreBackfacesForPicking(): boolean; set ignoreBackfacesForPicking(value: boolean); init(propertyChangedObservable: BABYLON.Observable): void; prepareGLTFPlugin(loader: BABYLON.GLTFFileLoader): void; resetGLTFValidationResults(): void; lightGizmos: Array; enableLightGizmo(light: BABYLON.Light, enable?: boolean, gizmoCamera?: BABYLON.Nullable): void; cameraGizmos: Array; enableCameraGizmo(camera: BABYLON.Camera, enable?: boolean, gizmoCamera?: BABYLON.Nullable): void; onSceneExplorerClosedObservable: BABYLON.Observable; onActionTabsClosedObservable: BABYLON.Observable; } export function setDebugNode(node: any): void; interface ITreeItemSpecializedComponentProps { label: string; entity?: any; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; globalState: GlobalState; gizmoCamera?: BABYLON.Camera; onClick?: () => void; } export class TreeItemSpecializedComponent extends React.Component { constructor(props: ITreeItemSpecializedComponentProps); onClick(): void; render(): import("react/jsx-runtime").JSX.Element; } export interface ITreeItemSelectableComponentProps { entity: any; selectedEntity?: any; mustExpand?: boolean; offset: number; globalState: GlobalState; gizmoCamera?: BABYLON.Camera; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; filter: BABYLON.Nullable; } export class TreeItemSelectableComponent extends React.Component { private _wasSelected; private _thisRef; constructor(props: ITreeItemSelectableComponentProps); switchExpandedState(mustExpand: boolean): void; shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: { isExpanded: boolean; isSelected: boolean; }): boolean; scrollIntoView(): void; componentDidMount(): void; componentDidUpdate(): void; onSelect(): void; renderChildren(): import("react/jsx-runtime").JSX.Element[] | null; render(): import("react/jsx-runtime").JSX.Element | null; } interface ITreeItemLabelComponentProps { label: string; onClick?: () => void; icon?: any; iconBase64?: string; color: string; } export class TreeItemLabelComponent extends React.Component { constructor(props: ITreeItemLabelComponentProps); onClick(): void; render(): import("react/jsx-runtime").JSX.Element; } export interface ITreeItemComponentProps { items?: BABYLON.Nullable; label: string; offset: number; filter: BABYLON.Nullable; forceSubitems?: boolean; globalState: GlobalState; gizmoCamera?: BABYLON.Camera; entity?: any; selectedEntity: any; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; contextMenuItems?: BABYLON.IInspectorContextMenuItem[]; } export class TreeItemComponent extends React.Component { static _ContextMenuUniqueIdGenerator: number; constructor(props: ITreeItemComponentProps); switchExpandedState(): void; shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: { isExpanded: boolean; }): boolean; expandAll(expand: boolean): void; renderContextMenu(): import("react/jsx-runtime").JSX.Element | null; render(): import("react/jsx-runtime").JSX.Element; } interface ISceneExplorerFilterComponentProps { onFilter: (filter: string) => void; } export class SceneExplorerFilterComponent extends React.Component { constructor(props: ISceneExplorerFilterComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISceneExplorerComponentProps { scene: BABYLON.Scene; contextMenu?: BABYLON.IInspectorOptions["contextMenu"]; contextMenuOverride?: BABYLON.IInspectorOptions["contextMenuOverride"]; gizmoCamera?: BABYLON.Camera; noCommands?: boolean; noHeader?: boolean; noExpand?: boolean; noClose?: boolean; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; additionalNodes?: BABYLON.IExplorerAdditionalNode[]; globalState: GlobalState; popupMode?: boolean; onPopup?: () => void; onClose?: () => void; } export class SceneExplorerComponent extends React.Component; selectedEntity: any; scene: BABYLON.Scene; }> { private _onSelectionChangeObserver; private _onSelectionRenamedObserver; private _onNewSceneAddedObserver; private _onNewSceneObserver; private _sceneExplorerRef; private _mutationTimeout; private _once; private _hooked; private _sceneMutationFunc; constructor(props: ISceneExplorerComponentProps); processMutation(): void; componentDidMount(): void; componentWillUnmount(): void; filterContent(filter: string): void; findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: { previousOne?: any; found?: boolean; }): boolean; processKeys(keyEvent: React.KeyboardEvent, allNodes: any[]): void; private _getPipelineContextMenus; private _getNodeContextMenus; private _getMaterialsContextMenus; private _getSpriteManagersContextMenus; private _getParticleSystemsContextMenus; private _getFrameGraphsContextMenus; renderContent(allNodes: any[]): import("react/jsx-runtime").JSX.Element | null; onClose(): void; onPopup(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IExtensionsComponentProps { target: any; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; } export class ExtensionsComponent extends React.Component { private _popup; private _extensionRef; constructor(props: IExtensionsComponentProps); showPopup(): void; componentDidMount(): void; componentDidUpdate(): void; render(): import("react/jsx-runtime").JSX.Element | null; } interface ITransformNodeItemComponentProps { transformNode: BABYLON.TransformNode; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class TransformNodeItemComponent extends React.Component { constructor(props: ITransformNodeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ITextureTreeItemComponentProps { texture: BABYLON.Texture; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class TextureTreeItemComponent extends React.Component { constructor(props: ITextureTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ITargetedAnimationItemComponentProps { targetedAnimation: BABYLON.TargetedAnimation; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class TargetedAnimationItemComponent extends React.Component { constructor(props: ITargetedAnimationItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISpriteTreeItemComponentProps { sprite: BABYLON.Sprite; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class SpriteTreeItemComponent extends React.Component { constructor(props: ISpriteTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISpriteManagerTreeItemComponentProps { spriteManager: BABYLON.SpriteManager; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class SpriteManagerTreeItemComponent extends React.Component { constructor(props: ISpriteManagerTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISoundTreeItemComponentProps { sound: BABYLON.Sound; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class SoundTreeItemComponent extends React.Component { constructor(props: ISoundTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISkeletonTreeItemComponentProps { skeleton: BABYLON.Skeleton; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class SkeletonTreeItemComponent extends React.Component { constructor(props: ISkeletonTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISceneTreeItemComponentProps { scene: BABYLON.Scene; gizmoCamera?: BABYLON.Camera; onRefresh: () => void; selectedEntity?: any; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onSelectionChangedObservable?: BABYLON.Observable; globalState: GlobalState; } export class SceneTreeItemComponent extends React.Component { private _gizmoLayerOnPointerObserver; private _gizmoLayerRenderObserver; private _onPointerObserver; private _onSelectionChangeObserver; private _selectedEntity; private _posDragEnd; private _scaleDragEnd; private _rotateDragEnd; constructor(props: ISceneTreeItemComponentProps); shouldComponentUpdate(nextProps: ISceneTreeItemComponentProps, nextState: { isSelected: boolean; isInPickingMode: boolean; }): boolean; updateGizmoAutoPicking(isInPickingMode: boolean): void; componentDidMount(): void; private _getMeshFromBone; componentWillUnmount(): void; onSelect(): void; onCoordinatesMode(): void; onPickingMode(): void; findCameraFromFrameGraph(frameGraph: BABYLON.FrameGraph): BABYLON.Nullable; setGizmoMode(mode: number): void; render(): import("react/jsx-runtime").JSX.Element; } interface IRenderPipelineItemComponenttProps { renderPipeline: BABYLON.PostProcessRenderPipeline; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class RenderingPipelineItemComponent extends React.Component { constructor(props: IRenderPipelineItemComponenttProps); render(): import("react/jsx-runtime").JSX.Element; } interface IPostProcessItemComponentProps { postProcess: BABYLON.PostProcess; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class PostProcessItemComponent extends React.Component { constructor(props: IPostProcessItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IParticleSystemTreeItemComponentProps { system: BABYLON.IParticleSystem; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class ParticleSystemTreeItemComponent extends React.Component { constructor(props: IParticleSystemTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IMeshTreeItemComponentProps { mesh: BABYLON.AbstractMesh; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; globalState: GlobalState; } export class MeshTreeItemComponent extends React.Component { constructor(props: IMeshTreeItemComponentProps); showBoundingBox(): void; switchVisibility(): void; private _getNameForLabel; private _editGeometry; render(): import("react/jsx-runtime").JSX.Element; } interface IMaterialTreeItemComponentProps { material: BABYLON.Material | BABYLON.NodeMaterial; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class MaterialTreeItemComponent extends React.Component { constructor(props: IMaterialTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ILightTreeItemComponentProps { light: BABYLON.Light; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; globalState: GlobalState; gizmoCamera?: BABYLON.Camera; } export class LightTreeItemComponent extends React.Component { constructor(props: ILightTreeItemComponentProps); switchIsEnabled(): void; toggleGizmo(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IFrameGraphItemComponenttProps { frameGraph: BABYLON.FrameGraph; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class FrameGraphTreeItemComponent extends React.Component { constructor(props: IFrameGraphItemComponenttProps); render(): import("react/jsx-runtime").JSX.Element; } interface IEffectLayerItemComponenttProps { layer: BABYLON.EffectLayer; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class EffectLayerItemComponent extends React.Component { constructor(props: IEffectLayerItemComponenttProps); render(): import("react/jsx-runtime").JSX.Element; } interface ICameraTreeItemComponentProps { camera: BABYLON.Camera; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; globalState: GlobalState; gizmoCamera?: BABYLON.Camera; } export class CameraTreeItemComponent extends React.Component { private _onBeforeRenderObserver; constructor(props: ICameraTreeItemComponentProps); setActive(): void; componentDidMount(): void; componentWillUnmount(): void; toggleGizmo(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IBoneTreeItemComponentProps { bone: BABYLON.Bone; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class BoneTreeItemComponent extends React.Component { constructor(props: IBoneTreeItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IAnimationGroupItemComponentProps { animationGroup: BABYLON.AnimationGroup; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class AnimationGroupItemComponent extends React.Component { constructor(props: IAnimationGroupItemComponentProps); render(): import("react/jsx-runtime").JSX.Element; } /** * Used to pass in the gui-editor package. * @param guiEditorPackage */ export function InjectGUIEditor(guiEditorPackage: any): void; /** * Change the URL that the GUI editor loads from * @param guiEditorURL */ export function SetGUIEditorURL(guiEditorURL: string): void; /** * Opens an ADT in the GUI editor * if you are in an ES6 environment, you must first call InjectGUIEditor to provide the gui-editor package * If you are in a UMD environment, it will load the package from a URL * @param adt * @param embed defines whether editor is being opened from the Playground * @returns a promise that resolves when the editor is opened */ export function EditAdvancedDynamicTexture(adt: BABYLON.GUI.AdvancedDynamicTexture, embed?: boolean): Promise; interface IControlTreeItemComponentProps { control: BABYLON.GUI.Control; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onClick: () => void; } export class ControlTreeItemComponent extends React.Component { constructor(props: IControlTreeItemComponentProps); highlight(): void; switchVisibility(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IAdvancedDynamicTextureTreeItemComponentProps { texture: BABYLON.GUI.AdvancedDynamicTexture; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; onSelectionChangedObservable?: BABYLON.Observable; onClick: () => void; } export class AdvancedDynamicTextureTreeItemComponent extends React.Component { private _onControlPickedObserver; constructor(props: IAdvancedDynamicTextureTreeItemComponentProps); componentWillUnmount(): void; onPickingMode(): void; render(): import("react/jsx-runtime").JSX.Element; } /** * Defines a structure to hold max, min and a optional current. */ export interface IPerfMinMax { min: number; max: number; current?: number; } /** * Defines structure of the object which contains information related to panning. */ export interface IPerfMousePanningPosition { xPos: number; delta: number; } /** * Defines structure of the object which contains information regarding the bounds of each dataset we want to consider. */ export interface IPerfIndexBounds { start: number; end: number; } export interface IPerfLayoutSize { width: number; height: number; } /** * Defines the structure of the meta object for the tooltip that appears when hovering over a performance graph! */ export interface IPerfTooltip { text: string; color: string; } /** * Defines the structure of a cache object used to store the result of measureText(). */ export interface IPerfTextMeasureCache { text: string; width: number; } /** * Defines a structure defining the available space in a drawable area. */ export interface IGraphDrawableArea { top: number; left: number; bottom: number; right: number; } /** * Defines the structure representing necessary ticker information. */ export interface IPerfTicker extends IPerfMinMax { id: string; text: string; } export interface IVisibleRangeChangedObservableProps { valueMap: Map; } /** * Defines what settings our canvas graphing service accepts */ export interface ICanvasGraphServiceSettings { datasets: BABYLON.IPerfDatasets; onVisibleRangeChangedObservable?: BABYLON.Observable; } /** * Defines the structure representing the preprocessable tooltip information. */ export interface ITooltipPreprocessedInformation { xForActualTimestamp: number; numberOfTooltipItems: number; longestText: string; focusedId: string; } export interface IPerfTooltipHoverPosition { xPos: number; yPos: number; } /** * Defines the supported timestamp units. */ export enum TimestampUnit { Milliseconds = 0, Seconds = 1, Minutes = 2, Hours = 3 } export class CanvasGraphService { private _ctx; private _width; private _height; private _sizeOfWindow; private _ticks; private _panPosition; private _position; private _datasetBounds; private _globalTimeMinMax; private _hoverPosition; private _drawableArea; private _axisHeight; private _tooltipItems; private _tooltipTextCache; private _tickerTextCache; private _tickerItems; private _preprocessedTooltipInfo; private _numberOfTickers; private _onVisibleRangeChangedObservable?; private readonly _addonFontLineHeight; private readonly _defaultLineHeight; readonly datasets: BABYLON.IPerfDatasets; metadata: Map; /** * Creates an instance of CanvasGraphService. * * @param canvas a pointer to the canvas dom element we would like to write to. * @param settings settings for our service. */ constructor(canvas: HTMLCanvasElement, settings: ICanvasGraphServiceSettings); /** * This method lets the service know it should get ready to update what it is displaying. */ update: (...args: any[]) => void; /** * Update the canvas graph service with the new height and width of the canvas. * @param size The new size of the canvas. */ resize(size: IPerfLayoutSize): void; /** * Force resets the position in the data, effectively returning to the most current data. */ resetDataPosition(): void; private _prevPointById; private _prevValueById; /** * This method draws the data and sets up the appropriate scales. */ private _draw; private _drawTickers; /** * Returns the index of the closest time for the datasets. * Uses a modified binary search to get value. * * @param targetTime the time we want to get close to. * @returns index of the item with the closest time to the targetTime */ private _getClosestPointToTimestamp; /** * This is a convenience method to get the number of collected slices. * @returns the total number of collected slices. */ private _getNumberOfSlices; /** * Draws the time axis, adjusts the drawable area for the graph. * * @param timeMinMax the minimum and maximum for the time axis. * @param drawableArea the current allocated drawable area. */ private _drawTimeAxis; /** * Given a timestamp (should be the maximum timestamp in view), this function returns the maximum unit the timestamp contains. * This information can be used for formatting purposes. * @param timestamp the maximum timestamp to find the maximum timestamp unit for. * @returns The maximum unit the timestamp has. */ private _getTimestampUnit; /** * Given a timestamp and the interval unit, this function will parse the timestamp to the appropriate format. * @param timestamp The timestamp to parse * @param intervalUnit The maximum unit of the maximum timestamp in an interval. * @returns a string representing the parsed timestamp. */ private _parseTimestamp; /** * Generates a list of ticks given the min and max of the axis, and the space available in the axis. * * @param minMax the minimum and maximum values of the axis * @param spaceAvailable the total amount of space we have allocated to our axis */ private _generateTicks; /** * Nice number algorithm based on psueudo code defined in "Graphics Gems" by Andrew S. Glassner. * This will find a "nice" number approximately equal to num. * * @param num The number we want to get close to. * @param shouldRound if true we will round the number, otherwise we will get the ceiling. * @returns a "nice" number approximately equal to num. */ private _niceNumber; /** * Gets the min and max as a single object from an array of numbers. * @param bounds * @param offset * @returns the min and max of the array. */ private _getMinMax; /** * Converts a single number to a pixel coordinate in a single axis by normalizing the data to a [0, 1] scale using the minimum and maximum values. * * @param num the number we want to get the pixel coordinate for * @param minMax the min and max of the dataset in the axis we want the pixel coordinate for. * @param startingPixel the starting pixel coordinate (this means it takes account for any offset). * @param spaceAvailable the total space available in this axis. * @param shouldFlipValue if we should use a [1, 0] scale instead of a [0, 1] scale. * @returns the pixel coordinate of the value in a single axis. */ private _getPixelForNumber; /** * Add in any necessary event listeners. * * @param canvas The canvas we want to attach listeners to. */ private _attachEventListeners; /** * We remove all event listeners we added. * * @param canvas The canvas we want to remove listeners from. */ private _removeEventListeners; /** * Handles what to do when we are hovering over the canvas and not panning. * * @param event A reference to the event to be handled. */ private _handleDataHover; /** * Debounced processing and drawing of tooltip. */ private _debouncedTooltip; /** * Handles what to do when we stop hovering over the canvas. */ private _handleStopHover; /** * Given a line defined by P1: (x1, y1) and P2: (x2, y2) get the distance of P0 (x0, y0) from the line. * https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_two_points * @param x1 x position of point P1 * @param y1 y position of point P1 * @param x2 x position of point P2 * @param y2 y position of point P2 * @param x0 x position of point P0 * @param y0 y position of point P0 * @returns distance of P0 from the line defined by P1 and P2 */ private _getDistanceFromLine; /** * This method does preprocessing calculations for the tooltip. * @param pos the position of our mouse. * @param drawableArea the remaining drawable area. */ private _preprocessTooltip; /** * Draws the tooltip given the area it is allowed to draw in and the current pixel position. * * @param pos the position of the mouse cursor in pixels (x, y). * @param drawableArea the available area we can draw in. */ private _drawTooltip; /** * Gets the number from a pixel position given the minimum and maximum value in range, and the starting pixel and the ending pixel. * * @param pixel current pixel position we want to get the number for. * @param minMax the minimum and maximum number in the range. * @param startingPixel position of the starting pixel in range. * @param endingPixel position of ending pixel in range. * @param shouldFlip if we should use a [1, 0] scale instead of a [0, 1] scale. * @returns number corresponding to pixel position */ private _getNumberFromPixel; /** * The handler for when we want to zoom in and out of the graph. * * @param event a mouse wheel event. */ private _handleZoom; /** * Initializes the panning object and attaches appropriate listener. * * @param event the mouse event containing positional information. */ private _handlePanStart; /** * While panning this event will keep track of the delta and update the "positions". * * @param event The mouse event that contains positional information. */ private _handlePan; /** * Clears the panning object and removes the appropriate listener. */ private _handlePanStop; /** * Method which returns true if the data should become realtime, false otherwise. * * @returns if the data should become realtime or not. */ private _shouldBecomeRealtime; /** * Will generate a playhead with a futurebox that takes up (1-scalefactor)*100% of the canvas. * * @param drawableArea The remaining drawable area. * @param scaleFactor The Percentage between 0.0 and 1.0 of the canvas the data gets drawn on. */ private _drawPlayheadRegion; /** * Method to do cleanup when the object is done being used. * */ destroy(): void; /** * This method clears the canvas */ clear(): void; } interface ICanvasGraphComponentProps { id: string; scene: BABYLON.Scene; collector: BABYLON.PerformanceViewerCollector; layoutObservable?: BABYLON.Observable; returnToPlayheadObservable?: BABYLON.Observable; onVisibleRangeChangedObservable?: BABYLON.Observable; initialGraphSize?: { width: number; height: number; }; } export var CanvasGraphComponent: React.FC; interface IEmbedHostComponentProps { scene: BABYLON.Scene; globalState: GlobalState; popupMode: boolean; noClose?: boolean; noExpand?: boolean; onClose: () => void; onPopup: () => void; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; additionalNodes?: BABYLON.IExplorerAdditionalNode[]; initialTab?: BABYLON.DebugLayerTab; } export class EmbedHostComponent extends React.Component { private _once; private _splitRef; private _topPartRef; private _bottomPartRef; constructor(props: IEmbedHostComponentProps); componentDidMount(): void; renderContent(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface ITabsComponentProps { children: any[]; selectedIndex: number; onSelectedIndexChange: (value: number) => void; } export class TabsComponent extends React.Component { constructor(props: ITabsComponentProps); onSelect(index: number): void; renderLabel(child: PaneComponent, index: number): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } export interface IPaneComponentProps { title: string; icon: any; scene: BABYLON.Scene; selectedEntity?: any; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; globalState: GlobalState; } export class PaneComponent extends React.Component { constructor(props: IPaneComponentProps); render(): JSX.Element | null; } interface IActionTabsComponentProps { scene?: BABYLON.Scene; noCommands?: boolean; noHeader?: boolean; noExpand?: boolean; noClose?: boolean; popupMode?: boolean; onPopup?: () => void; onClose?: () => void; globalState?: GlobalState; initialTab?: BABYLON.DebugLayerTab; } export class ActionTabsComponent extends React.Component { private _onSelectionChangeObserver; private _onTabChangedObserver; private _once; constructor(props: IActionTabsComponentProps); componentDidMount(): void; componentWillUnmount(): void; changeSelectedTab(index: number): void; renderContent(): import("react/jsx-runtime").JSX.Element | null; onClose(): void; onPopup(): void; render(): import("react/jsx-runtime").JSX.Element; } export class ToolsTabComponent extends PaneComponent { private _lockObject; private _videoRecorder; private _screenShotSize; private _gifOptions; private _useWidthHeight; private _isExportingGltf; private _gltfExportOptions; private _gifWorkerBlob; private _gifRecorder; private _previousRenderingScale; private _crunchingGIF; private _reflectorHostname; private _reflectorPort; private _reflector; private _envOptions; constructor(props: IPaneComponentProps); componentDidMount(): void; componentWillUnmount(): void; captureScreenshot(): void; captureEquirectangular(): void; captureRender(): void; recordVideo(): void; recordGIFInternal(): void; recordGIF(): void; importAnimations(event: any): void; exportGLTF(): void; exportBabylon(): void; createEnvTexture(): void; exportReplay(): void; startRecording(): void; applyDelta(file: File): void; connectReflector(): void; render(): import("react/jsx-runtime").JSX.Element | null; } export class StatisticsTabComponent extends PaneComponent { private _sceneInstrumentation; private _engineInstrumentation; private _timerIntervalId; constructor(props: IPaneComponentProps); componentWillUnmount(): void; render(): import("react/jsx-runtime").JSX.Element | null; } export class SettingsTabComponent extends PaneComponent { constructor(props: IPaneComponentProps); render(): import("react/jsx-runtime").JSX.Element; } export class PropertyGridTabComponent extends PaneComponent { private _timerIntervalId; private _lockObject; constructor(props: IPaneComponentProps); timerRefresh(): void; componentDidMount(): void; componentWillUnmount(): void; renderContent(): import("react/jsx-runtime").JSX.Element | null; renderTags(): import("react/jsx-runtime").JSX.Element[]; render(): import("react/jsx-runtime").JSX.Element; } export interface IPropertyComponentProps { globalState: GlobalState; block: BABYLON.NodeMaterialBlock; } interface IGradientStepComponentProps { globalState: GlobalState; step: BABYLON.GradientBlockColorStep; lineIndex: number; lockObject?: INSPECTOR.SharedUIComponents.LockObject; onDelete: () => void; onUpdateStep: () => void; onCheckForReOrder: () => void; onCopy?: () => void; } export class GradientStepComponent extends React.Component { constructor(props: IGradientStepComponentProps); updateColor(color: string): void; updateStep(gradient: number): void; onPointerUp(): void; render(): import("react/jsx-runtime").JSX.Element; } export class GradientPropertyTabComponent extends React.Component { private _gradientBlock; constructor(props: IPropertyComponentProps); forceRebuild(): void; deleteStep(step: BABYLON.GradientBlockColorStep): void; copyStep(step: BABYLON.GradientBlockColorStep): void; addNewStep(): void; checkForReOrder(): void; render(): import("react/jsx-runtime").JSX.Element; } export class DebugTabComponent extends PaneComponent { private _physicsViewersEnabled; private _namesViewerEnabled; constructor(props: IPaneComponentProps); switchPhysicsViewers(): void; switchNameViewerAsync(): Promise; render(): import("react/jsx-runtime").JSX.Element | null; } interface IGLTFComponentProps { scene: BABYLON.Scene; globalState: GlobalState; lockObject: INSPECTOR.SharedUIComponents.LockObject; } interface IGLTFComponentState { showGLTFLoaderOptions: boolean; showGLTFExtensionOptions: boolean; } export class GLTFComponent extends React.Component { private _onValidationResultsUpdatedObserver; constructor(props: IGLTFComponentProps); openValidationDetails(): void; prepareText(singularForm: string, count: number): string; componentDidMount(): void; componentWillUnmount(): void; renderValidation(): import("react/jsx-runtime").JSX.Element | null; render(): import("react/jsx-runtime").JSX.Element; } interface IVariantsPropertyGridComponentProps { globalState: GlobalState; host: any; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class VariantsPropertyGridComponent extends React.Component { constructor(props: IVariantsPropertyGridComponentProps); private _getVariantsExtension; render(): import("react/jsx-runtime").JSX.Element | null; } interface IScenePropertyGridComponentProps { globalState: GlobalState; scene: BABYLON.Scene; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; onSelectionChangedObservable?: BABYLON.Observable; } export class ScenePropertyGridComponent extends React.Component { private _storedEnvironmentTexture; private _renderingModeGroupObservable; constructor(props: IScenePropertyGridComponentProps); setRenderingModes(point: boolean, wireframe: boolean): void; switchIBL(): void; updateEnvironmentTexture(file: File): void; updateGravity(newValue: BABYLON.Vector3): void; updateTimeStep(newValue: number): void; normalizeScene(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IRenderGridPropertyGridComponentProps { globalState: GlobalState; scene: BABYLON.Scene; } export class RenderGridPropertyGridComponent extends React.Component { private _gridMesh; constructor(props: IRenderGridPropertyGridComponentProps); componentDidMount(): void; addOrRemoveGrid(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IParentPropertyGridComponentProps { globalState: GlobalState; lockObject: INSPECTOR.SharedUIComponents.LockObject; node: BABYLON.Node; onPropertyChangedObservable?: BABYLON.Observable; } export class ParentPropertyGridComponent extends React.Component { constructor(props: IParentPropertyGridComponentProps); private _getNameForSortingAndDisplay; render(): import("react/jsx-runtime").JSX.Element; } interface IFogPropertyGridComponentProps { globalState: GlobalState; scene: BABYLON.Scene; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class FogPropertyGridComponent extends React.Component { constructor(props: IFogPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IEmptyPropertyGridComponentProps { globalState: GlobalState; item: { inspectableCustomProperties: any; }; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class EmptyPropertyGridComponent extends React.Component { constructor(props: IEmptyPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ICustomPropertyGridComponentProps { globalState: GlobalState; target: any; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CustomPropertyGridComponent extends React.Component { constructor(props: ICustomPropertyGridComponentProps); renderInspectable(inspectable: BABYLON.IInspectable): import("react/jsx-runtime").JSX.Element | null; render(): import("react/jsx-runtime").JSX.Element | null; } interface ICommonPropertyGridComponentProps { globalState: GlobalState; host: { metadata: any; }; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonPropertyGridComponent extends React.Component { constructor(props: ICommonPropertyGridComponentProps); renderLevel(jsonObject: any): import("react/jsx-runtime").JSX.Element[]; render(): import("react/jsx-runtime").JSX.Element; } interface ISpritePropertyGridComponentProps { globalState: GlobalState; sprite: BABYLON.Sprite; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; onSelectionChangedObservable?: BABYLON.Observable; } export class SpritePropertyGridComponent extends React.Component { private _canvasRef; private _imageData; private _cachedCellIndex; constructor(props: ISpritePropertyGridComponentProps); onManagerLink(): void; switchPlayStopState(): void; disposeSprite(): void; componentDidMount(): void; componentDidUpdate(): void; shouldComponentUpdate(nextProps: ISpritePropertyGridComponentProps): boolean; updatePreview(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ISpriteManagerPropertyGridComponentProps { globalState: GlobalState; spriteManager: BABYLON.SpriteManager; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class SpriteManagerPropertyGridComponent extends React.Component { private _snippetUrl; constructor(props: ISpriteManagerPropertyGridComponentProps); addNewSprite(): void; disposeManager(): void; saveToFile(): void; loadFromFile(file: File): void; loadFromSnippet(): void; saveToSnippet(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ISoundPropertyGridComponentProps { globalState: GlobalState; sound: BABYLON.Sound; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class SoundPropertyGridComponent extends React.Component { constructor(props: ISoundPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISSRRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.SSRRenderingPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class SSRRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ISSRRenderingPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISSAORenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.SSAORenderingPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class SSAORenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ISSAORenderingPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISSAO2RenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.SSAO2RenderingPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class SSAO2RenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ISSAO2RenderingPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.PostProcessRenderPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class RenderingPipelinePropertyGridComponent extends React.Component { constructor(props: IRenderingPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IPostProcessPropertyGridComponentProps { globalState: GlobalState; postProcess: BABYLON.PostProcess; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class PostProcessPropertyGridComponent extends React.Component { constructor(props: IPostProcessPropertyGridComponentProps); edit(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ILenstRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.LensRenderingPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class LensRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ILenstRenderingPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IIblShadowsRenderPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.IblShadowsRenderPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class IblShadowsRenderPipelinePropertyGridComponent extends React.Component { constructor(props: IIblShadowsRenderPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IDefaultRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.DefaultRenderingPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class DefaultRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: IDefaultRenderingPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ICommonRenderingPipelinePropertyGridComponentProps { globalState: GlobalState; renderPipeline: BABYLON.PostProcessRenderPipeline; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonRenderingPipelinePropertyGridComponent extends React.Component { constructor(props: ICommonRenderingPipelinePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ICommonPostProcessPropertyGridComponentProps { globalState: GlobalState; postProcess: BABYLON.PostProcess; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonPostProcessPropertyGridComponent extends React.Component { constructor(props: ICommonPostProcessPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } export enum GradientGridMode { Factor = 0, Color3 = 1, Color4 = 2 } interface IValueGradientGridComponent { globalState: GlobalState; label: string; gradients: BABYLON.Nullable>; lockObject: INSPECTOR.SharedUIComponents.LockObject; docLink?: string; mode: GradientGridMode; host: BABYLON.IParticleSystem; codeRecorderPropertyName: string; onCreateRequired: () => void; onRemoveRequired: (step: BABYLON.IValueGradient) => void; } export class ValueGradientGridComponent extends React.Component { constructor(props: IValueGradientGridComponent); deleteStep(step: BABYLON.IValueGradient): void; addNewStep(): void; checkForReOrder(): void; updateAndSync(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ISphereEmitterGridComponentProps { globalState: GlobalState; emitter: BABYLON.SphereParticleEmitter; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class SphereEmitterGridComponent extends React.Component { constructor(props: ISphereEmitterGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IPointEmitterGridComponentProps { globalState: GlobalState; emitter: BABYLON.PointParticleEmitter; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class PointEmitterGridComponent extends React.Component { constructor(props: IPointEmitterGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IParticleSystemPropertyGridComponentProps { globalState: GlobalState; system: BABYLON.IParticleSystem; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class ParticleSystemPropertyGridComponent extends React.Component { private _snippetUrl; constructor(props: IParticleSystemPropertyGridComponentProps); renderEmitter(): import("react/jsx-runtime").JSX.Element | null; raiseOnPropertyChanged(property: string, newValue: any, previousValue: any): void; renderControls(): import("react/jsx-runtime").JSX.Element; saveToFile(): void; loadFromFile(file: File): void; loadFromSnippet(): void; saveToSnippet(): void; updateTexture(file: File): void; render(): import("react/jsx-runtime").JSX.Element; } interface IMeshEmitterGridComponentProps { globalState: GlobalState; emitter: BABYLON.MeshParticleEmitter; scene: BABYLON.Scene; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class MeshEmitterGridComponent extends React.Component { constructor(props: IMeshEmitterGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IHemisphericEmitterGridComponentProps { globalState: GlobalState; emitter: BABYLON.HemisphericParticleEmitter; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class HemisphericEmitterGridComponent extends React.Component { constructor(props: IHemisphericEmitterGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IFactorGradientStepGridComponent { globalState: GlobalState; gradient: BABYLON.FactorGradient; lockObject: INSPECTOR.SharedUIComponents.LockObject; lineIndex: number; onDelete: () => void; onUpdateGradient: () => void; onCheckForReOrder: () => void; host: BABYLON.IParticleSystem; codeRecorderPropertyName: string; } export class FactorGradientStepGridComponent extends React.Component { constructor(props: IFactorGradientStepGridComponent); shouldComponentUpdate(nextProps: IFactorGradientStepGridComponent, nextState: { gradient: number; factor1: string; factor2?: string; }): boolean; updateFactor1(valueString: string): void; updateFactor2(valueString: string): void; updateGradient(gradient: number): void; onPointerUp(): void; lock(): void; unlock(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ICylinderEmitterGridComponentProps { globalState: GlobalState; emitter: BABYLON.CylinderParticleEmitter; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CylinderEmitterGridComponent extends React.Component { constructor(props: ICylinderEmitterGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IConeEmitterGridComponentProps { globalState: GlobalState; emitter: BABYLON.ConeParticleEmitter; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class ConeEmitterGridComponent extends React.Component { constructor(props: IConeEmitterGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IColorGradientStepGridComponent { globalState: GlobalState; gradient: BABYLON.ColorGradient | BABYLON.Color3Gradient; lockObject: INSPECTOR.SharedUIComponents.LockObject; lineIndex: number; isColor3: boolean; onDelete: () => void; onUpdateGradient: () => void; onCheckForReOrder: () => void; host: BABYLON.IParticleSystem; codeRecorderPropertyName: string; } export class ColorGradientStepGridComponent extends React.Component { constructor(props: IColorGradientStepGridComponent); updateColor1(color: string): void; updateColor2(color: string): void; updateGradient(gradient: number): void; onPointerUp(): void; lock(): void; unlock(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IBoxEmitterGridComponentProps { globalState: GlobalState; emitter: BABYLON.BoxParticleEmitter; onPropertyChangedObservable?: BABYLON.Observable; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class BoxEmitterGridComponent extends React.Component { constructor(props: IBoxEmitterGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IAttractorsGridComponent { globalState: GlobalState; lockObject: INSPECTOR.SharedUIComponents.LockObject; docLink?: string; host: BABYLON.ParticleSystem; } export class AttractorsGridComponent extends React.Component { private _impostorMaterial; private _gizmoManager; private _sceneOnAfterRenderObserver; private _fontAsset; constructor(props: IAttractorsGridComponent); addNewAttractor(): void; updateImpostorScale(value: number): void; removeImpostor(attractor: BABYLON.Attractor): void; addImpostor(attractor: BABYLON.Attractor, index: number): void; addLabelAsync(attractor: BABYLON.Attractor, index: number): Promise; controlImpostor(attractor: BABYLON.Attractor, index: number): void; shouldComponentUpdate(nextProps: Readonly, nextState: Readonly<{ impostorScale: number; color: BABYLON.Color3; }>, nextContext: any): boolean; componentWillUnmount(): void; cleanup(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IAttractorGridComponent { globalState: GlobalState; attractor: BABYLON.Attractor; lockObject: INSPECTOR.SharedUIComponents.LockObject; lineIndex: number; host: BABYLON.IParticleSystem; codeRecorderPropertyName: string; onDelete: (attractor: BABYLON.Attractor) => void; removeImpostor: (attractor: BABYLON.Attractor) => void; addImpostor: (attractor: BABYLON.Attractor, index: number) => void; onControl: (attractor: BABYLON.Attractor, index: number) => void; isControlled: (attractor: BABYLON.Attractor) => boolean; } export class AttractorGridComponent extends React.Component { constructor(props: IAttractorGridComponent); lock(): void; unlock(): void; updateStrength(strength: number): void; onView(): void; onControl(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IMetadataComponentProps { globalState: GlobalState; entity: any; } enum MetadataTypes { UNDEFINED = "undefined", NULL = "null", STRING = "string", OBJECT = "Object", JSON = "JSON" } /** Metadata Grid Component */ export class MetadataGridComponent extends React.Component { private readonly _textAreaHost; /** * @param props - component props */ constructor(props: IMetadataComponentProps); /** @ignorenaming */ componentDidMount(): void; /** * @param prevProps - previous component props */ componentDidUpdate(prevProps: Readonly): void; /** on entity refresh */ refreshSelected(): void; /** * @param disabled - is disabled */ setTextAreaDisabled(disabled: boolean): void; /** * @returns class name */ getClassName(): string; /** * Determines the Metadata type * @param entity Picked entity * @returns MetadataTypes */ getEntityType(entity: any): MetadataTypes; /** * @param input - any input * @returns is string */ isString(input: any): boolean; /** * @param object - any object * @returns is parsable */ parsableJson(object: object): boolean; /** * @param string - any string * @returns parsable string */ parsableString(string: string): JSON | null; /** * @param validJson - a valid json * @param metadata - any metadata * @returns parsed metadata */ parseMetaObject(validJson: boolean, metadata: any): any; /** * Recurse through an object to check for any Functions, returns False if found at least one * @param o Any Object, String or number * @returns Boolean */ objectCanSafelyStringify(o: object | string | number | boolean): boolean; copyToClipboard(): void; /** Safely checks if valid JSON then appends necessary props without overwriting existing */ populateGltfExtras(): void; /** render * @returns the component */ render(): import("react/jsx-runtime").JSX.Element; } interface ITransformNodePropertyGridComponentProps { globalState: GlobalState; transformNode: BABYLON.TransformNode; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class TransformNodePropertyGridComponent extends React.Component { constructor(props: ITransformNodePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ISkeletonPropertyGridComponentProps { globalState: GlobalState; skeleton: BABYLON.Skeleton; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class SkeletonPropertyGridComponent extends React.Component { private _skeletonViewersEnabled; private _skeletonViewerDisplayOptions; private _skeletonViewers; constructor(props: ISkeletonPropertyGridComponentProps); switchSkeletonViewers(): void; checkSkeletonViewerState(props: ISkeletonPropertyGridComponentProps): void; changeDisplayMode(): void; changeDisplayOptions(option: string, value: number): void; shouldComponentUpdate(nextProps: ISkeletonPropertyGridComponentProps): boolean; render(): import("react/jsx-runtime").JSX.Element; } interface IMeshPropertyGridComponentProps { globalState: GlobalState; mesh: BABYLON.Mesh; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class MeshPropertyGridComponent extends React.Component { constructor(props: IMeshPropertyGridComponentProps); renderWireframeOver(): void; renderNormalVectors(): void; displayNormals(): void; displayVertexColors(): void; displayBoneWeights(): void; displaySkeletonMap(): void; onBoneDisplayIndexChange(value: number): void; onMaterialLink(): void; onSourceMeshLink(): void; onSkeletonLink(): void; convertPhysicsTypeToString(): string; private _getIdForDisplay; render(): import("react/jsx-runtime").JSX.Element; } interface IBonePropertyGridComponentProps { globalState: GlobalState; bone: BABYLON.Bone; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class BonePropertyGridComponent extends React.Component { constructor(props: IBonePropertyGridComponentProps); onTransformNodeLink(): void; render(): import("react/jsx-runtime").JSX.Element; } /** * Properties of the physics material grid component. */ export interface IPhysicsMaterialGridComponentProps { /** * Lock object */ lockObject: INSPECTOR.SharedUIComponents.LockObject; /** * Callback raised on the property changed event */ onPropertyChangedObservable?: BABYLON.Observable; /** * Physics body to edit */ body: BABYLON.PhysicsBody; /** * Global state */ globalState: GlobalState; } /** * Component that displays the physic material properties of a physics body. * @param props the component props * @returns the component */ export function PhysicsMaterialGridComponent(props: IPhysicsMaterialGridComponentProps): import("react/jsx-runtime").JSX.Element; /** * Properties of the physics mass properties grid component. */ export interface IPhysicsMassPropertiesGridComponentProps { /** * Lock object */ lockObject: INSPECTOR.SharedUIComponents.LockObject; /** * Callback raised on the property changed event */ onPropertyChangedObservable?: BABYLON.Observable; /** * Physics body to edit */ body: BABYLON.PhysicsBody; /** * Global state */ globalState: GlobalState; /** * Index of the instance to edit */ instanceIndex?: number; } /** * Component that displays the mass properties of a physics body. * @param props the component props * @returns the component */ export function PhysicsMassPropertiesGridComponent(props: IPhysicsMassPropertiesGridComponentProps): import("react/jsx-runtime").JSX.Element; /** * Properties of the physics body grid component. */ export interface IPhysicsBodyGridComponentProps { /** * Lock object */ lockObject: INSPECTOR.SharedUIComponents.LockObject; /** * Callback raised on the property changed event */ onPropertyChangedObservable?: BABYLON.Observable; /** * Physics body to edit */ body: BABYLON.PhysicsBody; /** * Global state */ globalState: GlobalState; } /** * Component that allows displaying and tweaking a physics body's properties. * @param props the component props * @returns the component */ export function PhysicsBodyGridComponent(props: IPhysicsBodyGridComponentProps): import("react/jsx-runtime").JSX.Element; interface ITexturePropertyGridComponentProps { texture: BABYLON.BaseTexture; lockObject: INSPECTOR.SharedUIComponents.LockObject; globalState: GlobalState; onPropertyChangedObservable?: BABYLON.Observable; } interface ITexturePropertyGridComponentState { isTextureEditorOpen: boolean; textureEditing: BABYLON.Nullable; } export class TexturePropertyGridComponent extends React.Component { private _adtInstrumentation; private _popoutWindowRef; private _textureLineRef; private _textureInspectorSize; constructor(props: ITexturePropertyGridComponentProps); componentWillUnmount(): void; updateTexture(file: File): void; openTextureEditor(): void; onOpenTextureEditor(): void; onCloseTextureEditor(callback?: { (): void; }): void; forceRefresh(): void; findTextureFormat(format: number): { label: string; normalizable: number; value: number; hideType?: undefined; compressed?: undefined; } | { label: string; normalizable: number; hideType: boolean; value: number; compressed?: undefined; } | { label: string; normalizable: number; compressed: boolean; value: number; hideType?: undefined; } | null; findTextureType(type: number): { label: string; normalizable: number; value: number; } | null; render(): import("react/jsx-runtime").JSX.Element; } interface IStandardMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.StandardMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class StandardMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IStandardMaterialPropertyGridComponentProps); renderTextures(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface ISkyMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.SkyMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } /** * Property grid component for the BABYLON.SkyMaterial */ export class SkyMaterialPropertyGridComponent extends React.Component { constructor(props: ISkyMaterialPropertyGridComponentProps); renderSky(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface IPBRSpecularGlossinessMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.PBRSpecularGlossinessMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class PBRSpecularGlossinessMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IPBRSpecularGlossinessMaterialPropertyGridComponentProps); renderTextures(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface IPBRMetallicRoughnessMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.PBRMetallicRoughnessMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class PBRMetallicRoughnessMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IPBRMetallicRoughnessMaterialPropertyGridComponentProps); renderTextures(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface IPBRMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.PBRMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } /** * @internal */ export class PBRMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IPBRMaterialPropertyGridComponentProps); switchAmbientMode(state: boolean): void; renderTextures(onDebugSelectionChangeObservable: BABYLON.Observable): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface INodeMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.NodeMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class NodeMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: INodeMaterialPropertyGridComponentProps); edit(): void; renderTextures(): import("react/jsx-runtime").JSX.Element | null; renderInputBlock(block: BABYLON.InputBlock): import("react/jsx-runtime").JSX.Element | null; renderInputValues(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface IMultiMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.MultiMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class MultiMaterialPropertyGridComponent extends React.Component { constructor(props: IMultiMaterialPropertyGridComponentProps); onMaterialLink(mat: BABYLON.Material): void; renderChildMaterial(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface IMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.Material; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class MaterialPropertyGridComponent extends React.Component { constructor(props: IMaterialPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ICommonMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.Material; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonMaterialPropertyGridComponent extends React.Component { constructor(props: ICommonMaterialPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IBackgroundMaterialPropertyGridComponentProps { globalState: GlobalState; material: BABYLON.BackgroundMaterial; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class BackgroundMaterialPropertyGridComponent extends React.Component { private _onDebugSelectionChangeObservable; constructor(props: IBackgroundMaterialPropertyGridComponentProps); renderTextures(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } interface IToolSettingsProps { tool: ITool | undefined; } export class ToolSettings extends React.Component { render(): import("react/jsx-runtime").JSX.Element; } export interface ITool extends IToolData { instance: IToolType; } interface IToolBarProps { tools: ITool[]; addTool(url: string): void; changeTool(toolIndex: number): void; activeToolIndex: number; metadata: IMetadata; setMetadata(data: any): void; pickerOpen: boolean; setPickerOpen(open: boolean): void; pickerRef: React.RefObject; hasAlpha: boolean; } interface IToolBarState { toolURL: string; addOpen: boolean; } export class ToolBar extends React.Component { private _lockObject; constructor(props: IToolBarProps); computeRGBAColor(): BABYLON.Color4; shouldComponentUpdate(nextProps: IToolBarProps): boolean; render(): import("react/jsx-runtime").JSX.Element; } interface ITextureEditorComponentProps { texture: BABYLON.BaseTexture; url: string; window: React.RefObject; onUpdate: () => void; } interface ITextureEditorComponentState { tools: ITool[]; activeToolIndex: number; metadata: IMetadata; channels: IChannel[]; pixelData: IPixelData; face: number; mipLevel: number; pickerOpen: boolean; } export interface IToolParameters { /** The visible scene in the editor. Useful for adding pointer and keyboard events. */ scene: BABYLON.Scene; /** The 2D canvas which you can sample pixel data from. Tools should not paint directly on this canvas. */ canvas2D: HTMLCanvasElement; /** The 3D scene which tools can add post processes to. */ scene3D: BABYLON.Scene; /** The size of the texture. */ size: BABYLON.ISize; /** Pushes the editor texture back to the original scene. This should be called every time a tool makes any modification to a texture. */ updateTexture: () => void; /** The metadata object which is shared between all tools. Feel free to store any information here. Do not set this directly: instead call setMetadata. */ metadata: IMetadata; /** Call this when you want to mutate the metadata. */ setMetadata: (data: any) => void; /** Returns the texture coordinates under the cursor */ getMouseCoordinates: (pointerInfo: BABYLON.PointerInfo) => BABYLON.Vector2; /** Provides a canvas that you can use the canvas API to paint on. */ startPainting: () => Promise; /** After you have painted on your canvas, call this method to push the updates back to the texture. */ updatePainting: () => void; /** Call this when you are finished painting. */ stopPainting: () => void; /** Returns whether the tool should be allowed to interact */ interactionEnabled: () => boolean; } export interface IToolGUIProps { instance: IToolType; } /** An interface representing the definition of a tool */ export interface IToolData { /** Name to display on the toolbar */ name: string; /** A class definition for the tool including setup and cleanup methods */ type: IToolConstructable; /** An SVG icon encoded in Base64 */ icon: string; /** Whether the tool uses postprocesses */ is3D?: boolean; cursor?: string; settingsComponent?: React.ComponentType; } export interface IToolType { /** Called when the tool is selected. */ setup: () => void; /** Called when the tool is deselected. */ cleanup: () => void; /** Optional. Called when the user resets the texture or uploads a new texture. Tools may want to reset their state when this happens. */ onReset?: () => void; } /** For constructable types, TS requires that you define a separate interface which constructs your actual interface */ interface IToolConstructable { new (getParameters: () => IToolParameters): IToolType; } export interface IMetadata { color: string; alpha: number; select: { x1: number; y1: number; x2: number; y2: number; }; [key: string]: any; } export class TextureEditorComponent extends React.Component { private _textureCanvasManager; private _uiCanvas; private _2DCanvas; private _3DCanvas; private _pickerRef; private _timer; private static _PREVIEW_UPDATE_DELAY_MS; constructor(props: ITextureEditorComponentProps); componentDidMount(): void; componentDidUpdate(): void; componentWillUnmount(): void; textureDidUpdate(): void; loadToolFromURL(url: string): void; addTools(tools: IToolData[]): void; getToolParameters(): IToolParameters; changeTool(index: number): void; setMetadata(newMetadata: any): void; setPickerOpen(open: boolean): void; onPointerDown(evt: React.PointerEvent): void; saveTexture(): void; resetTexture(): void; resizeTexture(width: number, height: number): void; uploadTexture(file: File): void; render(): import("react/jsx-runtime").JSX.Element; } export interface IPixelData { x?: number; y?: number; r?: number; g?: number; b?: number; a?: number; } export class TextureCanvasManager { private _engine; private _scene; private _camera; private _cameraPos; private _scale; private _isPanning; private _mouseX; private _mouseY; private _uiCanvas; private _size; /** The canvas we paint onto using the canvas API */ private _2DCanvas; /** The canvas we apply post processes to */ private _3DCanvas; /** The canvas which handles channel filtering */ private _channelsTexture; private _3DEngine; private _3DPlane; private _3DCanvasTexture; private _3DScene; private _channels; private _face; private _mipLevel; /** The texture from the original engine that we invoked the editor on */ private _originalTexture; /** This is a hidden texture which is only responsible for holding the actual texture memory in the original engine */ private _target; private _originalTextureProperties; /** Keeps track of whether we have modified the texture */ private _didEdit; private _plane; private _planeMaterial; /** Tracks which keys are currently pressed */ private _keyMap; /** Tracks which mouse buttons are currently pressed */ private _buttonsPressed; private readonly ZOOM_MOUSE_SPEED; private readonly ZOOM_KEYBOARD_SPEED; private readonly ZOOM_IN_KEY; private readonly ZOOM_OUT_KEY; private readonly PAN_SPEED; private readonly PAN_KEY; private readonly MIN_SCALE; private readonly GRID_SCALE; private readonly MAX_SCALE; private readonly SELECT_ALL_KEY; private readonly SAVE_KEY; private readonly RESET_KEY; private readonly DESELECT_KEY; /** The number of milliseconds between texture updates */ private readonly PUSH_FREQUENCY; private _tool; private _setPixelData; private _setMipLevel; private _window; private _metadata; private _editing3D; private _onUpdate; private _setMetadata; private _imageData; private _canPush; private _shouldPush; private _paintCanvas; constructor(texture: BABYLON.BaseTexture, window: Window, canvasUI: HTMLCanvasElement, canvas2D: HTMLCanvasElement, canvas3D: HTMLCanvasElement, setPixelData: (pixelData: IPixelData) => void, metadata: IMetadata, onUpdate: () => void, setMetadata: (metadata: any) => void, setMipLevel: (level: number) => void); updateTexture(): Promise; private pushTexture; startPainting(): Promise; updatePainting(): void; stopPainting(): void; private updateDisplay; set channels(channels: IChannel[]); paintPixelsOnCanvas(pixelData: Uint8Array, canvas: HTMLCanvasElement): void; grabOriginalTexture(): Promise>; getMouseCoordinates(pointerInfo: BABYLON.PointerInfo): BABYLON.Vector2; get scene(): BABYLON.Scene; get canvas2D(): HTMLCanvasElement; get size(): BABYLON.ISize; set tool(tool: BABYLON.Nullable); get tool(): BABYLON.Nullable; set face(face: number); set mipLevel(mipLevel: number); /** Returns the 3D scene used for postprocesses */ get scene3D(): BABYLON.Scene; set metadata(metadata: IMetadata); private makePlane; reset(): void; resize(newSize: BABYLON.ISize): Promise; setSize(size: BABYLON.ISize): void; upload(file: File): void; saveTexture(): void; toolInteractionEnabled(): boolean; dispose(): void; } interface ITextureCanvasComponentProps { canvasUI: React.RefObject; canvas2D: React.RefObject; canvas3D: React.RefObject; texture: BABYLON.BaseTexture; } export class TextureCanvasComponent extends React.Component { render(): import("react/jsx-runtime").JSX.Element; } interface IPropertiesBarProps { texture: BABYLON.BaseTexture; size: BABYLON.ISize; saveTexture(): void; pixelData: IPixelData; face: number; setFace(face: number): void; resetTexture(): void; resizeTexture(width: number, height: number): void; uploadTexture(file: File): void; mipLevel: number; setMipLevel: (mipLevel: number) => void; } interface IPropertiesBarState { width: number; height: number; } export class PropertiesBar extends React.PureComponent { private _faces; constructor(props: IPropertiesBarProps); private _pixelData; private _getNewDimension; componentWillUpdate(nextProps: IPropertiesBarProps): void; render(): import("react/jsx-runtime").JSX.Element; } export interface IChannel { visible: boolean; editable: boolean; name: string; id: "R" | "G" | "B" | "A"; icon: any; } interface IChannelsBarProps { channels: IChannel[]; setChannels(channelState: IChannel[]): void; } export class ChannelsBar extends React.PureComponent { render(): import("react/jsx-runtime").JSX.Element; } export var canvasShader: { path: { vertexSource: string; fragmentSource: string; }; options: { attributes: string[]; uniforms: string[]; }; }; interface IBottomBarProps { texture: BABYLON.BaseTexture; mipLevel: number; } export class BottomBar extends React.PureComponent { render(): import("react/jsx-runtime").JSX.Element; } export var RectangleSelect: IToolData; export var Paintbrush: IToolData; export var Floodfill: IToolData; export var Eyedropper: IToolData; var _default: IToolData[]; export var Contrast: IToolData; interface ISpotLightPropertyGridComponentProps { globalState: GlobalState; light: BABYLON.SpotLight; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; onSelectionChangedObservable?: BABYLON.Observable; } export class SpotLightPropertyGridComponent extends React.Component { constructor(props: ISpotLightPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IRectAreaLightPropertyGridComponentProps { globalState: GlobalState; light: BABYLON.RectAreaLight; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; onSelectionChangedObservable?: BABYLON.Observable; } export class RectAreaLightPropertyGridComponent extends React.Component { constructor(props: IRectAreaLightPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IPointLightPropertyGridComponentProps { globalState: GlobalState; light: BABYLON.PointLight; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class PointLightPropertyGridComponent extends React.Component { constructor(props: IPointLightPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IHemisphericLightPropertyGridComponentProps { globalState: GlobalState; light: BABYLON.HemisphericLight; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class HemisphericLightPropertyGridComponent extends React.Component { constructor(props: IHemisphericLightPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IDirectionalLightPropertyGridComponentProps { globalState: GlobalState; light: BABYLON.DirectionalLight; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class DirectionalLightPropertyGridComponent extends React.Component { constructor(props: IDirectionalLightPropertyGridComponentProps); displayFrustum(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ICommonShadowLightPropertyGridComponentProps { globalState: GlobalState; light: BABYLON.IShadowLight; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonShadowLightPropertyGridComponent extends React.Component { private _internals; constructor(props: ICommonShadowLightPropertyGridComponentProps); createShadowGenerator(): void; disposeShadowGenerator(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ICommonLightPropertyGridComponentProps { globalState: GlobalState; light: BABYLON.Light; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonLightPropertyGridComponent extends React.Component { constructor(props: ICommonLightPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ILayerPropertyGridComponentProps { globalState: GlobalState; layer: BABYLON.EffectLayer; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class LayerPropertyGridComponent extends React.Component { constructor(props: ILayerPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IFrameGraphPropertyGridComponentProps { globalState: GlobalState; frameGraph: BABYLON.FrameGraph; extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[]; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class FrameGraphPropertyGridComponent extends React.Component { constructor(props: IFrameGraphPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IFreeCameraPropertyGridComponentProps { globalState: GlobalState; camera: BABYLON.FreeCamera; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class FreeCameraPropertyGridComponent extends React.Component { constructor(props: IFreeCameraPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IFollowCameraPropertyGridComponentProps { globalState: GlobalState; camera: BABYLON.FollowCamera; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class FollowCameraPropertyGridComponent extends React.Component { constructor(props: IFollowCameraPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ICommonCameraPropertyGridComponentProps { globalState: GlobalState; camera: BABYLON.Camera; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonCameraPropertyGridComponent extends React.Component { constructor(props: ICommonCameraPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IArcRotateCameraPropertyGridComponentProps { globalState: GlobalState; camera: BABYLON.ArcRotateCamera; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class ArcRotateCameraPropertyGridComponent extends React.Component { constructor(props: IArcRotateCameraPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface ITargetedAnimationGridComponentProps { globalState: GlobalState; targetedAnimation: BABYLON.TargetedAnimation; scene: BABYLON.Scene; lockObject: INSPECTOR.SharedUIComponents.LockObject; onSelectionChangedObservable?: BABYLON.Observable; onPropertyChangedObservable?: BABYLON.Observable; } export class TargetedAnimationGridComponent extends React.Component { private _animationGroup; private _animationCurveEditorContext; constructor(props: ITargetedAnimationGridComponentProps); findAnimationGroup: () => void; playOrPause: () => void; deleteAnimation: () => void; updateContextFromProps: () => void; componentDidMount(): void; componentDidUpdate(prevProps: Readonly, prevState: Readonly<{}>, snapshot?: any): void; render(): import("react/jsx-runtime").JSX.Element; } interface IAnimationGridComponentProps { globalState: GlobalState; animatable: BABYLON.IAnimatable; scene: BABYLON.Scene; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class AnimationGridComponent extends React.Component { private _animations; private _ranges; private _mainAnimatable; private _onBeforeRenderObserver; private _isPlaying; private _timelineRef; private _animationCurveEditorContext; private _animationControl; constructor(props: IAnimationGridComponentProps); playOrPause(): void; componentDidMount(): void; componentWillUnmount(): void; onCurrentFrameChange(value: number): void; onChangeFromOrTo(): void; componentDidUpdate(prevProps: IAnimationGridComponentProps): void; render(): import("react/jsx-runtime").JSX.Element; } interface IAnimationGroupGridComponentProps { globalState: GlobalState; animationGroup: BABYLON.AnimationGroup; scene: BABYLON.Scene; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class AnimationGroupGridComponent extends React.Component { private _onAnimationGroupPlayObserver; private _onAnimationGroupPauseObserver; private _onBeforeRenderObserver; private _timelineRef; private _animationCurveEditorContext; constructor(props: IAnimationGroupGridComponentProps); componentDidMount(): void; disconnect(animationGroup: BABYLON.AnimationGroup): void; connect(animationGroup: BABYLON.AnimationGroup): void; updateCurrentFrame(animationGroup: BABYLON.AnimationGroup): void; shouldComponentUpdate(nextProps: IAnimationGroupGridComponentProps): boolean; componentWillUnmount(): void; playOrPause(): void; onCurrentFrameChange(value: number): void; render(): import("react/jsx-runtime").JSX.Element; } interface ITopBarComponentProps { globalState: GlobalState; context: Context; } interface ITopBarComponentState { keyFrameValue: string; keyValue: string; frameControlEnabled: boolean; valueControlEnabled: boolean; } export class TopBarComponent extends React.Component { private _onFrameSetObserver; private _onValueSetObserver; private _onActiveAnimationChangedObserver; private _onActiveKeyPointChanged; constructor(props: ITopBarComponentProps); componentWillUnmount(): void; render(): import("react/jsx-runtime").JSX.Element; } export interface IActiveAnimationChangedOptions { evaluateKeys?: boolean; frame?: boolean; range?: boolean; } export class Context { title: string; animations: BABYLON.Nullable; scene: BABYLON.Scene; target: BABYLON.Nullable; rootAnimationGroup: BABYLON.Nullable; activeAnimations: BABYLON.Animation[]; activeChannels: { [key: number]: string; }; activeKeyPoints: BABYLON.Nullable; mainKeyPoint: BABYLON.Nullable; snippetId: string; useTargetAnimations: boolean; activeFrame: number; fromKey: number; toKey: number; useExistingPlayRange: boolean; forwardAnimation: boolean; isPlaying: boolean; clipLength: number; referenceMinFrame: number; referenceMaxFrame: number; focusedInput: boolean; onActiveAnimationChanged: BABYLON.Observable; onActiveKeyPointChanged: BABYLON.Observable; onHostWindowResized: BABYLON.Observable; onSelectAllKeys: BABYLON.Observable; onActiveKeyFrameChanged: BABYLON.Observable; onFrameSet: BABYLON.Observable; onFrameManuallyEntered: BABYLON.Observable; onMainKeyPointSet: BABYLON.Observable; onMainKeyPointMoved: BABYLON.Observable; onValueSet: BABYLON.Observable; onValueManuallyEntered: BABYLON.Observable; onFrameRequired: BABYLON.Observable; onCreateOrUpdateKeyPointRequired: BABYLON.Observable; onFlattenTangentRequired: BABYLON.Observable; onLinearTangentRequired: BABYLON.Observable; onBreakTangentRequired: BABYLON.Observable; onUnifyTangentRequired: BABYLON.Observable; onStepTangentRequired: BABYLON.Observable; onDeleteAnimation: BABYLON.Observable; onGraphMoved: BABYLON.Observable; onGraphScaled: BABYLON.Observable; onRangeUpdated: BABYLON.Observable; onMoveToFrameRequired: BABYLON.Observable; onAnimationStateChanged: BABYLON.Observable; onDeleteKeyActiveKeyPoints: BABYLON.Observable; onSelectionRectangleMoved: BABYLON.Observable; onAnimationsLoaded: BABYLON.Observable; onEditAnimationRequired: BABYLON.Observable; onEditAnimationUIClosed: BABYLON.Observable; onClipLengthIncreased: BABYLON.Observable; onClipLengthDecreased: BABYLON.Observable; onInterpolationModeSet: BABYLON.Observable<{ keyId: number; value: BABYLON.AnimationKeyInterpolation; }>; onSelectToActivated: BABYLON.Observable<{ from: number; to: number; }>; onRangeFrameBarResized: BABYLON.Observable; onPlayheadMoved: BABYLON.Observable; lockLastFrameValue: boolean; lockLastFrameFrame: boolean; onActiveKeyDataChanged: BABYLON.Observable; prepare(): void; play(forward: boolean): void; stop(): void; moveToFrame(frame: number): void; refreshTarget(): void; clearSelection(): void; enableChannel(animation: BABYLON.Animation, color: string): void; disableChannel(animation: BABYLON.Animation): void; isChannelEnabled(animation: BABYLON.Animation, color: string): boolean; getActiveChannel(animation: BABYLON.Animation): string; resetAllActiveChannels(): void; getAnimationSortIndex(animation: BABYLON.Animation): number; getPrevKey(): BABYLON.Nullable; getNextKey(): BABYLON.Nullable; /** * If any current active animation has a key at the received frameNumber, * return the index of the animation in the active animation array, and * the index of the frame on the animation. * @param frameNumber the frame number to look for * @returns null if no key was found, or an object with the animation index and key index */ getKeyAtAnyFrameIndex(frameNumber: number): { animationIndex: number; keyIndex: number; } | null; /** * @returns true if any active animation has a quaternion animation */ hasActiveQuaternionAnimationKeyPoints(): boolean; } interface IAnimationCurveEditorComponentProps { globalState: GlobalState; context: Context; } interface IAnimationCurveEditorComponentState { isOpen: boolean; } export class AnimationCurveEditorComponent extends React.Component { constructor(props: IAnimationCurveEditorComponentProps); onCloseAnimationCurveEditor(window: Window | null): void; shouldComponentUpdate(newProps: IAnimationCurveEditorComponentProps, newState: IAnimationCurveEditorComponentState): boolean; private _onKeyDown; render(): import("react/jsx-runtime").JSX.Element; } interface ISideBarComponentProps { globalState: GlobalState; context: Context; } interface ISideBarComponentState { mode: Mode; } enum Mode { Edit = 0, Add = 1, Load = 2, Save = 3 } export class SideBarComponent extends React.Component { constructor(props: ISideBarComponentProps); private _onAddAnimation; private _onLoadAnimation; private _onSaveAnimation; private _onEditAnimation; render(): import("react/jsx-runtime").JSX.Element; } interface ISaveAnimationComponentProps { globalState: GlobalState; context: Context; } interface ISaveAnimationComponentState { } export class SaveAnimationComponent extends React.Component { private _selectedAnimations; private _root; constructor(props: ISaveAnimationComponentProps); private _getJson; saveToSnippetServer(): void; saveToFile(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ILoadAnimationComponentProps { globalState: GlobalState; context: Context; } interface ILoadAnimationComponentState { } export class LoadAnimationComponent extends React.Component { private _root; private _textInput; constructor(props: ILoadAnimationComponentProps); loadFromFile(evt: React.ChangeEvent): void; loadFromSnippetServer(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IEditAnimationComponentProps { globalState: GlobalState; context: Context; } interface IEditAnimationComponentState { isVisible: boolean; animation: BABYLON.Nullable; } export class EditAnimationComponent extends React.Component { private _root; private _displayName; private _property; private _loopModeElement; private _onEditAnimationRequiredObserver; constructor(props: IEditAnimationComponentProps); componentWillUnmount(): void; close(): void; validate(): void; render(): import("react/jsx-runtime").JSX.Element | null; } interface IAnimationSubEntryComponentProps { globalState: GlobalState; context: Context; animation: BABYLON.Animation; color: string; subName: string; } interface IAnimationSubEntryComponentState { isSelected: boolean; } export class AnimationSubEntryComponent extends React.Component { private _onActiveAnimationChangedObserver; private _onActiveKeyPointChangedObserver; constructor(props: IAnimationSubEntryComponentProps); componentWillUnmount(): void; private _activate; render(): import("react/jsx-runtime").JSX.Element; } interface IAnimationListComponentProps { globalState: GlobalState; context: Context; } interface IAnimationListComponentState { isVisible: boolean; } export class AnimationListComponent extends React.Component { private _onEditAnimationRequiredObserver; private _onEditAnimationUIClosedObserver; private _onDeleteAnimationObserver; constructor(props: IAnimationListComponentProps); componentWillUnmount(): void; render(): import("react/jsx-runtime").JSX.Element | null; } interface IAnimationEntryComponentProps { globalState: GlobalState; context: Context; animation: BABYLON.Animation; } interface IAnimationEntryComponentState { isExpanded: boolean; isSelected: boolean; } export class AnimationEntryComponent extends React.Component { private _onActiveAnimationChangedObserver; private _onActiveKeyPointChangedObserver; private _onSelectToActivatedObserver; private _unmount; constructor(props: IAnimationEntryComponentProps); private _onGear; private _onDelete; componentWillUnmount(): void; private _activate; private _expandOrCollapse; render(): import("react/jsx-runtime").JSX.Element; } interface IAddAnimationComponentProps { globalState: GlobalState; context: Context; } interface IAddAnimationComponentState { customPropertyMode: boolean; } export class AddAnimationComponent extends React.Component { private _root; private _displayName; private _property; private _typeElement; private _propertylement; private _loopModeElement; constructor(props: IAddAnimationComponentProps); createNew(): void; getInferredType(activeProperty?: string): any; render(): import("react/jsx-runtime").JSX.Element; } interface IRangeFrameBarComponentProps { globalState: GlobalState; context: Context; } interface IRangeFrameBarComponentState { } export class RangeFrameBarComponent extends React.Component { private _svgHost; private _viewWidth; private _offsetX; private _isMounted; private _onActiveAnimationChangedObserver; private _onPlayheadMovedObserver; private _onFrameManuallyEnteredObserver; constructor(props: IRangeFrameBarComponentProps); componentDidMount(): void; componentWillUnmount(): void; private _computeSizes; private _dropKeyFrames; private _buildActiveFrame; private _buildFrames; render(): import("react/jsx-runtime").JSX.Element; } interface IPlayHeadComponentProps { globalState: GlobalState; context: Context; } interface IPlayHeadComponentState { } export class PlayHeadComponent extends React.Component { private readonly _graphAbsoluteWidth; private _playHead; private _playHeadCircle; private _onBeforeRenderObserver; private _onActiveAnimationChangedObserver; private _onRangeFrameBarResizedObserver; private _onMoveToFrameRequiredObserver; private _onGraphMovedObserver; private _onGraphScaledObserver; private _viewScale; private _offsetX; private _offsetRange; private _viewWidth; private readonly _rangeWidthToPlayheadWidth; private _pointerIsDown; constructor(props: IPlayHeadComponentProps); private _moveHead; private _frameToPixel; private _pixelToFrame; componentWillUnmount(): void; private _getPixelValues; private _onPointerDown; private _onPointerMove; private _onPointerUp; render(): import("react/jsx-runtime").JSX.Element | null; } interface IKeyPointComponentProps { x: number; y: number; getPreviousX: () => BABYLON.Nullable; getNextX: () => BABYLON.Nullable; invertX: (x: number) => number; invertY: (y: number) => number; convertX: (x: number) => number; convertY: (y: number) => number; nextX?: number; scale: number; keyId: number; curve: Curve; context: Context; channel: string; onFrameValueChanged: (value: number) => void; onKeyValueChanged: (value: number) => void; } interface IKeyPointComponentState { selectedState: SelectionState; tangentSelectedIndex: number; x: number; y: number; } export enum SelectionState { None = 0, Selected = 1, Siblings = 2 } export class KeyPointComponent extends React.Component { private _onActiveKeyPointChangedObserver; private _onActiveKeyFrameChangedObserver; private _onFrameManuallyEnteredObserver; private _onValueManuallyEnteredObserver; private _onMainKeyPointSetObserver; private _onMainKeyPointMovedObserver; private _onSelectionRectangleMovedObserver; private _onFlattenTangentRequiredObserver; private _onLinearTangentRequiredObserver; private _onBreakTangentRequiredObserver; private _onUnifyTangentRequiredObserver; private _onStepTangentRequiredObserver; private _onSelectAllKeysObserver; private _pointerIsDown; private _sourcePointerX; private _sourcePointerY; private _offsetXToMain; private _offsetYToMain; private _svgHost; private _keyPointSVG; private _controlMode; private _storedLengthIn; private _storedLengthOut; private _inVec; private _outVec; private _lockX; private _lockY; private _accumulatedX; private _accumulatedY; constructor(props: IKeyPointComponentProps); componentWillUnmount(): void; shouldComponentUpdate(newProps: IKeyPointComponentProps, newState: IKeyPointComponentState): boolean; private _breakTangent; private _unifyTangent; private _flattenTangent; private _linearTangent; private _stepTangent; private _select; private _onPointerDown; private _extractSlope; private _processTangentMove; private _onPointerMove; private _onPointerUp; render(): import("react/jsx-runtime").JSX.Element | null; } interface IGraphComponentProps { globalState: GlobalState; context: Context; } interface IGraphComponentState { } export class GraphComponent extends React.Component { private readonly _minScale; private readonly _maxScale; private readonly _graphAbsoluteWidth; private readonly _graphAbsoluteHeight; private _viewWidth; private _viewCurveWidth; private _viewHeight; private _viewScale; private _offsetX; private _offsetY; private _inSelectionMode; private _graphOffsetX; private _minValue; private _maxValue; private _minFrame; private _maxFrame; private _svgHost; private _svgHost2; private _selectionRectangle; private _curves; private _pointerIsDown; private _sourcePointerX; private _sourcePointerY; private _selectionMade; private _selectionStartX; private _selectionStartY; private _onActiveAnimationChangedObserver; constructor(props: IGraphComponentProps); componentWillUnmount(): void; private _computeSizes; private _setDefaultInTangent; private _setDefaultOutTangent; private _evaluateKeys; private _extractValuesFromKeys; private _convertX; private _invertX; private _convertY; private _invertY; private _buildFrameIntervalAxis; private _buildYAxis; private _frameFromActiveKeys; private _dropKeyFrames; private _onPointerDown; private _onPointerMove; private _onPointerUp; private _onWheel; render(): import("react/jsx-runtime").JSX.Element; } interface IFrameBarComponentProps { globalState: GlobalState; context: Context; } interface IFrameBarComponentState { } export class FrameBarComponent extends React.Component { private readonly _graphAbsoluteWidth; private _svgHost; private _viewWidth; private _viewScale; private _offsetX; private _onActiveAnimationChangedObserver; constructor(props: IFrameBarComponentProps); componentWillUnmount(): void; private _computeSizes; private _buildFrames; render(): import("react/jsx-runtime").JSX.Element; } interface ICurveComponentProps { curve: Curve; convertX: (x: number) => number; convertY: (x: number) => number; context: Context; } interface ICurveComponentState { isSelected: boolean; } export class CurveComponent extends React.Component { private _onDataUpdatedObserver; private _onActiveAnimationChangedObserver; private _onInterpolationModeSetObserver; constructor(props: ICurveComponentProps); componentWillUnmount(): void; componentDidUpdate(): boolean; render(): import("react/jsx-runtime").JSX.Element | null; } export interface KeyEntry { frame: number; value: number; inTangent?: number; outTangent?: number; lockedTangent: boolean; interpolation?: BABYLON.AnimationKeyInterpolation; } export class Curve { static readonly SampleRate = 50; keys: KeyEntry[]; animation: BABYLON.Animation; color: string; onDataUpdatedObservable: BABYLON.Observable; property?: string; tangentBuilder?: () => any; setDefaultInTangent?: (keyId: number) => any; setDefaultOutTangent?: (keyId: number) => any; static readonly TangentLength = 50; constructor(color: string, animation: BABYLON.Animation, property?: string, tangentBuilder?: () => any, setDefaultInTangent?: (keyId: number) => any, setDefaultOutTangent?: (keyId: number) => any); getPathData(convertX: (x: number) => number, convertY: (y: number) => number): string; updateLockedTangentMode(keyIndex: number, enabled: boolean): void; updateInterpolationMode(keyIndex: number, interpolationMode: BABYLON.AnimationKeyInterpolation): void; getInControlPoint(keyIndex: number): number | undefined; getOutControlPoint(keyIndex: number): number | undefined; hasDefinedOutTangent(keyIndex: number): boolean; evaluateOutTangent(keyIndex: number): number; hasDefinedInTangent(keyIndex: number): boolean; evaluateInTangent(keyIndex: number): number; storeDefaultInTangent(keyIndex: number): void; storeDefaultOutTangent(keyIndex: number): void; updateInTangentFromControlPoint(keyId: number, slope: number): void; updateOutTangentFromControlPoint(keyId: number, slope: number): void; updateKeyFrame(keyId: number, frame: number): void; updateKeyValue(keyId: number, value: number): void; } interface ICanvasComponentProps { globalState: GlobalState; context: Context; } interface ICanvasComponentState { } export class CanvasComponent extends React.Component { private _onActiveAnimationChangedObserver; constructor(props: ICanvasComponentProps); componentWillUnmount(): void; render(): import("react/jsx-runtime").JSX.Element; } interface ITextInputComponentProps { globalState: GlobalState; context: Context; id?: string; className?: string; tooltip?: string; value: string; isNumber?: boolean; complement?: string; onValueAsNumberChanged?: (value: number, isFocused: boolean) => void; disabled?: boolean; } interface ITextInputComponentState { value: string; isFocused: boolean; } export class TextInputComponent extends React.Component { private _lastKnownGoodValue; constructor(props: ITextInputComponentProps); private _onChange; private _onBlur; private _onFocus; shouldComponentUpdate(newProps: ITextInputComponentProps, newState: ITextInputComponentState): boolean; private _onKeyPress; render(): import("react/jsx-runtime").JSX.Element; } interface IPushButtonComponentProps { globalState: GlobalState; context: Context; icon: string; id?: string; className?: string; isPushed?: boolean; onClick: (state: boolean) => void; tooltip?: string; } interface IPushButtonComponentState { isPushed: boolean; } export class PushButtonComponent extends React.Component { constructor(props: IPushButtonComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IControlButtonComponentProps { globalState: GlobalState; context: Context; icon: string; hoverIcon: string; id?: string; className?: string; onClick: () => void; tooltip?: string; } interface IControlButtonComponentState { } export class ControlButtonComponent extends React.Component { constructor(props: IControlButtonComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IActionButtonComponentProps { globalState: GlobalState; context: Context; icon: string; id?: string; className?: string; isActive?: boolean; onClick: () => void; tooltip?: string; } interface IActionButtonComponentState { } export class ActionButtonComponent extends React.Component { constructor(props: IActionButtonComponentProps); render(): import("react/jsx-runtime").JSX.Element; } interface IRangeSelectorComponentProps { globalState: GlobalState; context: Context; } interface IRangeSelectorComponentState { } export class RangeSelectorComponent extends React.Component { private _rangeHost; private _rangeScrollbarHost; private _viewWidth; private _pointerIsDown; private _minFrame; private _maxFrame; private _leftHandleIsActive; private _bothHandleIsActive; private _currentOffset; private _currentFrom; private _currentTo; constructor(props: IRangeSelectorComponentProps); private _computeSizes; private _onPointerDown; private _onPointerMove; private _updateLimits; private _onPointerUp; render(): import("react/jsx-runtime").JSX.Element; } interface IMediaPlayerComponentProps { globalState: GlobalState; context: Context; } interface IMediaPlayerComponentState { } export class MediaPlayerComponent extends React.Component { private _isMounted; constructor(props: IMediaPlayerComponentProps); componentDidMount(): void; componentWillUnmount(): void; private _onFirstKey; private _onPrevKey; private _onRewind; private _onForward; private _onPrevFrame; private _onNextFrame; private _onNextKey; private _onEndKey; private _onStop; render(): import("react/jsx-runtime").JSX.Element; } interface IBottomBarComponentProps { globalState: GlobalState; context: Context; } interface IBottomBarComponentState { clipLength: string; } export class BottomBarComponent extends React.Component { private _onAnimationsLoadedObserver; private _onActiveAnimationChangedObserver; private _onClipLengthIncreasedObserver; private _onClipLengthDecreasedObserver; constructor(props: IBottomBarComponentProps); private _changeClipLength; componentWillUnmount(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IPerformanceViewerSidebarComponentProps { collector: BABYLON.PerformanceViewerCollector; onVisibleRangeChangedObservable?: BABYLON.Observable; } export const PerformanceViewerSidebarComponent: (props: IPerformanceViewerSidebarComponentProps) => import("react/jsx-runtime").JSX.Element; interface IPerformanceViewerPopupComponentProps { scene: BABYLON.Scene; layoutObservable: BABYLON.Observable; returnToLiveObservable: BABYLON.Observable; performanceCollector: BABYLON.PerformanceViewerCollector; initialGraphSize?: { width: number; height: number; }; } export var PerformanceViewerPopupComponent: React.FC; interface IPerformanceViewerComponentProps { scene: BABYLON.Scene; } export enum IPerfMetadataCategory { Count = "Count", FrameSteps = "Frame Steps Duration" } export var PerformanceViewerComponent: React.FC; interface IPerformancePlayheadButtonProps { returnToPlayhead: BABYLON.Observable; } export var PerformancePlayheadButtonComponent: React.FC; export interface ITextureLinkLineComponentProps { label: string; texture: BABYLON.Nullable; material?: BABYLON.Material; texturedObject?: { getScene: () => BABYLON.Scene; }; onSelectionChangedObservable?: BABYLON.Observable; onDebugSelectionChangeObservable?: BABYLON.Observable; propertyName?: string; onTextureCreated?: (texture: BABYLON.BaseTexture) => void; customDebugAction?: (state: boolean) => void; onTextureRemoved?: () => void; fileFormats?: string; cubeOnly?: boolean; } export class TextureLinkLineComponent extends React.Component { private _onDebugSelectionChangeObserver; constructor(props: ITextureLinkLineComponentProps); componentDidMount(): void; componentWillUnmount(): void; debugTexture(): void; onLink(): void; onLinkTexture(texture: BABYLON.BaseTexture): void; updateTexture(file: File): void; removeTexture(): void; render(): import("react/jsx-runtime").JSX.Element | null; } interface ITextureLineComponentProps { texture: BABYLON.BaseTexture; width: number; height: number; globalState?: GlobalState; hideChannelSelect?: boolean; } export class TextureLineComponent extends React.Component { private _canvasRef; private static _TextureChannelStates; constructor(props: ITextureLineComponentProps); shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: { channels: TextureChannelsToDisplay; face: number; }): boolean; componentDidMount(): void; componentDidUpdate(): void; updatePreview(): Promise; render(): import("react/jsx-runtime").JSX.Element; } interface IQuaternionLineComponentProps { label: string; target: any; useEuler?: boolean; propertyName: string; onPropertyChangedObservable?: BABYLON.Observable; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class QuaternionLineComponent extends React.Component { private _localChange; constructor(props: IQuaternionLineComponentProps); _checkRoundCircle(a: number, b: number): boolean; shouldComponentUpdate(nextProps: IQuaternionLineComponentProps, nextState: { isExpanded: boolean; value: BABYLON.Quaternion; eulerValue: BABYLON.Vector3; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(currentValue: BABYLON.Quaternion, previousValue: BABYLON.Quaternion): void; updateQuaternion(): void; updateStateX(value: number): void; updateStateY(value: number): void; updateStateZ(value: number): void; updateStateW(value: number): void; updateQuaternionFromEuler(): void; updateStateEulerX(value: number): void; updateStateEulerY(value: number): void; updateStateEulerZ(value: number): void; onCopyClick(): void; render(): import("react/jsx-runtime").JSX.Element; } interface IMeshPickerComponentProps { globalState: GlobalState; target: any; property: string; scene: BABYLON.Scene; label: string; onPropertyChangedObservable?: BABYLON.Observable; } export class MeshPickerComponent extends React.Component { constructor(props: IMeshPickerComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR.SharedUIComponents { /** * Copy all styles from a document to another document or shadow root * @param source document to copy styles from * @param target document or shadow root to copy styles to */ export function CopyStyles(source: Document, target: DocumentOrShadowRoot): void; /** * Merges classNames by array of strings or conditions * @param classNames Array of className strings or truthy conditions * @returns A concatenated string, suitable for the className attribute */ export function MergeClassNames(classNames: ClassNameCondition[]): string; /** * className (replicating React type) or a tuple with the second member being any truthy value ["className", true] */ type ClassNameCondition = string | undefined | [string, any]; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class StringTools { private static _SaveAs; private static _Click; /** * Download a string into a file that will be saved locally by the browser * @param document * @param content defines the string to download locally as a file * @param filename */ static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class PropertyChangedEvent { object: any; property: string; value: any; initialValue: any; allowNullValue?: boolean; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Create a popup window * @param title default title for the popup * @param options options for the popup * @returns the parent control of the popup */ export function CreatePopup(title: string, options: Partial<{ onParentControlCreateCallback?: (parentControl: HTMLDivElement) => void; onWindowCreateCallback?: (newWindow: Window) => void; width?: number; height?: number; }>): HTMLDivElement | null; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Class handling undo / redo operations */ export class HistoryStack implements BABYLON.IDisposable { private _historyStack; private _redoStack; private _activeData; private readonly _maxHistoryLength; private _locked; private _dataProvider; private _applyUpdate; /** * Gets or sets a boolean indicating if the stack is enabled */ isEnabled: boolean; /** * Constructor * @param dataProvider defines the data provider function * @param applyUpdate defines the code to execute when undo/redo operation is required */ constructor(dataProvider: () => any, applyUpdate: (data: any) => void); /** * Process key event to handle undo / redo * @param evt defines the keyboard event to process * @returns true if the event was processed */ processKeyEvent(evt: KeyboardEvent): boolean; /** * Resets the stack */ reset(): void; /** * Remove the n-1 element of the stack */ collapseLastTwo(): void; private _generateJSONDiff; private _applyJSONDiff; private _copy; /** * Stores the current state */ store(): void; /** * Undo the latest operation */ undo(): void; /** * Redo the latest undo operation */ redo(): void; /** * Disposes the stack */ dispose(): void; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export function copyCommandToClipboard(strCommand: string): void; export function getClassNameWithNamespace(obj: any): { className: string; babylonNamespace: string; }; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Used by both particleSystem and alphaBlendModes */ export var CommonBlendModes: { label: string; value: number; }[]; /** * Used to populated the blendMode dropdown in our various tools (Node Editor, Inspector, etc.) * The below ParticleSystem consts were defined before new Engine alpha blend modes were added, so we have to reference * the ParticleSystem.FOO consts explicitly (as the underlying var values are different - they get mapped to engine consts within baseParticleSystem.ts) */ export var BlendModeOptions: { label: string; value: number; }[]; /** * Used to populated the alphaMode dropdown in our various tools (Node Editor, Inspector, etc.) */ export var AlphaModeOptions: { label: string; value: number; }[]; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Class used to provide lock mechanism */ export class LockObject { /** * Gets or set if the lock is engaged */ lock: boolean; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ITextBlockPropertyGridComponentProps { textBlock: BABYLON.GUI.TextBlock; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class TextBlockPropertyGridComponent extends React.Component { constructor(props: ITextBlockPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IStackPanelPropertyGridComponentProps { stackPanel: BABYLON.GUI.StackPanel; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class StackPanelPropertyGridComponent extends React.Component { constructor(props: IStackPanelPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ISliderPropertyGridComponentProps { slider: BABYLON.GUI.Slider; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class SliderPropertyGridComponent extends React.Component { constructor(props: ISliderPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IScrollViewerPropertyGridComponentProps { scrollViewer: BABYLON.GUI.ScrollViewer; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class ScrollViewerPropertyGridComponent extends React.Component { constructor(props: IScrollViewerPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IRectanglePropertyGridComponentProps { rectangle: BABYLON.GUI.Rectangle; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class RectanglePropertyGridComponent extends React.Component { constructor(props: IRectanglePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IRadioButtonPropertyGridComponentProps { radioButtons: BABYLON.GUI.RadioButton[]; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class RadioButtonPropertyGridComponent extends React.Component { constructor(props: IRadioButtonPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ILinePropertyGridComponentProps { line: BABYLON.GUI.Line; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class LinePropertyGridComponent extends React.Component { constructor(props: ILinePropertyGridComponentProps); onDashChange(value: string): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IInputTextPropertyGridComponentProps { inputText: BABYLON.GUI.InputText; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class InputTextPropertyGridComponent extends React.Component { constructor(props: IInputTextPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IImagePropertyGridComponentProps { image: BABYLON.GUI.Image; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class ImagePropertyGridComponent extends React.Component { constructor(props: IImagePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IImageBasedSliderPropertyGridComponentProps { imageBasedSlider: BABYLON.GUI.ImageBasedSlider; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class ImageBasedSliderPropertyGridComponent extends React.Component { constructor(props: IImageBasedSliderPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IGridPropertyGridComponentProps { grid: BABYLON.GUI.Grid; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class GridPropertyGridComponent extends React.Component { constructor(props: IGridPropertyGridComponentProps); renderRows(): import("react/jsx-runtime").JSX.Element[]; renderColumns(): import("react/jsx-runtime").JSX.Element[]; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IEllipsePropertyGridComponentProps { ellipse: BABYLON.GUI.Ellipse; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class EllipsePropertyGridComponent extends React.Component { constructor(props: IEllipsePropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IControlPropertyGridComponentProps { control: BABYLON.GUI.Control; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class ControlPropertyGridComponent extends React.Component { constructor(props: IControlPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ICommonControlPropertyGridComponentProps { controls?: BABYLON.GUI.Control[]; control?: BABYLON.GUI.Control; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CommonControlPropertyGridComponent extends React.Component { constructor(props: ICommonControlPropertyGridComponentProps); renderGridInformation(control: BABYLON.GUI.Control): import("react/jsx-runtime").JSX.Element | null; render(): import("react/jsx-runtime").JSX.Element | undefined; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IColorPickerPropertyGridComponentProps { colorPicker: BABYLON.GUI.ColorPicker; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class ColorPickerPropertyGridComponent extends React.Component { constructor(props: IColorPickerPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ICheckboxPropertyGridComponentProps { checkbox: BABYLON.GUI.Checkbox; lockObject: INSPECTOR.SharedUIComponents.LockObject; onPropertyChangedObservable?: BABYLON.Observable; } export class CheckboxPropertyGridComponent extends React.Component { constructor(props: ICheckboxPropertyGridComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Splitter component properties */ export interface ISplitterProps { /** * Unique identifier */ id?: string; /** * Splitter size */ size: number; /** * Minimum size for the controlled element */ minSize?: number; /** * Maximum size for the controlled element */ maxSize?: number; /** * Initial size for the controlled element */ initialSize?: number; /** * Defines the controlled side */ controlledSide: INSPECTOR.SharedUIComponents.ControlledSize; /** * refObject to the splitter element */ refObject?: React.RefObject; } /** * Creates a splitter component * @param props defines the splitter properties * @returns the splitter component */ export var Splitter: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export enum ControlledSize { First = 0, Second = 1 } export enum SplitDirection { Horizontal = 0, Vertical = 1 } /** * Context used to share data with splitters */ export interface ISplitContext { /** * Split direction */ direction: SplitDirection; /** * Function called by splitters to update the offset * @param offset new offet * @param source source element * @param controlledSide defined controlled element */ drag: (offset: number, source: HTMLElement, controlledSide: ControlledSize) => void; /** * Function called by splitters to begin dragging */ beginDrag: () => void; /** * Function called by splitters to end dragging */ endDrag: () => void; /** * Sync sizes for the elements * @param source source element * @param controlledSide defined controlled element * @param size size of the controlled element * @param minSize minimum size for the controlled element * @param maxSize maximum size for the controlled element */ sync: (source: HTMLElement, controlledSide: ControlledSize, size?: number, minSize?: number, maxSize?: number) => void; } export var SplitContext: import("react").Context; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Split container properties */ export interface ISplitContainerProps { /** * Unique identifier */ id?: string; /** * Split direction */ direction: INSPECTOR.SharedUIComponents.SplitDirection; /** * Minimum size for the floating elements */ floatingMinSize?: number; /** * RefObject to the root div element */ containerRef?: React.RefObject; /** * Optional class name */ className?: string; /** * Pointer down * @param event pointer events */ onPointerDown?: (event: React.PointerEvent) => void; /** * Pointer move * @param event pointer events */ onPointerMove?: (event: React.PointerEvent) => void; /** * Pointer up * @param event pointer events */ onPointerUp?: (event: React.PointerEvent) => void; /** * Drop * @param event drag events */ onDrop?: (event: React.DragEvent) => void; /** * Drag over * @param event drag events */ onDragOver?: (event: React.DragEvent) => void; } /** * Creates a split container component * @param props defines the split container properties * @returns the split container component */ export var SplitContainer: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class TypeLedger { static PortDataBuilder: (port: INSPECTOR.SharedUIComponents.NodePort, nodeContainer: INSPECTOR.SharedUIComponents.INodeContainer) => INSPECTOR.SharedUIComponents.IPortData; static NodeDataBuilder: (data: any, nodeContainer: INSPECTOR.SharedUIComponents.INodeContainer) => INSPECTOR.SharedUIComponents.INodeData; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export const IsFramePortData: (variableToCheck: any) => variableToCheck is INSPECTOR.SharedUIComponents.FramePortData; export const RefreshNode: (node: INSPECTOR.SharedUIComponents.GraphNode, visitedNodes?: Set, visitedLinks?: Set, canvas?: INSPECTOR.SharedUIComponents.GraphCanvasComponent) => void; export const BuildFloatUI: (container: HTMLDivElement, document: Document, displayName: string, isInteger: boolean, source: any, propertyName: string, onChange: () => void, min?: number, max?: number, visualPropertiesRefresh?: Array<() => void>, additionalClassName?: string) => void; export function GetListOfAcceptedTypes>(types: T, allValue: number, autoDetectValue: number, port: { acceptedConnectionPointTypes: number[]; excludedConnectionPointTypes: number[]; type: number; }, skips?: number[]): string[]; export function GetConnectionErrorMessage>(sourceType: number, types: T, allValue: number, autoDetectValue: number, port: { acceptedConnectionPointTypes: number[]; excludedConnectionPointTypes: number[]; type: number; }, skips?: number[]): string; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class StateManager { data: any; hostDocument: Document; lockObject: any; modalIsDisplayed: boolean; historyStack: INSPECTOR.SharedUIComponents.HistoryStack; onSearchBoxRequiredObservable: BABYLON.Observable<{ x: number; y: number; }>; onSelectionChangedObservable: BABYLON.Observable>; onFrameCreatedObservable: BABYLON.Observable; onUpdateRequiredObservable: BABYLON.Observable; onGraphNodeRemovalObservable: BABYLON.Observable; onSelectionBoxMoved: BABYLON.Observable; onCandidateLinkMoved: BABYLON.Observable>; onCandidatePortSelectedObservable: BABYLON.Observable>; onNewNodeCreatedObservable: BABYLON.Observable; onRebuildRequiredObservable: BABYLON.Observable; onNodeMovedObservable: BABYLON.Observable; onErrorMessageDialogRequiredObservable: BABYLON.Observable; onExposePortOnFrameObservable: BABYLON.Observable; onGridSizeChanged: BABYLON.Observable; onNewBlockRequiredObservable: BABYLON.Observable<{ type: string; targetX: number; targetY: number; needRepositioning?: boolean; smartAdd?: boolean; }>; onHighlightNodeObservable: BABYLON.Observable<{ data: any; active: boolean; }>; onPreviewCommandActivated: BABYLON.Observable; exportData: (data: any, frame?: BABYLON.Nullable) => string; isElbowConnectionAllowed: (nodeA: INSPECTOR.SharedUIComponents.FrameNodePort | INSPECTOR.SharedUIComponents.NodePort, nodeB: INSPECTOR.SharedUIComponents.FrameNodePort | INSPECTOR.SharedUIComponents.NodePort) => boolean; isDebugConnectionAllowed: (nodeA: INSPECTOR.SharedUIComponents.FrameNodePort | INSPECTOR.SharedUIComponents.NodePort, nodeB: INSPECTOR.SharedUIComponents.FrameNodePort | INSPECTOR.SharedUIComponents.NodePort) => boolean; applyNodePortDesign: (data: INSPECTOR.SharedUIComponents.IPortData, element: HTMLElement, imgHost: HTMLImageElement, pip: HTMLDivElement) => boolean; getPortColor: (portData: INSPECTOR.SharedUIComponents.IPortData) => string; storeEditorData: (serializationObject: any, frame?: BABYLON.Nullable) => void; getEditorDataMap: () => { [key: number]: number; }; getScene?: () => BABYLON.Scene; createDefaultInputData: (rootData: any, portData: INSPECTOR.SharedUIComponents.IPortData, nodeContainer: INSPECTOR.SharedUIComponents.INodeContainer) => BABYLON.Nullable<{ data: INSPECTOR.SharedUIComponents.INodeData; name: string; }>; private _isRebuildQueued; queueRebuildCommand(): void; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ISearchBoxComponentProps { stateManager: INSPECTOR.SharedUIComponents.StateManager; } /** * The search box component. */ export class SearchBoxComponent extends React.Component { private _handleEscKey; private _targetX; private _targetY; private _nodes; constructor(props: ISearchBoxComponentProps); hide(): void; onFilterChange(evt: React.ChangeEvent): void; onNewNodeRequested(name: string): void; onKeyDown(evt: React.KeyboardEvent): void; render(): import("react/jsx-runtime").JSX.Element | null; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class PropertyLedger { static DefaultControl: React.ComponentClass; static RegisteredControls: { [key: string]: React.ComponentClass; }; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class NodePort { portData: IPortData; node: INSPECTOR.SharedUIComponents.GraphNode; protected _element: HTMLDivElement; protected _portContainer: HTMLElement; protected _imgHost: HTMLImageElement; protected _pip: HTMLDivElement; protected _stateManager: INSPECTOR.SharedUIComponents.StateManager; protected _portLabelElement: Element; protected _onCandidateLinkMovedObserver: BABYLON.Nullable>>; protected _onSelectionChangedObserver: BABYLON.Nullable>>; protected _exposedOnFrame: boolean; protected _portUIcontainer?: HTMLDivElement; delegatedPort: BABYLON.Nullable; get element(): HTMLDivElement; get container(): HTMLElement; get portName(): string; set portName(newName: string); get disabled(): boolean; hasLabel(): boolean; get exposedOnFrame(): boolean; set exposedOnFrame(value: boolean); get exposedPortPosition(): number; set exposedPortPosition(value: number); private _isConnectedToNodeOutsideOfFrame; refresh(): void; constructor(portContainer: HTMLElement, portData: IPortData, node: INSPECTOR.SharedUIComponents.GraphNode, stateManager: INSPECTOR.SharedUIComponents.StateManager, portUIcontainer?: HTMLDivElement); dispose(): void; static CreatePortElement(portData: IPortData, node: INSPECTOR.SharedUIComponents.GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable, stateManager: INSPECTOR.SharedUIComponents.StateManager): NodePort; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class NodeLink { private _graphCanvas; private _portA; private _portB?; private _nodeA; private _nodeB?; private _path; private _selectionPath; private _onSelectionChangedObserver; private _isVisible; private _isTargetCandidate; private _gradient; onDisposedObservable: BABYLON.Observable; get isTargetCandidate(): boolean; set isTargetCandidate(value: boolean); get isVisible(): boolean; set isVisible(value: boolean); get portA(): INSPECTOR.SharedUIComponents.FrameNodePort | INSPECTOR.SharedUIComponents.NodePort; get portB(): INSPECTOR.SharedUIComponents.FrameNodePort | INSPECTOR.SharedUIComponents.NodePort | undefined; get nodeA(): INSPECTOR.SharedUIComponents.GraphNode; get nodeB(): INSPECTOR.SharedUIComponents.GraphNode | undefined; intersectsWith(rect: DOMRect): boolean; update(endX?: number, endY?: number, straight?: boolean): void; get path(): SVGPathElement; get selectionPath(): SVGPathElement; constructor(graphCanvas: INSPECTOR.SharedUIComponents.GraphCanvasComponent, portA: INSPECTOR.SharedUIComponents.NodePort, nodeA: INSPECTOR.SharedUIComponents.GraphNode, portB?: INSPECTOR.SharedUIComponents.NodePort, nodeB?: INSPECTOR.SharedUIComponents.GraphNode); onClick(evt: MouseEvent): void; dispose(notify?: boolean): void; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class NodeLedger { static RegisteredNodeNames: string[]; static NameFormatter: (name: string) => string; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class GraphNode { content: INSPECTOR.SharedUIComponents.INodeData; private static _IdGenerator; private _visual; private _headerContainer; private _headerIcon; private _headerIconImg; private _headerCollapseImg; private _header; private _headerCollapse; private _connections; private _optionsContainer; private _inputsContainer; private _outputsContainer; private _content; private _comments; private _executionTime; private _selectionBorder; private _inputPorts; private _outputPorts; private _links; private _x; private _y; private _gridAlignedX; private _gridAlignedY; private _mouseStartPointX; private _mouseStartPointY; private _stateManager; private _onSelectionChangedObserver; private _onSelectionBoxMovedObserver; private _onFrameCreatedObserver; private _onUpdateRequiredObserver; private _onHighlightNodeObserver; private _ownerCanvas; private _displayManager; private _isVisible; private _enclosingFrameId; private _visualPropertiesRefresh; private _lastClick; addClassToVisual(className: string): void; removeClassFromVisual(className: string): void; get isCollapsed(): boolean; get isVisible(): boolean; set isVisible(value: boolean); private _upateNodePortNames; get outputPorts(): INSPECTOR.SharedUIComponents.NodePort[]; get inputPorts(): INSPECTOR.SharedUIComponents.NodePort[]; get links(): INSPECTOR.SharedUIComponents.NodeLink[]; get gridAlignedX(): number; get gridAlignedY(): number; get x(): number; set x(value: number); get y(): number; set y(value: number); get width(): number; get height(): number; get id(): number; get name(): string; get enclosingFrameId(): number; set enclosingFrameId(value: number); setIsSelected(value: boolean, marqueeSelection: boolean): void; get rootElement(): HTMLDivElement; constructor(content: INSPECTOR.SharedUIComponents.INodeData, stateManager: INSPECTOR.SharedUIComponents.StateManager); isOverlappingFrame(frame: INSPECTOR.SharedUIComponents.GraphFrame): boolean; getPortForPortData(portData: INSPECTOR.SharedUIComponents.IPortData): INSPECTOR.SharedUIComponents.NodePort | null; getPortDataForPortDataContent(data: any): INSPECTOR.SharedUIComponents.IPortData | null; getLinksForPortDataContent(data: any): INSPECTOR.SharedUIComponents.NodeLink[]; getLinksForPortData(portData: INSPECTOR.SharedUIComponents.IPortData): INSPECTOR.SharedUIComponents.NodeLink[]; private _refreshFrames; _refreshLinks(): void; refresh(): void; private _expand; private _searchMiddle; private _onDown; cleanAccumulation(useCeil?: boolean): void; private _onUp; private _onMove; renderProperties(): BABYLON.Nullable; _forceRebuild(source: any, propertyName: string, notifiers?: BABYLON.IEditablePropertyOption["notifiers"]): void; private _isCollapsed; /** * Collapse the node */ collapse(): void; /** * Expand the node */ expand(): void; private _portUICount; private _buildInputPorts; appendVisual(root: HTMLDivElement, owner: INSPECTOR.SharedUIComponents.GraphCanvasComponent): void; dispose(): void; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export enum FramePortPosition { Top = 0, Middle = 1, Bottom = 2 } export class GraphFrame { private readonly _collapsedWidth; private static _FrameCounter; private static _FramePortCounter; private _name; private _color; private _x; private _y; private _gridAlignedX; private _gridAlignedY; private _width; private _height; element: HTMLDivElement; private _borderElement; private _headerElement; private _headerTextElement; private _headerCollapseElement; private _headerCloseElement; private _headerFocusElement; private _commentsElement; private _portContainer; private _outputPortContainer; private _inputPortContainer; private _nodes; private _ownerCanvas; private _mouseStartPointX; private _mouseStartPointY; private _onSelectionChangedObserver; private _onGraphNodeRemovalObserver; private _onExposePortOnFrameObserver; private _onNodeLinkDisposedObservers; private _isCollapsed; private _frameInPorts; private _frameOutPorts; private _controlledPorts; private _exposedInPorts; private _exposedOutPorts; private _id; private _comments; private _frameIsResizing; private _resizingDirection; private _minFrameHeight; private _minFrameWidth; private _mouseXLimit; onExpandStateChanged: BABYLON.Observable; private readonly _closeSVG; private readonly _expandSVG; private readonly _collapseSVG; private readonly _focusSVG; get id(): number; get isCollapsed(): boolean; private _createInputPort; private _markFramePortPositions; private _createFramePorts; private _removePortFromExposedWithNode; private _removePortFromExposedWithLink; private _createInputPorts; private _createOutputPorts; redrawFramePorts(): void; set isCollapsed(value: boolean); get nodes(): INSPECTOR.SharedUIComponents.GraphNode[]; get ports(): INSPECTOR.SharedUIComponents.FrameNodePort[]; get name(): string; set name(value: string); get color(): BABYLON.Color3; set color(value: BABYLON.Color3); get x(): number; set x(value: number); get y(): number; set y(value: number); get width(): number; set width(value: number); get height(): number; set height(value: number); get comments(): string; set comments(comments: string); constructor(candidate: BABYLON.Nullable, canvas: INSPECTOR.SharedUIComponents.GraphCanvasComponent, doNotCaptureNodes?: boolean); private _isFocused; /** * Enter/leave focus mode */ switchFocusMode(): void; refresh(): void; addNode(node: INSPECTOR.SharedUIComponents.GraphNode): void; removeNode(node: INSPECTOR.SharedUIComponents.GraphNode): void; syncNode(node: INSPECTOR.SharedUIComponents.GraphNode): void; cleanAccumulation(): void; private _onDown; move(newX: number, newY: number, align?: boolean): void; private _onUp; _moveFrame(offsetX: number, offsetY: number): void; private _onMove; moveFramePortUp(nodePort: INSPECTOR.SharedUIComponents.FrameNodePort): void; private _movePortUp; moveFramePortDown(nodePort: INSPECTOR.SharedUIComponents.FrameNodePort): void; private _movePortDown; private _initResizing; private _cleanUpResizing; private _updateMinHeightWithComments; private _isResizingTop; private _isResizingRight; private _isResizingBottom; private _isResizingLeft; private _onRightHandlePointerDown; private _onRightHandlePointerMove; private _moveRightHandle; private _onRightHandlePointerUp; private _onBottomHandlePointerDown; private _onBottomHandlePointerMove; private _moveBottomHandle; private _onBottomHandlePointerUp; private _onLeftHandlePointerDown; private _onLeftHandlePointerMove; private _moveLeftHandle; private _onLeftHandlePointerUp; private _onTopHandlePointerDown; private _onTopHandlePointerMove; private _moveTopHandle; private _onTopHandlePointerUp; private _onTopRightHandlePointerDown; private _onTopRightHandlePointerMove; private _moveTopRightHandle; private _onTopRightHandlePointerUp; private _onBottomRightHandlePointerDown; private _onBottomRightHandlePointerMove; private _moveBottomRightHandle; private _onBottomRightHandlePointerUp; private _onBottomLeftHandlePointerDown; private _onBottomLeftHandlePointerMove; private _moveBottomLeftHandle; private _onBottomLeftHandlePointerUp; private _onTopLeftHandlePointerDown; private _onTopLeftHandlePointerMove; private _moveTopLeftHandle; private _onTopLeftHandlePointerUp; private _expandLeft; private _expandTop; private _expandRight; private _expandBottom; dispose(): void; private _serializePortData; serialize(saveCollapsedState: boolean): INSPECTOR.SharedUIComponents.IFrameData; export(): void; adjustPorts(): void; static Parse(serializationData: INSPECTOR.SharedUIComponents.IFrameData, canvas: INSPECTOR.SharedUIComponents.GraphCanvasComponent, map?: { [key: number]: number; }): GraphFrame; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IGraphCanvasComponentProps { stateManager: INSPECTOR.SharedUIComponents.StateManager; onEmitNewNode: (nodeData: INSPECTOR.SharedUIComponents.INodeData) => INSPECTOR.SharedUIComponents.GraphNode; } export class GraphCanvasComponent extends React.Component implements INSPECTOR.SharedUIComponents.INodeContainer { static readonly NodeWidth = 100; private readonly _minZoom; private readonly _maxZoom; private _hostCanvasRef; private _hostCanvas; private _graphCanvasRef; private _graphCanvas; private _selectionContainerRef; private _selectionContainer; private _frameContainerRef; private _frameContainer; private _svgCanvasRef; private _svgCanvas; private _rootContainerRef; private _rootContainer; private _nodes; private _links; private _mouseStartPointX; private _mouseStartPointY; private _dropPointX; private _dropPointY; private _selectionStartX; private _selectionStartY; private _candidateLinkedHasMoved; private _x; private _y; private _lastx; private _lasty; private _zoom; private _selectedNodes; private _selectedLink; private _selectedPort; private _candidateLink; private _candidatePort; private _gridSize; private _selectionBox; private _selectedFrames; private _frameCandidate; private _frames; private _nodeDataContentList; private _altKeyIsPressed; private _shiftKeyIsPressed; private _multiKeyIsPressed; private _oldY; _frameIsMoving: boolean; _isLoading: boolean; _targetLinkCandidate: BABYLON.Nullable; private _copiedNodes; private _copiedFrames; get gridSize(): number; set gridSize(value: number); get stateManager(): INSPECTOR.SharedUIComponents.StateManager; get nodes(): INSPECTOR.SharedUIComponents.GraphNode[]; get links(): INSPECTOR.SharedUIComponents.NodeLink[]; get frames(): INSPECTOR.SharedUIComponents.GraphFrame[]; get zoom(): number; set zoom(value: number); get x(): number; set x(value: number); get y(): number; set y(value: number); get selectedNodes(): INSPECTOR.SharedUIComponents.GraphNode[]; get selectedLink(): BABYLON.Nullable; get selectedFrames(): INSPECTOR.SharedUIComponents.GraphFrame[]; get selectedPort(): BABYLON.Nullable; get canvasContainer(): HTMLDivElement; get hostCanvas(): HTMLDivElement; get svgCanvas(): HTMLElement; get selectionContainer(): HTMLDivElement; get frameContainer(): HTMLDivElement; private _selectedFrameAndNodesConflict; constructor(props: IGraphCanvasComponentProps); populateConnectedEntriesBeforeRemoval(item: INSPECTOR.SharedUIComponents.GraphNode, items: INSPECTOR.SharedUIComponents.GraphNode[], inputs: BABYLON.Nullable[], outputs: BABYLON.Nullable[]): void; automaticRewire(inputs: BABYLON.Nullable[], outputs: BABYLON.Nullable[], firstOnly?: boolean): void; smartAddOverLink(node: INSPECTOR.SharedUIComponents.GraphNode, link: INSPECTOR.SharedUIComponents.NodeLink): void; smartAddOverNode(node: INSPECTOR.SharedUIComponents.GraphNode, source: INSPECTOR.SharedUIComponents.GraphNode): void; deleteSelection(onRemove: (nodeData: INSPECTOR.SharedUIComponents.INodeData) => void, autoReconnect?: boolean): void; handleKeyDown(evt: KeyboardEvent, onRemove: (nodeData: INSPECTOR.SharedUIComponents.INodeData) => void, mouseLocationX: number, mouseLocationY: number, dataGenerator: (nodeData: INSPECTOR.SharedUIComponents.INodeData) => any, rootElement: HTMLDivElement): void; pasteSelection(copiedNodes: INSPECTOR.SharedUIComponents.GraphNode[], currentX: number, currentY: number, dataGenerator: (nodeData: INSPECTOR.SharedUIComponents.INodeData) => any, selectNew?: boolean): INSPECTOR.SharedUIComponents.GraphNode[]; reconnectNewNodes(nodeIndex: number, newNodes: INSPECTOR.SharedUIComponents.GraphNode[], sourceNodes: INSPECTOR.SharedUIComponents.GraphNode[], done: boolean[]): void; getCachedData(): any[]; removeDataFromCache(data: any): void; createNodeFromObject(nodeData: INSPECTOR.SharedUIComponents.INodeData, onNodeCreated: (data: any) => void, recursion?: boolean): INSPECTOR.SharedUIComponents.GraphNode; getGridPosition(position: number, useCeil?: boolean): number; getGridPositionCeil(position: number): number; updateTransform(): void; onKeyUp(): void; findNodeFromData(data: any): INSPECTOR.SharedUIComponents.GraphNode; reset(): void; connectPorts(pointA: INSPECTOR.SharedUIComponents.IPortData, pointB: INSPECTOR.SharedUIComponents.IPortData): void; removeLink(link: INSPECTOR.SharedUIComponents.NodeLink): void; appendNode(nodeData: INSPECTOR.SharedUIComponents.INodeData): INSPECTOR.SharedUIComponents.GraphNode; distributeGraph(): void; componentDidMount(): void; onMove(evt: React.PointerEvent): void; onDown(evt: React.PointerEvent): void; onUp(evt: React.PointerEvent): void; onWheel(evt: React.WheelEvent): void; zoomToFit(): void; processCandidatePort(): void; connectNodes(nodeA: INSPECTOR.SharedUIComponents.GraphNode, pointA: INSPECTOR.SharedUIComponents.IPortData, nodeB: INSPECTOR.SharedUIComponents.GraphNode, pointB: INSPECTOR.SharedUIComponents.IPortData): void; drop(newNode: INSPECTOR.SharedUIComponents.GraphNode, targetX: number, targetY: number, offsetX: number, offsetY: number): void; processEditorData(editorData: INSPECTOR.SharedUIComponents.IEditorData): void; reOrganize(editorData?: BABYLON.Nullable, isImportingAFrame?: boolean): void; addFrame(frameData: INSPECTOR.SharedUIComponents.IFrameData): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class FrameNodePort extends INSPECTOR.SharedUIComponents.NodePort { portData: INSPECTOR.SharedUIComponents.IPortData; node: INSPECTOR.SharedUIComponents.GraphNode; private _parentFrameId; private _isInput; private _framePortPosition; private _framePortId; private _onFramePortPositionChangedObservable; get parentFrameId(): number; get onFramePortPositionChangedObservable(): BABYLON.Observable; get isInput(): boolean; get framePortId(): number; get framePortPosition(): INSPECTOR.SharedUIComponents.FramePortPosition; set framePortPosition(position: INSPECTOR.SharedUIComponents.FramePortPosition); constructor(portContainer: HTMLElement, portData: INSPECTOR.SharedUIComponents.IPortData, node: INSPECTOR.SharedUIComponents.GraphNode, stateManager: INSPECTOR.SharedUIComponents.StateManager, isInput: boolean, framePortId: number, parentFrameId: number); static CreateFrameNodePortElement(portData: INSPECTOR.SharedUIComponents.IPortData, node: INSPECTOR.SharedUIComponents.GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable, stateManager: INSPECTOR.SharedUIComponents.StateManager, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export class DisplayLedger { static RegisteredControls: { [key: string]: any; }; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Function used to force a rebuild of the node system * @param source source object * @param stateManager defines the state manager to use * @param propertyName name of the property that has been changed * @param notifiers list of notifiers to use */ export function ForceRebuild(source: any, stateManager: INSPECTOR.SharedUIComponents.StateManager, propertyName: string, notifiers?: BABYLON.IEditablePropertyOption["notifiers"]): void; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type FramePortData = { frame: INSPECTOR.SharedUIComponents.GraphFrame; port: INSPECTOR.SharedUIComponents.FrameNodePort; }; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ISelectionChangedOptions { selection: BABYLON.Nullable; forceKeepSelection?: boolean; marqueeSelection?: boolean; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IPropertyComponentProps { stateManager: INSPECTOR.SharedUIComponents.StateManager; nodeData: INSPECTOR.SharedUIComponents.INodeData; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export enum PortDataDirection { /** Input */ Input = 0, /** Output */ Output = 1 } export enum PortDirectValueTypes { Float = 0, Int = 1 } export interface IPortDirectValueDefinition { /** * Gets the source object */ source: any; /** * Gets the property name used to store the value */ propertyName: string; /** * Gets or sets the min value accepted for this point if nothing is connected */ valueMin: BABYLON.Nullable; /** * Gets or sets the max value accepted for this point if nothing is connected */ valueMax: BABYLON.Nullable; /** * Gets or sets the type of the value */ valueType: PortDirectValueTypes; } export interface IPortData { data: any; name: string; internalName: string; isExposedOnFrame: boolean; exposedPortPosition: number; isConnected: boolean; direction: PortDataDirection; ownerData: any; connectedPort: BABYLON.Nullable; needDualDirectionValidation: boolean; hasEndpoints: boolean; endpoints: BABYLON.Nullable; directValueDefinition?: IPortDirectValueDefinition; updateDisplayName: (newName: string) => void; canConnectTo: (port: IPortData) => boolean; connectTo: (port: IPortData) => void; disconnectFrom: (port: IPortData) => void; checkCompatibilityState(port: IPortData): number; getCompatibilityIssueMessage(issue: number, targetNode: INSPECTOR.SharedUIComponents.GraphNode, targetPort: IPortData): string; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface INodeLocationInfo { blockId: number; x: number; y: number; isCollapsed: boolean; } export interface IFrameData { x: number; y: number; width: number; height: number; color: number[]; name: string; isCollapsed: boolean; blocks: number[]; comments: string; } export interface IEditorData { locations: INodeLocationInfo[]; x: number; y: number; zoom: number; frames?: IFrameData[]; map?: { [key: number]: number; }; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface INodeData { data: any; name: string; uniqueId: number; isInput: boolean; comments: string; executionTime?: number; refreshCallback?: () => void; prepareHeaderIcon: (iconDiv: HTMLDivElement, img: HTMLImageElement) => void; getClassName: () => string; dispose: () => void; getPortByName: (name: string) => BABYLON.Nullable; inputs: INSPECTOR.SharedUIComponents.IPortData[]; outputs: INSPECTOR.SharedUIComponents.IPortData[]; invisibleEndpoints?: BABYLON.Nullable; isConnectedToOutput?: () => boolean; isActive?: boolean; setIsActive?: (value: boolean) => void; canBeActivated?: boolean; onInputCountChanged?: () => void; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface INodeContainer { nodes: INSPECTOR.SharedUIComponents.GraphNode[]; appendNode(data: INSPECTOR.SharedUIComponents.INodeData): INSPECTOR.SharedUIComponents.GraphNode; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface VisualContentDescription { [key: string]: HTMLElement; } export interface IDisplayManager { getHeaderClass(data: INSPECTOR.SharedUIComponents.INodeData): string; shouldDisplayPortLabels(data: INSPECTOR.SharedUIComponents.IPortData): boolean; updatePreviewContent(data: INSPECTOR.SharedUIComponents.INodeData, contentArea: HTMLDivElement): void; updateFullVisualContent?(data: INSPECTOR.SharedUIComponents.INodeData, visualContent: VisualContentDescription): void; getBackgroundColor(data: INSPECTOR.SharedUIComponents.INodeData): string; getHeaderText(data: INSPECTOR.SharedUIComponents.INodeData): string; onSelectionChanged?(data: INSPECTOR.SharedUIComponents.INodeData, selectedData: BABYLON.Nullable, manager: INSPECTOR.SharedUIComponents.StateManager): void; onDispose?(nodeData: INSPECTOR.SharedUIComponents.INodeData, manager: INSPECTOR.SharedUIComponents.StateManager): void; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IVector4LineComponentProps { label: string; target?: any; propertyName?: string; step?: number; onChange?: (newvalue: BABYLON.Vector4) => void; useEuler?: boolean; onPropertyChangedObservable?: BABYLON.Observable; icon?: string; iconLabel?: string; value?: BABYLON.Vector4; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class Vector4LineComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: IVector4LineComponentProps); getCurrentValue(): any; shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: { isExpanded: boolean; value: BABYLON.Vector4; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void; updateVector4(): void; updateStateX(value: number): void; updateStateY(value: number): void; updateStateZ(value: number): void; updateStateW(value: number): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IVector3LineComponentProps { label: string; target?: any; propertyName?: string; step?: number; onChange?: (newvalue: BABYLON.Vector3) => void; useEuler?: boolean; onPropertyChangedObservable?: BABYLON.Observable; noSlider?: boolean; icon?: string; iconLabel?: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; directValue?: BABYLON.Vector3; additionalCommands?: JSX.Element[]; } export class Vector3LineComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: IVector3LineComponentProps); getCurrentValue(): any; shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: { isExpanded: boolean; value: BABYLON.Vector3; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void; updateVector3(): void; updateStateX(value: number): void; updateStateY(value: number): void; updateStateZ(value: number): void; onCopyClick(): string; renderFluent(): import("react/jsx-runtime").JSX.Element; renderOriginal(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IVector2LineComponentProps { label: string; target: any; propertyName: string; step?: number; onChange?: (newvalue: BABYLON.Vector2) => void; onPropertyChangedObservable?: BABYLON.Observable; icon?: string; iconLabel?: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class Vector2LineComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: IVector2LineComponentProps); shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: { isExpanded: boolean; value: BABYLON.Vector2; }): boolean; switchExpandState(): void; raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void; updateStateX(value: number): void; updateStateY(value: number): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IValueLineComponentProps { label: string; value: number; color?: string; fractionDigits?: number; units?: string; icon?: string; iconLabel?: string; } export class ValueLineComponent extends React.Component { constructor(props: IValueLineComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IUnitButtonProps { unit: string; locked?: boolean; onClick?: (unit: string) => void; } export function UnitButton(props: IUnitButtonProps): import("react/jsx-runtime").JSX.Element; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ITextureButtonLineProps { label: string; scene: BABYLON.Scene; onClick: (file: File) => void; onLink: (texture: BABYLON.BaseTexture) => void; accept: string; } interface ITextureButtonLineState { isOpen: boolean; } export class TextureButtonLine extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: ITextureButtonLineProps); onChange(evt: any): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ITextLineComponentProps { label?: string; value?: string; color?: string; underline?: boolean; onLink?: () => void; url?: string; ignoreValue?: boolean; additionalClass?: string; icon?: string; iconLabel?: string; tooltip?: string; onCopy?: true | (() => string); } export class TextLineComponent extends React.Component { constructor(props: ITextLineComponentProps); onLink(): void; copyFn(): (() => string) | undefined; renderContent(isLink: boolean, tooltip: string): import("react/jsx-runtime").JSX.Element | null; renderOriginal(isLink: boolean, tooltip: string): import("react/jsx-runtime").JSX.Element; renderFluent(isLink: boolean, tooltip: string): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ITextInputLineComponentProps { label?: string; lockObject?: INSPECTOR.SharedUIComponents.LockObject; target?: any; propertyName?: string; value?: string; onChange?: (value: string) => void; onPropertyChangedObservable?: BABYLON.Observable; icon?: string; iconLabel?: string; noUnderline?: boolean; numbersOnly?: boolean; delayInput?: boolean; arrows?: boolean; arrowsIncrement?: (amount: number) => void; step?: number; numeric?: boolean; roundValues?: boolean; min?: number; max?: number; placeholder?: string; unit?: React.ReactNode; validator?: (value: string) => boolean; multilines?: boolean; throttlePropertyChangedNotification?: boolean; throttlePropertyChangedNotificationDelay?: number; disabled?: boolean; } export class TextInputLineComponent extends React.Component { private _localChange; constructor(props: ITextInputLineComponentProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: { value: string; dragging: boolean; }): boolean; raiseOnPropertyChanged(newValue: string, previousValue: string): void; getCurrentNumericValue(value: string): number; updateValue(value: string, valueToValidate?: string): void; incrementValue(amount: number): void; onKeyDown(event: React.KeyboardEvent): void; renderFluent(value: string, placeholder: string, step: number): import("react/jsx-runtime").JSX.Element; renderOriginal(value: string, placeholder: string, step: number): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export const conflictingValuesPlaceholder = "\u2014"; /** * * @param targets a list of selected targets * @param onPropertyChangedObservable * @param getProperty * @returns a proxy object that can be passed as a target into the input */ export function makeTargetsProxy(targets: Type[], onPropertyChangedObservable?: BABYLON.Observable, getProperty?: (target: Type, property: keyof Type) => any): any; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ISliderLineComponentProps { label: string; target?: any; propertyName?: string; minimum: number; maximum: number; step: number; directValue?: number; useEuler?: boolean; onChange?: (value: number) => void; onInput?: (value: number) => void; onPropertyChangedObservable?: BABYLON.Observable; decimalCount?: number; margin?: boolean; icon?: string; iconLabel?: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; unit?: React.ReactNode; allowOverflow?: boolean; } export class SliderLineComponent extends React.Component { private _localChange; constructor(props: ISliderLineComponentProps); shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: { value: number; }): boolean; onChange(newValueString: any): void; onInput(newValueString: any): void; prepareDataToRead(value: number): number; onCopyClick(): void; renderFluent(): import("react/jsx-runtime").JSX.Element; renderOriginal(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IRadioButtonLineComponentProps { onSelectionChangedObservable: BABYLON.Observable; label: string; isSelected: () => boolean; onSelect: () => void; icon?: string; iconLabel?: string; } export class RadioButtonLineComponent extends React.Component { private _onSelectionChangedObserver; constructor(props: IRadioButtonLineComponentProps); componentDidMount(): void; componentWillUnmount(): void; onChange(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export var Null_Value: number; export interface IOptionsLineProps { label: string; target: any; propertyName: string; options: BABYLON.IInspectableOptions[]; noDirectUpdate?: boolean; onSelect?: (value: number | string) => void; extractValue?: (target: any) => number | string; onPropertyChangedObservable?: BABYLON.Observable; allowNullValue?: boolean; icon?: string; iconLabel?: string; className?: string; valuesAreStrings?: boolean; defaultIfNull?: number; } export class OptionsLine extends React.Component { private _localChange; private _remapValueIn; private _remapValueOut; private _getValue; constructor(props: IOptionsLineProps); shouldComponentUpdate(nextProps: IOptionsLineProps, nextState: { value: number; }): boolean; raiseOnPropertyChanged(newValue: number, previousValue: number): void; setValue(value: string | number): void; updateValue(valueString: string): void; onCopyClickStr(): string; private _renderFluent; private _renderOriginal; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface INumericInputProps { label: string; labelTooltip?: string; value: number; step?: number; onChange: (value: number) => void; precision?: number; icon?: string; iconLabel?: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class NumericInput extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: INumericInputProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: INumericInputProps, nextState: { value: string; }): boolean; updateValue(valueString: string): void; onBlur(): void; incrementValue(amount: number): void; onKeyDown(evt: React.KeyboardEvent): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IMessageLineComponentProps { text: string; color?: string; icon?: any; } export class MessageLineComponent extends React.Component { constructor(props: IMessageLineComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IMatrixLineComponentProps { label: string; target: any; propertyName: string; step?: number; onChange?: (newValue: BABYLON.Matrix) => void; onModeChange?: (mode: number) => void; onPropertyChangedObservable?: BABYLON.Observable; mode?: number; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class MatrixLineComponent extends React.Component { private _localChange; constructor(props: IMatrixLineComponentProps); shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: { value: BABYLON.Matrix; mode: number; angle: number; }): boolean; raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void; updateMatrix(): void; updateRow(value: BABYLON.Vector4, row: number): void; updateBasedOnMode(value: number): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ILinkButtonComponentProps { label: string; buttonLabel: string; url?: string; onClick: () => void; icon?: any; onIconClick?: () => void; } export class LinkButtonComponent extends React.Component { constructor(props: ILinkButtonComponentProps); onLink(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ILineWithFileButtonComponentProps { title: string; closed?: boolean; multiple?: boolean; label: string; iconImage: any; onIconClick: (file: File) => void; accept: string; uploadName?: string; } export class LineWithFileButtonComponent extends React.Component { private _uploadRef; constructor(props: ILineWithFileButtonComponentProps); onChange(evt: any): void; switchExpandedState(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ILineContainerComponentProps { selection?: INSPECTOR.SharedUIComponents.ISelectedLineContainer; title: string; children: any[] | any; closed?: boolean; } export class LineContainerComponent extends React.Component { constructor(props: ILineContainerComponentProps); switchExpandedState(): void; renderHeader(): import("react/jsx-runtime").JSX.Element; componentDidMount(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IInputArrowsComponentProps { incrementValue: (amount: number) => void; setDragging: (dragging: boolean) => void; } export class InputArrowsComponent extends React.Component { private _arrowsRef; private _drag; private _releaseListener; private _lockChangeListener; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IIndentedTextLineComponentProps { value?: string; color?: string; underline?: boolean; onLink?: () => void; url?: string; additionalClass?: string; } export class IndentedTextLineComponent extends React.Component { constructor(props: IIndentedTextLineComponentProps); onLink(): void; renderContent(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IIconComponentProps { icon: string; label?: string; } export class IconComponent extends React.Component { render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IIconButtonLineComponentProps { icon: string; onClick: () => void; tooltip: string; active?: boolean; } export class IconButtonLineComponent extends React.Component { constructor(props: IIconButtonLineComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ISelectedLineContainer { selectedLineContainerTitles: Array; selectedLineContainerTitlesNoFocus: Array; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IHexLineComponentProps { label: string; target: any; propertyName: string; lockObject?: INSPECTOR.SharedUIComponents.LockObject; onChange?: (newValue: number) => void; isInteger?: boolean; replaySourceReplacement?: string; onPropertyChangedObservable?: BABYLON.Observable; additionalClass?: string; step?: string; digits?: number; useEuler?: boolean; min?: number; icon?: string; iconLabel?: string; } export class HexLineComponent extends React.Component { private _localChange; private _store; private _propertyChange; constructor(props: IHexLineComponentProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: IHexLineComponentProps, nextState: { value: string; }): boolean; raiseOnPropertyChanged(newValue: number, previousValue: number): void; convertToHexString(valueString: string): string; updateValue(valueString: string, raisePropertyChanged: boolean): void; lock(): void; unlock(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IFloatLineComponentProps { label: string; target: any; propertyName: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; onChange?: (newValue: number) => void; isInteger?: boolean; onPropertyChangedObservable?: BABYLON.Observable; additionalClass?: string; step?: string; digits?: number; useEuler?: boolean; min?: number; max?: number; smallUI?: boolean; onEnter?: (newValue: number) => void; icon?: string; iconLabel?: string; defaultValue?: number; arrows?: boolean; unit?: React.ReactNode; onDragStart?: (newValue: number) => void; onDragStop?: (newValue: number) => void; disabled?: boolean; } export class FloatLineComponent extends React.Component { private _localChange; private _store; constructor(props: IFloatLineComponentProps); componentWillUnmount(): void; getValueString(value: any, props: IFloatLineComponentProps): string; shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: { value: string; dragging: boolean; }): boolean; raiseOnPropertyChanged(newValue: number, previousValue: number): void; updateValue(valueString: string): void; lock(): void; unlock(): void; incrementValue(amount: number, processStep?: boolean): void; onKeyDown(event: React.KeyboardEvent): void; onCopyClick(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IFileMultipleButtonLineComponentProps { label: string; onClick: (event: any) => void; accept: string; icon?: string; iconLabel?: string; } export class FileMultipleButtonLineComponent extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: IFileMultipleButtonLineComponentProps); onChange(evt: any): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface IFileButtonLineProps { label: string; onClick: (file: File) => void; accept: string; icon?: string; iconLabel?: string; } export class FileButtonLine extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: IFileButtonLineProps); onChange(evt: any): void; renderFluent(): import("react/jsx-runtime").JSX.Element; renderOriginal(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IDraggableLineWithButtonComponent { format: string; data: string; tooltip: string; iconImage: any; onIconClick: (value: string) => void; iconTitle: string; lenSuffixToRemove?: number; } export class DraggableLineWithButtonComponent extends React.Component { constructor(props: IDraggableLineWithButtonComponent); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IButtonLineComponentProps { format: string; data: string; tooltip: string; } export class DraggableLineComponent extends React.Component { constructor(props: IButtonLineComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColorPickerLineProps { value: BABYLON.Color4 | BABYLON.Color3; linearHint?: boolean; onColorChanged: (newOne: string) => void; icon?: string; iconLabel?: string; shouldPopRight?: boolean; lockObject?: INSPECTOR.SharedUIComponents.LockObject; } interface IColorPickerComponentState { pickerEnabled: boolean; color: BABYLON.Color3 | BABYLON.Color4; hex: string; } export class ColorPickerLine extends React.Component { private _floatRef; private _floatHostRef; constructor(props: IColorPickerLineProps); syncPositions(): void; shouldComponentUpdate(nextProps: IColorPickerLineProps, nextState: IColorPickerComponentState): boolean; getHexString(props?: Readonly): string; componentDidUpdate(): void; componentDidMount(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColorLineProps { label: string; target?: any; propertyName: string; onPropertyChangedObservable?: BABYLON.Observable; onChange?: () => void; isLinear?: boolean; icon?: string; iconLabel?: string; disableAlpha?: boolean; lockObject: INSPECTOR.SharedUIComponents.LockObject; } interface IColorLineComponentState { isExpanded: boolean; color: BABYLON.Color4; } export class ColorLine extends React.Component { constructor(props: IColorLineProps); shouldComponentUpdate(nextProps: IColorLineProps, nextState: IColorLineComponentState): boolean; getValue(props?: Readonly): BABYLON.Color4; setColorFromString(colorString: string): void; setColor(newColor: BABYLON.Color4): void; switchExpandState(): void; updateStateR(value: number): void; updateStateG(value: number): void; updateStateB(value: number): void; updateStateA(value: number): void; private _convertToColor; private _toColor3; onCopyClick(): void; renderFluent(): import("react/jsx-runtime").JSX.Element; renderOriginal(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColor4LineComponentProps { label: string; target?: any; propertyName: string; onPropertyChangedObservable?: BABYLON.Observable; onChange?: () => void; isLinear?: boolean; icon?: string; iconLabel?: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class Color4LineComponent extends React.Component { render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColor3LineComponentProps { label: string; target: any; propertyName: string; onPropertyChangedObservable?: BABYLON.Observable; isLinear?: boolean; icon?: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; iconLabel?: string; onChange?: () => void; } export class Color3LineComponent extends React.Component { render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ICheckBoxLineComponentProps { label?: string; target?: any; propertyName?: string; isSelected?: boolean | (() => boolean); onSelect?: (value: boolean) => void; onValueChanged?: () => void; onPropertyChangedObservable?: BABYLON.Observable; disabled?: boolean; icon?: string; iconLabel?: string; faIcons?: { enabled: any; disabled: any; }; large?: boolean; } export class CheckBoxLineComponent extends React.Component { private _localChange; constructor(props: ICheckBoxLineComponentProps); shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: { isSelected: boolean; isDisabled: boolean; isConflict: boolean; }): boolean; onChange(): void; onCopyClick(): void; renderOriginal(): import("react/jsx-runtime").JSX.Element; renderFluent(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IButtonLineComponentProps { label: string; onClick: () => void; icon?: string; iconLabel?: string; isDisabled?: boolean; } export class ButtonLineComponent extends React.Component { constructor(props: IButtonLineComponentProps); renderFluent(): import("react/jsx-runtime").JSX.Element; renderOriginal(): import("react/jsx-runtime").JSX.Element; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IBooleanLineComponentProps { label: string; value: boolean; icon?: string; iconLabel?: string; } export class BooleanLineComponent extends React.Component { constructor(props: IBooleanLineComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type TextareaProps = INSPECTOR.SharedUIComponents.BaseComponentProps & { placeholder?: string; }; /** * This is a texarea box that stops propagation of change/keydown events * @param props * @returns */ export var Textarea: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type SyncedSliderProps = INSPECTOR.SharedUIComponents.BaseComponentProps & { min?: number; max?: number; step?: number; }; /** * Component which synchronizes a slider and an input field, allowing the user to change a value using either control * @param props * @returns SyncedSlider component */ export var SyncedSliderInput: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type SwitchProps = INSPECTOR.SharedUIComponents.BaseComponentProps; /** * This is a primitive fluent boolean switch component whose only knowledge is the shared styling across all tools * @param props * @returns Switch component */ export var Switch: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type SpinButtonProps = INSPECTOR.SharedUIComponents.BaseComponentProps; export var SpinButton: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type InputProps = INSPECTOR.SharedUIComponents.BaseComponentProps & { step?: number; placeholder?: string; min?: number; max?: number; }; /** * This is an input text box that stops propagation of change events and sets its width based on the type of input (text or number) * @param props * @returns */ export var Input: React.FunctionComponent>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { type DropdownOptionValue = string | number; export type AcceptedDropdownValue = BABYLON.Nullable | undefined; export type DropdownOption = { /** * Defines the visible part of the option */ label: string; /** * Defines the value part of the option */ value: DropdownOptionValue; }; export type DropdownProps = INSPECTOR.SharedUIComponents.BaseComponentProps & { options: DropdownOption[]; includeNullAs?: "null" | "undefined"; }; /** * Renders a fluent UI dropdown component for the options passed in, and an additional 'Not Defined' option if null is set to true * This component can handle both null and undefined values * @param props * @returns dropdown component */ export var Dropdown: React.FunctionComponent>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type ColorPickerProps = { isLinearMode?: boolean; } & INSPECTOR.SharedUIComponents.BaseComponentProps; export var ColorPickerPopup: React.FunctionComponent>; type HsvKey = "h" | "s" | "v"; export type InputHexProps = INSPECTOR.SharedUIComponents.BaseComponentProps & { label?: string; linearHex?: boolean; isLinearMode?: boolean; }; /** * Component which displays the passed in color's HEX value, either in linearSpace (if linearHex is true) or in gamma space * When the hex color is changed by user, component calculates the new BABYLON.Color3/4 value and calls onChange * * Component uses the isLinearMode boolean to display an informative label regarding linear / gamma space * @param props - The properties for the InputHexField component. * @returns */ export var InputHexField: React.FunctionComponent; type InputHsvFieldProps = { color: BABYLON.Color3 | BABYLON.Color4; label: string; hsvKey: HsvKey; onChange: (color: BABYLON.Color3 | BABYLON.Color4) => void; max: number; scale?: number; }; /** * In the HSV (Hue, Saturation, Value) color model, Hue (H) ranges from 0 to 360 degrees, representing the color's position on the color wheel. * Saturation (S) ranges from 0 to 100%, indicating the intensity or purity of the color, with 0 being shades of gray and 100 being a fully saturated color. * Value (V) ranges from 0 to 100%, representing the brightness of the color, with 0 being black and 100 being the brightest. * @param props - The properties for the InputHsvField component. */ export var InputHsvField: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type CheckboxProps = INSPECTOR.SharedUIComponents.BaseComponentProps; /** * This is a primitive fluent checkbox that can both read and write checked state * @param props * @returns Checkbox component */ export var Checkbox: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type AccordionSectionProps = { title: string; collapseByDefault?: boolean; }; export var AccordionSection: React.FunctionComponent>; export var Accordion: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type TensorPropertyLineProps = INSPECTOR.SharedUIComponents.BaseComponentProps & INSPECTOR.SharedUIComponents.PropertyLineProps & { /** * If passed, all sliders will use this for the min value */ min?: number; /** * If passed, all sliders will use this for the max value */ max?: number; /** * If passed, the UX will use the conversion functions to display/update values */ valueConverter?: { /** * Will call from(val) before displaying in the UX */ from: (val: number) => number; /** * Will call to(val) before calling onChange */ to: (val: number) => number; }; }; type RotationVectorPropertyLineProps = TensorPropertyLineProps & { /** * Display angles as degrees instead of radians */ useDegrees?: boolean; }; export var RotationVectorPropertyLine: React.FunctionComponent; type QuaternionPropertyLineProps = TensorPropertyLineProps & { /** * Display angles as degrees instead of radians */ useDegrees?: boolean; }; export var QuaternionPropertyLine: React.FunctionComponent; export var Vector3PropertyLine: React.FunctionComponent>; export var Vector4PropertyLine: React.FunctionComponent>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { type TextProps = { value: string; tooltip?: string; }; /** * Wraps text in a property line * @param props - INSPECTOR.SharedUIComponents.PropertyLineProps and TextProps * @returns property-line wrapped text */ export var TextPropertyLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { type SyncedSliderLineProps = INSPECTOR.SharedUIComponents.SyncedSliderProps & INSPECTOR.SharedUIComponents.PropertyLineProps; /** * Renders a simple wrapper around the SyncedSliderInput * @param props * @returns */ export var SyncedSliderLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Wraps a switch in a property line * @param props - The properties for the switch and property line * @returns A React element representing the property line with a switch */ export var SwitchPropertyLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type PropertyLineProps = { /** * The name of the property to display in the property line. */ label: string; /** * Optional description for the property, shown on hover of the info icon */ description?: string; /** * Optional function returning a string to copy to clipboard. */ onCopy?: () => string; /** * If supplied, an 'expand' icon will be shown which, when clicked, renders this component within the property line. */ expandedContent?: JSX.Element; /** * Link to the documentation for this property, available from the info icon either linked from the description (if provided) or defalt 'docs' text */ docLink?: string; }; export var LineContainer: import("react").ForwardRefExoticComponent<{ children?: import("react").ReactNode | undefined; } & import("react").RefAttributes>; export type BaseComponentProps = { /** * The value of the property to be displayed and modified. */ value: T; /** * Callback function to handle changes to the value */ onChange: (value: T) => void; /** * Optional flag to disable the component, preventing any interaction. */ disabled?: boolean; /** * Optional class name to apply custom styles to the component. */ className?: string; }; /** * A reusable component that renders a property line with a label and child content, and an optional description, copy button, and expandable section. * * @param props - The properties for the PropertyLine component. * @returns A React element representing the property line. * */ export var PropertyLine: import("react").ForwardRefExoticComponent>; export var PlaceholderPropertyLine: React.FunctionComponent & PropertyLineProps>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { type LinkProps = { value: string; tooltip?: string; onLink?: () => void; url?: string; }; /** * Wraps a link in a property line * @param props - INSPECTOR.SharedUIComponents.PropertyLineProps and LinkProps * @returns property-line wrapped link */ export var LinkPropertyLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export var TextInputPropertyLine: React.FunctionComponent & INSPECTOR.SharedUIComponents.PropertyLineProps>; export var FloatInputPropertyLine: React.FunctionComponent & INSPECTOR.SharedUIComponents.PropertyLineProps>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Wraps a hex input in a property line * @param props - INSPECTOR.SharedUIComponents.PropertyLineProps and INSPECTOR.SharedUIComponents.InputHexProps * @returns property-line wrapped input hex component */ export var HexPropertyLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type ToolHostProps = { /** * Allows host to pass in a theme */ customTheme?: any; /** * Can be set to true to disable the copy button in the tool's property lines. Default is false (copy enabled) */ disableCopy?: boolean; }; export var ToolContext: import("react").Context<{ readonly useFluent: boolean; readonly disableCopy: boolean; }>; /** * For tools which are ready to move over the fluent, wrap the root of the tool (or the panel which you want fluentized) with this component * Today we will only enable fluent if the URL has the `newUX` query parameter is truthy * @param props * @returns */ export var FluentToolWrapper: React.FunctionComponent>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { type FileUploadLineProps = Omit & { onClick: (file: File) => void; accept: string; }; export var FileUploadLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { type DropdownPropertyLineProps = Omit, "includeNullAs"> & INSPECTOR.SharedUIComponents.PropertyLineProps; export var NullableDropdownPropertyLine: React.FunctionComponent>; /** * Dropdown component for explicitly defined number values. * If value can be undefined, use OptionalNumberDropdownPropertyLine instead. * If value can be null, use NullableNumberDropdownPropertyLine instead. */ export var NumberDropdownPropertyLine: React.FunctionComponent>; /** * Dropdown component for explicitly defined string values. * If value can be undefined, use OptionalStringDropdownPropertyLine instead. * If value can be null, use NullableStringDropdownPropertyLine instead. */ export var StringDropdownPropertyLine: React.FunctionComponent>; /** * Dropdown component for BABYLON.Nullable values. */ export var NullableNumberDropdownPropertyLine: React.FunctionComponent>>; /** * Dropdown component for BABYLON.Nullable values. */ export var NullableStringDropdownPropertyLine: React.FunctionComponent>>; /** * Dropdown component for number | undefined values */ export var OptionalNumberDropdownPropertyLine: React.FunctionComponent>; /** * Dropdown component for string | undefined values */ export var OptionalStringDropdownPropertyLine: React.FunctionComponent>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type ColorPropertyLineProps = INSPECTOR.SharedUIComponents.ColorPickerProps & INSPECTOR.SharedUIComponents.PropertyLineProps; export var Color3PropertyLine: React.FunctionComponent & INSPECTOR.SharedUIComponents.PropertyLineProps>; export var Color4PropertyLine: React.FunctionComponent & INSPECTOR.SharedUIComponents.PropertyLineProps>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Wraps a checkbox in a property line * @param props - INSPECTOR.SharedUIComponents.PropertyLineProps and INSPECTOR.SharedUIComponents.CheckboxProps * @returns property-line wrapped checkbox */ export var CheckboxPropertyLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type ButtonLineProps = { label: string; onClick: () => void; disabled?: boolean; icon?: string; title?: string; }; /** * Wraps a button with a label in a line container * @param props Button props plus a label * @returns A button inside a line */ export var ButtonLine: React.FunctionComponent; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export function ClassNames(names: any, styleObject: any): string; export function JoinClassNames(styleObject: any, ...names: string[]): string; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type ToggleProps = { toggled: "on" | "mixed" | "off"; onToggle?: () => void; padded?: boolean; color?: "dark" | "light"; }; export var Toggle: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ITextInputProps { label?: string; placeholder?: string; submitValue: (newValue: string) => void; validateValue?: (value: string) => boolean; cancelSubmit?: () => void; } /** * This component represents a text input that can be submitted or cancelled on buttons * @param props properties * @returns TextInputWithSubmit element */ export const TextInputWithSubmit: (props: ITextInputProps) => import("react/jsx-runtime").JSX.Element; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface MessageDialogProps { message: string; isError: boolean; onClose?: () => void; } export var MessageDialog: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type LabelProps = { text: string; children?: React.ReactChild; color?: "dark" | "light"; }; export var Label: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type IconProps = { color?: "dark" | "light"; icon: string; }; export var Icon: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type ButtonProps = { disabled?: boolean; active?: boolean; onClick?: () => void; color: "light" | "dark"; size: "default" | "small" | "wide" | "smaller"; title?: string; backgroundColor?: string; }; export var Button: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * utility hook to assist using the graph context * @returns */ export const useGraphContext: () => IGraphContext; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type IVisualRecordsType = Record; export type IConnectionType = { id: string; sourceId: string; targetId: string; }; export type ICustomDataType = { type: string; value: any; }; export type INodeType = { id: string; label: string; customData?: ICustomDataType; }; /** * props for the node renderer */ export interface INodeRendererProps { /** * array of connections between nodes */ connections: IConnectionType[]; /** * function called when a new connection is created */ updateConnections: (sourceId: string, targetId: string) => void; /** * function called when a connection is deleted */ deleteLine: (lineId: string) => void; /** * function called when a node is deleted */ deleteNode: (nodeId: string) => void; /** * array of all nodes */ nodes: INodeType[]; /** * id of the node to highlight */ highlightedNode?: BABYLON.Nullable; /** * function to be called if a node is selected */ selectNode?: (nodeId: BABYLON.Nullable) => void; /** * id of this renderer */ id: string; /** * optional list of custom components to be rendered inside nodes of * a certain type */ customComponents?: Record>; } /** * This component is a bridge between the app logic related to the graph, and the actual rendering * of it. It manages the nodes' positions and selection states. * @param props * @returns */ export const NodeRenderer: (props: React.PropsWithChildren) => import("react/jsx-runtime").JSX.Element; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IGraphContainerProps { onNodeMoved: (id: string, x: number, y: number) => void; id: string; } /** * This component contains all the nodes and handles their dragging * @param props properties * @returns graph node container element */ export var GraphNodesContainer: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IGraphNodeProps { id: string; name: string; x: number; y: number; selected?: boolean; width?: number; height?: number; highlighted?: boolean; parentContainerId: string; } export var SingleGraphNode: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * props for the GraphLineContainer */ export interface IGraphLinesContainerProps { /** * id of the container */ id: string; } /** * this component handles the dragging of new connections * @param props * @returns */ export var GraphLinesContainer: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * props for the GraphLine component */ export interface IGraphLineProps { /** * id of the line. temporary lines can have no id */ id?: string; /** * starting x pos of the line */ x1: number; /** * ending x pos of the line */ x2: number; /** * starting y pos of the line */ y1: number; /** * ending y pos of the line */ y2: number; /** * is the line selected */ selected?: boolean; /** * does the line have a direction */ directional?: boolean; } export const MarkerArrowId = "arrow"; /** * This component draws a SVG line between two points, with an optional marker * indicating direction * @param props properties * @returns graph line element */ export var GraphLine: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * this context is used to pass callbacks to the graph nodes and connections */ export interface IGraphContext { onNodesConnected?: (sourceId: string, targetId: string) => void; onLineSelected?: (lineId: string) => void; onNodeSelected?: (nodeId: string) => void; } export var GraphContextManager: import("react").Context; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IGraphContainerProps { } /** * This component is just a simple container to keep the nodes and lines containers * together * @param props * @returns */ export var GraphContainer: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Props for the connector */ export interface IGraphConnectorHandlerProps { /** * id of the parent node */ parentId: string; /** * x position of the parent node */ parentX: number; /** * y position of the parent node */ parentY: number; /** * x position of the connector relative to the parent node */ offsetX?: number; /** * y position of the connector relative to the parent node */ offsetY?: number; /** * width of the parent node */ parentWidth: number; /** * height of the parent node */ parentHeight: number; /** * id of the container where its parent node is */ parentContainerId: string; } /** * This component is used to initiate a connection between two nodes. Simply * drag the handle in a node and drop it in another node to create a connection. * @returns connector element */ export var GraphConnectorHandler: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * This components represents an options menu with optional * customizable properties. Option IDs should be unique. */ export interface IOption { label: string; value: string; id: string; } export interface IOptionsLineComponentProps { options: IOption[]; addOptionPlaceholder?: string; onOptionAdded?: (newOption: IOption) => void; onOptionSelected: (selectedOptionValue: string) => void; selectedOptionValue: string; validateNewOptionValue?: (newOptionValue: string) => boolean; addOptionText?: string; } export const OptionsLineComponent: (props: IOptionsLineComponentProps) => import("react/jsx-runtime").JSX.Element; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface INumericInputComponentProps { label: string; labelTooltip?: string; value: number; step?: number; onChange: (value: number) => void; precision?: number; icon?: string; iconLabel?: string; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class NumericInputComponent extends React.Component { static defaultProps: { step: number; }; private _localChange; constructor(props: INumericInputComponentProps); componentWillUnmount(): void; shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: { value: string; }): boolean; updateValue(valueString: string): void; onBlur(): void; incrementValue(amount: number): void; onKeyDown(evt: React.KeyboardEvent): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IFileButtonLineComponentProps { label: string; onClick: (file: File) => void; accept: string; icon?: string; iconLabel?: string; } export class FileButtonLineComponent extends React.Component { private static _IdGenerator; private _id; private _uploadInputRef; constructor(props: IFileButtonLineComponentProps); onChange(evt: any): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColorPickerLineComponentProps { value: BABYLON.Color4 | BABYLON.Color3; linearHint?: boolean; onColorChanged: (newOne: string) => void; icon?: string; iconLabel?: string; shouldPopRight?: boolean; lockObject?: INSPECTOR.SharedUIComponents.LockObject; backgroundColor?: string; } interface IColorPickerComponentState { pickerEnabled: boolean; color: BABYLON.Color3 | BABYLON.Color4; hex: string; } export class ColorPickerLineComponent extends React.Component { private _floatRef; private _floatHostRef; private _coverRef; constructor(props: IColorPickerLineComponentProps); syncPositions(): void; shouldComponentUpdate(nextProps: IColorPickerLineComponentProps, nextState: IColorPickerComponentState): boolean; getHexString(props?: Readonly): string; componentDidUpdate(): void; componentDidMount(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColorLineComponentProps { label: string; target: any; propertyName: string; onPropertyChangedObservable: BABYLON.Observable; onChange?: () => void; isLinear?: boolean; icon?: string; iconLabel?: string; disableAlpha?: boolean; lockObject: INSPECTOR.SharedUIComponents.LockObject; } interface IColorLineComponentState { isExpanded: boolean; color: BABYLON.Color4; } export class ColorLineComponent extends React.Component { constructor(props: IColorLineComponentProps); shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean; getValue(props?: Readonly): BABYLON.Color4; setColorFromString(colorString: string): void; setColor(newColor: BABYLON.Color4): void; switchExpandState(): void; updateStateR(value: number): void; updateStateG(value: number): void; updateStateB(value: number): void; updateStateA(value: number): void; copyToClipboard(): void; private _convertToColor; private _toColor3; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Given a column and row number in the layout, return the corresponding column/row * @param layout * @param column * @param row * @returns */ export const getPosInLayout: (layout: INSPECTOR.SharedUIComponents.Layout, column: number, row?: number) => INSPECTOR.SharedUIComponents.LayoutColumn | INSPECTOR.SharedUIComponents.LayoutTabsRow; /** * Remove a row in position row, column from the layout, and redistribute heights of remaining rows * @param layout * @param column * @param row */ export const removeLayoutRowAndRedistributePercentages: (layout: INSPECTOR.SharedUIComponents.Layout, column: number, row: number) => void; /** * Add a percentage string to a number * @param p1 the percentage string * @param p2 the number * @returns the sum of the percentage string and the number */ export const addPercentageStringToNumber: (p1: string, p2: number) => number; /** * Parses a percentage string into a number * @param p the percentage string * @returns the parsed number */ export const parsePercentage: (p: string) => number; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export type LayoutTab = { /** * Tab id */ id: string; /** * React component rendered by tab */ component: React.ReactElement; /** * Tab title */ title: string; }; export type LayoutTabsRow = { /** * row id */ id: string; /** * row height in its containing column */ height: string; /** * selected tab in row */ selectedTab: string; /** * list of tabs contained in row */ tabs: LayoutTab[]; }; export type LayoutColumn = { /** * column id */ id: string; /** * column width in the grid */ width: string; /** * column rows */ rows: LayoutTabsRow[]; }; export type Layout = { /** * layout columns */ columns?: LayoutColumn[]; }; export type TabDrag = { /** * row number of the tab being dragged */ rowNumber: number; /** * column number of the tab being dragged */ columnNumber: number; /** * the tabs being dragged */ tabs: { /** * id of tab being dragged */ id: string; }[]; }; export enum ElementTypes { RESIZE_BAR = "0", TAB = "1", TAB_GROUP = "2", NONE = "2" } export enum ResizeDirections { ROW = "row", COLUMN = "column" } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export var LayoutContext: import("react").Context<{ /** * The layout object */ layout: INSPECTOR.SharedUIComponents.Layout; /** * Function to set the layout object in the context */ setLayout: (layout: INSPECTOR.SharedUIComponents.Layout) => void; }>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the TabsContainer component. */ export interface IFlexibleTabsContainerProps { /** * The tabs to display */ tabs: INSPECTOR.SharedUIComponents.LayoutTab[]; /** * Row index of component in layout */ rowIndex: number; /** * Column index of component in layout */ columnIndex: number; /** * Which tab is selected in the layout */ selectedTab?: string; } /** * This component contains a set of tabs of which only one is visible at a time. * The tabs can also be dragged from and to different containers. * @param props properties * @returns tabs container element */ export var FlexibleTabsContainer: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the FlexibleTab component. */ export interface IFlexibleTabProps { /** * The tab's title. */ title: string; /** * If the tab is currently selected or not */ selected: boolean; /** * What happens when the user clicks on the tab */ onClick: () => void; /** * The object that will be sent to the drag event */ item: INSPECTOR.SharedUIComponents.TabDrag; /** * What happens when the user drops another tab after this one */ onTabDroppedAction: (item: INSPECTOR.SharedUIComponents.TabDrag) => void; } /** * A component that renders a tab that the user can click * to activate or drag to reorder. It also listens for * drop events if the user wants to drop another tab * after it. * @param props properties * @returns FlexibleTab element */ export var FlexibleTab: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the ResizeBar component. */ export interface IFlexibleRowResizerProps { /** * Row number of the component that is being resized */ rowNumber: number; /** * Column number of the component being resized */ columnNumber: number; /** * If the resizing happens in row or column direction */ direction: INSPECTOR.SharedUIComponents.ResizeDirections; } /** * The item that will be sent to the drag event */ export type ResizeItem = { /** * If the resizing happens in row or column direction */ direction: INSPECTOR.SharedUIComponents.ResizeDirections; /** * The row number of the component that is being resized */ rowNumber: number; /** * the column number of the component being resized */ columnNumber: number; }; /** * A component that renders a bar that the user can drag to resize. * @param props properties * @returns resize bar element */ export var FlexibleResizeBar: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the INSPECTOR.SharedUIComponents.Layout component. */ export interface IFlexibleGridLayoutProps { /** * A definition of the layout which can be changed by the user */ layoutDefinition: INSPECTOR.SharedUIComponents.Layout; } /** * This component represents a grid layout that can be resized and rearranged * by the user. * @param props properties * @returns layout element */ export var FlexibleGridLayout: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the GridContainer component. */ export interface IFlexibleGridContainerProps { } /** * Component responsible for mapping the layout to the actual components * @returns GridContainer element */ export var FlexibleGridContainer: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the FlexibleDropZone component. */ export interface IFlexibleDropZoneProps { /** * The row number of the component in the layout */ rowNumber: number; /** * The column number of the component in the layout */ columnNumber: number; } /** * This component contains the drag and drop zone for the resize bars that * allow redefining width and height of layout elements * @param props properties * @returns drop zone element */ export var FlexibleDropZone: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the DragHandler component. */ export interface IFlexibleDragHandlerProps { /** * The size of the containing element. Used to calculate the percentage of * space occupied by the component */ containerSize: { width: number; height: number; }; } /** * This component receives the drop events and updates the layout accordingly * @param props properties * @returns DragHandler element */ export var FlexibleDragHandler: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the Column component. */ export interface IFlexibleColumnProps { /** * Width of column */ width: string; } /** * This component represents a single column in the layout. It receives a width * that it occupies and the content to display * @param props * @returns */ export var FlexibleColumn: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Arguments for the DraggableIcon component. */ export interface IDraggableIconProps { /** * Icon source */ src: string; /** * Object that will be passed to the drag event */ item: INSPECTOR.SharedUIComponents.TabDrag; /** * Type of drag event */ type: INSPECTOR.SharedUIComponents.ElementTypes; } /** * An icon that can be dragged by the user * @param props properties * @returns draggable icon element */ export var DraggableIcon: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IHexColorProps { value: string; expectedLength: number; onChange: (value: string) => void; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class HexColorComponent extends React.Component { constructor(props: IHexColorProps); shouldComponentUpdate(nextProps: IHexColorProps, nextState: { hex: string; }): boolean; lock(): void; unlock(): void; updateHexValue(valueString: string): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Interface used to specify creation options for color picker */ export interface IColorPickerComponentProps { color: BABYLON.Color3 | BABYLON.Color4; linearhint?: boolean; debugMode?: boolean; onColorChanged?: (color: BABYLON.Color3 | BABYLON.Color4) => void; lockObject: INSPECTOR.SharedUIComponents.LockObject; backgroundColor?: string; } /** * Interface used to specify creation options for color picker */ export interface IColorPickerState { color: BABYLON.Color3; alpha: number; } /** * Class used to create a color picker */ export class ColorPickerComponent extends React.Component { private _saturationRef; private _hueRef; private _isSaturationPointerDown; private _isHuePointerDown; constructor(props: IColorPickerComponentProps); shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerState): boolean; onSaturationPointerDown(evt: React.PointerEvent): void; onSaturationPointerUp(evt: React.PointerEvent): void; onSaturationPointerMove(evt: React.PointerEvent): void; onHuePointerDown(evt: React.PointerEvent): void; onHuePointerUp(evt: React.PointerEvent): void; onHuePointerMove(evt: React.PointerEvent): void; private _evaluateSaturation; private _evaluateHue; componentDidUpdate(): void; raiseOnColorChanged(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColorComponentEntryProps { value: number; label: string; max?: number; min?: number; onChange: (value: number) => void; disabled?: boolean; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class ColorComponentComponentEntry extends React.Component { constructor(props: IColorComponentEntryProps); updateValue(valueString: string): void; lock(): void; unlock(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { interface ICommandDropdownComponentProps { icon?: string; tooltip: string; defaultValue?: string; items: { label: string; icon?: string; fileButton?: boolean; onClick?: () => void; onCheck?: (value: boolean) => void; storeKey?: string; isActive?: boolean; defaultValue?: boolean | string; subItems?: string[]; }[]; toRight?: boolean; } export class CommandDropdownComponent extends React.Component { constructor(props: ICommandDropdownComponentProps); render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ICommandButtonComponentProps { tooltip: string; shortcut?: string; icon: string; iconLabel?: string; isActive: boolean; onClick: () => void; disabled?: boolean; } export var CommandButtonComponent: React.FC; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface ICommandBarComponentProps { onSaveButtonClicked?: () => void; onSaveToSnippetButtonClicked?: () => void; onLoadFromSnippetButtonClicked?: () => void; onHelpButtonClicked?: () => void; onGiveFeedbackButtonClicked?: () => void; onSelectButtonClicked?: () => void; onPanButtonClicked?: () => void; onZoomButtonClicked?: () => void; onFitButtonClicked?: () => void; onArtboardColorChanged?: (newColor: string) => void; artboardColor?: string; artboardColorPickerColor?: string; } export var CommandBarComponent: React.FC>; } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IHexColorProps { value: string; expectedLength: number; onChange: (value: string) => void; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class HexColor extends React.Component { constructor(props: IHexColorProps); shouldComponentUpdate(nextProps: IHexColorProps, nextState: { hex: string; }): boolean; lock(): void; unlock(): void; updateHexValue(valueString: string): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { /** * Interface used to specify creation options for color picker */ export interface IColorPickerProps { color: BABYLON.Color3 | BABYLON.Color4; linearhint?: boolean; debugMode?: boolean; onColorChanged?: (color: BABYLON.Color3 | BABYLON.Color4) => void; lockObject: INSPECTOR.SharedUIComponents.LockObject; } /** * Interface used to specify creation options for color picker */ export interface IColorPickerState { color: BABYLON.Color3; alpha: number; } /** * Class used to create a color picker */ export class ColorPicker extends React.Component { private _saturationRef; private _hueRef; private _isSaturationPointerDown; private _isHuePointerDown; constructor(props: IColorPickerProps); shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean; onSaturationPointerDown(evt: React.PointerEvent): void; onSaturationPointerUp(evt: React.PointerEvent): void; onSaturationPointerMove(evt: React.PointerEvent): void; onHuePointerDown(evt: React.PointerEvent): void; onHuePointerUp(evt: React.PointerEvent): void; onHuePointerMove(evt: React.PointerEvent): void; private _evaluateSaturation; private _evaluateHue; componentDidUpdate(): void; raiseOnColorChanged(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { } declare module INSPECTOR.SharedUIComponents { export interface IColorComponentEntryProps { value: number; label: string; max?: number; min?: number; onChange: (value: number) => void; disabled?: boolean; lockObject: INSPECTOR.SharedUIComponents.LockObject; } export class ColorComponentEntry extends React.Component { constructor(props: IColorComponentEntryProps); updateValue(valueString: string): void; lock(): void; unlock(): void; render(): import("react/jsx-runtime").JSX.Element; } } declare module INSPECTOR { }