babylonjs-node-editor 5.0.0 → 5.0.1

package/babylon.nodeEditor.d.ts

@@ -1,7 +1,7 @@
 
 declare module BABYLON.NodeEditor {
     export class BlockTools {
-        static GetBlockFromString(data: string, scene: Scene, nodeMaterial: NodeMaterial): BABYLON.ElbowBlock | BABYLON.TwirlBlock | BABYLON.VoronoiNoiseBlock | BABYLON.ScreenSpaceBlock | BABYLON.CloudBlock | BABYLON.MatrixBuilderBlock | BABYLON.DesaturateBlock | BABYLON.RefractBlock | BABYLON.ReflectBlock | BABYLON.DerivativeBlock | BABYLON.Rotate2dBlock | BABYLON.NormalBlendBlock | BABYLON.WorleyNoise3DBlock | BABYLON.SimplexPerlin3DBlock | BABYLON.BonesBlock | BABYLON.InstancesBlock | BABYLON.MorphTargetsBlock | BABYLON.DiscardBlock | BABYLON.ImageProcessingBlock | BABYLON.ColorMergerBlock | BABYLON.VectorMergerBlock | BABYLON.ColorSplitterBlock | BABYLON.VectorSplitterBlock | BABYLON.TextureBlock | BABYLON.ReflectionTextureBlock | BABYLON.LightBlock | BABYLON.FogBlock | BABYLON.VertexOutputBlock | BABYLON.FragmentOutputBlock | BABYLON.AddBlock | BABYLON.ClampBlock | BABYLON.ScaleBlock | BABYLON.CrossBlock | BABYLON.DotBlock | BABYLON.PowBlock | BABYLON.MultiplyBlock | BABYLON.TransformBlock | BABYLON.TrigonometryBlock | BABYLON.RemapBlock | BABYLON.NormalizeBlock | BABYLON.FresnelBlock | BABYLON.LerpBlock | BABYLON.NLerpBlock | BABYLON.DivideBlock | BABYLON.SubtractBlock | BABYLON.ModBlock | BABYLON.StepBlock | BABYLON.SmoothStepBlock | BABYLON.OneMinusBlock | BABYLON.ReciprocalBlock | BABYLON.ViewDirectionBlock | BABYLON.LightInformationBlock | BABYLON.MaxBlock | BABYLON.MinBlock | BABYLON.LengthBlock | BABYLON.DistanceBlock | BABYLON.NegateBlock | BABYLON.PerturbNormalBlock | BABYLON.RandomNumberBlock | BABYLON.ReplaceColorBlock | BABYLON.PosterizeBlock | BABYLON.ArcTan2Block | BABYLON.GradientBlock | BABYLON.FrontFacingBlock | BABYLON.WaveBlock | BABYLON.InputBlock | BABYLON.PBRMetallicRoughnessBlock | BABYLON.SheenBlock | BABYLON.AnisotropyBlock | BABYLON.ReflectionBlock | BABYLON.ClearCoatBlock | BABYLON.RefractionBlock | BABYLON.SubSurfaceBlock | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock | BABYLON.ParticleRampGradientBlock | BABYLON.ParticleBlendMultiplyBlock | BABYLON.FragCoordBlock | BABYLON.ScreenSizeBlock | BABYLON.SceneDepthBlock | BABYLON.ConditionalBlock | BABYLON.ImageSourceBlock | BABYLON.ClipPlanesBlock | null;
+        static GetBlockFromString(data: string, scene: BABYLON.Scene, nodeMaterial: BABYLON.NodeMaterial): BABYLON.ElbowBlock | BABYLON.TwirlBlock | BABYLON.VoronoiNoiseBlock | BABYLON.ScreenSpaceBlock | BABYLON.CloudBlock | BABYLON.MatrixBuilderBlock | BABYLON.DesaturateBlock | BABYLON.RefractBlock | BABYLON.ReflectBlock | BABYLON.DerivativeBlock | BABYLON.Rotate2dBlock | BABYLON.NormalBlendBlock | BABYLON.WorleyNoise3DBlock | BABYLON.SimplexPerlin3DBlock | BABYLON.BonesBlock | BABYLON.InstancesBlock | BABYLON.MorphTargetsBlock | BABYLON.DiscardBlock | BABYLON.ImageProcessingBlock | BABYLON.ColorMergerBlock | BABYLON.VectorMergerBlock | BABYLON.ColorSplitterBlock | BABYLON.VectorSplitterBlock | BABYLON.TextureBlock | BABYLON.ReflectionTextureBlock | BABYLON.LightBlock | BABYLON.FogBlock | BABYLON.VertexOutputBlock | BABYLON.FragmentOutputBlock | BABYLON.AddBlock | BABYLON.ClampBlock | BABYLON.ScaleBlock | BABYLON.CrossBlock | BABYLON.DotBlock | BABYLON.PowBlock | BABYLON.MultiplyBlock | BABYLON.TransformBlock | BABYLON.TrigonometryBlock | BABYLON.RemapBlock | BABYLON.NormalizeBlock | BABYLON.FresnelBlock | BABYLON.LerpBlock | BABYLON.NLerpBlock | BABYLON.DivideBlock | BABYLON.SubtractBlock | BABYLON.ModBlock | BABYLON.StepBlock | BABYLON.SmoothStepBlock | BABYLON.OneMinusBlock | BABYLON.ReciprocalBlock | BABYLON.ViewDirectionBlock | BABYLON.LightInformationBlock | BABYLON.MaxBlock | BABYLON.MinBlock | BABYLON.LengthBlock | BABYLON.DistanceBlock | BABYLON.NegateBlock | BABYLON.PerturbNormalBlock | BABYLON.RandomNumberBlock | BABYLON.ReplaceColorBlock | BABYLON.PosterizeBlock | BABYLON.ArcTan2Block | BABYLON.GradientBlock | BABYLON.FrontFacingBlock | BABYLON.WaveBlock | BABYLON.InputBlock | BABYLON.PBRMetallicRoughnessBlock | BABYLON.SheenBlock | BABYLON.AnisotropyBlock | BABYLON.ReflectionBlock | BABYLON.ClearCoatBlock | BABYLON.RefractionBlock | BABYLON.SubSurfaceBlock | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock | BABYLON.ParticleRampGradientBlock | BABYLON.ParticleBlendMultiplyBlock | BABYLON.FragCoordBlock | BABYLON.ScreenSizeBlock | BABYLON.SceneDepthBlock | BABYLON.ConditionalBlock | BABYLON.ImageSourceBlock | BABYLON.ClipPlanesBlock | null;
         static GetColorFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
         static GetConnectionNodeTypeFromString(type: string): BABYLON.NodeMaterialBlockConnectionPointTypes.Float | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector2 | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector3 | BABYLON.NodeMaterialBlockConnectionPointTypes.Vector4 | BABYLON.NodeMaterialBlockConnectionPointTypes.Color3 | BABYLON.NodeMaterialBlockConnectionPointTypes.Color4 | BABYLON.NodeMaterialBlockConnectionPointTypes.Matrix | BABYLON.NodeMaterialBlockConnectionPointTypes.AutoDetect;
         static GetStringFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): "" | "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4";
@@ -139,19 +139,19 @@ declare module BABYLON.NodeEditor {
 
     interface IInputsPropertyTabComponentProps {
         globalState: GlobalState;
-        inputs: InputBlock[];
+        inputs: BABYLON.InputBlock[];
     }
     export class InputsPropertyTabComponent extends React.Component<IInputsPropertyTabComponentProps> {
         constructor(props: IInputsPropertyTabComponentProps);
-        processInputBlockUpdate(ib: InputBlock): void;
-        renderInputBlock(block: InputBlock): JSX.Element | null;
+        processInputBlockUpdate(ib: BABYLON.InputBlock): void;
+        renderInputBlock(block: BABYLON.InputBlock): JSX.Element | null;
         render(): JSX.Element;
     }
 
 
     interface IColor3PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: InputBlock;
+        inputBlock: BABYLON.InputBlock;
     }
     export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -160,7 +160,7 @@ declare module BABYLON.NodeEditor {
 
     interface IColor4PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: InputBlock;
+        inputBlock: BABYLON.InputBlock;
     }
     export class Color4PropertyTabComponent extends React.Component<IColor4PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -169,7 +169,7 @@ declare module BABYLON.NodeEditor {
 
     interface IFloatPropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: InputBlock;
+        inputBlock: BABYLON.InputBlock;
     }
     export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
         render(): JSX.Element;
@@ -178,7 +178,7 @@ declare module BABYLON.NodeEditor {
 
     interface IMatrixPropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: InputBlock;
+        inputBlock: BABYLON.InputBlock;
     }
     export class MatrixPropertyTabComponent extends React.Component<IMatrixPropertyTabComponentProps> {
         render(): JSX.Element;
@@ -187,7 +187,7 @@ declare module BABYLON.NodeEditor {
 
     interface IVector2PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: InputBlock;
+        inputBlock: BABYLON.InputBlock;
     }
     export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -196,7 +196,7 @@ declare module BABYLON.NodeEditor {
 
     interface IVector3PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: InputBlock;
+        inputBlock: BABYLON.InputBlock;
     }
     export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -205,7 +205,7 @@ declare module BABYLON.NodeEditor {
 
     interface IVector4PropertyTabComponentProps {
         globalState: GlobalState;
-        inputBlock: InputBlock;
+        inputBlock: BABYLON.InputBlock;
     }
     export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
         render(): JSX.Element;
@@ -216,10 +216,10 @@ declare module BABYLON.NodeEditor {
         globalState: GlobalState;
     }
     interface IPropertyTabComponentState {
-        currentNode: Nullable<GraphNode>;
-        currentFrame: Nullable<GraphFrame>;
-        currentFrameNodePort: Nullable<FrameNodePort>;
-        currentNodePort: Nullable<NodePort>;
+        currentNode: BABYLON.Nullable<GraphNode>;
+        currentFrame: BABYLON.Nullable<GraphFrame>;
+        currentFrameNodePort: BABYLON.Nullable<FrameNodePort>;
+        currentNodePort: BABYLON.Nullable<NodePort>;
         uploadInProgress: boolean;
     }
     export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
@@ -228,8 +228,8 @@ declare module BABYLON.NodeEditor {
         constructor(props: IPropertyTabComponentProps);
         componentDidMount(): void;
         componentWillUnmount(): void;
-        processInputBlockUpdate(ib: InputBlock): void;
-        renderInputBlock(block: InputBlock): JSX.Element | null;
+        processInputBlockUpdate(ib: BABYLON.InputBlock): void;
+        renderInputBlock(block: BABYLON.InputBlock): JSX.Element | null;
         load(file: File): void;
         loadFrame(file: File): void;
         save(): void;
@@ -244,16 +244,16 @@ declare module BABYLON.NodeEditor {
     export class ClampDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class ConditionalDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
         updatePreviewContent(): void;
     }
@@ -262,36 +262,36 @@ declare module BABYLON.NodeEditor {
     export class DiscardDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export interface IDisplayManager {
-        getHeaderClass(block: NodeMaterialBlock): string;
-        shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
-        getBackgroundColor(block: NodeMaterialBlock): string;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
+        shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
     }
 
 
     export class ElbowDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
-        getBackgroundColor(block: NodeMaterialBlock): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class GradientDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
-        getBackgroundColor(block: NodeMaterialBlock): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
@@ -300,47 +300,47 @@ declare module BABYLON.NodeEditor {
         private _previewImage;
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class InputDisplayManager implements IDisplayManager {
-        getHeaderClass(block: NodeMaterialBlock): "" | "constant" | "inspector";
+        getHeaderClass(block: BABYLON.NodeMaterialBlock): "" | "constant" | "inspector";
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         static GetBaseType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
-        getBackgroundColor(block: NodeMaterialBlock): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class OutputDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class PBRDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class RemapDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
         private _extractInputValue;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
@@ -349,18 +349,18 @@ declare module BABYLON.NodeEditor {
         private _previewImage;
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
-        getBackgroundColor(block: NodeMaterialBlock): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
+        getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
     export class TrigonometryDisplayManager implements IDisplayManager {
         getHeaderClass(): string;
         shouldDisplayPortLabels(): boolean;
-        getHeaderText(block: NodeMaterialBlock): string;
+        getHeaderText(block: BABYLON.NodeMaterialBlock): string;
         getBackgroundColor(): string;
-        updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
+        updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
     }
 
 
@@ -372,7 +372,7 @@ declare module BABYLON.NodeEditor {
 
 
     export class FrameNodePort extends NodePort {
-        connectionPoint: NodeMaterialConnectionPoint;
+        connectionPoint: BABYLON.NodeMaterialConnectionPoint;
         node: GraphNode;
         private _parentFrameId;
         private _isInput;
@@ -385,14 +385,14 @@ declare module BABYLON.NodeEditor {
         get framePortId(): number;
         get framePortPosition(): FramePortPosition;
         set framePortPosition(position: FramePortPosition);
-        constructor(portContainer: HTMLElement, connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number);
-        static CreateFrameNodePortElement(connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
+        constructor(portContainer: HTMLElement, connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number);
+        static CreateFrameNodePortElement(connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<IDisplayManager>, globalState: GlobalState, isInput: boolean, framePortId: number, parentFrameId: number): FrameNodePort;
     }
 
 
     export interface IGraphCanvasComponentProps {
         globalState: GlobalState;
-        onEmitNewBlock: (block: NodeMaterialBlock) => GraphNode;
+        onEmitNewBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
     }
     export type FramePortData = {
         frame: GraphFrame;
@@ -448,9 +448,9 @@ declare module BABYLON.NodeEditor {
         get y(): number;
         set y(value: number);
         get selectedNodes(): GraphNode[];
-        get selectedLink(): Nullable<NodeLink>;
+        get selectedLink(): BABYLON.Nullable<NodeLink>;
         get selectedFrames(): GraphFrame[];
-        get selectedPort(): Nullable<NodePort>;
+        get selectedPort(): BABYLON.Nullable<NodePort>;
         get canvasContainer(): HTMLDivElement;
         get hostCanvas(): HTMLDivElement;
         get svgCanvas(): HTMLElement;
@@ -462,11 +462,11 @@ declare module BABYLON.NodeEditor {
         getGridPositionCeil(position: number): number;
         updateTransform(): void;
         onKeyUp(): void;
-        findNodeFromBlock(block: NodeMaterialBlock): GraphNode;
+        findNodeFromBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
         reset(): void;
-        connectPorts(pointA: NodeMaterialConnectionPoint, pointB: NodeMaterialConnectionPoint): void;
+        connectPorts(pointA: BABYLON.NodeMaterialConnectionPoint, pointB: BABYLON.NodeMaterialConnectionPoint): void;
         removeLink(link: NodeLink): void;
-        appendBlock(block: NodeMaterialBlock): GraphNode;
+        appendBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
         distributeGraph(): void;
         componentDidMount(): void;
         onMove(evt: React.PointerEvent): void;
@@ -475,7 +475,7 @@ declare module BABYLON.NodeEditor {
         onWheel(evt: React.WheelEvent): void;
         zoomToFit(): void;
         processCandidatePort(): void;
-        connectNodes(nodeA: GraphNode, pointA: NodeMaterialConnectionPoint, nodeB: GraphNode, pointB: NodeMaterialConnectionPoint): void;
+        connectNodes(nodeA: GraphNode, pointA: BABYLON.NodeMaterialConnectionPoint, nodeB: GraphNode, pointB: BABYLON.NodeMaterialConnectionPoint): void;
         processEditorData(editorData: IEditorData): void;
         addFrame(frameData: IFrameData): void;
         render(): JSX.Element;
@@ -561,7 +561,7 @@ declare module BABYLON.NodeEditor {
         set height(value: number);
         get comments(): string;
         set comments(comments: string);
-        constructor(candidate: Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
+        constructor(candidate: BABYLON.Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
         refresh(): void;
         addNode(node: GraphNode): void;
         removeNode(node: GraphNode): void;
@@ -632,7 +632,7 @@ declare module BABYLON.NodeEditor {
 
     /// <reference types="react" />
     export class GraphNode {
-        block: NodeMaterialBlock;
+        block: BABYLON.NodeMaterialBlock;
         private _visual;
         private _headerContainer;
         private _promotionWarning;
@@ -681,10 +681,10 @@ declare module BABYLON.NodeEditor {
         get enclosingFrameId(): number;
         set enclosingFrameId(value: number);
         set isSelected(value: boolean);
-        constructor(block: NodeMaterialBlock, globalState: GlobalState);
+        constructor(block: BABYLON.NodeMaterialBlock, globalState: GlobalState);
         isOverlappingFrame(frame: GraphFrame): boolean;
-        getPortForConnectionPoint(point: NodeMaterialConnectionPoint): NodePort | null;
-        getLinksForConnectionPoint(point: NodeMaterialConnectionPoint): NodeLink[];
+        getPortForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): NodePort | null;
+        getLinksForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): NodeLink[];
         private _refreshFrames;
         _refreshLinks(): void;
         refresh(): void;
@@ -692,7 +692,7 @@ declare module BABYLON.NodeEditor {
         cleanAccumulation(useCeil?: boolean): void;
         private _onUp;
         private _onMove;
-        renderProperties(): Nullable<JSX.Element>;
+        renderProperties(): BABYLON.Nullable<JSX.Element>;
         appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
         dispose(): void;
     }
@@ -723,16 +723,16 @@ declare module BABYLON.NodeEditor {
 
 
     export class NodePort {
-        connectionPoint: NodeMaterialConnectionPoint;
+        connectionPoint: BABYLON.NodeMaterialConnectionPoint;
         node: GraphNode;
         protected _element: HTMLDivElement;
         protected _img: HTMLImageElement;
         protected _globalState: GlobalState;
         protected _portLabelElement: Element;
-        protected _onCandidateLinkMovedObserver: Nullable<Observer<Nullable<Vector2>>>;
-        protected _onSelectionChangedObserver: Nullable<Observer<Nullable<ISelectionChangedOptions>>>;
+        protected _onCandidateLinkMovedObserver: BABYLON.Nullable<BABYLON.Observer<BABYLON.Nullable<BABYLON.Vector2>>>;
+        protected _onSelectionChangedObserver: BABYLON.Nullable<BABYLON.Observer<BABYLON.Nullable<ISelectionChangedOptions>>>;
         protected _exposedOnFrame: boolean;
-        delegatedPort: Nullable<FrameNodePort>;
+        delegatedPort: BABYLON.Nullable<FrameNodePort>;
         get element(): HTMLDivElement;
         get portName(): string;
         set portName(newName: string);
@@ -744,9 +744,9 @@ declare module BABYLON.NodeEditor {
         set exposedPortPosition(value: number);
         private _isConnectedToNodeOutsideOfFrame;
         refresh(): void;
-        constructor(portContainer: HTMLElement, connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
+        constructor(portContainer: HTMLElement, connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
         dispose(): void;
-        static CreatePortElement(connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
+        static CreatePortElement(connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
     }
 
 
@@ -805,7 +805,7 @@ declare module BABYLON.NodeEditor {
             rebuild?: boolean;
             update?: boolean;
             activatePreviewCommand?: boolean;
-            callback?: (scene: Scene) => void;
+            callback?: (scene: BABYLON.Scene) => void;
         }): void;
         render(): JSX.Element;
     }
@@ -827,7 +827,7 @@ declare module BABYLON.NodeEditor {
 
     interface IGradientStepComponentProps {
         globalState: GlobalState;
-        step: GradientBlockColorStep;
+        step: BABYLON.GradientBlockColorStep;
         lineIndex: number;
         onDelete: () => void;
         onUpdateStep: () => void;
@@ -848,7 +848,7 @@ declare module BABYLON.NodeEditor {
     export class ImageSourcePropertyTabComponent extends React.Component<IPropertyComponentProps, {
         isEmbedded: boolean;
     }> {
-        get imageSourceBlock(): ImageSourceBlock;
+        get imageSourceBlock(): BABYLON.ImageSourceBlock;
         constructor(props: IPropertyComponentProps);
         UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
             isEmbedded: boolean;
@@ -904,12 +904,12 @@ declare module BABYLON.NodeEditor {
 
     export interface IPropertyComponentProps {
         globalState: GlobalState;
-        block: NodeMaterialBlock;
+        block: BABYLON.NodeMaterialBlock;
     }
 
 
     type ReflectionTexture = BABYLON.ReflectionTextureBlock | BABYLON.ReflectionBlock | BABYLON.RefractionBlock;
-    type AnyTexture = TextureBlock | ReflectionTexture | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock;
+    type AnyTexture = BABYLON.TextureBlock | ReflectionTexture | BABYLON.CurrentScreenBlock | BABYLON.ParticleTextureBlock;
     export class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps, {
         isEmbedded: boolean;
         loadAsCubeTexture: boolean;
@@ -955,26 +955,26 @@ declare module BABYLON.NodeEditor {
 
     export class PropertyLedger {
         static RegisteredControls: {
-            [key: string]: ComponentClass<IPropertyComponentProps>;
+            [key: string]: React.ComponentClass<IPropertyComponentProps>;
         };
     }
 
 
     export class ISelectionChangedOptions {
-        selection: Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData>;
+        selection: BABYLON.Nullable<GraphNode | NodeLink | GraphFrame | NodePort | FramePortData>;
         forceKeepSelection?: boolean;
     }
     export class GlobalState {
-        nodeMaterial: NodeMaterial;
+        nodeMaterial: BABYLON.NodeMaterial;
         hostElement: HTMLElement;
         hostDocument: HTMLDocument;
         hostWindow: Window;
         onNewNodeCreatedObservable: BABYLON.Observable<GraphNode>;
-        onSelectionChangedObservable: BABYLON.Observable<Nullable<ISelectionChangedOptions>>;
+        onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<ISelectionChangedOptions>>;
         onRebuildRequiredObservable: BABYLON.Observable<boolean>;
         onBuiltObservable: BABYLON.Observable<void>;
         onResetRequiredObservable: BABYLON.Observable<void>;
-        onUpdateRequiredObservable: BABYLON.Observable<Nullable<NodeMaterialBlock>>;
+        onUpdateRequiredObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.NodeMaterialBlock>>;
         onZoomToFitRequiredObservable: BABYLON.Observable<void>;
         onReOrganizedRequiredObservable: BABYLON.Observable<void>;
         onLogRequiredObservable: BABYLON.Observable<LogEntry>;
@@ -986,10 +986,10 @@ declare module BABYLON.NodeEditor {
         onBackFaceCullingChanged: BABYLON.Observable<void>;
         onDepthPrePassChanged: BABYLON.Observable<void>;
         onAnimationCommandActivated: BABYLON.Observable<void>;
-        onCandidateLinkMoved: BABYLON.Observable<Nullable<Vector2>>;
+        onCandidateLinkMoved: BABYLON.Observable<BABYLON.Nullable<BABYLON.Vector2>>;
         onSelectionBoxMoved: BABYLON.Observable<ClientRect | DOMRect>;
         onFrameCreatedObservable: BABYLON.Observable<GraphFrame>;
-        onCandidatePortSelectedObservable: BABYLON.Observable<Nullable<NodePort | FrameNodePort>>;
+        onCandidatePortSelectedObservable: BABYLON.Observable<BABYLON.Nullable<NodePort | FrameNodePort>>;
         onImportFrameObservable: BABYLON.Observable<any>;
         onGraphNodeRemovalObservable: BABYLON.Observable<GraphNode>;
         onPopupClosedObservable: BABYLON.Observable<void>;
@@ -999,7 +999,7 @@ declare module BABYLON.NodeEditor {
             targetY: number;
             needRepositioning?: boolean | undefined;
         }>;
-        onGetNodeFromBlock: (block: NodeMaterialBlock) => GraphNode;
+        onGetNodeFromBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
         onGridSizeChanged: BABYLON.Observable<void>;
         onExposePortOnFrameObservable: BABYLON.Observable<GraphNode>;
         previewType: PreviewType;
@@ -1015,7 +1015,7 @@ declare module BABYLON.NodeEditor {
         directionalLight0: boolean;
         directionalLight1: boolean;
         controlCamera: boolean;
-        storeEditorData: (serializationObject: any, frame?: Nullable<GraphFrame>) => void;
+        storeEditorData: (serializationObject: any, frame?: BABYLON.Nullable<GraphFrame>) => void;
         _mode: BABYLON.NodeMaterialModes;
         /** Gets the mode */
         get mode(): BABYLON.NodeMaterialModes;
@@ -1035,7 +1035,7 @@ declare module BABYLON.NodeEditor {
     interface IGraphEditorState {
         showPreviewPopUp: boolean;
     }
-    interface IInternalPreviewAreaOptions extends IInspectorOptions {
+    interface IInternalPreviewAreaOptions extends BABYLON.IInspectorOptions {
         popup: boolean;
         original: boolean;
         explorerWidth?: string;
@@ -1066,7 +1066,7 @@ declare module BABYLON.NodeEditor {
          * @param block
          * @param recursion
          */
-        createNodeFromObject(block: NodeMaterialBlock, recursion?: boolean): GraphNode;
+        createNodeFromObject(block: BABYLON.NodeMaterialBlock, recursion?: boolean): GraphNode;
         addValueNode(type: string): GraphNode;
         componentDidMount(): void;
         componentWillUnmount(): void;
@@ -1079,7 +1079,7 @@ declare module BABYLON.NodeEditor {
         loadGraph(): void;
         showWaitScreen(): void;
         hideWaitScreen(): void;
-        reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
+        reOrganize(editorData?: BABYLON.Nullable<IEditorData>, isImportingAFrame?: boolean): void;
         onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
         onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
         resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
@@ -1091,8 +1091,8 @@ declare module BABYLON.NodeEditor {
         initiatePreviewArea: (canvas?: HTMLCanvasElement) => void;
         createPopUp: () => void;
         createPopupWindow: (title: string, windowVariableName: string, width?: number, height?: number) => Window | null;
-        createPreviewMeshControlHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
-        createPreviewHost: (options: IInternalPreviewAreaOptions, parentControl: Nullable<HTMLElement>) => void;
+        createPreviewMeshControlHost: (options: IInternalPreviewAreaOptions, parentControl: BABYLON.Nullable<HTMLElement>) => void;
+        createPreviewHost: (options: IInternalPreviewAreaOptions, parentControl: BABYLON.Nullable<HTMLElement>) => void;
         fixPopUpStyles: (document: Document) => void;
         render(): JSX.Element;
     }
@@ -1104,13 +1104,13 @@ declare module BABYLON.NodeEditor {
      * Interface used to specify creation options for the node editor
      */
     export interface INodeEditorOptions {
-        nodeMaterial: NodeMaterial;
+        nodeMaterial: BABYLON.NodeMaterial;
         hostElement?: HTMLElement;
         customSave?: {
             label: string;
             action: (data: string) => Promise<void>;
         };
-        customLoadObservable?: Observable<any>;
+        customLoadObservable?: BABYLON.Observable<any>;
     }
     /**
      * Class used to create a node editor
@@ -1162,10 +1162,10 @@ declare module BABYLON.NodeEditor {
 
 
     export class SerializationTools {
-        static UpdateLocations(material: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): void;
-        static Serialize(material: NodeMaterial, globalState: GlobalState, frame?: Nullable<GraphFrame>): string;
+        static UpdateLocations(material: BABYLON.NodeMaterial, globalState: GlobalState, frame?: BABYLON.Nullable<GraphFrame>): void;
+        static Serialize(material: BABYLON.NodeMaterial, globalState: GlobalState, frame?: BABYLON.Nullable<GraphFrame>): string;
         static Deserialize(serializationObject: any, globalState: GlobalState): void;
-        static AddFrameToMaterial(serializationObject: any, globalState: GlobalState, currentMaterial: NodeMaterial): void;
+        static AddFrameToMaterial(serializationObject: any, globalState: GlobalState, currentMaterial: BABYLON.NodeMaterial): void;
     }
 
 
@@ -1187,7 +1187,7 @@ declare module BABYLON.NodeEditor {
         isSelected?: () => boolean;
         onSelect?: (value: boolean) => void;
         onValueChanged?: () => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         disabled?: boolean;
     }
     export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
@@ -1211,7 +1211,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         onChange?: () => void;
         globalState: GlobalState;
     }
@@ -1234,7 +1234,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         onChange?: () => void;
         globalState: GlobalState;
     }
@@ -1253,13 +1253,13 @@ declare module BABYLON.NodeEditor {
 
 
     export interface IColorPickerComponentProps {
-        value: Color4 | Color3;
+        value: BABYLON.Color4 | BABYLON.Color3;
         onColorChanged: (newOne: string) => void;
         globalState: GlobalState;
     }
     interface IColorPickerComponentState {
         pickerEnabled: boolean;
-        color: Color3 | Color4;
+        color: BABYLON.Color3 | BABYLON.Color4;
         hex: string;
     }
     export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
@@ -1319,7 +1319,7 @@ declare module BABYLON.NodeEditor {
         propertyName: string;
         onChange?: (newValue: number) => void;
         isInteger?: boolean;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         additionalClass?: string;
         step?: string;
         digits?: number;
@@ -1389,7 +1389,7 @@ declare module BABYLON.NodeEditor {
         step?: number;
         onChange?: (newValue: BABYLON.Matrix) => void;
         onModeChange?: (mode: number) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         mode?: number;
         globalState: GlobalState;
     }
@@ -1405,9 +1405,9 @@ declare module BABYLON.NodeEditor {
             mode: number;
             angle: number;
         }): boolean;
-        raiseOnPropertyChanged(previousValue: Vector3): void;
+        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
         updateMatrix(): void;
-        updateRow(value: Vector4, row: number): void;
+        updateRow(value: BABYLON.Vector4, row: number): void;
         updateBasedOnMode(value: number): void;
         render(): JSX.Element;
     }
@@ -1453,10 +1453,10 @@ declare module BABYLON.NodeEditor {
         target: any;
         className?: string;
         propertyName?: string;
-        options: IInspectableOptions[];
+        options: BABYLON.IInspectableOptions[];
         noDirectUpdate?: boolean;
         onSelect?: (value: number | string) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         valuesAreStrings?: boolean;
         defaultIfNull?: number;
         getSelection?: (target: any) => number;
@@ -1502,7 +1502,7 @@ declare module BABYLON.NodeEditor {
         useEuler?: boolean;
         onChange?: (value: number) => void;
         onInput?: (value: number) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         decimalCount?: number;
         globalState: GlobalState;
     }
@@ -1530,7 +1530,7 @@ declare module BABYLON.NodeEditor {
         multilines?: boolean;
         onChange?: (value: string) => void;
         validator?: (value: string) => boolean;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
         value: string;
@@ -1564,7 +1564,7 @@ declare module BABYLON.NodeEditor {
 
 
     interface ITextureLineComponentProps {
-        texture: BaseTexture;
+        texture: BABYLON.BaseTexture;
         width: number;
         height: number;
         globalState?: any;
@@ -1584,7 +1584,7 @@ declare module BABYLON.NodeEditor {
         componentDidMount(): void;
         componentDidUpdate(): void;
         updatePreview(): void;
-        static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;
+        static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BABYLON.BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): Promise<void>;
         render(): JSX.Element;
     }
 
@@ -1594,13 +1594,13 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: Vector2) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: BABYLON.Vector2) => void;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         globalState: GlobalState;
     }
     export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
         isExpanded: boolean;
-        value: Vector2;
+        value: BABYLON.Vector2;
     }> {
         static defaultProps: {
             step: number;
@@ -1609,10 +1609,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector2LineComponentProps);
         shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: Vector2;
+            value: BABYLON.Vector2;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: Vector2): void;
+        raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
         render(): JSX.Element;
@@ -1624,13 +1624,13 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: Vector3) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: BABYLON.Vector3) => void;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         globalState: GlobalState;
     }
     export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
         isExpanded: boolean;
-        value: Vector3;
+        value: BABYLON.Vector3;
     }> {
         static defaultProps: {
             step: number;
@@ -1639,10 +1639,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector3LineComponentProps);
         shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: Vector3;
+            value: BABYLON.Vector3;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: Vector3): void;
+        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
         updateVector3(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -1655,15 +1655,15 @@ declare module BABYLON.NodeEditor {
         label: string;
         target?: any;
         propertyName?: string;
-        value?: Vector4;
+        value?: BABYLON.Vector4;
         step?: number;
-        onChange?: (newvalue: Vector4) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: BABYLON.Vector4) => void;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         globalState: GlobalState;
     }
     export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
         isExpanded: boolean;
-        value: Vector4;
+        value: BABYLON.Vector4;
     }> {
         static defaultProps: {
             step: number;
@@ -1672,10 +1672,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector4LineComponentProps);
         shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: Vector4;
+            value: BABYLON.Vector4;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: Vector4): void;
+        raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
         updateVector4(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -1788,13 +1788,13 @@ declare module BABYLON.NodeEditor {
         isSelected?: () => boolean;
         onSelect?: (value: boolean) => void;
         onValueChanged?: () => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         disabled?: boolean;
         icon?: string;
         iconLabel?: string;
         faIcons?: {
-            enabled: IconDefinition;
-            disabled: IconDefinition;
+            enabled: any;
+            disabled: any;
         };
         large?: boolean;
     }
@@ -1819,7 +1819,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         isLinear?: boolean;
         icon?: string;
         lockObject?: LockObject;
@@ -1835,7 +1835,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target?: any;
         propertyName: string;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         onChange?: () => void;
         isLinear?: boolean;
         icon?: string;
@@ -1851,7 +1851,7 @@ declare module BABYLON.NodeEditor {
         label: string;
         target?: any;
         propertyName: string;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         onChange?: () => void;
         isLinear?: boolean;
         icon?: string;
@@ -1884,7 +1884,7 @@ declare module BABYLON.NodeEditor {
 
 
     export interface IColorPickerComponentProps {
-        value: Color4 | Color3;
+        value: BABYLON.Color4 | BABYLON.Color3;
         linearHint?: boolean;
         onColorChanged: (newOne: string) => void;
         icon?: string;
@@ -1893,7 +1893,7 @@ declare module BABYLON.NodeEditor {
     }
     interface IColorPickerComponentState {
         pickerEnabled: boolean;
-        color: Color3 | Color4;
+        color: BABYLON.Color3 | BABYLON.Color4;
         hex: string;
     }
     export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
@@ -1962,7 +1962,7 @@ declare module BABYLON.NodeEditor {
         lockObject?: LockObject;
         onChange?: (newValue: number) => void;
         isInteger?: boolean;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         additionalClass?: string;
         step?: string;
         digits?: number;
@@ -1976,6 +1976,8 @@ declare module BABYLON.NodeEditor {
         defaultValue?: number;
         arrows?: boolean;
         unit?: React.ReactNode;
+        onDragStart?: (newValue: number) => void;
+        onDragStop?: (newValue: number) => void;
     }
     export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
         value: string;
@@ -2008,7 +2010,7 @@ declare module BABYLON.NodeEditor {
         onChange?: (newValue: number) => void;
         isInteger?: boolean;
         replaySourceReplacement?: string;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         additionalClass?: string;
         step?: string;
         digits?: number;
@@ -2116,7 +2118,7 @@ declare module BABYLON.NodeEditor {
         buttonLabel: string;
         url?: string;
         onClick: () => void;
-        icon?: IconProp;
+        icon?: any;
         onIconClick?: () => void;
     }
     export class LinkButtonComponent extends React.Component<ILinkButtonComponentProps> {
@@ -2129,7 +2131,7 @@ declare module BABYLON.NodeEditor {
     interface IMessageLineComponentProps {
         text: string;
         color?: string;
-        icon?: IconProp;
+        icon?: any;
     }
     export class MessageLineComponent extends React.Component<IMessageLineComponentProps> {
         constructor(props: IMessageLineComponentProps);
@@ -2168,11 +2170,11 @@ declare module BABYLON.NodeEditor {
         label: string;
         target: any;
         propertyName: string;
-        options: IInspectableOptions[];
+        options: BABYLON.IInspectableOptions[];
         noDirectUpdate?: boolean;
         onSelect?: (value: number) => void;
         extractValue?: () => number;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         allowNullValue?: boolean;
         icon?: string;
         iconLabel?: string;
@@ -2200,7 +2202,7 @@ declare module BABYLON.NodeEditor {
 
 
     interface IRadioButtonLineComponentProps {
-        onSelectionChangedObservable: Observable<RadioButtonLineComponent>;
+        onSelectionChangedObservable: BABYLON.Observable<RadioButtonLineComponent>;
         label: string;
         isSelected: () => boolean;
         onSelect: () => void;
@@ -2230,7 +2232,7 @@ declare module BABYLON.NodeEditor {
         useEuler?: boolean;
         onChange?: (value: number) => void;
         onInput?: (value: number) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         decimalCount?: number;
         margin?: boolean;
         icon?: string;
@@ -2261,7 +2263,7 @@ declare module BABYLON.NodeEditor {
      * @param getProperty
      * @returns a proxy object that can be passed as a target into the input
      */
-    export function makeTargetsProxy<Type>(targets: Type[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>, getProperty?: (target: Type, property: keyof Type) => any): any;
+    export function makeTargetsProxy<Type>(targets: Type[], onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>, getProperty?: (target: Type, property: keyof Type) => any): any;
 
 
     export interface ITextInputLineComponentProps {
@@ -2271,7 +2273,7 @@ declare module BABYLON.NodeEditor {
         propertyName?: string;
         value?: string;
         onChange?: (value: string) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
         noUnderline?: boolean;
@@ -2357,14 +2359,14 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: Vector2) => void;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onChange?: (newvalue: BABYLON.Vector2) => void;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
     }
     export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
         isExpanded: boolean;
-        value: Vector2;
+        value: BABYLON.Vector2;
     }> {
         static defaultProps: {
             step: number;
@@ -2373,10 +2375,10 @@ declare module BABYLON.NodeEditor {
         constructor(props: IVector2LineComponentProps);
         shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: Vector2;
+            value: BABYLON.Vector2;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: Vector2): void;
+        raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
         render(): JSX.Element;
@@ -2388,16 +2390,16 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: Vector3) => void;
+        onChange?: (newvalue: BABYLON.Vector3) => void;
         useEuler?: boolean;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         noSlider?: boolean;
         icon?: string;
         iconLabel?: string;
     }
     export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
         isExpanded: boolean;
-        value: Vector3;
+        value: BABYLON.Vector3;
     }> {
         static defaultProps: {
             step: number;
@@ -2407,10 +2409,10 @@ declare module BABYLON.NodeEditor {
         getCurrentValue(): any;
         shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: Vector3;
+            value: BABYLON.Vector3;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: Vector3): void;
+        raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
         updateVector3(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -2424,15 +2426,15 @@ declare module BABYLON.NodeEditor {
         target: any;
         propertyName: string;
         step?: number;
-        onChange?: (newvalue: Vector4) => void;
+        onChange?: (newvalue: BABYLON.Vector4) => void;
         useEuler?: boolean;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
         icon?: string;
         iconLabel?: string;
     }
     export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
         isExpanded: boolean;
-        value: Vector4;
+        value: BABYLON.Vector4;
     }> {
         static defaultProps: {
             step: number;
@@ -2442,10 +2444,10 @@ declare module BABYLON.NodeEditor {
         getCurrentValue(): any;
         shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
             isExpanded: boolean;
-            value: Vector4;
+            value: BABYLON.Vector4;
         }): boolean;
         switchExpandState(): void;
-        raiseOnPropertyChanged(previousValue: Vector4): void;
+        raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
         updateVector4(): void;
         updateStateX(value: number): void;
         updateStateY(value: number): void;
@@ -2478,9 +2480,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ICheckboxPropertyGridComponentProps {
-        checkbox: Checkbox;
+        checkbox: BABYLON.GUI.Checkbox;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
         constructor(props: ICheckboxPropertyGridComponentProps);
@@ -2489,9 +2491,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IColorPickerPropertyGridComponentProps {
-        colorPicker: ColorPicker;
+        colorPicker: BABYLON.GUI.ColorPicker;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
         constructor(props: IColorPickerPropertyGridComponentProps);
@@ -2503,7 +2505,7 @@ declare module BABYLON.NodeEditor {
         controls?: BABYLON.GUI.Control[];
         control?: BABYLON.GUI.Control;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
         constructor(props: ICommonControlPropertyGridComponentProps);
@@ -2513,9 +2515,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IControlPropertyGridComponentProps {
-        control: Control;
+        control: BABYLON.GUI.Control;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
         constructor(props: IControlPropertyGridComponentProps);
@@ -2524,9 +2526,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IEllipsePropertyGridComponentProps {
-        ellipse: Ellipse;
+        ellipse: BABYLON.GUI.Ellipse;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
         constructor(props: IEllipsePropertyGridComponentProps);
@@ -2535,9 +2537,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IGridPropertyGridComponentProps {
-        grid: Grid;
+        grid: BABYLON.GUI.Grid;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
         constructor(props: IGridPropertyGridComponentProps);
@@ -2548,9 +2550,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IImageBasedSliderPropertyGridComponentProps {
-        imageBasedSlider: ImageBasedSlider;
+        imageBasedSlider: BABYLON.GUI.ImageBasedSlider;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
         constructor(props: IImageBasedSliderPropertyGridComponentProps);
@@ -2561,7 +2563,7 @@ declare module BABYLON.NodeEditor {
     interface IImagePropertyGridComponentProps {
         image: BABYLON.GUI.Image;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
         constructor(props: IImagePropertyGridComponentProps);
@@ -2570,9 +2572,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IInputTextPropertyGridComponentProps {
-        inputText: InputText;
+        inputText: BABYLON.GUI.InputText;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
         constructor(props: IInputTextPropertyGridComponentProps);
@@ -2581,9 +2583,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ILinePropertyGridComponentProps {
-        line: Line;
+        line: BABYLON.GUI.Line;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
         constructor(props: ILinePropertyGridComponentProps);
@@ -2593,9 +2595,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IRadioButtonPropertyGridComponentProps {
-        radioButtons: RadioButton[];
+        radioButtons: BABYLON.GUI.RadioButton[];
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
         constructor(props: IRadioButtonPropertyGridComponentProps);
@@ -2604,9 +2606,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IRectanglePropertyGridComponentProps {
-        rectangle: Rectangle;
+        rectangle: BABYLON.GUI.Rectangle;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
         constructor(props: IRectanglePropertyGridComponentProps);
@@ -2615,9 +2617,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IScrollViewerPropertyGridComponentProps {
-        scrollViewer: ScrollViewer;
+        scrollViewer: BABYLON.GUI.ScrollViewer;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
         constructor(props: IScrollViewerPropertyGridComponentProps);
@@ -2626,9 +2628,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ISliderPropertyGridComponentProps {
-        slider: Slider;
+        slider: BABYLON.GUI.Slider;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
         constructor(props: ISliderPropertyGridComponentProps);
@@ -2637,9 +2639,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface IStackPanelPropertyGridComponentProps {
-        stackPanel: StackPanel;
+        stackPanel: BABYLON.GUI.StackPanel;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
         constructor(props: IStackPanelPropertyGridComponentProps);
@@ -2648,9 +2650,9 @@ declare module BABYLON.NodeEditor {
 
 
     interface ITextBlockPropertyGridComponentProps {
-        textBlock: TextBlock;
+        textBlock: BABYLON.GUI.TextBlock;
         lockObject: LockObject;
-        onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
+        onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
     }
     export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
         constructor(props: ITextBlockPropertyGridComponentProps);