babylon.inspector.d.ts 124 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279
  1. /// <reference types="react" />
  2. declare module INSPECTOR {
  3. export class PropertyChangedEvent {
  4. object: any;
  5. property: string;
  6. value: any;
  7. initialValue: any;
  8. allowNullValue?: boolean;
  9. }
  10. }
  11. declare module INSPECTOR {
  12. export class ReplayRecorder {
  13. private _sceneRecorder;
  14. private _isRecording;
  15. get isRecording(): boolean;
  16. cancel(): void;
  17. trackScene(scene: BABYLON.Scene): void;
  18. applyDelta(json: any, scene: BABYLON.Scene): void;
  19. export(): void;
  20. }
  21. }
  22. declare module INSPECTOR {
  23. export class GlobalState {
  24. onSelectionChangedObservable: BABYLON.Observable<any>;
  25. onPropertyChangedObservable: BABYLON.Observable<PropertyChangedEvent>;
  26. onInspectorClosedObservable: BABYLON.Observable<BABYLON.Scene>;
  27. onTabChangedObservable: BABYLON.Observable<number>;
  28. onSelectionRenamedObservable: BABYLON.Observable<void>;
  29. onPluginActivatedObserver: BABYLON.Nullable<BABYLON.Observer<BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync>>;
  30. onNewSceneObservable: BABYLON.Observable<BABYLON.Scene>;
  31. sceneImportDefaults: {
  32. [key: string]: any;
  33. };
  34. validationResults: BABYLON.Nullable<BABYLON.GLTF2.IGLTFValidationResults>;
  35. onValidationResultsUpdatedObservable: BABYLON.Observable<BABYLON.Nullable<BABYLON.GLTF2.IGLTFValidationResults>>;
  36. onExtensionLoadedObservable: BABYLON.Observable<BABYLON.IGLTFLoaderExtension>;
  37. glTFLoaderExtensionDefaults: {
  38. [name: string]: {
  39. [key: string]: any;
  40. };
  41. };
  42. glTFLoaderDefaults: {
  43. [key: string]: any;
  44. };
  45. glTFLoaderExtenstions: {
  46. [key: string]: BABYLON.IGLTFLoaderExtension;
  47. };
  48. blockMutationUpdates: boolean;
  49. selectedLineContainerTitles: Array<string>;
  50. selectedLineContainerTitlesNoFocus: Array<string>;
  51. recorder: ReplayRecorder;
  52. private _onlyUseEulers;
  53. get onlyUseEulers(): boolean;
  54. set onlyUseEulers(value: boolean);
  55. private _ignoreBackfacesForPicking;
  56. get ignoreBackfacesForPicking(): boolean;
  57. set ignoreBackfacesForPicking(value: boolean);
  58. init(propertyChangedObservable: BABYLON.Observable<PropertyChangedEvent>): void;
  59. prepareGLTFPlugin(loader: BABYLON.GLTFFileLoader): void;
  60. lightGizmos: Array<BABYLON.LightGizmo>;
  61. enableLightGizmo(light: BABYLON.Light, enable?: boolean): void;
  62. }
  63. }
  64. declare module INSPECTOR {
  65. export interface IPaneComponentProps {
  66. title: string;
  67. scene: BABYLON.Scene;
  68. selectedEntity?: any;
  69. onSelectionChangedObservable?: BABYLON.Observable<any>;
  70. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  71. globalState: GlobalState;
  72. }
  73. export class PaneComponent extends React.Component<IPaneComponentProps, {
  74. tag: any;
  75. }> {
  76. constructor(props: IPaneComponentProps);
  77. render(): JSX.Element | null;
  78. }
  79. }
  80. declare module INSPECTOR {
  81. interface ITabsComponentProps {
  82. children: any[];
  83. selectedIndex: number;
  84. onSelectedIndexChange: (value: number) => void;
  85. }
  86. export class TabsComponent extends React.Component<ITabsComponentProps> {
  87. constructor(props: ITabsComponentProps);
  88. onSelect(index: number): void;
  89. renderLabel(child: PaneComponent, index: number): JSX.Element;
  90. render(): JSX.Element;
  91. }
  92. }
  93. declare module INSPECTOR {
  94. interface ITextLineComponentProps {
  95. label?: string;
  96. value?: string;
  97. color?: string;
  98. underline?: boolean;
  99. onLink?: () => void;
  100. url?: string;
  101. ignoreValue?: boolean;
  102. additionalClass?: string;
  103. }
  104. export class TextLineComponent extends React.Component<ITextLineComponentProps> {
  105. constructor(props: ITextLineComponentProps);
  106. onLink(): void;
  107. renderContent(): JSX.Element | null;
  108. render(): JSX.Element;
  109. }
  110. }
  111. declare module INSPECTOR {
  112. interface ILineContainerComponentProps {
  113. globalState?: GlobalState;
  114. title: string;
  115. children: any[] | any;
  116. closed?: boolean;
  117. }
  118. export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
  119. isExpanded: boolean;
  120. isHighlighted: boolean;
  121. }> {
  122. constructor(props: ILineContainerComponentProps);
  123. switchExpandedState(): void;
  124. componentDidMount(): void;
  125. renderHeader(): JSX.Element;
  126. render(): JSX.Element;
  127. }
  128. }
  129. declare module INSPECTOR {
  130. interface IValueLineComponentProps {
  131. label: string;
  132. value: number;
  133. color?: string;
  134. fractionDigits?: number;
  135. units?: string;
  136. }
  137. export class ValueLineComponent extends React.Component<IValueLineComponentProps> {
  138. constructor(props: IValueLineComponentProps);
  139. render(): JSX.Element;
  140. }
  141. }
  142. declare module INSPECTOR {
  143. export interface IBooleanLineComponentProps {
  144. label: string;
  145. value: boolean;
  146. }
  147. export class BooleanLineComponent extends React.Component<IBooleanLineComponentProps> {
  148. constructor(props: IBooleanLineComponentProps);
  149. render(): JSX.Element;
  150. }
  151. }
  152. declare module INSPECTOR {
  153. export class StatisticsTabComponent extends PaneComponent {
  154. private _sceneInstrumentation;
  155. private _engineInstrumentation;
  156. private _timerIntervalId;
  157. constructor(props: IPaneComponentProps);
  158. componentWillUnmount(): void;
  159. render(): JSX.Element | null;
  160. }
  161. }
  162. declare module INSPECTOR {
  163. export interface ICheckBoxLineComponentProps {
  164. label: string;
  165. target?: any;
  166. propertyName?: string;
  167. isSelected?: () => boolean;
  168. onSelect?: (value: boolean) => void;
  169. onValueChanged?: () => void;
  170. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  171. }
  172. export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
  173. isSelected: boolean;
  174. }> {
  175. private static _UniqueIdSeed;
  176. private _uniqueId;
  177. private _localChange;
  178. constructor(props: ICheckBoxLineComponentProps);
  179. shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
  180. isSelected: boolean;
  181. }): boolean;
  182. onChange(): void;
  183. render(): JSX.Element;
  184. }
  185. }
  186. declare module INSPECTOR {
  187. interface IRenderGridPropertyGridComponentProps {
  188. globalState: GlobalState;
  189. scene: BABYLON.Scene;
  190. }
  191. export class RenderGridPropertyGridComponent extends React.Component<IRenderGridPropertyGridComponentProps, {
  192. isEnabled: boolean;
  193. }> {
  194. private _gridMesh;
  195. constructor(props: IRenderGridPropertyGridComponentProps);
  196. componentDidMount(): void;
  197. addOrRemoveGrid(): void;
  198. render(): JSX.Element;
  199. }
  200. }
  201. declare module INSPECTOR {
  202. export class DebugTabComponent extends PaneComponent {
  203. private _physicsViewersEnabled;
  204. constructor(props: IPaneComponentProps);
  205. switchPhysicsViewers(): void;
  206. render(): JSX.Element | null;
  207. }
  208. }
  209. declare module INSPECTOR {
  210. interface ISliderLineComponentProps {
  211. label: string;
  212. target?: any;
  213. propertyName?: string;
  214. minimum: number;
  215. maximum: number;
  216. step: number;
  217. directValue?: number;
  218. useEuler?: boolean;
  219. onChange?: (value: number) => void;
  220. onInput?: (value: number) => void;
  221. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  222. decimalCount?: number;
  223. }
  224. export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
  225. value: number;
  226. }> {
  227. private _localChange;
  228. constructor(props: ISliderLineComponentProps);
  229. shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
  230. value: number;
  231. }): boolean;
  232. onChange(newValueString: any): void;
  233. onInput(newValueString: any): void;
  234. prepareDataToRead(value: number): number;
  235. render(): JSX.Element;
  236. }
  237. }
  238. declare module INSPECTOR {
  239. export const Null_Value: number;
  240. class ListLineOption {
  241. label: string;
  242. value: number;
  243. }
  244. interface IOptionsLineComponentProps {
  245. label: string;
  246. target: any;
  247. propertyName: string;
  248. options: ListLineOption[];
  249. noDirectUpdate?: boolean;
  250. onSelect?: (value: number) => void;
  251. extractValue?: () => number;
  252. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  253. allowNullValue?: boolean;
  254. }
  255. export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
  256. value: number;
  257. }> {
  258. private _localChange;
  259. private remapValueIn;
  260. private remapValueOut;
  261. constructor(props: IOptionsLineComponentProps);
  262. shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
  263. value: number;
  264. }): boolean;
  265. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  266. updateValue(valueString: string): void;
  267. render(): JSX.Element;
  268. }
  269. }
  270. declare module INSPECTOR {
  271. /**
  272. * Class used to provide lock mechanism
  273. */
  274. export class LockObject {
  275. /**
  276. * Gets or set if the lock is engaged
  277. */
  278. lock: boolean;
  279. }
  280. }
  281. declare module INSPECTOR {
  282. interface INumericInputComponentProps {
  283. label: string;
  284. value: number;
  285. step?: number;
  286. onChange: (value: number) => void;
  287. precision?: number;
  288. }
  289. export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
  290. value: string;
  291. }> {
  292. static defaultProps: {
  293. step: number;
  294. };
  295. private _localChange;
  296. constructor(props: INumericInputComponentProps);
  297. shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
  298. value: string;
  299. }): boolean;
  300. updateValue(evt: any): void;
  301. render(): JSX.Element;
  302. }
  303. }
  304. declare module INSPECTOR {
  305. export interface IColorPickerComponentProps {
  306. value: BABYLON.Color4 | BABYLON.Color3;
  307. onColorChanged: (newOne: string) => void;
  308. disableAlpha?: boolean;
  309. }
  310. interface IColorPickerComponentState {
  311. pickerEnabled: boolean;
  312. color: {
  313. r: number;
  314. g: number;
  315. b: number;
  316. a?: number;
  317. };
  318. hex: string;
  319. }
  320. export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
  321. private _floatRef;
  322. private _floatHostRef;
  323. constructor(props: IColorPickerComponentProps);
  324. syncPositions(): void;
  325. shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
  326. componentDidUpdate(): void;
  327. componentDidMount(): void;
  328. render(): JSX.Element;
  329. }
  330. }
  331. declare module INSPECTOR {
  332. export interface IColor3LineComponentProps {
  333. label: string;
  334. target: any;
  335. propertyName: string;
  336. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  337. isLinear?: boolean;
  338. }
  339. export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
  340. isExpanded: boolean;
  341. color: BABYLON.Color3;
  342. }> {
  343. private _localChange;
  344. constructor(props: IColor3LineComponentProps);
  345. shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
  346. color: BABYLON.Color3;
  347. }): boolean;
  348. setPropertyValue(newColor: BABYLON.Color3): void;
  349. onChange(newValue: string): void;
  350. switchExpandState(): void;
  351. raiseOnPropertyChanged(previousValue: BABYLON.Color3): void;
  352. updateStateR(value: number): void;
  353. updateStateG(value: number): void;
  354. updateStateB(value: number): void;
  355. copyToClipboard(): void;
  356. render(): JSX.Element;
  357. }
  358. }
  359. declare module INSPECTOR {
  360. interface IVector3LineComponentProps {
  361. label: string;
  362. target: any;
  363. propertyName: string;
  364. step?: number;
  365. onChange?: (newvalue: BABYLON.Vector3) => void;
  366. useEuler?: boolean;
  367. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  368. }
  369. export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
  370. isExpanded: boolean;
  371. value: BABYLON.Vector3;
  372. }> {
  373. static defaultProps: {
  374. step: number;
  375. };
  376. private _localChange;
  377. constructor(props: IVector3LineComponentProps);
  378. getCurrentValue(): any;
  379. shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
  380. isExpanded: boolean;
  381. value: BABYLON.Vector3;
  382. }): boolean;
  383. switchExpandState(): void;
  384. raiseOnPropertyChanged(previousValue: BABYLON.Vector3): void;
  385. updateVector3(): void;
  386. updateStateX(value: number): void;
  387. updateStateY(value: number): void;
  388. updateStateZ(value: number): void;
  389. render(): JSX.Element;
  390. }
  391. }
  392. declare module INSPECTOR {
  393. interface IQuaternionLineComponentProps {
  394. label: string;
  395. target: any;
  396. useEuler?: boolean;
  397. propertyName: string;
  398. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  399. }
  400. export class QuaternionLineComponent extends React.Component<IQuaternionLineComponentProps, {
  401. isExpanded: boolean;
  402. value: BABYLON.Quaternion;
  403. eulerValue: BABYLON.Vector3;
  404. }> {
  405. private _localChange;
  406. constructor(props: IQuaternionLineComponentProps);
  407. shouldComponentUpdate(nextProps: IQuaternionLineComponentProps, nextState: {
  408. isExpanded: boolean;
  409. value: BABYLON.Quaternion;
  410. eulerValue: BABYLON.Vector3;
  411. }): boolean;
  412. switchExpandState(): void;
  413. raiseOnPropertyChanged(currentValue: BABYLON.Quaternion, previousValue: BABYLON.Quaternion): void;
  414. updateQuaternion(): void;
  415. updateStateX(value: number): void;
  416. updateStateY(value: number): void;
  417. updateStateZ(value: number): void;
  418. updateStateW(value: number): void;
  419. updateQuaternionFromEuler(): void;
  420. updateStateEulerX(value: number): void;
  421. updateStateEulerY(value: number): void;
  422. updateStateEulerZ(value: number): void;
  423. render(): JSX.Element;
  424. }
  425. }
  426. declare module INSPECTOR {
  427. interface ITextInputLineComponentProps {
  428. label: string;
  429. lockObject: LockObject;
  430. target?: any;
  431. propertyName?: string;
  432. value?: string;
  433. onChange?: (value: string) => void;
  434. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  435. }
  436. export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
  437. value: string;
  438. }> {
  439. private _localChange;
  440. constructor(props: ITextInputLineComponentProps);
  441. componentWillUnmount(): void;
  442. shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
  443. value: string;
  444. }): boolean;
  445. raiseOnPropertyChanged(newValue: string, previousValue: string): void;
  446. updateValue(value: string): void;
  447. render(): JSX.Element;
  448. }
  449. }
  450. declare module INSPECTOR {
  451. interface ICustomPropertyGridComponentProps {
  452. globalState: GlobalState;
  453. target: any;
  454. lockObject: LockObject;
  455. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  456. }
  457. export class CustomPropertyGridComponent extends React.Component<ICustomPropertyGridComponentProps, {
  458. mode: number;
  459. }> {
  460. constructor(props: ICustomPropertyGridComponentProps);
  461. renderInspectable(inspectable: BABYLON.IInspectable): JSX.Element | null;
  462. render(): JSX.Element | null;
  463. }
  464. }
  465. declare module INSPECTOR {
  466. export interface IButtonLineComponentProps {
  467. label: string;
  468. onClick: () => void;
  469. }
  470. export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
  471. constructor(props: IButtonLineComponentProps);
  472. render(): JSX.Element;
  473. }
  474. }
  475. declare module INSPECTOR {
  476. interface IFloatLineComponentProps {
  477. label: string;
  478. target: any;
  479. propertyName: string;
  480. lockObject?: LockObject;
  481. onChange?: (newValue: number) => void;
  482. isInteger?: boolean;
  483. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  484. additionalClass?: string;
  485. step?: string;
  486. digits?: number;
  487. useEuler?: boolean;
  488. min?: number;
  489. }
  490. export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
  491. value: string;
  492. }> {
  493. private _localChange;
  494. private _store;
  495. constructor(props: IFloatLineComponentProps);
  496. componentWillUnmount(): void;
  497. shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
  498. value: string;
  499. }): boolean;
  500. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  501. updateValue(valueString: string): void;
  502. lock(): void;
  503. unlock(): void;
  504. render(): JSX.Element;
  505. }
  506. }
  507. declare module INSPECTOR {
  508. interface IAnchorSvgPointProps {
  509. control: BABYLON.Vector2;
  510. anchor: BABYLON.Vector2;
  511. active: boolean;
  512. type: string;
  513. index: string;
  514. selected: boolean;
  515. selectControlPoint: (id: string) => void;
  516. }
  517. export class AnchorSvgPoint extends React.Component<IAnchorSvgPointProps> {
  518. constructor(props: IAnchorSvgPointProps);
  519. select(): void;
  520. render(): JSX.Element;
  521. }
  522. }
  523. declare module INSPECTOR {
  524. export interface IKeyframeSvgPoint {
  525. keyframePoint: BABYLON.Vector2;
  526. rightControlPoint: BABYLON.Vector2 | null;
  527. leftControlPoint: BABYLON.Vector2 | null;
  528. id: string;
  529. selected: boolean;
  530. isLeftActive: boolean;
  531. isRightActive: boolean;
  532. curveId?: ICurveMetaData;
  533. }
  534. export interface ICurveMetaData {
  535. id: number;
  536. animationName: string;
  537. property: string;
  538. }
  539. interface IKeyframeSvgPointProps {
  540. keyframePoint: BABYLON.Vector2;
  541. leftControlPoint: BABYLON.Vector2 | null;
  542. rightControlPoint: BABYLON.Vector2 | null;
  543. id: string;
  544. selected: boolean;
  545. selectKeyframe: (id: string, multiselect: boolean) => void;
  546. selectedControlPoint: (type: string, id: string) => void;
  547. isLeftActive: boolean;
  548. isRightActive: boolean;
  549. }
  550. export class KeyframeSvgPoint extends React.Component<IKeyframeSvgPointProps> {
  551. constructor(props: IKeyframeSvgPointProps);
  552. select(e: React.MouseEvent<SVGImageElement>): void;
  553. render(): JSX.Element;
  554. }
  555. }
  556. declare module INSPECTOR {
  557. interface ISvgDraggableAreaProps {
  558. keyframeSvgPoints: IKeyframeSvgPoint[];
  559. updatePosition: (updatedKeyframe: IKeyframeSvgPoint, id: string) => void;
  560. scale: number;
  561. viewBoxScale: number;
  562. selectKeyframe: (id: string, multiselect: boolean) => void;
  563. selectedControlPoint: (type: string, id: string) => void;
  564. deselectKeyframes: () => void;
  565. removeSelectedKeyframes: (points: IKeyframeSvgPoint[]) => void;
  566. panningY: (panningY: number) => void;
  567. panningX: (panningX: number) => void;
  568. setCurrentFrame: (direction: number) => void;
  569. positionCanvas?: number;
  570. repositionCanvas?: boolean;
  571. canvasPositionEnded: () => void;
  572. resetActionableKeyframe: () => void;
  573. }
  574. export class SvgDraggableArea extends React.Component<ISvgDraggableAreaProps, {
  575. panX: number;
  576. panY: number;
  577. }> {
  578. private _active;
  579. private _isCurrentPointControl;
  580. private _currentPointId;
  581. private _draggableArea;
  582. private _panStart;
  583. private _panStop;
  584. private _playheadDrag;
  585. private _playheadSelected;
  586. constructor(props: ISvgDraggableAreaProps);
  587. componentDidMount(): void;
  588. componentWillReceiveProps(newProps: ISvgDraggableAreaProps): void;
  589. dragStart(e: React.TouchEvent<SVGSVGElement>): void;
  590. dragStart(e: React.MouseEvent<SVGSVGElement, MouseEvent>): void;
  591. drag(e: React.TouchEvent<SVGSVGElement>): void;
  592. drag(e: React.MouseEvent<SVGSVGElement, MouseEvent>): void;
  593. dragEnd(e: React.TouchEvent<SVGSVGElement>): void;
  594. dragEnd(e: React.MouseEvent<SVGSVGElement, MouseEvent>): void;
  595. getMousePosition(e: React.TouchEvent<SVGSVGElement>): BABYLON.Vector2 | undefined;
  596. getMousePosition(e: React.MouseEvent<SVGSVGElement, MouseEvent>): BABYLON.Vector2 | undefined;
  597. panDirection(): void;
  598. panTo(direction: string, value: number): void;
  599. keyDown(e: KeyboardEvent): void;
  600. keyUp(e: KeyboardEvent): void;
  601. focus(e: React.MouseEvent<SVGSVGElement>): void;
  602. isNotControlPointActive(): boolean;
  603. render(): JSX.Element;
  604. }
  605. }
  606. declare module INSPECTOR {
  607. export interface IIconButtonLineComponentProps {
  608. icon: string;
  609. onClick: () => void;
  610. tooltip: string;
  611. active?: boolean;
  612. }
  613. export class IconButtonLineComponent extends React.Component<IIconButtonLineComponentProps> {
  614. constructor(props: IIconButtonLineComponentProps);
  615. render(): JSX.Element;
  616. }
  617. }
  618. declare module INSPECTOR {
  619. interface IControlsProps {
  620. keyframes: BABYLON.IAnimationKey[] | null;
  621. selected: BABYLON.IAnimationKey | null;
  622. currentFrame: number;
  623. onCurrentFrameChange: (frame: number) => void;
  624. playPause: (direction: number) => void;
  625. isPlaying: boolean;
  626. scrollable: React.RefObject<HTMLDivElement>;
  627. }
  628. export class Controls extends React.Component<IControlsProps, {
  629. selected: BABYLON.IAnimationKey;
  630. playingType: string;
  631. }> {
  632. constructor(props: IControlsProps);
  633. playBackwards(): void;
  634. play(): void;
  635. pause(): void;
  636. nextFrame(): void;
  637. previousFrame(): void;
  638. nextKeyframe(): void;
  639. previousKeyframe(): void;
  640. render(): JSX.Element;
  641. }
  642. }
  643. declare module INSPECTOR {
  644. interface ITimelineProps {
  645. keyframes: BABYLON.IAnimationKey[] | null;
  646. selected: BABYLON.IAnimationKey | null;
  647. currentFrame: number;
  648. onCurrentFrameChange: (frame: number) => void;
  649. onAnimationLimitChange: (limit: number) => void;
  650. dragKeyframe: (frame: number, index: number) => void;
  651. playPause: (direction: number) => void;
  652. isPlaying: boolean;
  653. animationLimit: number;
  654. fps: number;
  655. repositionCanvas: (frame: number) => void;
  656. }
  657. export class Timeline extends React.Component<ITimelineProps, {
  658. selected: BABYLON.IAnimationKey;
  659. activeKeyframe: number | null;
  660. start: number;
  661. end: number;
  662. scrollWidth: number | undefined;
  663. selectionLength: number[];
  664. }> {
  665. readonly _frames: object[];
  666. private _scrollable;
  667. private _scrollbarHandle;
  668. private _scrollContainer;
  669. private _direction;
  670. private _scrolling;
  671. private _shiftX;
  672. private _active;
  673. constructor(props: ITimelineProps);
  674. componentDidMount(): void;
  675. calculateScrollWidth(start: number, end: number): number | undefined;
  676. playBackwards(event: React.MouseEvent<HTMLDivElement>): void;
  677. play(event: React.MouseEvent<HTMLDivElement>): void;
  678. pause(event: React.MouseEvent<HTMLDivElement>): void;
  679. handleInputChange(event: React.ChangeEvent<HTMLInputElement>): void;
  680. setCurrentFrame(event: React.MouseEvent<HTMLDivElement>): void;
  681. handleLimitChange(event: React.ChangeEvent<HTMLInputElement>): void;
  682. nextFrame(event: React.MouseEvent<HTMLDivElement>): void;
  683. previousFrame(event: React.MouseEvent<HTMLDivElement>): void;
  684. nextKeyframe(event: React.MouseEvent<HTMLDivElement>): void;
  685. previousKeyframe(event: React.MouseEvent<HTMLDivElement>): void;
  686. dragStart(e: React.TouchEvent<SVGSVGElement>): void;
  687. dragStart(e: React.MouseEvent<SVGSVGElement, MouseEvent>): void;
  688. drag(e: React.TouchEvent<SVGSVGElement>): void;
  689. drag(e: React.MouseEvent<SVGSVGElement, MouseEvent>): void;
  690. isFrameBeingUsed(frame: number, direction: number): number | false;
  691. dragEnd(e: React.TouchEvent<SVGSVGElement>): void;
  692. dragEnd(e: React.MouseEvent<SVGSVGElement, MouseEvent>): void;
  693. scrollDragStart(e: React.TouchEvent<HTMLDivElement>): void;
  694. scrollDragStart(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
  695. scrollDrag(e: React.TouchEvent<HTMLDivElement>): void;
  696. scrollDrag(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
  697. scrollDragEnd(e: React.TouchEvent<HTMLDivElement>): void;
  698. scrollDragEnd(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
  699. moveScrollbar(pageX: number): void;
  700. resizeScrollbarRight(clientX: number): void;
  701. resizeScrollbarLeft(clientX: number): void;
  702. range(start: number, end: number): number[];
  703. getKeyframe(frame: number): false | BABYLON.IAnimationKey | undefined;
  704. getCurrentFrame(frame: number): boolean;
  705. render(): JSX.Element;
  706. }
  707. }
  708. declare module INSPECTOR {
  709. interface IPlayheadProps {
  710. message: string;
  711. open: boolean;
  712. close: () => void;
  713. }
  714. export class Notification extends React.Component<IPlayheadProps> {
  715. constructor(props: IPlayheadProps);
  716. render(): JSX.Element;
  717. }
  718. }
  719. declare module INSPECTOR {
  720. interface IGraphActionsBarProps {
  721. addKeyframe: () => void;
  722. removeKeyframe: () => void;
  723. handleValueChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
  724. handleFrameChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
  725. flatTangent: () => void;
  726. brokeTangents: () => void;
  727. setLerpMode: () => void;
  728. brokenMode: boolean;
  729. lerpMode: boolean;
  730. actionableKeyframe: IActionableKeyFrame;
  731. title: string;
  732. close: (event: any) => void;
  733. enabled: boolean;
  734. setKeyframeValue: () => void;
  735. }
  736. export class GraphActionsBar extends React.Component<IGraphActionsBarProps> {
  737. private _frameInput;
  738. private _valueInput;
  739. constructor(props: IGraphActionsBarProps);
  740. componentDidMount(): void;
  741. componentWillUnmount(): void;
  742. isEnterKeyUp(event: KeyboardEvent): void;
  743. onBlur(event: React.FocusEvent<HTMLInputElement>): void;
  744. render(): JSX.Element;
  745. }
  746. }
  747. declare module INSPECTOR {
  748. interface IAddAnimationProps {
  749. isOpen: boolean;
  750. close: () => void;
  751. entity: BABYLON.IAnimatable;
  752. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  753. setNotificationMessage: (message: string) => void;
  754. finishedUpdate: () => void;
  755. addedNewAnimation: () => void;
  756. fps: number;
  757. selectedToUpdate?: BABYLON.Animation | undefined;
  758. }
  759. export class AddAnimation extends React.Component<IAddAnimationProps, {
  760. animationName: string;
  761. animationTargetProperty: string;
  762. animationType: number;
  763. loopMode: number;
  764. animationTargetPath: string;
  765. isUpdating: boolean;
  766. }> {
  767. constructor(props: IAddAnimationProps);
  768. setInitialState(editingAnimation?: BABYLON.Animation): {
  769. animationName: string;
  770. animationTargetPath: string;
  771. animationType: number;
  772. loopMode: number;
  773. animationTargetProperty: string;
  774. isUpdating: boolean;
  775. };
  776. componentWillReceiveProps(nextProps: IAddAnimationProps): void;
  777. updateAnimation(): void;
  778. getTypeAsString(type: number): "Float" | "Quaternion" | "Vector3" | "Vector2" | "Size" | "Color3" | "Color4";
  779. addAnimation(): void;
  780. raiseOnPropertyChanged(newValue: BABYLON.Animation[], previousValue: BABYLON.Animation[]): void;
  781. raiseOnPropertyUpdated(newValue: string | number | undefined, previousValue: string | number, property: string): void;
  782. handleNameChange(event: React.ChangeEvent<HTMLInputElement>): void;
  783. handlePathChange(event: React.ChangeEvent<HTMLInputElement>): void;
  784. handleTypeChange(event: React.ChangeEvent<HTMLSelectElement>): void;
  785. handlePropertyChange(event: React.ChangeEvent<HTMLInputElement>): void;
  786. handleLoopModeChange(event: React.ChangeEvent<HTMLSelectElement>): void;
  787. render(): JSX.Element;
  788. }
  789. }
  790. declare module INSPECTOR {
  791. interface IAnimationListTreeProps {
  792. isTargetedAnimation: boolean;
  793. entity: BABYLON.IAnimatable | BABYLON.TargetedAnimation;
  794. selected: BABYLON.Animation | null;
  795. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  796. selectAnimation: (selected: BABYLON.Animation, coordinate?: SelectedCoordinate) => void;
  797. empty: () => void;
  798. editAnimation: (selected: BABYLON.Animation) => void;
  799. deselectAnimation: () => void;
  800. }
  801. interface Item {
  802. index: number;
  803. name: string;
  804. property: string;
  805. selected: boolean;
  806. open: boolean;
  807. }
  808. export enum SelectedCoordinate {
  809. x = 0,
  810. y = 1,
  811. z = 2,
  812. w = 3,
  813. r = 0,
  814. g = 1,
  815. b = 2,
  816. a = 3,
  817. width = 0,
  818. height = 1
  819. }
  820. interface ItemCoordinate {
  821. id: string;
  822. color: string;
  823. coordinate: SelectedCoordinate;
  824. }
  825. export class AnimationListTree extends React.Component<IAnimationListTreeProps, {
  826. selectedCoordinate: SelectedCoordinate;
  827. selectedAnimation: number;
  828. animationList: Item[] | null;
  829. }> {
  830. constructor(props: IAnimationListTreeProps);
  831. deleteAnimation(): void;
  832. generateList(): Item[] | null;
  833. toggleProperty(index: number): void;
  834. setSelectedCoordinate(animation: BABYLON.Animation, coordinate: SelectedCoordinate, index: number): void;
  835. coordinateItem(i: number, animation: BABYLON.Animation, coordinate: string, color: string, selectedCoordinate: SelectedCoordinate): JSX.Element;
  836. typeAnimationItem(animation: BABYLON.Animation, i: number, childrenElements: ItemCoordinate[]): JSX.Element;
  837. setListItem(animation: BABYLON.Animation, i: number): JSX.Element | null;
  838. render(): JSX.Element;
  839. }
  840. }
  841. declare module INSPECTOR {
  842. interface IFileButtonLineComponentProps {
  843. label: string;
  844. onClick: (file: File) => void;
  845. accept: string;
  846. }
  847. export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
  848. private static _IDGenerator;
  849. private _id;
  850. private uploadInputRef;
  851. constructor(props: IFileButtonLineComponentProps);
  852. onChange(evt: any): void;
  853. render(): JSX.Element;
  854. }
  855. }
  856. declare module INSPECTOR {
  857. interface ILoadSnippetProps {
  858. animations: BABYLON.Animation[];
  859. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  860. lockObject: LockObject;
  861. globalState: GlobalState;
  862. snippetServer: string;
  863. setSnippetId: (id: string) => void;
  864. entity: BABYLON.IAnimatable | BABYLON.TargetedAnimation;
  865. setNotificationMessage: (message: string) => void;
  866. animationsLoaded: (numberOfAnimations: number) => void;
  867. }
  868. export class LoadSnippet extends React.Component<ILoadSnippetProps, {
  869. snippetId: string;
  870. }> {
  871. private _serverAddress;
  872. constructor(props: ILoadSnippetProps);
  873. change(value: string): void;
  874. loadFromFile(file: File): void;
  875. loadFromSnippet(): void;
  876. render(): JSX.Element;
  877. }
  878. }
  879. declare module INSPECTOR {
  880. interface ISaveSnippetProps {
  881. animations: BABYLON.Nullable<BABYLON.Animation[]>;
  882. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  883. lockObject: LockObject;
  884. globalState: GlobalState;
  885. snippetServer: string;
  886. snippetId: string;
  887. }
  888. export interface Snippet {
  889. url: string;
  890. id: string;
  891. }
  892. interface SelectedAnimation {
  893. id: string;
  894. name: string;
  895. index: number;
  896. selected: boolean;
  897. }
  898. export class SaveSnippet extends React.Component<ISaveSnippetProps, {
  899. selectedAnimations: SelectedAnimation[];
  900. }> {
  901. constructor(props: ISaveSnippetProps);
  902. handleCheckboxChange(e: React.ChangeEvent<HTMLInputElement>): void;
  903. stringifySelectedAnimations(): string;
  904. saveToFile(): void;
  905. saveToSnippet(): void;
  906. render(): JSX.Element;
  907. }
  908. }
  909. declare module INSPECTOR {
  910. interface IEditorControlsProps {
  911. isTargetedAnimation: boolean;
  912. entity: BABYLON.IAnimatable | BABYLON.TargetedAnimation;
  913. selected: BABYLON.Animation | null;
  914. lockObject: LockObject;
  915. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  916. setNotificationMessage: (message: string) => void;
  917. selectAnimation: (selected: BABYLON.Animation, axis?: SelectedCoordinate) => void;
  918. setFps: (fps: number) => void;
  919. setIsLooping: () => void;
  920. globalState: GlobalState;
  921. snippetServer: string;
  922. deselectAnimation: () => void;
  923. fps: number;
  924. }
  925. export class EditorControls extends React.Component<IEditorControlsProps, {
  926. isAnimationTabOpen: boolean;
  927. isEditTabOpen: boolean;
  928. isLoadTabOpen: boolean;
  929. isSaveTabOpen: boolean;
  930. isLoopActive: boolean;
  931. animationsCount: number;
  932. framesPerSecond: number;
  933. snippetId: string;
  934. selected: BABYLON.Animation | undefined;
  935. }> {
  936. constructor(props: IEditorControlsProps);
  937. componentWillReceiveProps(newProps: IEditorControlsProps): void;
  938. animationAdded(): void;
  939. finishedUpdate(): void;
  940. recountAnimations(): number;
  941. changeLoopBehavior(): void;
  942. handleTabs(tab: number): void;
  943. handleChangeFps(fps: number): void;
  944. emptiedList(): void;
  945. animationsLoaded(numberOfAnimations: number): void;
  946. editAnimation(selected: BABYLON.Animation): void;
  947. render(): JSX.Element;
  948. }
  949. }
  950. declare module INSPECTOR {
  951. interface ISwitchButtonProps {
  952. current: CurveScale;
  953. action?: (event: CurveScale) => void;
  954. }
  955. export class ScaleLabel extends React.Component<ISwitchButtonProps, {
  956. current: CurveScale;
  957. }> {
  958. constructor(props: ISwitchButtonProps);
  959. renderLabel(scale: CurveScale): "" | "DEG" | "FLT" | "INT" | "RAD";
  960. render(): JSX.Element;
  961. }
  962. }
  963. declare module INSPECTOR {
  964. interface IAnimationCurveEditorComponentProps {
  965. close: (event: any) => void;
  966. playOrPause?: () => void;
  967. scene: BABYLON.Scene;
  968. entity: BABYLON.IAnimatable | BABYLON.TargetedAnimation;
  969. lockObject: LockObject;
  970. globalState: GlobalState;
  971. }
  972. interface ICanvasAxis {
  973. value: number;
  974. label: number;
  975. }
  976. export enum CurveScale {
  977. float = 0,
  978. radians = 1,
  979. degrees = 2,
  980. integers = 3,
  981. default = 4
  982. }
  983. export interface IActionableKeyFrame {
  984. frame?: number | string;
  985. value?: any;
  986. }
  987. interface ICurveData {
  988. pathData: string;
  989. pathLength: number;
  990. domCurve: React.RefObject<SVGPathElement>;
  991. color: string;
  992. id: string;
  993. }
  994. export class AnimationCurveEditorComponent extends React.Component<IAnimationCurveEditorComponentProps, {
  995. isOpen: boolean;
  996. selected: BABYLON.Animation | null;
  997. svgKeyframes: IKeyframeSvgPoint[] | undefined;
  998. currentFrame: number;
  999. currentValue: number;
  1000. frameAxisLength: ICanvasAxis[];
  1001. valueAxisLength: ICanvasAxis[];
  1002. isFlatTangentMode: boolean;
  1003. isTangentMode: boolean;
  1004. isBrokenMode: boolean;
  1005. lerpMode: boolean;
  1006. scale: number;
  1007. playheadOffset: number;
  1008. notification: string;
  1009. currentPoint: SVGPoint | undefined;
  1010. playheadPos: number;
  1011. isPlaying: boolean;
  1012. selectedPathData: ICurveData[] | undefined;
  1013. selectedCoordinate: number;
  1014. animationLimit: number;
  1015. fps: number;
  1016. isLooping: boolean;
  1017. panningY: number;
  1018. panningX: number;
  1019. repositionCanvas: boolean;
  1020. actionableKeyframe: IActionableKeyFrame;
  1021. valueScale: CurveScale;
  1022. }> {
  1023. private _snippetUrl;
  1024. private _heightScale;
  1025. private _scaleFactor;
  1026. private _currentScale;
  1027. readonly _entityName: string;
  1028. readonly _canvasLength: number;
  1029. private _svgKeyframes;
  1030. private _isPlaying;
  1031. private _graphCanvas;
  1032. private _svgCanvas;
  1033. private _isTargetedAnimation;
  1034. private _pixelFrameUnit;
  1035. private _onBeforeRenderObserver;
  1036. private _mainAnimatable;
  1037. constructor(props: IAnimationCurveEditorComponentProps);
  1038. componentDidMount(): void;
  1039. /**
  1040. * Notifications
  1041. * To add notification we set the state and clear to make the notification bar hide.
  1042. */
  1043. clearNotification(): void;
  1044. /**
  1045. * Zoom and Scroll
  1046. * This section handles zoom and scroll
  1047. * of the graph area.
  1048. */
  1049. zoom(e: React.WheelEvent<HTMLDivElement>): void;
  1050. setFrameAxis(currentLength: number): {
  1051. value: number;
  1052. label: number;
  1053. }[];
  1054. setValueLines(type: CurveScale): ({
  1055. value: number;
  1056. label: string;
  1057. } | {
  1058. value: number;
  1059. label: number;
  1060. })[];
  1061. getValueLabel(i: number): number;
  1062. resetPlayheadOffset(): void;
  1063. encodeCurveId(animationName: string, coordinate: number): string;
  1064. decodeCurveId(id: string): {
  1065. order: number;
  1066. coordinate: number;
  1067. };
  1068. getKeyframeValueFromAnimation(id: string): {
  1069. frame: number;
  1070. value: number;
  1071. } | undefined;
  1072. /**
  1073. * Keyframe Manipulation
  1074. * This section handles events from SvgDraggableArea.
  1075. */
  1076. selectKeyframe(id: string, multiselect: boolean): void;
  1077. resetActionableKeyframe(): void;
  1078. selectedControlPoint(type: string, id: string): void;
  1079. deselectKeyframes(): void;
  1080. updateValuePerCoordinate(dataType: number, value: number | BABYLON.Vector2 | BABYLON.Vector3 | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Size | BABYLON.Quaternion, newValue: number, coordinate?: number): number | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
  1081. renderPoints(updatedSvgKeyFrame: IKeyframeSvgPoint, id: string): void;
  1082. updateLeftControlPoint(updatedSvgKeyFrame: IKeyframeSvgPoint, key: BABYLON.IAnimationKey, dataType: number, coordinate: number): void;
  1083. updateRightControlPoint(updatedSvgKeyFrame: IKeyframeSvgPoint, key: BABYLON.IAnimationKey, dataType: number, coordinate: number): void;
  1084. handleFrameChange(event: React.ChangeEvent<HTMLInputElement>): void;
  1085. handleValueChange(event: React.ChangeEvent<HTMLInputElement>): void;
  1086. setKeyframeValue(): void;
  1087. setFlatTangent(): void;
  1088. setTangentMode(): void;
  1089. setBrokenMode(): void;
  1090. setLerpMode(): void;
  1091. addKeyframeClick(): void;
  1092. removeKeyframeClick(): void;
  1093. removeKeyframes(points: IKeyframeSvgPoint[]): void;
  1094. addKeyFrame(event: React.MouseEvent<SVGSVGElement>): void;
  1095. /**
  1096. * Curve Rendering Functions
  1097. * This section handles how to render curves.
  1098. */
  1099. setKeyframePointLinear(point: BABYLON.Vector2, index: number): void;
  1100. flatTangents(keyframes: BABYLON.IAnimationKey[], dataType: number): BABYLON.IAnimationKey[];
  1101. returnZero(dataType: number): 0 | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
  1102. getValueAsArray(valueType: number, value: number | BABYLON.Vector2 | BABYLON.Vector3 | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Size | BABYLON.Quaternion): number[];
  1103. setValueAsType(valueType: number, arrayValue: number[]): number | BABYLON.Vector3 | BABYLON.Quaternion | BABYLON.Color3 | BABYLON.Color4 | BABYLON.Vector2 | BABYLON.Size;
  1104. getPathData(animation: BABYLON.Animation | null): ICurveData[] | undefined;
  1105. getAnimationData(animation: BABYLON.Animation): {
  1106. loopMode: number | undefined;
  1107. name: string;
  1108. blendingSpeed: number;
  1109. targetPropertyPath: string[];
  1110. targetProperty: string;
  1111. framesPerSecond: number;
  1112. highestFrame: number;
  1113. usesTangents: boolean;
  1114. easingType: string | undefined;
  1115. easingMode: number | undefined;
  1116. valueType: number;
  1117. };
  1118. curvePathWithTangents(keyframes: BABYLON.IAnimationKey[], data: string, middle: number, type: number, coordinate: number, animationName: string): string;
  1119. curvePath(keyframes: BABYLON.IAnimationKey[], data: string, middle: number, easingFunction: BABYLON.EasingFunction): string;
  1120. setKeyframePoint(controlPoints: BABYLON.Vector2[], index: number, keyframesCount: number): void;
  1121. interpolateControlPoints(p0: BABYLON.Vector2, p1: BABYLON.Vector2, u: number, p2: BABYLON.Vector2, v: number, p3: BABYLON.Vector2): BABYLON.Vector2[] | undefined;
  1122. deselectAnimation(): void;
  1123. /**
  1124. * Core functions
  1125. * This section handles main Curve Editor Functions.
  1126. */
  1127. selectAnimation(animation: BABYLON.Animation, coordinate?: SelectedCoordinate): void;
  1128. isAnimationPlaying(): boolean;
  1129. stopAnimation(): void;
  1130. setIsLooping(): void;
  1131. setFramesPerSecond(fps: number): void;
  1132. analizeAnimationForLerp(animation: BABYLON.Animation | null): boolean;
  1133. /**
  1134. * Timeline
  1135. * This section controls the timeline.
  1136. */
  1137. changeCurrentFrame(frame: number): void;
  1138. setCanvasPosition(frame: number): void;
  1139. setCurrentFrame(direction: number): void;
  1140. changeAnimationLimit(limit: number): void;
  1141. updateFrameInKeyFrame(frame: number, index: number): void;
  1142. playPause(direction: number): void;
  1143. moveFrameTo(e: React.MouseEvent<SVGRectElement, MouseEvent>): void;
  1144. registerObs(): void;
  1145. componentWillUnmount(): void;
  1146. isCurrentFrame(frame: number): boolean;
  1147. render(): JSX.Element;
  1148. }
  1149. }
  1150. declare module INSPECTOR {
  1151. interface IPopupComponentProps {
  1152. id: string;
  1153. title: string;
  1154. size: {
  1155. width: number;
  1156. height: number;
  1157. };
  1158. onOpen: (window: Window) => void;
  1159. onClose: (window: Window) => void;
  1160. }
  1161. export class PopupComponent extends React.Component<IPopupComponentProps, {
  1162. isComponentMounted: boolean;
  1163. blockedByBrowser: boolean;
  1164. }> {
  1165. private _container;
  1166. private _window;
  1167. private _curveEditorHost;
  1168. constructor(props: IPopupComponentProps);
  1169. componentDidMount(): void;
  1170. openPopup(): void;
  1171. componentWillUnmount(): void;
  1172. render(): React.ReactPortal | null;
  1173. }
  1174. }
  1175. declare module INSPECTOR {
  1176. interface IAnimationGridComponentProps {
  1177. globalState: GlobalState;
  1178. animatable: BABYLON.IAnimatable;
  1179. scene: BABYLON.Scene;
  1180. lockObject: LockObject;
  1181. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1182. }
  1183. export class AnimationGridComponent extends React.Component<IAnimationGridComponentProps, {
  1184. currentFrame: number;
  1185. }> {
  1186. private _animations;
  1187. private _ranges;
  1188. private _mainAnimatable;
  1189. private _onBeforeRenderObserver;
  1190. private _isPlaying;
  1191. private timelineRef;
  1192. private _isCurveEditorOpen;
  1193. private _animationControl;
  1194. constructor(props: IAnimationGridComponentProps);
  1195. playOrPause(): void;
  1196. componentDidMount(): void;
  1197. componentWillUnmount(): void;
  1198. onCurrentFrameChange(value: number): void;
  1199. onChangeFromOrTo(): void;
  1200. onOpenAnimationCurveEditor(): void;
  1201. onCloseAnimationCurveEditor(window: Window | null): void;
  1202. render(): JSX.Element;
  1203. }
  1204. }
  1205. declare module INSPECTOR {
  1206. interface ICommonMaterialPropertyGridComponentProps {
  1207. globalState: GlobalState;
  1208. material: BABYLON.Material;
  1209. lockObject: LockObject;
  1210. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1211. }
  1212. export class CommonMaterialPropertyGridComponent extends React.Component<ICommonMaterialPropertyGridComponentProps> {
  1213. constructor(props: ICommonMaterialPropertyGridComponentProps);
  1214. render(): JSX.Element;
  1215. }
  1216. }
  1217. declare module INSPECTOR {
  1218. interface IMaterialPropertyGridComponentProps {
  1219. globalState: GlobalState;
  1220. material: BABYLON.Material;
  1221. lockObject: LockObject;
  1222. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1223. }
  1224. export class MaterialPropertyGridComponent extends React.Component<IMaterialPropertyGridComponentProps> {
  1225. constructor(props: IMaterialPropertyGridComponentProps);
  1226. render(): JSX.Element;
  1227. }
  1228. }
  1229. declare module INSPECTOR {
  1230. export interface ITextureLinkLineComponentProps {
  1231. label: string;
  1232. texture: BABYLON.Nullable<BABYLON.BaseTexture>;
  1233. material?: BABYLON.Material;
  1234. onSelectionChangedObservable?: BABYLON.Observable<any>;
  1235. onDebugSelectionChangeObservable?: BABYLON.Observable<TextureLinkLineComponent>;
  1236. propertyName?: string;
  1237. onTextureCreated?: (texture: BABYLON.BaseTexture) => void;
  1238. customDebugAction?: (state: boolean) => void;
  1239. onTextureRemoved?: () => void;
  1240. }
  1241. export class TextureLinkLineComponent extends React.Component<ITextureLinkLineComponentProps, {
  1242. isDebugSelected: boolean;
  1243. }> {
  1244. private _onDebugSelectionChangeObserver;
  1245. constructor(props: ITextureLinkLineComponentProps);
  1246. componentDidMount(): void;
  1247. componentWillUnmount(): void;
  1248. debugTexture(): void;
  1249. onLink(): void;
  1250. updateTexture(file: File): void;
  1251. removeTexture(): void;
  1252. render(): JSX.Element | null;
  1253. }
  1254. }
  1255. declare module INSPECTOR {
  1256. interface IStandardMaterialPropertyGridComponentProps {
  1257. globalState: GlobalState;
  1258. material: BABYLON.StandardMaterial;
  1259. lockObject: LockObject;
  1260. onSelectionChangedObservable?: BABYLON.Observable<any>;
  1261. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1262. }
  1263. export class StandardMaterialPropertyGridComponent extends React.Component<IStandardMaterialPropertyGridComponentProps> {
  1264. private _onDebugSelectionChangeObservable;
  1265. constructor(props: IStandardMaterialPropertyGridComponentProps);
  1266. renderTextures(): JSX.Element;
  1267. render(): JSX.Element;
  1268. }
  1269. }
  1270. declare module INSPECTOR {
  1271. export interface TextureChannelsToDisplay {
  1272. R: boolean;
  1273. G: boolean;
  1274. B: boolean;
  1275. A: boolean;
  1276. }
  1277. export class TextureHelper {
  1278. private static _ProcessAsync;
  1279. static GetTextureDataAsync(texture: BABYLON.BaseTexture, width: number, height: number, face: number, channels: TextureChannelsToDisplay, globalState?: GlobalState): Promise<Uint8Array>;
  1280. }
  1281. }
  1282. declare module INSPECTOR {
  1283. interface ITextureLineComponentProps {
  1284. texture: BABYLON.BaseTexture;
  1285. width: number;
  1286. height: number;
  1287. globalState?: GlobalState;
  1288. hideChannelSelect?: boolean;
  1289. }
  1290. export class TextureLineComponent extends React.Component<ITextureLineComponentProps, {
  1291. channels: TextureChannelsToDisplay;
  1292. face: number;
  1293. }> {
  1294. private canvasRef;
  1295. private static TextureChannelStates;
  1296. constructor(props: ITextureLineComponentProps);
  1297. shouldComponentUpdate(nextProps: ITextureLineComponentProps, nextState: {
  1298. channels: TextureChannelsToDisplay;
  1299. face: number;
  1300. }): boolean;
  1301. componentDidMount(): void;
  1302. componentDidUpdate(): void;
  1303. updatePreview(): Promise<void>;
  1304. render(): JSX.Element;
  1305. }
  1306. }
  1307. declare module INSPECTOR {
  1308. export interface Tool {
  1309. type: any;
  1310. name: string;
  1311. instance: any;
  1312. icon: string;
  1313. }
  1314. interface ToolBarProps {
  1315. tools: Tool[];
  1316. addTool(url: string): void;
  1317. changeTool(toolIndex: number): void;
  1318. activeToolIndex: number;
  1319. metadata: any;
  1320. setMetadata(data: any): void;
  1321. }
  1322. interface ToolBarState {
  1323. toolURL: string;
  1324. pickerOpen: boolean;
  1325. addOpen: boolean;
  1326. }
  1327. export class ToolBar extends React.Component<ToolBarProps, ToolBarState> {
  1328. private pickerRef;
  1329. constructor(props: ToolBarProps);
  1330. computeRGBAColor(): string;
  1331. render(): JSX.Element;
  1332. }
  1333. }
  1334. declare module INSPECTOR {
  1335. export interface Channel {
  1336. visible: boolean;
  1337. editable: boolean;
  1338. name: string;
  1339. id: 'R' | 'G' | 'B' | 'A';
  1340. icon: any;
  1341. }
  1342. interface ChannelsBarProps {
  1343. channels: Channel[];
  1344. setChannels(channelState: Channel[]): void;
  1345. }
  1346. export class ChannelsBar extends React.Component<ChannelsBarProps> {
  1347. render(): JSX.Element;
  1348. }
  1349. }
  1350. declare module INSPECTOR {
  1351. export interface PixelData {
  1352. x?: number;
  1353. y?: number;
  1354. r?: number;
  1355. g?: number;
  1356. b?: number;
  1357. a?: number;
  1358. }
  1359. export class TextureCanvasManager {
  1360. private _engine;
  1361. private _scene;
  1362. private _camera;
  1363. private _scale;
  1364. private _isPanning;
  1365. private _mouseX;
  1366. private _mouseY;
  1367. private _UICanvas;
  1368. private _size;
  1369. private _2DCanvas;
  1370. private _displayCanvas;
  1371. private _channels;
  1372. private _face;
  1373. private _displayTexture;
  1374. private _originalTexture;
  1375. private _target;
  1376. private _originalInternalTexture;
  1377. private _didEdit;
  1378. private _plane;
  1379. private _planeMaterial;
  1380. private _planeFallbackMaterial;
  1381. private _keyMap;
  1382. private static ZOOM_MOUSE_SPEED;
  1383. private static ZOOM_KEYBOARD_SPEED;
  1384. private static ZOOM_IN_KEY;
  1385. private static ZOOM_OUT_KEY;
  1386. private static PAN_SPEED;
  1387. private static PAN_MOUSE_BUTTON;
  1388. private static PAN_KEY;
  1389. private static MIN_SCALE;
  1390. private static MAX_SCALE;
  1391. private _tool;
  1392. private _setPixelData;
  1393. metadata: any;
  1394. constructor(texture: BABYLON.BaseTexture, canvasUI: HTMLCanvasElement, canvas2D: HTMLCanvasElement, canvasDisplay: HTMLCanvasElement, setPixelData: (pixelData: PixelData) => void);
  1395. updateTexture(): Promise<void>;
  1396. private copyTextureToDisplayTexture;
  1397. set channels(channels: Channel[]);
  1398. static paintPixelsOnCanvas(pixelData: Uint8Array, canvas: HTMLCanvasElement): void;
  1399. grabOriginalTexture(): void;
  1400. getMouseCoordinates(pointerInfo: BABYLON.PointerInfo): BABYLON.Vector2;
  1401. get scene(): BABYLON.Scene;
  1402. get canvas2D(): HTMLCanvasElement;
  1403. get size(): BABYLON.ISize;
  1404. set tool(tool: BABYLON.Nullable<Tool>);
  1405. get tool(): BABYLON.Nullable<Tool>;
  1406. set face(face: number);
  1407. private makePlane;
  1408. reset(): void;
  1409. resize(newSize: BABYLON.ISize): Promise<void>;
  1410. private updateSize;
  1411. upload(file: File): void;
  1412. dispose(): void;
  1413. }
  1414. }
  1415. declare module INSPECTOR {
  1416. interface PropertiesBarProps {
  1417. texture: BABYLON.BaseTexture;
  1418. saveTexture(): void;
  1419. pixelData: PixelData;
  1420. face: number;
  1421. setFace(face: number): void;
  1422. resetTexture(): void;
  1423. resizeTexture(width: number, height: number): void;
  1424. uploadTexture(file: File): void;
  1425. }
  1426. interface PropertiesBarState {
  1427. width: number;
  1428. height: number;
  1429. }
  1430. interface PixelDataProps {
  1431. name: string;
  1432. data?: number;
  1433. }
  1434. function PixelData(props: PixelDataProps): JSX.Element;
  1435. export class PropertiesBar extends React.Component<PropertiesBarProps, PropertiesBarState> {
  1436. constructor(props: PropertiesBarProps);
  1437. render(): JSX.Element;
  1438. }
  1439. }
  1440. declare module INSPECTOR {
  1441. interface BottomBarProps {
  1442. name: string;
  1443. }
  1444. export class BottomBar extends React.Component<BottomBarProps> {
  1445. render(): JSX.Element;
  1446. }
  1447. }
  1448. declare module INSPECTOR {
  1449. interface TextureCanvasComponentProps {
  1450. canvasUI: React.RefObject<HTMLCanvasElement>;
  1451. canvas2D: React.RefObject<HTMLCanvasElement>;
  1452. canvasDisplay: React.RefObject<HTMLCanvasElement>;
  1453. texture: BABYLON.BaseTexture;
  1454. }
  1455. export class TextureCanvasComponent extends React.Component<TextureCanvasComponentProps> {
  1456. shouldComponentUpdate(nextProps: TextureCanvasComponentProps): boolean;
  1457. render(): JSX.Element;
  1458. }
  1459. }
  1460. declare module INSPECTOR {
  1461. export const Paintbrush: ToolData;
  1462. }
  1463. declare module INSPECTOR {
  1464. export const Eyedropper: ToolData;
  1465. }
  1466. declare module INSPECTOR {
  1467. export const Floodfill: ToolData;
  1468. }
  1469. declare module INSPECTOR {
  1470. const _default: import("babylonjs-inspector/components/actionTabs/tabs/propertyGrids/materials/textures/textureEditorComponent").ToolData[];
  1471. export default _default;
  1472. }
  1473. declare module INSPECTOR {
  1474. interface TextureEditorComponentProps {
  1475. globalState: GlobalState;
  1476. texture: BABYLON.BaseTexture;
  1477. url: string;
  1478. }
  1479. interface TextureEditorComponentState {
  1480. tools: Tool[];
  1481. activeToolIndex: number;
  1482. metadata: any;
  1483. channels: Channel[];
  1484. pixelData: PixelData;
  1485. face: number;
  1486. }
  1487. export interface ToolParameters {
  1488. scene: BABYLON.Scene;
  1489. canvas2D: HTMLCanvasElement;
  1490. size: BABYLON.ISize;
  1491. updateTexture: () => void;
  1492. getMetadata: () => any;
  1493. setMetadata: (data: any) => void;
  1494. }
  1495. export interface ToolData {
  1496. name: string;
  1497. type: any;
  1498. icon: string;
  1499. }
  1500. global {
  1501. var _TOOL_DATA_: ToolData;
  1502. }
  1503. export class TextureEditorComponent extends React.Component<TextureEditorComponentProps, TextureEditorComponentState> {
  1504. private _textureCanvasManager;
  1505. private canvasUI;
  1506. private canvas2D;
  1507. private canvasDisplay;
  1508. constructor(props: TextureEditorComponentProps);
  1509. componentDidMount(): void;
  1510. componentDidUpdate(): void;
  1511. componentWillUnmount(): void;
  1512. loadToolFromURL(url: string): void;
  1513. addTools(tools: ToolData[]): void;
  1514. getToolParameters(): ToolParameters;
  1515. changeTool(index: number): void;
  1516. setMetadata(newMetadata: any): void;
  1517. setFace(face: number): void;
  1518. saveTexture(): void;
  1519. resetTexture(): void;
  1520. resizeTexture(width: number, height: number): void;
  1521. uploadTexture(file: File): void;
  1522. render(): JSX.Element;
  1523. }
  1524. }
  1525. declare module INSPECTOR {
  1526. interface ITexturePropertyGridComponentProps {
  1527. texture: BABYLON.BaseTexture;
  1528. lockObject: LockObject;
  1529. globalState: GlobalState;
  1530. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1531. }
  1532. interface ITexturePropertyGridComponentState {
  1533. isTextureEditorOpen: boolean;
  1534. textureEditing: BABYLON.Nullable<BABYLON.BaseTexture>;
  1535. }
  1536. export class TexturePropertyGridComponent extends React.Component<ITexturePropertyGridComponentProps, ITexturePropertyGridComponentState> {
  1537. private _adtInstrumentation;
  1538. private textureLineRef;
  1539. constructor(props: ITexturePropertyGridComponentProps);
  1540. componentWillUnmount(): void;
  1541. updateTexture(file: File): void;
  1542. onOpenTextureEditor(): void;
  1543. onCloseTextureEditor(window: Window | null, callback?: {
  1544. (): void;
  1545. }): void;
  1546. forceRefresh(): void;
  1547. render(): JSX.Element;
  1548. }
  1549. }
  1550. declare module INSPECTOR {
  1551. interface IVector2LineComponentProps {
  1552. label: string;
  1553. target: any;
  1554. propertyName: string;
  1555. step?: number;
  1556. onChange?: (newvalue: BABYLON.Vector2) => void;
  1557. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1558. }
  1559. export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
  1560. isExpanded: boolean;
  1561. value: BABYLON.Vector2;
  1562. }> {
  1563. static defaultProps: {
  1564. step: number;
  1565. };
  1566. private _localChange;
  1567. constructor(props: IVector2LineComponentProps);
  1568. shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
  1569. isExpanded: boolean;
  1570. value: BABYLON.Vector2;
  1571. }): boolean;
  1572. switchExpandState(): void;
  1573. raiseOnPropertyChanged(previousValue: BABYLON.Vector2): void;
  1574. updateStateX(value: number): void;
  1575. updateStateY(value: number): void;
  1576. render(): JSX.Element;
  1577. }
  1578. }
  1579. declare module INSPECTOR {
  1580. interface IPBRMaterialPropertyGridComponentProps {
  1581. globalState: GlobalState;
  1582. material: BABYLON.PBRMaterial;
  1583. lockObject: LockObject;
  1584. onSelectionChangedObservable?: BABYLON.Observable<any>;
  1585. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1586. }
  1587. export class PBRMaterialPropertyGridComponent extends React.Component<IPBRMaterialPropertyGridComponentProps> {
  1588. private _onDebugSelectionChangeObservable;
  1589. constructor(props: IPBRMaterialPropertyGridComponentProps);
  1590. switchAmbientMode(state: boolean): void;
  1591. switchMetallicMode(state: boolean): void;
  1592. switchRoughnessMode(state: boolean): void;
  1593. renderTextures(onDebugSelectionChangeObservable: BABYLON.Observable<TextureLinkLineComponent>): JSX.Element;
  1594. render(): JSX.Element;
  1595. }
  1596. }
  1597. declare module INSPECTOR {
  1598. interface IRadioButtonLineComponentProps {
  1599. onSelectionChangedObservable: BABYLON.Observable<RadioButtonLineComponent>;
  1600. label: string;
  1601. isSelected: () => boolean;
  1602. onSelect: () => void;
  1603. }
  1604. export class RadioButtonLineComponent extends React.Component<IRadioButtonLineComponentProps, {
  1605. isSelected: boolean;
  1606. }> {
  1607. private _onSelectionChangedObserver;
  1608. constructor(props: IRadioButtonLineComponentProps);
  1609. componentDidMount(): void;
  1610. componentWillUnmount(): void;
  1611. onChange(): void;
  1612. render(): JSX.Element;
  1613. }
  1614. }
  1615. declare module INSPECTOR {
  1616. interface IFogPropertyGridComponentProps {
  1617. globalState: GlobalState;
  1618. scene: BABYLON.Scene;
  1619. lockObject: LockObject;
  1620. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1621. }
  1622. export class FogPropertyGridComponent extends React.Component<IFogPropertyGridComponentProps, {
  1623. mode: number;
  1624. }> {
  1625. constructor(props: IFogPropertyGridComponentProps);
  1626. render(): JSX.Element;
  1627. }
  1628. }
  1629. declare module INSPECTOR {
  1630. interface IScenePropertyGridComponentProps {
  1631. globalState: GlobalState;
  1632. scene: BABYLON.Scene;
  1633. lockObject: LockObject;
  1634. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1635. onSelectionChangedObservable?: BABYLON.Observable<any>;
  1636. }
  1637. export class ScenePropertyGridComponent extends React.Component<IScenePropertyGridComponentProps> {
  1638. private _storedEnvironmentTexture;
  1639. private _renderingModeGroupObservable;
  1640. constructor(props: IScenePropertyGridComponentProps);
  1641. setRenderingModes(point: boolean, wireframe: boolean): void;
  1642. switchIBL(): void;
  1643. updateEnvironmentTexture(file: File): void;
  1644. updateGravity(newValue: BABYLON.Vector3): void;
  1645. updateTimeStep(newValue: number): void;
  1646. normalizeScene(): void;
  1647. render(): JSX.Element;
  1648. }
  1649. }
  1650. declare module INSPECTOR {
  1651. interface ICommonLightPropertyGridComponentProps {
  1652. globalState: GlobalState;
  1653. light: BABYLON.Light;
  1654. lockObject: LockObject;
  1655. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1656. }
  1657. export class CommonLightPropertyGridComponent extends React.Component<ICommonLightPropertyGridComponentProps> {
  1658. constructor(props: ICommonLightPropertyGridComponentProps);
  1659. render(): JSX.Element;
  1660. }
  1661. }
  1662. declare module INSPECTOR {
  1663. interface IHemisphericLightPropertyGridComponentProps {
  1664. globalState: GlobalState;
  1665. light: BABYLON.HemisphericLight;
  1666. lockObject: LockObject;
  1667. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1668. }
  1669. export class HemisphericLightPropertyGridComponent extends React.Component<IHemisphericLightPropertyGridComponentProps> {
  1670. constructor(props: IHemisphericLightPropertyGridComponentProps);
  1671. render(): JSX.Element;
  1672. }
  1673. }
  1674. declare module INSPECTOR {
  1675. interface ICommonShadowLightPropertyGridComponentProps {
  1676. globalState: GlobalState;
  1677. light: BABYLON.IShadowLight;
  1678. lockObject: LockObject;
  1679. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1680. }
  1681. export class CommonShadowLightPropertyGridComponent extends React.Component<ICommonShadowLightPropertyGridComponentProps> {
  1682. private _internals;
  1683. constructor(props: ICommonShadowLightPropertyGridComponentProps);
  1684. createShadowGenerator(): void;
  1685. disposeShadowGenerator(): void;
  1686. render(): JSX.Element;
  1687. }
  1688. }
  1689. declare module INSPECTOR {
  1690. interface IPointLightPropertyGridComponentProps {
  1691. globalState: GlobalState;
  1692. light: BABYLON.PointLight;
  1693. lockObject: LockObject;
  1694. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1695. }
  1696. export class PointLightPropertyGridComponent extends React.Component<IPointLightPropertyGridComponentProps> {
  1697. constructor(props: IPointLightPropertyGridComponentProps);
  1698. render(): JSX.Element;
  1699. }
  1700. }
  1701. declare module INSPECTOR {
  1702. interface IHexLineComponentProps {
  1703. label: string;
  1704. target: any;
  1705. propertyName: string;
  1706. lockObject?: LockObject;
  1707. onChange?: (newValue: number) => void;
  1708. isInteger?: boolean;
  1709. replaySourceReplacement?: string;
  1710. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1711. additionalClass?: string;
  1712. step?: string;
  1713. digits?: number;
  1714. useEuler?: boolean;
  1715. min?: number;
  1716. }
  1717. export class HexLineComponent extends React.Component<IHexLineComponentProps, {
  1718. value: string;
  1719. }> {
  1720. private _localChange;
  1721. private _store;
  1722. private _propertyChange;
  1723. constructor(props: IHexLineComponentProps);
  1724. componentWillUnmount(): void;
  1725. shouldComponentUpdate(nextProps: IHexLineComponentProps, nextState: {
  1726. value: string;
  1727. }): boolean;
  1728. raiseOnPropertyChanged(newValue: number, previousValue: number): void;
  1729. convertToHexString(valueString: string): string;
  1730. updateValue(valueString: string, raisePropertyChanged: boolean): void;
  1731. lock(): void;
  1732. unlock(): void;
  1733. render(): JSX.Element;
  1734. }
  1735. }
  1736. declare module INSPECTOR {
  1737. interface ICommonCameraPropertyGridComponentProps {
  1738. globalState: GlobalState;
  1739. camera: BABYLON.Camera;
  1740. lockObject: LockObject;
  1741. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1742. }
  1743. export class CommonCameraPropertyGridComponent extends React.Component<ICommonCameraPropertyGridComponentProps, {
  1744. mode: number;
  1745. }> {
  1746. constructor(props: ICommonCameraPropertyGridComponentProps);
  1747. render(): JSX.Element;
  1748. }
  1749. }
  1750. declare module INSPECTOR {
  1751. interface IFreeCameraPropertyGridComponentProps {
  1752. globalState: GlobalState;
  1753. camera: BABYLON.FreeCamera;
  1754. lockObject: LockObject;
  1755. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1756. }
  1757. export class FreeCameraPropertyGridComponent extends React.Component<IFreeCameraPropertyGridComponentProps> {
  1758. constructor(props: IFreeCameraPropertyGridComponentProps);
  1759. render(): JSX.Element;
  1760. }
  1761. }
  1762. declare module INSPECTOR {
  1763. interface IArcRotateCameraPropertyGridComponentProps {
  1764. globalState: GlobalState;
  1765. camera: BABYLON.ArcRotateCamera;
  1766. lockObject: LockObject;
  1767. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1768. }
  1769. export class ArcRotateCameraPropertyGridComponent extends React.Component<IArcRotateCameraPropertyGridComponentProps> {
  1770. constructor(props: IArcRotateCameraPropertyGridComponentProps);
  1771. render(): JSX.Element;
  1772. }
  1773. }
  1774. declare module INSPECTOR {
  1775. interface IIndentedTextLineComponentProps {
  1776. value?: string;
  1777. color?: string;
  1778. underline?: boolean;
  1779. onLink?: () => void;
  1780. url?: string;
  1781. additionalClass?: string;
  1782. }
  1783. export class IndentedTextLineComponent extends React.Component<IIndentedTextLineComponentProps> {
  1784. constructor(props: IIndentedTextLineComponentProps);
  1785. onLink(): void;
  1786. renderContent(): JSX.Element;
  1787. render(): JSX.Element;
  1788. }
  1789. }
  1790. declare module INSPECTOR {
  1791. interface ICommonPropertyGridComponentProps {
  1792. globalState: GlobalState;
  1793. host: {
  1794. metadata: any;
  1795. };
  1796. lockObject: LockObject;
  1797. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1798. }
  1799. export class CommonPropertyGridComponent extends React.Component<ICommonPropertyGridComponentProps> {
  1800. constructor(props: ICommonPropertyGridComponentProps);
  1801. renderLevel(jsonObject: any): JSX.Element[];
  1802. render(): JSX.Element | null;
  1803. }
  1804. }
  1805. declare module INSPECTOR {
  1806. interface IVariantsPropertyGridComponentProps {
  1807. globalState: GlobalState;
  1808. host: any;
  1809. lockObject: LockObject;
  1810. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1811. }
  1812. export class VariantsPropertyGridComponent extends React.Component<IVariantsPropertyGridComponentProps> {
  1813. private _selectedVariants;
  1814. constructor(props: IVariantsPropertyGridComponentProps);
  1815. private _getVariantsExtension;
  1816. render(): JSX.Element | null;
  1817. }
  1818. }
  1819. declare module INSPECTOR {
  1820. interface IMeshPropertyGridComponentProps {
  1821. globalState: GlobalState;
  1822. mesh: BABYLON.Mesh;
  1823. lockObject: LockObject;
  1824. onSelectionChangedObservable?: BABYLON.Observable<any>;
  1825. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1826. }
  1827. export class MeshPropertyGridComponent extends React.Component<IMeshPropertyGridComponentProps, {
  1828. displayNormals: boolean;
  1829. displayVertexColors: boolean;
  1830. }> {
  1831. constructor(props: IMeshPropertyGridComponentProps);
  1832. renderWireframeOver(): void;
  1833. renderNormalVectors(): void;
  1834. displayNormals(): void;
  1835. displayVertexColors(): void;
  1836. onMaterialLink(): void;
  1837. onSourceMeshLink(): void;
  1838. onSkeletonLink(): void;
  1839. convertPhysicsTypeToString(): string;
  1840. render(): JSX.Element;
  1841. }
  1842. }
  1843. declare module INSPECTOR {
  1844. interface ITransformNodePropertyGridComponentProps {
  1845. globalState: GlobalState;
  1846. transformNode: BABYLON.TransformNode;
  1847. lockObject: LockObject;
  1848. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1849. }
  1850. export class TransformNodePropertyGridComponent extends React.Component<ITransformNodePropertyGridComponentProps> {
  1851. constructor(props: ITransformNodePropertyGridComponentProps);
  1852. render(): JSX.Element;
  1853. }
  1854. }
  1855. declare module INSPECTOR {
  1856. interface IBackgroundMaterialPropertyGridComponentProps {
  1857. globalState: GlobalState;
  1858. material: BABYLON.BackgroundMaterial;
  1859. lockObject: LockObject;
  1860. onSelectionChangedObservable?: BABYLON.Observable<any>;
  1861. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1862. }
  1863. export class BackgroundMaterialPropertyGridComponent extends React.Component<IBackgroundMaterialPropertyGridComponentProps> {
  1864. private _onDebugSelectionChangeObservable;
  1865. constructor(props: IBackgroundMaterialPropertyGridComponentProps);
  1866. renderTextures(): JSX.Element;
  1867. render(): JSX.Element;
  1868. }
  1869. }
  1870. declare module INSPECTOR {
  1871. interface ICommonControlPropertyGridComponentProps {
  1872. globalState: GlobalState;
  1873. control: BABYLON.GUI.Control;
  1874. lockObject: LockObject;
  1875. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1876. }
  1877. export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
  1878. constructor(props: ICommonControlPropertyGridComponentProps);
  1879. renderGridInformation(): JSX.Element | null;
  1880. render(): JSX.Element;
  1881. }
  1882. }
  1883. declare module INSPECTOR {
  1884. interface IControlPropertyGridComponentProps {
  1885. globalState: GlobalState;
  1886. control: BABYLON.GUI.Control;
  1887. lockObject: LockObject;
  1888. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1889. }
  1890. export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
  1891. constructor(props: IControlPropertyGridComponentProps);
  1892. render(): JSX.Element;
  1893. }
  1894. }
  1895. declare module INSPECTOR {
  1896. interface ITextBlockPropertyGridComponentProps {
  1897. globalState: GlobalState;
  1898. textBlock: BABYLON.GUI.TextBlock;
  1899. lockObject: LockObject;
  1900. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1901. }
  1902. export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
  1903. constructor(props: ITextBlockPropertyGridComponentProps);
  1904. render(): JSX.Element;
  1905. }
  1906. }
  1907. declare module INSPECTOR {
  1908. interface IInputTextPropertyGridComponentProps {
  1909. globalState: GlobalState;
  1910. inputText: BABYLON.GUI.InputText;
  1911. lockObject: LockObject;
  1912. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1913. }
  1914. export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
  1915. constructor(props: IInputTextPropertyGridComponentProps);
  1916. render(): JSX.Element;
  1917. }
  1918. }
  1919. declare module INSPECTOR {
  1920. interface IColorPickerPropertyGridComponentProps {
  1921. globalState: GlobalState;
  1922. colorPicker: BABYLON.GUI.ColorPicker;
  1923. lockObject: LockObject;
  1924. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1925. }
  1926. export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
  1927. constructor(props: IColorPickerPropertyGridComponentProps);
  1928. render(): JSX.Element;
  1929. }
  1930. }
  1931. declare module INSPECTOR {
  1932. interface IAnimationGroupGridComponentProps {
  1933. globalState: GlobalState;
  1934. animationGroup: BABYLON.AnimationGroup;
  1935. scene: BABYLON.Scene;
  1936. lockObject: LockObject;
  1937. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1938. }
  1939. export class AnimationGroupGridComponent extends React.Component<IAnimationGroupGridComponentProps, {
  1940. playButtonText: string;
  1941. currentFrame: number;
  1942. }> {
  1943. private _onAnimationGroupPlayObserver;
  1944. private _onAnimationGroupPauseObserver;
  1945. private _onBeforeRenderObserver;
  1946. private timelineRef;
  1947. constructor(props: IAnimationGroupGridComponentProps);
  1948. disconnect(animationGroup: BABYLON.AnimationGroup): void;
  1949. connect(animationGroup: BABYLON.AnimationGroup): void;
  1950. updateCurrentFrame(animationGroup: BABYLON.AnimationGroup): void;
  1951. shouldComponentUpdate(nextProps: IAnimationGroupGridComponentProps): boolean;
  1952. componentWillUnmount(): void;
  1953. playOrPause(): void;
  1954. onCurrentFrameChange(value: number): void;
  1955. render(): JSX.Element;
  1956. }
  1957. }
  1958. declare module INSPECTOR {
  1959. interface IImagePropertyGridComponentProps {
  1960. globalState: GlobalState;
  1961. image: BABYLON.GUI.Image;
  1962. lockObject: LockObject;
  1963. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1964. }
  1965. export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
  1966. constructor(props: IImagePropertyGridComponentProps);
  1967. render(): JSX.Element;
  1968. }
  1969. }
  1970. declare module INSPECTOR {
  1971. interface ISliderPropertyGridComponentProps {
  1972. globalState: GlobalState;
  1973. slider: BABYLON.GUI.Slider;
  1974. lockObject: LockObject;
  1975. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1976. }
  1977. export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
  1978. constructor(props: ISliderPropertyGridComponentProps);
  1979. render(): JSX.Element;
  1980. }
  1981. }
  1982. declare module INSPECTOR {
  1983. interface IImageBasedSliderPropertyGridComponentProps {
  1984. globalState: GlobalState;
  1985. imageBasedSlider: BABYLON.GUI.ImageBasedSlider;
  1986. lockObject: LockObject;
  1987. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  1988. }
  1989. export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
  1990. constructor(props: IImageBasedSliderPropertyGridComponentProps);
  1991. render(): JSX.Element;
  1992. }
  1993. }
  1994. declare module INSPECTOR {
  1995. interface IRectanglePropertyGridComponentProps {
  1996. globalState: GlobalState;
  1997. rectangle: BABYLON.GUI.Rectangle;
  1998. lockObject: LockObject;
  1999. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2000. }
  2001. export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
  2002. constructor(props: IRectanglePropertyGridComponentProps);
  2003. render(): JSX.Element;
  2004. }
  2005. }
  2006. declare module INSPECTOR {
  2007. interface IEllipsePropertyGridComponentProps {
  2008. globalState: GlobalState;
  2009. ellipse: BABYLON.GUI.Ellipse;
  2010. lockObject: LockObject;
  2011. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2012. }
  2013. export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
  2014. constructor(props: IEllipsePropertyGridComponentProps);
  2015. render(): JSX.Element;
  2016. }
  2017. }
  2018. declare module INSPECTOR {
  2019. interface ICheckboxPropertyGridComponentProps {
  2020. globalState: GlobalState;
  2021. checkbox: BABYLON.GUI.Checkbox;
  2022. lockObject: LockObject;
  2023. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2024. }
  2025. export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
  2026. constructor(props: ICheckboxPropertyGridComponentProps);
  2027. render(): JSX.Element;
  2028. }
  2029. }
  2030. declare module INSPECTOR {
  2031. interface IRadioButtonPropertyGridComponentProps {
  2032. globalState: GlobalState;
  2033. radioButton: BABYLON.GUI.RadioButton;
  2034. lockObject: LockObject;
  2035. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2036. }
  2037. export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
  2038. constructor(props: IRadioButtonPropertyGridComponentProps);
  2039. render(): JSX.Element;
  2040. }
  2041. }
  2042. declare module INSPECTOR {
  2043. interface ILinePropertyGridComponentProps {
  2044. globalState: GlobalState;
  2045. line: BABYLON.GUI.Line;
  2046. lockObject: LockObject;
  2047. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2048. }
  2049. export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
  2050. constructor(props: ILinePropertyGridComponentProps);
  2051. onDashChange(value: string): void;
  2052. render(): JSX.Element;
  2053. }
  2054. }
  2055. declare module INSPECTOR {
  2056. interface IScrollViewerPropertyGridComponentProps {
  2057. globalState: GlobalState;
  2058. scrollViewer: BABYLON.GUI.ScrollViewer;
  2059. lockObject: LockObject;
  2060. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2061. }
  2062. export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
  2063. constructor(props: IScrollViewerPropertyGridComponentProps);
  2064. render(): JSX.Element;
  2065. }
  2066. }
  2067. declare module INSPECTOR {
  2068. interface IGridPropertyGridComponentProps {
  2069. globalState: GlobalState;
  2070. grid: BABYLON.GUI.Grid;
  2071. lockObject: LockObject;
  2072. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2073. }
  2074. export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
  2075. constructor(props: IGridPropertyGridComponentProps);
  2076. renderRows(): JSX.Element[];
  2077. renderColumns(): JSX.Element[];
  2078. render(): JSX.Element;
  2079. }
  2080. }
  2081. declare module INSPECTOR {
  2082. interface IPBRMetallicRoughnessMaterialPropertyGridComponentProps {
  2083. globalState: GlobalState;
  2084. material: BABYLON.PBRMetallicRoughnessMaterial;
  2085. lockObject: LockObject;
  2086. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2087. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2088. }
  2089. export class PBRMetallicRoughnessMaterialPropertyGridComponent extends React.Component<IPBRMetallicRoughnessMaterialPropertyGridComponentProps> {
  2090. private _onDebugSelectionChangeObservable;
  2091. constructor(props: IPBRMetallicRoughnessMaterialPropertyGridComponentProps);
  2092. renderTextures(): JSX.Element;
  2093. render(): JSX.Element;
  2094. }
  2095. }
  2096. declare module INSPECTOR {
  2097. interface IPBRSpecularGlossinessMaterialPropertyGridComponentProps {
  2098. globalState: GlobalState;
  2099. material: BABYLON.PBRSpecularGlossinessMaterial;
  2100. lockObject: LockObject;
  2101. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2102. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2103. }
  2104. export class PBRSpecularGlossinessMaterialPropertyGridComponent extends React.Component<IPBRSpecularGlossinessMaterialPropertyGridComponentProps> {
  2105. private _onDebugSelectionChangeObservable;
  2106. constructor(props: IPBRSpecularGlossinessMaterialPropertyGridComponentProps);
  2107. renderTextures(): JSX.Element;
  2108. render(): JSX.Element;
  2109. }
  2110. }
  2111. declare module INSPECTOR {
  2112. interface IStackPanelPropertyGridComponentProps {
  2113. globalState: GlobalState;
  2114. stackPanel: BABYLON.GUI.StackPanel;
  2115. lockObject: LockObject;
  2116. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2117. }
  2118. export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
  2119. constructor(props: IStackPanelPropertyGridComponentProps);
  2120. render(): JSX.Element;
  2121. }
  2122. }
  2123. declare module INSPECTOR {
  2124. interface ICommonPostProcessPropertyGridComponentProps {
  2125. globalState: GlobalState;
  2126. postProcess: BABYLON.PostProcess;
  2127. lockObject: LockObject;
  2128. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2129. }
  2130. export class CommonPostProcessPropertyGridComponent extends React.Component<ICommonPostProcessPropertyGridComponentProps> {
  2131. constructor(props: ICommonPostProcessPropertyGridComponentProps);
  2132. render(): JSX.Element;
  2133. }
  2134. }
  2135. declare module INSPECTOR {
  2136. interface IPostProcessPropertyGridComponentProps {
  2137. globalState: GlobalState;
  2138. postProcess: BABYLON.PostProcess;
  2139. lockObject: LockObject;
  2140. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2141. }
  2142. export class PostProcessPropertyGridComponent extends React.Component<IPostProcessPropertyGridComponentProps> {
  2143. constructor(props: IPostProcessPropertyGridComponentProps);
  2144. edit(): void;
  2145. render(): JSX.Element;
  2146. }
  2147. }
  2148. declare module INSPECTOR {
  2149. interface ICommonRenderingPipelinePropertyGridComponentProps {
  2150. globalState: GlobalState;
  2151. renderPipeline: BABYLON.PostProcessRenderPipeline;
  2152. lockObject: LockObject;
  2153. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2154. }
  2155. export class CommonRenderingPipelinePropertyGridComponent extends React.Component<ICommonRenderingPipelinePropertyGridComponentProps> {
  2156. constructor(props: ICommonRenderingPipelinePropertyGridComponentProps);
  2157. render(): JSX.Element;
  2158. }
  2159. }
  2160. declare module INSPECTOR {
  2161. interface IRenderingPipelinePropertyGridComponentProps {
  2162. globalState: GlobalState;
  2163. renderPipeline: BABYLON.PostProcessRenderPipeline;
  2164. lockObject: LockObject;
  2165. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2166. }
  2167. export class RenderingPipelinePropertyGridComponent extends React.Component<IRenderingPipelinePropertyGridComponentProps> {
  2168. constructor(props: IRenderingPipelinePropertyGridComponentProps);
  2169. render(): JSX.Element;
  2170. }
  2171. }
  2172. declare module INSPECTOR {
  2173. interface IDefaultRenderingPipelinePropertyGridComponentProps {
  2174. globalState: GlobalState;
  2175. renderPipeline: BABYLON.DefaultRenderingPipeline;
  2176. lockObject: LockObject;
  2177. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2178. }
  2179. export class DefaultRenderingPipelinePropertyGridComponent extends React.Component<IDefaultRenderingPipelinePropertyGridComponentProps> {
  2180. constructor(props: IDefaultRenderingPipelinePropertyGridComponentProps);
  2181. render(): JSX.Element;
  2182. }
  2183. }
  2184. declare module INSPECTOR {
  2185. interface ISSAORenderingPipelinePropertyGridComponentProps {
  2186. globalState: GlobalState;
  2187. renderPipeline: BABYLON.SSAORenderingPipeline;
  2188. lockObject: LockObject;
  2189. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2190. }
  2191. export class SSAORenderingPipelinePropertyGridComponent extends React.Component<ISSAORenderingPipelinePropertyGridComponentProps> {
  2192. constructor(props: ISSAORenderingPipelinePropertyGridComponentProps);
  2193. render(): JSX.Element;
  2194. }
  2195. }
  2196. declare module INSPECTOR {
  2197. interface ISSAO2RenderingPipelinePropertyGridComponentProps {
  2198. globalState: GlobalState;
  2199. renderPipeline: BABYLON.SSAO2RenderingPipeline;
  2200. lockObject: LockObject;
  2201. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2202. }
  2203. export class SSAO2RenderingPipelinePropertyGridComponent extends React.Component<ISSAO2RenderingPipelinePropertyGridComponentProps> {
  2204. constructor(props: ISSAO2RenderingPipelinePropertyGridComponentProps);
  2205. render(): JSX.Element;
  2206. }
  2207. }
  2208. declare module INSPECTOR {
  2209. interface ISkeletonPropertyGridComponentProps {
  2210. globalState: GlobalState;
  2211. skeleton: BABYLON.Skeleton;
  2212. lockObject: LockObject;
  2213. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2214. }
  2215. export class SkeletonPropertyGridComponent extends React.Component<ISkeletonPropertyGridComponentProps> {
  2216. private _skeletonViewersEnabled;
  2217. private _skeletonViewers;
  2218. constructor(props: ISkeletonPropertyGridComponentProps);
  2219. switchSkeletonViewers(): void;
  2220. checkSkeletonViewerState(props: ISkeletonPropertyGridComponentProps): void;
  2221. shouldComponentUpdate(nextProps: ISkeletonPropertyGridComponentProps): boolean;
  2222. onOverrideMeshLink(): void;
  2223. render(): JSX.Element;
  2224. }
  2225. }
  2226. declare module INSPECTOR {
  2227. interface IBonePropertyGridComponentProps {
  2228. globalState: GlobalState;
  2229. bone: BABYLON.Bone;
  2230. lockObject: LockObject;
  2231. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2232. }
  2233. export class BonePropertyGridComponent extends React.Component<IBonePropertyGridComponentProps> {
  2234. constructor(props: IBonePropertyGridComponentProps);
  2235. onTransformNodeLink(): void;
  2236. render(): JSX.Element;
  2237. }
  2238. }
  2239. declare module INSPECTOR {
  2240. interface IDirectionalLightPropertyGridComponentProps {
  2241. globalState: GlobalState;
  2242. light: BABYLON.DirectionalLight;
  2243. lockObject: LockObject;
  2244. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2245. }
  2246. export class DirectionalLightPropertyGridComponent extends React.Component<IDirectionalLightPropertyGridComponentProps> {
  2247. constructor(props: IDirectionalLightPropertyGridComponentProps);
  2248. render(): JSX.Element;
  2249. }
  2250. }
  2251. declare module INSPECTOR {
  2252. interface ISpotLightPropertyGridComponentProps {
  2253. globalState: GlobalState;
  2254. light: BABYLON.SpotLight;
  2255. lockObject: LockObject;
  2256. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2257. }
  2258. export class SpotLightPropertyGridComponent extends React.Component<ISpotLightPropertyGridComponentProps> {
  2259. constructor(props: ISpotLightPropertyGridComponentProps);
  2260. render(): JSX.Element;
  2261. }
  2262. }
  2263. declare module INSPECTOR {
  2264. interface ILenstRenderingPipelinePropertyGridComponentProps {
  2265. globalState: GlobalState;
  2266. renderPipeline: BABYLON.LensRenderingPipeline;
  2267. lockObject: LockObject;
  2268. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2269. }
  2270. export class LensRenderingPipelinePropertyGridComponent extends React.Component<ILenstRenderingPipelinePropertyGridComponentProps> {
  2271. constructor(props: ILenstRenderingPipelinePropertyGridComponentProps);
  2272. render(): JSX.Element;
  2273. }
  2274. }
  2275. declare module INSPECTOR {
  2276. interface IVector4LineComponentProps {
  2277. label: string;
  2278. target: any;
  2279. propertyName: string;
  2280. step?: number;
  2281. onChange?: (newvalue: BABYLON.Vector4) => void;
  2282. useEuler?: boolean;
  2283. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2284. }
  2285. export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
  2286. isExpanded: boolean;
  2287. value: BABYLON.Vector4;
  2288. }> {
  2289. static defaultProps: {
  2290. step: number;
  2291. };
  2292. private _localChange;
  2293. constructor(props: IVector4LineComponentProps);
  2294. getCurrentValue(): any;
  2295. shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
  2296. isExpanded: boolean;
  2297. value: BABYLON.Vector4;
  2298. }): boolean;
  2299. switchExpandState(): void;
  2300. raiseOnPropertyChanged(previousValue: BABYLON.Vector4): void;
  2301. updateVector4(): void;
  2302. updateStateX(value: number): void;
  2303. updateStateY(value: number): void;
  2304. updateStateZ(value: number): void;
  2305. updateStateW(value: number): void;
  2306. render(): JSX.Element;
  2307. }
  2308. }
  2309. declare module INSPECTOR {
  2310. export interface IColor4LineComponentProps {
  2311. label: string;
  2312. target: any;
  2313. propertyName: string;
  2314. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2315. onChange?: () => void;
  2316. isLinear?: boolean;
  2317. }
  2318. export class Color4LineComponent extends React.Component<IColor4LineComponentProps, {
  2319. isExpanded: boolean;
  2320. color: BABYLON.Color4;
  2321. }> {
  2322. private _localChange;
  2323. constructor(props: IColor4LineComponentProps);
  2324. shouldComponentUpdate(nextProps: IColor4LineComponentProps, nextState: {
  2325. color: BABYLON.Color4;
  2326. }): boolean;
  2327. setPropertyValue(newColor: BABYLON.Color4): void;
  2328. onChange(newValue: string): void;
  2329. switchExpandState(): void;
  2330. raiseOnPropertyChanged(previousValue: BABYLON.Color4): void;
  2331. updateStateR(value: number): void;
  2332. updateStateG(value: number): void;
  2333. updateStateB(value: number): void;
  2334. updateStateA(value: number): void;
  2335. copyToClipboard(): void;
  2336. render(): JSX.Element;
  2337. }
  2338. }
  2339. declare module INSPECTOR {
  2340. interface INodeMaterialPropertyGridComponentProps {
  2341. globalState: GlobalState;
  2342. material: BABYLON.NodeMaterial;
  2343. lockObject: LockObject;
  2344. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2345. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2346. }
  2347. export class NodeMaterialPropertyGridComponent extends React.Component<INodeMaterialPropertyGridComponentProps> {
  2348. private _onDebugSelectionChangeObservable;
  2349. constructor(props: INodeMaterialPropertyGridComponentProps);
  2350. edit(): void;
  2351. renderTextures(): JSX.Element | null;
  2352. renderInputBlock(block: BABYLON.InputBlock): JSX.Element | null;
  2353. renderInputValues(): JSX.Element | null;
  2354. render(): JSX.Element;
  2355. }
  2356. }
  2357. declare module INSPECTOR {
  2358. interface IMultiMaterialPropertyGridComponentProps {
  2359. globalState: GlobalState;
  2360. material: BABYLON.MultiMaterial;
  2361. lockObject: LockObject;
  2362. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2363. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2364. }
  2365. export class MultiMaterialPropertyGridComponent extends React.Component<IMultiMaterialPropertyGridComponentProps> {
  2366. constructor(props: IMultiMaterialPropertyGridComponentProps);
  2367. onMaterialLink(mat: BABYLON.Material): void;
  2368. renderChildMaterial(): JSX.Element;
  2369. render(): JSX.Element;
  2370. }
  2371. }
  2372. declare module INSPECTOR {
  2373. interface IBoxEmitterGridComponentProps {
  2374. globalState: GlobalState;
  2375. emitter: BABYLON.BoxParticleEmitter;
  2376. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2377. }
  2378. export class BoxEmitterGridComponent extends React.Component<IBoxEmitterGridComponentProps> {
  2379. constructor(props: IBoxEmitterGridComponentProps);
  2380. render(): JSX.Element;
  2381. }
  2382. }
  2383. declare module INSPECTOR {
  2384. interface IConeEmitterGridComponentProps {
  2385. globalState: GlobalState;
  2386. emitter: BABYLON.ConeParticleEmitter;
  2387. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2388. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2389. }
  2390. export class ConeEmitterGridComponent extends React.Component<IConeEmitterGridComponentProps> {
  2391. constructor(props: IConeEmitterGridComponentProps);
  2392. render(): JSX.Element;
  2393. }
  2394. }
  2395. declare module INSPECTOR {
  2396. interface ICylinderEmitterGridComponentProps {
  2397. globalState: GlobalState;
  2398. emitter: BABYLON.CylinderParticleEmitter;
  2399. lockObject: LockObject;
  2400. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2401. }
  2402. export class CylinderEmitterGridComponent extends React.Component<ICylinderEmitterGridComponentProps> {
  2403. constructor(props: ICylinderEmitterGridComponentProps);
  2404. render(): JSX.Element;
  2405. }
  2406. }
  2407. declare module INSPECTOR {
  2408. interface IHemisphericEmitterGridComponentProps {
  2409. globalState: GlobalState;
  2410. emitter: BABYLON.HemisphericParticleEmitter;
  2411. lockObject: LockObject;
  2412. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2413. }
  2414. export class HemisphericEmitterGridComponent extends React.Component<IHemisphericEmitterGridComponentProps> {
  2415. constructor(props: IHemisphericEmitterGridComponentProps);
  2416. render(): JSX.Element;
  2417. }
  2418. }
  2419. declare module INSPECTOR {
  2420. interface IPointEmitterGridComponentProps {
  2421. globalState: GlobalState;
  2422. emitter: BABYLON.PointParticleEmitter;
  2423. lockObject: LockObject;
  2424. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2425. }
  2426. export class PointEmitterGridComponent extends React.Component<IPointEmitterGridComponentProps> {
  2427. constructor(props: IPointEmitterGridComponentProps);
  2428. render(): JSX.Element;
  2429. }
  2430. }
  2431. declare module INSPECTOR {
  2432. interface ISphereEmitterGridComponentProps {
  2433. globalState: GlobalState;
  2434. emitter: BABYLON.SphereParticleEmitter;
  2435. lockObject: LockObject;
  2436. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2437. }
  2438. export class SphereEmitterGridComponent extends React.Component<ISphereEmitterGridComponentProps> {
  2439. constructor(props: ISphereEmitterGridComponentProps);
  2440. render(): JSX.Element;
  2441. }
  2442. }
  2443. declare module INSPECTOR {
  2444. interface IMeshPickerComponentProps {
  2445. globalState: GlobalState;
  2446. target: any;
  2447. property: string;
  2448. scene: BABYLON.Scene;
  2449. label: string;
  2450. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2451. }
  2452. export class MeshPickerComponent extends React.Component<IMeshPickerComponentProps> {
  2453. constructor(props: IMeshPickerComponentProps);
  2454. render(): JSX.Element;
  2455. }
  2456. }
  2457. declare module INSPECTOR {
  2458. interface IMeshEmitterGridComponentProps {
  2459. globalState: GlobalState;
  2460. emitter: BABYLON.MeshParticleEmitter;
  2461. scene: BABYLON.Scene;
  2462. lockObject: LockObject;
  2463. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2464. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2465. }
  2466. export class MeshEmitterGridComponent extends React.Component<IMeshEmitterGridComponentProps> {
  2467. constructor(props: IMeshEmitterGridComponentProps);
  2468. render(): JSX.Element;
  2469. }
  2470. }
  2471. declare module INSPECTOR {
  2472. interface IFactorGradientStepGridComponent {
  2473. globalState: GlobalState;
  2474. gradient: BABYLON.FactorGradient;
  2475. lockObject: LockObject;
  2476. lineIndex: number;
  2477. onDelete: () => void;
  2478. onUpdateGradient: () => void;
  2479. onCheckForReOrder: () => void;
  2480. host: BABYLON.IParticleSystem;
  2481. codeRecorderPropertyName: string;
  2482. }
  2483. export class FactorGradientStepGridComponent extends React.Component<IFactorGradientStepGridComponent, {
  2484. gradient: number;
  2485. factor1: string;
  2486. factor2?: string;
  2487. }> {
  2488. constructor(props: IFactorGradientStepGridComponent);
  2489. shouldComponentUpdate(nextProps: IFactorGradientStepGridComponent, nextState: {
  2490. gradient: number;
  2491. factor1: string;
  2492. factor2?: string;
  2493. }): boolean;
  2494. updateFactor1(valueString: string): void;
  2495. updateFactor2(valueString: string): void;
  2496. updateGradient(gradient: number): void;
  2497. onPointerUp(): void;
  2498. lock(): void;
  2499. unlock(): void;
  2500. render(): JSX.Element;
  2501. }
  2502. }
  2503. declare module INSPECTOR {
  2504. interface IColorGradientStepGridComponent {
  2505. globalState: GlobalState;
  2506. gradient: BABYLON.ColorGradient | BABYLON.Color3Gradient;
  2507. lockObject: LockObject;
  2508. lineIndex: number;
  2509. isColor3: boolean;
  2510. onDelete: () => void;
  2511. onUpdateGradient: () => void;
  2512. onCheckForReOrder: () => void;
  2513. host: BABYLON.IParticleSystem;
  2514. codeRecorderPropertyName: string;
  2515. }
  2516. export class ColorGradientStepGridComponent extends React.Component<IColorGradientStepGridComponent, {
  2517. gradient: number;
  2518. }> {
  2519. constructor(props: IColorGradientStepGridComponent);
  2520. updateColor1(color: string): void;
  2521. updateColor2(color: string): void;
  2522. updateGradient(gradient: number): void;
  2523. onPointerUp(): void;
  2524. lock(): void;
  2525. unlock(): void;
  2526. render(): JSX.Element;
  2527. }
  2528. }
  2529. declare module INSPECTOR {
  2530. interface ILinkButtonComponentProps {
  2531. label: string;
  2532. buttonLabel: string;
  2533. url?: string;
  2534. onClick: () => void;
  2535. onIconClick?: () => void;
  2536. }
  2537. export class LinkButtonComponent extends React.Component<ILinkButtonComponentProps> {
  2538. constructor(props: ILinkButtonComponentProps);
  2539. onLink(): void;
  2540. render(): JSX.Element;
  2541. }
  2542. }
  2543. declare module INSPECTOR {
  2544. export enum GradientGridMode {
  2545. Factor = 0,
  2546. BABYLON.Color3 = 1,
  2547. BABYLON.Color4 = 2
  2548. }
  2549. interface IValueGradientGridComponent {
  2550. globalState: GlobalState;
  2551. label: string;
  2552. gradients: BABYLON.Nullable<Array<BABYLON.IValueGradient>>;
  2553. lockObject: LockObject;
  2554. docLink?: string;
  2555. mode: GradientGridMode;
  2556. host: BABYLON.IParticleSystem;
  2557. codeRecorderPropertyName: string;
  2558. onCreateRequired: () => void;
  2559. }
  2560. export class ValueGradientGridComponent extends React.Component<IValueGradientGridComponent> {
  2561. constructor(props: IValueGradientGridComponent);
  2562. deleteStep(step: BABYLON.IValueGradient): void;
  2563. addNewStep(): void;
  2564. checkForReOrder(): void;
  2565. updateAndSync(): void;
  2566. render(): JSX.Element;
  2567. }
  2568. }
  2569. declare module INSPECTOR {
  2570. interface IParticleSystemPropertyGridComponentProps {
  2571. globalState: GlobalState;
  2572. system: BABYLON.IParticleSystem;
  2573. lockObject: LockObject;
  2574. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2575. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2576. }
  2577. export class ParticleSystemPropertyGridComponent extends React.Component<IParticleSystemPropertyGridComponentProps> {
  2578. private _snippetUrl;
  2579. constructor(props: IParticleSystemPropertyGridComponentProps);
  2580. renderEmitter(): JSX.Element | null;
  2581. raiseOnPropertyChanged(property: string, newValue: any, previousValue: any): void;
  2582. renderControls(): JSX.Element;
  2583. saveToFile(): void;
  2584. loadFromFile(file: File): void;
  2585. loadFromSnippet(): void;
  2586. saveToSnippet(): void;
  2587. render(): JSX.Element;
  2588. }
  2589. }
  2590. declare module INSPECTOR {
  2591. interface ISpriteManagerPropertyGridComponentProps {
  2592. globalState: GlobalState;
  2593. spriteManager: BABYLON.SpriteManager;
  2594. lockObject: LockObject;
  2595. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2596. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2597. }
  2598. export class SpriteManagerPropertyGridComponent extends React.Component<ISpriteManagerPropertyGridComponentProps> {
  2599. private _snippetUrl;
  2600. constructor(props: ISpriteManagerPropertyGridComponentProps);
  2601. addNewSprite(): void;
  2602. disposeManager(): void;
  2603. saveToFile(): void;
  2604. loadFromFile(file: File): void;
  2605. loadFromSnippet(): void;
  2606. saveToSnippet(): void;
  2607. render(): JSX.Element;
  2608. }
  2609. }
  2610. declare module INSPECTOR {
  2611. interface ISpritePropertyGridComponentProps {
  2612. globalState: GlobalState;
  2613. sprite: BABYLON.Sprite;
  2614. lockObject: LockObject;
  2615. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2616. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2617. }
  2618. export class SpritePropertyGridComponent extends React.Component<ISpritePropertyGridComponentProps> {
  2619. private canvasRef;
  2620. private imageData;
  2621. private cachedCellIndex;
  2622. constructor(props: ISpritePropertyGridComponentProps);
  2623. onManagerLink(): void;
  2624. switchPlayStopState(): void;
  2625. disposeSprite(): void;
  2626. componentDidMount(): void;
  2627. componentDidUpdate(): void;
  2628. shouldComponentUpdate(nextProps: ISpritePropertyGridComponentProps): boolean;
  2629. updatePreview(): void;
  2630. render(): JSX.Element;
  2631. }
  2632. }
  2633. declare module INSPECTOR {
  2634. interface ITargetedAnimationGridComponentProps {
  2635. globalState: GlobalState;
  2636. targetedAnimation: BABYLON.TargetedAnimation;
  2637. scene: BABYLON.Scene;
  2638. lockObject: LockObject;
  2639. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2640. onPropertyChangedObservable?: BABYLON.Observable<PropertyChangedEvent>;
  2641. }
  2642. export class TargetedAnimationGridComponent extends React.Component<ITargetedAnimationGridComponentProps> {
  2643. private _isCurveEditorOpen;
  2644. private _animationGroup;
  2645. constructor(props: ITargetedAnimationGridComponentProps);
  2646. onOpenAnimationCurveEditor(): void;
  2647. onCloseAnimationCurveEditor(window: Window | null): void;
  2648. playOrPause(): void;
  2649. deleteAnimation(): void;
  2650. render(): JSX.Element;
  2651. }
  2652. }
  2653. declare module INSPECTOR {
  2654. export class PropertyGridTabComponent extends PaneComponent {
  2655. private _timerIntervalId;
  2656. private _lockObject;
  2657. constructor(props: IPaneComponentProps);
  2658. timerRefresh(): void;
  2659. componentDidMount(): void;
  2660. componentWillUnmount(): void;
  2661. render(): JSX.Element | null;
  2662. }
  2663. }
  2664. declare module INSPECTOR {
  2665. export interface IHeaderComponentProps {
  2666. title: string;
  2667. handleBack?: boolean;
  2668. noExpand?: boolean;
  2669. noClose?: boolean;
  2670. noCommands?: boolean;
  2671. onPopup: () => void;
  2672. onClose: () => void;
  2673. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2674. }
  2675. export class HeaderComponent extends React.Component<IHeaderComponentProps, {
  2676. isBackVisible: boolean;
  2677. }> {
  2678. private _backStack;
  2679. private _onSelectionChangeObserver;
  2680. constructor(props: IHeaderComponentProps);
  2681. componentDidMount(): void;
  2682. componentWillUnmount(): void;
  2683. goBack(): void;
  2684. renderLogo(): JSX.Element | null;
  2685. render(): JSX.Element;
  2686. }
  2687. }
  2688. declare module INSPECTOR {
  2689. interface IMessageLineComponentProps {
  2690. text: string;
  2691. color?: string;
  2692. }
  2693. export class MessageLineComponent extends React.Component<IMessageLineComponentProps> {
  2694. constructor(props: IMessageLineComponentProps);
  2695. render(): JSX.Element;
  2696. }
  2697. }
  2698. declare module INSPECTOR {
  2699. interface IGLTFComponentProps {
  2700. scene: BABYLON.Scene;
  2701. globalState: GlobalState;
  2702. }
  2703. export class GLTFComponent extends React.Component<IGLTFComponentProps> {
  2704. private _onValidationResultsUpdatedObserver;
  2705. constructor(props: IGLTFComponentProps);
  2706. openValidationDetails(): void;
  2707. prepareText(singularForm: string, count: number): string;
  2708. componentDidMount(): void;
  2709. componentWillUnmount(): void;
  2710. renderValidation(): JSX.Element | null;
  2711. render(): JSX.Element;
  2712. }
  2713. }
  2714. declare module INSPECTOR {
  2715. interface IFileMultipleButtonLineComponentProps {
  2716. label: string;
  2717. onClick: (event: any) => void;
  2718. accept: string;
  2719. }
  2720. export class FileMultipleButtonLineComponent extends React.Component<IFileMultipleButtonLineComponentProps> {
  2721. private static _IDGenerator;
  2722. private _id;
  2723. private uploadInputRef;
  2724. constructor(props: IFileMultipleButtonLineComponentProps);
  2725. onChange(evt: any): void;
  2726. render(): JSX.Element;
  2727. }
  2728. }
  2729. declare module INSPECTOR {
  2730. export class ToolsTabComponent extends PaneComponent {
  2731. private _videoRecorder;
  2732. private _screenShotSize;
  2733. private _gifOptions;
  2734. private _useWidthHeight;
  2735. private _isExporting;
  2736. private _gifWorkerBlob;
  2737. private _gifRecorder;
  2738. private _previousRenderingScale;
  2739. private _crunchingGIF;
  2740. constructor(props: IPaneComponentProps);
  2741. componentDidMount(): void;
  2742. componentWillUnmount(): void;
  2743. captureScreenshot(): void;
  2744. captureRender(): void;
  2745. recordVideo(): void;
  2746. recordGIFInternal(): void;
  2747. recordGIF(): void;
  2748. importAnimations(event: any): void;
  2749. shouldExport(node: BABYLON.Node): boolean;
  2750. exportGLTF(): void;
  2751. exportBabylon(): void;
  2752. createEnvTexture(): void;
  2753. exportReplay(): void;
  2754. startRecording(): void;
  2755. applyDelta(file: File): void;
  2756. render(): JSX.Element | null;
  2757. }
  2758. }
  2759. declare module INSPECTOR {
  2760. export class SettingsTabComponent extends PaneComponent {
  2761. constructor(props: IPaneComponentProps);
  2762. render(): JSX.Element;
  2763. }
  2764. }
  2765. declare module INSPECTOR {
  2766. interface IActionTabsComponentProps {
  2767. scene?: BABYLON.Scene;
  2768. noCommands?: boolean;
  2769. noHeader?: boolean;
  2770. noExpand?: boolean;
  2771. noClose?: boolean;
  2772. popupMode?: boolean;
  2773. onPopup?: () => void;
  2774. onClose?: () => void;
  2775. globalState?: GlobalState;
  2776. initialTab?: BABYLON.DebugLayerTab;
  2777. }
  2778. export class ActionTabsComponent extends React.Component<IActionTabsComponentProps, {
  2779. selectedEntity: any;
  2780. selectedIndex: number;
  2781. }> {
  2782. private _onSelectionChangeObserver;
  2783. private _onTabChangedObserver;
  2784. private _once;
  2785. constructor(props: IActionTabsComponentProps);
  2786. componentDidMount(): void;
  2787. componentWillUnmount(): void;
  2788. changeSelectedTab(index: number): void;
  2789. renderContent(): JSX.Element | null;
  2790. onClose(): void;
  2791. onPopup(): void;
  2792. render(): JSX.Element;
  2793. }
  2794. }
  2795. declare module INSPECTOR {
  2796. interface ITreeItemLabelComponentProps {
  2797. label: string;
  2798. onClick?: () => void;
  2799. color: string;
  2800. }
  2801. export class TreeItemLabelComponent extends React.Component<ITreeItemLabelComponentProps> {
  2802. constructor(props: ITreeItemLabelComponentProps);
  2803. onClick(): void;
  2804. render(): JSX.Element;
  2805. }
  2806. }
  2807. declare module INSPECTOR {
  2808. interface IExtensionsComponentProps {
  2809. target: any;
  2810. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2811. }
  2812. export class ExtensionsComponent extends React.Component<IExtensionsComponentProps, {
  2813. popupVisible: boolean;
  2814. }> {
  2815. private _popup;
  2816. private extensionRef;
  2817. constructor(props: IExtensionsComponentProps);
  2818. showPopup(): void;
  2819. componentDidMount(): void;
  2820. componentDidUpdate(): void;
  2821. render(): JSX.Element | null;
  2822. }
  2823. }
  2824. declare module INSPECTOR {
  2825. interface IMeshTreeItemComponentProps {
  2826. mesh: BABYLON.AbstractMesh;
  2827. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2828. onClick: () => void;
  2829. globalState: GlobalState;
  2830. }
  2831. export class MeshTreeItemComponent extends React.Component<IMeshTreeItemComponentProps, {
  2832. isBoundingBoxEnabled: boolean;
  2833. isVisible: boolean;
  2834. }> {
  2835. constructor(props: IMeshTreeItemComponentProps);
  2836. showBoundingBox(): void;
  2837. switchVisibility(): void;
  2838. render(): JSX.Element;
  2839. }
  2840. }
  2841. declare module INSPECTOR {
  2842. interface ICameraTreeItemComponentProps {
  2843. camera: BABYLON.Camera;
  2844. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2845. onClick: () => void;
  2846. }
  2847. export class CameraTreeItemComponent extends React.Component<ICameraTreeItemComponentProps, {
  2848. isActive: boolean;
  2849. }> {
  2850. private _onBeforeRenderObserver;
  2851. constructor(props: ICameraTreeItemComponentProps);
  2852. setActive(): void;
  2853. componentDidMount(): void;
  2854. componentWillUnmount(): void;
  2855. render(): JSX.Element;
  2856. }
  2857. }
  2858. declare module INSPECTOR {
  2859. interface ILightTreeItemComponentProps {
  2860. light: BABYLON.Light;
  2861. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2862. onClick: () => void;
  2863. globalState: GlobalState;
  2864. }
  2865. export class LightTreeItemComponent extends React.Component<ILightTreeItemComponentProps, {
  2866. isEnabled: boolean;
  2867. isGizmoEnabled: boolean;
  2868. }> {
  2869. constructor(props: ILightTreeItemComponentProps);
  2870. switchIsEnabled(): void;
  2871. toggleGizmo(): void;
  2872. render(): JSX.Element;
  2873. }
  2874. }
  2875. declare module INSPECTOR {
  2876. interface IMaterialTreeItemComponentProps {
  2877. material: BABYLON.Material;
  2878. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2879. onClick: () => void;
  2880. }
  2881. export class MaterialTreeItemComponent extends React.Component<IMaterialTreeItemComponentProps> {
  2882. constructor(props: IMaterialTreeItemComponentProps);
  2883. render(): JSX.Element;
  2884. }
  2885. }
  2886. declare module INSPECTOR {
  2887. interface ITextureTreeItemComponentProps {
  2888. texture: BABYLON.Texture;
  2889. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2890. onClick: () => void;
  2891. }
  2892. export class TextureTreeItemComponent extends React.Component<ITextureTreeItemComponentProps> {
  2893. constructor(props: ITextureTreeItemComponentProps);
  2894. render(): JSX.Element;
  2895. }
  2896. }
  2897. declare module INSPECTOR {
  2898. interface ITransformNodeItemComponentProps {
  2899. transformNode: BABYLON.TransformNode;
  2900. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2901. onClick: () => void;
  2902. }
  2903. export class TransformNodeItemComponent extends React.Component<ITransformNodeItemComponentProps> {
  2904. constructor(props: ITransformNodeItemComponentProps);
  2905. render(): JSX.Element;
  2906. }
  2907. }
  2908. declare module INSPECTOR {
  2909. interface IControlTreeItemComponentProps {
  2910. control: BABYLON.GUI.Control;
  2911. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2912. onClick: () => void;
  2913. }
  2914. export class ControlTreeItemComponent extends React.Component<IControlTreeItemComponentProps, {
  2915. isActive: boolean;
  2916. isVisible: boolean;
  2917. }> {
  2918. constructor(props: IControlTreeItemComponentProps);
  2919. highlight(): void;
  2920. switchVisibility(): void;
  2921. render(): JSX.Element;
  2922. }
  2923. }
  2924. declare module INSPECTOR {
  2925. interface IAdvancedDynamicTextureTreeItemComponentProps {
  2926. texture: BABYLON.GUI.AdvancedDynamicTexture;
  2927. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2928. onSelectionChangedObservable?: BABYLON.Observable<any>;
  2929. onClick: () => void;
  2930. }
  2931. export class AdvancedDynamicTextureTreeItemComponent extends React.Component<IAdvancedDynamicTextureTreeItemComponentProps, {
  2932. isInPickingMode: boolean;
  2933. }> {
  2934. private _onControlPickedObserver;
  2935. constructor(props: IAdvancedDynamicTextureTreeItemComponentProps);
  2936. componentWillUnmount(): void;
  2937. onPickingMode(): void;
  2938. render(): JSX.Element;
  2939. }
  2940. }
  2941. declare module INSPECTOR {
  2942. interface IAnimationGroupItemComponentProps {
  2943. animationGroup: BABYLON.AnimationGroup;
  2944. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2945. onClick: () => void;
  2946. }
  2947. export class AnimationGroupItemComponent extends React.Component<IAnimationGroupItemComponentProps> {
  2948. constructor(props: IAnimationGroupItemComponentProps);
  2949. render(): JSX.Element;
  2950. }
  2951. }
  2952. declare module INSPECTOR {
  2953. interface IPostProcessItemComponentProps {
  2954. postProcess: BABYLON.PostProcess;
  2955. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2956. onClick: () => void;
  2957. }
  2958. export class PostProcessItemComponent extends React.Component<IPostProcessItemComponentProps> {
  2959. constructor(props: IPostProcessItemComponentProps);
  2960. render(): JSX.Element;
  2961. }
  2962. }
  2963. declare module INSPECTOR {
  2964. interface IRenderPipelineItemComponenttProps {
  2965. renderPipeline: BABYLON.PostProcessRenderPipeline;
  2966. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2967. onClick: () => void;
  2968. }
  2969. export class RenderingPipelineItemComponent extends React.Component<IRenderPipelineItemComponenttProps> {
  2970. constructor(props: IRenderPipelineItemComponenttProps);
  2971. render(): JSX.Element;
  2972. }
  2973. }
  2974. declare module INSPECTOR {
  2975. interface ISkeletonTreeItemComponentProps {
  2976. skeleton: BABYLON.Skeleton;
  2977. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2978. onClick: () => void;
  2979. }
  2980. export class SkeletonTreeItemComponent extends React.Component<ISkeletonTreeItemComponentProps> {
  2981. constructor(props: ISkeletonTreeItemComponentProps);
  2982. render(): JSX.Element;
  2983. }
  2984. }
  2985. declare module INSPECTOR {
  2986. interface IBoneTreeItemComponenttProps {
  2987. bone: BABYLON.Bone;
  2988. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  2989. onClick: () => void;
  2990. }
  2991. export class BoneTreeItemComponent extends React.Component<IBoneTreeItemComponenttProps> {
  2992. constructor(props: IBoneTreeItemComponenttProps);
  2993. render(): JSX.Element;
  2994. }
  2995. }
  2996. declare module INSPECTOR {
  2997. interface IParticleSystemTreeItemComponentProps {
  2998. system: BABYLON.IParticleSystem;
  2999. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3000. onClick: () => void;
  3001. }
  3002. export class ParticleSystemTreeItemComponent extends React.Component<IParticleSystemTreeItemComponentProps> {
  3003. constructor(props: IParticleSystemTreeItemComponentProps);
  3004. render(): JSX.Element;
  3005. }
  3006. }
  3007. declare module INSPECTOR {
  3008. interface ISpriteManagerTreeItemComponentProps {
  3009. spriteManager: BABYLON.SpriteManager;
  3010. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3011. onClick: () => void;
  3012. }
  3013. export class SpriteManagerTreeItemComponent extends React.Component<ISpriteManagerTreeItemComponentProps> {
  3014. constructor(props: ISpriteManagerTreeItemComponentProps);
  3015. render(): JSX.Element;
  3016. }
  3017. }
  3018. declare module INSPECTOR {
  3019. interface ISpriteTreeItemComponentProps {
  3020. sprite: BABYLON.Sprite;
  3021. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3022. onClick: () => void;
  3023. }
  3024. export class SpriteTreeItemComponent extends React.Component<ISpriteTreeItemComponentProps> {
  3025. constructor(props: ISpriteTreeItemComponentProps);
  3026. render(): JSX.Element;
  3027. }
  3028. }
  3029. declare module INSPECTOR {
  3030. interface ITargetedAnimationItemComponentProps {
  3031. targetedAnimation: BABYLON.TargetedAnimation;
  3032. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3033. onClick: () => void;
  3034. }
  3035. export class TargetedAnimationItemComponent extends React.Component<ITargetedAnimationItemComponentProps> {
  3036. constructor(props: ITargetedAnimationItemComponentProps);
  3037. render(): JSX.Element;
  3038. }
  3039. }
  3040. declare module INSPECTOR {
  3041. interface ITreeItemSpecializedComponentProps {
  3042. label: string;
  3043. entity?: any;
  3044. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3045. globalState: GlobalState;
  3046. onClick?: () => void;
  3047. }
  3048. export class TreeItemSpecializedComponent extends React.Component<ITreeItemSpecializedComponentProps> {
  3049. constructor(props: ITreeItemSpecializedComponentProps);
  3050. onClick(): void;
  3051. render(): JSX.Element;
  3052. }
  3053. }
  3054. declare module INSPECTOR {
  3055. export class Tools {
  3056. static LookForItem(item: any, selectedEntity: any): boolean;
  3057. private static _RecursiveRemoveHiddenMeshesAndHoistChildren;
  3058. static SortAndFilter(parent: any, items: any[]): any[];
  3059. }
  3060. }
  3061. declare module INSPECTOR {
  3062. export interface ITreeItemSelectableComponentProps {
  3063. entity: any;
  3064. selectedEntity?: any;
  3065. mustExpand?: boolean;
  3066. offset: number;
  3067. globalState: GlobalState;
  3068. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3069. filter: BABYLON.Nullable<string>;
  3070. }
  3071. export class TreeItemSelectableComponent extends React.Component<ITreeItemSelectableComponentProps, {
  3072. isExpanded: boolean;
  3073. isSelected: boolean;
  3074. }> {
  3075. private _wasSelected;
  3076. constructor(props: ITreeItemSelectableComponentProps);
  3077. switchExpandedState(): void;
  3078. shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: {
  3079. isExpanded: boolean;
  3080. isSelected: boolean;
  3081. }): boolean;
  3082. scrollIntoView(): void;
  3083. componentDidMount(): void;
  3084. componentDidUpdate(): void;
  3085. onSelect(): void;
  3086. renderChildren(): JSX.Element[] | null;
  3087. render(): JSX.Element | null;
  3088. }
  3089. }
  3090. declare module INSPECTOR {
  3091. export interface ITreeItemComponentProps {
  3092. items?: BABYLON.Nullable<any[]>;
  3093. label: string;
  3094. offset: number;
  3095. filter: BABYLON.Nullable<string>;
  3096. forceSubitems?: boolean;
  3097. globalState: GlobalState;
  3098. entity?: any;
  3099. selectedEntity: any;
  3100. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3101. contextMenuItems?: {
  3102. label: string;
  3103. action: () => void;
  3104. }[];
  3105. }
  3106. export class TreeItemComponent extends React.Component<ITreeItemComponentProps, {
  3107. isExpanded: boolean;
  3108. mustExpand: boolean;
  3109. }> {
  3110. static _ContextMenuUniqueIdGenerator: number;
  3111. constructor(props: ITreeItemComponentProps);
  3112. switchExpandedState(): void;
  3113. shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: {
  3114. isExpanded: boolean;
  3115. }): boolean;
  3116. expandAll(expand: boolean): void;
  3117. renderContextMenu(): JSX.Element | null;
  3118. render(): JSX.Element;
  3119. }
  3120. }
  3121. declare module INSPECTOR {
  3122. interface ISceneTreeItemComponentProps {
  3123. scene: BABYLON.Scene;
  3124. onRefresh: () => void;
  3125. selectedEntity?: any;
  3126. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3127. onSelectionChangedObservable?: BABYLON.Observable<any>;
  3128. globalState: GlobalState;
  3129. }
  3130. export class SceneTreeItemComponent extends React.Component<ISceneTreeItemComponentProps, {
  3131. isSelected: boolean;
  3132. isInPickingMode: boolean;
  3133. gizmoMode: number;
  3134. }> {
  3135. private _gizmoLayerOnPointerObserver;
  3136. private _onPointerObserver;
  3137. private _onSelectionChangeObserver;
  3138. private _selectedEntity;
  3139. private _posDragEnd;
  3140. private _scaleDragEnd;
  3141. private _rotateDragEnd;
  3142. constructor(props: ISceneTreeItemComponentProps);
  3143. shouldComponentUpdate(nextProps: ISceneTreeItemComponentProps, nextState: {
  3144. isSelected: boolean;
  3145. isInPickingMode: boolean;
  3146. }): boolean;
  3147. componentDidMount(): void;
  3148. componentWillUnmount(): void;
  3149. onSelect(): void;
  3150. onPickingMode(): void;
  3151. setGizmoMode(mode: number): void;
  3152. render(): JSX.Element;
  3153. }
  3154. }
  3155. declare module INSPECTOR {
  3156. interface ISceneExplorerFilterComponentProps {
  3157. onFilter: (filter: string) => void;
  3158. }
  3159. export class SceneExplorerFilterComponent extends React.Component<ISceneExplorerFilterComponentProps> {
  3160. constructor(props: ISceneExplorerFilterComponentProps);
  3161. render(): JSX.Element;
  3162. }
  3163. interface ISceneExplorerComponentProps {
  3164. scene: BABYLON.Scene;
  3165. noCommands?: boolean;
  3166. noHeader?: boolean;
  3167. noExpand?: boolean;
  3168. noClose?: boolean;
  3169. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3170. globalState: GlobalState;
  3171. popupMode?: boolean;
  3172. onPopup?: () => void;
  3173. onClose?: () => void;
  3174. }
  3175. export class SceneExplorerComponent extends React.Component<ISceneExplorerComponentProps, {
  3176. filter: BABYLON.Nullable<string>;
  3177. selectedEntity: any;
  3178. scene: BABYLON.Scene;
  3179. }> {
  3180. private _onSelectionChangeObserver;
  3181. private _onSelectionRenamedObserver;
  3182. private _onNewSceneAddedObserver;
  3183. private _onNewSceneObserver;
  3184. private sceneExplorerRef;
  3185. private _once;
  3186. private _hooked;
  3187. private sceneMutationFunc;
  3188. constructor(props: ISceneExplorerComponentProps);
  3189. processMutation(): void;
  3190. componentDidMount(): void;
  3191. componentWillUnmount(): void;
  3192. filterContent(filter: string): void;
  3193. findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: {
  3194. previousOne?: any;
  3195. found?: boolean;
  3196. }): boolean;
  3197. processKeys(keyEvent: React.KeyboardEvent<HTMLDivElement>): void;
  3198. renderContent(): JSX.Element | null;
  3199. onClose(): void;
  3200. onPopup(): void;
  3201. render(): JSX.Element;
  3202. }
  3203. }
  3204. declare module INSPECTOR {
  3205. interface IEmbedHostComponentProps {
  3206. scene: BABYLON.Scene;
  3207. globalState: GlobalState;
  3208. popupMode: boolean;
  3209. noClose?: boolean;
  3210. noExpand?: boolean;
  3211. onClose: () => void;
  3212. onPopup: () => void;
  3213. extensibilityGroups?: BABYLON.IExplorerExtensibilityGroup[];
  3214. initialTab?: BABYLON.DebugLayerTab;
  3215. }
  3216. export class EmbedHostComponent extends React.Component<IEmbedHostComponentProps> {
  3217. private _once;
  3218. private splitRef;
  3219. private topPartRef;
  3220. private bottomPartRef;
  3221. constructor(props: IEmbedHostComponentProps);
  3222. componentDidMount(): void;
  3223. renderContent(): JSX.Element;
  3224. render(): JSX.Element;
  3225. }
  3226. }
  3227. declare module INSPECTOR {
  3228. export class Inspector {
  3229. private static _SceneExplorerHost;
  3230. private static _ActionTabsHost;
  3231. private static _EmbedHost;
  3232. private static _NewCanvasContainer;
  3233. private static _SceneExplorerWindow;
  3234. private static _ActionTabsWindow;
  3235. private static _EmbedHostWindow;
  3236. private static _Scene;
  3237. private static _OpenedPane;
  3238. private static _OnBeforeRenderObserver;
  3239. static OnSelectionChangeObservable: BABYLON.Observable<any>;
  3240. static OnPropertyChangedObservable: BABYLON.Observable<PropertyChangedEvent>;
  3241. private static _GlobalState;
  3242. static MarkLineContainerTitleForHighlighting(title: string): void;
  3243. static MarkMultipleLineContainerTitlesForHighlighting(titles: string[]): void;
  3244. private static _CopyStyles;
  3245. private static _CreateSceneExplorer;
  3246. private static _CreateActionTabs;
  3247. private static _CreateEmbedHost;
  3248. static _CreatePopup(title: string, windowVariableName: string, width?: number, height?: number, lateBinding?: boolean): HTMLDivElement | null;
  3249. static get IsVisible(): boolean;
  3250. static EarlyAttachToLoader(): void;
  3251. static Show(scene: BABYLON.Scene, userOptions: Partial<BABYLON.IInspectorOptions>): void;
  3252. static _SetNewScene(scene: BABYLON.Scene): void;
  3253. static _CreateCanvasContainer(parentControl: HTMLElement): void;
  3254. private static _DestroyCanvasContainer;
  3255. private static _Cleanup;
  3256. private static _RemoveElementFromDOM;
  3257. static Hide(): void;
  3258. }
  3259. }
  3260. declare module INSPECTOR {
  3261. interface IPlayheadProps {
  3262. frame: number;
  3263. offset: number;
  3264. onCurrentFrameChange: (frame: number) => void;
  3265. }
  3266. export class Playhead extends React.Component<IPlayheadProps> {
  3267. private _direction;
  3268. private _active;
  3269. constructor(props: IPlayheadProps);
  3270. dragStart(e: React.TouchEvent<HTMLDivElement>): void;
  3271. dragStart(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
  3272. drag(e: React.TouchEvent<HTMLDivElement>): void;
  3273. drag(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
  3274. dragEnd(e: React.TouchEvent<HTMLDivElement>): void;
  3275. dragEnd(e: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
  3276. calculateMove(): string;
  3277. render(): JSX.Element;
  3278. }
  3279. }