babylon.viewer.d.ts 103 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487
  1. /// <reference path="./babylon.module.d.ts"/>
  2. /// <reference path="./babylon.glTF2Interface.d.ts"/>
  3. /// <reference path="./babylonjs.loaders.d.ts"/>
  4. declare module "babylonjs-loaders"{ export=BABYLON;}
  5. // Generated by dts-bundle v0.7.3
  6. // Dependencies for this module:
  7. // ../../../../../Tools/Gulp/babylonjs
  8. // ../../../../../Tools/Gulp/babylonjs-gltf2interface
  9. // ../../../../../Tools/Gulp/babylonjs-loaders
  10. declare module BabylonViewer {
  11. /**
  12. * BabylonJS Viewer
  13. *
  14. * An HTML-Based viewer for 3D models, based on BabylonJS and its extensions.
  15. */
  16. let disableInit: boolean;
  17. /**
  18. * Dispose all viewers currently registered
  19. */
  20. function disposeAll(): void;
  21. const Version: string;
  22. }
  23. declare module BabylonViewer {
  24. /**
  25. * This is the mapper's interface. Implement this function to create your own mapper and register it at the mapper manager
  26. */
  27. export interface IMapper {
  28. map(rawSource: any): ViewerConfiguration;
  29. }
  30. /**
  31. * The MapperManager manages the different implemented mappers.
  32. * It allows the user to register new mappers as well and use them to parse their own configuration data
  33. */
  34. export class MapperManager {
  35. /**
  36. * The default mapper is the JSON mapper.
  37. */
  38. static DefaultMapper: string;
  39. constructor();
  40. /**
  41. * Get a specific configuration mapper.
  42. *
  43. * @param type the name of the mapper to load
  44. */
  45. getMapper(type: string): IMapper;
  46. /**
  47. * Use this functio to register your own configuration mapper.
  48. * After a mapper is registered, it can be used to parse the specific type fo configuration to the standard ViewerConfiguration.
  49. * @param type the name of the mapper. This will be used to define the configuration type and/or to get the mapper
  50. * @param mapper The implemented mapper
  51. */
  52. registerMapper(type: string, mapper: IMapper): void;
  53. /**
  54. * Dispose the mapper manager and all of its mappers.
  55. */
  56. dispose(): void;
  57. }
  58. /**
  59. * mapperManager is a singleton of the type MapperManager.
  60. * The mapperManager can be disposed directly with calling mapperManager.dispose()
  61. * or indirectly with using BabylonViewer.disposeAll()
  62. */
  63. export let mapperManager: MapperManager;
  64. }
  65. declare module BabylonViewer {
  66. export class ViewerGlobals {
  67. disableInit: boolean;
  68. disableWebGL2Support: boolean;
  69. readonly version: string;
  70. }
  71. export let viewerGlobals: ViewerGlobals;
  72. }
  73. declare module BabylonViewer {
  74. /**
  75. * The viewer manager is the container for all viewers currently registered on this page.
  76. * It is possible to have more than one viewer on a single page.
  77. */
  78. export class ViewerManager {
  79. /**
  80. * A callback that will be triggered when a new viewer was added
  81. */
  82. onViewerAdded: (viewer: AbstractViewer) => void;
  83. /**
  84. * Will notify when a new viewer was added
  85. */
  86. onViewerAddedObservable: BABYLON.Observable<AbstractViewer>;
  87. /**
  88. * Will notify when a viewer was removed (disposed)
  89. */
  90. onViewerRemovedObservable: BABYLON.Observable<string>;
  91. constructor();
  92. /**
  93. * Adding a new viewer to the viewer manager and start tracking it.
  94. * @param viewer the viewer to add
  95. */
  96. addViewer(viewer: AbstractViewer): void;
  97. /**
  98. * remove a viewer from the viewer manager
  99. * @param viewer the viewer to remove
  100. */
  101. removeViewer(viewer: AbstractViewer): void;
  102. /**
  103. * Get a viewer by its baseId (if the container element has an ID, it is the this is. if not, a random id was assigned)
  104. * @param id the id of the HTMl element (or the viewer's, if none provided)
  105. */
  106. getViewerById(id: string): AbstractViewer;
  107. /**
  108. * Get a viewer using a container element
  109. * @param element the HTML element to search viewers associated with
  110. */
  111. getViewerByHTMLElement(element: HTMLElement): AbstractViewer | undefined;
  112. /**
  113. * Get a promise that will fullfil when this viewer was initialized.
  114. * Since viewer initialization and template injection is asynchronous, using the promise will guaranty that
  115. * you will get the viewer after everything was already configured.
  116. * @param id the viewer id to find
  117. */
  118. getViewerPromiseById(id: string): Promise<AbstractViewer>;
  119. /**
  120. * dispose the manager and all of its associated viewers
  121. */
  122. dispose(): void;
  123. }
  124. export let viewerManager: ViewerManager;
  125. }
  126. declare module BabylonViewer {
  127. /**
  128. * The Default viewer is the default implementation of the AbstractViewer.
  129. * It uses the templating system to render a new canvas and controls.
  130. */
  131. export class DefaultViewer extends AbstractViewer {
  132. containerElement: Element;
  133. fullscreenElement?: Element;
  134. /**
  135. * Create a new default viewer
  136. * @param containerElement the element in which the templates will be rendered
  137. * @param initialConfiguration the initial configuration. Defaults to extending the default configuration
  138. */
  139. constructor(containerElement: Element, initialConfiguration?: ViewerConfiguration);
  140. registerTemplatePlugin(plugin: IViewerTemplatePlugin): void;
  141. /**
  142. * This will be executed when the templates initialize.
  143. */
  144. protected _onTemplatesLoaded(): Promise<AbstractViewer>;
  145. protected _initVR(): void;
  146. /**
  147. * Toggle fullscreen of the entire viewer
  148. */
  149. toggleFullscreen: () => void;
  150. /**
  151. * Preparing the container element to present the viewer
  152. */
  153. protected _prepareContainerElement(): void;
  154. /**
  155. * This function will configure the templates and update them after a model was loaded
  156. * It is mainly responsible to changing the title and subtitle etc'.
  157. * @param model the model to be used to configure the templates by
  158. */
  159. protected _configureTemplate(model?: ViewerModel): void;
  160. /**
  161. * This will load a new model to the default viewer
  162. * overriding the AbstractViewer's loadModel.
  163. * The scene will automatically be cleared of the old models, if exist.
  164. * @param model the configuration object (or URL) to load.
  165. */
  166. loadModel(model?: string | File | IModelConfiguration): Promise<ViewerModel>;
  167. /**
  168. * Show the overlay and the defined sub-screen.
  169. * Mainly used for help and errors
  170. * @param subScreen the name of the subScreen. Those can be defined in the configuration object
  171. */
  172. showOverlayScreen(subScreen: string): Promise<Template> | Promise<string>;
  173. /**
  174. * Hide the overlay screen.
  175. */
  176. hideOverlayScreen(): Promise<Template> | Promise<string>;
  177. /**
  178. * show the viewer (in case it was hidden)
  179. *
  180. * @param visibilityFunction an optional function to execute in order to show the container
  181. */
  182. show(visibilityFunction?: ((template: Template) => Promise<Template>)): Promise<Template>;
  183. /**
  184. * hide the viewer (in case it is visible)
  185. *
  186. * @param visibilityFunction an optional function to execute in order to hide the container
  187. */
  188. hide(visibilityFunction?: ((template: Template) => Promise<Template>)): Promise<Template>;
  189. /**
  190. * Show the loading screen.
  191. * The loading screen can be configured using the configuration object
  192. */
  193. showLoadingScreen(): Promise<Template> | Promise<string>;
  194. /**
  195. * Hide the loading screen
  196. */
  197. hideLoadingScreen(): Promise<Template> | Promise<string>;
  198. dispose(): void;
  199. protected _onConfigurationLoaded(configuration: ViewerConfiguration): void;
  200. }
  201. }
  202. declare module BabylonViewer {
  203. /**
  204. * The AbstractViewer is the center of Babylon's viewer.
  205. * It is the basic implementation of the default viewer and is responsible of loading and showing the model and the templates
  206. */
  207. export abstract class AbstractViewer {
  208. containerElement: Element;
  209. /**
  210. * The corresponsing template manager of this viewer.
  211. */
  212. templateManager: TemplateManager;
  213. /**
  214. * Babylon BABYLON.Engine corresponding with this viewer
  215. */
  216. engine: BABYLON.Engine;
  217. /**
  218. * The ID of this viewer. it will be generated randomly or use the HTML Element's ID.
  219. */
  220. readonly baseId: string;
  221. /**
  222. * The last loader used to load a model.
  223. * @deprecated
  224. */
  225. lastUsedLoader: BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync;
  226. /**
  227. * The ModelLoader instance connected with this viewer.
  228. */
  229. modelLoader: ModelLoader;
  230. /**
  231. * A flag that controls whether or not the render loop should be executed
  232. */
  233. runRenderLoop: boolean;
  234. /**
  235. * The scene manager connected with this viewer instance
  236. */
  237. sceneManager: SceneManager;
  238. /**
  239. * Will notify when the scene was initialized
  240. */
  241. readonly onSceneInitObservable: BABYLON.Observable<BABYLON.Scene>;
  242. /**
  243. * will notify when the engine was initialized
  244. */
  245. readonly onEngineInitObservable: BABYLON.Observable<BABYLON.Engine>;
  246. /**
  247. * Will notify when a new model was added to the scene.
  248. * Note that added does not neccessarily mean loaded!
  249. */
  250. readonly onModelAddedObservable: BABYLON.Observable<ViewerModel>;
  251. /**
  252. * will notify after every model load
  253. */
  254. readonly onModelLoadedObservable: BABYLON.Observable<ViewerModel>;
  255. /**
  256. * will notify when any model notify of progress
  257. */
  258. readonly onModelLoadProgressObservable: BABYLON.Observable<BABYLON.SceneLoaderProgressEvent>;
  259. /**
  260. * will notify when any model load failed.
  261. */
  262. readonly onModelLoadErrorObservable: BABYLON.Observable<{
  263. message: string;
  264. exception: any;
  265. }>;
  266. /**
  267. * Will notify when a model was removed from the scene;
  268. */
  269. readonly onModelRemovedObservable: BABYLON.Observable<ViewerModel>;
  270. /**
  271. * will notify when a new loader was initialized.
  272. * Used mainly to know when a model starts loading.
  273. */
  274. readonly onLoaderInitObservable: BABYLON.Observable<BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync>;
  275. /**
  276. * Observers registered here will be executed when the entire load process has finished.
  277. */
  278. readonly onInitDoneObservable: BABYLON.Observable<AbstractViewer>;
  279. /**
  280. * Functions added to this observable will be executed on each frame rendered.
  281. */
  282. readonly onFrameRenderedObservable: BABYLON.Observable<AbstractViewer>;
  283. /**
  284. * Observers registered here will be executed when VR more is entered.
  285. */
  286. readonly onEnteringVRObservable: BABYLON.Observable<AbstractViewer>;
  287. /**
  288. * Observers registered here will be executed when VR mode is exited.
  289. */
  290. readonly onExitingVRObservable: BABYLON.Observable<AbstractViewer>;
  291. observablesManager: ObservablesManager;
  292. /**
  293. * The canvas associated with this viewer
  294. */
  295. protected _canvas: HTMLCanvasElement;
  296. /**
  297. * The (single) canvas of this viewer
  298. */
  299. readonly canvas: HTMLCanvasElement;
  300. /**
  301. * is this viewer disposed?
  302. */
  303. protected _isDisposed: boolean;
  304. /**
  305. * registered onBeforeRender functions.
  306. * This functions are also registered at the native scene. The reference can be used to unregister them.
  307. */
  308. protected _registeredOnBeforeRenderFunctions: Array<() => void>;
  309. /**
  310. * The configuration loader of this viewer
  311. */
  312. protected _configurationLoader: ConfigurationLoader;
  313. /**
  314. * Is the viewer already initialized. for internal use.
  315. */
  316. protected _isInit: boolean;
  317. protected _configurationContainer: ConfigurationContainer;
  318. readonly configurationContainer: ConfigurationContainer;
  319. constructor(containerElement: Element, initialConfiguration?: ViewerConfiguration);
  320. /**
  321. * get the baseId of this viewer
  322. */
  323. getBaseId(): string;
  324. /**
  325. * Do we have a canvas to render on, and is it a part of the scene
  326. */
  327. isCanvasInDOM(): boolean;
  328. /**
  329. * Set the viewer's background rendering flag.
  330. */
  331. renderInBackground: boolean;
  332. /**
  333. * Get the configuration object. This is a reference only.
  334. * The configuration can ONLY be updated using the updateConfiguration function.
  335. * changing this object will have no direct effect on the scene.
  336. */
  337. readonly configuration: ViewerConfiguration;
  338. /**
  339. * force resizing the engine.
  340. */
  341. forceResize(): void;
  342. protected _hdToggled: boolean;
  343. toggleHD(): void;
  344. protected _vrToggled: boolean;
  345. protected _vrScale: number;
  346. protected _vrInit: boolean;
  347. toggleVR(): void;
  348. protected _initVR(): void;
  349. /**
  350. * The resize function that will be registered with the window object
  351. */
  352. protected _resize: () => void;
  353. protected _onConfigurationLoaded(configuration: ViewerConfiguration): void;
  354. /**
  355. * Force a single render loop execution.
  356. */
  357. forceRender(): void;
  358. /**
  359. * render loop that will be executed by the engine
  360. */
  361. protected _render: (force?: boolean) => void;
  362. /**
  363. * Takes a screenshot of the scene and returns it as a base64 encoded png.
  364. * @param callback optional callback that will be triggered when screenshot is done.
  365. * @param width Optional screenshot width (default to 512).
  366. * @param height Optional screenshot height (default to 512).
  367. * @returns a promise with the screenshot data
  368. */
  369. takeScreenshot(callback?: (data: string) => void, width?: number, height?: number): Promise<string>;
  370. /**
  371. * Update the current viewer configuration with new values.
  372. * Only provided information will be updated, old configuration values will be kept.
  373. * If this.configuration was manually changed, you can trigger this function with no parameters,
  374. * and the entire configuration will be updated.
  375. * @param newConfiguration the partial configuration to update or a URL to a JSON holding the updated configuration
  376. *
  377. */
  378. updateConfiguration(newConfiguration?: Partial<ViewerConfiguration> | string): void;
  379. /**
  380. * this is used to register native functions using the configuration object.
  381. * This will configure the observers.
  382. * @param observersConfiguration observers configuration
  383. */
  384. protected _configureObservers(observersConfiguration: IObserversConfiguration): void;
  385. /**
  386. * Dispose the entire viewer including the scene and the engine
  387. */
  388. dispose(): void;
  389. /**
  390. * This will prepare the container element for the viewer
  391. */
  392. protected abstract _prepareContainerElement(): any;
  393. /**
  394. * This function will execute when the HTML templates finished initializing.
  395. * It should initialize the engine and continue execution.
  396. *
  397. * @returns {Promise<AbstractViewer>} The viewer object will be returned after the object was loaded.
  398. */
  399. protected _onTemplatesLoaded(): Promise<AbstractViewer>;
  400. /**
  401. * This will force the creation of an engine and a scene.
  402. * It will also load a model if preconfigured.
  403. * But first - it will load the extendible onTemplateLoaded()!
  404. */
  405. protected _onTemplateLoaded(): Promise<AbstractViewer>;
  406. /**
  407. * Initialize the engine. Retruns a promise in case async calls are needed.
  408. *
  409. * @protected
  410. * @returns {Promise<BABYLON.Engine>}
  411. * @memberof Viewer
  412. */
  413. protected _initEngine(): Promise<BABYLON.Engine>;
  414. /**
  415. * Initialize a model loading. The returned object (a ViewerModel object) will be loaded in the background.
  416. * The difference between this and loadModel is that loadModel will fulfill the promise when the model finished loading.
  417. *
  418. * @param modelConfig model configuration to use when loading the model.
  419. * @param clearScene should the scene be cleared before loading this model
  420. * @returns a ViewerModel object that is not yet fully loaded.
  421. */
  422. initModel(modelConfig: string | File | IModelConfiguration, clearScene?: boolean): ViewerModel;
  423. /**
  424. * load a model using the provided configuration.
  425. * This function, as opposed to initModel, will return a promise that resolves when the model is loaded, and rejects with error.
  426. * If you want to attach to the observables of the model, use initModle instead.
  427. *
  428. * @param modelConfig the model configuration or URL to load.
  429. * @param clearScene Should the scene be cleared before loading the model
  430. * @returns a Promise the fulfills when the model finished loading successfully.
  431. */
  432. loadModel(modelConfig: string | File | IModelConfiguration, clearScene?: boolean): Promise<ViewerModel>;
  433. protected _initTelemetryEvents(): void;
  434. /**
  435. * Injects all the spectre shader in the babylon shader store
  436. */
  437. protected _injectCustomShaders(): void;
  438. }
  439. }
  440. declare module BabylonViewer {
  441. /**
  442. * The data structure of a telemetry event.
  443. */
  444. export interface TelemetryData {
  445. event: string;
  446. session: string;
  447. date: Date;
  448. now: number;
  449. viewerId?: string;
  450. detail: any;
  451. }
  452. /**
  453. * Receives Telemetry events and raises events to the API
  454. */
  455. export class TelemetryManager {
  456. onEventBroadcastedObservable: BABYLON.Observable<TelemetryData>;
  457. /**
  458. * Receives a telemetry event
  459. * @param event The name of the Telemetry event
  460. * @param details An additional value, or an object containing a list of property/value pairs
  461. */
  462. readonly broadcast: (event: string, viewerId?: string | undefined, details?: any) => void;
  463. /**
  464. * Log a Telemetry event for errors raised on the WebGL context.
  465. * @param engine The Babylon engine with the WebGL context.
  466. */
  467. flushWebGLErrors(engine: BABYLON.Engine, viewerId?: string): void;
  468. /**
  469. * Enable or disable telemetry events
  470. * @param enabled Boolan, true if events are enabled
  471. */
  472. enable: boolean;
  473. /**
  474. * Returns the current session ID or creates one if it doesn't exixt
  475. * @return The current session ID
  476. */
  477. readonly session: string;
  478. /**
  479. * Disposes the telemetry manager
  480. */
  481. dispose(): void;
  482. }
  483. export const telemetryManager: TelemetryManager;
  484. }
  485. declare module BabylonViewer {
  486. /**
  487. * An instance of the class is in charge of loading the model correctly.
  488. * This class will continously be expended with tasks required from the specific loaders Babylon has.
  489. *
  490. * A Model loader is unique per (Abstract)Viewer. It is being generated by the viewer
  491. */
  492. export class ModelLoader {
  493. readonly baseUrl: string;
  494. /**
  495. * Create a new Model loader
  496. * @param _viewer the viewer using this model loader
  497. */
  498. constructor(_observablesManager: ObservablesManager, _configurationContainer?: ConfigurationContainer | undefined);
  499. /**
  500. * Adds a new plugin to the loader process.
  501. *
  502. * @param plugin the plugin name or the plugin itself
  503. */
  504. addPlugin(plugin: ILoaderPlugin | string): void;
  505. /**
  506. * Load a model using predefined configuration
  507. * @param modelConfiguration the modelConfiguration to use to load the model
  508. */
  509. load(modelConfiguration: IModelConfiguration): ViewerModel;
  510. cancelLoad(model: ViewerModel): void;
  511. /**
  512. * dispose the model loader.
  513. * If loaders are registered and are in the middle of loading, they will be disposed and the request(s) will be cancelled.
  514. */
  515. dispose(): void;
  516. }
  517. }
  518. declare module BabylonViewer {
  519. /**
  520. * The current state of the model
  521. */
  522. export enum ModelState {
  523. INIT = 0,
  524. LOADING = 1,
  525. LOADED = 2,
  526. ENTRY = 3,
  527. ENTRYDONE = 4,
  528. COMPLETE = 5,
  529. CANCELED = 6,
  530. ERROR = 7
  531. }
  532. /**
  533. * The viewer model is a container for all assets representing a sngle loaded model.
  534. */
  535. export class ViewerModel implements BABYLON.IDisposable {
  536. /**
  537. * The loader used to load this model.
  538. */
  539. loader: BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync;
  540. /**
  541. * This model's root mesh (the parent of all other meshes).
  542. * This mesh does not(!) exist in the meshes array.
  543. */
  544. rootMesh: BABYLON.AbstractMesh;
  545. /**
  546. * ParticleSystems connected to this model
  547. */
  548. particleSystems: Array<BABYLON.IParticleSystem>;
  549. /**
  550. * Skeletons defined in this model
  551. */
  552. skeletons: Array<BABYLON.Skeleton>;
  553. /**
  554. * The current model animation.
  555. * On init, this will be undefined.
  556. */
  557. currentAnimation: IModelAnimation;
  558. /**
  559. * Observers registered here will be executed when the model is done loading
  560. */
  561. onLoadedObservable: BABYLON.Observable<ViewerModel>;
  562. /**
  563. * Observers registered here will be executed when the loader notified of a progress event
  564. */
  565. onLoadProgressObservable: BABYLON.Observable<BABYLON.SceneLoaderProgressEvent>;
  566. /**
  567. * Observers registered here will be executed when the loader notified of an error.
  568. */
  569. onLoadErrorObservable: BABYLON.Observable<{
  570. message: string;
  571. exception: any;
  572. }>;
  573. /**
  574. * Will be executed after the model finished loading and complete, including entry animation and lod
  575. */
  576. onCompleteObservable: BABYLON.Observable<ViewerModel>;
  577. /**
  578. * Observers registered here will be executed every time the model is being configured.
  579. * This can be used to extend the model's configuration without extending the class itself
  580. */
  581. onAfterConfigure: BABYLON.Observable<ViewerModel>;
  582. /**
  583. * The current model state (loaded, error, etc)
  584. */
  585. state: ModelState;
  586. /**
  587. * A loadID provided by the modelLoader, unique to ths (Abstract)Viewer instance.
  588. */
  589. loadId: number;
  590. loadInfo: IAsset;
  591. constructor(_observablesManager: ObservablesManager, modelConfiguration: IModelConfiguration, _configurationContainer?: ConfigurationContainer | undefined);
  592. shadowsRenderedAfterLoad: boolean;
  593. getViewerId(): string | undefined;
  594. /**
  595. * Set whether this model is enabled or not.
  596. */
  597. enabled: boolean;
  598. loaderDone: boolean;
  599. /**
  600. * Add a mesh to this model.
  601. * Any mesh that has no parent will be provided with the root mesh as its new parent.
  602. *
  603. * @param mesh the new mesh to add
  604. * @param triggerLoaded should this mesh trigger the onLoaded observable. Used when adding meshes manually.
  605. */
  606. addMesh(mesh: BABYLON.AbstractMesh, triggerLoaded?: boolean): Promise<ViewerModel> | undefined;
  607. /**
  608. * get the list of meshes (excluding the root mesh)
  609. */
  610. readonly meshes: BABYLON.AbstractMesh[];
  611. /**
  612. * (Re-)set the model's entire configuration
  613. * @param newConfiguration the new configuration to replace the new one
  614. */
  615. configuration: IModelConfiguration;
  616. /**
  617. * Update the current configuration with new values.
  618. * Configuration will not be overwritten, but merged with the new configuration.
  619. * Priority is to the new configuration
  620. * @param newConfiguration the configuration to be merged into the current configuration;
  621. */
  622. updateConfiguration(newConfiguration: Partial<IModelConfiguration>): void;
  623. /**
  624. * Add a new animation group to this model.
  625. * @param animationGroup the new animation group to be added
  626. */
  627. addAnimationGroup(animationGroup: BABYLON.AnimationGroup): void;
  628. /**
  629. * Get the ModelAnimation array
  630. */
  631. getAnimations(): Array<IModelAnimation>;
  632. /**
  633. * Get the animations' names. Using the names you can play a specific animation.
  634. */
  635. getAnimationNames(): Array<string>;
  636. /**
  637. * Get an animation by the provided name. Used mainly when playing n animation.
  638. * @param name the name of the animation to find
  639. */
  640. protected _getAnimationByName(name: string): BABYLON.Nullable<IModelAnimation>;
  641. /**
  642. * Choose an initialized animation using its name and start playing it
  643. * @param name the name of the animation to play
  644. * @returns The model aniamtion to be played.
  645. */
  646. playAnimation(name: string): IModelAnimation;
  647. setCurrentAnimationByName(name: string): IModelAnimation;
  648. /**
  649. * Apply a material configuration to a material
  650. * @param material BABYLON.Material to apply configuration to
  651. * @hidden
  652. */
  653. _applyModelMaterialConfiguration(material: BABYLON.Material): void;
  654. /**
  655. * Begin @animations with the specified @easingFunction
  656. * @param animations The BABYLON Animations to begin
  657. * @param duration of transition, in seconds
  658. * @param easingFunction An easing function to apply
  659. * @param easingMode A easing mode to apply to the easingFunction
  660. * @param onAnimationEnd Call back trigger at the end of the animation.
  661. */
  662. transitionTo(animations: BABYLON.Animation[], duration: number, easingFunction: any, easingMode: number | undefined, // BABYLON.EasingFunction.EASINGMODE_EASEINOUT,
  663. onAnimationEnd: () => void): void;
  664. /**
  665. * Stops and removes all animations that have been applied to the model
  666. */
  667. stopAllAnimations(): void;
  668. /**
  669. * Will remove this model from the viewer (but NOT dispose it).
  670. */
  671. remove(): void;
  672. /**
  673. * Dispose this model, including all of its associated assets.
  674. */
  675. dispose(): void;
  676. }
  677. }
  678. declare module BabylonViewer {
  679. /**
  680. * BABYLON.Animation play mode enum - is the animation looping or playing once
  681. */
  682. export const enum AnimationPlayMode {
  683. ONCE = 0,
  684. LOOP = 1
  685. }
  686. /**
  687. * An enum representing the current state of an animation object
  688. */
  689. export const enum AnimationState {
  690. INIT = 0,
  691. PLAYING = 1,
  692. PAUSED = 2,
  693. STOPPED = 3,
  694. ENDED = 4
  695. }
  696. /**
  697. * The different type of easing functions available
  698. */
  699. export const enum EasingFunction {
  700. Linear = 0,
  701. CircleEase = 1,
  702. BackEase = 2,
  703. BounceEase = 3,
  704. CubicEase = 4,
  705. ElasticEase = 5,
  706. ExponentialEase = 6,
  707. PowerEase = 7,
  708. QuadraticEase = 8,
  709. QuarticEase = 9,
  710. QuinticEase = 10,
  711. SineEase = 11
  712. }
  713. /**
  714. * Defines a simple animation to be applied to a model (scale).
  715. */
  716. export interface ModelAnimationConfiguration {
  717. /**
  718. * Time of animation, in seconds
  719. */
  720. time: number;
  721. /**
  722. * Scale to apply
  723. */
  724. scaling?: BABYLON.Vector3;
  725. /**
  726. * Easing function to apply
  727. * See SPECTRE.EasingFunction
  728. */
  729. easingFunction?: number;
  730. /**
  731. * An Easing mode to apply to the easing function
  732. * See BABYLON.EasingFunction
  733. */
  734. easingMode?: number;
  735. }
  736. /**
  737. * This interface can be implemented to define new types of ModelAnimation objects.
  738. */
  739. export interface IModelAnimation {
  740. /**
  741. * Current animation state (playing, stopped etc')
  742. */
  743. readonly state: AnimationState;
  744. /**
  745. * the name of the animation
  746. */
  747. readonly name: string;
  748. /**
  749. * Get the max numbers of frame available in the animation group
  750. *
  751. * In correlation to an arry, this would be ".length"
  752. */
  753. readonly frames: number;
  754. /**
  755. * Get the current frame playing right now.
  756. * This can be used to poll the frame currently playing (and, for exmaple, display a progress bar with the data)
  757. *
  758. * In correlation to an array, this would be the current index
  759. */
  760. readonly currentFrame: number;
  761. /**
  762. * BABYLON.Animation's FPS value
  763. */
  764. readonly fps: number;
  765. /**
  766. * Get or set the animation's speed ration (Frame-to-fps)
  767. */
  768. speedRatio: number;
  769. /**
  770. * Gets or sets the aimation's play mode.
  771. */
  772. playMode: AnimationPlayMode;
  773. /**
  774. * Start the animation
  775. */
  776. start(): any;
  777. /**
  778. * Stop the animation.
  779. * This will fail silently if the animation group is already stopped.
  780. */
  781. stop(): any;
  782. /**
  783. * Pause the animation
  784. * This will fail silently if the animation is not currently playing
  785. */
  786. pause(): any;
  787. /**
  788. * Reset this animation
  789. */
  790. reset(): any;
  791. /**
  792. * Restart the animation
  793. */
  794. restart(): any;
  795. /**
  796. * Go to a specific
  797. * @param frameNumber the frame number to go to
  798. */
  799. goToFrame(frameNumber: number): any;
  800. /**
  801. * Dispose this animation
  802. */
  803. dispose(): any;
  804. }
  805. /**
  806. * The GroupModelAnimation is an implementation of the IModelAnimation interface using BABYLON's
  807. * native GroupAnimation class.
  808. */
  809. export class GroupModelAnimation implements IModelAnimation {
  810. /**
  811. * Create a new GroupModelAnimation object using an BABYLON.AnimationGroup object
  812. * @param _animationGroup The aniamtion group to base the class on
  813. */
  814. constructor(_animationGroup: BABYLON.AnimationGroup);
  815. /**
  816. * Get the animation's name
  817. */
  818. readonly name: string;
  819. /**
  820. * Get the current animation's state
  821. */
  822. readonly state: AnimationState;
  823. /**
  824. * Sets the speed ratio to use for all animations
  825. */
  826. speedRatio: number;
  827. /**
  828. * Get the max numbers of frame available in the animation group
  829. *
  830. * In correlation to an arry, this would be ".length"
  831. */
  832. readonly frames: number;
  833. /**
  834. * Get the current frame playing right now.
  835. * This can be used to poll the frame currently playing (and, for exmaple, display a progress bar with the data)
  836. *
  837. * In correlation to an array, this would be the current index
  838. */
  839. readonly currentFrame: number;
  840. /**
  841. * Get the FPS value of this animation
  842. */
  843. readonly fps: number;
  844. /**
  845. * Set the play mode.
  846. * If the animation is played, it will continue playing at least once more, depending on the new play mode set.
  847. * If the animation is not set, the will be initialized and will wait for the user to start playing it.
  848. */
  849. playMode: AnimationPlayMode;
  850. /**
  851. * Reset the animation group
  852. */
  853. reset(): void;
  854. /**
  855. * Restart the animation group
  856. */
  857. restart(): void;
  858. /**
  859. *
  860. * @param frameNumber Go to a specific frame in the animation
  861. */
  862. goToFrame(frameNumber: number): void;
  863. /**
  864. * Start playing the animation.
  865. */
  866. start(): void;
  867. /**
  868. * Pause the animation
  869. */
  870. pause(): void;
  871. /**
  872. * Stop the animation.
  873. * This will fail silently if the animation group is already stopped.
  874. */
  875. stop(): void;
  876. /**
  877. * Dispose this animation object.
  878. */
  879. dispose(): void;
  880. }
  881. }
  882. declare module BabylonViewer {
  883. /**
  884. * This interface defines the structure of a loader plugin.
  885. * Any of those functions will be called if (!) the loader supports those callbacks.
  886. * Any loader supports onInit, onLoaded, onError and onProgress.
  887. */
  888. export interface ILoaderPlugin {
  889. onInit?: (loader: BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync, model: ViewerModel) => void;
  890. onLoaded?: (model: ViewerModel) => void;
  891. onError?: (message: string, exception?: any) => void;
  892. onProgress?: (progressEvent: BABYLON.SceneLoaderProgressEvent) => void;
  893. onExtensionLoaded?: (extension: BABYLON.IGLTFLoaderExtension) => void;
  894. onParsed?: (parsedData: BABYLON.IGLTFLoaderData) => void;
  895. onMeshLoaded?: (mesh: BABYLON.AbstractMesh) => void;
  896. onTextureLoaded?: (texture: BABYLON.BaseTexture) => void;
  897. onMaterialLoaded?: (material: BABYLON.Material) => void;
  898. onComplete?: () => void;
  899. }
  900. }
  901. declare module BabylonViewer {
  902. export interface IViewerTemplatePlugin {
  903. readonly templateName: string;
  904. readonly eventsToAttach?: Array<string>;
  905. interactionPredicate(event: EventCallback): boolean;
  906. onEvent?(event: EventCallback): void;
  907. addHTMLTemplate?(template: Template): void;
  908. }
  909. export abstract class AbstractViewerNavbarButton implements IViewerTemplatePlugin {
  910. readonly templateName: string;
  911. readonly eventsToAttach: Array<string>;
  912. protected _prepend: boolean;
  913. protected _buttonName: string;
  914. protected _buttonClass: string;
  915. protected _htmlTemplate: string;
  916. constructor(buttonName: string, buttonClass?: string, htmlTemplate?: string);
  917. interactionPredicate(event: EventCallback): boolean;
  918. abstract onEvent(event: EventCallback): void;
  919. addHTMLTemplate(template: Template): void;
  920. protected _generateHTMLElement(template: Template): Element | DocumentFragment;
  921. }
  922. }
  923. declare module BabylonViewer {
  924. /**
  925. *
  926. * @param name the name of the custom optimizer configuration
  927. * @param upgrade set to true if you want to upgrade optimizer and false if you want to degrade
  928. */
  929. export function getCustomOptimizerByName(name: string, upgrade?: boolean): typeof extendedUpgrade;
  930. export function registerCustomOptimizer(name: string, optimizer: (sceneManager: SceneManager) => boolean): void;
  931. }
  932. declare module BabylonViewer {
  933. /**
  934. * Will attach an init function the the DOMContentLoaded event.
  935. * The init function will be removed automatically after the event was triggered.
  936. */
  937. export function initListeners(): void;
  938. /**
  939. * Select all HTML tags on the page that match the selector and initialize a viewer
  940. *
  941. * @param selector the selector to initialize the viewer on (default is 'babylon')
  942. */
  943. export function InitTags(selector?: string): void;
  944. }
  945. declare module BabylonViewer {
  946. export function getConfigurationKey(key: string, configObject: any): any;
  947. export interface ViewerConfiguration {
  948. version?: string;
  949. extends?: string;
  950. pageUrl?: string;
  951. configuration?: string | {
  952. url?: string;
  953. payload?: any;
  954. mapper?: string;
  955. };
  956. observers?: IObserversConfiguration;
  957. canvasElement?: string;
  958. model?: IModelConfiguration | string;
  959. scene?: ISceneConfiguration;
  960. optimizer?: ISceneOptimizerConfiguration | boolean;
  961. camera?: ICameraConfiguration;
  962. skybox?: boolean | ISkyboxConfiguration;
  963. ground?: boolean | IGroundConfiguration;
  964. lights?: {
  965. [name: string]: number | boolean | ILightConfiguration;
  966. };
  967. engine?: {
  968. renderInBackground?: boolean;
  969. antialiasing?: boolean;
  970. disableResize?: boolean;
  971. engineOptions?: BABYLON.EngineOptions;
  972. adaptiveQuality?: boolean;
  973. hdEnabled?: boolean;
  974. };
  975. templates?: {
  976. main: ITemplateConfiguration;
  977. [key: string]: ITemplateConfiguration;
  978. };
  979. customShaders?: {
  980. shaders?: {
  981. [key: string]: string;
  982. };
  983. includes?: {
  984. [key: string]: string;
  985. };
  986. };
  987. loaderPlugins?: {
  988. extendedMaterial?: boolean;
  989. msftLod?: boolean;
  990. telemetry?: boolean;
  991. minecraft?: boolean;
  992. [propName: string]: boolean | undefined;
  993. };
  994. environmentMap?: IEnvironmentMapConfiguration;
  995. vr?: IVRConfiguration;
  996. lab?: {
  997. flashlight?: boolean | {
  998. exponent?: number;
  999. angle?: number;
  1000. intensity?: number;
  1001. diffuse?: {
  1002. r: number;
  1003. g: number;
  1004. b: number;
  1005. };
  1006. specular?: {
  1007. r: number;
  1008. g: number;
  1009. b: number;
  1010. };
  1011. };
  1012. hideLoadingDelay?: number;
  1013. /** Deprecated */
  1014. assetsRootURL?: string;
  1015. environmentMainColor?: {
  1016. r: number;
  1017. g: number;
  1018. b: number;
  1019. };
  1020. /** Deprecated */
  1021. environmentMap?: {
  1022. /**
  1023. * Environment map texture path in relative to the asset folder.
  1024. */
  1025. texture: string;
  1026. /**
  1027. * Default rotation to apply to the environment map.
  1028. */
  1029. rotationY: number;
  1030. /**
  1031. * Tint level of the main color on the environment map.
  1032. */
  1033. tintLevel: number;
  1034. };
  1035. defaultRenderingPipelines?: boolean | IDefaultRenderingPipelineConfiguration;
  1036. globalLightRotation?: number;
  1037. };
  1038. }
  1039. }
  1040. declare module BabylonViewer {
  1041. /**
  1042. * The object sent when an event is triggered
  1043. */
  1044. export interface EventCallback {
  1045. event: Event;
  1046. template: Template;
  1047. selector: string;
  1048. payload?: any;
  1049. }
  1050. /**
  1051. * The template manager, a member of the viewer class, will manage the viewer's templates and generate the HTML.
  1052. * The template manager managers a single viewer and can be seen as the collection of all sub-templates of the viewer.
  1053. */
  1054. export class TemplateManager {
  1055. containerElement: Element;
  1056. /**
  1057. * Will be triggered when any template is initialized
  1058. */
  1059. onTemplateInit: BABYLON.Observable<Template>;
  1060. /**
  1061. * Will be triggered when any template is fully loaded
  1062. */
  1063. onTemplateLoaded: BABYLON.Observable<Template>;
  1064. /**
  1065. * Will be triggered when a template state changes
  1066. */
  1067. onTemplateStateChange: BABYLON.Observable<Template>;
  1068. /**
  1069. * Will be triggered when all templates finished loading
  1070. */
  1071. onAllLoaded: BABYLON.Observable<TemplateManager>;
  1072. /**
  1073. * Will be triggered when any event on any template is triggered.
  1074. */
  1075. onEventTriggered: BABYLON.Observable<EventCallback>;
  1076. /**
  1077. * This template manager's event manager. In charge of callback registrations to native event types
  1078. */
  1079. eventManager: EventManager;
  1080. constructor(containerElement: Element);
  1081. /**
  1082. * Initialize the template(s) for the viewer. Called bay the Viewer class
  1083. * @param templates the templates to be used to initialize the main template
  1084. */
  1085. initTemplate(templates: {
  1086. [key: string]: ITemplateConfiguration;
  1087. }): Promise<void>;
  1088. /**
  1089. * Get the canvas in the template tree.
  1090. * There must be one and only one canvas inthe template.
  1091. */
  1092. getCanvas(): HTMLCanvasElement | null;
  1093. /**
  1094. * Get a specific template from the template tree
  1095. * @param name the name of the template to load
  1096. */
  1097. getTemplate(name: string): Template | undefined;
  1098. /**
  1099. * Dispose the template manager
  1100. */
  1101. dispose(): void;
  1102. }
  1103. /**
  1104. * This class represents a single template in the viewer's template tree.
  1105. * An example for a template is a single canvas, an overlay (containing sub-templates) or the navigation bar.
  1106. * A template is injected using the template manager in the correct position.
  1107. * The template is rendered using Handlebars and can use Handlebars' features (such as parameter injection)
  1108. *
  1109. * For further information please refer to the documentation page, https://doc.babylonjs.com
  1110. */
  1111. export class Template {
  1112. name: string;
  1113. /**
  1114. * Will be triggered when the template is loaded
  1115. */
  1116. onLoaded: BABYLON.Observable<Template>;
  1117. /**
  1118. * will be triggered when the template is appended to the tree
  1119. */
  1120. onAppended: BABYLON.Observable<Template>;
  1121. /**
  1122. * Will be triggered when the template's state changed (shown, hidden)
  1123. */
  1124. onStateChange: BABYLON.Observable<Template>;
  1125. /**
  1126. * Will be triggered when an event is triggered on ths template.
  1127. * The event is a native browser event (like mouse or pointer events)
  1128. */
  1129. onEventTriggered: BABYLON.Observable<EventCallback>;
  1130. onParamsUpdated: BABYLON.Observable<Template>;
  1131. onHTMLRendered: BABYLON.Observable<Template>;
  1132. /**
  1133. * is the template loaded?
  1134. */
  1135. isLoaded: boolean;
  1136. /**
  1137. * This is meant to be used to track the show and hide functions.
  1138. * This is NOT (!!) a flag to check if the element is actually visible to the user.
  1139. */
  1140. isShown: boolean;
  1141. /**
  1142. * Is this template a part of the HTML tree (the template manager injected it)
  1143. */
  1144. isInHtmlTree: boolean;
  1145. /**
  1146. * The HTML element containing this template
  1147. */
  1148. parent: HTMLElement;
  1149. /**
  1150. * A promise that is fulfilled when the template finished loading.
  1151. */
  1152. initPromise: Promise<Template>;
  1153. constructor(name: string, _configuration: ITemplateConfiguration);
  1154. /**
  1155. * Some templates have parameters (like background color for example).
  1156. * The parameters are provided to Handlebars which in turn generates the template.
  1157. * This function will update the template with the new parameters
  1158. *
  1159. * Note that when updating parameters the events will be registered again (after being cleared).
  1160. *
  1161. * @param params the new template parameters
  1162. */
  1163. updateParams(params: {
  1164. [key: string]: string | number | boolean | object;
  1165. }, append?: boolean): void;
  1166. redraw(): void;
  1167. /**
  1168. * Get the template'S configuration
  1169. */
  1170. readonly configuration: ITemplateConfiguration;
  1171. /**
  1172. * A template can be a parent element for other templates or HTML elements.
  1173. * This function will deliver all child HTML elements of this template.
  1174. */
  1175. getChildElements(): Array<string>;
  1176. /**
  1177. * Appending the template to a parent HTML element.
  1178. * If a parent is already set and you wish to replace the old HTML with new one, forceRemove should be true.
  1179. * @param parent the parent to which the template is added
  1180. * @param forceRemove if the parent already exists, shoud the template be removed from it?
  1181. */
  1182. appendTo(parent: HTMLElement, forceRemove?: boolean): void;
  1183. /**
  1184. * Show the template using the provided visibilityFunction, or natively using display: flex.
  1185. * The provided function returns a promise that should be fullfilled when the element is shown.
  1186. * Since it is a promise async operations are more than possible.
  1187. * See the default viewer for an opacity example.
  1188. * @param visibilityFunction The function to execute to show the template.
  1189. */
  1190. show(visibilityFunction?: (template: Template) => Promise<Template>): Promise<Template>;
  1191. /**
  1192. * Hide the template using the provided visibilityFunction, or natively using display: none.
  1193. * The provided function returns a promise that should be fullfilled when the element is hidden.
  1194. * Since it is a promise async operations are more than possible.
  1195. * See the default viewer for an opacity example.
  1196. * @param visibilityFunction The function to execute to show the template.
  1197. */
  1198. hide(visibilityFunction?: (template: Template) => Promise<Template>): Promise<Template>;
  1199. /**
  1200. * Dispose this template
  1201. */
  1202. dispose(): void;
  1203. }
  1204. }
  1205. declare module BabylonViewer {
  1206. export class ConfigurationContainer {
  1207. configuration: ViewerConfiguration;
  1208. viewerId: string;
  1209. mainColor: BABYLON.Color3;
  1210. reflectionColor: BABYLON.Color3;
  1211. scene?: BABYLON.Scene;
  1212. }
  1213. }
  1214. declare module BabylonViewer {
  1215. /**
  1216. * The configuration loader will load the configuration object from any source and will use the defined mapper to
  1217. * parse the object and return a conform ViewerConfiguration.
  1218. * It is a private member of the scene.
  1219. */
  1220. export class ConfigurationLoader {
  1221. constructor(_enableCache?: boolean);
  1222. /**
  1223. * load a configuration object that is defined in the initial configuration provided.
  1224. * The viewer configuration can extend different types of configuration objects and have an extra configuration defined.
  1225. *
  1226. * @param initConfig the initial configuration that has the definitions of further configuration to load.
  1227. * @param callback an optional callback that will be called sync, if noconfiguration needs to be loaded or configuration is payload-only
  1228. * @returns A promise that delivers the extended viewer configuration, when done.
  1229. */
  1230. loadConfiguration(initConfig?: ViewerConfiguration, callback?: (config: ViewerConfiguration) => void): Promise<ViewerConfiguration>;
  1231. /**
  1232. * Dispose the configuration loader. This will cancel file requests, if active.
  1233. */
  1234. dispose(): void;
  1235. }
  1236. }
  1237. declare module BabylonViewer {
  1238. export class ObservablesManager {
  1239. /**
  1240. * Will notify when the scene was initialized
  1241. */
  1242. onSceneInitObservable: BABYLON.Observable<BABYLON.Scene>;
  1243. /**
  1244. * will notify when the engine was initialized
  1245. */
  1246. onEngineInitObservable: BABYLON.Observable<BABYLON.Engine>;
  1247. /**
  1248. * Will notify when a new model was added to the scene.
  1249. * Note that added does not neccessarily mean loaded!
  1250. */
  1251. onModelAddedObservable: BABYLON.Observable<ViewerModel>;
  1252. /**
  1253. * will notify after every model load
  1254. */
  1255. onModelLoadedObservable: BABYLON.Observable<ViewerModel>;
  1256. /**
  1257. * will notify when any model notify of progress
  1258. */
  1259. onModelLoadProgressObservable: BABYLON.Observable<BABYLON.SceneLoaderProgressEvent>;
  1260. /**
  1261. * will notify when any model load failed.
  1262. */
  1263. onModelLoadErrorObservable: BABYLON.Observable<{
  1264. message: string;
  1265. exception: any;
  1266. }>;
  1267. /**
  1268. * Will notify when a model was removed from the scene;
  1269. */
  1270. onModelRemovedObservable: BABYLON.Observable<ViewerModel>;
  1271. /**
  1272. * will notify when a new loader was initialized.
  1273. * Used mainly to know when a model starts loading.
  1274. */
  1275. onLoaderInitObservable: BABYLON.Observable<BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync>;
  1276. /**
  1277. * Observers registered here will be executed when the entire load process has finished.
  1278. */
  1279. onViewerInitDoneObservable: BABYLON.Observable<any>;
  1280. /**
  1281. * Will notify when the viewer init started (after configuration was loaded)
  1282. */
  1283. onViewerInitStartedObservable: BABYLON.Observable<any>;
  1284. /**
  1285. * Functions added to this observable will be executed on each frame rendered.
  1286. */
  1287. onFrameRenderedObservable: BABYLON.Observable<any>;
  1288. /**
  1289. * Will notify when VR mode is entered.
  1290. */
  1291. onEnteringVRObservable: BABYLON.Observable<any>;
  1292. /**
  1293. * Will notify when VR mode is exited.
  1294. */
  1295. onExitingVRObservable: BABYLON.Observable<any>;
  1296. constructor();
  1297. dispose(): void;
  1298. }
  1299. }
  1300. declare module BabylonViewer {
  1301. /**
  1302. * This interface describes the structure of the variable sent with the configuration observables of the scene manager.
  1303. * O - the type of object we are dealing with (Light, BABYLON.ArcRotateCamera, BABYLON.Scene, etc')
  1304. * T - the configuration type
  1305. */
  1306. export interface IPostConfigurationCallback<OBJ, CONF> {
  1307. newConfiguration: CONF;
  1308. sceneManager: SceneManager;
  1309. object: OBJ;
  1310. model?: ViewerModel;
  1311. }
  1312. export class SceneManager {
  1313. /**
  1314. * Will notify when the scene was initialized
  1315. */
  1316. onSceneInitObservable: BABYLON.Observable<BABYLON.Scene>;
  1317. /**
  1318. * Will notify after the scene was configured. Can be used to further configure the scene
  1319. */
  1320. onSceneConfiguredObservable: BABYLON.Observable<IPostConfigurationCallback<BABYLON.Scene, ISceneConfiguration>>;
  1321. /**
  1322. * Will notify after the scene optimized was configured. Can be used to further configure the scene optimizer
  1323. */
  1324. onSceneOptimizerConfiguredObservable: BABYLON.Observable<IPostConfigurationCallback<BABYLON.SceneOptimizer, ISceneOptimizerConfiguration | boolean>>;
  1325. /**
  1326. * Will notify after the camera was configured. Can be used to further configure the camera
  1327. */
  1328. onCameraConfiguredObservable: BABYLON.Observable<IPostConfigurationCallback<BABYLON.ArcRotateCamera, ICameraConfiguration>>;
  1329. /**
  1330. * Will notify after the lights were configured. Can be used to further configure lights
  1331. */
  1332. onLightsConfiguredObservable: BABYLON.Observable<IPostConfigurationCallback<Array<BABYLON.Light>, {
  1333. [name: string]: ILightConfiguration | boolean | number;
  1334. }>>;
  1335. /**
  1336. * Will notify after the model(s) were configured. Can be used to further configure models
  1337. */
  1338. onModelsConfiguredObservable: BABYLON.Observable<IPostConfigurationCallback<Array<ViewerModel>, IModelConfiguration>>;
  1339. /**
  1340. * Will notify after the envirnoment was configured. Can be used to further configure the environment
  1341. */
  1342. onEnvironmentConfiguredObservable: BABYLON.Observable<IPostConfigurationCallback<BABYLON.EnvironmentHelper, {
  1343. skybox?: ISkyboxConfiguration | boolean;
  1344. ground?: IGroundConfiguration | boolean;
  1345. }>>;
  1346. /**
  1347. * Will notify after the model(s) were configured. Can be used to further configure models
  1348. */
  1349. onVRConfiguredObservable: BABYLON.Observable<IPostConfigurationCallback<BABYLON.VRExperienceHelper, IVRConfiguration>>;
  1350. /**
  1351. * The Babylon BABYLON.Scene of this viewer
  1352. */
  1353. scene: BABYLON.Scene;
  1354. /**
  1355. * The camera used in this viewer
  1356. */
  1357. camera: BABYLON.ArcRotateCamera;
  1358. /**
  1359. * Babylon's scene optimizer
  1360. */
  1361. sceneOptimizer: BABYLON.SceneOptimizer;
  1362. /**
  1363. * Models displayed in this viewer.
  1364. */
  1365. models: Array<ViewerModel>;
  1366. /**
  1367. * Babylon's environment helper of this viewer
  1368. */
  1369. environmentHelper?: BABYLON.EnvironmentHelper;
  1370. protected _defaultHighpTextureType: number;
  1371. protected _shadowGeneratorBias: number;
  1372. protected _defaultPipelineTextureType: number;
  1373. /**
  1374. * The maximum number of shadows supported by the curent viewer
  1375. */
  1376. protected _maxShadows: number;
  1377. /**
  1378. * The labs variable consists of objects that will have their API change.
  1379. * Please be careful when using labs in production.
  1380. */
  1381. labs: ViewerLabs;
  1382. readonly defaultRenderingPipeline: BABYLON.Nullable<BABYLON.DefaultRenderingPipeline>;
  1383. protected _vrHelper?: BABYLON.VRExperienceHelper;
  1384. readonly vrHelper: BABYLON.VRExperienceHelper | undefined;
  1385. constructor(_engine: BABYLON.Engine, _configurationContainer: ConfigurationContainer, _observablesManager?: ObservablesManager | undefined);
  1386. /**
  1387. * Returns a boolean representing HDR support
  1388. */
  1389. readonly isHdrSupported: boolean;
  1390. /**
  1391. * Return the main color defined in the configuration.
  1392. */
  1393. readonly mainColor: BABYLON.Color3;
  1394. readonly reflectionColor: BABYLON.Color3;
  1395. animationBlendingEnabled: boolean;
  1396. readonly observablesManager: ObservablesManager | undefined;
  1397. /**
  1398. * Should shadows be rendered every frame, or only once and stop.
  1399. * This can be used to optimize a scene.
  1400. *
  1401. * Not that the shadows will NOT disapear but will remain in place.
  1402. * @param process if true shadows will be updated once every frame. if false they will stop being updated.
  1403. */
  1404. processShadows: boolean;
  1405. groundEnabled: boolean;
  1406. /**
  1407. * sets wether the reflection is disabled.
  1408. */
  1409. groundMirrorEnabled: boolean;
  1410. defaultRenderingPipelineEnabled: boolean;
  1411. /**
  1412. * Sets the engine flags to unlock all babylon features.
  1413. * Can also be configured using the scene.flags configuration object
  1414. */
  1415. unlockBabylonFeatures(): void;
  1416. /**
  1417. * initialize the scene. Calling this function again will dispose the old scene, if exists.
  1418. */
  1419. initScene(sceneConfiguration?: ISceneConfiguration, optimizerConfiguration?: boolean | ISceneOptimizerConfiguration): Promise<BABYLON.Scene>;
  1420. clearScene(clearModels?: boolean, clearLights?: boolean): void;
  1421. /**
  1422. * This will update the scene's configuration, including camera, lights, environment.
  1423. * @param newConfiguration the delta that should be configured. This includes only the changes
  1424. * @param globalConfiguration The global configuration object, after the new configuration was merged into it
  1425. */
  1426. updateConfiguration(newConfiguration: Partial<ViewerConfiguration>): void;
  1427. bloomEnabled: boolean;
  1428. fxaaEnabled: boolean;
  1429. /**
  1430. * internally configure the scene using the provided configuration.
  1431. * The scene will not be recreated, but just updated.
  1432. * @param sceneConfig the (new) scene configuration
  1433. */
  1434. protected _configureScene(sceneConfig: ISceneConfiguration): void;
  1435. /**
  1436. * Configure the scene optimizer.
  1437. * The existing scene optimizer will be disposed and a new one will be created.
  1438. * @param optimizerConfig the (new) optimizer configuration
  1439. */
  1440. protected _configureOptimizer(optimizerConfig: ISceneOptimizerConfiguration | boolean): void;
  1441. /**
  1442. * configure all models using the configuration.
  1443. * @param modelConfiguration the configuration to use to reconfigure the models
  1444. */
  1445. protected _configureVR(vrConfig: IVRConfiguration): void;
  1446. protected _configureEnvironmentMap(environmentMapConfiguration: IEnvironmentMapConfiguration): any;
  1447. /**
  1448. * (Re) configure the camera. The camera will only be created once and from this point will only be reconfigured.
  1449. * @param cameraConfig the new camera configuration
  1450. * @param model optionally use the model to configure the camera.
  1451. */
  1452. protected _configureCamera(cameraConfig?: ICameraConfiguration): void;
  1453. protected _configureEnvironment(skyboxConifguration?: ISkyboxConfiguration | boolean, groundConfiguration?: IGroundConfiguration | boolean): void;
  1454. /**
  1455. * configure the lights.
  1456. *
  1457. * @param lightsConfiguration the (new) light(s) configuration
  1458. * @param model optionally use the model to configure the camera.
  1459. */
  1460. protected _configureLights(lightsConfiguration?: {
  1461. [name: string]: ILightConfiguration | boolean | number;
  1462. }): void;
  1463. /**
  1464. * Gets the shadow map blur kernel according to the light configuration.
  1465. * @param light The light used to generate the shadows
  1466. * @param bufferSize The size of the shadow map
  1467. * @return the kernel blur size
  1468. */
  1469. getBlurKernel(light: BABYLON.IShadowLight, bufferSize: number): number;
  1470. /**
  1471. * Alters render settings to reduce features based on hardware feature limitations
  1472. * @param enableHDR Allows the viewer to run in HDR mode.
  1473. */
  1474. protected _handleHardwareLimitations(enableHDR?: boolean): void;
  1475. /**
  1476. * Dispoe the entire viewer including the scene and the engine
  1477. */
  1478. dispose(): void;
  1479. }
  1480. }
  1481. declare module BabylonViewer {
  1482. export interface IModelConfiguration {
  1483. id?: string;
  1484. url?: string;
  1485. root?: string;
  1486. file?: string | File;
  1487. loader?: string;
  1488. position?: {
  1489. x: number;
  1490. y: number;
  1491. z: number;
  1492. };
  1493. rotation?: {
  1494. x: number;
  1495. y: number;
  1496. z: number;
  1497. w?: number;
  1498. };
  1499. scaling?: {
  1500. x: number;
  1501. y: number;
  1502. z: number;
  1503. };
  1504. parentObjectIndex?: number;
  1505. castShadow?: boolean;
  1506. receiveShadows?: boolean;
  1507. normalize?: boolean | {
  1508. center?: boolean;
  1509. unitSize?: boolean;
  1510. parentIndex?: number;
  1511. };
  1512. title?: string;
  1513. subtitle?: string;
  1514. thumbnail?: string;
  1515. animation?: {
  1516. autoStart?: boolean | string;
  1517. playOnce?: boolean;
  1518. autoStartIndex?: number;
  1519. };
  1520. entryAnimation?: IModelAnimationConfiguration;
  1521. exitAnimation?: IModelAnimationConfiguration;
  1522. material?: {
  1523. directEnabled?: boolean;
  1524. directIntensity?: number;
  1525. emissiveIntensity?: number;
  1526. environmentIntensity?: number;
  1527. [propName: string]: any;
  1528. };
  1529. /**
  1530. * Rotation offset axis definition
  1531. */
  1532. rotationOffsetAxis?: {
  1533. x: number;
  1534. y: number;
  1535. z: number;
  1536. };
  1537. /**
  1538. * the offset angle
  1539. */
  1540. rotationOffsetAngle?: number;
  1541. loaderConfiguration?: {
  1542. maxLODsToLoad?: number;
  1543. progressiveLoading?: boolean;
  1544. };
  1545. }
  1546. }
  1547. declare module BabylonViewer {
  1548. /**
  1549. * Get a loader plugin according to its name.
  1550. * The plugin will be cached and will be reused if called for again.
  1551. *
  1552. * @param name the name of the plugin
  1553. */
  1554. export function getLoaderPluginByName(name: string): ILoaderPlugin;
  1555. /**
  1556. *
  1557. */
  1558. export function addLoaderPlugin(name: string, plugin: ILoaderPlugin): void;
  1559. }
  1560. declare module BabylonViewer {
  1561. /**
  1562. * A custom upgrade-oriented function configuration for the scene optimizer.
  1563. *
  1564. * @param viewer the viewer to optimize
  1565. */
  1566. export function extendedUpgrade(sceneManager: SceneManager): boolean;
  1567. /**
  1568. * A custom degrade-oriented function configuration for the scene optimizer.
  1569. *
  1570. * @param viewer the viewer to optimize
  1571. */
  1572. export function extendedDegrade(sceneManager: SceneManager): boolean;
  1573. }
  1574. declare module BabylonViewer {
  1575. export interface IEnvironmentMapConfiguration {
  1576. /**
  1577. * Environment map texture path in relative to the asset folder.
  1578. */
  1579. texture: string;
  1580. /**
  1581. * Default rotation to apply to the environment map.
  1582. */
  1583. rotationY: number;
  1584. /**
  1585. * Tint level of the main color on the environment map.
  1586. */
  1587. tintLevel: number;
  1588. /**
  1589. * The environment's main color.
  1590. */
  1591. mainColor?: {
  1592. r?: number;
  1593. g?: number;
  1594. b?: number;
  1595. };
  1596. }
  1597. }
  1598. declare module BabylonViewer {
  1599. /**
  1600. * The EventManager is in charge of registering user interctions with the viewer.
  1601. * It is used in the TemplateManager
  1602. */
  1603. export class EventManager {
  1604. constructor(_templateManager: TemplateManager);
  1605. /**
  1606. * Register a new callback to a specific template.
  1607. * The best example for the usage can be found in the DefaultViewer
  1608. *
  1609. * @param templateName the templateName to register the event to
  1610. * @param callback The callback to be executed
  1611. * @param eventType the type of event to register
  1612. * @param selector an optional selector. if not defined the parent object in the template will be selected
  1613. */
  1614. registerCallback(templateName: string, callback: (eventData: EventCallback) => void, eventType?: string, selector?: string): void;
  1615. /**
  1616. * This will remove a registered event from the defined template.
  1617. * Each one of the variables apart from the template name are optional, but one must be provided.
  1618. *
  1619. * @param templateName the templateName
  1620. * @param callback the callback to remove (optional)
  1621. * @param eventType the event type to remove (optional)
  1622. * @param selector the selector from which to remove the event (optional)
  1623. */
  1624. unregisterCallback(templateName: string, callback: (eventData: EventCallback) => void, eventType?: string, selector?: string): void;
  1625. /**
  1626. * Dispose the event manager
  1627. */
  1628. dispose(): void;
  1629. }
  1630. }
  1631. declare module BabylonViewer {
  1632. /**
  1633. * The ViewerLabs class will hold functions that are not (!) backwards compatible.
  1634. * The APIs in all labs-related classes and configuration might change.
  1635. * Once stable, lab features will be moved to the publis API and configuration object.
  1636. */
  1637. export class ViewerLabs {
  1638. constructor(_scene: BABYLON.Scene);
  1639. assetsRootURL: string;
  1640. environment: PBREnvironment;
  1641. /**
  1642. * Loads an environment map from a given URL
  1643. * @param url URL of environment map
  1644. * @param onSuccess Callback fired after environment successfully applied to the scene
  1645. * @param onProgress Callback fired at progress events while loading the environment map
  1646. * @param onError Callback fired when the load fails
  1647. */
  1648. loadEnvironment(url: string, onSuccess?: (env: PBREnvironment) => void, onProgress?: (bytesLoaded: number, bytesTotal: number) => void, onError?: (e: any) => void): void;
  1649. /**
  1650. * Loads an environment map from a given URL
  1651. * @param buffer ArrayBuffer containing environment map
  1652. * @param onSuccess Callback fired after environment successfully applied to the scene
  1653. * @param onProgress Callback fired at progress events while loading the environment map
  1654. * @param onError Callback fired when the load fails
  1655. */
  1656. loadEnvironment(buffer: ArrayBuffer, onSuccess?: (env: PBREnvironment) => void, onProgress?: (bytesLoaded: number, bytesTotal: number) => void, onError?: (e: any) => void): void;
  1657. /**
  1658. * Sets the environment to an already loaded environment
  1659. * @param env PBREnvironment instance
  1660. * @param onSuccess Callback fired after environment successfully applied to the scene
  1661. * @param onProgress Callback fired at progress events while loading the environment map
  1662. * @param onError Callback fired when the load fails
  1663. */
  1664. loadEnvironment(env: PBREnvironment, onSuccess?: (env: PBREnvironment) => void, onProgress?: (bytesLoaded: number, bytesTotal: number) => void, onError?: (e: any) => void): void;
  1665. /**
  1666. * Applies an `EnvironmentMapConfiguration` to the scene
  1667. * @param environmentMapConfiguration Environment map configuration to apply
  1668. */
  1669. applyEnvironmentMapConfiguration(rotationY?: number): void;
  1670. /**
  1671. * Get an environment asset url by using the configuration if the path is not absolute.
  1672. * @param url Asset url
  1673. * @returns The Asset url using the `environmentAssetsRootURL` if the url is not an absolute path.
  1674. */
  1675. getAssetUrl(url: string): string;
  1676. rotateShadowLight(shadowLight: BABYLON.ShadowLight, amount: number, point?: BABYLON.Vector3, axis?: BABYLON.Vector3, target?: BABYLON.Vector3): void;
  1677. }
  1678. }
  1679. declare module BabylonViewer {
  1680. /**
  1681. * Defines an animation to be applied to a model (translation, scale or rotation).
  1682. */
  1683. export interface IModelAnimationConfiguration {
  1684. /**
  1685. * Time of animation, in seconds
  1686. */
  1687. time?: number;
  1688. /**
  1689. * Scale to apply
  1690. */
  1691. scaling?: {
  1692. x: number;
  1693. y: number;
  1694. z: number;
  1695. };
  1696. /**
  1697. * Easing function to apply
  1698. */
  1699. easingFunction?: number;
  1700. /**
  1701. * An Easing mode to apply to the easing function
  1702. * See BABYLON.EasingFunction
  1703. */
  1704. easingMode?: number;
  1705. }
  1706. }
  1707. declare module BabylonViewer {
  1708. export class TelemetryLoaderPlugin implements ILoaderPlugin {
  1709. onInit(loader: BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync, model: ViewerModel): void;
  1710. onLoaded(model: ViewerModel): void;
  1711. onError(message: string, exception: any): void;
  1712. onComplete(): void;
  1713. }
  1714. }
  1715. declare module BabylonViewer {
  1716. /**
  1717. * A loder plugin to use MSFT_lod extension correctly (glTF)
  1718. */
  1719. export class MSFTLodLoaderPlugin implements ILoaderPlugin {
  1720. onInit(loader: BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync, model: ViewerModel): void;
  1721. onExtensionLoaded(extension: BABYLON.IGLTFLoaderExtension): void;
  1722. }
  1723. }
  1724. declare module BabylonViewer {
  1725. /**
  1726. * Force-apply material configuration right after a material was loaded.
  1727. */
  1728. export class ApplyMaterialConfigPlugin implements ILoaderPlugin {
  1729. onInit(loader: BABYLON.ISceneLoaderPlugin | BABYLON.ISceneLoaderPluginAsync, model: ViewerModel): void;
  1730. onMaterialLoaded(material: BABYLON.Material): void;
  1731. }
  1732. }
  1733. declare module BabylonViewer {
  1734. /**
  1735. * A (PBR) material will be extended using this function.
  1736. * This function will hold extra default configuration for the viewer, if not implemented in Babylon itself.
  1737. */
  1738. export class ExtendedMaterialLoaderPlugin implements ILoaderPlugin {
  1739. onMaterialLoaded(baseMaterial: BABYLON.Material): void;
  1740. }
  1741. }
  1742. declare module BabylonViewer {
  1743. export interface ICameraConfiguration {
  1744. position?: {
  1745. x: number;
  1746. y: number;
  1747. z: number;
  1748. };
  1749. rotation?: {
  1750. x: number;
  1751. y: number;
  1752. z: number;
  1753. w: number;
  1754. };
  1755. fov?: number;
  1756. fovMode?: number;
  1757. minZ?: number;
  1758. maxZ?: number;
  1759. inertia?: number;
  1760. exposure?: number;
  1761. pinchPrecision?: number;
  1762. behaviors?: {
  1763. [name: string]: boolean | number | ICameraBehaviorConfiguration;
  1764. };
  1765. disableCameraControl?: boolean;
  1766. disableCtrlForPanning?: boolean;
  1767. disableAutoFocus?: boolean;
  1768. [propName: string]: any;
  1769. }
  1770. export interface ICameraBehaviorConfiguration {
  1771. type: number;
  1772. [propName: string]: any;
  1773. }
  1774. }
  1775. declare module BabylonViewer {
  1776. /**
  1777. * The Color Grading Configuration groups the different settings used to define the color grading used in the viewer.
  1778. */
  1779. export interface IColorGradingConfiguration {
  1780. /**
  1781. * Transform data string, encoded as determined by transformDataFormat.
  1782. */
  1783. transformData: string;
  1784. /**
  1785. * The encoding format of TransformData (currently only raw-base16 is supported).
  1786. */
  1787. transformDataFormat: string;
  1788. /**
  1789. * The weight of the transform
  1790. */
  1791. transformWeight: number;
  1792. /**
  1793. * Color curve colorFilterHueGlobal value
  1794. */
  1795. colorFilterHueGlobal: number;
  1796. /**
  1797. * Color curve colorFilterHueShadows value
  1798. */
  1799. colorFilterHueShadows: number;
  1800. /**
  1801. * Color curve colorFilterHueMidtones value
  1802. */
  1803. colorFilterHueMidtones: number;
  1804. /**
  1805. * Color curve colorFilterHueHighlights value
  1806. */
  1807. colorFilterHueHighlights: number;
  1808. /**
  1809. * Color curve colorFilterDensityGlobal value
  1810. */
  1811. colorFilterDensityGlobal: number;
  1812. /**
  1813. * Color curve colorFilterDensityShadows value
  1814. */
  1815. colorFilterDensityShadows: number;
  1816. /**
  1817. * Color curve colorFilterDensityMidtones value
  1818. */
  1819. colorFilterDensityMidtones: number;
  1820. /**
  1821. * Color curve colorFilterDensityHighlights value
  1822. */
  1823. colorFilterDensityHighlights: number;
  1824. /**
  1825. * Color curve saturationGlobal value
  1826. */
  1827. saturationGlobal: number;
  1828. /**
  1829. * Color curve saturationShadows value
  1830. */
  1831. saturationShadows: number;
  1832. /**
  1833. * Color curve saturationMidtones value
  1834. */
  1835. saturationMidtones: number;
  1836. /**
  1837. * Color curve saturationHighlights value
  1838. */
  1839. saturationHighlights: number;
  1840. /**
  1841. * Color curve exposureGlobal value
  1842. */
  1843. exposureGlobal: number;
  1844. /**
  1845. * Color curve exposureShadows value
  1846. */
  1847. exposureShadows: number;
  1848. /**
  1849. * Color curve exposureMidtones value
  1850. */
  1851. exposureMidtones: number;
  1852. /**
  1853. * Color curve exposureHighlights value
  1854. */
  1855. exposureHighlights: number;
  1856. }
  1857. }
  1858. declare module BabylonViewer {
  1859. export interface IDefaultRenderingPipelineConfiguration {
  1860. sharpenEnabled?: boolean;
  1861. bloomEnabled?: boolean;
  1862. bloomThreshold?: number;
  1863. depthOfFieldEnabled?: boolean;
  1864. depthOfFieldBlurLevel?: BABYLON.DepthOfFieldEffectBlurLevel;
  1865. fxaaEnabled?: boolean;
  1866. imageProcessingEnabled?: boolean;
  1867. defaultPipelineTextureType?: number;
  1868. bloomScale?: number;
  1869. chromaticAberrationEnabled?: boolean;
  1870. grainEnabled?: boolean;
  1871. bloomKernel?: number;
  1872. hardwareScaleLevel?: number;
  1873. bloomWeight?: number;
  1874. hdr?: boolean;
  1875. samples?: number;
  1876. glowLayerEnabled?: boolean;
  1877. }
  1878. }
  1879. declare module BabylonViewer {
  1880. export interface IGroundConfiguration {
  1881. size?: number;
  1882. receiveShadows?: boolean;
  1883. shadowLevel?: number;
  1884. shadowOnly?: boolean;
  1885. mirror?: boolean | {
  1886. sizeRatio?: number;
  1887. blurKernel?: number;
  1888. amount?: number;
  1889. fresnelWeight?: number;
  1890. fallOffDistance?: number;
  1891. textureType?: number;
  1892. };
  1893. texture?: string;
  1894. color?: {
  1895. r: number;
  1896. g: number;
  1897. b: number;
  1898. };
  1899. opacity?: number;
  1900. material?: {
  1901. [propName: string]: any;
  1902. };
  1903. }
  1904. }
  1905. declare module BabylonViewer {
  1906. export interface IImageProcessingConfiguration {
  1907. colorGradingEnabled?: boolean;
  1908. colorCurvesEnabled?: boolean;
  1909. colorCurves?: {
  1910. globalHue?: number;
  1911. globalDensity?: number;
  1912. globalSaturation?: number;
  1913. globalExposure?: number;
  1914. highlightsHue?: number;
  1915. highlightsDensity?: number;
  1916. highlightsSaturation?: number;
  1917. highlightsExposure?: number;
  1918. midtonesHue?: number;
  1919. midtonesDensity?: number;
  1920. midtonesSaturation?: number;
  1921. midtonesExposure?: number;
  1922. shadowsHue?: number;
  1923. shadowsDensity?: number;
  1924. shadowsSaturation?: number;
  1925. shadowsExposure?: number;
  1926. };
  1927. colorGradingWithGreenDepth?: boolean;
  1928. colorGradingBGR?: boolean;
  1929. exposure?: number;
  1930. toneMappingEnabled?: boolean;
  1931. contrast?: number;
  1932. vignetteEnabled?: boolean;
  1933. vignetteStretch?: number;
  1934. vignetteCentreX?: number;
  1935. vignetteCentreY?: number;
  1936. vignetteWeight?: number;
  1937. vignetteColor?: {
  1938. r: number;
  1939. g: number;
  1940. b: number;
  1941. a?: number;
  1942. };
  1943. vignetteCameraFov?: number;
  1944. vignetteBlendMode?: number;
  1945. vignetteM?: boolean;
  1946. applyByPostProcess?: boolean;
  1947. isEnabled?: boolean;
  1948. }
  1949. }
  1950. declare module BabylonViewer {
  1951. export interface ILightConfiguration {
  1952. type: number;
  1953. name?: string;
  1954. disabled?: boolean;
  1955. position?: {
  1956. x: number;
  1957. y: number;
  1958. z: number;
  1959. };
  1960. target?: {
  1961. x: number;
  1962. y: number;
  1963. z: number;
  1964. };
  1965. direction?: {
  1966. x: number;
  1967. y: number;
  1968. z: number;
  1969. };
  1970. diffuse?: {
  1971. r: number;
  1972. g: number;
  1973. b: number;
  1974. };
  1975. specular?: {
  1976. r: number;
  1977. g: number;
  1978. b: number;
  1979. };
  1980. intensity?: number;
  1981. intensityMode?: number;
  1982. radius?: number;
  1983. shadownEnabled?: boolean;
  1984. shadowConfig?: {
  1985. useBlurExponentialShadowMap?: boolean;
  1986. useBlurCloseExponentialShadowMap?: boolean;
  1987. useKernelBlur?: boolean;
  1988. blurKernel?: number;
  1989. blurScale?: number;
  1990. minZ?: number;
  1991. maxZ?: number;
  1992. frustumSize?: number;
  1993. angleScale?: number;
  1994. frustumEdgeFalloff?: number;
  1995. [propName: string]: any;
  1996. };
  1997. spotAngle?: number;
  1998. shadowFieldOfView?: number;
  1999. shadowBufferSize?: number;
  2000. shadowFrustumSize?: number;
  2001. shadowMinZ?: number;
  2002. shadowMaxZ?: number;
  2003. [propName: string]: any;
  2004. behaviors?: {
  2005. [name: string]: number | {
  2006. type: number;
  2007. [propName: string]: any;
  2008. };
  2009. };
  2010. }
  2011. }
  2012. declare module BabylonViewer {
  2013. export interface IObserversConfiguration {
  2014. onEngineInit?: string;
  2015. onSceneInit?: string;
  2016. onModelLoaded?: string;
  2017. }
  2018. }
  2019. declare module BabylonViewer {
  2020. export interface ISceneConfiguration {
  2021. debug?: boolean;
  2022. clearColor?: {
  2023. r: number;
  2024. g: number;
  2025. b: number;
  2026. a: number;
  2027. };
  2028. /** Deprecated, use environmentMap.mainColor instead. */
  2029. mainColor?: {
  2030. r?: number;
  2031. g?: number;
  2032. b?: number;
  2033. };
  2034. imageProcessingConfiguration?: IImageProcessingConfiguration;
  2035. environmentTexture?: string;
  2036. colorGrading?: IColorGradingConfiguration;
  2037. environmentRotationY?: number;
  2038. /**
  2039. * Deprecated, please use default rendering pipeline
  2040. */
  2041. glow?: boolean | BABYLON.IGlowLayerOptions;
  2042. disableHdr?: boolean;
  2043. renderInBackground?: boolean;
  2044. disableCameraControl?: boolean;
  2045. animationPropertiesOverride?: {
  2046. [propName: string]: any;
  2047. };
  2048. defaultMaterial?: {
  2049. materialType: "standard" | "pbr";
  2050. [propName: string]: any;
  2051. };
  2052. flags?: {
  2053. shadowsEnabled?: boolean;
  2054. particlesEnabled?: boolean;
  2055. collisionsEnabled?: boolean;
  2056. lightsEnabled?: boolean;
  2057. texturesEnabled?: boolean;
  2058. lensFlaresEnabled?: boolean;
  2059. proceduralTexturesEnabled?: boolean;
  2060. renderTargetsEnabled?: boolean;
  2061. spritesEnabled?: boolean;
  2062. skeletonsEnabled?: boolean;
  2063. audioEnabled?: boolean;
  2064. };
  2065. assetsRootURL?: string;
  2066. }
  2067. }
  2068. declare module BabylonViewer {
  2069. export interface ISceneOptimizerConfiguration {
  2070. targetFrameRate?: number;
  2071. trackerDuration?: number;
  2072. autoGeneratePriorities?: boolean;
  2073. improvementMode?: boolean;
  2074. degradation?: string;
  2075. types?: {
  2076. texture?: ISceneOptimizerParameters;
  2077. hardwareScaling?: ISceneOptimizerParameters;
  2078. shadow?: ISceneOptimizerParameters;
  2079. postProcess?: ISceneOptimizerParameters;
  2080. lensFlare?: ISceneOptimizerParameters;
  2081. particles?: ISceneOptimizerParameters;
  2082. renderTarget?: ISceneOptimizerParameters;
  2083. mergeMeshes?: ISceneOptimizerParameters;
  2084. };
  2085. custom?: string;
  2086. }
  2087. export interface ISceneOptimizerParameters {
  2088. priority?: number;
  2089. maximumSize?: number;
  2090. step?: number;
  2091. }
  2092. }
  2093. declare module BabylonViewer {
  2094. export interface ISkyboxConfiguration {
  2095. cubeTexture?: {
  2096. noMipMap?: boolean;
  2097. gammaSpace?: boolean;
  2098. url?: string | Array<string>;
  2099. };
  2100. color?: {
  2101. r: number;
  2102. g: number;
  2103. b: number;
  2104. };
  2105. pbr?: boolean;
  2106. scale?: number;
  2107. blur?: number;
  2108. material?: {
  2109. imageProcessingConfiguration?: IImageProcessingConfiguration;
  2110. [propName: string]: any;
  2111. };
  2112. infiniteDistance?: boolean;
  2113. }
  2114. }
  2115. declare module BabylonViewer {
  2116. /**
  2117. * A single template configuration object
  2118. */
  2119. export interface ITemplateConfiguration {
  2120. /**
  2121. * can be either the id of the template's html element or a URL.
  2122. * See - http://doc.babylonjs.com/extensions/the_templating_system#location-vs-html
  2123. */
  2124. location?: string;
  2125. /**
  2126. * If no location is provided you can provide here the raw html of this template.
  2127. * See http://doc.babylonjs.com/extensions/the_templating_system#location-vs-html
  2128. */
  2129. html?: string;
  2130. id?: string;
  2131. /**
  2132. * Parameters that will be delivered to the template and will render it accordingly.
  2133. */
  2134. params?: {
  2135. [key: string]: string | number | boolean | object;
  2136. };
  2137. /**
  2138. * Events to attach to this template.
  2139. * event name is the key. the value can either be a boolean (attach to the parent element)
  2140. * or a map of html id elements.
  2141. *
  2142. * See - http://doc.babylonjs.com/extensions/the_templating_system#event-binding
  2143. */
  2144. events?: {
  2145. pointerdown?: boolean | {
  2146. [id: string]: boolean;
  2147. };
  2148. pointerup?: boolean | {
  2149. [id: string]: boolean;
  2150. };
  2151. pointermove?: boolean | {
  2152. [id: string]: boolean;
  2153. };
  2154. pointerover?: boolean | {
  2155. [id: string]: boolean;
  2156. };
  2157. pointerout?: boolean | {
  2158. [id: string]: boolean;
  2159. };
  2160. pointerenter?: boolean | {
  2161. [id: string]: boolean;
  2162. };
  2163. pointerleave?: boolean | {
  2164. [id: string]: boolean;
  2165. };
  2166. pointercancel?: boolean | {
  2167. [id: string]: boolean;
  2168. };
  2169. click?: boolean | {
  2170. [id: string]: boolean;
  2171. };
  2172. dragstart?: boolean | {
  2173. [id: string]: boolean;
  2174. };
  2175. drop?: boolean | {
  2176. [id: string]: boolean;
  2177. };
  2178. [key: string]: boolean | {
  2179. [id: string]: boolean;
  2180. } | undefined;
  2181. };
  2182. }
  2183. }
  2184. declare module BabylonViewer {
  2185. export interface IVRConfiguration {
  2186. disabled?: boolean;
  2187. objectScaleFactor?: number;
  2188. disableInteractions?: boolean;
  2189. disableTeleportation?: boolean;
  2190. overrideFloorMeshName?: string;
  2191. vrOptions?: BABYLON.VRExperienceHelperOptions;
  2192. modelHeightCorrection?: number | boolean;
  2193. rotateUsingControllers?: boolean;
  2194. cameraPosition?: {
  2195. x: number;
  2196. y: number;
  2197. z: number;
  2198. };
  2199. }
  2200. }
  2201. declare module BabylonViewer {
  2202. /**
  2203. * Spherical polynomial coefficients (counter part to spherical harmonic coefficients used in shader irradiance calculation)
  2204. * @ignoreChildren
  2205. */
  2206. export interface SphericalPolynomalCoefficients {
  2207. x: BABYLON.Vector3;
  2208. y: BABYLON.Vector3;
  2209. z: BABYLON.Vector3;
  2210. xx: BABYLON.Vector3;
  2211. yy: BABYLON.Vector3;
  2212. zz: BABYLON.Vector3;
  2213. yz: BABYLON.Vector3;
  2214. zx: BABYLON.Vector3;
  2215. xy: BABYLON.Vector3;
  2216. }
  2217. /**
  2218. * Wraps data and maps required for environments with physically based rendering
  2219. */
  2220. export interface PBREnvironment {
  2221. /**
  2222. * Spherical Polynomial Coefficients representing an irradiance map
  2223. */
  2224. irradiancePolynomialCoefficients: SphericalPolynomalCoefficients;
  2225. /**
  2226. * Specular cubemap
  2227. */
  2228. specularTexture?: TextureCube;
  2229. /**
  2230. * A scale factor applied to RGB values after reading from environment maps
  2231. */
  2232. textureIntensityScale: number;
  2233. }
  2234. /**
  2235. * Environment map representations: layouts, projections and approximations
  2236. */
  2237. export type MapType = 'irradiance_sh_coefficients_9' | 'cubemap_faces';
  2238. /**
  2239. * Image type used for environment map
  2240. */
  2241. export type ImageType = 'png';
  2242. /**
  2243. * A generic field in JSON that report's its type
  2244. */
  2245. export interface TypedObject<T> {
  2246. type: T;
  2247. }
  2248. /**
  2249. * Describes a range of bytes starting at byte pos (inclusive) and finishing at byte pos + length - 1
  2250. */
  2251. export interface ByteRange {
  2252. pos: number;
  2253. length: number;
  2254. }
  2255. /**
  2256. * Complete Spectre Environment JSON Descriptor
  2257. */
  2258. export interface EnvJsonDescriptor {
  2259. radiance: TypedObject<MapType>;
  2260. irradiance: TypedObject<MapType>;
  2261. specular: TypedObject<MapType>;
  2262. }
  2263. /**
  2264. * Spherical harmonic coefficients to provide an irradiance map
  2265. */
  2266. export interface IrradianceSHCoefficients9 extends TypedObject<MapType> {
  2267. l00: Array<number>;
  2268. l1_1: Array<number>;
  2269. l10: Array<number>;
  2270. l11: Array<number>;
  2271. l2_2: Array<number>;
  2272. l2_1: Array<number>;
  2273. l20: Array<number>;
  2274. l21: Array<number>;
  2275. l22: Array<number>;
  2276. }
  2277. /**
  2278. * A generic set of images, where the image content is specified by byte ranges in the mipmaps field
  2279. */
  2280. export interface ImageSet<T> extends TypedObject<MapType> {
  2281. imageType: ImageType;
  2282. width: number;
  2283. height: number;
  2284. mipmaps: Array<T>;
  2285. multiplier: number;
  2286. }
  2287. /**
  2288. * A set of cubemap faces
  2289. */
  2290. export type CubemapFaces = ImageSet<Array<ByteRange>>;
  2291. /**
  2292. * A single image containing an atlas of equirectangular-projection maps across all mip levels
  2293. */
  2294. export type EquirectangularMipmapAtlas = ImageSet<ByteRange>;
  2295. /**
  2296. * A static class proving methods to aid parsing Spectre environment files
  2297. */
  2298. export class EnvironmentDeserializer {
  2299. /**
  2300. * Parses an arraybuffer into a new PBREnvironment object
  2301. * @param arrayBuffer The arraybuffer of the Spectre environment file
  2302. * @return a PBREnvironment object
  2303. */
  2304. static Parse(arrayBuffer: ArrayBuffer): PBREnvironment;
  2305. }
  2306. }
  2307. declare module BabylonViewer {
  2308. /**
  2309. * WebGL Pixel Formats
  2310. */
  2311. export const enum PixelFormat {
  2312. DEPTH_COMPONENT = 6402,
  2313. ALPHA = 6406,
  2314. RGB = 6407,
  2315. RGBA = 6408,
  2316. LUMINANCE = 6409,
  2317. LUMINANCE_ALPHA = 6410
  2318. }
  2319. /**
  2320. * WebGL Pixel Types
  2321. */
  2322. export const enum PixelType {
  2323. UNSIGNED_BYTE = 5121,
  2324. UNSIGNED_SHORT_4_4_4_4 = 32819,
  2325. UNSIGNED_SHORT_5_5_5_1 = 32820,
  2326. UNSIGNED_SHORT_5_6_5 = 33635
  2327. }
  2328. /**
  2329. * WebGL Texture Magnification Filter
  2330. */
  2331. export const enum TextureMagFilter {
  2332. NEAREST = 9728,
  2333. LINEAR = 9729
  2334. }
  2335. /**
  2336. * WebGL Texture Minification Filter
  2337. */
  2338. export const enum TextureMinFilter {
  2339. NEAREST = 9728,
  2340. LINEAR = 9729,
  2341. NEAREST_MIPMAP_NEAREST = 9984,
  2342. LINEAR_MIPMAP_NEAREST = 9985,
  2343. NEAREST_MIPMAP_LINEAR = 9986,
  2344. LINEAR_MIPMAP_LINEAR = 9987
  2345. }
  2346. /**
  2347. * WebGL Texture Wrap Modes
  2348. */
  2349. export const enum TextureWrapMode {
  2350. REPEAT = 10497,
  2351. CLAMP_TO_EDGE = 33071,
  2352. MIRRORED_REPEAT = 33648
  2353. }
  2354. /**
  2355. * Raw texture data and descriptor sufficient for WebGL texture upload
  2356. */
  2357. export interface TextureData {
  2358. /**
  2359. * Width of image
  2360. */
  2361. width: number;
  2362. /**
  2363. * Height of image
  2364. */
  2365. height: number;
  2366. /**
  2367. * Format of pixels in data
  2368. */
  2369. format: PixelFormat;
  2370. /**
  2371. * Row byte alignment of pixels in data
  2372. */
  2373. alignment: number;
  2374. /**
  2375. * Pixel data
  2376. */
  2377. data: ArrayBufferView;
  2378. }
  2379. /**
  2380. * Wraps sampling parameters for a WebGL texture
  2381. */
  2382. export interface SamplingParameters {
  2383. /**
  2384. * Magnification mode when upsampling from a WebGL texture
  2385. */
  2386. magFilter?: TextureMagFilter;
  2387. /**
  2388. * Minification mode when upsampling from a WebGL texture
  2389. */
  2390. minFilter?: TextureMinFilter;
  2391. /**
  2392. * X axis wrapping mode when sampling out of a WebGL texture bounds
  2393. */
  2394. wrapS?: TextureWrapMode;
  2395. /**
  2396. * Y axis wrapping mode when sampling out of a WebGL texture bounds
  2397. */
  2398. wrapT?: TextureWrapMode;
  2399. /**
  2400. * Anisotropic filtering samples
  2401. */
  2402. maxAnisotropy?: number;
  2403. }
  2404. /**
  2405. * Represents a valid WebGL texture source for use in texImage2D
  2406. */
  2407. export type TextureSource = TextureData | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
  2408. /**
  2409. * A generic set of texture mipmaps (where index 0 has the largest dimension)
  2410. */
  2411. export type Mipmaps<T> = Array<T>;
  2412. /**
  2413. * A set of 6 cubemap arranged in the order [+x, -x, +y, -y, +z, -z]
  2414. */
  2415. export type Faces<T> = Array<T>;
  2416. /**
  2417. * A set of texture mipmaps specifically for 2D textures in WebGL (where index 0 has the largest dimension)
  2418. */
  2419. export type Mipmaps2D = Mipmaps<TextureSource>;
  2420. /**
  2421. * A set of texture mipmaps specifically for cubemap textures in WebGL (where index 0 has the largest dimension)
  2422. */
  2423. export type MipmapsCube = Mipmaps<Faces<TextureSource>>;
  2424. /**
  2425. * A minimal WebGL cubemap descriptor
  2426. */
  2427. export class TextureCube {
  2428. internalFormat: PixelFormat;
  2429. type: PixelType;
  2430. source: MipmapsCube;
  2431. /**
  2432. * Returns the width of a face of the texture or 0 if not available
  2433. */
  2434. readonly Width: number;
  2435. /**
  2436. * Returns the height of a face of the texture or 0 if not available
  2437. */
  2438. readonly Height: number;
  2439. /**
  2440. * constructor
  2441. * @param internalFormat WebGL pixel format for the texture on the GPU
  2442. * @param type WebGL pixel type of the supplied data and texture on the GPU
  2443. * @param source An array containing mipmap levels of faces, where each mipmap level is an array of faces and each face is a TextureSource object
  2444. */
  2445. constructor(internalFormat: PixelFormat, type: PixelType, source?: MipmapsCube);
  2446. }
  2447. /**
  2448. * A static class providing methods to aid working with Bablyon textures.
  2449. */
  2450. export class TextureUtils {
  2451. /**
  2452. * A prefix used when storing a babylon texture object reference on a Spectre texture object
  2453. */
  2454. static BabylonTextureKeyPrefix: string;
  2455. /**
  2456. * Controls anisotropic filtering for deserialized textures.
  2457. */
  2458. static MaxAnisotropy: number;
  2459. /**
  2460. * Returns a BabylonCubeTexture instance from a Spectre texture cube, subject to sampling parameters.
  2461. * If such a texture has already been requested in the past, this texture will be returned, otherwise a new one will be created.
  2462. * The advantage of this is to enable working with texture objects without the need to initialize on the GPU until desired.
  2463. * @param scene A Babylon BABYLON.Scene instance
  2464. * @param textureCube A Spectre TextureCube object
  2465. * @param parameters WebGL texture sampling parameters
  2466. * @param automaticMipmaps Pass true to enable automatic mipmap generation where possible (requires power of images)
  2467. * @param environment Specifies that the texture will be used as an environment
  2468. * @param singleLod Specifies that the texture will be a singleLod (for environment)
  2469. * @return Babylon cube texture
  2470. */
  2471. static GetBabylonCubeTexture(scene: BABYLON.Scene, textureCube: TextureCube, automaticMipmaps: boolean, environment?: boolean, singleLod?: boolean): BABYLON.CubeTexture;
  2472. /**
  2473. * Applies Spectre SamplingParameters to a Babylon texture by directly setting texture parameters on the internal WebGLTexture as well as setting Babylon fields
  2474. * @param babylonTexture Babylon texture to apply texture to (requires the Babylon texture has an initialize _texture field)
  2475. * @param parameters Spectre SamplingParameters to apply
  2476. */
  2477. static ApplySamplingParameters(babylonTexture: BABYLON.BaseTexture, parameters: SamplingParameters): void;
  2478. /**
  2479. * Environment preprocessing dedicated value (Internal Use or Advanced only).
  2480. */
  2481. static EnvironmentLODScale: number;
  2482. /**
  2483. * Environment preprocessing dedicated value (Internal Use or Advanced only)..
  2484. */
  2485. static EnvironmentLODOffset: number;
  2486. }
  2487. }