babylon.nodeEditor.module.d.ts 93 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407
  1. /// <reference types="react" />
  2. declare module "babylonjs-node-editor/blockTools" {
  3. import { AlphaTestBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/alphaTestBlock';
  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/nodeMaterialBlockConnectionPointTypes';
  29. import { FresnelBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/fresnelBlock';
  30. export class BlockTools {
  31. static GetBlockFromString(data: string): BonesBlock | InstancesBlock | MorphTargetsBlock | AlphaTestBlock | ImageProcessingBlock | ColorMergerBlock | VectorMergerBlock | ColorSplitterBlock | VectorSplitterBlock | TextureBlock | ReflectionTextureBlock | LightBlock | FogBlock | VertexOutputBlock | FragmentOutputBlock | AddBlock | ClampBlock | ScaleBlock | CrossBlock | DotBlock | MultiplyBlock | TransformBlock | TrigonometryBlock | RemapBlock | NormalizeBlock | FresnelBlock | null;
  32. static GetColorFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): string;
  33. static GetConnectionNodeTypeFromString(type: string): NodeMaterialBlockConnectionPointTypes.Float | NodeMaterialBlockConnectionPointTypes.Vector2 | NodeMaterialBlockConnectionPointTypes.Vector3 | NodeMaterialBlockConnectionPointTypes.Vector4 | NodeMaterialBlockConnectionPointTypes.Color3 | NodeMaterialBlockConnectionPointTypes.Color4 | NodeMaterialBlockConnectionPointTypes.Matrix | NodeMaterialBlockConnectionPointTypes.AutoDetect;
  34. static GetStringFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes): "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4" | "";
  35. }
  36. }
  37. declare module "babylonjs-node-editor/dataStorage" {
  38. export class DataStorage {
  39. private static _InMemoryStorage;
  40. static ReadBoolean(key: string, defaultValue: boolean): boolean;
  41. static StoreBoolean(key: string, value: boolean): void;
  42. static ReadNumber(key: string, defaultValue: number): number;
  43. static StoreNumber(key: string, value: number): void;
  44. }
  45. }
  46. declare module "babylonjs-node-editor/sharedComponents/textLineComponent" {
  47. import * as React from "react";
  48. interface ITextLineComponentProps {
  49. label: string;
  50. value: string;
  51. color?: string;
  52. underline?: boolean;
  53. onLink?: () => void;
  54. }
  55. export class TextLineComponent extends React.Component<ITextLineComponentProps> {
  56. constructor(props: ITextLineComponentProps);
  57. onLink(): void;
  58. renderContent(): JSX.Element;
  59. render(): JSX.Element;
  60. }
  61. }
  62. declare module "babylonjs-node-editor/sharedComponents/lineContainerComponent" {
  63. import * as React from "react";
  64. interface ILineContainerComponentProps {
  65. title: string;
  66. children: any[] | any;
  67. closed?: boolean;
  68. }
  69. export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
  70. isExpanded: boolean;
  71. }> {
  72. constructor(props: ILineContainerComponentProps);
  73. switchExpandedState(): void;
  74. renderHeader(): JSX.Element;
  75. render(): JSX.Element;
  76. }
  77. }
  78. declare module "babylonjs-node-editor/sharedComponents/propertyChangedEvent" {
  79. export class PropertyChangedEvent {
  80. object: any;
  81. property: string;
  82. value: any;
  83. initialValue: any;
  84. }
  85. }
  86. declare module "babylonjs-node-editor/sharedComponents/textInputLineComponent" {
  87. import * as React from "react";
  88. import { Observable } from "babylonjs/Misc/observable";
  89. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  90. import { GlobalState } from "babylonjs-node-editor/globalState";
  91. interface ITextInputLineComponentProps {
  92. label: string;
  93. globalState: GlobalState;
  94. target?: any;
  95. propertyName?: string;
  96. value?: string;
  97. onChange?: (value: string) => void;
  98. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  99. }
  100. export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
  101. value: string;
  102. }> {
  103. private _localChange;
  104. constructor(props: ITextInputLineComponentProps);
  105. shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
  106. value: string;
  107. }): boolean;
  108. raiseOnPropertyChanged(newValue: string, previousValue: string): void;
  109. updateValue(value: string, raisePropertyChanged: boolean): void;
  110. render(): JSX.Element;
  111. }
  112. }
  113. declare module "babylonjs-node-editor/sharedComponents/checkBoxLineComponent" {
  114. import * as React from "react";
  115. import { Observable } from "babylonjs/Misc/observable";
  116. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  117. export interface ICheckBoxLineComponentProps {
  118. label: string;
  119. target?: any;
  120. propertyName?: string;
  121. isSelected?: () => boolean;
  122. onSelect?: (value: boolean) => void;
  123. onValueChanged?: () => void;
  124. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  125. }
  126. export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
  127. isSelected: boolean;
  128. }> {
  129. private static _UniqueIdSeed;
  130. private _uniqueId;
  131. private _localChange;
  132. constructor(props: ICheckBoxLineComponentProps);
  133. shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
  134. isSelected: boolean;
  135. }): boolean;
  136. onChange(): void;
  137. render(): JSX.Element;
  138. }
  139. }
  140. declare module "babylonjs-node-editor/components/diagram/generic/genericNodeModel" {
  141. import { Nullable } from 'babylonjs/types';
  142. import { Vector2, Vector3, Vector4, Matrix } from 'babylonjs/Maths/math';
  143. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  144. import { DiagramModel } from 'storm-react-diagrams/dist/@types/src/models/DiagramModel';
  145. import { GraphEditor, NodeCreationOptions } from "babylonjs-node-editor/graphEditor";
  146. import { GlobalState } from "babylonjs-node-editor/globalState";
  147. /**
  148. * Generic node model which stores information about a node editor block
  149. */
  150. export class GenericNodeModel extends DefaultNodeModel {
  151. /**
  152. * Vector2 for the node if it exists
  153. */
  154. vector2: Nullable<Vector2>;
  155. /**
  156. * Vector3 for the node if it exists
  157. */
  158. vector3: Nullable<Vector3>;
  159. /**
  160. * Vector4 for the node if it exists
  161. */
  162. vector4: Nullable<Vector4>;
  163. /**
  164. * Matrix for the node if it exists
  165. */
  166. matrix: Nullable<Matrix>;
  167. /**
  168. * Constructs the node model
  169. */
  170. constructor();
  171. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  172. renderProperties(globalState: GlobalState): JSX.Element;
  173. }
  174. }
  175. declare module "babylonjs-node-editor/components/diagram/link/advancedLinkModel" {
  176. import { DefaultLinkModel } from 'storm-react-diagrams';
  177. export class AdvancedLinkModel extends DefaultLinkModel {
  178. constructor();
  179. }
  180. }
  181. declare module "babylonjs-node-editor/components/diagram/port/defaultPortModel" {
  182. import { LinkModel, PortModel } from "storm-react-diagrams";
  183. import { Nullable } from 'babylonjs/types';
  184. import { NodeMaterialConnectionPoint } from 'babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint';
  185. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  186. /**
  187. * Port model
  188. */
  189. export class DefaultPortModel extends PortModel {
  190. /**
  191. * If the port is input or output
  192. */
  193. position: string | "input" | "output";
  194. /**
  195. * What the port is connected to
  196. */
  197. connection: Nullable<NodeMaterialConnectionPoint>;
  198. defaultValue: any;
  199. static idCounter: number;
  200. constructor(name: string, type?: string);
  201. canLinkToPort(port: DefaultPortModel): boolean;
  202. syncWithNodeMaterialConnectionPoint(connection: NodeMaterialConnectionPoint): void;
  203. getNodeModel(): DefaultNodeModel;
  204. link(outPort: DefaultPortModel): LinkModel<import("storm-react-diagrams").LinkModelListener>;
  205. createLinkModel(): LinkModel;
  206. static SortInputOutput(a: Nullable<DefaultPortModel>, b: Nullable<DefaultPortModel>): {
  207. input: DefaultPortModel;
  208. output: DefaultPortModel;
  209. } | null;
  210. }
  211. }
  212. declare module "babylonjs-node-editor/components/diagram/port/defaultPortWidget" {
  213. import { BaseWidget, PortState, NodeModel, BaseWidgetProps } from 'storm-react-diagrams';
  214. export interface IDefaultPortWidgetProps extends BaseWidgetProps {
  215. name: string;
  216. node: NodeModel;
  217. style: any;
  218. }
  219. export class DefaultPortWidget extends BaseWidget<IDefaultPortWidgetProps, PortState> {
  220. constructor(props: IDefaultPortWidgetProps);
  221. getClassName(): string;
  222. render(): JSX.Element;
  223. }
  224. }
  225. declare module "babylonjs-node-editor/components/diagram/portHelper" {
  226. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  227. import { Nullable } from 'babylonjs/types';
  228. import { NodeMaterialBlockConnectionPointTypes } from 'babylonjs/Materials/Node/nodeMaterialBlockConnectionPointTypes';
  229. export class PortHelper {
  230. private static _GetPortTypeIndicator;
  231. static _GetPortStyle(type: NodeMaterialBlockConnectionPointTypes): {
  232. background: string;
  233. };
  234. static GenerateOutputPorts(node: Nullable<DefaultNodeModel>, ignoreLabel: boolean): JSX.Element[];
  235. static GenerateInputPorts(node: Nullable<DefaultNodeModel>, includeOnly?: string[], ignoreLabel?: boolean): JSX.Element[];
  236. }
  237. }
  238. declare module "babylonjs-node-editor/components/diagram/generic/genericNodeWidget" {
  239. import * as React from "react";
  240. import { Nullable } from 'babylonjs/types';
  241. import { GlobalState } from "babylonjs-node-editor/globalState";
  242. import { GenericNodeModel } from "babylonjs-node-editor/components/diagram/generic/genericNodeModel";
  243. /**
  244. * GenericNodeWidgetProps
  245. */
  246. export interface GenericNodeWidgetProps {
  247. node: Nullable<GenericNodeModel>;
  248. globalState: GlobalState;
  249. }
  250. /**
  251. * GenericNodeWidgetState
  252. */
  253. export interface GenericNodeWidgetState {
  254. }
  255. /**
  256. * Used to display a node block for the node editor
  257. */
  258. export class GenericNodeWidget extends React.Component<GenericNodeWidgetProps, GenericNodeWidgetState> {
  259. /**
  260. * Creates a GenericNodeWidget
  261. * @param props
  262. */
  263. constructor(props: GenericNodeWidgetProps);
  264. render(): JSX.Element;
  265. }
  266. }
  267. declare module "babylonjs-node-editor/components/diagram/generic/genericNodeFactory" {
  268. import * as SRD from "storm-react-diagrams";
  269. import { GenericNodeModel } from "babylonjs-node-editor/components/diagram/generic/genericNodeModel";
  270. import { GlobalState } from "babylonjs-node-editor/globalState";
  271. /**
  272. * Node factory which creates editor nodes
  273. */
  274. export class GenericNodeFactory extends SRD.AbstractNodeFactory {
  275. private _globalState;
  276. /**
  277. * Constructs a GenericNodeFactory
  278. */
  279. constructor(globalState: GlobalState);
  280. /**
  281. * Generates a node widget
  282. * @param diagramEngine diagram engine
  283. * @param node node to generate
  284. * @returns node widget jsx
  285. */
  286. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: GenericNodeModel): JSX.Element;
  287. /**
  288. * Gets a new instance of a node model
  289. * @returns generic node model
  290. */
  291. getNewInstance(): GenericNodeModel;
  292. }
  293. }
  294. declare module "babylonjs-node-editor/sharedComponents/draggableLineComponent" {
  295. import * as React from "react";
  296. export interface IButtonLineComponentProps {
  297. data: string;
  298. }
  299. export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
  300. constructor(props: IButtonLineComponentProps);
  301. render(): JSX.Element;
  302. }
  303. }
  304. declare module "babylonjs-node-editor/components/nodeList/nodeListComponent" {
  305. import * as React from "react";
  306. import { GlobalState } from "babylonjs-node-editor/globalState";
  307. interface INodeListComponentProps {
  308. globalState: GlobalState;
  309. }
  310. export class NodeListComponent extends React.Component<INodeListComponentProps> {
  311. render(): JSX.Element;
  312. }
  313. }
  314. declare module "babylonjs-node-editor/sharedComponents/buttonLineComponent" {
  315. import * as React from "react";
  316. export interface IButtonLineComponentProps {
  317. label: string;
  318. onClick: () => void;
  319. }
  320. export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
  321. constructor(props: IButtonLineComponentProps);
  322. render(): JSX.Element;
  323. }
  324. }
  325. declare module "babylonjs-node-editor/stringTools" {
  326. import { NodeMaterialBlockConnectionPointTypes } from 'babylonjs/Materials/Node/nodeMaterialBlockConnectionPointTypes';
  327. export class StringTools {
  328. /**
  329. * Gets the base math type of node material block connection point.
  330. * @param type Type to parse.
  331. */
  332. static GetBaseType(type: NodeMaterialBlockConnectionPointTypes): string;
  333. /**
  334. * Download a string into a file that will be saved locally by the browser
  335. * @param content defines the string to download locally as a file
  336. */
  337. static DownloadAsFile(content: string, filename: string): void;
  338. }
  339. }
  340. declare module "babylonjs-node-editor/sharedComponents/fileButtonLineComponent" {
  341. import * as React from "react";
  342. interface IFileButtonLineComponentProps {
  343. label: string;
  344. onClick: (file: File) => void;
  345. accept: string;
  346. }
  347. export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
  348. constructor(props: IFileButtonLineComponentProps);
  349. onChange(evt: any): void;
  350. render(): JSX.Element;
  351. }
  352. }
  353. declare module "babylonjs-node-editor/nodeLocationInfo" {
  354. export interface INodeLocationInfo {
  355. blockId: number;
  356. x: number;
  357. y: number;
  358. }
  359. }
  360. declare module "babylonjs-node-editor/components/propertyTab/propertyTabComponent" {
  361. import * as React from "react";
  362. import { GlobalState } from "babylonjs-node-editor/globalState";
  363. import { Nullable } from 'babylonjs/types';
  364. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  365. interface IPropertyTabComponentProps {
  366. globalState: GlobalState;
  367. }
  368. export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, {
  369. currentNode: Nullable<DefaultNodeModel>;
  370. }> {
  371. constructor(props: IPropertyTabComponentProps);
  372. componentWillMount(): void;
  373. load(file: File): void;
  374. save(): void;
  375. render(): JSX.Element;
  376. }
  377. }
  378. declare module "babylonjs-node-editor/portal" {
  379. import * as React from "react";
  380. import { GlobalState } from "babylonjs-node-editor/globalState";
  381. interface IPortalProps {
  382. globalState: GlobalState;
  383. }
  384. export class Portal extends React.Component<IPortalProps> {
  385. render(): React.ReactPortal;
  386. }
  387. }
  388. declare module "babylonjs-node-editor/components/diagram/texture/texturePropertyTabComponent" {
  389. import * as React from "react";
  390. import { GlobalState } from "babylonjs-node-editor/globalState";
  391. import { TextureNodeModel } from "babylonjs-node-editor/components/diagram/texture/textureNodeModel";
  392. interface ITexturePropertyTabComponentProps {
  393. globalState: GlobalState;
  394. node: TextureNodeModel;
  395. }
  396. export class TexturePropertyTabComponent extends React.Component<ITexturePropertyTabComponentProps> {
  397. updateAftertextureLoad(): void;
  398. /**
  399. * Replaces the texture of the node
  400. * @param file the file of the texture to use
  401. */
  402. replaceTexture(file: File): void;
  403. render(): JSX.Element;
  404. }
  405. }
  406. declare module "babylonjs-node-editor/components/diagram/texture/textureNodeModel" {
  407. import { Nullable } from 'babylonjs/types';
  408. import { BaseTexture } from 'babylonjs/Materials/Textures/baseTexture';
  409. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  410. import { GlobalState } from "babylonjs-node-editor/globalState";
  411. import { NodeCreationOptions, GraphEditor } from "babylonjs-node-editor/graphEditor";
  412. import { DiagramModel } from 'storm-react-diagrams/dist/@types/src/models/DiagramModel';
  413. /**
  414. * Texture node model which stores information about a node editor block
  415. */
  416. export class TextureNodeModel extends DefaultNodeModel {
  417. private _block;
  418. /**
  419. * Texture for the node if it exists
  420. */
  421. texture: Nullable<BaseTexture>;
  422. /**
  423. * Constructs the node model
  424. */
  425. constructor();
  426. renderProperties(globalState: GlobalState): JSX.Element;
  427. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  428. }
  429. }
  430. declare module "babylonjs-node-editor/sharedComponents/textureLineComponent" {
  431. import * as React from "react";
  432. import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
  433. interface ITextureLineComponentProps {
  434. texture: BaseTexture;
  435. width: number;
  436. height: number;
  437. globalState?: any;
  438. hideChannelSelect?: boolean;
  439. }
  440. export class TextureLineComponent extends React.Component<ITextureLineComponentProps, {
  441. displayRed: boolean;
  442. displayGreen: boolean;
  443. displayBlue: boolean;
  444. displayAlpha: boolean;
  445. face: number;
  446. }> {
  447. constructor(props: ITextureLineComponentProps);
  448. shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
  449. displayRed: boolean;
  450. displayGreen: boolean;
  451. displayBlue: boolean;
  452. displayAlpha: boolean;
  453. face: number;
  454. }): boolean;
  455. componentDidMount(): void;
  456. componentDidUpdate(): void;
  457. updatePreview(): void;
  458. render(): JSX.Element;
  459. }
  460. }
  461. declare module "babylonjs-node-editor/components/diagram/texture/textureNodeWidget" {
  462. import * as React from "react";
  463. import { TextureNodeModel } from "babylonjs-node-editor/components/diagram/texture/textureNodeModel";
  464. import { Nullable } from 'babylonjs/types';
  465. import { GlobalState } from "babylonjs-node-editor/globalState";
  466. /**
  467. * GenericNodeWidgetProps
  468. */
  469. export interface ITextureNodeWidgetProps {
  470. node: Nullable<TextureNodeModel>;
  471. globalState: GlobalState;
  472. }
  473. /**
  474. * Used to display a node block for the node editor
  475. */
  476. export class TextureNodeWidget extends React.Component<ITextureNodeWidgetProps> {
  477. /**
  478. * Creates a GenericNodeWidget
  479. * @param props
  480. */
  481. constructor(props: ITextureNodeWidgetProps);
  482. render(): JSX.Element;
  483. }
  484. }
  485. declare module "babylonjs-node-editor/components/diagram/texture/textureNodeFactory" {
  486. import * as SRD from "storm-react-diagrams";
  487. import { TextureNodeModel } from "babylonjs-node-editor/components/diagram/texture/textureNodeModel";
  488. import { GlobalState } from "babylonjs-node-editor/globalState";
  489. /**
  490. * Node factory which creates editor nodes
  491. */
  492. export class TextureNodeFactory extends SRD.AbstractNodeFactory {
  493. private _globalState;
  494. /**
  495. * Constructs a TextureNodeFactory
  496. */
  497. constructor(globalState: GlobalState);
  498. /**
  499. * Generates a node widget
  500. * @param diagramEngine diagram engine
  501. * @param node node to generate
  502. * @returns node widget jsx
  503. */
  504. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: TextureNodeModel): JSX.Element;
  505. /**
  506. * Gets a new instance of a node model
  507. * @returns texture node model
  508. */
  509. getNewInstance(): TextureNodeModel;
  510. }
  511. }
  512. declare module "babylonjs-node-editor/sharedComponents/numericInputComponent" {
  513. import * as React from "react";
  514. interface INumericInputComponentProps {
  515. label: string;
  516. value: number;
  517. step?: number;
  518. onChange: (value: number) => void;
  519. }
  520. export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
  521. value: string;
  522. }> {
  523. static defaultProps: {
  524. step: number;
  525. };
  526. private _localChange;
  527. constructor(props: INumericInputComponentProps);
  528. shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
  529. value: string;
  530. }): boolean;
  531. updateValue(evt: any): void;
  532. render(): JSX.Element;
  533. }
  534. }
  535. declare module "babylonjs-node-editor/sharedComponents/vector2LineComponent" {
  536. import * as React from "react";
  537. import { Vector2 } from "babylonjs/Maths/math";
  538. import { Observable } from "babylonjs/Misc/observable";
  539. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  540. interface IVector2LineComponentProps {
  541. label: string;
  542. target: any;
  543. propertyName: string;
  544. step?: number;
  545. onChange?: (newvalue: Vector2) => void;
  546. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  547. }
  548. export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
  549. isExpanded: boolean;
  550. value: Vector2;
  551. }> {
  552. static defaultProps: {
  553. step: number;
  554. };
  555. private _localChange;
  556. constructor(props: IVector2LineComponentProps);
  557. shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
  558. isExpanded: boolean;
  559. value: Vector2;
  560. }): boolean;
  561. switchExpandState(): void;
  562. raiseOnPropertyChanged(previousValue: Vector2): void;
  563. updateStateX(value: number): void;
  564. updateStateY(value: number): void;
  565. render(): JSX.Element;
  566. }
  567. }
  568. declare module "babylonjs-node-editor/components/propertyTab/properties/vector2PropertyTabComponent" {
  569. import * as React from "react";
  570. import { GlobalState } from "babylonjs-node-editor/globalState";
  571. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  572. interface IVector2PropertyTabComponentProps {
  573. globalState: GlobalState;
  574. inputBlock: InputBlock;
  575. }
  576. export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
  577. render(): JSX.Element;
  578. }
  579. }
  580. declare module "babylonjs-node-editor/sharedComponents/vector3LineComponent" {
  581. import * as React from "react";
  582. import { Vector3 } from "babylonjs/Maths/math";
  583. import { Observable } from "babylonjs/Misc/observable";
  584. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  585. interface IVector3LineComponentProps {
  586. label: string;
  587. target: any;
  588. propertyName: string;
  589. step?: number;
  590. onChange?: (newvalue: Vector3) => void;
  591. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  592. }
  593. export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
  594. isExpanded: boolean;
  595. value: Vector3;
  596. }> {
  597. static defaultProps: {
  598. step: number;
  599. };
  600. private _localChange;
  601. constructor(props: IVector3LineComponentProps);
  602. shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
  603. isExpanded: boolean;
  604. value: Vector3;
  605. }): boolean;
  606. switchExpandState(): void;
  607. raiseOnPropertyChanged(previousValue: Vector3): void;
  608. updateVector3(): void;
  609. updateStateX(value: number): void;
  610. updateStateY(value: number): void;
  611. updateStateZ(value: number): void;
  612. render(): JSX.Element;
  613. }
  614. }
  615. declare module "babylonjs-node-editor/components/propertyTab/properties/vector3PropertyTabComponent" {
  616. import * as React from "react";
  617. import { GlobalState } from "babylonjs-node-editor/globalState";
  618. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  619. interface IVector3PropertyTabComponentProps {
  620. globalState: GlobalState;
  621. inputBlock: InputBlock;
  622. }
  623. export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
  624. render(): JSX.Element;
  625. }
  626. }
  627. declare module "babylonjs-node-editor/sharedComponents/optionsLineComponent" {
  628. import * as React from "react";
  629. import { Observable } from "babylonjs/Misc/observable";
  630. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  631. class ListLineOption {
  632. label: string;
  633. value: number | string;
  634. }
  635. interface IOptionsLineComponentProps {
  636. label: string;
  637. target: any;
  638. propertyName?: string;
  639. options: ListLineOption[];
  640. noDirectUpdate?: boolean;
  641. onSelect?: (value: number | string) => void;
  642. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  643. valuesAreStrings?: boolean;
  644. defaultIfNull?: number;
  645. getSelection?: (target: any) => number;
  646. }
  647. export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
  648. value: number | string;
  649. }> {
  650. private _localChange;
  651. private _getValue;
  652. constructor(props: IOptionsLineComponentProps);
  653. shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
  654. value: number;
  655. }): boolean;
  656. raiseOnPropertyChanged(newValue: number | string, previousValue: number | string): void;
  657. updateValue(valueString: string): void;
  658. render(): JSX.Element;
  659. }
  660. }
  661. declare module "babylonjs-node-editor/sharedComponents/color3LineComponent" {
  662. import * as React from "react";
  663. import { Observable } from "babylonjs/Misc/observable";
  664. import { Color3 } from "babylonjs/Maths/math";
  665. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  666. export interface IColor3LineComponentProps {
  667. label: string;
  668. target: any;
  669. propertyName: string;
  670. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  671. onChange?: () => void;
  672. }
  673. export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
  674. isExpanded: boolean;
  675. color: Color3;
  676. }> {
  677. private _localChange;
  678. constructor(props: IColor3LineComponentProps);
  679. shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
  680. color: Color3;
  681. }): boolean;
  682. onChange(newValue: string): void;
  683. switchExpandState(): void;
  684. raiseOnPropertyChanged(previousValue: Color3): void;
  685. updateStateR(value: number): void;
  686. updateStateG(value: number): void;
  687. updateStateB(value: number): void;
  688. copyToClipboard(): void;
  689. render(): JSX.Element;
  690. }
  691. }
  692. declare module "babylonjs-node-editor/components/propertyTab/properties/color3PropertyTabComponent" {
  693. import * as React from "react";
  694. import { GlobalState } from "babylonjs-node-editor/globalState";
  695. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  696. interface IColor3PropertyTabComponentProps {
  697. globalState: GlobalState;
  698. inputBlock: InputBlock;
  699. }
  700. export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
  701. render(): JSX.Element;
  702. }
  703. }
  704. declare module "babylonjs-node-editor/sharedComponents/floatLineComponent" {
  705. import * as React from "react";
  706. import { Observable } from "babylonjs/Misc/observable";
  707. import { PropertyChangedEvent } from "babylonjs-node-editor/sharedComponents/propertyChangedEvent";
  708. interface IFloatLineComponentProps {
  709. label: string;
  710. target: any;
  711. propertyName: string;
  712. onChange?: (newValue: number) => void;
  713. isInteger?: boolean;
  714. onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
  715. additionalClass?: string;
  716. step?: string;
  717. digits?: number;
  718. }
  719. export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
  720. value: string;
  721. }> {
  722. private _localChange;
  723. private _store;
  724. constructor(props: IFloatLineComponentProps);
  725. shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
  726. value: string;
  727. }): boolean;
  728. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  729. updateValue(valueString: string): void;
  730. render(): JSX.Element;
  731. }
  732. }
  733. declare module "babylonjs-node-editor/components/propertyTab/properties/floatPropertyTabComponent" {
  734. import * as React from "react";
  735. import { GlobalState } from "babylonjs-node-editor/globalState";
  736. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  737. interface IFloatPropertyTabComponentProps {
  738. globalState: GlobalState;
  739. inputBlock: InputBlock;
  740. }
  741. export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
  742. render(): JSX.Element;
  743. }
  744. }
  745. declare module "babylonjs-node-editor/components/diagram/input/inputNodePropertyComponent" {
  746. import * as React from "react";
  747. import { GlobalState } from "babylonjs-node-editor/globalState";
  748. import { InputNodeModel } from "babylonjs-node-editor/components/diagram/input/inputNodeModel";
  749. interface IInputPropertyTabComponentProps {
  750. globalState: GlobalState;
  751. inputNode: InputNodeModel;
  752. }
  753. export class InputPropertyTabComponentProps extends React.Component<IInputPropertyTabComponentProps> {
  754. constructor(props: IInputPropertyTabComponentProps);
  755. renderValue(globalState: GlobalState): JSX.Element | null;
  756. setDefaultValue(): void;
  757. render(): JSX.Element;
  758. }
  759. }
  760. declare module "babylonjs-node-editor/components/diagram/input/inputNodeModel" {
  761. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  762. import { GlobalState } from "babylonjs-node-editor/globalState";
  763. import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
  764. /**
  765. * Generic node model which stores information about a node editor block
  766. */
  767. export class InputNodeModel extends DefaultNodeModel {
  768. readonly inputBlock: InputBlock;
  769. /**
  770. * Constructs the node model
  771. */
  772. constructor();
  773. renderProperties(globalState: GlobalState): JSX.Element;
  774. }
  775. }
  776. declare module "babylonjs-node-editor/components/diagram/input/inputNodeWidget" {
  777. import * as React from "react";
  778. import { InputNodeModel } from "babylonjs-node-editor/components/diagram/input/inputNodeModel";
  779. import { Nullable } from 'babylonjs/types';
  780. import { GlobalState } from "babylonjs-node-editor/globalState";
  781. /**
  782. * GenericNodeWidgetProps
  783. */
  784. export interface IInputNodeWidgetProps {
  785. node: Nullable<InputNodeModel>;
  786. globalState: GlobalState;
  787. }
  788. /**
  789. * Used to display a node block for the node editor
  790. */
  791. export class InputNodeWidget extends React.Component<IInputNodeWidgetProps> {
  792. /**
  793. * Creates a GenericNodeWidget
  794. * @param props
  795. */
  796. constructor(props: IInputNodeWidgetProps);
  797. renderValue(value: string): JSX.Element | null;
  798. render(): JSX.Element | null;
  799. }
  800. }
  801. declare module "babylonjs-node-editor/components/diagram/input/inputNodeFactory" {
  802. import * as SRD from "storm-react-diagrams";
  803. import { GlobalState } from "babylonjs-node-editor/globalState";
  804. import { InputNodeModel } from "babylonjs-node-editor/components/diagram/input/inputNodeModel";
  805. /**
  806. * Node factory which creates editor nodes
  807. */
  808. export class InputNodeFactory extends SRD.AbstractNodeFactory {
  809. private _globalState;
  810. /**
  811. * Constructs a GenericNodeFactory
  812. */
  813. constructor(globalState: GlobalState);
  814. /**
  815. * Generates a node widget
  816. * @param diagramEngine diagram engine
  817. * @param node node to generate
  818. * @returns node widget jsx
  819. */
  820. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: InputNodeModel): JSX.Element;
  821. /**
  822. * Gets a new instance of a node model
  823. * @returns input node model
  824. */
  825. getNewInstance(): InputNodeModel;
  826. }
  827. }
  828. declare module "babylonjs-node-editor/components/log/logComponent" {
  829. import * as React from "react";
  830. import { GlobalState } from "babylonjs-node-editor/globalState";
  831. interface ILogComponentProps {
  832. globalState: GlobalState;
  833. }
  834. export class LogEntry {
  835. message: string;
  836. isError: boolean;
  837. constructor(message: string, isError: boolean);
  838. }
  839. export class LogComponent extends React.Component<ILogComponentProps, {
  840. logs: LogEntry[];
  841. }> {
  842. constructor(props: ILogComponentProps);
  843. componentWillMount(): void;
  844. componentDidUpdate(): void;
  845. render(): JSX.Element;
  846. }
  847. }
  848. declare module "babylonjs-node-editor/components/diagram/light/lightPropertyTabComponent" {
  849. import * as React from "react";
  850. import { GlobalState } from "babylonjs-node-editor/globalState";
  851. import { LightNodeModel } from "babylonjs-node-editor/components/diagram/light/lightNodeModel";
  852. interface ILightPropertyTabComponentProps {
  853. globalState: GlobalState;
  854. node: LightNodeModel;
  855. }
  856. export class LightPropertyTabComponent extends React.Component<ILightPropertyTabComponentProps> {
  857. render(): JSX.Element;
  858. }
  859. }
  860. declare module "babylonjs-node-editor/components/diagram/light/lightNodeModel" {
  861. import { Nullable } from 'babylonjs/types';
  862. import { Light } from 'babylonjs/Lights/light';
  863. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  864. import { GlobalState } from "babylonjs-node-editor/globalState";
  865. import { NodeCreationOptions, GraphEditor } from "babylonjs-node-editor/graphEditor";
  866. import { DiagramModel } from 'storm-react-diagrams/dist/@types/src/models/DiagramModel';
  867. /**
  868. * Light node model which stores information about a node editor block
  869. */
  870. export class LightNodeModel extends DefaultNodeModel {
  871. private _block;
  872. /**
  873. * Light for the node if it exists
  874. */
  875. light: Nullable<Light>;
  876. /**
  877. * Constructs the node model
  878. */
  879. constructor();
  880. renderProperties(globalState: GlobalState): JSX.Element;
  881. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  882. }
  883. }
  884. declare module "babylonjs-node-editor/components/diagram/light/lightNodeWidget" {
  885. import * as React from "react";
  886. import { LightNodeModel } from "babylonjs-node-editor/components/diagram/light/lightNodeModel";
  887. import { Nullable } from 'babylonjs/types';
  888. import { GlobalState } from "babylonjs-node-editor/globalState";
  889. /**
  890. * GenericNodeWidgetProps
  891. */
  892. export interface ILightNodeWidgetProps {
  893. node: Nullable<LightNodeModel>;
  894. globalState: GlobalState;
  895. }
  896. /**
  897. * Used to display a node block for the node editor
  898. */
  899. export class LightNodeWidget extends React.Component<ILightNodeWidgetProps> {
  900. /**
  901. * Creates a GenericNodeWidget
  902. * @param props
  903. */
  904. constructor(props: ILightNodeWidgetProps);
  905. render(): JSX.Element;
  906. }
  907. }
  908. declare module "babylonjs-node-editor/components/diagram/light/lightNodeFactory" {
  909. import * as SRD from "storm-react-diagrams";
  910. import { LightNodeModel } from "babylonjs-node-editor/components/diagram/light/lightNodeModel";
  911. import { GlobalState } from "babylonjs-node-editor/globalState";
  912. /**
  913. * Node factory which creates editor nodes
  914. */
  915. export class LightNodeFactory extends SRD.AbstractNodeFactory {
  916. private _globalState;
  917. /**
  918. * Constructs a LightNodeFactory
  919. */
  920. constructor(globalState: GlobalState);
  921. /**
  922. * Generates a node widget
  923. * @param diagramEngine diagram engine
  924. * @param node node to generate
  925. * @returns node widget jsx
  926. */
  927. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: LightNodeModel): JSX.Element;
  928. /**
  929. * Gets a new instance of a node model
  930. * @returns light node model
  931. */
  932. getNewInstance(): LightNodeModel;
  933. }
  934. }
  935. declare module "babylonjs-node-editor/sharedComponents/messageDialog" {
  936. import * as React from "react";
  937. import { GlobalState } from "babylonjs-node-editor/globalState";
  938. interface IMessageDialogComponentProps {
  939. globalState: GlobalState;
  940. }
  941. export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
  942. message: string;
  943. isError: boolean;
  944. }> {
  945. constructor(props: IMessageDialogComponentProps);
  946. render(): JSX.Element | null;
  947. }
  948. }
  949. declare module "babylonjs-node-editor/components/diagram/link/advancedLinkFactory" {
  950. import { DefaultLinkFactory, DefaultLinkWidget } from 'storm-react-diagrams';
  951. import { AdvancedLinkModel } from "babylonjs-node-editor/components/diagram/link/advancedLinkModel";
  952. export class AdvancedLinkFactory extends DefaultLinkFactory {
  953. constructor();
  954. getNewInstance(initialConfig?: any): AdvancedLinkModel;
  955. generateLinkSegment(model: AdvancedLinkModel, widget: DefaultLinkWidget, selected: boolean, path: string): JSX.Element;
  956. }
  957. }
  958. declare module "babylonjs-node-editor/components/diagram/remap/remapNodePropertyComponent" {
  959. import * as React from "react";
  960. import { GlobalState } from "babylonjs-node-editor/globalState";
  961. import { RemapNodeModel } from "babylonjs-node-editor/components/diagram/remap/remapNodeModel";
  962. interface IRemapPropertyTabComponentProps {
  963. globalState: GlobalState;
  964. remapNode: RemapNodeModel;
  965. }
  966. export class RemapPropertyTabComponentProps extends React.Component<IRemapPropertyTabComponentProps> {
  967. constructor(props: IRemapPropertyTabComponentProps);
  968. forceRebuild(): void;
  969. render(): JSX.Element;
  970. }
  971. }
  972. declare module "babylonjs-node-editor/components/diagram/remap/remapNodeModel" {
  973. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  974. import { GlobalState } from "babylonjs-node-editor/globalState";
  975. import { RemapBlock } from 'babylonjs/Materials/Node/Blocks/remapBlock';
  976. /**
  977. * Generic node model which stores information about a node editor block
  978. */
  979. export class RemapNodeModel extends DefaultNodeModel {
  980. readonly remapBlock: RemapBlock;
  981. /**
  982. * Constructs the node model
  983. */
  984. constructor();
  985. renderProperties(globalState: GlobalState): JSX.Element;
  986. }
  987. }
  988. declare module "babylonjs-node-editor/components/diagram/remap/remapNodeWidget" {
  989. import * as React from "react";
  990. import { RemapNodeModel } from "babylonjs-node-editor/components/diagram/remap/remapNodeModel";
  991. import { Nullable } from 'babylonjs/types';
  992. import { GlobalState } from "babylonjs-node-editor/globalState";
  993. /**
  994. * RemapNodeWidgetProps
  995. */
  996. export interface RemapNodeWidgetProps {
  997. node: Nullable<RemapNodeModel>;
  998. globalState: GlobalState;
  999. }
  1000. /**
  1001. * Used to display a node block for the node editor
  1002. */
  1003. export class RemapNodeWidget extends React.Component<RemapNodeWidgetProps> {
  1004. /**
  1005. * Creates a GenericNodeWidget
  1006. * @param props
  1007. */
  1008. constructor(props: RemapNodeWidgetProps);
  1009. renderValue(value: string): JSX.Element | null;
  1010. render(): JSX.Element;
  1011. }
  1012. }
  1013. declare module "babylonjs-node-editor/components/diagram/remap/remapNodeFactory" {
  1014. import * as SRD from "storm-react-diagrams";
  1015. import { GlobalState } from "babylonjs-node-editor/globalState";
  1016. import { RemapNodeModel } from "babylonjs-node-editor/components/diagram/remap/remapNodeModel";
  1017. /**
  1018. * Node factory which creates editor nodes
  1019. */
  1020. export class RemapNodeFactory extends SRD.AbstractNodeFactory {
  1021. private _globalState;
  1022. /**
  1023. * Constructs a GenericNodeFactory
  1024. */
  1025. constructor(globalState: GlobalState);
  1026. /**
  1027. * Generates a node widget
  1028. * @param diagramEngine diagram engine
  1029. * @param node node to generate
  1030. * @returns node widget jsx
  1031. */
  1032. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: RemapNodeModel): JSX.Element;
  1033. /**
  1034. * Gets a new instance of a node model
  1035. * @returns input node model
  1036. */
  1037. getNewInstance(): RemapNodeModel;
  1038. }
  1039. }
  1040. declare module "babylonjs-node-editor/graphHelper" {
  1041. import * as dagre from "babylonjs-node-editor/dagre";
  1042. import { DiagramModel } from 'storm-react-diagrams/dist/@types/src/models/DiagramModel';
  1043. export class GraphHelper {
  1044. static DistributeGraph(model: DiagramModel): dagre.Node[];
  1045. private static _MapElements;
  1046. private static _MapEdges;
  1047. }
  1048. }
  1049. declare module "babylonjs-node-editor/components/preview/previewMeshType" {
  1050. export enum PreviewMeshType {
  1051. Sphere = 0,
  1052. Box = 1,
  1053. Torus = 2,
  1054. Cylinder = 3
  1055. }
  1056. }
  1057. declare module "babylonjs-node-editor/components/preview/previewManager" {
  1058. import { GlobalState } from "babylonjs-node-editor/globalState";
  1059. export class PreviewManager {
  1060. private _nodeMaterial;
  1061. private _onBuildObserver;
  1062. private _onPreviewMeshTypeChangedObserver;
  1063. private _onUpdateRequiredObserver;
  1064. private _engine;
  1065. private _scene;
  1066. private _light;
  1067. private _dummy;
  1068. private _camera;
  1069. private _material;
  1070. private _globalState;
  1071. constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
  1072. private _refreshPreviewMesh;
  1073. private _updatePreview;
  1074. dispose(): void;
  1075. }
  1076. }
  1077. declare module "babylonjs-node-editor/components/preview/previewMeshControlComponent" {
  1078. import * as React from "react";
  1079. import { GlobalState } from "babylonjs-node-editor/globalState";
  1080. import { PreviewMeshType } from "babylonjs-node-editor/components/preview/previewMeshType";
  1081. interface IPreviewMeshControlComponent {
  1082. globalState: GlobalState;
  1083. }
  1084. export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
  1085. changeMeshType(newOne: PreviewMeshType): void;
  1086. render(): JSX.Element;
  1087. }
  1088. }
  1089. declare module "babylonjs-node-editor/components/diagram/trigonometry/trigonometryNodePropertyComponent" {
  1090. import * as React from "react";
  1091. import { GlobalState } from "babylonjs-node-editor/globalState";
  1092. import { TrigonometryNodeModel } from "babylonjs-node-editor/components/diagram/trigonometry/trigonometryNodeModel";
  1093. interface ITrigonometryTabComponentProps {
  1094. globalState: GlobalState;
  1095. trigonometryNode: TrigonometryNodeModel;
  1096. }
  1097. export class TrigonometryPropertyTabComponentProps extends React.Component<ITrigonometryTabComponentProps> {
  1098. constructor(props: ITrigonometryTabComponentProps);
  1099. render(): JSX.Element;
  1100. }
  1101. }
  1102. declare module "babylonjs-node-editor/components/diagram/trigonometry/trigonometryNodeModel" {
  1103. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  1104. import { GlobalState } from "babylonjs-node-editor/globalState";
  1105. import { TrigonometryBlock } from 'babylonjs/Materials/Node/Blocks/trigonometryBlock';
  1106. /**
  1107. * Generic node model which stores information about a node editor block
  1108. */
  1109. export class TrigonometryNodeModel extends DefaultNodeModel {
  1110. readonly trigonometryBlock: TrigonometryBlock;
  1111. /**
  1112. * Constructs the node model
  1113. */
  1114. constructor();
  1115. renderProperties(globalState: GlobalState): JSX.Element;
  1116. }
  1117. }
  1118. declare module "babylonjs-node-editor/components/diagram/trigonometry/trigonometryNodeWidget" {
  1119. import * as React from "react";
  1120. import { TrigonometryNodeModel } from "babylonjs-node-editor/components/diagram/trigonometry/trigonometryNodeModel";
  1121. import { Nullable } from 'babylonjs/types';
  1122. import { GlobalState } from "babylonjs-node-editor/globalState";
  1123. /**
  1124. * GenericNodeWidgetProps
  1125. */
  1126. export interface ITrigonometryNodeWidgetProps {
  1127. node: Nullable<TrigonometryNodeModel>;
  1128. globalState: GlobalState;
  1129. }
  1130. /**
  1131. * Used to display a node block for the node editor
  1132. */
  1133. export class TrigonometryNodeWidget extends React.Component<ITrigonometryNodeWidgetProps> {
  1134. /**
  1135. * Creates a GenericNodeWidget
  1136. * @param props
  1137. */
  1138. constructor(props: ITrigonometryNodeWidgetProps);
  1139. render(): JSX.Element;
  1140. }
  1141. }
  1142. declare module "babylonjs-node-editor/components/diagram/trigonometry/trigonometryNodeFactory" {
  1143. import * as SRD from "storm-react-diagrams";
  1144. import { GlobalState } from "babylonjs-node-editor/globalState";
  1145. import { TrigonometryNodeModel } from "babylonjs-node-editor/components/diagram/trigonometry/trigonometryNodeModel";
  1146. /**
  1147. * Node factory which creates editor nodes
  1148. */
  1149. export class TrigonometryNodeFactory extends SRD.AbstractNodeFactory {
  1150. private _globalState;
  1151. /**
  1152. * Constructs a GenericNodeFactory
  1153. */
  1154. constructor(globalState: GlobalState);
  1155. /**
  1156. * Generates a node widget
  1157. * @param diagramEngine diagram engine
  1158. * @param node node to generate
  1159. * @returns node widget jsx
  1160. */
  1161. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: TrigonometryNodeModel): JSX.Element;
  1162. /**
  1163. * Gets a new instance of a node model
  1164. * @returns input node model
  1165. */
  1166. getNewInstance(): TrigonometryNodeModel;
  1167. }
  1168. }
  1169. declare module "babylonjs-node-editor/graphEditor" {
  1170. import { LinkModel } from "storm-react-diagrams";
  1171. import * as React from "react";
  1172. import { GlobalState } from "babylonjs-node-editor/globalState";
  1173. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1174. import { NodeMaterialConnectionPoint } from 'babylonjs/Materials/Node/nodeMaterialBlockConnectionPoint';
  1175. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  1176. import { Nullable } from 'babylonjs/types';
  1177. import { INodeLocationInfo } from "babylonjs-node-editor/nodeLocationInfo";
  1178. interface IGraphEditorProps {
  1179. globalState: GlobalState;
  1180. }
  1181. export class NodeCreationOptions {
  1182. nodeMaterialBlock: NodeMaterialBlock;
  1183. type?: string;
  1184. connection?: NodeMaterialConnectionPoint;
  1185. }
  1186. export class GraphEditor extends React.Component<IGraphEditorProps> {
  1187. private readonly NodeWidth;
  1188. private _engine;
  1189. private _model;
  1190. private _startX;
  1191. private _moveInProgress;
  1192. private _leftWidth;
  1193. private _rightWidth;
  1194. private _nodes;
  1195. private _blocks;
  1196. private _previewManager;
  1197. private _copiedNode;
  1198. private _mouseLocationX;
  1199. private _mouseLocationY;
  1200. private _onWidgetKeyUpPointer;
  1201. /** @hidden */
  1202. _toAdd: LinkModel[] | null;
  1203. /**
  1204. * Creates a node and recursivly creates its parent nodes from it's input
  1205. * @param nodeMaterialBlock
  1206. */
  1207. createNodeFromObject(options: NodeCreationOptions): DefaultNodeModel;
  1208. addValueNode(type: string): DefaultNodeModel;
  1209. onWidgetKeyUp(evt: any): void;
  1210. componentDidMount(): void;
  1211. componentWillUnmount(): void;
  1212. constructor(props: IGraphEditorProps);
  1213. zoomToFit(retry?: number): void;
  1214. buildMaterial(): void;
  1215. build(needToWait?: boolean, locations?: Nullable<INodeLocationInfo[]>): void;
  1216. reOrganize(locations?: Nullable<INodeLocationInfo[]>): void;
  1217. onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
  1218. onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
  1219. resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
  1220. buildColumnLayout(): string;
  1221. emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
  1222. render(): JSX.Element;
  1223. }
  1224. }
  1225. declare module "babylonjs-node-editor/components/diagram/defaultNodeModel" {
  1226. import { NodeModel, DiagramModel } from "storm-react-diagrams";
  1227. import { Nullable } from 'babylonjs/types';
  1228. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1229. import { GraphEditor, NodeCreationOptions } from "babylonjs-node-editor/graphEditor";
  1230. import { GlobalState } from "babylonjs-node-editor/globalState";
  1231. import { DefaultPortModel } from "babylonjs-node-editor/components/diagram/port/defaultPortModel";
  1232. /**
  1233. * Generic node model which stores information about a node editor block
  1234. */
  1235. export class DefaultNodeModel extends NodeModel {
  1236. /**
  1237. * The babylon block this node represents
  1238. */
  1239. block: Nullable<NodeMaterialBlock>;
  1240. ports: {
  1241. [s: string]: DefaultPortModel;
  1242. };
  1243. /**
  1244. * Constructs the node model
  1245. */
  1246. constructor(key: string);
  1247. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  1248. renderProperties(globalState: GlobalState): JSX.Element | null;
  1249. }
  1250. }
  1251. declare module "babylonjs-node-editor/globalState" {
  1252. import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
  1253. import { Nullable } from "babylonjs/types";
  1254. import { Observable } from 'babylonjs/Misc/observable';
  1255. import { DefaultNodeModel } from "babylonjs-node-editor/components/diagram/defaultNodeModel";
  1256. import { LogEntry } from "babylonjs-node-editor/components/log/logComponent";
  1257. import { NodeModel } from 'storm-react-diagrams';
  1258. import { INodeLocationInfo } from "babylonjs-node-editor/nodeLocationInfo";
  1259. import { NodeMaterialBlock } from 'babylonjs/Materials/Node/nodeMaterialBlock';
  1260. import { PreviewMeshType } from "babylonjs-node-editor/components/preview/previewMeshType";
  1261. export class GlobalState {
  1262. nodeMaterial: NodeMaterial;
  1263. hostElement: HTMLElement;
  1264. hostDocument: HTMLDocument;
  1265. onSelectionChangedObservable: Observable<Nullable<DefaultNodeModel>>;
  1266. onRebuildRequiredObservable: Observable<void>;
  1267. onResetRequiredObservable: Observable<Nullable<INodeLocationInfo[]>>;
  1268. onUpdateRequiredObservable: Observable<void>;
  1269. onZoomToFitRequiredObservable: Observable<void>;
  1270. onReOrganizedRequiredObservable: Observable<void>;
  1271. onLogRequiredObservable: Observable<LogEntry>;
  1272. onErrorMessageDialogRequiredObservable: Observable<string>;
  1273. onPreviewMeshTypeChanged: Observable<void>;
  1274. onGetNodeFromBlock: (block: NodeMaterialBlock) => NodeModel;
  1275. previewMeshType: PreviewMeshType;
  1276. blockKeyboardEvents: boolean;
  1277. constructor();
  1278. }
  1279. }
  1280. declare module "babylonjs-node-editor/sharedComponents/popup" {
  1281. export class Popup {
  1282. static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): HTMLDivElement | null;
  1283. private static _CopyStyles;
  1284. }
  1285. }
  1286. declare module "babylonjs-node-editor/nodeEditor" {
  1287. import { NodeMaterial } from "babylonjs/Materials/Node/nodeMaterial";
  1288. /**
  1289. * Interface used to specify creation options for the node editor
  1290. */
  1291. export interface INodeEditorOptions {
  1292. nodeMaterial: NodeMaterial;
  1293. }
  1294. /**
  1295. * Class used to create a node editor
  1296. */
  1297. export class NodeEditor {
  1298. /**
  1299. * Show the node editor
  1300. * @param options defines the options to use to configure the node editor
  1301. */
  1302. static Show(options: INodeEditorOptions): void;
  1303. }
  1304. }
  1305. declare module "babylonjs-node-editor/index" {
  1306. export * from "babylonjs-node-editor/nodeEditor";
  1307. }
  1308. declare module "babylonjs-node-editor/legacy/legacy" {
  1309. export * from "babylonjs-node-editor/index";
  1310. }
  1311. declare module "babylonjs-node-editor" {
  1312. export * from "babylonjs-node-editor/legacy/legacy";
  1313. }
  1314. /// <reference types="react" />
  1315. declare module NODEEDITOR {
  1316. export class BlockTools {
  1317. 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 | null;
  1318. static GetColorFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
  1319. 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;
  1320. static GetStringFromConnectionNodeType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): "Float" | "Vector2" | "Vector3" | "Vector4" | "Matrix" | "Color3" | "Color4" | "";
  1321. }
  1322. }
  1323. declare module NODEEDITOR {
  1324. export class DataStorage {
  1325. private static _InMemoryStorage;
  1326. static ReadBoolean(key: string, defaultValue: boolean): boolean;
  1327. static StoreBoolean(key: string, value: boolean): void;
  1328. static ReadNumber(key: string, defaultValue: number): number;
  1329. static StoreNumber(key: string, value: number): void;
  1330. }
  1331. }
  1332. declare module NODEEDITOR {
  1333. interface ITextLineComponentProps {
  1334. label: string;
  1335. value: string;
  1336. color?: string;
  1337. underline?: boolean;
  1338. onLink?: () => void;
  1339. }
  1340. export class TextLineComponent extends React.Component<ITextLineComponentProps> {
  1341. constructor(props: ITextLineComponentProps);
  1342. onLink(): void;
  1343. renderContent(): JSX.Element;
  1344. render(): JSX.Element;
  1345. }
  1346. }
  1347. declare module NODEEDITOR {
  1348. interface ILineContainerComponentProps {
  1349. title: string;
  1350. children: any[] | any;
  1351. closed?: boolean;
  1352. }
  1353. export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
  1354. isExpanded: boolean;
  1355. }> {
  1356. constructor(props: ILineContainerComponentProps);
  1357. switchExpandedState(): void;
  1358. renderHeader(): JSX.Element;
  1359. render(): JSX.Element;
  1360. }
  1361. }
  1362. declare module NODEEDITOR {
  1363. export class PropertyChangedEvent {
  1364. object: any;
  1365. property: string;
  1366. value: any;
  1367. initialValue: any;
  1368. }
  1369. }
  1370. declare module NODEEDITOR {
  1371. interface ITextInputLineComponentProps {
  1372. label: string;
  1373. globalState: GlobalState;
  1374. target?: any;
  1375. propertyName?: string;
  1376. value?: string;
  1377. onChange?: (value: string) => void;
  1378. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1379. }
  1380. export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
  1381. value: string;
  1382. }> {
  1383. private _localChange;
  1384. constructor(props: ITextInputLineComponentProps);
  1385. shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
  1386. value: string;
  1387. }): boolean;
  1388. raiseOnPropertyChanged(newValue: string, previousValue: string): void;
  1389. updateValue(value: string, raisePropertyChanged: boolean): void;
  1390. render(): JSX.Element;
  1391. }
  1392. }
  1393. declare module NODEEDITOR {
  1394. export interface ICheckBoxLineComponentProps {
  1395. label: string;
  1396. target?: any;
  1397. propertyName?: string;
  1398. isSelected?: () => boolean;
  1399. onSelect?: (value: boolean) => void;
  1400. onValueChanged?: () => void;
  1401. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1402. }
  1403. export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
  1404. isSelected: boolean;
  1405. }> {
  1406. private static _UniqueIdSeed;
  1407. private _uniqueId;
  1408. private _localChange;
  1409. constructor(props: ICheckBoxLineComponentProps);
  1410. shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
  1411. isSelected: boolean;
  1412. }): boolean;
  1413. onChange(): void;
  1414. render(): JSX.Element;
  1415. }
  1416. }
  1417. declare module NODEEDITOR {
  1418. /**
  1419. * Generic node model which stores information about a node editor block
  1420. */
  1421. export class GenericNodeModel extends DefaultNodeModel {
  1422. /**
  1423. * BABYLON.Vector2 for the node if it exists
  1424. */
  1425. vector2: BABYLON.Nullable<BABYLON.Vector2>;
  1426. /**
  1427. * BABYLON.Vector3 for the node if it exists
  1428. */
  1429. vector3: BABYLON.Nullable<BABYLON.Vector3>;
  1430. /**
  1431. * BABYLON.Vector4 for the node if it exists
  1432. */
  1433. vector4: BABYLON.Nullable<BABYLON.Vector4>;
  1434. /**
  1435. * BABYLON.Matrix for the node if it exists
  1436. */
  1437. matrix: BABYLON.Nullable<BABYLON.Matrix>;
  1438. /**
  1439. * Constructs the node model
  1440. */
  1441. constructor();
  1442. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  1443. renderProperties(globalState: GlobalState): JSX.Element;
  1444. }
  1445. }
  1446. declare module NODEEDITOR {
  1447. export class AdvancedLinkModel extends DefaultLinkModel {
  1448. constructor();
  1449. }
  1450. }
  1451. declare module NODEEDITOR {
  1452. /**
  1453. * Port model
  1454. */
  1455. export class DefaultPortModel extends PortModel {
  1456. /**
  1457. * If the port is input or output
  1458. */
  1459. position: string | "input" | "output";
  1460. /**
  1461. * What the port is connected to
  1462. */
  1463. connection: BABYLON.Nullable<BABYLON.NodeMaterialConnectionPoint>;
  1464. defaultValue: any;
  1465. static idCounter: number;
  1466. constructor(name: string, type?: string);
  1467. canLinkToPort(port: DefaultPortModel): boolean;
  1468. syncWithNodeMaterialConnectionPoint(connection: BABYLON.NodeMaterialConnectionPoint): void;
  1469. getNodeModel(): DefaultNodeModel;
  1470. link(outPort: DefaultPortModel): LinkModel<import("storm-react-diagrams").LinkModelListener>;
  1471. createLinkModel(): LinkModel;
  1472. static SortInputOutput(a: BABYLON.Nullable<DefaultPortModel>, b: BABYLON.Nullable<DefaultPortModel>): {
  1473. input: DefaultPortModel;
  1474. output: DefaultPortModel;
  1475. } | null;
  1476. }
  1477. }
  1478. declare module NODEEDITOR {
  1479. export interface IDefaultPortWidgetProps extends BaseWidgetProps {
  1480. name: string;
  1481. node: NodeModel;
  1482. style: any;
  1483. }
  1484. export class DefaultPortWidget extends BaseWidget<IDefaultPortWidgetProps, PortState> {
  1485. constructor(props: IDefaultPortWidgetProps);
  1486. getClassName(): string;
  1487. render(): JSX.Element;
  1488. }
  1489. }
  1490. declare module NODEEDITOR {
  1491. export class PortHelper {
  1492. private static _GetPortTypeIndicator;
  1493. static _GetPortStyle(type: BABYLON.NodeMaterialBlockConnectionPointTypes): {
  1494. background: string;
  1495. };
  1496. static GenerateOutputPorts(node: BABYLON.Nullable<DefaultNodeModel>, ignoreLabel: boolean): JSX.Element[];
  1497. static GenerateInputPorts(node: BABYLON.Nullable<DefaultNodeModel>, includeOnly?: string[], ignoreLabel?: boolean): JSX.Element[];
  1498. }
  1499. }
  1500. declare module NODEEDITOR {
  1501. /**
  1502. * GenericNodeWidgetProps
  1503. */
  1504. export interface GenericNodeWidgetProps {
  1505. node: BABYLON.Nullable<GenericNodeModel>;
  1506. globalState: GlobalState;
  1507. }
  1508. /**
  1509. * GenericNodeWidgetState
  1510. */
  1511. export interface GenericNodeWidgetState {
  1512. }
  1513. /**
  1514. * Used to display a node block for the node editor
  1515. */
  1516. export class GenericNodeWidget extends React.Component<GenericNodeWidgetProps, GenericNodeWidgetState> {
  1517. /**
  1518. * Creates a GenericNodeWidget
  1519. * @param props
  1520. */
  1521. constructor(props: GenericNodeWidgetProps);
  1522. render(): JSX.Element;
  1523. }
  1524. }
  1525. declare module NODEEDITOR {
  1526. /**
  1527. * Node factory which creates editor nodes
  1528. */
  1529. export class GenericNodeFactory extends SRD.AbstractNodeFactory {
  1530. private _globalState;
  1531. /**
  1532. * Constructs a GenericNodeFactory
  1533. */
  1534. constructor(globalState: GlobalState);
  1535. /**
  1536. * Generates a node widget
  1537. * @param diagramEngine diagram engine
  1538. * @param node node to generate
  1539. * @returns node widget jsx
  1540. */
  1541. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: GenericNodeModel): JSX.Element;
  1542. /**
  1543. * Gets a new instance of a node model
  1544. * @returns generic node model
  1545. */
  1546. getNewInstance(): GenericNodeModel;
  1547. }
  1548. }
  1549. declare module NODEEDITOR {
  1550. export interface IButtonLineComponentProps {
  1551. data: string;
  1552. }
  1553. export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
  1554. constructor(props: IButtonLineComponentProps);
  1555. render(): JSX.Element;
  1556. }
  1557. }
  1558. declare module NODEEDITOR {
  1559. interface INodeListComponentProps {
  1560. globalState: GlobalState;
  1561. }
  1562. export class NodeListComponent extends React.Component<INodeListComponentProps> {
  1563. render(): JSX.Element;
  1564. }
  1565. }
  1566. declare module NODEEDITOR {
  1567. export interface IButtonLineComponentProps {
  1568. label: string;
  1569. onClick: () => void;
  1570. }
  1571. export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
  1572. constructor(props: IButtonLineComponentProps);
  1573. render(): JSX.Element;
  1574. }
  1575. }
  1576. declare module NODEEDITOR {
  1577. export class StringTools {
  1578. /**
  1579. * Gets the base math type of node material block connection point.
  1580. * @param type Type to parse.
  1581. */
  1582. static GetBaseType(type: BABYLON.NodeMaterialBlockConnectionPointTypes): string;
  1583. /**
  1584. * Download a string into a file that will be saved locally by the browser
  1585. * @param content defines the string to download locally as a file
  1586. */
  1587. static DownloadAsFile(content: string, filename: string): void;
  1588. }
  1589. }
  1590. declare module NODEEDITOR {
  1591. interface IFileButtonLineComponentProps {
  1592. label: string;
  1593. onClick: (file: File) => void;
  1594. accept: string;
  1595. }
  1596. export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
  1597. constructor(props: IFileButtonLineComponentProps);
  1598. onChange(evt: any): void;
  1599. render(): JSX.Element;
  1600. }
  1601. }
  1602. declare module NODEEDITOR {
  1603. export interface INodeLocationInfo {
  1604. blockId: number;
  1605. x: number;
  1606. y: number;
  1607. }
  1608. }
  1609. declare module NODEEDITOR {
  1610. interface IPropertyTabComponentProps {
  1611. globalState: GlobalState;
  1612. }
  1613. export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, {
  1614. currentNode: BABYLON.Nullable<DefaultNodeModel>;
  1615. }> {
  1616. constructor(props: IPropertyTabComponentProps);
  1617. componentWillMount(): void;
  1618. load(file: File): void;
  1619. save(): void;
  1620. render(): JSX.Element;
  1621. }
  1622. }
  1623. declare module NODEEDITOR {
  1624. interface IPortalProps {
  1625. globalState: GlobalState;
  1626. }
  1627. export class Portal extends React.Component<IPortalProps> {
  1628. render(): React.ReactPortal;
  1629. }
  1630. }
  1631. declare module NODEEDITOR {
  1632. interface ITexturePropertyTabComponentProps {
  1633. globalState: GlobalState;
  1634. node: TextureNodeModel;
  1635. }
  1636. export class TexturePropertyTabComponent extends React.Component<ITexturePropertyTabComponentProps> {
  1637. updateAftertextureLoad(): void;
  1638. /**
  1639. * Replaces the texture of the node
  1640. * @param file the file of the texture to use
  1641. */
  1642. replaceTexture(file: File): void;
  1643. render(): JSX.Element;
  1644. }
  1645. }
  1646. declare module NODEEDITOR {
  1647. /**
  1648. * Texture node model which stores information about a node editor block
  1649. */
  1650. export class TextureNodeModel extends DefaultNodeModel {
  1651. private _block;
  1652. /**
  1653. * Texture for the node if it exists
  1654. */
  1655. texture: BABYLON.Nullable<BABYLON.BaseTexture>;
  1656. /**
  1657. * Constructs the node model
  1658. */
  1659. constructor();
  1660. renderProperties(globalState: GlobalState): JSX.Element;
  1661. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  1662. }
  1663. }
  1664. declare module NODEEDITOR {
  1665. interface ITextureLineComponentProps {
  1666. texture: BABYLON.BaseTexture;
  1667. width: number;
  1668. height: number;
  1669. globalState?: any;
  1670. hideChannelSelect?: boolean;
  1671. }
  1672. export class TextureLineComponent extends React.Component<ITextureLineComponentProps, {
  1673. displayRed: boolean;
  1674. displayGreen: boolean;
  1675. displayBlue: boolean;
  1676. displayAlpha: boolean;
  1677. face: number;
  1678. }> {
  1679. constructor(props: ITextureLineComponentProps);
  1680. shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
  1681. displayRed: boolean;
  1682. displayGreen: boolean;
  1683. displayBlue: boolean;
  1684. displayAlpha: boolean;
  1685. face: number;
  1686. }): boolean;
  1687. componentDidMount(): void;
  1688. componentDidUpdate(): void;
  1689. updatePreview(): void;
  1690. render(): JSX.Element;
  1691. }
  1692. }
  1693. declare module NODEEDITOR {
  1694. /**
  1695. * GenericNodeWidgetProps
  1696. */
  1697. export interface ITextureNodeWidgetProps {
  1698. node: BABYLON.Nullable<TextureNodeModel>;
  1699. globalState: GlobalState;
  1700. }
  1701. /**
  1702. * Used to display a node block for the node editor
  1703. */
  1704. export class TextureNodeWidget extends React.Component<ITextureNodeWidgetProps> {
  1705. /**
  1706. * Creates a GenericNodeWidget
  1707. * @param props
  1708. */
  1709. constructor(props: ITextureNodeWidgetProps);
  1710. render(): JSX.Element;
  1711. }
  1712. }
  1713. declare module NODEEDITOR {
  1714. /**
  1715. * Node factory which creates editor nodes
  1716. */
  1717. export class TextureNodeFactory extends SRD.AbstractNodeFactory {
  1718. private _globalState;
  1719. /**
  1720. * Constructs a TextureNodeFactory
  1721. */
  1722. constructor(globalState: GlobalState);
  1723. /**
  1724. * Generates a node widget
  1725. * @param diagramEngine diagram engine
  1726. * @param node node to generate
  1727. * @returns node widget jsx
  1728. */
  1729. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: TextureNodeModel): JSX.Element;
  1730. /**
  1731. * Gets a new instance of a node model
  1732. * @returns texture node model
  1733. */
  1734. getNewInstance(): TextureNodeModel;
  1735. }
  1736. }
  1737. declare module NODEEDITOR {
  1738. interface INumericInputComponentProps {
  1739. label: string;
  1740. value: number;
  1741. step?: number;
  1742. onChange: (value: number) => void;
  1743. }
  1744. export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
  1745. value: string;
  1746. }> {
  1747. static defaultProps: {
  1748. step: number;
  1749. };
  1750. private _localChange;
  1751. constructor(props: INumericInputComponentProps);
  1752. shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
  1753. value: string;
  1754. }): boolean;
  1755. updateValue(evt: any): void;
  1756. render(): JSX.Element;
  1757. }
  1758. }
  1759. declare module NODEEDITOR {
  1760. interface IVector2LineComponentProps {
  1761. label: string;
  1762. target: any;
  1763. propertyName: string;
  1764. step?: number;
  1765. onChange?: (newvalue: BABYLON.Vector2) => void;
  1766. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1767. }
  1768. export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
  1769. isExpanded: boolean;
  1770. value: BABYLON.Vector2;
  1771. }> {
  1772. static defaultProps: {
  1773. step: number;
  1774. };
  1775. private _localChange;
  1776. constructor(props: IVector2LineComponentProps);
  1777. shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
  1778. isExpanded: boolean;
  1779. value: BABYLON.Vector2;
  1780. }): boolean;
  1781. switchExpandState(): void;
  1782. raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
  1783. updateStateX(value: number): void;
  1784. updateStateY(value: number): void;
  1785. render(): JSX.Element;
  1786. }
  1787. }
  1788. declare module NODEEDITOR {
  1789. interface IVector2PropertyTabComponentProps {
  1790. globalState: GlobalState;
  1791. inputBlock: BABYLON.InputBlock;
  1792. }
  1793. export class Vector2PropertyTabComponent extends React.Component<IVector2PropertyTabComponentProps> {
  1794. render(): JSX.Element;
  1795. }
  1796. }
  1797. declare module NODEEDITOR {
  1798. interface IVector3LineComponentProps {
  1799. label: string;
  1800. target: any;
  1801. propertyName: string;
  1802. step?: number;
  1803. onChange?: (newvalue: BABYLON.Vector3) => void;
  1804. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1805. }
  1806. export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
  1807. isExpanded: boolean;
  1808. value: BABYLON.Vector3;
  1809. }> {
  1810. static defaultProps: {
  1811. step: number;
  1812. };
  1813. private _localChange;
  1814. constructor(props: IVector3LineComponentProps);
  1815. shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
  1816. isExpanded: boolean;
  1817. value: BABYLON.Vector3;
  1818. }): boolean;
  1819. switchExpandState(): void;
  1820. raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
  1821. updateVector3(): void;
  1822. updateStateX(value: number): void;
  1823. updateStateY(value: number): void;
  1824. updateStateZ(value: number): void;
  1825. render(): JSX.Element;
  1826. }
  1827. }
  1828. declare module NODEEDITOR {
  1829. interface IVector3PropertyTabComponentProps {
  1830. globalState: GlobalState;
  1831. inputBlock: BABYLON.InputBlock;
  1832. }
  1833. export class Vector3PropertyTabComponent extends React.Component<IVector3PropertyTabComponentProps> {
  1834. render(): JSX.Element;
  1835. }
  1836. }
  1837. declare module NODEEDITOR {
  1838. class ListLineOption {
  1839. label: string;
  1840. value: number | string;
  1841. }
  1842. interface IOptionsLineComponentProps {
  1843. label: string;
  1844. target: any;
  1845. propertyName?: string;
  1846. options: ListLineOption[];
  1847. noDirectUpdate?: boolean;
  1848. onSelect?: (value: number | string) => void;
  1849. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1850. valuesAreStrings?: boolean;
  1851. defaultIfNull?: number;
  1852. getSelection?: (target: any) => number;
  1853. }
  1854. export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
  1855. value: number | string;
  1856. }> {
  1857. private _localChange;
  1858. private _getValue;
  1859. constructor(props: IOptionsLineComponentProps);
  1860. shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
  1861. value: number;
  1862. }): boolean;
  1863. raiseOnPropertyChanged(newValue: number | string, previousValue: number | string): void;
  1864. updateValue(valueString: string): void;
  1865. render(): JSX.Element;
  1866. }
  1867. }
  1868. declare module NODEEDITOR {
  1869. export interface IColor3LineComponentProps {
  1870. label: string;
  1871. target: any;
  1872. propertyName: string;
  1873. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1874. onChange?: () => void;
  1875. }
  1876. export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
  1877. isExpanded: boolean;
  1878. color: BABYLON.Color3;
  1879. }> {
  1880. private _localChange;
  1881. constructor(props: IColor3LineComponentProps);
  1882. shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
  1883. color: BABYLON.Color3;
  1884. }): boolean;
  1885. onChange(newValue: string): void;
  1886. switchExpandState(): void;
  1887. raiseOnPropertyChanged(previousValue: BABYLON.Color3): void;
  1888. updateStateR(value: number): void;
  1889. updateStateG(value: number): void;
  1890. updateStateB(value: number): void;
  1891. copyToClipboard(): void;
  1892. render(): JSX.Element;
  1893. }
  1894. }
  1895. declare module NODEEDITOR {
  1896. interface IColor3PropertyTabComponentProps {
  1897. globalState: GlobalState;
  1898. inputBlock: BABYLON.InputBlock;
  1899. }
  1900. export class Color3PropertyTabComponent extends React.Component<IColor3PropertyTabComponentProps> {
  1901. render(): JSX.Element;
  1902. }
  1903. }
  1904. declare module NODEEDITOR {
  1905. interface IFloatLineComponentProps {
  1906. label: string;
  1907. target: any;
  1908. propertyName: string;
  1909. onChange?: (newValue: number) => void;
  1910. isInteger?: boolean;
  1911. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1912. additionalClass?: string;
  1913. step?: string;
  1914. digits?: number;
  1915. }
  1916. export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
  1917. value: string;
  1918. }> {
  1919. private _localChange;
  1920. private _store;
  1921. constructor(props: IFloatLineComponentProps);
  1922. shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
  1923. value: string;
  1924. }): boolean;
  1925. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  1926. updateValue(valueString: string): void;
  1927. render(): JSX.Element;
  1928. }
  1929. }
  1930. declare module NODEEDITOR {
  1931. interface IFloatPropertyTabComponentProps {
  1932. globalState: GlobalState;
  1933. inputBlock: BABYLON.InputBlock;
  1934. }
  1935. export class FloatPropertyTabComponent extends React.Component<IFloatPropertyTabComponentProps> {
  1936. render(): JSX.Element;
  1937. }
  1938. }
  1939. declare module NODEEDITOR {
  1940. interface IInputPropertyTabComponentProps {
  1941. globalState: GlobalState;
  1942. inputNode: InputNodeModel;
  1943. }
  1944. export class InputPropertyTabComponentProps extends React.Component<IInputPropertyTabComponentProps> {
  1945. constructor(props: IInputPropertyTabComponentProps);
  1946. renderValue(globalState: GlobalState): JSX.Element | null;
  1947. setDefaultValue(): void;
  1948. render(): JSX.Element;
  1949. }
  1950. }
  1951. declare module NODEEDITOR {
  1952. /**
  1953. * Generic node model which stores information about a node editor block
  1954. */
  1955. export class InputNodeModel extends DefaultNodeModel {
  1956. readonly inputBlock: BABYLON.InputBlock;
  1957. /**
  1958. * Constructs the node model
  1959. */
  1960. constructor();
  1961. renderProperties(globalState: GlobalState): JSX.Element;
  1962. }
  1963. }
  1964. declare module NODEEDITOR {
  1965. /**
  1966. * GenericNodeWidgetProps
  1967. */
  1968. export interface IInputNodeWidgetProps {
  1969. node: BABYLON.Nullable<InputNodeModel>;
  1970. globalState: GlobalState;
  1971. }
  1972. /**
  1973. * Used to display a node block for the node editor
  1974. */
  1975. export class InputNodeWidget extends React.Component<IInputNodeWidgetProps> {
  1976. /**
  1977. * Creates a GenericNodeWidget
  1978. * @param props
  1979. */
  1980. constructor(props: IInputNodeWidgetProps);
  1981. renderValue(value: string): JSX.Element | null;
  1982. render(): JSX.Element | null;
  1983. }
  1984. }
  1985. declare module NODEEDITOR {
  1986. /**
  1987. * Node factory which creates editor nodes
  1988. */
  1989. export class InputNodeFactory extends SRD.AbstractNodeFactory {
  1990. private _globalState;
  1991. /**
  1992. * Constructs a GenericNodeFactory
  1993. */
  1994. constructor(globalState: GlobalState);
  1995. /**
  1996. * Generates a node widget
  1997. * @param diagramEngine diagram engine
  1998. * @param node node to generate
  1999. * @returns node widget jsx
  2000. */
  2001. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: InputNodeModel): JSX.Element;
  2002. /**
  2003. * Gets a new instance of a node model
  2004. * @returns input node model
  2005. */
  2006. getNewInstance(): InputNodeModel;
  2007. }
  2008. }
  2009. declare module NODEEDITOR {
  2010. interface ILogComponentProps {
  2011. globalState: GlobalState;
  2012. }
  2013. export class LogEntry {
  2014. message: string;
  2015. isError: boolean;
  2016. constructor(message: string, isError: boolean);
  2017. }
  2018. export class LogComponent extends React.Component<ILogComponentProps, {
  2019. logs: LogEntry[];
  2020. }> {
  2021. constructor(props: ILogComponentProps);
  2022. componentWillMount(): void;
  2023. componentDidUpdate(): void;
  2024. render(): JSX.Element;
  2025. }
  2026. }
  2027. declare module NODEEDITOR {
  2028. interface ILightPropertyTabComponentProps {
  2029. globalState: GlobalState;
  2030. node: LightNodeModel;
  2031. }
  2032. export class LightPropertyTabComponent extends React.Component<ILightPropertyTabComponentProps> {
  2033. render(): JSX.Element;
  2034. }
  2035. }
  2036. declare module NODEEDITOR {
  2037. /**
  2038. * BABYLON.Light node model which stores information about a node editor block
  2039. */
  2040. export class LightNodeModel extends DefaultNodeModel {
  2041. private _block;
  2042. /**
  2043. * BABYLON.Light for the node if it exists
  2044. */
  2045. light: BABYLON.Nullable<BABYLON.Light>;
  2046. /**
  2047. * Constructs the node model
  2048. */
  2049. constructor();
  2050. renderProperties(globalState: GlobalState): JSX.Element;
  2051. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  2052. }
  2053. }
  2054. declare module NODEEDITOR {
  2055. /**
  2056. * GenericNodeWidgetProps
  2057. */
  2058. export interface ILightNodeWidgetProps {
  2059. node: BABYLON.Nullable<LightNodeModel>;
  2060. globalState: GlobalState;
  2061. }
  2062. /**
  2063. * Used to display a node block for the node editor
  2064. */
  2065. export class LightNodeWidget extends React.Component<ILightNodeWidgetProps> {
  2066. /**
  2067. * Creates a GenericNodeWidget
  2068. * @param props
  2069. */
  2070. constructor(props: ILightNodeWidgetProps);
  2071. render(): JSX.Element;
  2072. }
  2073. }
  2074. declare module NODEEDITOR {
  2075. /**
  2076. * Node factory which creates editor nodes
  2077. */
  2078. export class LightNodeFactory extends SRD.AbstractNodeFactory {
  2079. private _globalState;
  2080. /**
  2081. * Constructs a LightNodeFactory
  2082. */
  2083. constructor(globalState: GlobalState);
  2084. /**
  2085. * Generates a node widget
  2086. * @param diagramEngine diagram engine
  2087. * @param node node to generate
  2088. * @returns node widget jsx
  2089. */
  2090. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: LightNodeModel): JSX.Element;
  2091. /**
  2092. * Gets a new instance of a node model
  2093. * @returns light node model
  2094. */
  2095. getNewInstance(): LightNodeModel;
  2096. }
  2097. }
  2098. declare module NODEEDITOR {
  2099. interface IMessageDialogComponentProps {
  2100. globalState: GlobalState;
  2101. }
  2102. export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
  2103. message: string;
  2104. isError: boolean;
  2105. }> {
  2106. constructor(props: IMessageDialogComponentProps);
  2107. render(): JSX.Element | null;
  2108. }
  2109. }
  2110. declare module NODEEDITOR {
  2111. export class AdvancedLinkFactory extends DefaultLinkFactory {
  2112. constructor();
  2113. getNewInstance(initialConfig?: any): AdvancedLinkModel;
  2114. generateLinkSegment(model: AdvancedLinkModel, widget: DefaultLinkWidget, selected: boolean, path: string): JSX.Element;
  2115. }
  2116. }
  2117. declare module NODEEDITOR {
  2118. interface IRemapPropertyTabComponentProps {
  2119. globalState: GlobalState;
  2120. remapNode: RemapNodeModel;
  2121. }
  2122. export class RemapPropertyTabComponentProps extends React.Component<IRemapPropertyTabComponentProps> {
  2123. constructor(props: IRemapPropertyTabComponentProps);
  2124. forceRebuild(): void;
  2125. render(): JSX.Element;
  2126. }
  2127. }
  2128. declare module NODEEDITOR {
  2129. /**
  2130. * Generic node model which stores information about a node editor block
  2131. */
  2132. export class RemapNodeModel extends DefaultNodeModel {
  2133. readonly remapBlock: BABYLON.RemapBlock;
  2134. /**
  2135. * Constructs the node model
  2136. */
  2137. constructor();
  2138. renderProperties(globalState: GlobalState): JSX.Element;
  2139. }
  2140. }
  2141. declare module NODEEDITOR {
  2142. /**
  2143. * RemapNodeWidgetProps
  2144. */
  2145. export interface RemapNodeWidgetProps {
  2146. node: BABYLON.Nullable<RemapNodeModel>;
  2147. globalState: GlobalState;
  2148. }
  2149. /**
  2150. * Used to display a node block for the node editor
  2151. */
  2152. export class RemapNodeWidget extends React.Component<RemapNodeWidgetProps> {
  2153. /**
  2154. * Creates a GenericNodeWidget
  2155. * @param props
  2156. */
  2157. constructor(props: RemapNodeWidgetProps);
  2158. renderValue(value: string): JSX.Element | null;
  2159. render(): JSX.Element;
  2160. }
  2161. }
  2162. declare module NODEEDITOR {
  2163. /**
  2164. * Node factory which creates editor nodes
  2165. */
  2166. export class RemapNodeFactory extends SRD.AbstractNodeFactory {
  2167. private _globalState;
  2168. /**
  2169. * Constructs a GenericNodeFactory
  2170. */
  2171. constructor(globalState: GlobalState);
  2172. /**
  2173. * Generates a node widget
  2174. * @param diagramEngine diagram engine
  2175. * @param node node to generate
  2176. * @returns node widget jsx
  2177. */
  2178. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: RemapNodeModel): JSX.Element;
  2179. /**
  2180. * Gets a new instance of a node model
  2181. * @returns input node model
  2182. */
  2183. getNewInstance(): RemapNodeModel;
  2184. }
  2185. }
  2186. declare module NODEEDITOR {
  2187. export class GraphHelper {
  2188. static DistributeGraph(model: DiagramModel): dagre.Node[];
  2189. private static _MapElements;
  2190. private static _MapEdges;
  2191. }
  2192. }
  2193. declare module NODEEDITOR {
  2194. export enum PreviewMeshType {
  2195. Sphere = 0,
  2196. Box = 1,
  2197. Torus = 2,
  2198. Cylinder = 3
  2199. }
  2200. }
  2201. declare module NODEEDITOR {
  2202. export class PreviewManager {
  2203. private _nodeMaterial;
  2204. private _onBuildObserver;
  2205. private _onPreviewMeshTypeChangedObserver;
  2206. private _onUpdateRequiredObserver;
  2207. private _engine;
  2208. private _scene;
  2209. private _light;
  2210. private _dummy;
  2211. private _camera;
  2212. private _material;
  2213. private _globalState;
  2214. constructor(targetCanvas: HTMLCanvasElement, globalState: GlobalState);
  2215. private _refreshPreviewMesh;
  2216. private _updatePreview;
  2217. dispose(): void;
  2218. }
  2219. }
  2220. declare module NODEEDITOR {
  2221. interface IPreviewMeshControlComponent {
  2222. globalState: GlobalState;
  2223. }
  2224. export class PreviewMeshControlComponent extends React.Component<IPreviewMeshControlComponent> {
  2225. changeMeshType(newOne: PreviewMeshType): void;
  2226. render(): JSX.Element;
  2227. }
  2228. }
  2229. declare module NODEEDITOR {
  2230. interface ITrigonometryTabComponentProps {
  2231. globalState: GlobalState;
  2232. trigonometryNode: TrigonometryNodeModel;
  2233. }
  2234. export class TrigonometryPropertyTabComponentProps extends React.Component<ITrigonometryTabComponentProps> {
  2235. constructor(props: ITrigonometryTabComponentProps);
  2236. render(): JSX.Element;
  2237. }
  2238. }
  2239. declare module NODEEDITOR {
  2240. /**
  2241. * Generic node model which stores information about a node editor block
  2242. */
  2243. export class TrigonometryNodeModel extends DefaultNodeModel {
  2244. readonly trigonometryBlock: BABYLON.TrigonometryBlock;
  2245. /**
  2246. * Constructs the node model
  2247. */
  2248. constructor();
  2249. renderProperties(globalState: GlobalState): JSX.Element;
  2250. }
  2251. }
  2252. declare module NODEEDITOR {
  2253. /**
  2254. * GenericNodeWidgetProps
  2255. */
  2256. export interface ITrigonometryNodeWidgetProps {
  2257. node: BABYLON.Nullable<TrigonometryNodeModel>;
  2258. globalState: GlobalState;
  2259. }
  2260. /**
  2261. * Used to display a node block for the node editor
  2262. */
  2263. export class TrigonometryNodeWidget extends React.Component<ITrigonometryNodeWidgetProps> {
  2264. /**
  2265. * Creates a GenericNodeWidget
  2266. * @param props
  2267. */
  2268. constructor(props: ITrigonometryNodeWidgetProps);
  2269. render(): JSX.Element;
  2270. }
  2271. }
  2272. declare module NODEEDITOR {
  2273. /**
  2274. * Node factory which creates editor nodes
  2275. */
  2276. export class TrigonometryNodeFactory extends SRD.AbstractNodeFactory {
  2277. private _globalState;
  2278. /**
  2279. * Constructs a GenericNodeFactory
  2280. */
  2281. constructor(globalState: GlobalState);
  2282. /**
  2283. * Generates a node widget
  2284. * @param diagramEngine diagram engine
  2285. * @param node node to generate
  2286. * @returns node widget jsx
  2287. */
  2288. generateReactWidget(diagramEngine: SRD.DiagramEngine, node: TrigonometryNodeModel): JSX.Element;
  2289. /**
  2290. * Gets a new instance of a node model
  2291. * @returns input node model
  2292. */
  2293. getNewInstance(): TrigonometryNodeModel;
  2294. }
  2295. }
  2296. declare module NODEEDITOR {
  2297. interface IGraphEditorProps {
  2298. globalState: GlobalState;
  2299. }
  2300. export class NodeCreationOptions {
  2301. nodeMaterialBlock: BABYLON.NodeMaterialBlock;
  2302. type?: string;
  2303. connection?: BABYLON.NodeMaterialConnectionPoint;
  2304. }
  2305. export class GraphEditor extends React.Component<IGraphEditorProps> {
  2306. private readonly NodeWidth;
  2307. private _engine;
  2308. private _model;
  2309. private _startX;
  2310. private _moveInProgress;
  2311. private _leftWidth;
  2312. private _rightWidth;
  2313. private _nodes;
  2314. private _blocks;
  2315. private _previewManager;
  2316. private _copiedNode;
  2317. private _mouseLocationX;
  2318. private _mouseLocationY;
  2319. private _onWidgetKeyUpPointer;
  2320. /** @hidden */
  2321. _toAdd: LinkModel[] | null;
  2322. /**
  2323. * Creates a node and recursivly creates its parent nodes from it's input
  2324. * @param nodeMaterialBlock
  2325. */
  2326. createNodeFromObject(options: NodeCreationOptions): DefaultNodeModel;
  2327. addValueNode(type: string): DefaultNodeModel;
  2328. onWidgetKeyUp(evt: any): void;
  2329. componentDidMount(): void;
  2330. componentWillUnmount(): void;
  2331. constructor(props: IGraphEditorProps);
  2332. zoomToFit(retry?: number): void;
  2333. buildMaterial(): void;
  2334. build(needToWait?: boolean, locations?: BABYLON.Nullable<INodeLocationInfo[]>): void;
  2335. reOrganize(locations?: BABYLON.Nullable<INodeLocationInfo[]>): void;
  2336. onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
  2337. onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
  2338. resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
  2339. buildColumnLayout(): string;
  2340. emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
  2341. render(): JSX.Element;
  2342. }
  2343. }
  2344. declare module NODEEDITOR {
  2345. /**
  2346. * Generic node model which stores information about a node editor block
  2347. */
  2348. export class DefaultNodeModel extends NodeModel {
  2349. /**
  2350. * The babylon block this node represents
  2351. */
  2352. block: BABYLON.Nullable<BABYLON.NodeMaterialBlock>;
  2353. ports: {
  2354. [s: string]: DefaultPortModel;
  2355. };
  2356. /**
  2357. * Constructs the node model
  2358. */
  2359. constructor(key: string);
  2360. prepare(options: NodeCreationOptions, nodes: Array<DefaultNodeModel>, model: DiagramModel, graphEditor: GraphEditor): void;
  2361. renderProperties(globalState: GlobalState): JSX.Element | null;
  2362. }
  2363. }
  2364. declare module NODEEDITOR {
  2365. export class GlobalState {
  2366. nodeMaterial: BABYLON.NodeMaterial;
  2367. hostElement: HTMLElement;
  2368. hostDocument: HTMLDocument;
  2369. onSelectionChangedObservable: BABYLON.Observable<BABYLON.Nullable<DefaultNodeModel>>;
  2370. onRebuildRequiredObservable: BABYLON.Observable<void>;
  2371. onResetRequiredObservable: BABYLON.Observable<BABYLON.Nullable<INodeLocationInfo[]>>;
  2372. onUpdateRequiredObservable: BABYLON.Observable<void>;
  2373. onZoomToFitRequiredObservable: BABYLON.Observable<void>;
  2374. onReOrganizedRequiredObservable: BABYLON.Observable<void>;
  2375. onLogRequiredObservable: BABYLON.Observable<LogEntry>;
  2376. onErrorMessageDialogRequiredObservable: BABYLON.Observable<string>;
  2377. onPreviewMeshTypeChanged: BABYLON.Observable<void>;
  2378. onGetNodeFromBlock: (block: BABYLON.NodeMaterialBlock) => NodeModel;
  2379. previewMeshType: PreviewMeshType;
  2380. blockKeyboardEvents: boolean;
  2381. constructor();
  2382. }
  2383. }
  2384. declare module NODEEDITOR {
  2385. export class Popup {
  2386. static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): HTMLDivElement | null;
  2387. private static _CopyStyles;
  2388. }
  2389. }
  2390. declare module NODEEDITOR {
  2391. /**
  2392. * Interface used to specify creation options for the node editor
  2393. */
  2394. export interface INodeEditorOptions {
  2395. nodeMaterial: BABYLON.NodeMaterial;
  2396. }
  2397. /**
  2398. * Class used to create a node editor
  2399. */
  2400. export class NodeEditor {
  2401. /**
  2402. * Show the node editor
  2403. * @param options defines the options to use to configure the node editor
  2404. */
  2405. static Show(options: INodeEditorOptions): void;
  2406. }
  2407. }