babylon.nodeEditor.d.ts 46 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321
  1. /// <reference types="react" />
  2. declare module NODEEDITOR {
  3. export class BlockTools {
  4. static GetBlockFromString(data: string): BABYLON.BonesBlock | BABYLON.InstancesBlock | BABYLON.MorphTargetsBlock | BABYLON.AlphaTestBlock | 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.MultiplyBlock | BABYLON.TransformBlock | BABYLON.TrigonometryBlock | BABYLON.RemapBlock | BABYLON.NormalizeBlock | BABYLON.FresnelBlock | BABYLON.LerpBlock | BABYLON.DivideBlock | BABYLON.SubtractBlock | BABYLON.StepBlock | BABYLON.OneMinusBlock | BABYLON.ViewDirectionBlock | BABYLON.LightInformationBlock | BABYLON.MaxBlock | BABYLON.MinBlock | BABYLON.PerturbNormalBlock | BABYLON.InputBlock | null;
  5. static GetColorFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
  6. 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;
  7. static GetStringFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4" | "";
  8. }
  9. }
  10. declare module NODEEDITOR {
  11. export class DataStorage {
  12. private static _InMemoryStorage;
  13. static ReadBoolean(key: string, defaultValue: boolean): boolean;
  14. static StoreBoolean(key: string, value: boolean): void;
  15. static ReadNumber(key: string, defaultValue: number): number;
  16. static StoreNumber(key: string, value: number): void;
  17. }
  18. }
  19. declare module NODEEDITOR {
  20. interface ITextLineComponentProps {
  21. label: string;
  22. value: string;
  23. color?: string;
  24. underline?: boolean;
  25. onLink?: () => void;
  26. }
  27. export class TextLineComponent extends React.Component<ITextLineComponentProps> {
  28. constructor(props: ITextLineComponentProps);
  29. onLink(): void;
  30. renderContent(): JSX.Element;
  31. render(): JSX.Element;
  32. }
  33. }
  34. declare module NODEEDITOR {
  35. interface ILineContainerComponentProps {
  36. title: string;
  37. children: any[] | any;
  38. closed?: boolean;
  39. }
  40. export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
  41. isExpanded: boolean;
  42. }> {
  43. constructor(props: ILineContainerComponentProps);
  44. switchExpandedState(): void;
  45. renderHeader(): JSX.Element;
  46. render(): JSX.Element;
  47. }
  48. }
  49. declare module NODEEDITOR {
  50. export class PropertyChangedEvent {
  51. object: any;
  52. property: string;
  53. value: any;
  54. initialValue: any;
  55. }
  56. }
  57. declare module NODEEDITOR {
  58. interface ITextInputLineComponentProps {
  59. label: string;
  60. globalState: GlobalState;
  61. target?: any;
  62. propertyName?: string;
  63. value?: string;
  64. onChange?: (value: string) => void;
  65. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  66. }
  67. export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
  68. value: string;
  69. }> {
  70. private _localChange;
  71. constructor(props: ITextInputLineComponentProps);
  72. shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
  73. value: string;
  74. }): boolean;
  75. raiseOnPropertyChanged(newValue: string, previousValue: string): void;
  76. updateValue(value: string, raisePropertyChanged: boolean): void;
  77. render(): JSX.Element;
  78. }
  79. }
  80. declare module NODEEDITOR {
  81. export interface ICheckBoxLineComponentProps {
  82. label: string;
  83. target?: any;
  84. propertyName?: string;
  85. isSelected?: () => boolean;
  86. onSelect?: (value: boolean) => void;
  87. onValueChanged?: () => void;
  88. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  89. }
  90. export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
  91. isSelected: boolean;
  92. }> {
  93. private static _UniqueIdSeed;
  94. private _uniqueId;
  95. private _localChange;
  96. constructor(props: ICheckBoxLineComponentProps);
  97. shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
  98. isSelected: boolean;
  99. }): boolean;
  100. onChange(): void;
  101. render(): JSX.Element;
  102. }
  103. }
  104. declare module NODEEDITOR {
  105. /**
  106. * Generic node model which stores information about a node editor block
  107. */
  108. export class GenericNodeModel extends DefaultNodeModel {
  109. /**
  110. * BABYLON.Vector2 for the node if it exists
  111. */
  112. vector2: BABYLON.Nullable<BABYLON.Vector2>;
  113. /**
  114. * BABYLON.Vector3 for the node if it exists
  115. */
  116. vector3: BABYLON.Nullable<BABYLON.Vector3>;
  117. /**
  118. * BABYLON.Vector4 for the node if it exists
  119. */
  120. vector4: BABYLON.Nullable<BABYLON.Vector4>;
  121. /**
  122. * BABYLON.Matrix for the node if it exists
  123. */
  124. matrix: BABYLON.Nullable<BABYLON.Matrix>;
  125. /**
  126. * Constructs the node model
  127. */
  128. constructor();
  129. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  130. renderProperties(globalState: GlobalState): JSX.Element;
  131. }
  132. }
  133. declare module NODEEDITOR {
  134. export class AdvancedLinkModel extends DefaultLinkModel {
  135. constructor();
  136. }
  137. }
  138. declare module NODEEDITOR {
  139. /**
  140. * Port model
  141. */
  142. export class DefaultPortModel extends PortModel {
  143. /**
  144. * If the port is input or output
  145. */
  146. position: string | "input" | "output";
  147. /**
  148. * What the port is connected to
  149. */
  150. connection: BABYLON.Nullable<BABYLON.NodeMaterialConnectionPoint>;
  151. defaultValue: any;
  152. static idCounter: number;
  153. constructor(name: string, type?: string);
  154. canLinkToPort(port: DefaultPortModel): boolean;
  155. syncWithNodeMaterialConnectionPoint(connection: BABYLON.NodeMaterialConnectionPoint): void;
  156. getNodeModel(): DefaultNodeModel;
  157. link(outPort: DefaultPortModel): LinkModel<import("storm-react-diagrams").LinkModelListener>;
  158. createLinkModel(): LinkModel;
  159. static SortInputOutput(a: BABYLON.Nullable<DefaultPortModel>, b: BABYLON.Nullable<DefaultPortModel>): {
  160. input: DefaultPortModel;
  161. output: DefaultPortModel;
  162. } | null;
  163. }
  164. }
  165. declare module NODEEDITOR {
  166. export interface IDefaultPortWidgetProps extends BaseWidgetProps {
  167. name: string;
  168. node: NodeModel;
  169. style: any;
  170. }
  171. export class DefaultPortWidget extends BaseWidget<IDefaultPortWidgetProps, PortState> {
  172. constructor(props: IDefaultPortWidgetProps);
  173. getClassName(): string;
  174. render(): JSX.Element;
  175. }
  176. }
  177. declare module NODEEDITOR {
  178. export class PortHelper {
  179. private static _GetPortTypeIndicator;
  180. static _GetPortStyle(type: BABYLON.NodeMaterialBlockConnectionPointTypes): {
  181. background: string;
  182. };
  183. static GenerateOutputPorts(node: BABYLON.Nullable<DefaultNodeModel>, ignoreLabel: boolean): JSX.Element[];
  184. static GenerateInputPorts(node: BABYLON.Nullable<DefaultNodeModel>, includeOnly?: string[], ignoreLabel?: boolean): JSX.Element[];
  185. }
  186. }
  187. declare module NODEEDITOR {
  188. /**
  189. * GenericNodeWidgetProps
  190. */
  191. export interface GenericNodeWidgetProps {
  192. node: BABYLON.Nullable<GenericNodeModel>;
  193. globalState: GlobalState;
  194. }
  195. /**
  196. * GenericNodeWidgetState
  197. */
  198. export interface GenericNodeWidgetState {
  199. }
  200. /**
  201. * Used to display a node block for the node editor
  202. */
  203. export class GenericNodeWidget extends React.Component<GenericNodeWidgetProps, GenericNodeWidgetState> {
  204. /**
  205. * Creates a GenericNodeWidget
  206. * @param props
  207. */
  208. constructor(props: GenericNodeWidgetProps);
  209. render(): JSX.Element;
  210. }
  211. }
  212. declare module NODEEDITOR {
  213. /**
  214. * Node factory which creates editor nodes
  215. */
  216. export class GenericNodeFactory extends SRD.AbstractNodeFactory {
  217. private _globalState;
  218. /**
  219. * Constructs a GenericNodeFactory
  220. */
  221. constructor(globalState: GlobalState);
  222. /**
  223. * Generates a node widget
  224. * @param diagramEngine diagram engine
  225. * @param node node to generate
  226. * @returns node widget jsx
  227. */
  228. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: GenericNodeModel): JSX.Element;
  229. /**
  230. * Gets a new instance of a node model
  231. * @returns generic node model
  232. */
  233. getNewInstance(): GenericNodeModel;
  234. }
  235. }
  236. declare module NODEEDITOR {
  237. export interface IButtonLineComponentProps {
  238. data: string;
  239. }
  240. export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
  241. constructor(props: IButtonLineComponentProps);
  242. render(): JSX.Element;
  243. }
  244. }
  245. declare module NODEEDITOR {
  246. interface INodeListComponentProps {
  247. globalState: GlobalState;
  248. }
  249. export class NodeListComponent extends React.Component<INodeListComponentProps, {
  250. filter: string;
  251. }> {
  252. constructor(props: INodeListComponentProps);
  253. filterContent(filter: string): void;
  254. render(): JSX.Element;
  255. }
  256. }
  257. declare module NODEEDITOR {
  258. export interface IButtonLineComponentProps {
  259. label: string;
  260. onClick: () => void;
  261. }
  262. export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
  263. constructor(props: IButtonLineComponentProps);
  264. render(): JSX.Element;
  265. }
  266. }
  267. declare module NODEEDITOR {
  268. export class StringTools {
  269. /**
  270. * Gets the base math type of node material block connection point.
  271. * @param type Type to parse.
  272. */
  273. static GetBaseType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
  274. /**
  275. * Download a string into a file that will be saved locally by the browser
  276. * @param content defines the string to download locally as a file
  277. */
  278. static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
  279. }
  280. }
  281. declare module NODEEDITOR {
  282. interface IFileButtonLineComponentProps {
  283. label: string;
  284. onClick: (file: File) => void;
  285. accept: string;
  286. }
  287. export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
  288. constructor(props: IFileButtonLineComponentProps);
  289. onChange(evt: any): void;
  290. render(): JSX.Element;
  291. }
  292. }
  293. declare module NODEEDITOR {
  294. export interface INodeLocationInfo {
  295. blockId: number;
  296. x: number;
  297. y: number;
  298. }
  299. }
  300. declare module NODEEDITOR {
  301. export class SerializationTools {
  302. static Serialize(material: BABYLON.NodeMaterial, globalState: GlobalState): string;
  303. static Deserialize(serializationObject: any, globalState: GlobalState): void;
  304. }
  305. }
  306. declare module NODEEDITOR {
  307. interface IPropertyTabComponentProps {
  308. globalState: GlobalState;
  309. }
  310. export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, {
  311. currentNode: BABYLON.Nullable<DefaultNodeModel>;
  312. }> {
  313. constructor(props: IPropertyTabComponentProps);
  314. componentDidMount(): void;
  315. load(file: File): void;
  316. save(): void;
  317. customSave(): void;
  318. render(): JSX.Element;
  319. }
  320. }
  321. declare module NODEEDITOR {
  322. interface IPortalProps {
  323. globalState: GlobalState;
  324. }
  325. export class Portal extends React.Component<IPortalProps> {
  326. render(): React.ReactPortal;
  327. }
  328. }
  329. declare module NODEEDITOR {
  330. interface ITexturePropertyTabComponentProps {
  331. globalState: GlobalState;
  332. node: TextureNodeModel;
  333. }
  334. export class TexturePropertyTabComponent extends React.Component<ITexturePropertyTabComponentProps, {
  335. isEmbedded: boolean;
  336. }> {
  337. constructor(props: ITexturePropertyTabComponentProps);
  338. updateAftertextureLoad(): void;
  339. /**
  340. * Replaces the texture of the node
  341. * @param file the file of the texture to use
  342. */
  343. replaceTexture(file: File): void;
  344. replaceTextureWithUrl(url: string): void;
  345. render(): JSX.Element;
  346. }
  347. }
  348. declare module NODEEDITOR {
  349. /**
  350. * Texture node model which stores information about a node editor block
  351. */
  352. export class TextureNodeModel extends DefaultNodeModel {
  353. private _block;
  354. /**
  355. * Texture for the node if it exists
  356. */
  357. texture: BABYLON.Nullable<BABYLON.BaseTexture>;
  358. /**
  359. * Constructs the node model
  360. */
  361. constructor();
  362. renderProperties(globalState: GlobalState): JSX.Element;
  363. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  364. }
  365. }
  366. declare module NODEEDITOR {
  367. interface ITextureLineComponentProps {
  368. texture: BABYLON.BaseTexture;
  369. width: number;
  370. height: number;
  371. globalState?: any;
  372. hideChannelSelect?: boolean;
  373. }
  374. export class TextureLineComponent extends React.Component<ITextureLineComponentProps, {
  375. displayRed: boolean;
  376. displayGreen: boolean;
  377. displayBlue: boolean;
  378. displayAlpha: boolean;
  379. face: number;
  380. }> {
  381. constructor(props: ITextureLineComponentProps);
  382. shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
  383. displayRed: boolean;
  384. displayGreen: boolean;
  385. displayBlue: boolean;
  386. displayAlpha: boolean;
  387. face: number;
  388. }): boolean;
  389. componentDidMount(): void;
  390. componentDidUpdate(): void;
  391. updatePreview(): void;
  392. render(): JSX.Element;
  393. }
  394. }
  395. declare module NODEEDITOR {
  396. /**
  397. * GenericNodeWidgetProps
  398. */
  399. export interface ITextureNodeWidgetProps {
  400. node: BABYLON.Nullable<TextureNodeModel>;
  401. globalState: GlobalState;
  402. }
  403. /**
  404. * Used to display a node block for the node editor
  405. */
  406. export class TextureNodeWidget extends React.Component<ITextureNodeWidgetProps> {
  407. /**
  408. * Creates a GenericNodeWidget
  409. * @param props
  410. */
  411. constructor(props: ITextureNodeWidgetProps);
  412. render(): JSX.Element;
  413. }
  414. }
  415. declare module NODEEDITOR {
  416. /**
  417. * Node factory which creates editor nodes
  418. */
  419. export class TextureNodeFactory extends SRD.AbstractNodeFactory {
  420. private _globalState;
  421. /**
  422. * Constructs a TextureNodeFactory
  423. */
  424. constructor(globalState: GlobalState);
  425. /**
  426. * Generates a node widget
  427. * @param diagramEngine diagram engine
  428. * @param node node to generate
  429. * @returns node widget jsx
  430. */
  431. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: TextureNodeModel): JSX.Element;
  432. /**
  433. * Gets a new instance of a node model
  434. * @returns texture node model
  435. */
  436. getNewInstance(): TextureNodeModel;
  437. }
  438. }
  439. declare module NODEEDITOR {
  440. interface INumericInputComponentProps {
  441. label: string;
  442. value: number;
  443. step?: number;
  444. onChange: (value: number) => void;
  445. }
  446. export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
  447. value: string;
  448. }> {
  449. static defaultProps: {
  450. step: number;
  451. };
  452. private _localChange;
  453. constructor(props: INumericInputComponentProps);
  454. shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
  455. value: string;
  456. }): boolean;
  457. updateValue(evt: any): void;
  458. render(): JSX.Element;
  459. }
  460. }
  461. declare module NODEEDITOR {
  462. interface IVector2LineComponentProps {
  463. label: string;
  464. target: any;
  465. propertyName: string;
  466. step?: number;
  467. onChange?: (newvalue: BABYLON.Vector2) => void;
  468. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  469. }
  470. export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
  471. isExpanded: boolean;
  472. value: BABYLON.Vector2;
  473. }> {
  474. static defaultProps: {
  475. step: number;
  476. };
  477. private _localChange;
  478. constructor(props: IVector2LineComponentProps);
  479. shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
  480. isExpanded: boolean;
  481. value: BABYLON.Vector2;
  482. }): boolean;
  483. switchExpandState(): void;
  484. raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
  485. updateStateX(value: number): void;
  486. updateStateY(value: number): void;
  487. render(): JSX.Element;
  488. }
  489. }
  490. declare module NODEEDITOR {
  491. interface IVector2PropertyTabComponentProps {
  492. globalState: GlobalState;
  493. inputBlock: BABYLON.InputBlock;
  494. }
  495. export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
  496. render(): JSX.Element;
  497. }
  498. }
  499. declare module NODEEDITOR {
  500. interface IVector3LineComponentProps {
  501. label: string;
  502. target: any;
  503. propertyName: string;
  504. step?: number;
  505. onChange?: (newvalue: BABYLON.Vector3) => void;
  506. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  507. }
  508. export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
  509. isExpanded: boolean;
  510. value: BABYLON.Vector3;
  511. }> {
  512. static defaultProps: {
  513. step: number;
  514. };
  515. private _localChange;
  516. constructor(props: IVector3LineComponentProps);
  517. shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
  518. isExpanded: boolean;
  519. value: BABYLON.Vector3;
  520. }): boolean;
  521. switchExpandState(): void;
  522. raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
  523. updateVector3(): void;
  524. updateStateX(value: number): void;
  525. updateStateY(value: number): void;
  526. updateStateZ(value: number): void;
  527. render(): JSX.Element;
  528. }
  529. }
  530. declare module NODEEDITOR {
  531. interface IVector3PropertyTabComponentProps {
  532. globalState: GlobalState;
  533. inputBlock: BABYLON.InputBlock;
  534. }
  535. export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
  536. render(): JSX.Element;
  537. }
  538. }
  539. declare module NODEEDITOR {
  540. class ListLineOption {
  541. label: string;
  542. value: number | string;
  543. }
  544. interface IOptionsLineComponentProps {
  545. label: string;
  546. target: any;
  547. propertyName?: string;
  548. options: ListLineOption[];
  549. noDirectUpdate?: boolean;
  550. onSelect?: (value: number | string) => void;
  551. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  552. valuesAreStrings?: boolean;
  553. defaultIfNull?: number;
  554. getSelection?: (target: any) => number;
  555. }
  556. export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
  557. value: number | string;
  558. }> {
  559. private _localChange;
  560. private _getValue;
  561. constructor(props: IOptionsLineComponentProps);
  562. shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
  563. value: number;
  564. }): boolean;
  565. raiseOnPropertyChanged(newValue: number | string, previousValue: number | string): void;
  566. updateValue(valueString: string): void;
  567. render(): JSX.Element;
  568. }
  569. }
  570. declare module NODEEDITOR {
  571. export interface IColor3LineComponentProps {
  572. label: string;
  573. target: any;
  574. propertyName: string;
  575. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  576. onChange?: () => void;
  577. }
  578. export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
  579. isExpanded: boolean;
  580. color: BABYLON.Color3;
  581. }> {
  582. private _localChange;
  583. constructor(props: IColor3LineComponentProps);
  584. shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
  585. color: BABYLON.Color3;
  586. }): boolean;
  587. onChange(newValue: string): void;
  588. switchExpandState(): void;
  589. raiseOnPropertyChanged(previousValue: BABYLON.Color3): void;
  590. updateStateR(value: number): void;
  591. updateStateG(value: number): void;
  592. updateStateB(value: number): void;
  593. copyToClipboard(): void;
  594. render(): JSX.Element;
  595. }
  596. }
  597. declare module NODEEDITOR {
  598. interface IColor3PropertyTabComponentProps {
  599. globalState: GlobalState;
  600. inputBlock: BABYLON.InputBlock;
  601. }
  602. export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
  603. render(): JSX.Element;
  604. }
  605. }
  606. declare module NODEEDITOR {
  607. interface IFloatLineComponentProps {
  608. label: string;
  609. target: any;
  610. propertyName: string;
  611. onChange?: (newValue: number) => void;
  612. isInteger?: boolean;
  613. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  614. additionalClass?: string;
  615. step?: string;
  616. digits?: number;
  617. }
  618. export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
  619. value: string;
  620. }> {
  621. private _localChange;
  622. private _store;
  623. constructor(props: IFloatLineComponentProps);
  624. shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
  625. value: string;
  626. }): boolean;
  627. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  628. updateValue(valueString: string): void;
  629. render(): JSX.Element;
  630. }
  631. }
  632. declare module NODEEDITOR {
  633. interface IFloatPropertyTabComponentProps {
  634. globalState: GlobalState;
  635. inputBlock: BABYLON.InputBlock;
  636. }
  637. export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
  638. render(): JSX.Element;
  639. }
  640. }
  641. declare module NODEEDITOR {
  642. interface IVector4LineComponentProps {
  643. label: string;
  644. target?: any;
  645. propertyName?: string;
  646. value?: BABYLON.Vector4;
  647. step?: number;
  648. onChange?: (newvalue: BABYLON.Vector4) => void;
  649. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  650. }
  651. export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
  652. isExpanded: boolean;
  653. value: BABYLON.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: BABYLON.Vector4;
  663. }): boolean;
  664. switchExpandState(): void;
  665. raiseOnPropertyChanged(previousValue: BABYLON.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 NODEEDITOR {
  675. interface IVector4PropertyTabComponentProps {
  676. globalState: GlobalState;
  677. inputBlock: BABYLON.InputBlock;
  678. }
  679. export class Vector4PropertyTabComponent extends React.Component<IVector4PropertyTabComponentProps> {
  680. render(): JSX.Element;
  681. }
  682. }
  683. declare module NODEEDITOR {
  684. interface IMatrixLineComponentProps {
  685. label: string;
  686. target: any;
  687. propertyName: string;
  688. step?: number;
  689. onChange?: (newValue: BABYLON.Matrix) => void;
  690. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  691. }
  692. export class MatrixLineComponent extends React.Component<IMatrixLineComponentProps, {
  693. value: BABYLON.Matrix;
  694. }> {
  695. private _localChange;
  696. constructor(props: IMatrixLineComponentProps);
  697. shouldComponentUpdate(nextProps: IMatrixLineComponentProps, nextState: {
  698. value: BABYLON.Matrix;
  699. }): boolean;
  700. raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
  701. updateMatrix(): void;
  702. updateRow(value: BABYLON.Vector4, row: number): void;
  703. render(): JSX.Element;
  704. }
  705. }
  706. declare module NODEEDITOR {
  707. interface IMatrixPropertyTabComponentProps {
  708. globalState: GlobalState;
  709. inputBlock: BABYLON.InputBlock;
  710. }
  711. export class MatrixPropertyTabComponent extends React.Component<IMatrixPropertyTabComponentProps> {
  712. render(): JSX.Element;
  713. }
  714. }
  715. declare module NODEEDITOR {
  716. interface IInputPropertyTabComponentProps {
  717. globalState: GlobalState;
  718. inputNode: InputNodeModel;
  719. }
  720. export class InputPropertyTabComponentProps extends React.Component<IInputPropertyTabComponentProps> {
  721. constructor(props: IInputPropertyTabComponentProps);
  722. renderValue(globalState: GlobalState): JSX.Element | null;
  723. setDefaultValue(): void;
  724. render(): JSX.Element;
  725. }
  726. }
  727. declare module NODEEDITOR {
  728. /**
  729. * Generic node model which stores information about a node editor block
  730. */
  731. export class InputNodeModel extends DefaultNodeModel {
  732. readonly inputBlock: BABYLON.InputBlock;
  733. /**
  734. * Constructs the node model
  735. */
  736. constructor();
  737. renderProperties(globalState: GlobalState): JSX.Element;
  738. }
  739. }
  740. declare module NODEEDITOR {
  741. /**
  742. * GenericNodeWidgetProps
  743. */
  744. export interface IInputNodeWidgetProps {
  745. node: BABYLON.Nullable<InputNodeModel>;
  746. globalState: GlobalState;
  747. }
  748. /**
  749. * Used to display a node block for the node editor
  750. */
  751. export class InputNodeWidget extends React.Component<IInputNodeWidgetProps> {
  752. /**
  753. * Creates a GenericNodeWidget
  754. * @param props
  755. */
  756. constructor(props: IInputNodeWidgetProps);
  757. renderValue(value: string): JSX.Element | null;
  758. render(): JSX.Element | null;
  759. }
  760. }
  761. declare module NODEEDITOR {
  762. /**
  763. * Node factory which creates editor nodes
  764. */
  765. export class InputNodeFactory extends SRD.AbstractNodeFactory {
  766. private _globalState;
  767. /**
  768. * Constructs a GenericNodeFactory
  769. */
  770. constructor(globalState: GlobalState);
  771. /**
  772. * Generates a node widget
  773. * @param diagramEngine diagram engine
  774. * @param node node to generate
  775. * @returns node widget jsx
  776. */
  777. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: InputNodeModel): JSX.Element;
  778. /**
  779. * Gets a new instance of a node model
  780. * @returns input node model
  781. */
  782. getNewInstance(): InputNodeModel;
  783. }
  784. }
  785. declare module NODEEDITOR {
  786. interface ILogComponentProps {
  787. globalState: GlobalState;
  788. }
  789. export class LogEntry {
  790. message: string;
  791. isError: boolean;
  792. constructor(message: string, isError: boolean);
  793. }
  794. export class LogComponent extends React.Component<ILogComponentProps, {
  795. logs: LogEntry[];
  796. }> {
  797. constructor(props: ILogComponentProps);
  798. componentDidMount(): void;
  799. componentDidUpdate(): void;
  800. render(): JSX.Element;
  801. }
  802. }
  803. declare module NODEEDITOR {
  804. interface ILightPropertyTabComponentProps {
  805. globalState: GlobalState;
  806. node: LightNodeModel;
  807. }
  808. export class LightPropertyTabComponent extends React.Component<ILightPropertyTabComponentProps> {
  809. render(): JSX.Element;
  810. }
  811. }
  812. declare module NODEEDITOR {
  813. /**
  814. * BABYLON.Light node model which stores information about a node editor block
  815. */
  816. export class LightNodeModel extends DefaultNodeModel {
  817. private _block;
  818. /**
  819. * BABYLON.Light for the node if it exists
  820. */
  821. light: BABYLON.Nullable<BABYLON.Light>;
  822. /**
  823. * Constructs the node model
  824. */
  825. constructor();
  826. renderProperties(globalState: GlobalState): JSX.Element;
  827. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  828. }
  829. }
  830. declare module NODEEDITOR {
  831. /**
  832. * GenericNodeWidgetProps
  833. */
  834. export interface ILightNodeWidgetProps {
  835. node: BABYLON.Nullable<LightNodeModel>;
  836. globalState: GlobalState;
  837. }
  838. /**
  839. * Used to display a node block for the node editor
  840. */
  841. export class LightNodeWidget extends React.Component<ILightNodeWidgetProps> {
  842. /**
  843. * Creates a GenericNodeWidget
  844. * @param props
  845. */
  846. constructor(props: ILightNodeWidgetProps);
  847. render(): JSX.Element;
  848. }
  849. }
  850. declare module NODEEDITOR {
  851. /**
  852. * Node factory which creates editor nodes
  853. */
  854. export class LightNodeFactory extends SRD.AbstractNodeFactory {
  855. private _globalState;
  856. /**
  857. * Constructs a LightNodeFactory
  858. */
  859. constructor(globalState: GlobalState);
  860. /**
  861. * Generates a node widget
  862. * @param diagramEngine diagram engine
  863. * @param node node to generate
  864. * @returns node widget jsx
  865. */
  866. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: LightNodeModel): JSX.Element;
  867. /**
  868. * Gets a new instance of a node model
  869. * @returns light node model
  870. */
  871. getNewInstance(): LightNodeModel;
  872. }
  873. }
  874. declare module NODEEDITOR {
  875. interface IMessageDialogComponentProps {
  876. globalState: GlobalState;
  877. }
  878. export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
  879. message: string;
  880. isError: boolean;
  881. }> {
  882. constructor(props: IMessageDialogComponentProps);
  883. render(): JSX.Element | null;
  884. }
  885. }
  886. declare module NODEEDITOR {
  887. export class AdvancedLinkFactory extends DefaultLinkFactory {
  888. constructor();
  889. getNewInstance(initialConfig?: any): AdvancedLinkModel;
  890. generateLinkSegment(model: AdvancedLinkModel, widget: DefaultLinkWidget, selected: boolean, path: string): JSX.Element;
  891. }
  892. }
  893. declare module NODEEDITOR {
  894. interface IRemapPropertyTabComponentProps {
  895. globalState: GlobalState;
  896. remapNode: RemapNodeModel;
  897. }
  898. export class RemapPropertyTabComponentProps extends React.Component<IRemapPropertyTabComponentProps> {
  899. constructor(props: IRemapPropertyTabComponentProps);
  900. forceRebuild(): void;
  901. render(): JSX.Element;
  902. }
  903. }
  904. declare module NODEEDITOR {
  905. /**
  906. * Generic node model which stores information about a node editor block
  907. */
  908. export class RemapNodeModel extends DefaultNodeModel {
  909. readonly remapBlock: BABYLON.RemapBlock;
  910. /**
  911. * Constructs the node model
  912. */
  913. constructor();
  914. renderProperties(globalState: GlobalState): JSX.Element;
  915. }
  916. }
  917. declare module NODEEDITOR {
  918. /**
  919. * RemapNodeWidgetProps
  920. */
  921. export interface RemapNodeWidgetProps {
  922. node: BABYLON.Nullable<RemapNodeModel>;
  923. globalState: GlobalState;
  924. }
  925. /**
  926. * Used to display a node block for the node editor
  927. */
  928. export class RemapNodeWidget extends React.Component<RemapNodeWidgetProps> {
  929. /**
  930. * Creates a GenericNodeWidget
  931. * @param props
  932. */
  933. constructor(props: RemapNodeWidgetProps);
  934. renderValue(value: string): JSX.Element | null;
  935. extractInputValue(connectionPoint: BABYLON.NodeMaterialConnectionPoint): any;
  936. render(): JSX.Element;
  937. }
  938. }
  939. declare module NODEEDITOR {
  940. /**
  941. * Node factory which creates editor nodes
  942. */
  943. export class RemapNodeFactory extends SRD.AbstractNodeFactory {
  944. private _globalState;
  945. /**
  946. * Constructs a GenericNodeFactory
  947. */
  948. constructor(globalState: GlobalState);
  949. /**
  950. * Generates a node widget
  951. * @param diagramEngine diagram engine
  952. * @param node node to generate
  953. * @returns node widget jsx
  954. */
  955. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: RemapNodeModel): JSX.Element;
  956. /**
  957. * Gets a new instance of a node model
  958. * @returns input node model
  959. */
  960. getNewInstance(): RemapNodeModel;
  961. }
  962. }
  963. declare module NODEEDITOR {
  964. export class GraphHelper {
  965. static DistributeGraph(model: DiagramModel): dagre.Node[];
  966. private static _MapElements;
  967. private static _MapEdges;
  968. }
  969. }
  970. declare module NODEEDITOR {
  971. export enum PreviewMeshType {
  972. Sphere = 0,
  973. Box = 1,
  974. Torus = 2,
  975. Cylinder = 3,
  976. Plane = 4,
  977. Custom = 5
  978. }
  979. }
  980. declare module NODEEDITOR {
  981. export class PreviewManager {
  982. private _nodeMaterial;
  983. private _onBuildObserver;
  984. private _onPreviewCommandActivatedObserver;
  985. private _onUpdateRequiredObserver;
  986. private _engine;
  987. private _scene;
  988. private _light;
  989. private _dummy;
  990. private _camera;
  991. private _material;
  992. private _globalState;
  993. private _currentType;
  994. constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
  995. private _refreshPreviewMesh;
  996. private _updatePreview;
  997. dispose(): void;
  998. }
  999. }
  1000. declare module NODEEDITOR {
  1001. interface IPreviewMeshControlComponent {
  1002. globalState: GlobalState;
  1003. }
  1004. export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
  1005. changeMeshType(newOne: PreviewMeshType): void;
  1006. useCustomMesh(evt: any): void;
  1007. render(): JSX.Element;
  1008. }
  1009. }
  1010. declare module NODEEDITOR {
  1011. interface ITrigonometryTabComponentProps {
  1012. globalState: GlobalState;
  1013. trigonometryNode: TrigonometryNodeModel;
  1014. }
  1015. export class TrigonometryPropertyTabComponentProps extends React.Component<ITrigonometryTabComponentProps> {
  1016. constructor(props: ITrigonometryTabComponentProps);
  1017. render(): JSX.Element;
  1018. }
  1019. }
  1020. declare module NODEEDITOR {
  1021. /**
  1022. * Generic node model which stores information about a node editor block
  1023. */
  1024. export class TrigonometryNodeModel extends DefaultNodeModel {
  1025. readonly trigonometryBlock: BABYLON.TrigonometryBlock;
  1026. /**
  1027. * Constructs the node model
  1028. */
  1029. constructor();
  1030. renderProperties(globalState: GlobalState): JSX.Element;
  1031. }
  1032. }
  1033. declare module NODEEDITOR {
  1034. /**
  1035. * GenericNodeWidgetProps
  1036. */
  1037. export interface ITrigonometryNodeWidgetProps {
  1038. node: BABYLON.Nullable<TrigonometryNodeModel>;
  1039. globalState: GlobalState;
  1040. }
  1041. /**
  1042. * Used to display a node block for the node editor
  1043. */
  1044. export class TrigonometryNodeWidget extends React.Component<ITrigonometryNodeWidgetProps> {
  1045. /**
  1046. * Creates a GenericNodeWidget
  1047. * @param props
  1048. */
  1049. constructor(props: ITrigonometryNodeWidgetProps);
  1050. render(): JSX.Element;
  1051. }
  1052. }
  1053. declare module NODEEDITOR {
  1054. /**
  1055. * Node factory which creates editor nodes
  1056. */
  1057. export class TrigonometryNodeFactory extends SRD.AbstractNodeFactory {
  1058. private _globalState;
  1059. /**
  1060. * Constructs a GenericNodeFactory
  1061. */
  1062. constructor(globalState: GlobalState);
  1063. /**
  1064. * Generates a node widget
  1065. * @param diagramEngine diagram engine
  1066. * @param node node to generate
  1067. * @returns node widget jsx
  1068. */
  1069. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: TrigonometryNodeModel): JSX.Element;
  1070. /**
  1071. * Gets a new instance of a node model
  1072. * @returns input node model
  1073. */
  1074. getNewInstance(): TrigonometryNodeModel;
  1075. }
  1076. }
  1077. declare module NODEEDITOR {
  1078. interface IClampPropertyTabComponentProps {
  1079. globalState: GlobalState;
  1080. remapNode: ClampNodeModel;
  1081. }
  1082. export class ClampPropertyTabComponentProps extends React.Component<IClampPropertyTabComponentProps> {
  1083. constructor(props: IClampPropertyTabComponentProps);
  1084. forceRebuild(): void;
  1085. render(): JSX.Element;
  1086. }
  1087. }
  1088. declare module NODEEDITOR {
  1089. export class ClampNodeModel extends DefaultNodeModel {
  1090. readonly clampBlock: BABYLON.ClampBlock;
  1091. /**
  1092. * Constructs the node model
  1093. */
  1094. constructor();
  1095. renderProperties(globalState: GlobalState): JSX.Element;
  1096. }
  1097. }
  1098. declare module NODEEDITOR {
  1099. export interface ClampNodeWidgetProps {
  1100. node: BABYLON.Nullable<ClampNodeModel>;
  1101. globalState: GlobalState;
  1102. }
  1103. export class ClampNodeWidget extends React.Component<ClampNodeWidgetProps> {
  1104. constructor(props: ClampNodeWidgetProps);
  1105. renderValue(value: string): JSX.Element | null;
  1106. render(): JSX.Element;
  1107. }
  1108. }
  1109. declare module NODEEDITOR {
  1110. export class ClampNodeFactory extends SRD.AbstractNodeFactory {
  1111. private _globalState;
  1112. constructor(globalState: GlobalState);
  1113. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: ClampNodeModel): JSX.Element;
  1114. getNewInstance(): ClampNodeModel;
  1115. }
  1116. }
  1117. declare module NODEEDITOR {
  1118. interface ILightPropertyTabComponentProps {
  1119. globalState: GlobalState;
  1120. node: LightInformationNodeModel;
  1121. }
  1122. export class LightInformationPropertyTabComponent extends React.Component<ILightPropertyTabComponentProps> {
  1123. render(): JSX.Element;
  1124. }
  1125. }
  1126. declare module NODEEDITOR {
  1127. export class LightInformationNodeModel extends DefaultNodeModel {
  1128. private _block;
  1129. /**
  1130. * BABYLON.Light for the node if it exists
  1131. */
  1132. light: BABYLON.Nullable<BABYLON.Light>;
  1133. /**
  1134. * Constructs the node model
  1135. */
  1136. constructor();
  1137. renderProperties(globalState: GlobalState): JSX.Element;
  1138. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  1139. }
  1140. }
  1141. declare module NODEEDITOR {
  1142. /**
  1143. * GenericNodeWidgetProps
  1144. */
  1145. export interface ILightInformationNodeWidgetProps {
  1146. node: BABYLON.Nullable<LightInformationNodeModel>;
  1147. globalState: GlobalState;
  1148. }
  1149. /**
  1150. * Used to display a node block for the node editor
  1151. */
  1152. export class LightInformationNodeWidget extends React.Component<ILightInformationNodeWidgetProps> {
  1153. /**
  1154. * Creates a GenericNodeWidget
  1155. * @param props
  1156. */
  1157. constructor(props: ILightInformationNodeWidgetProps);
  1158. render(): JSX.Element;
  1159. }
  1160. }
  1161. declare module NODEEDITOR {
  1162. /**
  1163. * Node factory which creates editor nodes
  1164. */
  1165. export class LightInformationNodeFactory extends SRD.AbstractNodeFactory {
  1166. private _globalState;
  1167. /**
  1168. * Constructs a LightNodeFactory
  1169. */
  1170. constructor(globalState: GlobalState);
  1171. /**
  1172. * Generates a node widget
  1173. * @param diagramEngine diagram engine
  1174. * @param node node to generate
  1175. * @returns node widget jsx
  1176. */
  1177. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: LightInformationNodeModel): JSX.Element;
  1178. /**
  1179. * Gets a new instance of a node model
  1180. * @returns light node model
  1181. */
  1182. getNewInstance(): LightInformationNodeModel;
  1183. }
  1184. }
  1185. declare module NODEEDITOR {
  1186. interface IPreviewAreaComponent {
  1187. globalState: GlobalState;
  1188. width: number;
  1189. }
  1190. export class PreviewAreaComponent extends React.Component<IPreviewAreaComponent> {
  1191. changeAnimation(): void;
  1192. changeBackground(value: string): void;
  1193. render(): JSX.Element;
  1194. }
  1195. }
  1196. declare module NODEEDITOR {
  1197. interface IGraphEditorProps {
  1198. globalState: GlobalState;
  1199. }
  1200. export class NodeCreationOptions {
  1201. nodeMaterialBlock: BABYLON.NodeMaterialBlock;
  1202. type?: string;
  1203. connection?: BABYLON.NodeMaterialConnectionPoint;
  1204. }
  1205. export class GraphEditor extends React.Component<IGraphEditorProps> {
  1206. private readonly NodeWidth;
  1207. private _engine;
  1208. private _model;
  1209. private _startX;
  1210. private _moveInProgress;
  1211. private _leftWidth;
  1212. private _rightWidth;
  1213. private _nodes;
  1214. private _blocks;
  1215. private _previewManager;
  1216. private _copiedNodes;
  1217. private _mouseLocationX;
  1218. private _mouseLocationY;
  1219. private _onWidgetKeyUpPointer;
  1220. /** @hidden */
  1221. _toAdd: LinkModel[] | null;
  1222. /**
  1223. * Creates a node and recursivly creates its parent nodes from it's input
  1224. * @param nodeMaterialBlock
  1225. */
  1226. createNodeFromObject(options: NodeCreationOptions): DefaultNodeModel;
  1227. addValueNode(type: string): DefaultNodeModel;
  1228. onWidgetKeyUp(evt: any): void;
  1229. componentDidMount(): void;
  1230. componentWillUnmount(): void;
  1231. constructor(props: IGraphEditorProps);
  1232. zoomToFit(retry?: number): void;
  1233. buildMaterial(): void;
  1234. applyFragmentOutputConstraints(rootInput: DefaultPortModel): void;
  1235. build(needToWait?: boolean, locations?: BABYLON.Nullable<INodeLocationInfo[]>): void;
  1236. reOrganize(locations?: BABYLON.Nullable<INodeLocationInfo[]>): void;
  1237. onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
  1238. onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
  1239. resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
  1240. buildColumnLayout(): string;
  1241. emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
  1242. render(): JSX.Element;
  1243. }
  1244. }
  1245. declare module NODEEDITOR {
  1246. /**
  1247. * Generic node model which stores information about a node editor block
  1248. */
  1249. export class DefaultNodeModel extends NodeModel {
  1250. /**
  1251. * The babylon block this node represents
  1252. */
  1253. block: BABYLON.Nullable<BABYLON.NodeMaterialBlock>;
  1254. ports: {
  1255. [s: string]: DefaultPortModel;
  1256. };
  1257. /**
  1258. * Constructs the node model
  1259. */
  1260. constructor(key: string);
  1261. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  1262. renderProperties(globalState: GlobalState): JSX.Element | null;
  1263. }
  1264. }
  1265. declare module NODEEDITOR {
  1266. export class GlobalState {
  1267. nodeMaterial: BABYLON.NodeMaterial;
  1268. hostElement: HTMLElement;
  1269. hostDocument: HTMLDocument;
  1270. onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<DefaultNodeModel>>;
  1271. onRebuildRequiredObservable: BABYLON.Observable<void>;
  1272. onResetRequiredObservable: BABYLON.Observable<BABYLON.Nullable<INodeLocationInfo[]>>;
  1273. onUpdateRequiredObservable: BABYLON.Observable<void>;
  1274. onZoomToFitRequiredObservable: BABYLON.Observable<void>;
  1275. onReOrganizedRequiredObservable: BABYLON.Observable<void>;
  1276. onLogRequiredObservable: BABYLON.Observable<LogEntry>;
  1277. onErrorMessageDialogRequiredObservable: BABYLON.Observable<string>;
  1278. onPreviewCommandActivated: BABYLON.Observable<void>;
  1279. onGetNodeFromBlock: (block: BABYLON.NodeMaterialBlock) => NodeModel;
  1280. previewMeshType: PreviewMeshType;
  1281. rotatePreview: boolean;
  1282. backgroundColor: BABYLON.Color4;
  1283. blockKeyboardEvents: boolean;
  1284. customSave?: {
  1285. label: string;
  1286. action: (data: string) => Promise<void>;
  1287. };
  1288. constructor();
  1289. }
  1290. }
  1291. declare module NODEEDITOR {
  1292. export class Popup {
  1293. static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): HTMLDivElement | null;
  1294. private static _CopyStyles;
  1295. }
  1296. }
  1297. declare module NODEEDITOR {
  1298. /**
  1299. * Interface used to specify creation options for the node editor
  1300. */
  1301. export interface INodeEditorOptions {
  1302. nodeMaterial: BABYLON.NodeMaterial;
  1303. hostElement?: HTMLElement;
  1304. customSave?: {
  1305. label: string;
  1306. action: (data: string) => Promise<void>;
  1307. };
  1308. customLoadObservable?: BABYLON.Observable<any>;
  1309. }
  1310. /**
  1311. * Class used to create a node editor
  1312. */
  1313. export class NodeEditor {
  1314. private static _CurrentState;
  1315. /**
  1316. * Show the node editor
  1317. * @param options defines the options to use to configure the node editor
  1318. */
  1319. static Show(options: INodeEditorOptions): void;
  1320. }
  1321. }