///
declare module "babylonjs-inspector/components/propertyChangedEvent" {
export class PropertyChangedEvent {
object: any;
property: string;
value: any;
initialValue: any;
allowNullValue?: boolean;
}
}
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/globalState" {
import { IGLTFValidationResults } from "babylonjs-gltf2interface";
import { Nullable } from "babylonjs/types";
import { Observable, Observer } 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";
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;
glTFLoaderExtensionDefaults: {
[name: string]: {
[key: string]: any;
};
};
glTFLoaderDefaults: {
[key: string]: any;
};
glTFLoaderExtensions: {
[key: string]: import("babylonjs-loaders/glTF/index").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: import("babylonjs-loaders/glTF/index").GLTFFileLoader): void;
lightGizmos: Array;
enableLightGizmo(light: Light, enable?: boolean): void;
cameraGizmos: Array;
enableCameraGizmo(camera: Camera, enable?: boolean): void;
}
}
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;
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/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;
renderLabel(child: PaneComponent, index: number): JSX.Element;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/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;
}
export class TextLineComponent extends React.Component {
constructor(props: ITextLineComponentProps);
onLink(): void;
renderContent(): JSX.Element | null;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lineContainerComponent" {
import * as React from "react";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ILineContainerComponentProps {
globalState?: GlobalState;
title: string;
children: any[] | any;
closed?: boolean;
}
export class LineContainerComponent extends React.Component {
constructor(props: ILineContainerComponentProps);
switchExpandedState(): void;
componentDidMount(): void;
renderHeader(): JSX.Element;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/valueLineComponent" {
import * as React from "react";
interface IValueLineComponentProps {
label: string;
value: number;
color?: string;
fractionDigits?: number;
units?: string;
}
export class ValueLineComponent extends React.Component {
constructor(props: IValueLineComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/booleanLineComponent" {
import * as React from "react";
export interface IBooleanLineComponentProps {
label: string;
value: boolean;
}
export class BooleanLineComponent extends React.Component {
constructor(props: IBooleanLineComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/statisticsTabComponent" {
import { PaneComponent, IPaneComponentProps } from "babylonjs-inspector/components/actionTabs/paneComponent";
export class StatisticsTabComponent extends PaneComponent {
private _sceneInstrumentation;
private _engineInstrumentation;
private _timerIntervalId;
constructor(props: IPaneComponentProps);
componentWillUnmount(): void;
render(): JSX.Element | null;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/checkBoxLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
export interface ICheckBoxLineComponentProps {
label: string;
target?: any;
propertyName?: string;
isSelected?: () => boolean;
onSelect?: (value: boolean) => void;
onValueChanged?: () => void;
onPropertyChangedObservable?: Observable;
}
export class CheckBoxLineComponent extends React.Component {
private static _UniqueIdSeed;
private _uniqueId;
private _localChange;
constructor(props: ICheckBoxLineComponentProps);
shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
isSelected: boolean;
}): boolean;
onChange(): void;
render(): JSX.Element;
}
}
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;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/debugTabComponent" {
import { PaneComponent, IPaneComponentProps } from "babylonjs-inspector/components/actionTabs/paneComponent";
export class DebugTabComponent extends PaneComponent {
private _physicsViewersEnabled;
constructor(props: IPaneComponentProps);
switchPhysicsViewers(): void;
render(): JSX.Element | null;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/sliderLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
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;
}
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;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/optionsLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
export const Null_Value: number;
export class ListLineOption {
label: string;
value: number;
selected?: boolean;
}
export interface IOptionsLineComponentProps {
label: string;
target: any;
propertyName: string;
options: ListLineOption[];
noDirectUpdate?: boolean;
onSelect?: (value: number) => void;
extractValue?: () => number;
onPropertyChangedObservable?: Observable;
allowNullValue?: boolean;
}
export class OptionsLineComponent extends React.Component {
private _localChange;
private remapValueIn;
private remapValueOut;
constructor(props: IOptionsLineComponentProps);
shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
value: number;
}): boolean;
raiseOnPropertyChanged(newValue: number, previousValue: number): void;
updateValue(valueString: string): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/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/components/actionTabs/lines/numericInputComponent" {
import * as React from "react";
interface INumericInputComponentProps {
label: string;
value: number;
step?: number;
onChange: (value: number) => void;
precision?: number;
}
export class NumericInputComponent extends React.Component {
static defaultProps: {
step: number;
};
private _localChange;
constructor(props: INumericInputComponentProps);
shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
value: string;
}): boolean;
updateValue(evt: any): void;
onBlur(): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/colorPickerComponent" {
import * as React from "react";
import { Color4, Color3 } from 'babylonjs/Maths/math.color';
export interface IColorPickerComponentProps {
value: Color4 | Color3;
onColorChanged: (newOne: string) => void;
disableAlpha?: boolean;
}
interface IColorPickerComponentState {
pickerEnabled: boolean;
color: {
r: number;
g: number;
b: number;
a?: number;
};
hex: string;
}
export class ColorPickerLineComponent extends React.Component {
private _floatRef;
private _floatHostRef;
constructor(props: IColorPickerComponentProps);
syncPositions(): void;
shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
componentDidUpdate(): void;
componentDidMount(): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/color3LineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Color3 } from 'babylonjs/Maths/math.color';
export interface IColor3LineComponentProps {
label: string;
target: any;
propertyName: string;
onPropertyChangedObservable?: Observable;
isLinear?: boolean;
}
export class Color3LineComponent extends React.Component {
private _localChange;
constructor(props: IColor3LineComponentProps);
shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
color: Color3;
}): boolean;
setPropertyValue(newColor: Color3): void;
onChange(newValue: string): void;
switchExpandState(): void;
raiseOnPropertyChanged(previousValue: Color3): void;
updateStateR(value: number): void;
updateStateG(value: number): void;
updateStateB(value: number): void;
copyToClipboard(): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/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/components/propertyChangedEvent";
interface IVector3LineComponentProps {
label: string;
target: any;
propertyName: string;
step?: number;
onChange?: (newvalue: Vector3) => void;
useEuler?: boolean;
onPropertyChangedObservable?: Observable;
noSlider?: boolean;
}
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;
render(): JSX.Element;
}
}
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";
interface IQuaternionLineComponentProps {
label: string;
target: any;
useEuler?: boolean;
propertyName: string;
onPropertyChangedObservable?: Observable;
}
export class QuaternionLineComponent extends React.Component {
private _localChange;
constructor(props: IQuaternionLineComponentProps);
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;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/textInputLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
interface ITextInputLineComponentProps {
label: string;
lockObject: LockObject;
target?: any;
propertyName?: string;
value?: string;
onChange?: (value: string) => void;
onPropertyChangedObservable?: Observable;
}
export class TextInputLineComponent extends React.Component {
private _localChange;
constructor(props: ITextInputLineComponentProps);
componentWillUnmount(): void;
shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
value: string;
}): boolean;
raiseOnPropertyChanged(newValue: string, previousValue: string): void;
updateValue(value: string): void;
render(): JSX.Element;
}
}
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/components/actionTabs/tabs/propertyGrids/lockObject";
interface ICustomPropertyGridComponentProps {
globalState: GlobalState;
target: any;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class CustomPropertyGridComponent extends React.Component {
constructor(props: ICustomPropertyGridComponentProps);
renderInspectable(inspectable: IInspectable): JSX.Element | null;
render(): JSX.Element | null;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/buttonLineComponent" {
import * as React from "react";
export interface IButtonLineComponentProps {
label: string;
onClick: () => void;
}
export class ButtonLineComponent extends React.Component {
constructor(props: IButtonLineComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/floatLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/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;
}
export class FloatLineComponent extends React.Component {
private _localChange;
private _store;
constructor(props: IFloatLineComponentProps);
componentWillUnmount(): void;
shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
value: string;
}): boolean;
raiseOnPropertyChanged(newValue: number, previousValue: number): void;
updateValue(valueString: string): void;
lock(): void;
unlock(): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/anchorSvgPoint" {
import * as React from "react";
import { Vector2 } from "babylonjs/Maths/math.vector";
interface IAnchorSvgPointProps {
control: Vector2;
anchor: Vector2;
active: boolean;
type: string;
index: string;
selected: boolean;
selectControlPoint: (id: string) => void;
framesInCanvasView: {
from: number;
to: number;
};
}
/**
* Renders the control point to a keyframe.
*/
export class AnchorSvgPoint extends React.Component {
constructor(props: IAnchorSvgPointProps);
componentDidUpdate(prevProps: IAnchorSvgPointProps, prevState: any): void;
select: () => void;
setVisiblePoint(): Vector2;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/keyframeSvgPoint" {
import * as React from "react";
import { Vector2 } from "babylonjs/Maths/math.vector";
export interface IKeyframeSvgPoint {
keyframePoint: Vector2;
rightControlPoint: Vector2 | null;
leftControlPoint: Vector2 | null;
id: string;
selected: boolean;
isLeftActive: boolean;
isRightActive: boolean;
curveId?: ICurveMetaData;
}
export interface ICurveMetaData {
id: number;
animationName: string;
property: string;
}
interface IKeyframeSvgPointProps {
keyframePoint: Vector2;
leftControlPoint: Vector2 | null;
rightControlPoint: Vector2 | null;
id: string;
selected: boolean;
selectKeyframe: (id: string, multiselect: boolean) => void;
selectedControlPoint: (type: string, id: string) => void;
isLeftActive: boolean;
isRightActive: boolean;
framesInCanvasView: {
from: number;
to: number;
};
}
/**
* Renders the Keyframe as an SVG Element for the Canvas component.
* Holds the two control points to generate the proper curve.
*/
export class KeyframeSvgPoint extends React.Component {
constructor(props: IKeyframeSvgPointProps);
select: (e: React.MouseEvent) => void;
selectedControlPointId: (type: string) => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/svgDraggableArea" {
import * as React from "react";
import { Vector2 } from "babylonjs/Maths/math.vector";
import { IKeyframeSvgPoint } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/keyframeSvgPoint";
interface ISvgDraggableAreaProps {
keyframeSvgPoints: IKeyframeSvgPoint[];
updatePosition: (updatedKeyframe: IKeyframeSvgPoint, id: string) => void;
scale: number;
viewBoxScale: number;
deselectKeyframes: () => void;
removeSelectedKeyframes: (points: IKeyframeSvgPoint[]) => void;
panningY: (panningY: number) => void;
panningX: (panningX: number) => void;
setCurrentFrame: (direction: number) => void;
positionCanvas?: Vector2;
repositionCanvas?: boolean;
canvasPositionEnded: () => void;
resetActionableKeyframe: () => void;
framesInCanvasView: {
from: number;
to: number;
};
framesResized: number;
}
/**
* The SvgDraggableArea is a wrapper for SVG Canvas the interaction
*
* Here we control the drag and key behavior for the SVG components.
*/
export class SvgDraggableArea extends React.Component {
private _active;
private _isCurrentPointControl;
private _currentPointId;
private _draggableArea;
private _panStart;
private _panStop;
private _playheadDrag;
private _playheadSelected;
private _movedX;
private _movedY;
private _isControlKeyPress;
readonly _dragBuffer: number;
readonly _draggingMultiplier: number;
constructor(props: ISvgDraggableAreaProps);
componentDidMount(): void;
componentDidUpdate(prevProps: ISvgDraggableAreaProps): void;
dragStart: (e: React.MouseEvent) => void;
drag: (e: React.MouseEvent) => void;
dragEnd: (e: React.MouseEvent) => void;
getMousePosition: (e: React.MouseEvent) => Vector2 | undefined;
/**
* Handles the canvas panning direction and sets the X and Y values to move the
* SVG canvas
*/
panDirection(): void;
keyDown(e: KeyboardEvent): void;
keyUp(e: KeyboardEvent): void;
focus: (e: React.MouseEvent) => void;
isNotControlPointActive(): boolean;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/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);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/controls" {
import * as React from "react";
import { IAnimationKey } from "babylonjs/Animations/animationKey";
interface IControlsProps {
keyframes: IAnimationKey[] | null;
selected: IAnimationKey | null;
currentFrame: number;
onCurrentFrameChange: (frame: number) => void;
repositionCanvas: (keyframe: IAnimationKey) => void;
playPause: (direction: number) => void;
isPlaying: boolean;
scrollable: React.RefObject;
}
/**
* The playback controls for the animation editor
*/
export class Controls extends React.Component {
readonly _sizeOfKeyframe: number;
constructor(props: IControlsProps);
playBackwards: () => void;
play: () => void;
pause: () => void;
moveToAnimationStart: () => void;
moveToAnimationEnd: () => void;
nextKeyframe: () => void;
previousKeyframe: () => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/timeline" {
import * as React from "react";
import { IAnimationKey } from "babylonjs/Animations/animationKey";
interface ITimelineProps {
keyframes: IAnimationKey[] | null;
selected: IAnimationKey | null;
currentFrame: number;
onCurrentFrameChange: (frame: number) => void;
onAnimationLimitChange: (limit: number) => void;
dragKeyframe: (frame: number, index: number) => void;
playPause: (direction: number) => void;
isPlaying: boolean;
animationLimit: number;
fps: number;
repositionCanvas: (keyframe: IAnimationKey) => void;
resizeWindowProportion: number;
}
/**
* The Timeline for the curve editor
*
* Has a scrollbar that can be resized and move to left and right.
* The timeline does not affect the Canvas but only the frame container.
*/
export class Timeline extends React.Component {
private _scrollable;
private _scrollbarHandle;
private _scrollContainer;
private _inputAnimationLimit;
private _direction;
private _scrolling;
private _shiftX;
private _active;
readonly _marginScrollbar: number;
constructor(props: ITimelineProps);
componentDidMount(): void;
componentDidUpdate(prevProps: ITimelineProps): void;
componentWillUnmount(): void;
isEnterKeyUp(event: KeyboardEvent): void;
onInputBlur(event: React.FocusEvent): void;
setControlState(): void;
/**
* @param {number} start Frame from which the scrollbar should begin.
* @param {number} end Last frame for the timeline.
*/
calculateScrollWidth(start: number, end: number): number | undefined;
playBackwards(event: React.MouseEvent): void;
play(event: React.MouseEvent): void;
pause(event: React.MouseEvent): void;
setCurrentFrame: (event: React.MouseEvent) => void;
/**
* Handles the change of number of frames available in the timeline.
*/
handleLimitChange(event: React.ChangeEvent): void;
dragStart: (e: React.MouseEvent) => void;
drag: (e: React.MouseEvent) => void;
/**
* Check if the frame is being used as a Keyframe by the animation
*/
isFrameBeingUsed(frame: number, direction: number): number | false;
dragEnd: (e: React.MouseEvent) => void;
scrollDragStart: (e: React.MouseEvent) => void;
scrollDrag: (e: React.MouseEvent) => void;
scrollDragEnd: (e: React.MouseEvent) => void;
/**
* Sets the start, end and selection length of the scrollbar. This will control the width and
* height of the scrollbar as well as the number of frames available
* @param {number} pageX Controls the X axis of the scrollbar movement.
*/
moveScrollbar(pageX: number): void;
/**
* Controls the resizing of the scrollbar from the right handle
*/
resizeScrollbarRight(clientX: number): void;
/**
* Controls the resizing of the scrollbar from the left handle
*/
resizeScrollbarLeft(clientX: number): void;
/**
* Returns array with the expected length between two numbers
*/
range(start: number, end: number): number[];
getKeyframe(frame: number): false | IAnimationKey | undefined;
getCurrentFrame(frame: number): boolean;
dragDomFalse: () => boolean;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/notification" {
import * as React from "react";
interface IPlayheadProps {
message: string;
open: boolean;
close: () => void;
}
/**
* Renders the notification for the user
*/
export class Notification extends React.Component {
constructor(props: IPlayheadProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/graphActionsBar" {
import * as React from "react";
import { IActionableKeyFrame } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationCurveEditorComponent";
interface IGraphActionsBarProps {
addKeyframe: () => void;
removeKeyframe: () => void;
frameSelectedKeyframes: () => void;
handleValueChange: (e: React.ChangeEvent) => void;
handleFrameChange: (e: React.ChangeEvent) => void;
flatTangent: () => void;
brokeTangents: () => void;
setLerpToActiveControlPoint: () => void;
brokenMode: boolean;
lerpMode: boolean;
actionableKeyframe: IActionableKeyFrame;
title: string;
enabled: boolean;
setKeyframeValue: (actionableKeyframe: IActionableKeyFrame) => void;
frameRange: {
min: number | undefined;
max: number | undefined;
};
}
/**
* Has the buttons and actions for the Canvas Graph.
* Handles input change and actions (flat, broken mode, set linear control points)
*/
export class GraphActionsBar extends React.Component {
private _frameInput;
private _valueInput;
constructor(props: IGraphActionsBarProps);
componentDidMount(): void;
componentDidUpdate(prevProps: IGraphActionsBarProps, prevState: any): void;
selectedKeyframeChanged(keyframe: IActionableKeyFrame): {
frame: string;
value: string;
};
componentWillUnmount(): void;
isEnterKeyUp(event: KeyboardEvent): void;
onBlur: (event: React.FocusEvent) => void;
getFrame(): string | number;
getValue(): string | number;
handleValueChange: (e: React.ChangeEvent) => void;
handleFrameChange: (e: React.ChangeEvent) => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/addAnimation" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Animation } from "babylonjs/Animations/animation";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
interface IAddAnimationProps {
isOpen: boolean;
close: () => void;
entity: IAnimatable;
onPropertyChangedObservable?: Observable;
setNotificationMessage: (message: string) => void;
finishedUpdate: () => void;
addedNewAnimation: (animation: Animation) => void;
fps: number;
selectedToUpdate?: Animation | undefined;
}
/**
* Controls the creation of a new animation
*/
export class AddAnimation extends React.Component {
constructor(props: IAddAnimationProps);
setInitialState(editingAnimation?: Animation): {
animationName: string;
animationTargetPath: string;
animationType: number;
loopMode: number;
animationTargetProperty: string;
isUpdating: boolean;
};
componentDidUpdate(prevProps: IAddAnimationProps, prevState: any): void;
updateAnimation: () => void;
getTypeAsString(type: number): "Float" | "Quaternion" | "Vector3" | "Vector2" | "Size" | "Color3" | "Color4";
addAnimation: () => void;
raiseOnPropertyChanged(newValue: Animation[], previousValue: Animation[]): void;
raiseOnPropertyUpdated(newValue: string | number | undefined, previousValue: string | number, property: string): void;
handlePathChange: (event: React.ChangeEvent) => void;
handleNameChange: (event: React.ChangeEvent) => void;
handleTypeChange: (event: React.ChangeEvent) => void;
handlePropertyChange: (event: React.ChangeEvent) => void;
handleLoopModeChange: (event: React.ChangeEvent) => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationListTree" {
import * as React from "react";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { TargetedAnimation } from "babylonjs/Animations/animationGroup";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Animation } from "babylonjs/Animations/animation";
import { Nullable } from "babylonjs/types";
interface IAnimationListTreeProps {
isTargetedAnimation: boolean;
entity: IAnimatable | TargetedAnimation;
selected: Animation | null;
onPropertyChangedObservable?: Observable;
selectAnimation: (selected: Animation, coordinate?: SelectedCoordinate) => void;
empty: () => void;
editAnimation: (selected: Animation) => void;
deselectAnimation: () => void;
}
interface Item {
index: number;
name: string;
property: string;
selected: boolean;
open: boolean;
}
export enum SelectedCoordinate {
x = 0,
y = 1,
z = 2,
w = 3,
r = 0,
g = 1,
b = 2,
a = 3,
width = 0,
height = 1
}
interface ItemCoordinate {
id: string;
color: string;
coordinate: SelectedCoordinate;
}
/**
* Renders a list of current animations.
*/
export class AnimationListTree extends React.Component | Animation;
}> {
constructor(props: IAnimationListTreeProps);
componentDidUpdate(prevProps: IAnimationListTreeProps): void;
deleteAnimation: () => void;
raiseOnPropertyChanged(newValue: Animation[], previousValue: Animation[]): void;
generateList(): Item[] | null;
toggleProperty(index: number): void;
setSelectedCoordinate(animation: Animation, coordinate: SelectedCoordinate, index: number): void;
coordinateItem(i: number, animation: Animation, coordinate: string, color: string, selectedCoordinate: SelectedCoordinate): JSX.Element;
typeAnimationItem(animation: Animation, i: number, childrenElements: ItemCoordinate[]): JSX.Element;
setListItem(animation: Animation, i: number): JSX.Element | null;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/fileButtonLineComponent" {
import * as React from "react";
interface IFileButtonLineComponentProps {
label: string;
onClick: (file: File) => void;
accept: string;
}
export class FileButtonLineComponent extends React.Component {
private static _IDGenerator;
private _id;
private uploadInputRef;
constructor(props: IFileButtonLineComponentProps);
onChange(evt: any): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/loadsnippet" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Animation } from "babylonjs/Animations/animation";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { TargetedAnimation } from "babylonjs/Animations/animationGroup";
interface ILoadSnippetProps {
animations: Animation[];
onPropertyChangedObservable?: Observable;
lockObject: LockObject;
globalState: GlobalState;
snippetServer: string;
setSnippetId: (id: string) => void;
entity: IAnimatable | TargetedAnimation;
setNotificationMessage: (message: string) => void;
animationsLoaded: (numberOfAnimations: number) => void;
}
/**
* Loads animation locally or from the Babylon.js Snippet Server
*/
export class LoadSnippet extends React.Component {
private _serverAddress;
constructor(props: ILoadSnippetProps);
change: (value: string) => void;
loadFromFile: (file: File) => void;
loadFromSnippet: () => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/saveSnippet" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Animation } from "babylonjs/Animations/animation";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Nullable } from "babylonjs/types";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ISaveSnippetProps {
animations: Nullable;
onPropertyChangedObservable?: Observable;
lockObject: LockObject;
globalState: GlobalState;
snippetServer: string;
snippetId: string;
}
export interface Snippet {
url: string;
id: string;
}
interface SelectedAnimation {
id: string;
name: string;
index: number;
selected: boolean;
}
/**
* Saves the animation snippet to the Babylon.js site or downloads the animation file locally
*/
export class SaveSnippet extends React.Component {
constructor(props: ISaveSnippetProps);
handleCheckboxChange: (e: React.ChangeEvent) => void;
stringifySelectedAnimations(): string;
saveToFile: () => void;
saveToSnippet: () => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/editorControls" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Animation } from "babylonjs/Animations/animation";
import { SelectedCoordinate } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationListTree";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { TargetedAnimation } from "babylonjs/Animations/animationGroup";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IEditorControlsProps {
isTargetedAnimation: boolean;
entity: IAnimatable | TargetedAnimation;
selected: Animation | null;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
setNotificationMessage: (message: string) => void;
selectAnimation: (selected: Animation, axis?: SelectedCoordinate) => void;
setFps: (fps: number) => void;
setIsLooping: () => void;
globalState: GlobalState;
snippetServer: string;
deselectAnimation: () => void;
fps: number;
}
/**
* Renders the Curve Editor controls to create, save, remove, load and edit animations
*/
export class EditorControls extends React.Component {
constructor(props: IEditorControlsProps);
componentDidUpdate(prevProps: IEditorControlsProps): void;
onAnimationAdded: (animation: Animation) => void;
finishedUpdate: () => void;
recountAnimations(): number;
changeLoopBehavior: () => void;
handleFirstTab: () => void;
handleSecondTab: () => void;
handleThirdTab: () => void;
handleFourthTab: () => void;
handleTabs(tab: number): void;
handleChangeFps: (fps: number) => void;
/**
* Cleans the list when has been emptied
*/
onEmptiedList: () => void;
/**
* When animations have been reloaded update tabs
*/
animationsLoaded: (numberOfAnimations: number) => void;
editAnimation: (selected: Animation) => void;
setSnippetId: (id: string) => void;
/**
* Marks animation tab closed and hides the tab
*/
onCloseAddAnimation: () => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/scale-label" {
import * as React from "react";
import { CurveScale } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationCurveEditorComponent";
interface ISwitchButtonProps {
current: CurveScale;
action?: (event: CurveScale) => void;
}
/**
* Displays the current scale
*/
export class ScaleLabel extends React.Component {
constructor(props: ISwitchButtonProps);
renderLabel(scale: CurveScale): "" | "DEG" | "FLT" | "INT" | "RAD";
onClickHandle: () => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationCurveEditorComponent" {
import * as React from "react";
import { Animation } from "babylonjs/Animations/animation";
import { Vector2, Vector3, Quaternion } from "babylonjs/Maths/math.vector";
import { Color3, Color4 } from "babylonjs/Maths/math.color";
import { Size } from "babylonjs/Maths/math.size";
import { EasingFunction } from "babylonjs/Animations/easing";
import { IAnimationKey } from "babylonjs/Animations/animationKey";
import { IKeyframeSvgPoint } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/keyframeSvgPoint";
import { Scene } from "babylonjs/scene";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { TargetedAnimation } from "babylonjs/Animations/animationGroup";
import { SelectedCoordinate } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/animations/animationListTree";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
import { Nullable } from "babylonjs/types";
interface IAnimationCurveEditorComponentProps {
playOrPause?: () => void;
scene: Scene;
entity: IAnimatable | TargetedAnimation;
lockObject: LockObject;
globalState: GlobalState;
}
interface ICanvasAxis {
value: number;
label: number;
}
export enum CurveScale {
float = 0,
radians = 1,
degrees = 2,
integers = 3,
default = 4
}
export interface IActionableKeyFrame {
frame?: number | string;
value?: any;
}
interface ICurveData {
pathData: string;
pathLength: number;
domCurve: React.RefObject;
color: string;
id: string;
}
/**
* Animation curve Editor Component
*/
export class AnimationCurveEditorComponent extends React.Component;
canvasWidthScale: number;
valuesPositionResize: number;
framesInCanvasView: {
from: number;
to: number;
};
maxFrame: number | undefined;
minFrame: number | undefined;
framesResized: number;
}> {
readonly _entityName: string;
private _snippetUrl;
private _heightScale;
private _scaleFactor;
private _currentScale;
private _pixelFrameUnit;
private _svgKeyframes;
private _isPlaying;
private _graphCanvas;
private _editor;
private _editorWindow;
private _resizeId;
private _svgCanvas;
private _isTargetedAnimation;
private _resizedTimeline;
private _onBeforeRenderObserver;
private _mainAnimatable;
constructor(props: IAnimationCurveEditorComponentProps);
componentDidMount(): void;
componentDidUpdate(prevProps: IAnimationCurveEditorComponentProps, prevState: any): void;
componentWillUnmount(): void;
onCurrentFrameChangeChangeScene(value: number): void;
/**
* Notifications
* To add notification we set the state and clear to make the notification bar hide.
*/
clearNotification: () => void;
/**
* Zoom and Scroll
* This section handles zoom and scroll
* of the graph area.
*/
zoom: (e: React.WheelEvent) => void;
/**
* Returns Array with labels and values for Frame axis in Canvas
*/
setFrameAxis(currentLength: number): {
value: number;
label: number;
}[];
/**
* Returns Array with labels, lines and values for Value axis in Canvas
*/
setValueLines(): {
value: number;
label: string;
}[];
/**
* Creates a string id from animation name and the keyframe index
*/
encodeCurveId(animationName: string, keyframeIndex: number): string;
/**
* Returns the animation keyframe index and the animation selected coordinate (x, y, z)
*/
decodeCurveId(id: string): {
order: number;
coordinate: number;
};
/**
* Returns the value from a keyframe
*/
getKeyframeValueFromAnimation(id: string): {
frame: number;
value: number;
} | undefined;
/**
* Keyframe Manipulation
* This section handles events from SvgDraggableArea.
*/
selectKeyframe: (id: string, multiselect: boolean) => void;
/**
* Determine if two control points are collinear (flat tangent)
*/
hasCollinearPoints: (kf: IKeyframeSvgPoint | undefined) => boolean;
/**
* Returns the previous and next keyframe from a selected frame.
*/
getPreviousAndNextKeyframe: (frame: number) => {
prev: number | undefined;
next: number | undefined;
};
/**
* Selects a keyframe in animation based on its Id
*/
selectKeyframeFromId: (id: string, actionableKeyframe: IActionableKeyFrame) => void;
/**
* Resets the current selected keyframe as an updatable pairs by Graph Control Bar
*/
resetActionableKeyframe: () => void;
/**
* Sets the selected control point.
*/
selectedControlPoint: (type: string, id: string) => void;
/**
* Sets the selected control point.
*/
deselectKeyframes: () => void;
/**
* Update the Animation Key values based on its type
*/
updateValuePerCoordinate(dataType: number, value: number | Vector2 | Vector3 | Color3 | Color4 | Size | Quaternion, newValue: number, coordinate?: number): number | Vector3 | Quaternion | Color3 | Color4 | Vector2 | Size;
/**
* Animation should always have a keyframe at Frame Zero
*/
forceFrameZeroToExist(keys: IAnimationKey[]): void;
/**
* Renders SVG points with dragging of the curve
*/
renderPoints: (updatedSvgKeyFrame: IKeyframeSvgPoint, id: string) => void;
/**
* Updates the left control point on render points
*/
updateLeftControlPoint(updatedSvgKeyFrame: IKeyframeSvgPoint, key: IAnimationKey, dataType: number, coordinate: number): void;
/**
* Updates the right control point on render points
*/
updateRightControlPoint(updatedSvgKeyFrame: IKeyframeSvgPoint, key: IAnimationKey, dataType: number, coordinate: number): void;
/**
* Get the current Control Point weight (how far the X value is multiplied)
*/
getControlPointWeight(updatedSvgKeyFrame: IKeyframeSvgPoint): number;
/**
* Handles a Frame selection change
*/
handleFrameChange: (event: React.ChangeEvent) => void;
/**
* Handles how a value change on a selected frame
*/
handleValueChange: (event: React.ChangeEvent) => void;
/**
* Set the Keyframe from input control in Graph Control Bar
*/
setKeyframeValueFromInput: (actionableKeyframe: IActionableKeyFrame) => void;
/**
* Sets the SVG Keyframe value
*/
setKeyframeValue: () => void;
/**
* Set the flat tangent to the current selected control points.
*/
setFlatTangent: () => void;
/**
* Sets Broken mode of lines
*/
setBrokenMode: () => void;
/**
* Sets a control point to be a linear interpolation with its Keyframe
*/
setLerpToActiveControlPoint: () => void;
/**
* Adds a new keyframe to the curve on canvas click
*/
addKeyframeClick: () => void;
/**
* Remove keyframe on click
*/
removeKeyframeClick: () => void;
/**
* Remove the selected keyframes
*/
removeKeyframes: (points: IKeyframeSvgPoint[]) => void;
/**
* Adds a keyframe
*/
addKeyFrame(event: React.MouseEvent): void;
/**
* Curve Rendering Functions
* This section handles how to render curves.
*/
setKeyframePointLinear(point: Vector2, index: number): void;
flatTangents(keyframes: IAnimationKey[], dataType: number): IAnimationKey[];
/**
* Return a Keyframe zero value depending on Type
*/
returnZero(dataType: number): 0 | Vector3 | Quaternion | Color3 | Color4 | Vector2 | Size;
/**
* Return the keyframe value as an array depending on type
*/
getValueAsArray(valueType: number, value: number | Vector2 | Vector3 | Color3 | Color4 | Size | Quaternion): number[];
/**
* Sets the keyframe value as an array depending on type
*/
setValueAsType(valueType: number, arrayValue: number[]): number | Vector3 | Quaternion | Color3 | Color4 | Vector2 | Size;
/**
* Returns the SVG Path Data to render the curve
*/
getPathData(animation: Animation | null): ICurveData[] | undefined;
getAnimationData(animation: Animation): {
loopMode: number | undefined;
name: string;
blendingSpeed: number;
targetPropertyPath: string[];
targetProperty: string;
framesPerSecond: number;
highestFrame: number;
usesTangents: boolean;
easingType: string | undefined;
easingMode: number | undefined;
valueType: number;
};
calculateLinearTangents(keyframes: IAnimationKey[]): IAnimationKey[];
/**
* Calculates the proper linear tangents if there is no tangents defined
*/
curvePathWithoutTangents(keyframes: IAnimationKey[], data: string, middle: number, type: number, coordinate: number, animationName: string): string;
/**
* Calculates the curve data and control points for animation
*/
curvePathWithTangents(keyframes: IAnimationKey[], data: string, middle: number, type: number, coordinate: number, animationName: string): string;
/**
* Calculates a curve path from predefined easing function
*/
curvePath(keyframes: IAnimationKey[], data: string, middle: number, easingFunction: EasingFunction): string;
/**
* Sets the proper SVG Keyframe points
*/
setKeyframePoint(controlPoints: Vector2[], index: number, keyframesCount: number): void;
interpolateControlPoints(p0: Vector2, p1: Vector2, u: number, p2: Vector2, v: number, p3: Vector2): Vector2[] | undefined;
deselectAnimation: () => void;
/**
* Remove all curves from canvas
*/
cleanCanvas: () => void;
/**
* Selects the animation and renders the curve
*/
selectAnimation: (animation: Animation, coordinate?: SelectedCoordinate | undefined) => void;
/**
* Set the state for the last selected keyframe
*/
postSelectionEvents: () => void;
/**
* Set main animatable to play or pause the animation
*/
setMainAnimatable(): void;
isAnimationPlaying(): boolean;
stopAnimation(): void;
setIsLooping: () => void;
setFramesPerSecond: (fps: number) => void;
/**
* Check if the animation has easing predefined
*/
analyzeAnimationForLerp(animation: Animation | null): boolean;
/**
* Timeline
* This section controls the timeline.
*/
changeCurrentFrame: (frame: number) => void;
/**
* Calculate the value of the selected frame in curve
*/
calculateCurrentPointInCurve: (frame: number) => number | undefined;
/**
* Center the position the canvas depending on Keyframe value and frame
*/
setCanvasPosition: (keyframe: IAnimationKey) => void;
setCurrentFrame: (frame: number) => void;
/**
* Change the timeline animation frame limit
*/
changeAnimationLimit: (limit: number) => void;
/**
* Update the frame in the selected Keyframe
*/
updateFrameInKeyFrame: (frame: number, index: number) => void;
playPause: (direction: number) => void;
/**
* Set the frame to selected position on canvas
*/
moveFrameTo(e: React.MouseEvent): void;
registerObs(): void;
isCurrentFrame(frame: number): boolean;
setPanningY: (panningY: number) => void;
setPanningX: (panningX: number) => void;
canvasPositionEnded: () => void;
setNotificationMessage: (message: string) => void;
frameSelectedKeyframes: () => void;
/**
* Handle the frames quantity and scale on Window resize width
*/
onWindowResizeWidth: () => void;
onWindowEndResize: (framesResized: number) => void;
onTimelineResize: () => void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/popupComponent" {
import * as React from "react";
interface IPopupComponentProps {
id: string;
title: string;
size: {
width: number;
height: number;
};
onOpen: (window: Window) => void;
onClose: (window: Window) => void;
}
export class PopupComponent extends React.Component {
private _container;
private _window;
private _curveEditorHost;
constructor(props: IPopupComponentProps);
componentDidMount(): void;
openPopup(): void;
componentWillUnmount(): void;
getWindow(): Window | null;
render(): React.ReactPortal | null;
}
}
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/components/actionTabs/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 _isCurveEditorOpen;
private _animationControl;
constructor(props: IAnimationGridComponentProps);
playOrPause(): void;
componentDidMount(): void;
componentWillUnmount(): void;
onCurrentFrameChange(value: number): void;
onChangeFromOrTo(): void;
onOpenAnimationCurveEditor(): void;
onCloseAnimationCurveEditor(window: Window | null): void;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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";
export interface ITextureLinkLineComponentProps {
label: string;
texture: Nullable;
material?: Material;
onSelectionChangedObservable?: Observable;
onDebugSelectionChangeObservable?: Observable;
propertyName?: string;
onTextureCreated?: (texture: BaseTexture) => void;
customDebugAction?: (state: boolean) => void;
onTextureRemoved?: () => void;
}
export class TextureLinkLineComponent extends React.Component {
private _onDebugSelectionChangeObserver;
constructor(props: ITextureLinkLineComponentProps);
componentDidMount(): void;
componentWillUnmount(): void;
debugTexture(): void;
onLink(): void;
updateTexture(file: File): void;
removeTexture(): void;
render(): JSX.Element | null;
}
}
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/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IStandardMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: StandardMaterial;
lockObject: LockObject;
onSelectionChangedObservable?: Observable;
onPropertyChangedObservable?: Observable;
}
export class StandardMaterialPropertyGridComponent extends React.Component {
private _onDebugSelectionChangeObservable;
constructor(props: IStandardMaterialPropertyGridComponentProps);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/lod" {
/** @hidden */
export var lodPixelShader: {
name: string;
shader: string;
};
}
declare module "babylonjs-inspector/lodCube" {
/** @hidden */
export var lodCubePixelShader: {
name: string;
shader: string;
};
}
declare module "babylonjs-inspector/textureHelper" {
import { GlobalState } from "babylonjs-inspector/components/globalState";
import { BaseTexture } from 'babylonjs/Materials/Textures/baseTexture';
import "babylonjs-inspector/lod";
import "babylonjs-inspector/lodCube";
export interface TextureChannelsToDisplay {
R: boolean;
G: boolean;
B: boolean;
A: boolean;
}
export class TextureHelper {
private static _ProcessAsync;
static GetTextureDataAsync(texture: BaseTexture, width: number, height: number, face: number, channels: TextureChannelsToDisplay, globalState?: GlobalState, lod?: number): Promise;
}
}
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;
render(): JSX.Element;
}
}
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";
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 {
constructor(props: IToolBarProps);
computeRGBAColor(): string;
shouldComponentUpdate(nextProps: IToolBarProps): boolean;
render(): JSX.Element;
}
}
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 {
render(): JSX.Element;
}
}
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/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;
/** The internal texture representation of the original texture */
private _originalInternalTexture;
/** Keeps track of whether we have modified the texture */
private _didEdit;
private _plane;
private _planeMaterial;
/** Tracks which keys are currently pressed */
private _keyMap;
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_MOUSE_BUTTON;
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;
dispose(): void;
}
}
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 _resetButton;
private _uploadButton;
private _saveButton;
private _babylonLogo;
private _resizeButton;
private _mipUp;
private _mipDown;
private _faces;
constructor(props: IPropertiesBarProps);
private pixelData;
private getNewDimension;
componentWillUpdate(nextProps: IPropertiesBarProps): void;
render(): JSX.Element;
}
}
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 {
render(): JSX.Element;
}
}
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 {
render(): JSX.Element;
}
}
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/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/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/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/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/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 {
render(): JSX.Element;
}
}
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";
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 access to the BABYLON namespace */
BABYLON: any;
/** 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;
}
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 seperate 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;
}
global {
var _TOOL_DATA_: IToolData;
}
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(): JSX.Element;
}
}
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/components/actionTabs/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(window: Window): void;
onCloseTextureEditor(callback?: {
(): void;
}): void;
forceRefresh(): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/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/components/propertyChangedEvent";
interface IVector2LineComponentProps {
label: string;
target: any;
propertyName: string;
step?: number;
onChange?: (newvalue: Vector2) => void;
onPropertyChangedObservable?: Observable;
}
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;
render(): JSX.Element;
}
}
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/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IPBRMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: PBRMaterial;
lockObject: LockObject;
onSelectionChangedObservable?: Observable;
onPropertyChangedObservable?: Observable;
}
export class PBRMaterialPropertyGridComponent extends React.Component {
private _onDebugSelectionChangeObservable;
constructor(props: IPBRMaterialPropertyGridComponentProps);
switchAmbientMode(state: boolean): void;
switchMetallicMode(state: boolean): void;
switchRoughnessMode(state: boolean): void;
renderTextures(onDebugSelectionChangeObservable: Observable): JSX.Element;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/radioLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
interface IRadioButtonLineComponentProps {
onSelectionChangedObservable: Observable;
label: string;
isSelected: () => boolean;
onSelect: () => void;
}
export class RadioButtonLineComponent extends React.Component {
private _onSelectionChangedObserver;
constructor(props: IRadioButtonLineComponentProps);
componentDidMount(): void;
componentWillUnmount(): void;
onChange(): void;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
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;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/hexLineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/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;
}
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(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/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;
renderContent(): JSX.Element;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
renderLevel(jsonObject: any): JSX.Element[];
render(): JSX.Element | null;
}
}
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/components/actionTabs/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;
render(): JSX.Element | null;
}
}
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/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
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;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/commonControlPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Control } from "babylonjs-gui/2D/controls/control";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ICommonControlPropertyGridComponentProps {
globalState: GlobalState;
control: Control;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class CommonControlPropertyGridComponent extends React.Component {
constructor(props: ICommonControlPropertyGridComponentProps);
renderGridInformation(): JSX.Element | null;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/controlPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { Control } from "babylonjs-gui/2D/controls/control";
import { GlobalState } from "babylonjs-inspector/components/globalState";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
interface IControlPropertyGridComponentProps {
globalState: GlobalState;
control: Control;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class ControlPropertyGridComponent extends React.Component {
constructor(props: IControlPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/textBlockPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { TextBlock } from "babylonjs-gui/2D/controls/textBlock";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ITextBlockPropertyGridComponentProps {
globalState: GlobalState;
textBlock: TextBlock;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class TextBlockPropertyGridComponent extends React.Component {
constructor(props: ITextBlockPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/inputTextPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { InputText } from "babylonjs-gui/2D/controls/inputText";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IInputTextPropertyGridComponentProps {
globalState: GlobalState;
inputText: InputText;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class InputTextPropertyGridComponent extends React.Component {
constructor(props: IInputTextPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { ColorPicker } from "babylonjs-gui/2D/controls/colorpicker";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IColorPickerPropertyGridComponentProps {
globalState: GlobalState;
colorPicker: ColorPicker;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class ColorPickerPropertyGridComponent extends React.Component {
constructor(props: IColorPickerPropertyGridComponentProps);
render(): JSX.Element;
}
}
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/components/actionTabs/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;
constructor(props: IAnimationGroupGridComponentProps);
disconnect(animationGroup: AnimationGroup): void;
connect(animationGroup: AnimationGroup): void;
updateCurrentFrame(animationGroup: AnimationGroup): void;
shouldComponentUpdate(nextProps: IAnimationGroupGridComponentProps): boolean;
componentWillUnmount(): void;
playOrPause(): void;
onCurrentFrameChange(value: number): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/imagePropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Image } from "babylonjs-gui/2D/controls/image";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IImagePropertyGridComponentProps {
globalState: GlobalState;
image: Image;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class ImagePropertyGridComponent extends React.Component {
constructor(props: IImagePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Slider } from "babylonjs-gui/2D/controls/sliders/slider";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ISliderPropertyGridComponentProps {
globalState: GlobalState;
slider: Slider;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class SliderPropertyGridComponent extends React.Component {
constructor(props: ISliderPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { ImageBasedSlider } from "babylonjs-gui/2D/controls/sliders/imageBasedSlider";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IImageBasedSliderPropertyGridComponentProps {
globalState: GlobalState;
imageBasedSlider: ImageBasedSlider;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class ImageBasedSliderPropertyGridComponent extends React.Component {
constructor(props: IImageBasedSliderPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Rectangle } from "babylonjs-gui/2D/controls/rectangle";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IRectanglePropertyGridComponentProps {
globalState: GlobalState;
rectangle: Rectangle;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class RectanglePropertyGridComponent extends React.Component {
constructor(props: IRectanglePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Ellipse } from "babylonjs-gui/2D/controls/ellipse";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IEllipsePropertyGridComponentProps {
globalState: GlobalState;
ellipse: Ellipse;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class EllipsePropertyGridComponent extends React.Component {
constructor(props: IEllipsePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Checkbox } from "babylonjs-gui/2D/controls/checkbox";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ICheckboxPropertyGridComponentProps {
globalState: GlobalState;
checkbox: Checkbox;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class CheckboxPropertyGridComponent extends React.Component {
constructor(props: ICheckboxPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { RadioButton } from "babylonjs-gui/2D/controls/radioButton";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IRadioButtonPropertyGridComponentProps {
globalState: GlobalState;
radioButton: RadioButton;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class RadioButtonPropertyGridComponent extends React.Component {
constructor(props: IRadioButtonPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/linePropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Line } from "babylonjs-gui/2D/controls/line";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ILinePropertyGridComponentProps {
globalState: GlobalState;
line: Line;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class LinePropertyGridComponent extends React.Component {
constructor(props: ILinePropertyGridComponentProps);
onDashChange(value: string): void;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { ScrollViewer } from "babylonjs-gui/2D/controls/scrollViewers/scrollViewer";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IScrollViewerPropertyGridComponentProps {
globalState: GlobalState;
scrollViewer: ScrollViewer;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class ScrollViewerPropertyGridComponent extends React.Component {
constructor(props: IScrollViewerPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/gridPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { Grid } from "babylonjs-gui/2D/controls/grid";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IGridPropertyGridComponentProps {
globalState: GlobalState;
grid: Grid;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class GridPropertyGridComponent extends React.Component {
constructor(props: IGridPropertyGridComponentProps);
renderRows(): JSX.Element[];
renderColumns(): JSX.Element[];
render(): JSX.Element;
}
}
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/components/actionTabs/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);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
import { LockObject } from "babylonjs-inspector/components/actionTabs/tabs/propertyGrids/lockObject";
import { StackPanel } from "babylonjs-gui/2D/controls/stackPanel";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface IStackPanelPropertyGridComponentProps {
globalState: GlobalState;
stackPanel: StackPanel;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class StackPanelPropertyGridComponent extends React.Component {
constructor(props: IStackPanelPropertyGridComponentProps);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/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;
onOverrideMeshLink(): void;
render(): JSX.Element;
}
}
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/components/actionTabs/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;
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
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/components/actionTabs/tabs/propertyGrids/lockObject";
import { GlobalState } from "babylonjs-inspector/components/globalState";
interface ISpotLightPropertyGridComponentProps {
globalState: GlobalState;
light: SpotLight;
lockObject: LockObject;
onPropertyChangedObservable?: Observable;
}
export class SpotLightPropertyGridComponent extends React.Component {
constructor(props: ISpotLightPropertyGridComponentProps);
render(): JSX.Element;
}
}
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/components/actionTabs/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);
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/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/components/propertyChangedEvent";
interface IVector4LineComponentProps {
label: string;
target: any;
propertyName: string;
step?: number;
onChange?: (newvalue: Vector4) => void;
useEuler?: boolean;
onPropertyChangedObservable?: Observable;
}
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;
render(): JSX.Element;
}
}
declare module "babylonjs-inspector/components/actionTabs/lines/color4LineComponent" {
import * as React from "react";
import { Observable } from "babylonjs/Misc/observable";
import { Color4 } from "babylonjs/Maths/math.color";
import { PropertyChangedEvent } from "babylonjs-inspector/components/propertyChangedEvent";
export interface IColor4LineComponentProps {
label: string;
target: any;
propertyName: string;
onPropertyChangedObservable?: Observable;
onChange?: () => void;
isLinear?: boolean;
}
export class Color4LineComponent extends React.Component {
private _localChange;
constructor(props: IColor4LineComponentProps);
shouldComponentUpdate(nextProps: IColor4LineComponentProps, nextState: {
color: Color4;
}): boolean;
setPropertyValue(newColor: Color4): void;
onChange(newValue: string): void;
switchExpandState(): void;
raiseOnPropertyChanged(previousValue: Color4): void;
updateStateR(value: number): void;
updateStateG(value: number): void;
updateStateB(value: number): void;
updateStateA(value: number): void;
copyToClipboard(): void;
render(): JSX.Element;
}
}
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';
interface IGradientStepComponentProps {
globalState: GlobalState;
step: GradientBlockColorStep;
lineIndex: number;
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(): JSX.Element;
}
}
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/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