babylon.nodeEditor.module.d.ts 119 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851
  1. /// <reference types="react" />
  2. declare module "babylonjs-node-editor/blockTools" {
  3. import { DiscardBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/discardBlock';
  4. import { BonesBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/bonesBlock';
  5. import { InstancesBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/instancesBlock';
  6. import { MorphTargetsBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/morphTargetsBlock';
  7. import { ImageProcessingBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/imageProcessingBlock';
  8. import { ColorMergerBlock } from 'babylonjs/Materials/Node/Blocks/colorMergerBlock';
  9. import { VectorMergerBlock } from 'babylonjs/Materials/Node/Blocks/vectorMergerBlock';
  10. import { ColorSplitterBlock } from 'babylonjs/Materials/Node/Blocks/colorSplitterBlock';
  11. import { VectorSplitterBlock } from 'babylonjs/Materials/Node/Blocks/vectorSplitterBlock';
  12. import { RemapBlock } from 'babylonjs/Materials/Node/Blocks/remapBlock';
  13. import { TextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/textureBlock';
  14. import { ReflectionTextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock';
  15. import { LightBlock } from 'babylonjs/Materials/Node/Blocks/Dual/lightBlock';
  16. import { FogBlock } from 'babylonjs/Materials/Node/Blocks/Dual/fogBlock';
  17. import { VertexOutputBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/vertexOutputBlock';
  18. import { FragmentOutputBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/fragmentOutputBlock';
  19. import { NormalizeBlock } from 'babylonjs/Materials/Node/Blocks/normalizeBlock';
  20. import { AddBlock } from 'babylonjs/Materials/Node/Blocks/addBlock';
  21. import { ScaleBlock } from 'babylonjs/Materials/Node/Blocks/scaleBlock';
  22. import { TrigonometryBlock } from 'babylonjs/Materials/Node/Blocks/trigonometryBlock';
  23. import { ClampBlock } from 'babylonjs/Materials/Node/Blocks/clampBlock';
  24. import { CrossBlock } from 'babylonjs/Materials/Node/Blocks/crossBlock';
  25. import { DotBlock } from 'babylonjs/Materials/Node/Blocks/dotBlock';
  26. import { MultiplyBlock } from 'babylonjs/Materials/Node/Blocks/multiplyBlock';
  27. import { TransformBlock } from 'babylonjs/Materials/Node/Blocks/transformBlock';
  28. import { NodeMaterialBlockConnectionPointTypes } from 'babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes';
  29. import { FresnelBlock } from 'babylonjs/Materials/Node/Blocks/fresnelBlock';
  30. import { LerpBlock } from 'babylonjs/Materials/Node/Blocks/lerpBlock';
  31. import { NLerpBlock } from 'babylonjs/Materials/Node/Blocks/nLerpBlock';
  32. import { DivideBlock } from 'babylonjs/Materials/Node/Blocks/divideBlock';
  33. import { SubtractBlock } from 'babylonjs/Materials/Node/Blocks/subtractBlock';
  34. import { StepBlock } from 'babylonjs/Materials/Node/Blocks/stepBlock';
  35. import { SmoothStepBlock } from 'babylonjs/Materials/Node/Blocks/smoothStepBlock';
  36. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  37. import { OneMinusBlock } from 'babylonjs/Materials/Node/Blocks/oneMinusBlock';
  38. import { ViewDirectionBlock } from 'babylonjs/Materials/Node/Blocks/viewDirectionBlock';
  39. import { LightInformationBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/lightInformationBlock';
  40. import { MaxBlock } from 'babylonjs/Materials/Node/Blocks/maxBlock';
  41. import { MinBlock } from 'babylonjs/Materials/Node/Blocks/minBlock';
  42. import { PerturbNormalBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/perturbNormalBlock';
  43. import { LengthBlock } from 'babylonjs/Materials/Node/Blocks/lengthBlock';
  44. import { DistanceBlock } from 'babylonjs/Materials/Node/Blocks/distanceBlock';
  45. import { FrontFacingBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/frontFacingBlock';
  46. import { NegateBlock } from 'babylonjs/Materials/Node/Blocks/negateBlock';
  47. import { PowBlock } from 'babylonjs/Materials/Node/Blocks/powBlock';
  48. import { Scene } from 'babylonjs/scene';
  49. import { RandomNumberBlock } from 'babylonjs/Materials/Node/Blocks/randomNumberBlock';
  50. import { ReplaceColorBlock } from 'babylonjs/Materials/Node/Blocks/replaceColorBlock';
  51. import { PosterizeBlock } from 'babylonjs/Materials/Node/Blocks/posterizeBlock';
  52. import { ArcTan2Block } from 'babylonjs/Materials/Node/Blocks/arcTan2Block';
  53. import { ReciprocalBlock } from 'babylonjs/Materials/Node/Blocks/reciprocalBlock';
  54. import { GradientBlock } from 'babylonjs/Materials/Node/Blocks/gradientBlock';
  55. import { WaveBlock } from 'babylonjs/Materials/Node/Blocks/waveBlock';
  56. import { NodeMaterial } from 'babylonjs/Materials/Node/nodeMaterial';
  57. import { WorleyNoise3DBlock } from 'babylonjs/Materials/Node/Blocks/worleyNoise3DBlock';
  58. import { SimplexPerlin3DBlock } from 'babylonjs/Materials/Node/Blocks/simplexPerlin3DBlock';
  59. import { NormalBlendBlock } from 'babylonjs/Materials/Node/Blocks/normalBlendBlock';
  60. import { Rotate2dBlock } from 'babylonjs/Materials/Node/Blocks/rotate2dBlock';
  61. import { DerivativeBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/derivativeBlock';
  62. import { RefractBlock } from 'babylonjs/Materials/Node/Blocks/refractBlock';
  63. import { ReflectBlock } from 'babylonjs/Materials/Node/Blocks/reflectBlock';
  64. import { DesaturateBlock } from 'babylonjs/Materials/Node/Blocks/desaturateBlock';
  65. export class BlockTools {
  66. static GetBlockFromString(data: string, scene: Scene, nodeMaterial: NodeMaterial): DesaturateBlock | RefractBlock | ReflectBlock | DerivativeBlock | Rotate2dBlock | NormalBlendBlock | WorleyNoise3DBlock | SimplexPerlin3DBlock | BonesBlock | InstancesBlock | MorphTargetsBlock | DiscardBlock | ImageProcessingBlock | ColorMergerBlock | VectorMergerBlock | ColorSplitterBlock | VectorSplitterBlock | TextureBlock | ReflectionTextureBlock | LightBlock | FogBlock | VertexOutputBlock | FragmentOutputBlock | AddBlock | ClampBlock | ScaleBlock | CrossBlock | DotBlock | PowBlock | MultiplyBlock | TransformBlock | TrigonometryBlock | RemapBlock | NormalizeBlock | FresnelBlock | LerpBlock | NLerpBlock | DivideBlock | SubtractBlock | StepBlock | SmoothStepBlock | OneMinusBlock | ReciprocalBlock | ViewDirectionBlock | LightInformationBlock | MaxBlock | MinBlock | LengthBlock | DistanceBlock | NegateBlock | PerturbNormalBlock | RandomNumberBlock | ReplaceColorBlock | PosterizeBlock | ArcTan2Block | GradientBlock | FrontFacingBlock | WaveBlock | InputBlock | null;
  67. static GetColorFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): string;
  68. static GetConnectionNodeTypeFromString(type: string): NodeMaterialBlockConnectionPointTypes.Float | NodeMaterialBlockConnectionPointTypes.Vector2 | NodeMaterialBlockConnectionPointTypes.Vector3 | NodeMaterialBlockConnectionPointTypes.Vector4 | NodeMaterialBlockConnectionPointTypes.Color3 | NodeMaterialBlockConnectionPointTypes.Color4 | NodeMaterialBlockConnectionPointTypes.Matrix | NodeMaterialBlockConnectionPointTypes.AutoDetect;
  69. static GetStringFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4" | "";
  70. }
  71. }
  72. declare module "babylonjs-node-editor/dataStorage" {
  73. export class DataStorage {
  74. private static _InMemoryStorage;
  75. static ReadBoolean(key: string, defaultValue: boolean): boolean;
  76. static StoreBoolean(key: string, value: boolean): void;
  77. static ReadNumber(key: string, defaultValue: number): number;
  78. static StoreNumber(key: string, value: number): void;
  79. }
  80. }
  81. declare module "babylonjs-node-editor/components/log/logComponent" {
  82. import * as React from "react";
  83. import { GlobalState } from "babylonjs-node-editor/globalState";
  84. interface ILogComponentProps {
  85. globalState: GlobalState;
  86. }
  87. export class LogEntry {
  88. message: string;
  89. isError: boolean;
  90. constructor(message: string, isError: boolean);
  91. }
  92. export class LogComponent extends React.Component<ILogComponentProps, {
  93. logs: LogEntry[];
  94. }> {
  95. constructor(props: ILogComponentProps);
  96. componentDidMount(): void;
  97. componentDidUpdate(): void;
  98. render(): JSX.Element;
  99. }
  100. }
  101. declare module "babylonjs-node-editor/components/preview/previewMeshType" {
  102. export enum PreviewMeshType {
  103. Sphere = 0,
  104. Box = 1,
  105. Torus = 2,
  106. Cylinder = 3,
  107. Plane = 4,
  108. ShaderBall = 5,
  109. Custom = 6
  110. }
  111. }
  112. declare module "babylonjs-node-editor/diagram/display/displayManager" {
  113. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  114. export interface IDisplayManager {
  115. getHeaderClass(block: NodeMaterialBlock): string;
  116. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  117. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  118. getBackgroundColor(block: NodeMaterialBlock): string;
  119. getHeaderText(block: NodeMaterialBlock): string;
  120. }
  121. }
  122. declare module "babylonjs-node-editor/diagram/nodePort" {
  123. import { NodeMaterialConnectionPoint } from 'babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint';
  124. import { GlobalState } from "babylonjs-node-editor/globalState";
  125. import { Nullable } from 'babylonjs/types';
  126. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  127. import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
  128. export class NodePort {
  129. connectionPoint: NodeMaterialConnectionPoint;
  130. node: GraphNode;
  131. private _element;
  132. private _img;
  133. private _globalState;
  134. private _onCandidateLinkMovedObserver;
  135. delegatedPort: Nullable<NodePort>;
  136. get element(): HTMLDivElement;
  137. refresh(): void;
  138. constructor(portContainer: HTMLElement, connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
  139. dispose(): void;
  140. static CreatePortElement(connectionPoint: NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
  141. }
  142. }
  143. declare module "babylonjs-node-editor/nodeLocationInfo" {
  144. export interface INodeLocationInfo {
  145. blockId: number;
  146. x: number;
  147. y: number;
  148. }
  149. export interface IFrameData {
  150. x: number;
  151. y: number;
  152. width: number;
  153. height: number;
  154. color: number[];
  155. name: string;
  156. isCollapsed: boolean;
  157. blocks: number[];
  158. }
  159. export interface IEditorData {
  160. locations: INodeLocationInfo[];
  161. x: number;
  162. y: number;
  163. zoom: number;
  164. frames?: IFrameData[];
  165. map?: {
  166. [key: number]: number;
  167. };
  168. }
  169. }
  170. declare module "babylonjs-node-editor/serializationTools" {
  171. import { NodeMaterial } from 'babylonjs/Materials/Node/nodeMaterial';
  172. import { GlobalState } from "babylonjs-node-editor/globalState";
  173. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  174. export class SerializationTools {
  175. static UpdateLocations(material: NodeMaterial, globalState: GlobalState): void;
  176. static Serialize(material: NodeMaterial, globalState: GlobalState, selectedBlocks?: NodeMaterialBlock[]): string;
  177. static Deserialize(serializationObject: any, globalState: GlobalState): void;
  178. }
  179. }
  180. declare module "babylonjs-node-editor/stringTools" {
  181. import { NodeMaterialBlockConnectionPointTypes } from 'babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes';
  182. export class StringTools {
  183. private static _SaveAs;
  184. private static _Click;
  185. /**
  186. * Gets the base math type of node material block connection point.
  187. * @param type Type to parse.
  188. */
  189. static GetBaseType(type: NodeMaterialBlockConnectionPointTypes): string;
  190. /**
  191. * Download a string into a file that will be saved locally by the browser
  192. * @param content defines the string to download locally as a file
  193. */
  194. static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
  195. }
  196. }
  197. declare module "babylonjs-node-editor/diagram/graphFrame" {
  198. import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
  199. import { GraphCanvasComponent } from "babylonjs-node-editor/diagram/graphCanvas";
  200. import { Nullable } from 'babylonjs/types';
  201. import { Observable } from 'babylonjs/Misc/observable';
  202. import { IFrameData } from "babylonjs-node-editor/nodeLocationInfo";
  203. import { Color3 } from 'babylonjs/Maths/math.color';
  204. export class GraphFrame {
  205. private readonly CollapsedWidth;
  206. private static _FrameCounter;
  207. private _name;
  208. private _color;
  209. private _x;
  210. private _y;
  211. private _gridAlignedX;
  212. private _gridAlignedY;
  213. private _width;
  214. private _height;
  215. element: HTMLDivElement;
  216. private _borderElement;
  217. private _headerElement;
  218. private _headerTextElement;
  219. private _headerCollapseElement;
  220. private _headerCloseElement;
  221. private _portContainer;
  222. private _outputPortContainer;
  223. private _inputPortContainer;
  224. private _nodes;
  225. private _ownerCanvas;
  226. private _mouseStartPointX;
  227. private _mouseStartPointY;
  228. private _onSelectionChangedObserver;
  229. private _isCollapsed;
  230. private _ports;
  231. private _controlledPorts;
  232. private _id;
  233. onExpandStateChanged: Observable<GraphFrame>;
  234. private readonly CloseSVG;
  235. private readonly ExpandSVG;
  236. private readonly CollapseSVG;
  237. get id(): number;
  238. get isCollapsed(): boolean;
  239. private _createInputPort;
  240. set isCollapsed(value: boolean);
  241. get nodes(): GraphNode[];
  242. get name(): string;
  243. set name(value: string);
  244. get color(): Color3;
  245. set color(value: Color3);
  246. get x(): number;
  247. set x(value: number);
  248. get y(): number;
  249. set y(value: number);
  250. get width(): number;
  251. set width(value: number);
  252. get height(): number;
  253. set height(value: number);
  254. constructor(candidate: Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
  255. refresh(): void;
  256. addNode(node: GraphNode): void;
  257. removeNode(node: GraphNode): void;
  258. syncNode(node: GraphNode): void;
  259. cleanAccumulation(): void;
  260. private _onDown;
  261. move(newX: number, newY: number, align?: boolean): void;
  262. private _onUp;
  263. private _moveFrame;
  264. private _onMove;
  265. dispose(): void;
  266. serialize(): IFrameData;
  267. export(): void;
  268. static Parse(serializationData: IFrameData, canvas: GraphCanvasComponent, map?: {
  269. [key: number]: number;
  270. }): GraphFrame;
  271. }
  272. }
  273. declare module "babylonjs-node-editor/diagram/nodeLink" {
  274. import { GraphCanvasComponent } from "babylonjs-node-editor/diagram/graphCanvas";
  275. import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
  276. import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
  277. import { Observable } from 'babylonjs/Misc/observable';
  278. export class NodeLink {
  279. private _graphCanvas;
  280. private _portA;
  281. private _portB?;
  282. private _nodeA;
  283. private _nodeB?;
  284. private _path;
  285. private _selectionPath;
  286. private _onSelectionChangedObserver;
  287. private _isVisible;
  288. onDisposedObservable: Observable<NodeLink>;
  289. get isVisible(): boolean;
  290. set isVisible(value: boolean);
  291. get portA(): NodePort;
  292. get portB(): NodePort | undefined;
  293. get nodeA(): GraphNode;
  294. get nodeB(): GraphNode | undefined;
  295. update(endX?: number, endY?: number, straight?: boolean): void;
  296. constructor(graphCanvas: GraphCanvasComponent, portA: NodePort, nodeA: GraphNode, portB?: NodePort, nodeB?: GraphNode);
  297. onClick(): void;
  298. dispose(): void;
  299. }
  300. }
  301. declare module "babylonjs-node-editor/diagram/graphCanvas" {
  302. import * as React from "react";
  303. import { GlobalState } from "babylonjs-node-editor/globalState";
  304. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  305. import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
  306. import { Nullable } from 'babylonjs/types';
  307. import { NodeLink } from "babylonjs-node-editor/diagram/nodeLink";
  308. import { NodeMaterialConnectionPoint } from 'babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint';
  309. import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
  310. import { IEditorData } from "babylonjs-node-editor/nodeLocationInfo";
  311. export interface IGraphCanvasComponentProps {
  312. globalState: GlobalState;
  313. }
  314. export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> {
  315. private readonly MinZoom;
  316. private readonly MaxZoom;
  317. private _hostCanvas;
  318. private _graphCanvas;
  319. private _selectionContainer;
  320. private _frameContainer;
  321. private _svgCanvas;
  322. private _rootContainer;
  323. private _nodes;
  324. private _links;
  325. private _mouseStartPointX;
  326. private _mouseStartPointY;
  327. private _dropPointX;
  328. private _dropPointY;
  329. private _selectionStartX;
  330. private _selectionStartY;
  331. private _x;
  332. private _y;
  333. private _zoom;
  334. private _selectedNodes;
  335. private _selectedLink;
  336. private _candidateLink;
  337. private _candidatePort;
  338. private _gridSize;
  339. private _selectionBox;
  340. private _selectedFrame;
  341. private _frameCandidate;
  342. private _frames;
  343. private _altKeyIsPressed;
  344. private _ctrlKeyIsPressed;
  345. private _oldY;
  346. _frameIsMoving: boolean;
  347. get gridSize(): number;
  348. set gridSize(value: number);
  349. get globalState(): GlobalState;
  350. get nodes(): GraphNode[];
  351. get links(): NodeLink[];
  352. get frames(): GraphFrame[];
  353. get zoom(): number;
  354. set zoom(value: number);
  355. get x(): number;
  356. set x(value: number);
  357. get y(): number;
  358. set y(value: number);
  359. get selectedNodes(): GraphNode[];
  360. get selectedLink(): Nullable<NodeLink>;
  361. get selectedFrame(): Nullable<GraphFrame>;
  362. get canvasContainer(): HTMLDivElement;
  363. get svgCanvas(): HTMLElement;
  364. get selectionContainer(): HTMLDivElement;
  365. get frameContainer(): HTMLDivElement;
  366. constructor(props: IGraphCanvasComponentProps);
  367. getGridPosition(position: number, useCeil?: boolean): number;
  368. getGridPositionCeil(position: number): number;
  369. updateTransform(): void;
  370. onKeyUp(): void;
  371. findNodeFromBlock(block: NodeMaterialBlock): GraphNode;
  372. reset(): void;
  373. connectPorts(pointA: NodeMaterialConnectionPoint, pointB: NodeMaterialConnectionPoint): void;
  374. removeLink(link: NodeLink): void;
  375. appendBlock(block: NodeMaterialBlock): GraphNode;
  376. distributeGraph(): void;
  377. componentDidMount(): void;
  378. onMove(evt: React.PointerEvent): void;
  379. onDown(evt: React.PointerEvent<HTMLElement>): void;
  380. onUp(evt: React.PointerEvent): void;
  381. onWheel(evt: React.WheelEvent): void;
  382. zoomToFit(): void;
  383. processCandidatePort(): void;
  384. processEditorData(editorData: IEditorData): void;
  385. render(): JSX.Element;
  386. }
  387. }
  388. declare module "babylonjs-node-editor/sharedComponents/propertyChangedEvent" {
  389. export class PropertyChangedEvent {
  390. object: any;
  391. property: string;
  392. value: any;
  393. initialValue: any;
  394. }
  395. }
  396. declare module "babylonjs-node-editor/sharedComponents/floatLineComponent" {
  397. import * as React from "react";
  398. import { Observable } from "babylonjs/Misc/observable";
  399. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  400. interface IFloatLineComponentProps {
  401. label: string;
  402. target: any;
  403. propertyName: string;
  404. onChange?: (newValue: number) => void;
  405. isInteger?: boolean;
  406. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  407. additionalClass?: string;
  408. step?: string;
  409. digits?: number;
  410. }
  411. export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
  412. value: string;
  413. }> {
  414. private _localChange;
  415. private _store;
  416. constructor(props: IFloatLineComponentProps);
  417. shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
  418. value: string;
  419. }): boolean;
  420. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  421. updateValue(valueString: string): void;
  422. render(): JSX.Element;
  423. }
  424. }
  425. declare module "babylonjs-node-editor/components/propertyTab/properties/floatPropertyTabComponent" {
  426. import * as React from "react";
  427. import { GlobalState } from "babylonjs-node-editor/globalState";
  428. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  429. interface IFloatPropertyTabComponentProps {
  430. globalState: GlobalState;
  431. inputBlock: InputBlock;
  432. }
  433. export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
  434. render(): JSX.Element;
  435. }
  436. }
  437. declare module "babylonjs-node-editor/sharedComponents/sliderLineComponent" {
  438. import * as React from "react";
  439. import { Observable } from "babylonjs/Misc/observable";
  440. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  441. interface ISliderLineComponentProps {
  442. label: string;
  443. target?: any;
  444. propertyName?: string;
  445. minimum: number;
  446. maximum: number;
  447. step: number;
  448. directValue?: number;
  449. useEuler?: boolean;
  450. onChange?: (value: number) => void;
  451. onInput?: (value: number) => void;
  452. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  453. decimalCount?: number;
  454. }
  455. export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
  456. value: number;
  457. }> {
  458. private _localChange;
  459. constructor(props: ISliderLineComponentProps);
  460. shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
  461. value: number;
  462. }): boolean;
  463. onChange(newValueString: any): void;
  464. onInput(newValueString: any): void;
  465. prepareDataToRead(value: number): number;
  466. render(): JSX.Element;
  467. }
  468. }
  469. declare module "babylonjs-node-editor/sharedComponents/numericInputComponent" {
  470. import * as React from "react";
  471. import { GlobalState } from "babylonjs-node-editor/globalState";
  472. interface INumericInputComponentProps {
  473. label: string;
  474. value: number;
  475. step?: number;
  476. onChange: (value: number) => void;
  477. globalState: GlobalState;
  478. }
  479. export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
  480. value: string;
  481. }> {
  482. static defaultProps: {
  483. step: number;
  484. };
  485. private _localChange;
  486. constructor(props: INumericInputComponentProps);
  487. shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
  488. value: string;
  489. }): boolean;
  490. updateValue(evt: any): void;
  491. render(): JSX.Element;
  492. }
  493. }
  494. declare module "babylonjs-node-editor/sharedComponents/vector2LineComponent" {
  495. import * as React from "react";
  496. import { Vector2 } from "babylonjs/Maths/math";
  497. import { Observable } from "babylonjs/Misc/observable";
  498. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  499. import { GlobalState } from "babylonjs-node-editor/globalState";
  500. interface IVector2LineComponentProps {
  501. label: string;
  502. target: any;
  503. propertyName: string;
  504. step?: number;
  505. onChange?: (newvalue: Vector2) => void;
  506. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  507. globalState: GlobalState;
  508. }
  509. export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
  510. isExpanded: boolean;
  511. value: Vector2;
  512. }> {
  513. static defaultProps: {
  514. step: number;
  515. };
  516. private _localChange;
  517. constructor(props: IVector2LineComponentProps);
  518. shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
  519. isExpanded: boolean;
  520. value: Vector2;
  521. }): boolean;
  522. switchExpandState(): void;
  523. raiseOnPropertyChanged(previousValue: Vector2): void;
  524. updateStateX(value: number): void;
  525. updateStateY(value: number): void;
  526. render(): JSX.Element;
  527. }
  528. }
  529. declare module "babylonjs-node-editor/components/propertyTab/properties/vector2PropertyTabComponent" {
  530. import * as React from "react";
  531. import { GlobalState } from "babylonjs-node-editor/globalState";
  532. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  533. interface IVector2PropertyTabComponentProps {
  534. globalState: GlobalState;
  535. inputBlock: InputBlock;
  536. }
  537. export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
  538. render(): JSX.Element;
  539. }
  540. }
  541. declare module "babylonjs-node-editor/sharedComponents/color3LineComponent" {
  542. import * as React from "react";
  543. import { Observable } from "babylonjs/Misc/observable";
  544. import { Color3 } from "babylonjs/Maths/math";
  545. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  546. import { GlobalState } from "babylonjs-node-editor/globalState";
  547. export interface IColor3LineComponentProps {
  548. label: string;
  549. target: any;
  550. propertyName: string;
  551. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  552. onChange?: () => void;
  553. globalState: GlobalState;
  554. }
  555. export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
  556. isExpanded: boolean;
  557. color: Color3;
  558. }> {
  559. private _localChange;
  560. constructor(props: IColor3LineComponentProps);
  561. shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
  562. color: Color3;
  563. }): boolean;
  564. onChange(newValue: string): void;
  565. switchExpandState(): void;
  566. raiseOnPropertyChanged(previousValue: Color3): void;
  567. updateStateR(value: number): void;
  568. updateStateG(value: number): void;
  569. updateStateB(value: number): void;
  570. copyToClipboard(): void;
  571. render(): JSX.Element;
  572. }
  573. }
  574. declare module "babylonjs-node-editor/components/propertyTab/properties/color3PropertyTabComponent" {
  575. import * as React from "react";
  576. import { GlobalState } from "babylonjs-node-editor/globalState";
  577. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  578. interface IColor3PropertyTabComponentProps {
  579. globalState: GlobalState;
  580. inputBlock: InputBlock;
  581. }
  582. export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
  583. render(): JSX.Element;
  584. }
  585. }
  586. declare module "babylonjs-node-editor/sharedComponents/vector3LineComponent" {
  587. import * as React from "react";
  588. import { Vector3 } from "babylonjs/Maths/math";
  589. import { Observable } from "babylonjs/Misc/observable";
  590. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  591. import { GlobalState } from "babylonjs-node-editor/globalState";
  592. interface IVector3LineComponentProps {
  593. label: string;
  594. target: any;
  595. propertyName: string;
  596. step?: number;
  597. onChange?: (newvalue: Vector3) => void;
  598. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  599. globalState: GlobalState;
  600. }
  601. export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
  602. isExpanded: boolean;
  603. value: Vector3;
  604. }> {
  605. static defaultProps: {
  606. step: number;
  607. };
  608. private _localChange;
  609. constructor(props: IVector3LineComponentProps);
  610. shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
  611. isExpanded: boolean;
  612. value: Vector3;
  613. }): boolean;
  614. switchExpandState(): void;
  615. raiseOnPropertyChanged(previousValue: Vector3): void;
  616. updateVector3(): void;
  617. updateStateX(value: number): void;
  618. updateStateY(value: number): void;
  619. updateStateZ(value: number): void;
  620. render(): JSX.Element;
  621. }
  622. }
  623. declare module "babylonjs-node-editor/components/propertyTab/properties/vector3PropertyTabComponent" {
  624. import * as React from "react";
  625. import { GlobalState } from "babylonjs-node-editor/globalState";
  626. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  627. interface IVector3PropertyTabComponentProps {
  628. globalState: GlobalState;
  629. inputBlock: InputBlock;
  630. }
  631. export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
  632. render(): JSX.Element;
  633. }
  634. }
  635. declare module "babylonjs-node-editor/sharedComponents/vector4LineComponent" {
  636. import * as React from "react";
  637. import { Vector4 } from "babylonjs/Maths/math";
  638. import { Observable } from "babylonjs/Misc/observable";
  639. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  640. import { GlobalState } from "babylonjs-node-editor/globalState";
  641. interface IVector4LineComponentProps {
  642. label: string;
  643. target?: any;
  644. propertyName?: string;
  645. value?: Vector4;
  646. step?: number;
  647. onChange?: (newvalue: Vector4) => void;
  648. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  649. globalState: GlobalState;
  650. }
  651. export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
  652. isExpanded: boolean;
  653. value: Vector4;
  654. }> {
  655. static defaultProps: {
  656. step: number;
  657. };
  658. private _localChange;
  659. constructor(props: IVector4LineComponentProps);
  660. shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
  661. isExpanded: boolean;
  662. value: Vector4;
  663. }): boolean;
  664. switchExpandState(): void;
  665. raiseOnPropertyChanged(previousValue: Vector4): void;
  666. updateVector4(): void;
  667. updateStateX(value: number): void;
  668. updateStateY(value: number): void;
  669. updateStateZ(value: number): void;
  670. updateStateW(value: number): void;
  671. render(): JSX.Element;
  672. }
  673. }
  674. declare module "babylonjs-node-editor/components/propertyTab/properties/vector4PropertyTabComponent" {
  675. import * as React from "react";
  676. import { GlobalState } from "babylonjs-node-editor/globalState";
  677. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  678. interface IVector4PropertyTabComponentProps {
  679. globalState: GlobalState;
  680. inputBlock: InputBlock;
  681. }
  682. export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
  683. render(): JSX.Element;
  684. }
  685. }
  686. declare module "babylonjs-node-editor/sharedComponents/optionsLineComponent" {
  687. import * as React from "react";
  688. import { Observable } from "babylonjs/Misc/observable";
  689. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  690. class ListLineOption {
  691. label: string;
  692. value: number | string;
  693. }
  694. interface IOptionsLineComponentProps {
  695. label: string;
  696. target: any;
  697. className?: string;
  698. propertyName?: string;
  699. options: ListLineOption[];
  700. noDirectUpdate?: boolean;
  701. onSelect?: (value: number | string) => void;
  702. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  703. valuesAreStrings?: boolean;
  704. defaultIfNull?: number;
  705. getSelection?: (target: any) => number;
  706. }
  707. export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
  708. value: number | string;
  709. }> {
  710. private _localChange;
  711. private _getValue;
  712. constructor(props: IOptionsLineComponentProps);
  713. shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
  714. value: number;
  715. }): boolean;
  716. raiseOnPropertyChanged(newValue: number | string, previousValue: number | string): void;
  717. updateValue(valueString: string): void;
  718. render(): JSX.Element;
  719. }
  720. }
  721. declare module "babylonjs-node-editor/sharedComponents/matrixLineComponent" {
  722. import * as React from "react";
  723. import { Vector3, Matrix, Vector4 } from "babylonjs/Maths/math";
  724. import { Observable } from "babylonjs/Misc/observable";
  725. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  726. import { GlobalState } from "babylonjs-node-editor/globalState";
  727. interface IMatrixLineComponentProps {
  728. label: string;
  729. target: any;
  730. propertyName: string;
  731. step?: number;
  732. onChange?: (newValue: Matrix) => void;
  733. onModeChange?: (mode: number) => void;
  734. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  735. mode?: number;
  736. globalState: GlobalState;
  737. }
  738. export class MatrixLineComponent extends React.Component<IMatrixLineComponentProps, {
  739. value: Matrix;
  740. mode: number;
  741. angle: number;
  742. }> {
  743. private _localChange;
  744. constructor(props: IMatrixLineComponentProps);
  745. shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: {
  746. value: Matrix;
  747. mode: number;
  748. angle: number;
  749. }): boolean;
  750. raiseOnPropertyChanged(previousValue: Vector3): void;
  751. updateMatrix(): void;
  752. updateRow(value: Vector4, row: number): void;
  753. updateBasedOnMode(value: number): void;
  754. render(): JSX.Element;
  755. }
  756. }
  757. declare module "babylonjs-node-editor/components/propertyTab/properties/matrixPropertyTabComponent" {
  758. import * as React from "react";
  759. import { GlobalState } from "babylonjs-node-editor/globalState";
  760. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  761. interface IMatrixPropertyTabComponentProps {
  762. globalState: GlobalState;
  763. inputBlock: InputBlock;
  764. }
  765. export class MatrixPropertyTabComponent extends React.Component<IMatrixPropertyTabComponentProps> {
  766. render(): JSX.Element;
  767. }
  768. }
  769. declare module "babylonjs-node-editor/sharedComponents/lineContainerComponent" {
  770. import * as React from "react";
  771. interface ILineContainerComponentProps {
  772. title: string;
  773. children: any[] | any;
  774. closed?: boolean;
  775. }
  776. export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
  777. isExpanded: boolean;
  778. }> {
  779. constructor(props: ILineContainerComponentProps);
  780. switchExpandedState(): void;
  781. renderHeader(): JSX.Element;
  782. render(): JSX.Element;
  783. }
  784. }
  785. declare module "babylonjs-node-editor/diagram/properties/propertyComponentProps" {
  786. import { GlobalState } from "babylonjs-node-editor/globalState";
  787. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  788. export interface IPropertyComponentProps {
  789. globalState: GlobalState;
  790. block: NodeMaterialBlock;
  791. }
  792. }
  793. declare module "babylonjs-node-editor/sharedComponents/textInputLineComponent" {
  794. import * as React from "react";
  795. import { Observable } from "babylonjs/Misc/observable";
  796. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  797. import { GlobalState } from "babylonjs-node-editor/globalState";
  798. interface ITextInputLineComponentProps {
  799. label: string;
  800. globalState: GlobalState;
  801. target?: any;
  802. propertyName?: string;
  803. value?: string;
  804. onChange?: (value: string) => void;
  805. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  806. }
  807. export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
  808. value: string;
  809. }> {
  810. private _localChange;
  811. constructor(props: ITextInputLineComponentProps);
  812. shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
  813. value: string;
  814. }): boolean;
  815. raiseOnPropertyChanged(newValue: string, previousValue: string): void;
  816. updateValue(value: string, raisePropertyChanged: boolean): void;
  817. render(): JSX.Element;
  818. }
  819. }
  820. declare module "babylonjs-node-editor/sharedComponents/textLineComponent" {
  821. import * as React from "react";
  822. interface ITextLineComponentProps {
  823. label: string;
  824. value: string;
  825. color?: string;
  826. underline?: boolean;
  827. onLink?: () => void;
  828. }
  829. export class TextLineComponent extends React.Component<ITextLineComponentProps> {
  830. constructor(props: ITextLineComponentProps);
  831. onLink(): void;
  832. renderContent(): JSX.Element;
  833. render(): JSX.Element;
  834. }
  835. }
  836. declare module "babylonjs-node-editor/diagram/properties/genericNodePropertyComponent" {
  837. import * as React from "react";
  838. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  839. export class GenericPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  840. constructor(props: IPropertyComponentProps);
  841. render(): JSX.Element;
  842. }
  843. }
  844. declare module "babylonjs-node-editor/sharedComponents/checkBoxLineComponent" {
  845. import * as React from "react";
  846. import { Observable } from "babylonjs/Misc/observable";
  847. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  848. export interface ICheckBoxLineComponentProps {
  849. label: string;
  850. target?: any;
  851. propertyName?: string;
  852. isSelected?: () => boolean;
  853. onSelect?: (value: boolean) => void;
  854. onValueChanged?: () => void;
  855. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  856. }
  857. export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
  858. isSelected: boolean;
  859. }> {
  860. private static _UniqueIdSeed;
  861. private _uniqueId;
  862. private _localChange;
  863. constructor(props: ICheckBoxLineComponentProps);
  864. shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
  865. isSelected: boolean;
  866. }): boolean;
  867. onChange(): void;
  868. render(): JSX.Element;
  869. }
  870. }
  871. declare module "babylonjs-node-editor/sharedComponents/color4LineComponent" {
  872. import * as React from "react";
  873. import { Observable } from "babylonjs/Misc/observable";
  874. import { Color4 } from "babylonjs/Maths/math";
  875. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  876. import { GlobalState } from "babylonjs-node-editor/globalState";
  877. export interface IColor4LineComponentProps {
  878. label: string;
  879. target: any;
  880. propertyName: string;
  881. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  882. onChange?: () => void;
  883. globalState: GlobalState;
  884. }
  885. export class Color4LineComponent extends React.Component<IColor4LineComponentProps, {
  886. isExpanded: boolean;
  887. color: Color4;
  888. }> {
  889. private _localChange;
  890. constructor(props: IColor4LineComponentProps);
  891. shouldComponentUpdate(nextProps: IColor4LineComponentProps, nextState: {
  892. color: Color4;
  893. }): boolean;
  894. onChange(newValue: string): void;
  895. switchExpandState(): void;
  896. raiseOnPropertyChanged(previousValue: Color4): void;
  897. updateStateR(value: number): void;
  898. updateStateG(value: number): void;
  899. updateStateB(value: number): void;
  900. updateStateA(value: number): void;
  901. copyToClipboard(): void;
  902. render(): JSX.Element;
  903. }
  904. }
  905. declare module "babylonjs-node-editor/components/propertyTab/properties/color4PropertyTabComponent" {
  906. import * as React from "react";
  907. import { GlobalState } from "babylonjs-node-editor/globalState";
  908. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  909. interface IColor4PropertyTabComponentProps {
  910. globalState: GlobalState;
  911. inputBlock: InputBlock;
  912. }
  913. export class Color4PropertyTabComponent extends React.Component<IColor4PropertyTabComponentProps> {
  914. render(): JSX.Element;
  915. }
  916. }
  917. declare module "babylonjs-node-editor/diagram/properties/inputNodePropertyComponent" {
  918. import * as React from "react";
  919. import { GlobalState } from "babylonjs-node-editor/globalState";
  920. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  921. export class InputPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  922. constructor(props: IPropertyComponentProps);
  923. renderValue(globalState: GlobalState): JSX.Element | null;
  924. setDefaultValue(): void;
  925. render(): JSX.Element;
  926. }
  927. }
  928. declare module "babylonjs-node-editor/diagram/properties/transformNodePropertyComponent" {
  929. import * as React from "react";
  930. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  931. export class TransformPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  932. constructor(props: IPropertyComponentProps);
  933. render(): JSX.Element;
  934. }
  935. }
  936. declare module "babylonjs-node-editor/diagram/properties/PerturbNormalNodePropertyComponent" {
  937. import * as React from "react";
  938. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  939. export class PerturbNormalPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  940. constructor(props: IPropertyComponentProps);
  941. render(): JSX.Element;
  942. }
  943. }
  944. declare module "babylonjs-node-editor/diagram/properties/worleyNoise3DNodePropertyComponent" {
  945. import * as React from "react";
  946. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  947. export class WorleyNoise3DNodePropertyComponent extends React.Component<IPropertyComponentProps> {
  948. constructor(props: IPropertyComponentProps);
  949. render(): JSX.Element;
  950. }
  951. }
  952. declare module "babylonjs-node-editor/diagram/properties/clampNodePropertyComponent" {
  953. import * as React from "react";
  954. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  955. export class ClampPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  956. constructor(props: IPropertyComponentProps);
  957. forceRebuild(): void;
  958. render(): JSX.Element;
  959. }
  960. }
  961. declare module "babylonjs-node-editor/diagram/properties/gradientStepComponent" {
  962. import * as React from 'react';
  963. import { GlobalState } from "babylonjs-node-editor/globalState";
  964. import { GradientBlockColorStep } from 'babylonjs/Materials/Node/Blocks/gradientBlock';
  965. interface IGradientStepComponentProps {
  966. globalState: GlobalState;
  967. step: GradientBlockColorStep;
  968. lineIndex: number;
  969. onDelete: () => void;
  970. onUpdateStep: () => void;
  971. }
  972. export class GradientStepComponent extends React.Component<IGradientStepComponentProps, {
  973. gradient: number;
  974. }> {
  975. constructor(props: IGradientStepComponentProps);
  976. updateColor(color: string): void;
  977. updateStep(gradient: number): void;
  978. render(): JSX.Element;
  979. }
  980. }
  981. declare module "babylonjs-node-editor/sharedComponents/buttonLineComponent" {
  982. import * as React from "react";
  983. export interface IButtonLineComponentProps {
  984. label: string;
  985. onClick: () => void;
  986. }
  987. export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
  988. constructor(props: IButtonLineComponentProps);
  989. render(): JSX.Element;
  990. }
  991. }
  992. declare module "babylonjs-node-editor/diagram/properties/gradientNodePropertyComponent" {
  993. import * as React from "react";
  994. import { GradientBlockColorStep } from 'babylonjs/Materials/Node/Blocks/gradientBlock';
  995. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  996. export class GradientPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  997. constructor(props: IPropertyComponentProps);
  998. forceRebuild(): void;
  999. deleteStep(step: GradientBlockColorStep): void;
  1000. addNewStep(): void;
  1001. render(): JSX.Element;
  1002. }
  1003. }
  1004. declare module "babylonjs-node-editor/diagram/properties/lightPropertyTabComponent" {
  1005. import * as React from "react";
  1006. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  1007. export class LightPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  1008. render(): JSX.Element;
  1009. }
  1010. }
  1011. declare module "babylonjs-node-editor/diagram/properties/lightInformationPropertyTabComponent" {
  1012. import * as React from "react";
  1013. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  1014. export class LightInformationPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  1015. render(): JSX.Element;
  1016. }
  1017. }
  1018. declare module "babylonjs-node-editor/diagram/properties/remapNodePropertyComponent" {
  1019. import * as React from "react";
  1020. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  1021. export class RemapPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  1022. constructor(props: IPropertyComponentProps);
  1023. forceRebuild(): void;
  1024. render(): JSX.Element;
  1025. }
  1026. }
  1027. declare module "babylonjs-node-editor/sharedComponents/fileButtonLineComponent" {
  1028. import * as React from "react";
  1029. interface IFileButtonLineComponentProps {
  1030. label: string;
  1031. onClick: (file: File) => void;
  1032. accept: string;
  1033. }
  1034. export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
  1035. constructor(props: IFileButtonLineComponentProps);
  1036. onChange(evt: any): void;
  1037. render(): JSX.Element;
  1038. }
  1039. }
  1040. declare module "babylonjs-node-editor/diagram/properties/texturePropertyTabComponent" {
  1041. import * as React from "react";
  1042. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  1043. import { ReflectionTextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock';
  1044. import { TextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/textureBlock';
  1045. export class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps, {
  1046. isEmbedded: boolean;
  1047. loadAsCubeTexture: boolean;
  1048. }> {
  1049. get textureBlock(): TextureBlock | ReflectionTextureBlock;
  1050. constructor(props: IPropertyComponentProps);
  1051. UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
  1052. isEmbedded: boolean;
  1053. loadAsCubeTexture: boolean;
  1054. }): void;
  1055. private _generateRandomForCache;
  1056. updateAfterTextureLoad(): void;
  1057. removeTexture(): void;
  1058. _prepareTexture(): void;
  1059. /**
  1060. * Replaces the texture of the node
  1061. * @param file the file of the texture to use
  1062. */
  1063. replaceTexture(file: File): void;
  1064. replaceTextureWithUrl(url: string): void;
  1065. render(): JSX.Element;
  1066. }
  1067. }
  1068. declare module "babylonjs-node-editor/diagram/properties/trigonometryNodePropertyComponent" {
  1069. import * as React from "react";
  1070. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  1071. export class TrigonometryPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  1072. constructor(props: IPropertyComponentProps);
  1073. render(): JSX.Element;
  1074. }
  1075. }
  1076. declare module "babylonjs-node-editor/diagram/propertyLedger" {
  1077. import { ComponentClass } from 'react';
  1078. import { IPropertyComponentProps } from "babylonjs-node-editor/diagram/properties/propertyComponentProps";
  1079. export class PropertyLedger {
  1080. static RegisteredControls: {
  1081. [key: string]: ComponentClass<IPropertyComponentProps>;
  1082. };
  1083. }
  1084. }
  1085. declare module "babylonjs-node-editor/diagram/display/inputDisplayManager" {
  1086. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  1087. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1088. export class InputDisplayManager implements IDisplayManager {
  1089. getHeaderClass(block: NodeMaterialBlock): "" | "constant" | "inspector";
  1090. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  1091. getHeaderText(block: NodeMaterialBlock): string;
  1092. getBackgroundColor(block: NodeMaterialBlock): string;
  1093. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1094. }
  1095. }
  1096. declare module "babylonjs-node-editor/diagram/display/outputDisplayManager" {
  1097. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  1098. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1099. export class OutputDisplayManager implements IDisplayManager {
  1100. getHeaderClass(block: NodeMaterialBlock): string;
  1101. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  1102. getHeaderText(block: NodeMaterialBlock): string;
  1103. getBackgroundColor(block: NodeMaterialBlock): string;
  1104. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1105. }
  1106. }
  1107. declare module "babylonjs-node-editor/diagram/display/clampDisplayManager" {
  1108. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  1109. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1110. export class ClampDisplayManager implements IDisplayManager {
  1111. getHeaderClass(block: NodeMaterialBlock): string;
  1112. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  1113. getHeaderText(block: NodeMaterialBlock): string;
  1114. getBackgroundColor(block: NodeMaterialBlock): string;
  1115. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1116. }
  1117. }
  1118. declare module "babylonjs-node-editor/diagram/display/gradientDisplayManager" {
  1119. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  1120. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1121. export class GradientDisplayManager implements IDisplayManager {
  1122. getHeaderClass(block: NodeMaterialBlock): string;
  1123. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  1124. getHeaderText(block: NodeMaterialBlock): string;
  1125. getBackgroundColor(block: NodeMaterialBlock): string;
  1126. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1127. }
  1128. }
  1129. declare module "babylonjs-node-editor/diagram/display/remapDisplayManager" {
  1130. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  1131. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1132. export class RemapDisplayManager implements IDisplayManager {
  1133. getHeaderClass(block: NodeMaterialBlock): string;
  1134. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  1135. getHeaderText(block: NodeMaterialBlock): string;
  1136. getBackgroundColor(block: NodeMaterialBlock): string;
  1137. private _extractInputValue;
  1138. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1139. }
  1140. }
  1141. declare module "babylonjs-node-editor/diagram/display/trigonometryDisplayManager" {
  1142. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  1143. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1144. export class TrigonometryDisplayManager implements IDisplayManager {
  1145. getHeaderClass(block: NodeMaterialBlock): string;
  1146. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  1147. getHeaderText(block: NodeMaterialBlock): string;
  1148. getBackgroundColor(block: NodeMaterialBlock): string;
  1149. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1150. }
  1151. }
  1152. declare module "babylonjs-node-editor/sharedComponents/textureLineComponent" {
  1153. import * as React from "react";
  1154. import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
  1155. interface ITextureLineComponentProps {
  1156. texture: BaseTexture;
  1157. width: number;
  1158. height: number;
  1159. globalState?: any;
  1160. hideChannelSelect?: boolean;
  1161. }
  1162. export interface ITextureLineComponentState {
  1163. displayRed: boolean;
  1164. displayGreen: boolean;
  1165. displayBlue: boolean;
  1166. displayAlpha: boolean;
  1167. face: number;
  1168. }
  1169. export class TextureLineComponent extends React.Component<ITextureLineComponentProps, ITextureLineComponentState> {
  1170. constructor(props: ITextureLineComponentProps);
  1171. shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
  1172. displayRed: boolean;
  1173. displayGreen: boolean;
  1174. displayBlue: boolean;
  1175. displayAlpha: boolean;
  1176. face: number;
  1177. }): boolean;
  1178. componentDidMount(): void;
  1179. componentDidUpdate(): void;
  1180. updatePreview(): void;
  1181. static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): void;
  1182. render(): JSX.Element;
  1183. }
  1184. }
  1185. declare module "babylonjs-node-editor/diagram/display/textureDisplayManager" {
  1186. import { IDisplayManager } from "babylonjs-node-editor/diagram/display/displayManager";
  1187. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1188. export class TextureDisplayManager implements IDisplayManager {
  1189. private _previewCanvas;
  1190. private _previewImage;
  1191. getHeaderClass(block: NodeMaterialBlock): string;
  1192. shouldDisplayPortLabels(block: NodeMaterialBlock): boolean;
  1193. getHeaderText(block: NodeMaterialBlock): string;
  1194. getBackgroundColor(block: NodeMaterialBlock): string;
  1195. updatePreviewContent(block: NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1196. }
  1197. }
  1198. declare module "babylonjs-node-editor/diagram/displayLedger" {
  1199. export class DisplayLedger {
  1200. static RegisteredControls: {
  1201. [key: string]: any;
  1202. };
  1203. }
  1204. }
  1205. declare module "babylonjs-node-editor/diagram/graphNode" {
  1206. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1207. import { GlobalState } from "babylonjs-node-editor/globalState";
  1208. import { Nullable } from 'babylonjs/types';
  1209. import { NodeMaterialConnectionPoint } from 'babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint';
  1210. import { GraphCanvasComponent } from "babylonjs-node-editor/diagram/graphCanvas";
  1211. import { NodeLink } from "babylonjs-node-editor/diagram/nodeLink";
  1212. import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
  1213. import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
  1214. export class GraphNode {
  1215. block: NodeMaterialBlock;
  1216. private _visual;
  1217. private _header;
  1218. private _connections;
  1219. private _inputsContainer;
  1220. private _outputsContainer;
  1221. private _content;
  1222. private _comments;
  1223. private _inputPorts;
  1224. private _outputPorts;
  1225. private _links;
  1226. private _x;
  1227. private _y;
  1228. private _gridAlignedX;
  1229. private _gridAlignedY;
  1230. private _mouseStartPointX;
  1231. private _mouseStartPointY;
  1232. private _globalState;
  1233. private _onSelectionChangedObserver;
  1234. private _onSelectionBoxMovedObserver;
  1235. private _onFrameCreatedObserver;
  1236. private _onUpdateRequiredObserver;
  1237. private _ownerCanvas;
  1238. private _isSelected;
  1239. private _displayManager;
  1240. private _isVisible;
  1241. get isVisible(): boolean;
  1242. set isVisible(value: boolean);
  1243. get outputPorts(): NodePort[];
  1244. get inputPorts(): NodePort[];
  1245. get links(): NodeLink[];
  1246. get gridAlignedX(): number;
  1247. get gridAlignedY(): number;
  1248. get x(): number;
  1249. set x(value: number);
  1250. get y(): number;
  1251. set y(value: number);
  1252. get width(): number;
  1253. get height(): number;
  1254. get id(): number;
  1255. get name(): string;
  1256. get isSelected(): boolean;
  1257. set isSelected(value: boolean);
  1258. constructor(block: NodeMaterialBlock, globalState: GlobalState);
  1259. isOverlappingFrame(frame: GraphFrame): boolean;
  1260. getPortForConnectionPoint(point: NodeMaterialConnectionPoint): Nullable<NodePort>;
  1261. getLinksForConnectionPoint(point: NodeMaterialConnectionPoint): NodeLink[];
  1262. private _refreshFrames;
  1263. private _refreshLinks;
  1264. refresh(): void;
  1265. private _onDown;
  1266. cleanAccumulation(useCeil?: boolean): void;
  1267. private _onUp;
  1268. private _onMove;
  1269. renderProperties(): Nullable<JSX.Element>;
  1270. appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
  1271. dispose(): void;
  1272. }
  1273. }
  1274. declare module "babylonjs-node-editor/globalState" {
  1275. import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
  1276. import { Nullable } from "babylonjs/types";
  1277. import { Observable } from 'babylonjs/Misc/observable';
  1278. import { LogEntry } from "babylonjs-node-editor/components/log/logComponent";
  1279. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1280. import { PreviewMeshType } from "babylonjs-node-editor/components/preview/previewMeshType";
  1281. import { Color4 } from 'babylonjs/Maths/math.color';
  1282. import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
  1283. import { Vector2 } from 'babylonjs/Maths/math.vector';
  1284. import { NodePort } from "babylonjs-node-editor/diagram/nodePort";
  1285. import { NodeLink } from "babylonjs-node-editor/diagram/nodeLink";
  1286. import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
  1287. export class GlobalState {
  1288. nodeMaterial: NodeMaterial;
  1289. hostElement: HTMLElement;
  1290. hostDocument: HTMLDocument;
  1291. onSelectionChangedObservable: Observable<Nullable<GraphNode | GraphFrame | NodeLink>>;
  1292. onRebuildRequiredObservable: Observable<void>;
  1293. onResetRequiredObservable: Observable<void>;
  1294. onUpdateRequiredObservable: Observable<void>;
  1295. onZoomToFitRequiredObservable: Observable<void>;
  1296. onReOrganizedRequiredObservable: Observable<void>;
  1297. onLogRequiredObservable: Observable<LogEntry>;
  1298. onErrorMessageDialogRequiredObservable: Observable<string>;
  1299. onIsLoadingChanged: Observable<boolean>;
  1300. onPreviewCommandActivated: Observable<void>;
  1301. onLightUpdated: Observable<void>;
  1302. onPreviewBackgroundChanged: Observable<void>;
  1303. onBackFaceCullingChanged: Observable<void>;
  1304. onDepthPrePassChanged: Observable<void>;
  1305. onAnimationCommandActivated: Observable<void>;
  1306. onCandidateLinkMoved: Observable<Nullable<Vector2>>;
  1307. onSelectionBoxMoved: Observable<DOMRect | ClientRect>;
  1308. onFrameCreated: Observable<GraphFrame>;
  1309. onCandidatePortSelected: Observable<Nullable<NodePort>>;
  1310. onGetNodeFromBlock: (block: NodeMaterialBlock) => GraphNode;
  1311. onGridSizeChanged: Observable<void>;
  1312. previewMeshType: PreviewMeshType;
  1313. previewMeshFile: File;
  1314. rotatePreview: boolean;
  1315. backgroundColor: Color4;
  1316. backFaceCulling: boolean;
  1317. depthPrePass: boolean;
  1318. blockKeyboardEvents: boolean;
  1319. hemisphericLight: boolean;
  1320. directionalLight0: boolean;
  1321. directionalLight1: boolean;
  1322. controlCamera: boolean;
  1323. storeEditorData: (serializationObject: any) => void;
  1324. customSave?: {
  1325. label: string;
  1326. action: (data: string) => Promise<void>;
  1327. };
  1328. constructor();
  1329. }
  1330. }
  1331. declare module "babylonjs-node-editor/sharedComponents/draggableLineComponent" {
  1332. import * as React from "react";
  1333. export interface IButtonLineComponentProps {
  1334. data: string;
  1335. tooltip: string;
  1336. }
  1337. export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
  1338. constructor(props: IButtonLineComponentProps);
  1339. render(): JSX.Element;
  1340. }
  1341. }
  1342. declare module "babylonjs-node-editor/components/nodeList/nodeListComponent" {
  1343. import * as React from "react";
  1344. import { GlobalState } from "babylonjs-node-editor/globalState";
  1345. interface INodeListComponentProps {
  1346. globalState: GlobalState;
  1347. }
  1348. export class NodeListComponent extends React.Component<INodeListComponentProps, {
  1349. filter: string;
  1350. }> {
  1351. private static _Tooltips;
  1352. constructor(props: INodeListComponentProps);
  1353. filterContent(filter: string): void;
  1354. render(): JSX.Element;
  1355. }
  1356. }
  1357. declare module "babylonjs-node-editor/diagram/properties/framePropertyComponent" {
  1358. import * as React from "react";
  1359. import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
  1360. import { GlobalState } from "babylonjs-node-editor/globalState";
  1361. export interface IFramePropertyTabComponentProps {
  1362. globalState: GlobalState;
  1363. frame: GraphFrame;
  1364. }
  1365. export class FramePropertyTabComponent extends React.Component<IFramePropertyTabComponentProps> {
  1366. private onFrameExpandStateChangedObserver;
  1367. constructor(props: IFramePropertyTabComponentProps);
  1368. componentDidMount(): void;
  1369. componentWillUnmount(): void;
  1370. render(): JSX.Element;
  1371. }
  1372. }
  1373. declare module "babylonjs-node-editor/components/propertyTab/propertyTabComponent" {
  1374. import * as React from "react";
  1375. import { GlobalState } from "babylonjs-node-editor/globalState";
  1376. import { Nullable } from 'babylonjs/types';
  1377. import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
  1378. import { GraphFrame } from "babylonjs-node-editor/diagram/graphFrame";
  1379. interface IPropertyTabComponentProps {
  1380. globalState: GlobalState;
  1381. }
  1382. export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, {
  1383. currentNode: Nullable<GraphNode>;
  1384. currentFrame: Nullable<GraphFrame>;
  1385. }> {
  1386. constructor(props: IPropertyTabComponentProps);
  1387. componentDidMount(): void;
  1388. load(file: File): void;
  1389. save(): void;
  1390. customSave(): void;
  1391. render(): JSX.Element;
  1392. }
  1393. }
  1394. declare module "babylonjs-node-editor/portal" {
  1395. import * as React from "react";
  1396. import { GlobalState } from "babylonjs-node-editor/globalState";
  1397. interface IPortalProps {
  1398. globalState: GlobalState;
  1399. }
  1400. export class Portal extends React.Component<IPortalProps> {
  1401. render(): React.ReactPortal;
  1402. }
  1403. }
  1404. declare module "babylonjs-node-editor/sharedComponents/messageDialog" {
  1405. import * as React from "react";
  1406. import { GlobalState } from "babylonjs-node-editor/globalState";
  1407. interface IMessageDialogComponentProps {
  1408. globalState: GlobalState;
  1409. }
  1410. export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
  1411. message: string;
  1412. isError: boolean;
  1413. }> {
  1414. constructor(props: IMessageDialogComponentProps);
  1415. render(): JSX.Element | null;
  1416. }
  1417. }
  1418. declare module "babylonjs-node-editor/components/preview/previewManager" {
  1419. import { GlobalState } from "babylonjs-node-editor/globalState";
  1420. export class PreviewManager {
  1421. private _nodeMaterial;
  1422. private _onBuildObserver;
  1423. private _onPreviewCommandActivatedObserver;
  1424. private _onAnimationCommandActivatedObserver;
  1425. private _onUpdateRequiredObserver;
  1426. private _onPreviewBackgroundChangedObserver;
  1427. private _onBackFaceCullingChangedObserver;
  1428. private _onDepthPrePassChangedObserver;
  1429. private _onLightUpdatedObserver;
  1430. private _engine;
  1431. private _scene;
  1432. private _meshes;
  1433. private _camera;
  1434. private _material;
  1435. private _globalState;
  1436. private _currentType;
  1437. private _lightParent;
  1438. constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
  1439. private _handleAnimations;
  1440. private _prepareLights;
  1441. private _prepareMeshes;
  1442. private _refreshPreviewMesh;
  1443. private _forceCompilationAsync;
  1444. private _updatePreview;
  1445. dispose(): void;
  1446. }
  1447. }
  1448. declare module "babylonjs-node-editor/components/preview/previewMeshControlComponent" {
  1449. import * as React from "react";
  1450. import { GlobalState } from "babylonjs-node-editor/globalState";
  1451. import { PreviewMeshType } from "babylonjs-node-editor/components/preview/previewMeshType";
  1452. interface IPreviewMeshControlComponent {
  1453. globalState: GlobalState;
  1454. }
  1455. export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
  1456. changeMeshType(newOne: PreviewMeshType): void;
  1457. useCustomMesh(evt: any): void;
  1458. render(): JSX.Element;
  1459. }
  1460. }
  1461. declare module "babylonjs-node-editor/components/preview/previewAreaComponent" {
  1462. import * as React from "react";
  1463. import { GlobalState } from "babylonjs-node-editor/globalState";
  1464. interface IPreviewAreaComponentProps {
  1465. globalState: GlobalState;
  1466. width: number;
  1467. }
  1468. export class PreviewAreaComponent extends React.Component<IPreviewAreaComponentProps, {
  1469. isLoading: boolean;
  1470. }> {
  1471. constructor(props: IPreviewAreaComponentProps);
  1472. changeAnimation(): void;
  1473. changeBackground(value: string): void;
  1474. changeBackFaceCulling(value: boolean): void;
  1475. changeDepthPrePass(value: boolean): void;
  1476. render(): JSX.Element;
  1477. }
  1478. }
  1479. declare module "babylonjs-node-editor/graphEditor" {
  1480. import * as React from "react";
  1481. import { GlobalState } from "babylonjs-node-editor/globalState";
  1482. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1483. import { Nullable } from 'babylonjs/types';
  1484. import { IEditorData } from "babylonjs-node-editor/nodeLocationInfo";
  1485. import { GraphNode } from "babylonjs-node-editor/diagram/graphNode";
  1486. interface IGraphEditorProps {
  1487. globalState: GlobalState;
  1488. }
  1489. export class GraphEditor extends React.Component<IGraphEditorProps> {
  1490. private readonly NodeWidth;
  1491. private _graphCanvas;
  1492. private _startX;
  1493. private _moveInProgress;
  1494. private _leftWidth;
  1495. private _rightWidth;
  1496. private _blocks;
  1497. private _previewManager;
  1498. private _copiedNodes;
  1499. private _copiedFrame;
  1500. private _mouseLocationX;
  1501. private _mouseLocationY;
  1502. private _onWidgetKeyUpPointer;
  1503. createNodeFromObject(block: NodeMaterialBlock, recursion?: boolean): GraphNode;
  1504. addValueNode(type: string): GraphNode;
  1505. componentDidMount(): void;
  1506. componentWillUnmount(): void;
  1507. constructor(props: IGraphEditorProps);
  1508. reconnectNewNodes(nodeIndex: number, newNodes: GraphNode[], sourceNodes: GraphNode[], done: boolean[]): void;
  1509. pasteSelection(copiedNodes: GraphNode[], currentX: number, currentY: number): void;
  1510. zoomToFit(): void;
  1511. buildMaterial(): void;
  1512. build(): void;
  1513. reOrganize(editorData?: Nullable<IEditorData>): void;
  1514. onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
  1515. onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
  1516. resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
  1517. buildColumnLayout(): string;
  1518. emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
  1519. render(): JSX.Element;
  1520. }
  1521. }
  1522. declare module "babylonjs-node-editor/sharedComponents/popup" {
  1523. export class Popup {
  1524. static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): import("babylonjs/types").Nullable<HTMLDivElement>;
  1525. private static _CopyStyles;
  1526. }
  1527. }
  1528. declare module "babylonjs-node-editor/nodeEditor" {
  1529. import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
  1530. import { Observable } from 'babylonjs/Misc/observable';
  1531. /**
  1532. * Interface used to specify creation options for the node editor
  1533. */
  1534. export interface INodeEditorOptions {
  1535. nodeMaterial: NodeMaterial;
  1536. hostElement?: HTMLElement;
  1537. customSave?: {
  1538. label: string;
  1539. action: (data: string) => Promise<void>;
  1540. };
  1541. customLoadObservable?: Observable<any>;
  1542. }
  1543. /**
  1544. * Class used to create a node editor
  1545. */
  1546. export class NodeEditor {
  1547. private static _CurrentState;
  1548. /**
  1549. * Show the node editor
  1550. * @param options defines the options to use to configure the node editor
  1551. */
  1552. static Show(options: INodeEditorOptions): void;
  1553. }
  1554. }
  1555. declare module "babylonjs-node-editor/index" {
  1556. export * from "babylonjs-node-editor/nodeEditor";
  1557. }
  1558. declare module "babylonjs-node-editor/legacy/legacy" {
  1559. export * from "babylonjs-node-editor/index";
  1560. }
  1561. declare module "babylonjs-node-editor" {
  1562. export * from "babylonjs-node-editor/legacy/legacy";
  1563. }
  1564. /// <reference types="react" />
  1565. declare module NODEEDITOR {
  1566. export class BlockTools {
  1567. static GetBlockFromString(data: string, scene: BABYLON.Scene, nodeMaterial: BABYLON.NodeMaterial): 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.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 | null;
  1568. static GetColorFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
  1569. 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;
  1570. static GetStringFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4" | "";
  1571. }
  1572. }
  1573. declare module NODEEDITOR {
  1574. export class DataStorage {
  1575. private static _InMemoryStorage;
  1576. static ReadBoolean(key: string, defaultValue: boolean): boolean;
  1577. static StoreBoolean(key: string, value: boolean): void;
  1578. static ReadNumber(key: string, defaultValue: number): number;
  1579. static StoreNumber(key: string, value: number): void;
  1580. }
  1581. }
  1582. declare module NODEEDITOR {
  1583. interface ILogComponentProps {
  1584. globalState: GlobalState;
  1585. }
  1586. export class LogEntry {
  1587. message: string;
  1588. isError: boolean;
  1589. constructor(message: string, isError: boolean);
  1590. }
  1591. export class LogComponent extends React.Component<ILogComponentProps, {
  1592. logs: LogEntry[];
  1593. }> {
  1594. constructor(props: ILogComponentProps);
  1595. componentDidMount(): void;
  1596. componentDidUpdate(): void;
  1597. render(): JSX.Element;
  1598. }
  1599. }
  1600. declare module NODEEDITOR {
  1601. export enum PreviewMeshType {
  1602. Sphere = 0,
  1603. Box = 1,
  1604. Torus = 2,
  1605. Cylinder = 3,
  1606. Plane = 4,
  1607. ShaderBall = 5,
  1608. Custom = 6
  1609. }
  1610. }
  1611. declare module NODEEDITOR {
  1612. export interface IDisplayManager {
  1613. getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
  1614. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  1615. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  1616. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  1617. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  1618. }
  1619. }
  1620. declare module NODEEDITOR {
  1621. export class NodePort {
  1622. connectionPoint: BABYLON.NodeMaterialConnectionPoint;
  1623. node: GraphNode;
  1624. private _element;
  1625. private _img;
  1626. private _globalState;
  1627. private _onCandidateLinkMovedObserver;
  1628. delegatedPort: BABYLON.Nullable<NodePort>;
  1629. get element(): HTMLDivElement;
  1630. refresh(): void;
  1631. constructor(portContainer: HTMLElement, connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, globalState: GlobalState);
  1632. dispose(): void;
  1633. static CreatePortElement(connectionPoint: BABYLON.NodeMaterialConnectionPoint, node: GraphNode, root: HTMLElement, displayManager: BABYLON.Nullable<IDisplayManager>, globalState: GlobalState): NodePort;
  1634. }
  1635. }
  1636. declare module NODEEDITOR {
  1637. export interface INodeLocationInfo {
  1638. blockId: number;
  1639. x: number;
  1640. y: number;
  1641. }
  1642. export interface IFrameData {
  1643. x: number;
  1644. y: number;
  1645. width: number;
  1646. height: number;
  1647. color: number[];
  1648. name: string;
  1649. isCollapsed: boolean;
  1650. blocks: number[];
  1651. }
  1652. export interface IEditorData {
  1653. locations: INodeLocationInfo[];
  1654. x: number;
  1655. y: number;
  1656. zoom: number;
  1657. frames?: IFrameData[];
  1658. map?: {
  1659. [key: number]: number;
  1660. };
  1661. }
  1662. }
  1663. declare module NODEEDITOR {
  1664. export class SerializationTools {
  1665. static UpdateLocations(material: BABYLON.NodeMaterial, globalState: GlobalState): void;
  1666. static Serialize(material: BABYLON.NodeMaterial, globalState: GlobalState, selectedBlocks?: BABYLON.NodeMaterialBlock[]): string;
  1667. static Deserialize(serializationObject: any, globalState: GlobalState): void;
  1668. }
  1669. }
  1670. declare module NODEEDITOR {
  1671. export class StringTools {
  1672. private static _SaveAs;
  1673. private static _Click;
  1674. /**
  1675. * Gets the base math type of node material block connection point.
  1676. * @param type Type to parse.
  1677. */
  1678. static GetBaseType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
  1679. /**
  1680. * Download a string into a file that will be saved locally by the browser
  1681. * @param content defines the string to download locally as a file
  1682. */
  1683. static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
  1684. }
  1685. }
  1686. declare module NODEEDITOR {
  1687. export class GraphFrame {
  1688. private readonly CollapsedWidth;
  1689. private static _FrameCounter;
  1690. private _name;
  1691. private _color;
  1692. private _x;
  1693. private _y;
  1694. private _gridAlignedX;
  1695. private _gridAlignedY;
  1696. private _width;
  1697. private _height;
  1698. element: HTMLDivElement;
  1699. private _borderElement;
  1700. private _headerElement;
  1701. private _headerTextElement;
  1702. private _headerCollapseElement;
  1703. private _headerCloseElement;
  1704. private _portContainer;
  1705. private _outputPortContainer;
  1706. private _inputPortContainer;
  1707. private _nodes;
  1708. private _ownerCanvas;
  1709. private _mouseStartPointX;
  1710. private _mouseStartPointY;
  1711. private _onSelectionChangedObserver;
  1712. private _isCollapsed;
  1713. private _ports;
  1714. private _controlledPorts;
  1715. private _id;
  1716. onExpandStateChanged: BABYLON.Observable<GraphFrame>;
  1717. private readonly CloseSVG;
  1718. private readonly ExpandSVG;
  1719. private readonly CollapseSVG;
  1720. get id(): number;
  1721. get isCollapsed(): boolean;
  1722. private _createInputPort;
  1723. set isCollapsed(value: boolean);
  1724. get nodes(): GraphNode[];
  1725. get name(): string;
  1726. set name(value: string);
  1727. get color(): BABYLON.Color3;
  1728. set color(value: BABYLON.Color3);
  1729. get x(): number;
  1730. set x(value: number);
  1731. get y(): number;
  1732. set y(value: number);
  1733. get width(): number;
  1734. set width(value: number);
  1735. get height(): number;
  1736. set height(value: number);
  1737. constructor(candidate: BABYLON.Nullable<HTMLDivElement>, canvas: GraphCanvasComponent, doNotCaptureNodes?: boolean);
  1738. refresh(): void;
  1739. addNode(node: GraphNode): void;
  1740. removeNode(node: GraphNode): void;
  1741. syncNode(node: GraphNode): void;
  1742. cleanAccumulation(): void;
  1743. private _onDown;
  1744. move(newX: number, newY: number, align?: boolean): void;
  1745. private _onUp;
  1746. private _moveFrame;
  1747. private _onMove;
  1748. dispose(): void;
  1749. serialize(): IFrameData;
  1750. export(): void;
  1751. static Parse(serializationData: IFrameData, canvas: GraphCanvasComponent, map?: {
  1752. [key: number]: number;
  1753. }): GraphFrame;
  1754. }
  1755. }
  1756. declare module NODEEDITOR {
  1757. export class NodeLink {
  1758. private _graphCanvas;
  1759. private _portA;
  1760. private _portB?;
  1761. private _nodeA;
  1762. private _nodeB?;
  1763. private _path;
  1764. private _selectionPath;
  1765. private _onSelectionChangedObserver;
  1766. private _isVisible;
  1767. onDisposedObservable: BABYLON.Observable<NodeLink>;
  1768. get isVisible(): boolean;
  1769. set isVisible(value: boolean);
  1770. get portA(): NodePort;
  1771. get portB(): NodePort | undefined;
  1772. get nodeA(): GraphNode;
  1773. get nodeB(): GraphNode | undefined;
  1774. update(endX?: number, endY?: number, straight?: boolean): void;
  1775. constructor(graphCanvas: GraphCanvasComponent, portA: NodePort, nodeA: GraphNode, portB?: NodePort, nodeB?: GraphNode);
  1776. onClick(): void;
  1777. dispose(): void;
  1778. }
  1779. }
  1780. declare module NODEEDITOR {
  1781. export interface IGraphCanvasComponentProps {
  1782. globalState: GlobalState;
  1783. }
  1784. export class GraphCanvasComponent extends React.Component<IGraphCanvasComponentProps> {
  1785. private readonly MinZoom;
  1786. private readonly MaxZoom;
  1787. private _hostCanvas;
  1788. private _graphCanvas;
  1789. private _selectionContainer;
  1790. private _frameContainer;
  1791. private _svgCanvas;
  1792. private _rootContainer;
  1793. private _nodes;
  1794. private _links;
  1795. private _mouseStartPointX;
  1796. private _mouseStartPointY;
  1797. private _dropPointX;
  1798. private _dropPointY;
  1799. private _selectionStartX;
  1800. private _selectionStartY;
  1801. private _x;
  1802. private _y;
  1803. private _zoom;
  1804. private _selectedNodes;
  1805. private _selectedLink;
  1806. private _candidateLink;
  1807. private _candidatePort;
  1808. private _gridSize;
  1809. private _selectionBox;
  1810. private _selectedFrame;
  1811. private _frameCandidate;
  1812. private _frames;
  1813. private _altKeyIsPressed;
  1814. private _ctrlKeyIsPressed;
  1815. private _oldY;
  1816. _frameIsMoving: boolean;
  1817. get gridSize(): number;
  1818. set gridSize(value: number);
  1819. get globalState(): GlobalState;
  1820. get nodes(): GraphNode[];
  1821. get links(): NodeLink[];
  1822. get frames(): GraphFrame[];
  1823. get zoom(): number;
  1824. set zoom(value: number);
  1825. get x(): number;
  1826. set x(value: number);
  1827. get y(): number;
  1828. set y(value: number);
  1829. get selectedNodes(): GraphNode[];
  1830. get selectedLink(): BABYLON.Nullable<NodeLink>;
  1831. get selectedFrame(): BABYLON.Nullable<GraphFrame>;
  1832. get canvasContainer(): HTMLDivElement;
  1833. get svgCanvas(): HTMLElement;
  1834. get selectionContainer(): HTMLDivElement;
  1835. get frameContainer(): HTMLDivElement;
  1836. constructor(props: IGraphCanvasComponentProps);
  1837. getGridPosition(position: number, useCeil?: boolean): number;
  1838. getGridPositionCeil(position: number): number;
  1839. updateTransform(): void;
  1840. onKeyUp(): void;
  1841. findNodeFromBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
  1842. reset(): void;
  1843. connectPorts(pointA: BABYLON.NodeMaterialConnectionPoint, pointB: BABYLON.NodeMaterialConnectionPoint): void;
  1844. removeLink(link: NodeLink): void;
  1845. appendBlock(block: BABYLON.NodeMaterialBlock): GraphNode;
  1846. distributeGraph(): void;
  1847. componentDidMount(): void;
  1848. onMove(evt: React.PointerEvent): void;
  1849. onDown(evt: React.PointerEvent<HTMLElement>): void;
  1850. onUp(evt: React.PointerEvent): void;
  1851. onWheel(evt: React.WheelEvent): void;
  1852. zoomToFit(): void;
  1853. processCandidatePort(): void;
  1854. processEditorData(editorData: IEditorData): void;
  1855. render(): JSX.Element;
  1856. }
  1857. }
  1858. declare module NODEEDITOR {
  1859. export class PropertyChangedEvent {
  1860. object: any;
  1861. property: string;
  1862. value: any;
  1863. initialValue: any;
  1864. }
  1865. }
  1866. declare module NODEEDITOR {
  1867. interface IFloatLineComponentProps {
  1868. label: string;
  1869. target: any;
  1870. propertyName: string;
  1871. onChange?: (newValue: number) => void;
  1872. isInteger?: boolean;
  1873. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1874. additionalClass?: string;
  1875. step?: string;
  1876. digits?: number;
  1877. }
  1878. export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
  1879. value: string;
  1880. }> {
  1881. private _localChange;
  1882. private _store;
  1883. constructor(props: IFloatLineComponentProps);
  1884. shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
  1885. value: string;
  1886. }): boolean;
  1887. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  1888. updateValue(valueString: string): void;
  1889. render(): JSX.Element;
  1890. }
  1891. }
  1892. declare module NODEEDITOR {
  1893. interface IFloatPropertyTabComponentProps {
  1894. globalState: GlobalState;
  1895. inputBlock: BABYLON.InputBlock;
  1896. }
  1897. export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
  1898. render(): JSX.Element;
  1899. }
  1900. }
  1901. declare module NODEEDITOR {
  1902. interface ISliderLineComponentProps {
  1903. label: string;
  1904. target?: any;
  1905. propertyName?: string;
  1906. minimum: number;
  1907. maximum: number;
  1908. step: number;
  1909. directValue?: number;
  1910. useEuler?: boolean;
  1911. onChange?: (value: number) => void;
  1912. onInput?: (value: number) => void;
  1913. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1914. decimalCount?: number;
  1915. }
  1916. export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
  1917. value: number;
  1918. }> {
  1919. private _localChange;
  1920. constructor(props: ISliderLineComponentProps);
  1921. shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
  1922. value: number;
  1923. }): boolean;
  1924. onChange(newValueString: any): void;
  1925. onInput(newValueString: any): void;
  1926. prepareDataToRead(value: number): number;
  1927. render(): JSX.Element;
  1928. }
  1929. }
  1930. declare module NODEEDITOR {
  1931. interface INumericInputComponentProps {
  1932. label: string;
  1933. value: number;
  1934. step?: number;
  1935. onChange: (value: number) => void;
  1936. globalState: GlobalState;
  1937. }
  1938. export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
  1939. value: string;
  1940. }> {
  1941. static defaultProps: {
  1942. step: number;
  1943. };
  1944. private _localChange;
  1945. constructor(props: INumericInputComponentProps);
  1946. shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
  1947. value: string;
  1948. }): boolean;
  1949. updateValue(evt: any): void;
  1950. render(): JSX.Element;
  1951. }
  1952. }
  1953. declare module NODEEDITOR {
  1954. interface IVector2LineComponentProps {
  1955. label: string;
  1956. target: any;
  1957. propertyName: string;
  1958. step?: number;
  1959. onChange?: (newvalue: BABYLON.Vector2) => void;
  1960. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1961. globalState: GlobalState;
  1962. }
  1963. export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
  1964. isExpanded: boolean;
  1965. value: BABYLON.Vector2;
  1966. }> {
  1967. static defaultProps: {
  1968. step: number;
  1969. };
  1970. private _localChange;
  1971. constructor(props: IVector2LineComponentProps);
  1972. shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
  1973. isExpanded: boolean;
  1974. value: BABYLON.Vector2;
  1975. }): boolean;
  1976. switchExpandState(): void;
  1977. raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
  1978. updateStateX(value: number): void;
  1979. updateStateY(value: number): void;
  1980. render(): JSX.Element;
  1981. }
  1982. }
  1983. declare module NODEEDITOR {
  1984. interface IVector2PropertyTabComponentProps {
  1985. globalState: GlobalState;
  1986. inputBlock: BABYLON.InputBlock;
  1987. }
  1988. export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
  1989. render(): JSX.Element;
  1990. }
  1991. }
  1992. declare module NODEEDITOR {
  1993. export interface IColor3LineComponentProps {
  1994. label: string;
  1995. target: any;
  1996. propertyName: string;
  1997. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1998. onChange?: () => void;
  1999. globalState: GlobalState;
  2000. }
  2001. export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
  2002. isExpanded: boolean;
  2003. color: BABYLON.Color3;
  2004. }> {
  2005. private _localChange;
  2006. constructor(props: IColor3LineComponentProps);
  2007. shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
  2008. color: BABYLON.Color3;
  2009. }): boolean;
  2010. onChange(newValue: string): void;
  2011. switchExpandState(): void;
  2012. raiseOnPropertyChanged(previousValue: BABYLON.Color3): void;
  2013. updateStateR(value: number): void;
  2014. updateStateG(value: number): void;
  2015. updateStateB(value: number): void;
  2016. copyToClipboard(): void;
  2017. render(): JSX.Element;
  2018. }
  2019. }
  2020. declare module NODEEDITOR {
  2021. interface IColor3PropertyTabComponentProps {
  2022. globalState: GlobalState;
  2023. inputBlock: BABYLON.InputBlock;
  2024. }
  2025. export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
  2026. render(): JSX.Element;
  2027. }
  2028. }
  2029. declare module NODEEDITOR {
  2030. interface IVector3LineComponentProps {
  2031. label: string;
  2032. target: any;
  2033. propertyName: string;
  2034. step?: number;
  2035. onChange?: (newvalue: BABYLON.Vector3) => void;
  2036. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2037. globalState: GlobalState;
  2038. }
  2039. export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
  2040. isExpanded: boolean;
  2041. value: BABYLON.Vector3;
  2042. }> {
  2043. static defaultProps: {
  2044. step: number;
  2045. };
  2046. private _localChange;
  2047. constructor(props: IVector3LineComponentProps);
  2048. shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
  2049. isExpanded: boolean;
  2050. value: BABYLON.Vector3;
  2051. }): boolean;
  2052. switchExpandState(): void;
  2053. raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
  2054. updateVector3(): void;
  2055. updateStateX(value: number): void;
  2056. updateStateY(value: number): void;
  2057. updateStateZ(value: number): void;
  2058. render(): JSX.Element;
  2059. }
  2060. }
  2061. declare module NODEEDITOR {
  2062. interface IVector3PropertyTabComponentProps {
  2063. globalState: GlobalState;
  2064. inputBlock: BABYLON.InputBlock;
  2065. }
  2066. export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
  2067. render(): JSX.Element;
  2068. }
  2069. }
  2070. declare module NODEEDITOR {
  2071. interface IVector4LineComponentProps {
  2072. label: string;
  2073. target?: any;
  2074. propertyName?: string;
  2075. value?: BABYLON.Vector4;
  2076. step?: number;
  2077. onChange?: (newvalue: BABYLON.Vector4) => void;
  2078. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2079. globalState: GlobalState;
  2080. }
  2081. export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
  2082. isExpanded: boolean;
  2083. value: BABYLON.Vector4;
  2084. }> {
  2085. static defaultProps: {
  2086. step: number;
  2087. };
  2088. private _localChange;
  2089. constructor(props: IVector4LineComponentProps);
  2090. shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
  2091. isExpanded: boolean;
  2092. value: BABYLON.Vector4;
  2093. }): boolean;
  2094. switchExpandState(): void;
  2095. raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
  2096. updateVector4(): void;
  2097. updateStateX(value: number): void;
  2098. updateStateY(value: number): void;
  2099. updateStateZ(value: number): void;
  2100. updateStateW(value: number): void;
  2101. render(): JSX.Element;
  2102. }
  2103. }
  2104. declare module NODEEDITOR {
  2105. interface IVector4PropertyTabComponentProps {
  2106. globalState: GlobalState;
  2107. inputBlock: BABYLON.InputBlock;
  2108. }
  2109. export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
  2110. render(): JSX.Element;
  2111. }
  2112. }
  2113. declare module NODEEDITOR {
  2114. class ListLineOption {
  2115. label: string;
  2116. value: number | string;
  2117. }
  2118. interface IOptionsLineComponentProps {
  2119. label: string;
  2120. target: any;
  2121. className?: string;
  2122. propertyName?: string;
  2123. options: ListLineOption[];
  2124. noDirectUpdate?: boolean;
  2125. onSelect?: (value: number | string) => void;
  2126. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2127. valuesAreStrings?: boolean;
  2128. defaultIfNull?: number;
  2129. getSelection?: (target: any) => number;
  2130. }
  2131. export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
  2132. value: number | string;
  2133. }> {
  2134. private _localChange;
  2135. private _getValue;
  2136. constructor(props: IOptionsLineComponentProps);
  2137. shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
  2138. value: number;
  2139. }): boolean;
  2140. raiseOnPropertyChanged(newValue: number | string, previousValue: number | string): void;
  2141. updateValue(valueString: string): void;
  2142. render(): JSX.Element;
  2143. }
  2144. }
  2145. declare module NODEEDITOR {
  2146. interface IMatrixLineComponentProps {
  2147. label: string;
  2148. target: any;
  2149. propertyName: string;
  2150. step?: number;
  2151. onChange?: (newValue: BABYLON.Matrix) => void;
  2152. onModeChange?: (mode: number) => void;
  2153. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2154. mode?: number;
  2155. globalState: GlobalState;
  2156. }
  2157. export class MatrixLineComponent extends React.Component<IMatrixLineComponentProps, {
  2158. value: BABYLON.Matrix;
  2159. mode: number;
  2160. angle: number;
  2161. }> {
  2162. private _localChange;
  2163. constructor(props: IMatrixLineComponentProps);
  2164. shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: {
  2165. value: BABYLON.Matrix;
  2166. mode: number;
  2167. angle: number;
  2168. }): boolean;
  2169. raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
  2170. updateMatrix(): void;
  2171. updateRow(value: BABYLON.Vector4, row: number): void;
  2172. updateBasedOnMode(value: number): void;
  2173. render(): JSX.Element;
  2174. }
  2175. }
  2176. declare module NODEEDITOR {
  2177. interface IMatrixPropertyTabComponentProps {
  2178. globalState: GlobalState;
  2179. inputBlock: BABYLON.InputBlock;
  2180. }
  2181. export class MatrixPropertyTabComponent extends React.Component<IMatrixPropertyTabComponentProps> {
  2182. render(): JSX.Element;
  2183. }
  2184. }
  2185. declare module NODEEDITOR {
  2186. interface ILineContainerComponentProps {
  2187. title: string;
  2188. children: any[] | any;
  2189. closed?: boolean;
  2190. }
  2191. export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
  2192. isExpanded: boolean;
  2193. }> {
  2194. constructor(props: ILineContainerComponentProps);
  2195. switchExpandedState(): void;
  2196. renderHeader(): JSX.Element;
  2197. render(): JSX.Element;
  2198. }
  2199. }
  2200. declare module NODEEDITOR {
  2201. export interface IPropertyComponentProps {
  2202. globalState: GlobalState;
  2203. block: BABYLON.NodeMaterialBlock;
  2204. }
  2205. }
  2206. declare module NODEEDITOR {
  2207. interface ITextInputLineComponentProps {
  2208. label: string;
  2209. globalState: GlobalState;
  2210. target?: any;
  2211. propertyName?: string;
  2212. value?: string;
  2213. onChange?: (value: string) => void;
  2214. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2215. }
  2216. export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
  2217. value: string;
  2218. }> {
  2219. private _localChange;
  2220. constructor(props: ITextInputLineComponentProps);
  2221. shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
  2222. value: string;
  2223. }): boolean;
  2224. raiseOnPropertyChanged(newValue: string, previousValue: string): void;
  2225. updateValue(value: string, raisePropertyChanged: boolean): void;
  2226. render(): JSX.Element;
  2227. }
  2228. }
  2229. declare module NODEEDITOR {
  2230. interface ITextLineComponentProps {
  2231. label: string;
  2232. value: string;
  2233. color?: string;
  2234. underline?: boolean;
  2235. onLink?: () => void;
  2236. }
  2237. export class TextLineComponent extends React.Component<ITextLineComponentProps> {
  2238. constructor(props: ITextLineComponentProps);
  2239. onLink(): void;
  2240. renderContent(): JSX.Element;
  2241. render(): JSX.Element;
  2242. }
  2243. }
  2244. declare module NODEEDITOR {
  2245. export class GenericPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2246. constructor(props: IPropertyComponentProps);
  2247. render(): JSX.Element;
  2248. }
  2249. }
  2250. declare module NODEEDITOR {
  2251. export interface ICheckBoxLineComponentProps {
  2252. label: string;
  2253. target?: any;
  2254. propertyName?: string;
  2255. isSelected?: () => boolean;
  2256. onSelect?: (value: boolean) => void;
  2257. onValueChanged?: () => void;
  2258. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2259. }
  2260. export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
  2261. isSelected: boolean;
  2262. }> {
  2263. private static _UniqueIdSeed;
  2264. private _uniqueId;
  2265. private _localChange;
  2266. constructor(props: ICheckBoxLineComponentProps);
  2267. shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
  2268. isSelected: boolean;
  2269. }): boolean;
  2270. onChange(): void;
  2271. render(): JSX.Element;
  2272. }
  2273. }
  2274. declare module NODEEDITOR {
  2275. export interface IColor4LineComponentProps {
  2276. label: string;
  2277. target: any;
  2278. propertyName: string;
  2279. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2280. onChange?: () => void;
  2281. globalState: GlobalState;
  2282. }
  2283. export class Color4LineComponent extends React.Component<IColor4LineComponentProps, {
  2284. isExpanded: boolean;
  2285. color: BABYLON.Color4;
  2286. }> {
  2287. private _localChange;
  2288. constructor(props: IColor4LineComponentProps);
  2289. shouldComponentUpdate(nextProps: IColor4LineComponentProps, nextState: {
  2290. color: BABYLON.Color4;
  2291. }): boolean;
  2292. onChange(newValue: string): void;
  2293. switchExpandState(): void;
  2294. raiseOnPropertyChanged(previousValue: BABYLON.Color4): void;
  2295. updateStateR(value: number): void;
  2296. updateStateG(value: number): void;
  2297. updateStateB(value: number): void;
  2298. updateStateA(value: number): void;
  2299. copyToClipboard(): void;
  2300. render(): JSX.Element;
  2301. }
  2302. }
  2303. declare module NODEEDITOR {
  2304. interface IColor4PropertyTabComponentProps {
  2305. globalState: GlobalState;
  2306. inputBlock: BABYLON.InputBlock;
  2307. }
  2308. export class Color4PropertyTabComponent extends React.Component<IColor4PropertyTabComponentProps> {
  2309. render(): JSX.Element;
  2310. }
  2311. }
  2312. declare module NODEEDITOR {
  2313. export class InputPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2314. constructor(props: IPropertyComponentProps);
  2315. renderValue(globalState: GlobalState): JSX.Element | null;
  2316. setDefaultValue(): void;
  2317. render(): JSX.Element;
  2318. }
  2319. }
  2320. declare module NODEEDITOR {
  2321. export class TransformPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2322. constructor(props: IPropertyComponentProps);
  2323. render(): JSX.Element;
  2324. }
  2325. }
  2326. declare module NODEEDITOR {
  2327. export class PerturbNormalPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2328. constructor(props: IPropertyComponentProps);
  2329. render(): JSX.Element;
  2330. }
  2331. }
  2332. declare module NODEEDITOR {
  2333. export class WorleyNoise3DNodePropertyComponent extends React.Component<IPropertyComponentProps> {
  2334. constructor(props: IPropertyComponentProps);
  2335. render(): JSX.Element;
  2336. }
  2337. }
  2338. declare module NODEEDITOR {
  2339. export class ClampPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2340. constructor(props: IPropertyComponentProps);
  2341. forceRebuild(): void;
  2342. render(): JSX.Element;
  2343. }
  2344. }
  2345. declare module NODEEDITOR {
  2346. interface IGradientStepComponentProps {
  2347. globalState: GlobalState;
  2348. step: BABYLON.GradientBlockColorStep;
  2349. lineIndex: number;
  2350. onDelete: () => void;
  2351. onUpdateStep: () => void;
  2352. }
  2353. export class GradientStepComponent extends React.Component<IGradientStepComponentProps, {
  2354. gradient: number;
  2355. }> {
  2356. constructor(props: IGradientStepComponentProps);
  2357. updateColor(color: string): void;
  2358. updateStep(gradient: number): void;
  2359. render(): JSX.Element;
  2360. }
  2361. }
  2362. declare module NODEEDITOR {
  2363. export interface IButtonLineComponentProps {
  2364. label: string;
  2365. onClick: () => void;
  2366. }
  2367. export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
  2368. constructor(props: IButtonLineComponentProps);
  2369. render(): JSX.Element;
  2370. }
  2371. }
  2372. declare module NODEEDITOR {
  2373. export class GradientPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2374. constructor(props: IPropertyComponentProps);
  2375. forceRebuild(): void;
  2376. deleteStep(step: BABYLON.GradientBlockColorStep): void;
  2377. addNewStep(): void;
  2378. render(): JSX.Element;
  2379. }
  2380. }
  2381. declare module NODEEDITOR {
  2382. export class LightPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2383. render(): JSX.Element;
  2384. }
  2385. }
  2386. declare module NODEEDITOR {
  2387. export class LightInformationPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2388. render(): JSX.Element;
  2389. }
  2390. }
  2391. declare module NODEEDITOR {
  2392. export class RemapPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2393. constructor(props: IPropertyComponentProps);
  2394. forceRebuild(): void;
  2395. render(): JSX.Element;
  2396. }
  2397. }
  2398. declare module NODEEDITOR {
  2399. interface IFileButtonLineComponentProps {
  2400. label: string;
  2401. onClick: (file: File) => void;
  2402. accept: string;
  2403. }
  2404. export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
  2405. constructor(props: IFileButtonLineComponentProps);
  2406. onChange(evt: any): void;
  2407. render(): JSX.Element;
  2408. }
  2409. }
  2410. declare module NODEEDITOR {
  2411. export class TexturePropertyTabComponent extends React.Component<IPropertyComponentProps, {
  2412. isEmbedded: boolean;
  2413. loadAsCubeTexture: boolean;
  2414. }> {
  2415. get textureBlock(): BABYLON.TextureBlock | BABYLON.ReflectionTextureBlock;
  2416. constructor(props: IPropertyComponentProps);
  2417. UNSAFE_componentWillUpdate(nextProps: IPropertyComponentProps, nextState: {
  2418. isEmbedded: boolean;
  2419. loadAsCubeTexture: boolean;
  2420. }): void;
  2421. private _generateRandomForCache;
  2422. updateAfterTextureLoad(): void;
  2423. removeTexture(): void;
  2424. _prepareTexture(): void;
  2425. /**
  2426. * Replaces the texture of the node
  2427. * @param file the file of the texture to use
  2428. */
  2429. replaceTexture(file: File): void;
  2430. replaceTextureWithUrl(url: string): void;
  2431. render(): JSX.Element;
  2432. }
  2433. }
  2434. declare module NODEEDITOR {
  2435. export class TrigonometryPropertyTabComponent extends React.Component<IPropertyComponentProps> {
  2436. constructor(props: IPropertyComponentProps);
  2437. render(): JSX.Element;
  2438. }
  2439. }
  2440. declare module NODEEDITOR {
  2441. export class PropertyLedger {
  2442. static RegisteredControls: {
  2443. [key: string]: React.ComponentClass<IPropertyComponentProps>;
  2444. };
  2445. }
  2446. }
  2447. declare module NODEEDITOR {
  2448. export class InputDisplayManager implements IDisplayManager {
  2449. getHeaderClass(block: BABYLON.NodeMaterialBlock): "" | "constant" | "inspector";
  2450. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  2451. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  2452. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  2453. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  2454. }
  2455. }
  2456. declare module NODEEDITOR {
  2457. export class OutputDisplayManager implements IDisplayManager {
  2458. getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
  2459. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  2460. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  2461. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  2462. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  2463. }
  2464. }
  2465. declare module NODEEDITOR {
  2466. export class ClampDisplayManager implements IDisplayManager {
  2467. getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
  2468. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  2469. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  2470. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  2471. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  2472. }
  2473. }
  2474. declare module NODEEDITOR {
  2475. export class GradientDisplayManager implements IDisplayManager {
  2476. getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
  2477. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  2478. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  2479. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  2480. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  2481. }
  2482. }
  2483. declare module NODEEDITOR {
  2484. export class RemapDisplayManager implements IDisplayManager {
  2485. getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
  2486. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  2487. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  2488. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  2489. private _extractInputValue;
  2490. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  2491. }
  2492. }
  2493. declare module NODEEDITOR {
  2494. export class TrigonometryDisplayManager implements IDisplayManager {
  2495. getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
  2496. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  2497. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  2498. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  2499. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  2500. }
  2501. }
  2502. declare module NODEEDITOR {
  2503. interface ITextureLineComponentProps {
  2504. texture: BABYLON.BaseTexture;
  2505. width: number;
  2506. height: number;
  2507. globalState?: any;
  2508. hideChannelSelect?: boolean;
  2509. }
  2510. export interface ITextureLineComponentState {
  2511. displayRed: boolean;
  2512. displayGreen: boolean;
  2513. displayBlue: boolean;
  2514. displayAlpha: boolean;
  2515. face: number;
  2516. }
  2517. export class TextureLineComponent extends React.Component<ITextureLineComponentProps, ITextureLineComponentState> {
  2518. constructor(props: ITextureLineComponentProps);
  2519. shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
  2520. displayRed: boolean;
  2521. displayGreen: boolean;
  2522. displayBlue: boolean;
  2523. displayAlpha: boolean;
  2524. face: number;
  2525. }): boolean;
  2526. componentDidMount(): void;
  2527. componentDidUpdate(): void;
  2528. updatePreview(): void;
  2529. static UpdatePreview(previewCanvas: HTMLCanvasElement, texture: BABYLON.BaseTexture, width: number, options: ITextureLineComponentState, onReady?: () => void, globalState?: any): void;
  2530. render(): JSX.Element;
  2531. }
  2532. }
  2533. declare module NODEEDITOR {
  2534. export class TextureDisplayManager implements IDisplayManager {
  2535. private _previewCanvas;
  2536. private _previewImage;
  2537. getHeaderClass(block: BABYLON.NodeMaterialBlock): string;
  2538. shouldDisplayPortLabels(block: BABYLON.NodeMaterialBlock): boolean;
  2539. getHeaderText(block: BABYLON.NodeMaterialBlock): string;
  2540. getBackgroundColor(block: BABYLON.NodeMaterialBlock): string;
  2541. updatePreviewContent(block: BABYLON.NodeMaterialBlock, contentArea: HTMLDivElement): void;
  2542. }
  2543. }
  2544. declare module NODEEDITOR {
  2545. export class DisplayLedger {
  2546. static RegisteredControls: {
  2547. [key: string]: any;
  2548. };
  2549. }
  2550. }
  2551. declare module NODEEDITOR {
  2552. export class GraphNode {
  2553. block: BABYLON.NodeMaterialBlock;
  2554. private _visual;
  2555. private _header;
  2556. private _connections;
  2557. private _inputsContainer;
  2558. private _outputsContainer;
  2559. private _content;
  2560. private _comments;
  2561. private _inputPorts;
  2562. private _outputPorts;
  2563. private _links;
  2564. private _x;
  2565. private _y;
  2566. private _gridAlignedX;
  2567. private _gridAlignedY;
  2568. private _mouseStartPointX;
  2569. private _mouseStartPointY;
  2570. private _globalState;
  2571. private _onSelectionChangedObserver;
  2572. private _onSelectionBoxMovedObserver;
  2573. private _onFrameCreatedObserver;
  2574. private _onUpdateRequiredObserver;
  2575. private _ownerCanvas;
  2576. private _isSelected;
  2577. private _displayManager;
  2578. private _isVisible;
  2579. get isVisible(): boolean;
  2580. set isVisible(value: boolean);
  2581. get outputPorts(): NodePort[];
  2582. get inputPorts(): NodePort[];
  2583. get links(): NodeLink[];
  2584. get gridAlignedX(): number;
  2585. get gridAlignedY(): number;
  2586. get x(): number;
  2587. set x(value: number);
  2588. get y(): number;
  2589. set y(value: number);
  2590. get width(): number;
  2591. get height(): number;
  2592. get id(): number;
  2593. get name(): string;
  2594. get isSelected(): boolean;
  2595. set isSelected(value: boolean);
  2596. constructor(block: BABYLON.NodeMaterialBlock, globalState: GlobalState);
  2597. isOverlappingFrame(frame: GraphFrame): boolean;
  2598. getPortForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): BABYLON.Nullable<NodePort>;
  2599. getLinksForConnectionPoint(point: BABYLON.NodeMaterialConnectionPoint): NodeLink[];
  2600. private _refreshFrames;
  2601. private _refreshLinks;
  2602. refresh(): void;
  2603. private _onDown;
  2604. cleanAccumulation(useCeil?: boolean): void;
  2605. private _onUp;
  2606. private _onMove;
  2607. renderProperties(): BABYLON.Nullable<JSX.Element>;
  2608. appendVisual(root: HTMLDivElement, owner: GraphCanvasComponent): void;
  2609. dispose(): void;
  2610. }
  2611. }
  2612. declare module NODEEDITOR {
  2613. export class GlobalState {
  2614. nodeMaterial: BABYLON.NodeMaterial;
  2615. hostElement: HTMLElement;
  2616. hostDocument: HTMLDocument;
  2617. onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<GraphNode | GraphFrame | NodeLink>>;
  2618. onRebuildRequiredObservable: BABYLON.Observable<void>;
  2619. onResetRequiredObservable: BABYLON.Observable<void>;
  2620. onUpdateRequiredObservable: BABYLON.Observable<void>;
  2621. onZoomToFitRequiredObservable: BABYLON.Observable<void>;
  2622. onReOrganizedRequiredObservable: BABYLON.Observable<void>;
  2623. onLogRequiredObservable: BABYLON.Observable<LogEntry>;
  2624. onErrorMessageDialogRequiredObservable: BABYLON.Observable<string>;
  2625. onIsLoadingChanged: BABYLON.Observable<boolean>;
  2626. onPreviewCommandActivated: BABYLON.Observable<void>;
  2627. onLightUpdated: BABYLON.Observable<void>;
  2628. onPreviewBackgroundChanged: BABYLON.Observable<void>;
  2629. onBackFaceCullingChanged: BABYLON.Observable<void>;
  2630. onDepthPrePassChanged: BABYLON.Observable<void>;
  2631. onAnimationCommandActivated: BABYLON.Observable<void>;
  2632. onCandidateLinkMoved: BABYLON.Observable<BABYLON.Nullable<BABYLON.Vector2>>;
  2633. onSelectionBoxMoved: BABYLON.Observable<DOMRect | ClientRect>;
  2634. onFrameCreated: BABYLON.Observable<GraphFrame>;
  2635. onCandidatePortSelected: BABYLON.Observable<BABYLON.Nullable<NodePort>>;
  2636. onGetNodeFromBlock: (block: BABYLON.NodeMaterialBlock) => GraphNode;
  2637. onGridSizeChanged: BABYLON.Observable<void>;
  2638. previewMeshType: PreviewMeshType;
  2639. previewMeshFile: File;
  2640. rotatePreview: boolean;
  2641. backgroundColor: BABYLON.Color4;
  2642. backFaceCulling: boolean;
  2643. depthPrePass: boolean;
  2644. blockKeyboardEvents: boolean;
  2645. hemisphericLight: boolean;
  2646. directionalLight0: boolean;
  2647. directionalLight1: boolean;
  2648. controlCamera: boolean;
  2649. storeEditorData: (serializationObject: any) => void;
  2650. customSave?: {
  2651. label: string;
  2652. action: (data: string) => Promise<void>;
  2653. };
  2654. constructor();
  2655. }
  2656. }
  2657. declare module NODEEDITOR {
  2658. export interface IButtonLineComponentProps {
  2659. data: string;
  2660. tooltip: string;
  2661. }
  2662. export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
  2663. constructor(props: IButtonLineComponentProps);
  2664. render(): JSX.Element;
  2665. }
  2666. }
  2667. declare module NODEEDITOR {
  2668. interface INodeListComponentProps {
  2669. globalState: GlobalState;
  2670. }
  2671. export class NodeListComponent extends React.Component<INodeListComponentProps, {
  2672. filter: string;
  2673. }> {
  2674. private static _Tooltips;
  2675. constructor(props: INodeListComponentProps);
  2676. filterContent(filter: string): void;
  2677. render(): JSX.Element;
  2678. }
  2679. }
  2680. declare module NODEEDITOR {
  2681. export interface IFramePropertyTabComponentProps {
  2682. globalState: GlobalState;
  2683. frame: GraphFrame;
  2684. }
  2685. export class FramePropertyTabComponent extends React.Component<IFramePropertyTabComponentProps> {
  2686. private onFrameExpandStateChangedObserver;
  2687. constructor(props: IFramePropertyTabComponentProps);
  2688. componentDidMount(): void;
  2689. componentWillUnmount(): void;
  2690. render(): JSX.Element;
  2691. }
  2692. }
  2693. declare module NODEEDITOR {
  2694. interface IPropertyTabComponentProps {
  2695. globalState: GlobalState;
  2696. }
  2697. export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, {
  2698. currentNode: BABYLON.Nullable<GraphNode>;
  2699. currentFrame: BABYLON.Nullable<GraphFrame>;
  2700. }> {
  2701. constructor(props: IPropertyTabComponentProps);
  2702. componentDidMount(): void;
  2703. load(file: File): void;
  2704. save(): void;
  2705. customSave(): void;
  2706. render(): JSX.Element;
  2707. }
  2708. }
  2709. declare module NODEEDITOR {
  2710. interface IPortalProps {
  2711. globalState: GlobalState;
  2712. }
  2713. export class Portal extends React.Component<IPortalProps> {
  2714. render(): React.ReactPortal;
  2715. }
  2716. }
  2717. declare module NODEEDITOR {
  2718. interface IMessageDialogComponentProps {
  2719. globalState: GlobalState;
  2720. }
  2721. export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
  2722. message: string;
  2723. isError: boolean;
  2724. }> {
  2725. constructor(props: IMessageDialogComponentProps);
  2726. render(): JSX.Element | null;
  2727. }
  2728. }
  2729. declare module NODEEDITOR {
  2730. export class PreviewManager {
  2731. private _nodeMaterial;
  2732. private _onBuildObserver;
  2733. private _onPreviewCommandActivatedObserver;
  2734. private _onAnimationCommandActivatedObserver;
  2735. private _onUpdateRequiredObserver;
  2736. private _onPreviewBackgroundChangedObserver;
  2737. private _onBackFaceCullingChangedObserver;
  2738. private _onDepthPrePassChangedObserver;
  2739. private _onLightUpdatedObserver;
  2740. private _engine;
  2741. private _scene;
  2742. private _meshes;
  2743. private _camera;
  2744. private _material;
  2745. private _globalState;
  2746. private _currentType;
  2747. private _lightParent;
  2748. constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
  2749. private _handleAnimations;
  2750. private _prepareLights;
  2751. private _prepareMeshes;
  2752. private _refreshPreviewMesh;
  2753. private _forceCompilationAsync;
  2754. private _updatePreview;
  2755. dispose(): void;
  2756. }
  2757. }
  2758. declare module NODEEDITOR {
  2759. interface IPreviewMeshControlComponent {
  2760. globalState: GlobalState;
  2761. }
  2762. export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
  2763. changeMeshType(newOne: PreviewMeshType): void;
  2764. useCustomMesh(evt: any): void;
  2765. render(): JSX.Element;
  2766. }
  2767. }
  2768. declare module NODEEDITOR {
  2769. interface IPreviewAreaComponentProps {
  2770. globalState: GlobalState;
  2771. width: number;
  2772. }
  2773. export class PreviewAreaComponent extends React.Component<IPreviewAreaComponentProps, {
  2774. isLoading: boolean;
  2775. }> {
  2776. constructor(props: IPreviewAreaComponentProps);
  2777. changeAnimation(): void;
  2778. changeBackground(value: string): void;
  2779. changeBackFaceCulling(value: boolean): void;
  2780. changeDepthPrePass(value: boolean): void;
  2781. render(): JSX.Element;
  2782. }
  2783. }
  2784. declare module NODEEDITOR {
  2785. interface IGraphEditorProps {
  2786. globalState: GlobalState;
  2787. }
  2788. export class GraphEditor extends React.Component<IGraphEditorProps> {
  2789. private readonly NodeWidth;
  2790. private _graphCanvas;
  2791. private _startX;
  2792. private _moveInProgress;
  2793. private _leftWidth;
  2794. private _rightWidth;
  2795. private _blocks;
  2796. private _previewManager;
  2797. private _copiedNodes;
  2798. private _copiedFrame;
  2799. private _mouseLocationX;
  2800. private _mouseLocationY;
  2801. private _onWidgetKeyUpPointer;
  2802. createNodeFromObject(block: BABYLON.NodeMaterialBlock, recursion?: boolean): GraphNode;
  2803. addValueNode(type: string): GraphNode;
  2804. componentDidMount(): void;
  2805. componentWillUnmount(): void;
  2806. constructor(props: IGraphEditorProps);
  2807. reconnectNewNodes(nodeIndex: number, newNodes: GraphNode[], sourceNodes: GraphNode[], done: boolean[]): void;
  2808. pasteSelection(copiedNodes: GraphNode[], currentX: number, currentY: number): void;
  2809. zoomToFit(): void;
  2810. buildMaterial(): void;
  2811. build(): void;
  2812. reOrganize(editorData?: BABYLON.Nullable<IEditorData>): void;
  2813. onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
  2814. onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
  2815. resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
  2816. buildColumnLayout(): string;
  2817. emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
  2818. render(): JSX.Element;
  2819. }
  2820. }
  2821. declare module NODEEDITOR {
  2822. export class Popup {
  2823. static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): Nullable<HTMLDivElement>;
  2824. private static _CopyStyles;
  2825. }
  2826. }
  2827. declare module NODEEDITOR {
  2828. /**
  2829. * Interface used to specify creation options for the node editor
  2830. */
  2831. export interface INodeEditorOptions {
  2832. nodeMaterial: BABYLON.NodeMaterial;
  2833. hostElement?: HTMLElement;
  2834. customSave?: {
  2835. label: string;
  2836. action: (data: string) => Promise<void>;
  2837. };
  2838. customLoadObservable?: BABYLON.Observable<any>;
  2839. }
  2840. /**
  2841. * Class used to create a node editor
  2842. */
  2843. export class NodeEditor {
  2844. private static _CurrentState;
  2845. /**
  2846. * Show the node editor
  2847. * @param options defines the options to use to configure the node editor
  2848. */
  2849. static Show(options: INodeEditorOptions): void;
  2850. }
  2851. }