///
declare module INSPECTOR {
export class PropertyChangedEvent {
object: any;
property: string;
value: any;
initialValue: any;
allowNullValue?: boolean;
}
}
declare module INSPECTOR {
export class ReplayRecorder {
private _sceneRecorder;
private _isRecording;
get isRecording(): boolean;
cancel(): void;
trackScene(scene: BABYLON.Scene): void;
applyDelta(json: any, scene: BABYLON.Scene): void;
export(): void;
}
}
declare module INSPECTOR {
export class GlobalState {
onSelectionChangedObservable: BABYLON.Observable;
onPropertyChangedObservable: BABYLON.Observable;
onInspectorClosedObservable: BABYLON.Observable;
onTabChangedObservable: BABYLON.Observable;
onSelectionRenamedObservable: BABYLON.Observable;
onPluginActivatedObserver: BABYLON.Nullable>;
onNewSceneObservable: BABYLON.Observable;
sceneImportDefaults: {
[key: string]: any;
};
validationResults: BABYLON.Nullable;
onValidationResultsUpdatedObservable: BABYLON.Observable>;
onExtensionLoadedObservable: BABYLON.Observable;
glTFLoaderExtensionDefaults: {
[name: string]: {
[key: string]: any;
};
};
glTFLoaderDefaults: {
[key: string]: any;
};
glTFLoaderExtenstions: {
[key: string]: BABYLON.IGLTFLoaderExtension;
};
blockMutationUpdates: boolean;
selectedLineContainerTitles: Array;
selectedLineContainerTitlesNoFocus: Array;
recorder: ReplayRecorder;
private _onlyUseEulers;
get onlyUseEulers(): boolean;
set onlyUseEulers(value: boolean);
private _ignoreBackfacesForPicking;
get ignoreBackfacesForPicking(): boolean;
set ignoreBackfacesForPicking(value: boolean);
init(propertyChangedObservable: BABYLON.Observable): void;
prepareGLTFPlugin(loader: BABYLON.GLTFFileLoader): void;
lightGizmos: Array;
enableLightGizmo(light: BABYLON.Light, enable?: boolean): void;
}
}
declare module INSPECTOR {
export interface IPaneComponentProps {
title: string;
scene: BABYLON.Scene;
selectedEntity?: any;
onSelectionChangedObservable?: BABYLON.Observable;
onPropertyChangedObservable?: BABYLON.Observable;
globalState: GlobalState;
}
export class PaneComponent extends React.Component {
constructor(props: IPaneComponentProps);
render(): JSX.Element | null;
}
}
declare module INSPECTOR {
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 INSPECTOR {
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 INSPECTOR {
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 INSPECTOR {
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 INSPECTOR {
export interface IBooleanLineComponentProps {
label: string;
value: boolean;
}
export class BooleanLineComponent extends React.Component {
constructor(props: IBooleanLineComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
export class StatisticsTabComponent extends PaneComponent {
private _sceneInstrumentation;
private _engineInstrumentation;
private _timerIntervalId;
constructor(props: IPaneComponentProps);
componentWillUnmount(): void;
render(): JSX.Element | null;
}
}
declare module INSPECTOR {
export interface ICheckBoxLineComponentProps {
label: string;
target?: any;
propertyName?: string;
isSelected?: () => boolean;
onSelect?: (value: boolean) => void;
onValueChanged?: () => void;
onPropertyChangedObservable?: BABYLON.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 INSPECTOR {
interface IRenderGridPropertyGridComponentProps {
globalState: GlobalState;
scene: BABYLON.Scene;
}
export class RenderGridPropertyGridComponent extends React.Component {
private _gridMesh;
constructor(props: IRenderGridPropertyGridComponentProps);
componentDidMount(): void;
addOrRemoveGrid(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export class DebugTabComponent extends PaneComponent {
private _physicsViewersEnabled;
constructor(props: IPaneComponentProps);
switchPhysicsViewers(): void;
render(): JSX.Element | null;
}
}
declare module INSPECTOR {
interface ISliderLineComponentProps {
label: string;
target?: any;
propertyName?: string;
minimum: number;
maximum: number;
step: number;
directValue?: number;
useEuler?: boolean;
onChange?: (value: number) => void;
onInput?: (value: number) => void;
onPropertyChangedObservable?: BABYLON.Observable;
decimalCount?: number;
}
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 INSPECTOR {
export const Null_Value: number;
class ListLineOption {
label: string;
value: number;
}
interface IOptionsLineComponentProps {
label: string;
target: any;
propertyName: string;
options: ListLineOption[];
noDirectUpdate?: boolean;
onSelect?: (value: number) => void;
extractValue?: () => number;
onPropertyChangedObservable?: BABYLON.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 INSPECTOR {
/**
* Class used to provide lock mechanism
*/
export class LockObject {
/**
* Gets or set if the lock is engaged
*/
lock: boolean;
}
}
declare module INSPECTOR {
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;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface IColorPickerComponentProps {
value: BABYLON.Color4 | BABYLON.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 INSPECTOR {
export interface IColor3LineComponentProps {
label: string;
target: any;
propertyName: string;
onPropertyChangedObservable?: BABYLON.Observable;
isLinear?: boolean;
}
export class Color3LineComponent extends React.Component {
private _localChange;
constructor(props: IColor3LineComponentProps);
shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
color: BABYLON.Color3;
}): boolean;
setPropertyValue(newColor: BABYLON.Color3): void;
onChange(newValue: string): void;
switchExpandState(): void;
raiseOnPropertyChanged(previousValue: BABYLON.Color3): void;
updateStateR(value: number): void;
updateStateG(value: number): void;
updateStateB(value: number): void;
copyToClipboard(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IVector3LineComponentProps {
label: string;
target: any;
propertyName: string;
step?: number;
onChange?: (newvalue: BABYLON.Vector3) => void;
useEuler?: boolean;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class Vector3LineComponent extends React.Component {
static defaultProps: {
step: number;
};
private _localChange;
constructor(props: IVector3LineComponentProps);
getCurrentValue(): any;
shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
isExpanded: boolean;
value: BABYLON.Vector3;
}): boolean;
switchExpandState(): void;
raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
updateVector3(): void;
updateStateX(value: number): void;
updateStateY(value: number): void;
updateStateZ(value: number): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IQuaternionLineComponentProps {
label: string;
target: any;
useEuler?: boolean;
propertyName: string;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class QuaternionLineComponent extends React.Component {
private _localChange;
constructor(props: IQuaternionLineComponentProps);
shouldComponentUpdate(nextProps: IQuaternionLineComponentProps, nextState: {
isExpanded: boolean;
value: BABYLON.Quaternion;
eulerValue: BABYLON.Vector3;
}): boolean;
switchExpandState(): void;
raiseOnPropertyChanged(currentValue: BABYLON.Quaternion, previousValue: BABYLON.Quaternion): void;
updateQuaternion(): void;
updateStateX(value: number): void;
updateStateY(value: number): void;
updateStateZ(value: number): void;
updateStateW(value: number): void;
updateQuaternionFromEuler(): void;
updateStateEulerX(value: number): void;
updateStateEulerY(value: number): void;
updateStateEulerZ(value: number): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ITextInputLineComponentProps {
label: string;
lockObject: LockObject;
target?: any;
propertyName?: string;
value?: string;
onChange?: (value: string) => void;
onPropertyChangedObservable?: BABYLON.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 INSPECTOR {
interface ICustomPropertyGridComponentProps {
globalState: GlobalState;
target: any;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CustomPropertyGridComponent extends React.Component {
constructor(props: ICustomPropertyGridComponentProps);
renderInspectable(inspectable: BABYLON.IInspectable): JSX.Element | null;
render(): JSX.Element | null;
}
}
declare module INSPECTOR {
export interface IButtonLineComponentProps {
label: string;
onClick: () => void;
}
export class ButtonLineComponent extends React.Component {
constructor(props: IButtonLineComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IFloatLineComponentProps {
label: string;
target: any;
propertyName: string;
lockObject?: LockObject;
onChange?: (newValue: number) => void;
isInteger?: boolean;
onPropertyChangedObservable?: BABYLON.Observable;
additionalClass?: string;
step?: string;
digits?: number;
useEuler?: boolean;
min?: 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 INSPECTOR {
interface IAnchorSvgPointProps {
control: BABYLON.Vector2;
anchor: BABYLON.Vector2;
active: boolean;
type: string;
index: string;
selected: boolean;
selectControlPoint: (id: string) => void;
}
export class AnchorSvgPoint extends React.Component {
constructor(props: IAnchorSvgPointProps);
select(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface IKeyframeSvgPoint {
keyframePoint: BABYLON.Vector2;
rightControlPoint: BABYLON.Vector2 | null;
leftControlPoint: BABYLON.Vector2 | null;
id: string;
selected: boolean;
isLeftActive: boolean;
isRightActive: boolean;
curveId?: ICurveMetaData;
}
export interface ICurveMetaData {
id: number;
animationName: string;
property: string;
}
interface IKeyframeSvgPointProps {
keyframePoint: BABYLON.Vector2;
leftControlPoint: BABYLON.Vector2 | null;
rightControlPoint: BABYLON.Vector2 | null;
id: string;
selected: boolean;
selectKeyframe: (id: string, multiselect: boolean) => void;
selectedControlPoint: (type: string, id: string) => void;
isLeftActive: boolean;
isRightActive: boolean;
}
export class KeyframeSvgPoint extends React.Component {
constructor(props: IKeyframeSvgPointProps);
select(e: React.MouseEvent): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ISvgDraggableAreaProps {
keyframeSvgPoints: IKeyframeSvgPoint[];
updatePosition: (updatedKeyframe: IKeyframeSvgPoint, id: string) => void;
scale: number;
viewBoxScale: number;
selectKeyframe: (id: string, multiselect: boolean) => void;
selectedControlPoint: (type: string, id: string) => void;
deselectKeyframes: () => void;
removeSelectedKeyframes: (points: IKeyframeSvgPoint[]) => void;
panningY: (panningY: number) => void;
panningX: (panningX: number) => void;
setCurrentFrame: (direction: number) => void;
positionCanvas?: number;
repositionCanvas?: boolean;
canvasPositionEnded: () => void;
resetActionableKeyframe: () => void;
}
export class SvgDraggableArea extends React.Component {
private _active;
private _isCurrentPointControl;
private _currentPointId;
private _draggableArea;
private _panStart;
private _panStop;
private _playheadDrag;
private _playheadSelected;
constructor(props: ISvgDraggableAreaProps);
componentDidMount(): void;
componentWillReceiveProps(newProps: ISvgDraggableAreaProps): void;
dragStart(e: React.TouchEvent): void;
dragStart(e: React.MouseEvent): void;
drag(e: React.TouchEvent): void;
drag(e: React.MouseEvent): void;
dragEnd(e: React.TouchEvent): void;
dragEnd(e: React.MouseEvent): void;
getMousePosition(e: React.TouchEvent): BABYLON.Vector2 | undefined;
getMousePosition(e: React.MouseEvent): BABYLON.Vector2 | undefined;
panDirection(): void;
panTo(direction: string, value: number): void;
keyDown(e: KeyboardEvent): void;
keyUp(e: KeyboardEvent): void;
focus(e: React.MouseEvent): void;
isNotControlPointActive(): boolean;
render(): JSX.Element;
}
}
declare module INSPECTOR {
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 INSPECTOR {
interface IControlsProps {
keyframes: BABYLON.IAnimationKey[] | null;
selected: BABYLON.IAnimationKey | null;
currentFrame: number;
onCurrentFrameChange: (frame: number) => void;
playPause: (direction: number) => void;
isPlaying: boolean;
scrollable: React.RefObject;
}
export class Controls extends React.Component {
constructor(props: IControlsProps);
playBackwards(): void;
play(): void;
pause(): void;
nextFrame(): void;
previousFrame(): void;
nextKeyframe(): void;
previousKeyframe(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ITimelineProps {
keyframes: BABYLON.IAnimationKey[] | null;
selected: BABYLON.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: (frame: number) => void;
}
export class Timeline extends React.Component {
readonly _frames: object[];
private _scrollable;
private _scrollbarHandle;
private _scrollContainer;
private _direction;
private _scrolling;
private _shiftX;
private _active;
constructor(props: ITimelineProps);
componentDidMount(): void;
calculateScrollWidth(start: number, end: number): number | undefined;
playBackwards(event: React.MouseEvent): void;
play(event: React.MouseEvent): void;
pause(event: React.MouseEvent): void;
handleInputChange(event: React.ChangeEvent): void;
setCurrentFrame(event: React.MouseEvent): void;
handleLimitChange(event: React.ChangeEvent): void;
nextFrame(event: React.MouseEvent): void;
previousFrame(event: React.MouseEvent): void;
nextKeyframe(event: React.MouseEvent): void;
previousKeyframe(event: React.MouseEvent): void;
dragStart(e: React.TouchEvent): void;
dragStart(e: React.MouseEvent): void;
drag(e: React.TouchEvent): void;
drag(e: React.MouseEvent): void;
isFrameBeingUsed(frame: number, direction: number): number | false;
dragEnd(e: React.TouchEvent): void;
dragEnd(e: React.MouseEvent): void;
scrollDragStart(e: React.TouchEvent): void;
scrollDragStart(e: React.MouseEvent): void;
scrollDrag(e: React.TouchEvent): void;
scrollDrag(e: React.MouseEvent): void;
scrollDragEnd(e: React.TouchEvent): void;
scrollDragEnd(e: React.MouseEvent): void;
moveScrollbar(pageX: number): void;
resizeScrollbarRight(clientX: number): void;
resizeScrollbarLeft(clientX: number): void;
range(start: number, end: number): number[];
getKeyframe(frame: number): false | BABYLON.IAnimationKey | undefined;
getCurrentFrame(frame: number): boolean;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IPlayheadProps {
message: string;
open: boolean;
close: () => void;
}
export class Notification extends React.Component {
constructor(props: IPlayheadProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IGraphActionsBarProps {
addKeyframe: () => void;
removeKeyframe: () => void;
handleValueChange: (e: React.ChangeEvent) => void;
handleFrameChange: (e: React.ChangeEvent) => void;
flatTangent: () => void;
brokeTangents: () => void;
setLerpMode: () => void;
brokenMode: boolean;
lerpMode: boolean;
actionableKeyframe: IActionableKeyFrame;
title: string;
close: (event: any) => void;
enabled: boolean;
setKeyframeValue: () => void;
}
export class GraphActionsBar extends React.Component {
private _frameInput;
private _valueInput;
constructor(props: IGraphActionsBarProps);
componentDidMount(): void;
componentWillUnmount(): void;
isEnterKeyUp(event: KeyboardEvent): void;
onBlur(event: React.FocusEvent): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IAddAnimationProps {
isOpen: boolean;
close: () => void;
entity: BABYLON.IAnimatable;
onPropertyChangedObservable?: BABYLON.Observable;
setNotificationMessage: (message: string) => void;
finishedUpdate: () => void;
addedNewAnimation: () => void;
fps: number;
selectedToUpdate?: BABYLON.Animation | undefined;
}
export class AddAnimation extends React.Component {
constructor(props: IAddAnimationProps);
setInitialState(editingAnimation?: BABYLON.Animation): {
animationName: string;
animationTargetPath: string;
animationType: number;
loopMode: number;
animationTargetProperty: string;
isUpdating: boolean;
};
componentWillReceiveProps(nextProps: IAddAnimationProps): void;
updateAnimation(): void;
getTypeAsString(type: number): "Float" | "Quaternion" | "Vector3" | "Vector2" | "Size" | "Color3" | "Color4";
addAnimation(): void;
raiseOnPropertyChanged(newValue: BABYLON.Animation[], previousValue: BABYLON.Animation[]): void;
raiseOnPropertyUpdated(newValue: string | number | undefined, previousValue: string | number, property: string): void;
handleNameChange(event: React.ChangeEvent): void;
handlePathChange(event: React.ChangeEvent): void;
handleTypeChange(event: React.ChangeEvent): void;
handlePropertyChange(event: React.ChangeEvent): void;
handleLoopModeChange(event: React.ChangeEvent): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IAnimationListTreeProps {
isTargetedAnimation: boolean;
entity: BABYLON.IAnimatable | BABYLON.TargetedAnimation;
selected: BABYLON.Animation | null;
onPropertyChangedObservable?: BABYLON.Observable;
selectAnimation: (selected: BABYLON.Animation, coordinate?: SelectedCoordinate) => void;
empty: () => void;
editAnimation: (selected: BABYLON.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;
}
export class AnimationListTree extends React.Component {
constructor(props: IAnimationListTreeProps);
deleteAnimation(): void;
generateList(): Item[] | null;
toggleProperty(index: number): void;
setSelectedCoordinate(animation: BABYLON.Animation, coordinate: SelectedCoordinate, index: number): void;
coordinateItem(i: number, animation: BABYLON.Animation, coordinate: string, color: string, selectedCoordinate: SelectedCoordinate): JSX.Element;
typeAnimationItem(animation: BABYLON.Animation, i: number, childrenElements: ItemCoordinate[]): JSX.Element;
setListItem(animation: BABYLON.Animation, i: number): JSX.Element | null;
render(): JSX.Element;
}
}
declare module INSPECTOR {
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 INSPECTOR {
interface ILoadSnippetProps {
animations: BABYLON.Animation[];
onPropertyChangedObservable?: BABYLON.Observable;
lockObject: LockObject;
globalState: GlobalState;
snippetServer: string;
setSnippetId: (id: string) => void;
entity: BABYLON.IAnimatable | BABYLON.TargetedAnimation;
setNotificationMessage: (message: string) => void;
animationsLoaded: (numberOfAnimations: number) => void;
}
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 INSPECTOR {
interface ISaveSnippetProps {
animations: BABYLON.Nullable;
onPropertyChangedObservable?: BABYLON.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;
}
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 INSPECTOR {
interface IEditorControlsProps {
isTargetedAnimation: boolean;
entity: BABYLON.IAnimatable | BABYLON.TargetedAnimation;
selected: BABYLON.Animation | null;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
setNotificationMessage: (message: string) => void;
selectAnimation: (selected: BABYLON.Animation, axis?: SelectedCoordinate) => void;
setFps: (fps: number) => void;
setIsLooping: () => void;
globalState: GlobalState;
snippetServer: string;
deselectAnimation: () => void;
fps: number;
}
export class EditorControls extends React.Component {
constructor(props: IEditorControlsProps);
componentWillReceiveProps(newProps: IEditorControlsProps): void;
animationAdded(): void;
finishedUpdate(): void;
recountAnimations(): number;
changeLoopBehavior(): void;
handleTabs(tab: number): void;
handleChangeFps(fps: number): void;
emptiedList(): void;
animationsLoaded(numberOfAnimations: number): void;
editAnimation(selected: BABYLON.Animation): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ISwitchButtonProps {
current: CurveScale;
action?: (event: CurveScale) => void;
}
export class ScaleLabel extends React.Component {
constructor(props: ISwitchButtonProps);
renderLabel(scale: CurveScale): "" | "DEG" | "FLT" | "INT" | "RAD";
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IAnimationCurveEditorComponentProps {
close: (event: any) => void;
playOrPause?: () => void;
scene: BABYLON.Scene;
entity: BABYLON.IAnimatable | BABYLON.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;
}
export class AnimationCurveEditorComponent extends React.Component {
private _snippetUrl;
private _heightScale;
private _scaleFactor;
private _currentScale;
readonly _entityName: string;
readonly _canvasLength: number;
private _svgKeyframes;
private _isPlaying;
private _graphCanvas;
private _svgCanvas;
private _isTargetedAnimation;
private _pixelFrameUnit;
private _onBeforeRenderObserver;
private _mainAnimatable;
constructor(props: IAnimationCurveEditorComponentProps);
componentDidMount(): 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;
setFrameAxis(currentLength: number): {
value: number;
label: number;
}[];
setValueLines(type: CurveScale): ({
value: number;
label: string;
} | {
value: number;
label: number;
})[];
getValueLabel(i: number): number;
resetPlayheadOffset(): void;
encodeCurveId(animationName: string, coordinate: number): string;
decodeCurveId(id: string): {
order: number;
coordinate: number;
};
getKeyframeValueFromAnimation(id: string): {
frame: number;
value: number;
} | undefined;
/**
* Keyframe Manipulation
* This section handles events from SvgDraggableArea.
*/
selectKeyframe(id: string, multiselect: boolean): void;
resetActionableKeyframe(): void;
selectedControlPoint(type: string, id: string): void;
deselectKeyframes(): void;
updateValuePerCoordinate(dataType: number, value: number | BABYLON.Vector2 | BABYLON.Vector3 | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Size | BABYLON.Quaternion, newValue: number, coordinate?: number): number | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
renderPoints(updatedSvgKeyFrame: IKeyframeSvgPoint, id: string): void;
updateLeftControlPoint(updatedSvgKeyFrame: IKeyframeSvgPoint, key: BABYLON.IAnimationKey, dataType: number, coordinate: number): void;
updateRightControlPoint(updatedSvgKeyFrame: IKeyframeSvgPoint, key: BABYLON.IAnimationKey, dataType: number, coordinate: number): void;
handleFrameChange(event: React.ChangeEvent): void;
handleValueChange(event: React.ChangeEvent): void;
setKeyframeValue(): void;
setFlatTangent(): void;
setTangentMode(): void;
setBrokenMode(): void;
setLerpMode(): void;
addKeyframeClick(): void;
removeKeyframeClick(): void;
removeKeyframes(points: IKeyframeSvgPoint[]): void;
addKeyFrame(event: React.MouseEvent): void;
/**
* Curve Rendering Functions
* This section handles how to render curves.
*/
setKeyframePointLinear(point: BABYLON.Vector2, index: number): void;
flatTangents(keyframes: BABYLON.IAnimationKey[], dataType: number): BABYLON.IAnimationKey[];
returnZero(dataType: number): 0 | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
getValueAsArray(valueType: number, value: number | BABYLON.Vector2 | BABYLON.Vector3 | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Size | BABYLON.Quaternion): number[];
setValueAsType(valueType: number, arrayValue: number[]): number | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
getPathData(animation: BABYLON.Animation | null): ICurveData[] | undefined;
getAnimationData(animation: BABYLON.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;
};
curvePathWithTangents(keyframes: BABYLON.IAnimationKey[], data: string, middle: number, type: number, coordinate: number, animationName: string): string;
curvePath(keyframes: BABYLON.IAnimationKey[], data: string, middle: number, easingFunction: BABYLON.EasingFunction): string;
setKeyframePoint(controlPoints: BABYLON.Vector2[], index: number, keyframesCount: number): void;
interpolateControlPoints(p0: BABYLON.Vector2, p1: BABYLON.Vector2, u: number, p2: BABYLON.Vector2, v: number, p3: BABYLON.Vector2): BABYLON.Vector2[] | undefined;
deselectAnimation(): void;
/**
* Core functions
* This section handles main Curve Editor Functions.
*/
selectAnimation(animation: BABYLON.Animation, coordinate?: SelectedCoordinate): void;
isAnimationPlaying(): boolean;
stopAnimation(): void;
setIsLooping(): void;
setFramesPerSecond(fps: number): void;
analizeAnimationForLerp(animation: BABYLON.Animation | null): boolean;
/**
* Timeline
* This section controls the timeline.
*/
changeCurrentFrame(frame: number): void;
setCanvasPosition(frame: number): void;
setCurrentFrame(direction: number): void;
changeAnimationLimit(limit: number): void;
updateFrameInKeyFrame(frame: number, index: number): void;
playPause(direction: number): void;
moveFrameTo(e: React.MouseEvent): void;
registerObs(): void;
componentWillUnmount(): void;
isCurrentFrame(frame: number): boolean;
render(): JSX.Element;
}
}
declare module INSPECTOR {
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;
render(): React.ReactPortal | null;
}
}
declare module INSPECTOR {
interface IAnimationGridComponentProps {
globalState: GlobalState;
animatable: BABYLON.IAnimatable;
scene: BABYLON.Scene;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.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 INSPECTOR {
interface ICommonMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: BABYLON.Material;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonMaterialPropertyGridComponent extends React.Component {
constructor(props: ICommonMaterialPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: BABYLON.Material;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class MaterialPropertyGridComponent extends React.Component {
constructor(props: IMaterialPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface ITextureLinkLineComponentProps {
label: string;
texture: BABYLON.Nullable;
material?: BABYLON.Material;
onSelectionChangedObservable?: BABYLON.Observable;
onDebugSelectionChangeObservable?: BABYLON.Observable;
propertyName?: string;
onTextureCreated?: (texture: BABYLON.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 INSPECTOR {
interface IStandardMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: BABYLON.StandardMaterial;
lockObject: LockObject;
onSelectionChangedObservable?: BABYLON.Observable;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class StandardMaterialPropertyGridComponent extends React.Component {
private _onDebugSelectionChangeObservable;
constructor(props: IStandardMaterialPropertyGridComponentProps);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface TextureChannelsToDisplay {
R: boolean;
G: boolean;
B: boolean;
A: boolean;
}
export class TextureHelper {
private static _ProcessAsync;
static GetTextureDataAsync(texture: BABYLON.BaseTexture, width: number, height: number, face: number, channels: TextureChannelsToDisplay, globalState?: GlobalState): Promise;
}
}
declare module INSPECTOR {
interface ITextureLineComponentProps {
texture: BABYLON.BaseTexture;
width: number;
height: number;
globalState?: GlobalState;
hideChannelSelect?: boolean;
}
export class TextureLineComponent extends React.Component {
private canvasRef;
private static TextureChannelStates;
constructor(props: ITextureLineComponentProps);
shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
channels: TextureChannelsToDisplay;
face: number;
}): boolean;
componentDidMount(): void;
componentDidUpdate(): void;
updatePreview(): Promise;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface Tool {
type: any;
name: string;
instance: any;
icon: string;
}
interface ToolBarProps {
tools: Tool[];
addTool(url: string): void;
changeTool(toolIndex: number): void;
activeToolIndex: number;
metadata: any;
setMetadata(data: any): void;
}
interface ToolBarState {
toolURL: string;
pickerOpen: boolean;
addOpen: boolean;
}
export class ToolBar extends React.Component {
private pickerRef;
constructor(props: ToolBarProps);
computeRGBAColor(): string;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface Channel {
visible: boolean;
editable: boolean;
name: string;
id: 'R' | 'G' | 'B' | 'A';
icon: any;
}
interface ChannelsBarProps {
channels: Channel[];
setChannels(channelState: Channel[]): void;
}
export class ChannelsBar extends React.Component {
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface PixelData {
x?: number;
y?: number;
r?: number;
g?: number;
b?: number;
a?: number;
}
export class TextureCanvasManager {
private _engine;
private _scene;
private _camera;
private _scale;
private _isPanning;
private _mouseX;
private _mouseY;
private _UICanvas;
private _size;
private _2DCanvas;
private _displayCanvas;
private _channels;
private _face;
private _displayTexture;
private _originalTexture;
private _target;
private _originalInternalTexture;
private _didEdit;
private _plane;
private _planeMaterial;
private _planeFallbackMaterial;
private _keyMap;
private static ZOOM_MOUSE_SPEED;
private static ZOOM_KEYBOARD_SPEED;
private static ZOOM_IN_KEY;
private static ZOOM_OUT_KEY;
private static PAN_SPEED;
private static PAN_MOUSE_BUTTON;
private static PAN_KEY;
private static MIN_SCALE;
private static MAX_SCALE;
private _tool;
private _setPixelData;
metadata: any;
constructor(texture: BABYLON.BaseTexture, canvasUI: HTMLCanvasElement, canvas2D: HTMLCanvasElement, canvasDisplay: HTMLCanvasElement, setPixelData: (pixelData: PixelData) => void);
updateTexture(): Promise;
private copyTextureToDisplayTexture;
set channels(channels: Channel[]);
static paintPixelsOnCanvas(pixelData: Uint8Array, canvas: HTMLCanvasElement): void;
grabOriginalTexture(): void;
getMouseCoordinates(pointerInfo: BABYLON.PointerInfo): BABYLON.Vector2;
get scene(): BABYLON.Scene;
get canvas2D(): HTMLCanvasElement;
get size(): BABYLON.ISize;
set tool(tool: BABYLON.Nullable);
get tool(): BABYLON.Nullable;
set face(face: number);
private makePlane;
reset(): void;
resize(newSize: BABYLON.ISize): Promise;
private updateSize;
upload(file: File): void;
dispose(): void;
}
}
declare module INSPECTOR {
interface PropertiesBarProps {
texture: BABYLON.BaseTexture;
saveTexture(): void;
pixelData: PixelData;
face: number;
setFace(face: number): void;
resetTexture(): void;
resizeTexture(width: number, height: number): void;
uploadTexture(file: File): void;
}
interface PropertiesBarState {
width: number;
height: number;
}
interface PixelDataProps {
name: string;
data?: number;
}
function PixelData(props: PixelDataProps): JSX.Element;
export class PropertiesBar extends React.Component {
constructor(props: PropertiesBarProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface BottomBarProps {
name: string;
}
export class BottomBar extends React.Component {
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface TextureCanvasComponentProps {
canvasUI: React.RefObject;
canvas2D: React.RefObject;
canvasDisplay: React.RefObject;
texture: BABYLON.BaseTexture;
}
export class TextureCanvasComponent extends React.Component {
shouldComponentUpdate(nextProps: TextureCanvasComponentProps): boolean;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export const Paintbrush: ToolData;
}
declare module INSPECTOR {
export const Eyedropper: ToolData;
}
declare module INSPECTOR {
export const Floodfill: ToolData;
}
declare module INSPECTOR {
const _default: import("babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent").ToolData[];
export default _default;
}
declare module INSPECTOR {
interface TextureEditorComponentProps {
globalState: GlobalState;
texture: BABYLON.BaseTexture;
url: string;
}
interface TextureEditorComponentState {
tools: Tool[];
activeToolIndex: number;
metadata: any;
channels: Channel[];
pixelData: PixelData;
face: number;
}
export interface ToolParameters {
scene: BABYLON.Scene;
canvas2D: HTMLCanvasElement;
size: BABYLON.ISize;
updateTexture: () => void;
getMetadata: () => any;
setMetadata: (data: any) => void;
}
export interface ToolData {
name: string;
type: any;
icon: string;
}
global {
var _TOOL_DATA_: ToolData;
}
export class TextureEditorComponent extends React.Component {
private _textureCanvasManager;
private canvasUI;
private canvas2D;
private canvasDisplay;
constructor(props: TextureEditorComponentProps);
componentDidMount(): void;
componentDidUpdate(): void;
componentWillUnmount(): void;
loadToolFromURL(url: string): void;
addTools(tools: ToolData[]): void;
getToolParameters(): ToolParameters;
changeTool(index: number): void;
setMetadata(newMetadata: any): void;
setFace(face: number): void;
saveTexture(): void;
resetTexture(): void;
resizeTexture(width: number, height: number): void;
uploadTexture(file: File): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ITexturePropertyGridComponentProps {
texture: BABYLON.BaseTexture;
lockObject: LockObject;
globalState: GlobalState;
onPropertyChangedObservable?: BABYLON.Observable;
}
interface ITexturePropertyGridComponentState {
isTextureEditorOpen: boolean;
textureEditing: BABYLON.Nullable;
}
export class TexturePropertyGridComponent extends React.Component {
private _adtInstrumentation;
private textureLineRef;
constructor(props: ITexturePropertyGridComponentProps);
componentWillUnmount(): void;
updateTexture(file: File): void;
onOpenTextureEditor(): void;
onCloseTextureEditor(window: Window | null, callback?: {
(): void;
}): void;
forceRefresh(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IVector2LineComponentProps {
label: string;
target: any;
propertyName: string;
step?: number;
onChange?: (newvalue: BABYLON.Vector2) => void;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class Vector2LineComponent extends React.Component {
static defaultProps: {
step: number;
};
private _localChange;
constructor(props: IVector2LineComponentProps);
shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
isExpanded: boolean;
value: BABYLON.Vector2;
}): boolean;
switchExpandState(): void;
raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
updateStateX(value: number): void;
updateStateY(value: number): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IPBRMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: BABYLON.PBRMaterial;
lockObject: LockObject;
onSelectionChangedObservable?: BABYLON.Observable;
onPropertyChangedObservable?: BABYLON.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: BABYLON.Observable): JSX.Element;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IRadioButtonLineComponentProps {
onSelectionChangedObservable: BABYLON.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 INSPECTOR {
interface IFogPropertyGridComponentProps {
globalState: GlobalState;
scene: BABYLON.Scene;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class FogPropertyGridComponent extends React.Component {
constructor(props: IFogPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IScenePropertyGridComponentProps {
globalState: GlobalState;
scene: BABYLON.Scene;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
onSelectionChangedObservable?: BABYLON.Observable;
}
export class ScenePropertyGridComponent extends React.Component {
private _storedEnvironmentTexture;
private _renderingModeGroupObservable;
constructor(props: IScenePropertyGridComponentProps);
setRenderingModes(point: boolean, wireframe: boolean): void;
switchIBL(): void;
updateEnvironmentTexture(file: File): void;
updateGravity(newValue: BABYLON.Vector3): void;
updateTimeStep(newValue: number): void;
normalizeScene(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ICommonLightPropertyGridComponentProps {
globalState: GlobalState;
light: BABYLON.Light;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonLightPropertyGridComponent extends React.Component {
constructor(props: ICommonLightPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IHemisphericLightPropertyGridComponentProps {
globalState: GlobalState;
light: BABYLON.HemisphericLight;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class HemisphericLightPropertyGridComponent extends React.Component {
constructor(props: IHemisphericLightPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ICommonShadowLightPropertyGridComponentProps {
globalState: GlobalState;
light: BABYLON.IShadowLight;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonShadowLightPropertyGridComponent extends React.Component {
private _internals;
constructor(props: ICommonShadowLightPropertyGridComponentProps);
createShadowGenerator(): void;
disposeShadowGenerator(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IPointLightPropertyGridComponentProps {
globalState: GlobalState;
light: BABYLON.PointLight;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class PointLightPropertyGridComponent extends React.Component {
constructor(props: IPointLightPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IHexLineComponentProps {
label: string;
target: any;
propertyName: string;
lockObject?: LockObject;
onChange?: (newValue: number) => void;
isInteger?: boolean;
replaySourceReplacement?: string;
onPropertyChangedObservable?: BABYLON.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 INSPECTOR {
interface ICommonCameraPropertyGridComponentProps {
globalState: GlobalState;
camera: BABYLON.Camera;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonCameraPropertyGridComponent extends React.Component {
constructor(props: ICommonCameraPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IFreeCameraPropertyGridComponentProps {
globalState: GlobalState;
camera: BABYLON.FreeCamera;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class FreeCameraPropertyGridComponent extends React.Component {
constructor(props: IFreeCameraPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IArcRotateCameraPropertyGridComponentProps {
globalState: GlobalState;
camera: BABYLON.ArcRotateCamera;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class ArcRotateCameraPropertyGridComponent extends React.Component {
constructor(props: IArcRotateCameraPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
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 INSPECTOR {
interface ICommonPropertyGridComponentProps {
globalState: GlobalState;
host: {
metadata: any;
};
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonPropertyGridComponent extends React.Component {
constructor(props: ICommonPropertyGridComponentProps);
renderLevel(jsonObject: any): JSX.Element[];
render(): JSX.Element | null;
}
}
declare module INSPECTOR {
interface IVariantsPropertyGridComponentProps {
globalState: GlobalState;
host: any;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class VariantsPropertyGridComponent extends React.Component {
private _selectedVariants;
constructor(props: IVariantsPropertyGridComponentProps);
private _getVariantsExtension;
render(): JSX.Element | null;
}
}
declare module INSPECTOR {
interface IMeshPropertyGridComponentProps {
globalState: GlobalState;
mesh: BABYLON.Mesh;
lockObject: LockObject;
onSelectionChangedObservable?: BABYLON.Observable;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class MeshPropertyGridComponent extends React.Component {
constructor(props: IMeshPropertyGridComponentProps);
renderWireframeOver(): void;
renderNormalVectors(): void;
displayNormals(): void;
displayVertexColors(): void;
onMaterialLink(): void;
onSourceMeshLink(): void;
onSkeletonLink(): void;
convertPhysicsTypeToString(): string;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ITransformNodePropertyGridComponentProps {
globalState: GlobalState;
transformNode: BABYLON.TransformNode;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class TransformNodePropertyGridComponent extends React.Component {
constructor(props: ITransformNodePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IBackgroundMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: BABYLON.BackgroundMaterial;
lockObject: LockObject;
onSelectionChangedObservable?: BABYLON.Observable;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class BackgroundMaterialPropertyGridComponent extends React.Component {
private _onDebugSelectionChangeObservable;
constructor(props: IBackgroundMaterialPropertyGridComponentProps);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ICommonControlPropertyGridComponentProps {
globalState: GlobalState;
control: BABYLON.GUI.Control;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonControlPropertyGridComponent extends React.Component {
constructor(props: ICommonControlPropertyGridComponentProps);
renderGridInformation(): JSX.Element | null;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IControlPropertyGridComponentProps {
globalState: GlobalState;
control: BABYLON.GUI.Control;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class ControlPropertyGridComponent extends React.Component {
constructor(props: IControlPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ITextBlockPropertyGridComponentProps {
globalState: GlobalState;
textBlock: BABYLON.GUI.TextBlock;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class TextBlockPropertyGridComponent extends React.Component {
constructor(props: ITextBlockPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IInputTextPropertyGridComponentProps {
globalState: GlobalState;
inputText: BABYLON.GUI.InputText;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class InputTextPropertyGridComponent extends React.Component {
constructor(props: IInputTextPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IColorPickerPropertyGridComponentProps {
globalState: GlobalState;
colorPicker: BABYLON.GUI.ColorPicker;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class ColorPickerPropertyGridComponent extends React.Component {
constructor(props: IColorPickerPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IAnimationGroupGridComponentProps {
globalState: GlobalState;
animationGroup: BABYLON.AnimationGroup;
scene: BABYLON.Scene;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class AnimationGroupGridComponent extends React.Component {
private _onAnimationGroupPlayObserver;
private _onAnimationGroupPauseObserver;
private _onBeforeRenderObserver;
private timelineRef;
constructor(props: IAnimationGroupGridComponentProps);
disconnect(animationGroup: BABYLON.AnimationGroup): void;
connect(animationGroup: BABYLON.AnimationGroup): void;
updateCurrentFrame(animationGroup: BABYLON.AnimationGroup): void;
shouldComponentUpdate(nextProps: IAnimationGroupGridComponentProps): boolean;
componentWillUnmount(): void;
playOrPause(): void;
onCurrentFrameChange(value: number): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IImagePropertyGridComponentProps {
globalState: GlobalState;
image: BABYLON.GUI.Image;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class ImagePropertyGridComponent extends React.Component {
constructor(props: IImagePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ISliderPropertyGridComponentProps {
globalState: GlobalState;
slider: BABYLON.GUI.Slider;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class SliderPropertyGridComponent extends React.Component {
constructor(props: ISliderPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IImageBasedSliderPropertyGridComponentProps {
globalState: GlobalState;
imageBasedSlider: BABYLON.GUI.ImageBasedSlider;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class ImageBasedSliderPropertyGridComponent extends React.Component {
constructor(props: IImageBasedSliderPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IRectanglePropertyGridComponentProps {
globalState: GlobalState;
rectangle: BABYLON.GUI.Rectangle;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class RectanglePropertyGridComponent extends React.Component {
constructor(props: IRectanglePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IEllipsePropertyGridComponentProps {
globalState: GlobalState;
ellipse: BABYLON.GUI.Ellipse;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class EllipsePropertyGridComponent extends React.Component {
constructor(props: IEllipsePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ICheckboxPropertyGridComponentProps {
globalState: GlobalState;
checkbox: BABYLON.GUI.Checkbox;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CheckboxPropertyGridComponent extends React.Component {
constructor(props: ICheckboxPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IRadioButtonPropertyGridComponentProps {
globalState: GlobalState;
radioButton: BABYLON.GUI.RadioButton;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class RadioButtonPropertyGridComponent extends React.Component {
constructor(props: IRadioButtonPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ILinePropertyGridComponentProps {
globalState: GlobalState;
line: BABYLON.GUI.Line;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class LinePropertyGridComponent extends React.Component {
constructor(props: ILinePropertyGridComponentProps);
onDashChange(value: string): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IScrollViewerPropertyGridComponentProps {
globalState: GlobalState;
scrollViewer: BABYLON.GUI.ScrollViewer;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class ScrollViewerPropertyGridComponent extends React.Component {
constructor(props: IScrollViewerPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IGridPropertyGridComponentProps {
globalState: GlobalState;
grid: BABYLON.GUI.Grid;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class GridPropertyGridComponent extends React.Component {
constructor(props: IGridPropertyGridComponentProps);
renderRows(): JSX.Element[];
renderColumns(): JSX.Element[];
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IPBRMetallicRoughnessMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: BABYLON.PBRMetallicRoughnessMaterial;
lockObject: LockObject;
onSelectionChangedObservable?: BABYLON.Observable;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class PBRMetallicRoughnessMaterialPropertyGridComponent extends React.Component {
private _onDebugSelectionChangeObservable;
constructor(props: IPBRMetallicRoughnessMaterialPropertyGridComponentProps);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IPBRSpecularGlossinessMaterialPropertyGridComponentProps {
globalState: GlobalState;
material: BABYLON.PBRSpecularGlossinessMaterial;
lockObject: LockObject;
onSelectionChangedObservable?: BABYLON.Observable;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class PBRSpecularGlossinessMaterialPropertyGridComponent extends React.Component {
private _onDebugSelectionChangeObservable;
constructor(props: IPBRSpecularGlossinessMaterialPropertyGridComponentProps);
renderTextures(): JSX.Element;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IStackPanelPropertyGridComponentProps {
globalState: GlobalState;
stackPanel: BABYLON.GUI.StackPanel;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class StackPanelPropertyGridComponent extends React.Component {
constructor(props: IStackPanelPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ICommonPostProcessPropertyGridComponentProps {
globalState: GlobalState;
postProcess: BABYLON.PostProcess;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonPostProcessPropertyGridComponent extends React.Component {
constructor(props: ICommonPostProcessPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IPostProcessPropertyGridComponentProps {
globalState: GlobalState;
postProcess: BABYLON.PostProcess;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class PostProcessPropertyGridComponent extends React.Component {
constructor(props: IPostProcessPropertyGridComponentProps);
edit(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ICommonRenderingPipelinePropertyGridComponentProps {
globalState: GlobalState;
renderPipeline: BABYLON.PostProcessRenderPipeline;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class CommonRenderingPipelinePropertyGridComponent extends React.Component {
constructor(props: ICommonRenderingPipelinePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IRenderingPipelinePropertyGridComponentProps {
globalState: GlobalState;
renderPipeline: BABYLON.PostProcessRenderPipeline;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class RenderingPipelinePropertyGridComponent extends React.Component {
constructor(props: IRenderingPipelinePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IDefaultRenderingPipelinePropertyGridComponentProps {
globalState: GlobalState;
renderPipeline: BABYLON.DefaultRenderingPipeline;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class DefaultRenderingPipelinePropertyGridComponent extends React.Component {
constructor(props: IDefaultRenderingPipelinePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ISSAORenderingPipelinePropertyGridComponentProps {
globalState: GlobalState;
renderPipeline: BABYLON.SSAORenderingPipeline;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class SSAORenderingPipelinePropertyGridComponent extends React.Component {
constructor(props: ISSAORenderingPipelinePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ISSAO2RenderingPipelinePropertyGridComponentProps {
globalState: GlobalState;
renderPipeline: BABYLON.SSAO2RenderingPipeline;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class SSAO2RenderingPipelinePropertyGridComponent extends React.Component {
constructor(props: ISSAO2RenderingPipelinePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ISkeletonPropertyGridComponentProps {
globalState: GlobalState;
skeleton: BABYLON.Skeleton;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class SkeletonPropertyGridComponent extends React.Component {
private _skeletonViewersEnabled;
private _skeletonViewers;
constructor(props: ISkeletonPropertyGridComponentProps);
switchSkeletonViewers(): void;
checkSkeletonViewerState(props: ISkeletonPropertyGridComponentProps): void;
shouldComponentUpdate(nextProps: ISkeletonPropertyGridComponentProps): boolean;
onOverrideMeshLink(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IBonePropertyGridComponentProps {
globalState: GlobalState;
bone: BABYLON.Bone;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class BonePropertyGridComponent extends React.Component {
constructor(props: IBonePropertyGridComponentProps);
onTransformNodeLink(): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IDirectionalLightPropertyGridComponentProps {
globalState: GlobalState;
light: BABYLON.DirectionalLight;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class DirectionalLightPropertyGridComponent extends React.Component {
constructor(props: IDirectionalLightPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ISpotLightPropertyGridComponentProps {
globalState: GlobalState;
light: BABYLON.SpotLight;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class SpotLightPropertyGridComponent extends React.Component {
constructor(props: ISpotLightPropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ILenstRenderingPipelinePropertyGridComponentProps {
globalState: GlobalState;
renderPipeline: BABYLON.LensRenderingPipeline;
lockObject: LockObject;
onPropertyChangedObservable?: BABYLON.Observable;
}
export class LensRenderingPipelinePropertyGridComponent extends React.Component {
constructor(props: ILenstRenderingPipelinePropertyGridComponentProps);
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface IVector4LineComponentProps {
label: string;
target: any;
propertyName: string;
step?: number;
onChange?: (newvalue: BABYLON.Vector4) => void;
useEuler?: boolean;
onPropertyChangedObservable?: BABYLON.Observable