///
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;
};
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: BABYLON.Observable): void;
prepareGLTFPlugin(loader: import("babylonjs-loaders/glTF/index").GLTFFileLoader): void;
lightGizmos: Array;
enableLightGizmo(light: BABYLON.Light, enable?: boolean): void;
cameraGizmos: Array;
enableCameraGizmo(camera: BABYLON.Camera, 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;
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?: 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;
onBlur(): 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;
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: 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;
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 INSPECTOR {
interface IAnchorSvgPointProps {
control: BABYLON.Vector2;
anchor: BABYLON.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(): BABYLON.Vector2;
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;
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 INSPECTOR {
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?: BABYLON.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) => BABYLON.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 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;
repositionCanvas: (keyframe: BABYLON.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 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: (keyframe: BABYLON.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 | BABYLON.IAnimationKey | undefined;
getCurrentFrame(frame: number): boolean;
dragDomFalse: () => boolean;
render(): JSX.Element;
}
}
declare module INSPECTOR {
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 INSPECTOR {
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 INSPECTOR {
interface IAddAnimationProps {
isOpen: boolean;
close: () => void;
entity: BABYLON.IAnimatable;
onPropertyChangedObservable?: BABYLON.Observable;
setNotificationMessage: (message: string) => void;
finishedUpdate: () => void;
addedNewAnimation: (animation: BABYLON.Animation) => void;
fps: number;
selectedToUpdate?: BABYLON.Animation | undefined;
}
/**
* Controls the creation of a new animation
*/
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;
};
componentDidUpdate(prevProps: IAddAnimationProps, prevState: any): 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;
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 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;
}
/**
* Renders a list of current animations.
*/
export class AnimationListTree extends React.Component | BABYLON.Animation;
}> {
constructor(props: IAnimationListTreeProps);
componentDidUpdate(prevProps: IAnimationListTreeProps): void;
deleteAnimation: () => void;
raiseOnPropertyChanged(newValue: BABYLON.Animation[], previousValue: BABYLON.Animation[]): 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;
}
/**
* 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 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;
}
/**
* 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 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;
}
/**
* 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: BABYLON.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: BABYLON.Animation) => void;
setSnippetId: (id: string) => void;
/**
* Marks animation tab closed and hides the tab
*/
onCloseAddAnimation: () => void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
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 INSPECTOR {
interface IAnimationCurveEditorComponentProps {
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;
}
/**
* BABYLON.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 BABYLON.GUI.Control Bar
*/
resetActionableKeyframe: () => void;
/**
* Sets the selected control point.
*/
selectedControlPoint: (type: string, id: string) => void;
/**
* Sets the selected control point.
*/
deselectKeyframes: () => void;
/**
* Update the BABYLON.Animation Key values based on its type
*/
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;
/**
* BABYLON.Animation should always have a keyframe at Frame Zero
*/
forceFrameZeroToExist(keys: BABYLON.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: BABYLON.IAnimationKey, dataType: number, coordinate: number): void;
/**
* Updates the right control point on render points
*/
updateRightControlPoint(updatedSvgKeyFrame: IKeyframeSvgPoint, key: BABYLON.IAnimationKey, dataType: number, coordinate: number): void;
/**
* Get the current BABYLON.GUI.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 BABYLON.GUI.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: BABYLON.Vector2, index: number): void;
flatTangents(keyframes: BABYLON.IAnimationKey[], dataType: number): BABYLON.IAnimationKey[];
/**
* Return a Keyframe zero value depending on Type
*/
returnZero(dataType: number): 0 | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
/**
* Return the keyframe value as an array depending on type
*/
getValueAsArray(valueType: number, value: number | BABYLON.Vector2 | BABYLON.Vector3 | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Size | BABYLON.Quaternion): number[];
/**
* Sets the keyframe value as an array depending on type
*/
setValueAsType(valueType: number, arrayValue: number[]): number | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
/**
* Returns the SVG Path Data to render the curve
*/
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;
};
calculateLinearTangents(keyframes: BABYLON.IAnimationKey[]): BABYLON.IAnimationKey[];
/**
* Calculates the proper linear tangents if there is no tangents defined
*/
curvePathWithoutTangents(keyframes: BABYLON.IAnimationKey[], data: string, middle: number, type: number, coordinate: number, animationName: string): string;
/**
* Calculates the curve data and control points for animation
*/
curvePathWithTangents(keyframes: BABYLON.IAnimationKey[], data: string, middle: number, type: number, coordinate: number, animationName: string): string;
/**
* Calculates a curve path from predefined easing function
*/
curvePath(keyframes: BABYLON.IAnimationKey[], data: string, middle: number, easingFunction: BABYLON.EasingFunction): string;
/**
* Sets the proper SVG Keyframe points
*/
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;
/**
* Remove all curves from canvas
*/
cleanCanvas: () => void;
/**
* Selects the animation and renders the curve
*/
selectAnimation: (animation: BABYLON.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: BABYLON.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: BABYLON.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 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;
getWindow(): Window | null;
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 {
/** @hidden */
export var lodPixelShader: {
name: string;
shader: string;
};
}
declare module INSPECTOR {
/** @hidden */
export var lodCubePixelShader: {
name: string;
shader: string;
};
}
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, lod?: number): 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 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 INSPECTOR {
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 INSPECTOR {
export const canvasShader: {
path: {
vertexSource: string;
fragmentSource: string;
};
options: {
attributes: string[];
uniforms: string[];
};
};
}
declare module INSPECTOR {
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: BABYLON.BaseTexture, window: Window, canvasUI: HTMLCanvasElement, canvas2D: HTMLCanvasElement, canvas3D: HTMLCanvasElement, setPixelData: (pixelData: IPixelData) => void, metadata: IMetadata, onUpdate: () => void, setMetadata: (metadata: any) => void, setMipLevel: (level: number) => void);
updateTexture(): Promise;
private pushTexture;
startPainting(): Promise;
updatePainting(): void;
stopPainting(): void;
private updateDisplay;
set channels(channels: IChannel[]);
paintPixelsOnCanvas(pixelData: Uint8Array, canvas: HTMLCanvasElement): void;
grabOriginalTexture(): Promise;
getMouseCoordinates(pointerInfo: BABYLON.PointerInfo): BABYLON.Vector2;
get scene(): BABYLON.Scene;
get canvas2D(): HTMLCanvasElement;
get size(): BABYLON.ISize;
set tool(tool: BABYLON.Nullable);
get tool(): BABYLON.Nullable;
set face(face: number);
set mipLevel(mipLevel: number);
/** Returns the 3D scene used for postprocesses */
get scene3D(): BABYLON.Scene;
set metadata(metadata: IMetadata);
private makePlane;
reset(): void;
resize(newSize: BABYLON.ISize): Promise;
setSize(size: BABYLON.ISize): void;
upload(file: File): void;
saveTexture(): void;
dispose(): void;
}
}
declare module INSPECTOR {
interface IPropertiesBarProps {
texture: BABYLON.BaseTexture;
size: BABYLON.ISize;
saveTexture(): void;
pixelData: IPixelData;
face: number;
setFace(face: number): void;
resetTexture(): void;
resizeTexture(width: number, height: number): void;
uploadTexture(file: File): void;
mipLevel: number;
setMipLevel: (mipLevel: number) => void;
}
interface IPropertiesBarState {
width: number;
height: number;
}
export class PropertiesBar extends React.PureComponent {
private _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 INSPECTOR {
interface IBottomBarProps {
texture: BABYLON.BaseTexture;
mipLevel: number;
}
export class BottomBar extends React.PureComponent {
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ITextureCanvasComponentProps {
canvasUI: React.RefObject;
canvas2D: React.RefObject;
canvas3D: React.RefObject;
texture: BABYLON.BaseTexture;
}
export class TextureCanvasComponent extends React.Component {
render(): JSX.Element;
}
}
declare module INSPECTOR {
export const Paintbrush: IToolData;
}
declare module INSPECTOR {
export const Eyedropper: IToolData;
}
declare module INSPECTOR {
export const Floodfill: IToolData;
}
declare module INSPECTOR {
export const RectangleSelect: IToolData;
}
declare module INSPECTOR {
const _default: import("babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent").IToolData[];
export default _default;
}
declare module INSPECTOR {
interface IToolSettingsProps {
tool: ITool | undefined;
}
export class ToolSettings extends React.Component {
render(): JSX.Element;
}
}
declare module INSPECTOR {
interface ITextureEditorComponentProps {
texture: BABYLON.BaseTexture;
url: string;
window: React.RefObject;
onUpdate: () => void;
}
interface ITextureEditorComponentState {
tools: ITool[];
activeToolIndex: number;
metadata: IMetadata;
channels: IChannel[];
pixelData: IPixelData;
face: number;
mipLevel: number;
pickerOpen: boolean;
}
export interface IToolParameters {
/** The visible scene in the editor. Useful for adding pointer and keyboard events. */
scene: BABYLON.Scene;
/** The 2D canvas which you can sample pixel data from. Tools should not paint directly on this canvas. */
canvas2D: HTMLCanvasElement;
/** The 3D scene which tools can add post processes to. */
scene3D: BABYLON.Scene;
/** The size of the texture. */
size: BABYLON.ISize;
/** Pushes the editor texture back to the original scene. This should be called every time a tool makes any modification to a texture. */
updateTexture: () => void;
/** The metadata object which is shared between all tools. Feel free to store any information here. Do not set this directly: instead call setMetadata. */
metadata: IMetadata;
/** Call this when you want to mutate the metadata. */
setMetadata: (data: any) => void;
/** Returns the texture coordinates under the cursor */
getMouseCoordinates: (pointerInfo: BABYLON.PointerInfo) => BABYLON.Vector2;
/** Provides 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 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 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 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 {
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;
displayBoneWeights(): void;
displaySkeletonMap(): void;
onBoneDisplayIndexChange(value: number): 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 _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 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;
}
export class Vector4LineComponent extends React.Component {
static defaultProps: {
step: number;
};
private _localChange;
constructor(props: IVector4LineComponentProps);
getCurrentValue(): any;
shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
isExpanded: boolean;
value: BABYLON.Vector4;
}): boolean;
switchExpandState(): void;
raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
updateVector4(): void;
updateStateX(value: number): void;
updateStateY(value: number): void;
updateStateZ(value: number): void;
updateStateW(value: number): void;
render(): JSX.Element;
}
}
declare module INSPECTOR {
export interface IColor4LineComponentProps {
label: string;
target: any;
propertyName: string;
onPropertyChangedObservable?: BABYLON.Observable;
onChange?: () => void;
isLinear?: boolean;
}
export class Color4LineComponent extends React.Component {
private _localChange;
constructor(props: IColor4LineComponentProps);
shouldComponentUpdate(nextProps: IColor4LineComponentProps, nextState: {
color: BABYLON.Color4;
}): boolean;
setPropertyValue(newColor: BABYLON.Color4): void;
onChange(newValue: string): void;
switchExpandState(): void;
raiseOnPropertyChanged(previousValue: BABYLON.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 INSPECTOR {
interface IGradientStepComponentProps {
globalState: GlobalState;
step: BABYLON.GradientBlockColorStep;
lineIndex: number;
onDelete: () => void;
onUpdateStep: () => void;
onCheckForReOrder: () => void;
onCopy?: () => void;
}
export class GradientStepComponent extends React.Component