Rename baseEngine to thinEngine

Tools/Publisher/tasks/versionNumberManager.js

@@ -5,13 +5,13 @@ const colorConsole = require("../../NodeHelpers/colorConsole");
 
 // Global Variables.
 const config = require("../../Config/config.js");
-const enginePath = path.join(config.core.computed.mainDirectory, "Engines/baseEngine.ts");
+const enginePath = path.join(config.core.computed.mainDirectory, "Engines/thinEngine.ts");
 
 /**
  * Get the version from the engine class for Babylon
  */
 function getEngineVersion() {
-    colorConsole.log("Get version from baseEngine.ts", enginePath);
+    colorConsole.log("Get version from thinEngine.ts", enginePath);
     const engineContent = fs.readFileSync(enginePath).toString();
 
     const versionRegex = new RegExp(`public static get Version\\(\\): string {\\s*return "(\\S*)";\\s*}`, "gm");
@@ -23,7 +23,7 @@ function getEngineVersion() {
         return version;
     }
 
-    colorConsole.error("Version not found in baseEngine.ts");
+    colorConsole.error("Version not found in thinEngine.ts");
     process.exit(1);
 }
 
@@ -31,7 +31,7 @@ function getEngineVersion() {
  * Update the version in the engine class for Babylon
  */
 function updateEngineVersion(newVersion) {
-    colorConsole.log("Updating version in baseEngine.ts to: " + newVersion.green);
+    colorConsole.log("Updating version in thinEngine.ts to: " + newVersion.green);
     let engineContent = fs.readFileSync(enginePath).toString();
     let replaced = engineContent.replace(/(public static get Version\(\): string {\s*return ")(.*)(";\s*})/g, "$1" + newVersion + "$3");
     replaced = replaced.replace(/(public static get NpmPackage\(\): string {\s*return ")(.*)(";\s*})/g, "$1" + "babylonjs@" + newVersion + "$3");

Viewer/src/configuration/configuration.ts

@@ -1,6 +1,6 @@
 import { ICameraConfiguration, IDefaultRenderingPipelineConfiguration, IGroundConfiguration, ILightConfiguration, IModelConfiguration, IObserversConfiguration, ISceneConfiguration, ISceneOptimizerConfiguration, ISkyboxConfiguration, ITemplateConfiguration, IVRConfiguration } from './interfaces';
 import { IEnvironmentMapConfiguration } from './interfaces/environmentMapConfiguration';
-import { EngineOptions } from 'babylonjs/Engines/baseEngine';
+import { EngineOptions } from 'babylonjs/Engines/thinEngine';
 
 export function getConfigurationKey(key: string, configObject: any) {
     let splits = key.split('.');

src/Engines/Extensions/engine.cubeTexture.ts

@@ -1,4 +1,4 @@
-import { BaseEngine } from "../../Engines/baseEngine";
+import { ThinEngine } from "../../Engines/thinEngine";
 import { InternalTexture } from '../../Materials/Textures/internalTexture';
 import { Logger } from '../../Misc/logger';
 import { Nullable } from '../../types';
@@ -8,8 +8,8 @@ import { WebRequest } from '../../Misc/webRequest';
 import { FileTools } from '../../Misc/fileTools';
 import { DepthTextureCreationOptions } from '../depthTextureCreationOptions';
 
-declare module "../../Engines/baseEngine" {
-    export interface BaseEngine {
+declare module "../../Engines/thinEngine" {
+    export interface ThinEngine {
         /**
          * Creates a depth stencil cube texture.
          * This is only available in WebGL 2.
@@ -89,7 +89,7 @@ declare module "../../Engines/baseEngine" {
     }
 }
 
-BaseEngine.prototype._createDepthStencilCubeTexture = function(size: number, options: DepthTextureCreationOptions): InternalTexture {
+ThinEngine.prototype._createDepthStencilCubeTexture = function(size: number, options: DepthTextureCreationOptions): InternalTexture {
     var internalTexture = new InternalTexture(this, InternalTexture.DATASOURCE_UNKNOWN);
     internalTexture.isCube = true;
 
@@ -125,7 +125,7 @@ BaseEngine.prototype._createDepthStencilCubeTexture = function(size: number, opt
     return internalTexture;
 };
 
-BaseEngine.prototype._partialLoadFile = function(url: string, index: number, loadedFiles: (string | ArrayBuffer)[], onfinish: (files: (string | ArrayBuffer)[]) => void, onErrorCallBack: Nullable<(message?: string, exception?: any) => void> = null): void {
+ThinEngine.prototype._partialLoadFile = function(url: string, index: number, loadedFiles: (string | ArrayBuffer)[], onfinish: (files: (string | ArrayBuffer)[]) => void, onErrorCallBack: Nullable<(message?: string, exception?: any) => void> = null): void {
     var onload = (data: string | ArrayBuffer) => {
         loadedFiles[index] = data;
         (<any>loadedFiles)._internalCount++;
@@ -144,7 +144,7 @@ BaseEngine.prototype._partialLoadFile = function(url: string, index: number, loa
     this._loadFile(url, onload, undefined, undefined, true, onerror);
 };
 
-BaseEngine.prototype._cascadeLoadFiles = function(scene: Nullable<Scene>, onfinish: (images: (string | ArrayBuffer)[]) => void, files: string[], onError: Nullable<(message?: string, exception?: any) => void> = null): void {
+ThinEngine.prototype._cascadeLoadFiles = function(scene: Nullable<Scene>, onfinish: (images: (string | ArrayBuffer)[]) => void, files: string[], onError: Nullable<(message?: string, exception?: any) => void> = null): void {
     var loadedFiles: (string | ArrayBuffer)[] = [];
     (<any>loadedFiles)._internalCount = 0;
 
@@ -153,7 +153,7 @@ BaseEngine.prototype._cascadeLoadFiles = function(scene: Nullable<Scene>, onfini
     }
 };
 
-BaseEngine.prototype._cascadeLoadImgs = function(scene: Nullable<Scene>,
+ThinEngine.prototype._cascadeLoadImgs = function(scene: Nullable<Scene>,
     onfinish: (images: HTMLImageElement[]) => void, files: string[], onError: Nullable<(message?: string, exception?: any) => void> = null) {
 
     var loadedImages: HTMLImageElement[] = [];
@@ -164,7 +164,7 @@ BaseEngine.prototype._cascadeLoadImgs = function(scene: Nullable<Scene>,
     }
 };
 
-BaseEngine.prototype._partialLoadImg = function(url: string, index: number, loadedImages: HTMLImageElement[], scene: Nullable<Scene>,
+ThinEngine.prototype._partialLoadImg = function(url: string, index: number, loadedImages: HTMLImageElement[], scene: Nullable<Scene>,
     onfinish: (images: HTMLImageElement[]) => void, onErrorCallBack: Nullable<(message?: string, exception?: any) => void> = null) {
 
     var img: HTMLImageElement;
@@ -198,7 +198,7 @@ BaseEngine.prototype._partialLoadImg = function(url: string, index: number, load
     }
 };
 
-BaseEngine.prototype.createCubeTexture = function(rootUrl: string, scene: Nullable<Scene>, files: Nullable<string[]>, noMipmap?: boolean, onLoad: Nullable<(data?: any) => void> = null, onError: Nullable<(message?: string, exception?: any) => void> = null, format?: number, forcedExtension: any = null, createPolynomials: boolean = false, lodScale: number = 0, lodOffset: number = 0, fallback: Nullable<InternalTexture> = null, excludeLoaders: Array<IInternalTextureLoader> = []): InternalTexture {
+ThinEngine.prototype.createCubeTexture = function(rootUrl: string, scene: Nullable<Scene>, files: Nullable<string[]>, noMipmap?: boolean, onLoad: Nullable<(data?: any) => void> = null, onError: Nullable<(message?: string, exception?: any) => void> = null, format?: number, forcedExtension: any = null, createPolynomials: boolean = false, lodScale: number = 0, lodOffset: number = 0, fallback: Nullable<InternalTexture> = null, excludeLoaders: Array<IInternalTextureLoader> = []): InternalTexture {
     var gl = this._gl;
 
     var texture = fallback ? fallback : new InternalTexture(this, InternalTexture.DATASOURCE_CUBE);
@@ -217,7 +217,7 @@ BaseEngine.prototype.createCubeTexture = function(rootUrl: string, scene: Nullab
     var extension = forcedExtension ? forcedExtension : (lastDot > -1 ? rootUrl.substring(lastDot).toLowerCase() : "");
 
     let loader: Nullable<IInternalTextureLoader> = null;
-    for (let availableLoader of BaseEngine._TextureLoaders) {
+    for (let availableLoader of ThinEngine._TextureLoaders) {
         if (excludeLoaders.indexOf(availableLoader) === -1 && availableLoader.canLoad(extension, this._textureFormatInUse, fallback, false, false)) {
             loader = availableLoader;
             break;
@@ -269,7 +269,7 @@ BaseEngine.prototype.createCubeTexture = function(rootUrl: string, scene: Nullab
         }
 
         this._cascadeLoadImgs(scene, (imgs) => {
-            var width = this.needPOTTextures ? BaseEngine.GetExponentOfTwo(imgs[0].width, this._caps.maxCubemapTextureSize) : imgs[0].width;
+            var width = this.needPOTTextures ? ThinEngine.GetExponentOfTwo(imgs[0].width, this._caps.maxCubemapTextureSize) : imgs[0].width;
             var height = width;
 
             this._prepareWorkingCanvas();

src/Engines/Extensions/engine.multiRender.ts

@@ -3,10 +3,10 @@ import { IMultiRenderTargetOptions } from '../../Materials/Textures/multiRenderT
 import { Logger } from '../../Misc/logger';
 import { Nullable } from '../../types';
 import { Constants } from '../constants';
-import { BaseEngine } from '../baseEngine';
+import { ThinEngine } from '../thinEngine';
 
-declare module "../../Engines/baseEngine" {
-    export interface BaseEngine {
+declare module "../../Engines/thinEngine" {
+    export interface ThinEngine {
         /**
          * Unbind a list of render target textures from the webGL context
          * This is used only when drawBuffer extension or webGL2 are active
@@ -36,7 +36,7 @@ declare module "../../Engines/baseEngine" {
     }
 }
 
-BaseEngine.prototype.unBindMultiColorAttachmentFramebuffer = function(textures: InternalTexture[], disableGenerateMipMaps: boolean = false, onBeforeUnbind?: () => void): void {
+ThinEngine.prototype.unBindMultiColorAttachmentFramebuffer = function(textures: InternalTexture[], disableGenerateMipMaps: boolean = false, onBeforeUnbind?: () => void): void {
     this._currentRenderTarget = null;
 
     // If MSAA, we need to bitblt back to main texture
@@ -93,7 +93,7 @@ BaseEngine.prototype.unBindMultiColorAttachmentFramebuffer = function(textures:
     this._bindUnboundFramebuffer(null);
 };
 
-BaseEngine.prototype.createMultipleRenderTarget = function(size: any, options: IMultiRenderTargetOptions): InternalTexture[] {
+ThinEngine.prototype.createMultipleRenderTarget = function(size: any, options: IMultiRenderTargetOptions): InternalTexture[] {
     var generateMipMaps = false;
     var generateDepthBuffer = true;
     var generateStencilBuffer = false;
@@ -251,7 +251,7 @@ BaseEngine.prototype.createMultipleRenderTarget = function(size: any, options: I
     return textures;
 };
 
-BaseEngine.prototype.updateMultipleRenderTargetTextureSampleCount = function(textures: Nullable<InternalTexture[]>, samples: number): number {
+ThinEngine.prototype.updateMultipleRenderTargetTextureSampleCount = function(textures: Nullable<InternalTexture[]>, samples: number): number {
     if (this.webGLVersion < 2 || !textures || textures.length == 0) {
         return 1;
     }

src/Engines/Extensions/engine.rawTexture.ts

@@ -6,10 +6,10 @@ import { Tools } from '../../Misc/tools';
 import { Scene } from '../../scene';
 import { WebRequest } from '../../Misc/webRequest';
 import { Constants } from '../constants';
-import { BaseEngine } from '../baseEngine';
+import { ThinEngine } from '../thinEngine';
 
-declare module "../../Engines/baseEngine" {
-    export interface BaseEngine {
+declare module "../../Engines/thinEngine" {
+    export interface ThinEngine {
         /**
          * Creates a raw texture
          * @param data defines the data to store in the texture
@@ -174,7 +174,7 @@ declare module "../../Engines/baseEngine" {
     }
 }
 
-BaseEngine.prototype.updateRawTexture = function(texture: Nullable<InternalTexture>, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression: Nullable<string> = null, type: number = Constants.TEXTURETYPE_UNSIGNED_INT): void {
+ThinEngine.prototype.updateRawTexture = function(texture: Nullable<InternalTexture>, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression: Nullable<string> = null, type: number = Constants.TEXTURETYPE_UNSIGNED_INT): void {
     if (!texture) {
         return;
     }
@@ -213,7 +213,7 @@ BaseEngine.prototype.updateRawTexture = function(texture: Nullable<InternalTextu
     texture.isReady = true;
 };
 
-BaseEngine.prototype.createRawTexture = function(data: Nullable<ArrayBufferView>, width: number, height: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression: Nullable<string> = null, type: number = Constants.TEXTURETYPE_UNSIGNED_INT): InternalTexture {
+ThinEngine.prototype.createRawTexture = function(data: Nullable<ArrayBufferView>, width: number, height: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression: Nullable<string> = null, type: number = Constants.TEXTURETYPE_UNSIGNED_INT): InternalTexture {
     var texture = new InternalTexture(this, InternalTexture.DATASOURCE_RAW);
     texture.baseWidth = width;
     texture.baseHeight = height;
@@ -250,7 +250,7 @@ BaseEngine.prototype.createRawTexture = function(data: Nullable<ArrayBufferView>
     return texture;
 };
 
-BaseEngine.prototype.createRawCubeTexture = function(data: Nullable<ArrayBufferView[]>, size: number, format: number, type: number,
+ThinEngine.prototype.createRawCubeTexture = function(data: Nullable<ArrayBufferView[]>, size: number, format: number, type: number,
     generateMipMaps: boolean, invertY: boolean, samplingMode: number,
     compression: Nullable<string> = null): InternalTexture {
     var gl = this._gl;
@@ -326,7 +326,7 @@ BaseEngine.prototype.createRawCubeTexture = function(data: Nullable<ArrayBufferV
     return texture;
 };
 
-BaseEngine.prototype.updateRawCubeTexture = function(texture: InternalTexture, data: ArrayBufferView[], format: number, type: number, invertY: boolean, compression: Nullable<string> = null, level: number = 0): void {
+ThinEngine.prototype.updateRawCubeTexture = function(texture: InternalTexture, data: ArrayBufferView[], format: number, type: number, invertY: boolean, compression: Nullable<string> = null, level: number = 0): void {
     texture._bufferViewArray = data;
     texture.format = format;
     texture.type = type;
@@ -375,7 +375,7 @@ BaseEngine.prototype.updateRawCubeTexture = function(texture: InternalTexture, d
     texture.isReady = true;
 };
 
-BaseEngine.prototype.createRawCubeTextureFromUrl = function(url: string, scene: Scene, size: number, format: number, type: number, noMipmap: boolean,
+ThinEngine.prototype.createRawCubeTextureFromUrl = function(url: string, scene: Scene, size: number, format: number, type: number, noMipmap: boolean,
     callback: (ArrayBuffer: ArrayBuffer) => Nullable<ArrayBufferView[]>,
     mipmapGenerator: Nullable<((faces: ArrayBufferView[]) => ArrayBufferView[][])>,
     onLoad: Nullable<() => void> = null,
@@ -453,7 +453,7 @@ BaseEngine.prototype.createRawCubeTextureFromUrl = function(url: string, scene:
     return texture;
 };
 
-BaseEngine.prototype.createRawTexture3D = function(data: Nullable<ArrayBufferView>, width: number, height: number, depth: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression: Nullable<string> = null, textureType: number = Constants.TEXTURETYPE_UNSIGNED_INT): InternalTexture {
+ThinEngine.prototype.createRawTexture3D = function(data: Nullable<ArrayBufferView>, width: number, height: number, depth: number, format: number, generateMipMaps: boolean, invertY: boolean, samplingMode: number, compression: Nullable<string> = null, textureType: number = Constants.TEXTURETYPE_UNSIGNED_INT): InternalTexture {
     var texture = new InternalTexture(this, InternalTexture.DATASOURCE_RAW3D);
     texture.baseWidth = width;
     texture.baseHeight = height;
@@ -491,7 +491,7 @@ BaseEngine.prototype.createRawTexture3D = function(data: Nullable<ArrayBufferVie
     return texture;
 };
 
-BaseEngine.prototype.updateRawTexture3D = function(texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression: Nullable<string> = null, textureType: number = Constants.TEXTURETYPE_UNSIGNED_INT): void {
+ThinEngine.prototype.updateRawTexture3D = function(texture: InternalTexture, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression: Nullable<string> = null, textureType: number = Constants.TEXTURETYPE_UNSIGNED_INT): void {
     var internalType = this._getWebGLTextureType(textureType);
     var internalFormat = this._getInternalFormat(format);
     var internalSizedFomat = this._getRGBABufferInternalSizedFormat(textureType, format);

src/Engines/Extensions/engine.renderTarget.ts

@@ -2,10 +2,10 @@ import { InternalTexture } from '../../Materials/Textures/internalTexture';
 import { Logger } from '../../Misc/logger';
 import { RenderTargetCreationOptions } from '../../Materials/Textures/renderTargetCreationOptions';
 import { Constants } from '../constants';
-import { BaseEngine } from '../baseEngine';
+import { ThinEngine } from '../thinEngine';
 
-declare module "../../Engines/baseEngine" {
-    export interface BaseEngine {
+declare module "../../Engines/thinEngine" {
+    export interface ThinEngine {
         /**
          * Creates a new render target cube texture
          * @param size defines the size of the texture
@@ -16,7 +16,7 @@ declare module "../../Engines/baseEngine" {
     }
 }
 
-BaseEngine.prototype.createRenderTargetCubeTexture = function(size: number, options?: Partial<RenderTargetCreationOptions>): InternalTexture {
+ThinEngine.prototype.createRenderTargetCubeTexture = function(size: number, options?: Partial<RenderTargetCreationOptions>): InternalTexture {
     let fullOptions = {
         generateMipMaps: true,
         generateDepthBuffer: true,

src/Engines/WebGL/webGLPipelineContext.ts

@@ -1,10 +1,10 @@
 import { IPipelineContext } from '../IPipelineContext';
 import { Nullable } from '../../types';
-import { BaseEngine } from '../baseEngine';
+import { ThinEngine } from '../thinEngine';
 
 /** @hidden */
 export class WebGLPipelineContext implements IPipelineContext {
-    public engine: BaseEngine;
+    public engine: ThinEngine;
     public program: Nullable<WebGLProgram>;
     public context?: WebGLRenderingContext;
     public vertexShader?: WebGLShader;

src/Engines/engine.ts

@@ -13,7 +13,7 @@ import { _DevTools } from '../Misc/devTools';
 import { WebGLPipelineContext } from './WebGL/webGLPipelineContext';
 import { IPipelineContext } from './IPipelineContext';
 import { ICustomAnimationFrameRequester } from '../Misc/customAnimationFrameRequester';
-import { BaseEngine, EngineOptions } from './baseEngine';
+import { ThinEngine, EngineOptions } from './thinEngine';
 import { Constants } from './constants';
 import { PerformanceMonitor } from '../Misc';
 
@@ -34,7 +34,7 @@ export interface IDisplayChangedEventArgs {
 /**
  * The engine class is responsible for interfacing with all lower-level APIs such as WebGL and Audio
  */
-export class Engine extends BaseEngine {
+export class Engine extends ThinEngine {
     // Const statics
 
     /** Defines that alpha blending is disabled */
@@ -243,14 +243,14 @@ export class Engine extends BaseEngine {
      */
     // Not mixed with Version for tooling purpose.
     public static get NpmPackage(): string {
-        return BaseEngine.NpmPackage;
+        return ThinEngine.NpmPackage;
     }
 
     /**
      * Returns the current version of the framework
      */
     public static get Version(): string {
-        return BaseEngine.Version;
+        return ThinEngine.Version;
     }
 
     /** Gets the list of created engines */

src/Engines/index.ts

@@ -1,7 +1,7 @@
 export * from "./constants";
 export * from "./engineCapabilities";
 export * from "./instancingAttributeInfo";
-export * from "./baseEngine";
+export * from "./thinEngine";
 export * from "./engine";
 export * from "./engine.backwardCompatibility";
 export * from "./engineStore";

src/Engines/nativeEngine.ts

@@ -20,7 +20,7 @@ import { WebRequest } from '../Misc/webRequest';
 import { NativeShaderProcessor } from './Native/nativeShaderProcessor';
 import { Logger } from "../Misc/logger";
 import { Constants } from './constants';
-import { BaseEngine } from './baseEngine';
+import { ThinEngine } from './thinEngine';
 import { EngineCapabilities } from './engineCapabilities';
 
 interface INativeEngine {
@@ -381,8 +381,8 @@ export class NativeEngine extends Engine {
     public createShaderProgram(pipelineContext: IPipelineContext, vertexCode: string, fragmentCode: string, defines: Nullable<string>, context?: WebGLRenderingContext, transformFeedbackVaryings: Nullable<string[]> = null): any {
         this.onBeforeShaderCompilationObservable.notifyObservers(this);
         const program = this._native.createProgram(
-            BaseEngine._ConcatenateShader(vertexCode, defines),
-            BaseEngine._ConcatenateShader(fragmentCode, defines)
+            ThinEngine._ConcatenateShader(vertexCode, defines),
+            ThinEngine._ConcatenateShader(fragmentCode, defines)
         );
         this.onAfterShaderCompilationObservable.notifyObservers(this);
         return program;

src/Engines/baseEngine.ts

@@ -118,7 +118,7 @@ export interface EngineOptions extends WebGLContextAttributes {
 /**
  * The base engine class (root of all engines)
  */
-export class BaseEngine {
+export class ThinEngine {
     /** Use this array to turn off some WebGL2 features on known buggy browsers version */
     public static ExceptionList = [
         { key: "Chrome\/63\.0", capture: "63\\.0\\.3239\\.(\\d+)", captureConstraint: 108, targets: ["uniformBuffer"] },

src/Materials/Textures/internalTexture.ts

@@ -7,7 +7,7 @@ import { _DepthCullingState, _StencilState, _AlphaState } from "../../States/ind
 import { Constants } from "../../Engines/constants";
 import { _DevTools } from '../../Misc/devTools';
 
-declare type BaseEngine = import("../../Engines/baseEngine").BaseEngine;
+declare type ThinEngine = import("../../Engines/thinEngine").ThinEngine;
 declare type BaseTexture = import("../../Materials/Textures/baseTexture").BaseTexture;
 
 /**
@@ -237,13 +237,13 @@ export class InternalTexture {
     /** @hidden */
     public _references: number = 1;
 
-    private _engine: BaseEngine;
+    private _engine: ThinEngine;
 
     /**
      * Gets the Engine the texture belongs to.
      * @returns The babylon engine
      */
-    public getEngine(): BaseEngine {
+    public getEngine(): ThinEngine {
         return this._engine;
     }
 
@@ -260,7 +260,7 @@ export class InternalTexture {
      * @param dataSource defines the type of data that will be used
      * @param delayAllocation if the texture allocation should be delayed (default: false)
      */
-    constructor(engine: BaseEngine, dataSource: number, delayAllocation = false) {
+    constructor(engine: ThinEngine, dataSource: number, delayAllocation = false) {
         this._engine = engine;
         this._dataSource = dataSource;
 

src/Materials/effect.ts

@@ -8,7 +8,7 @@ import { IPipelineContext } from '../Engines/IPipelineContext';
 import { DataBuffer } from '../Meshes/dataBuffer';
 import { ShaderProcessor } from '../Engines/Processors/shaderProcessor';
 import { IMatrixLike, IVector2Like, IVector3Like, IVector4Like, IColor3Like, IColor4Like } from '../Maths/math.like';
-import { BaseEngine } from '../Engines/baseEngine';
+import { ThinEngine } from '../Engines/thinEngine';
 
 declare type Engine = import("../Engines/engine").Engine;
 declare type InternalTexture = import("../Materials/Textures/internalTexture").InternalTexture;
@@ -290,7 +290,8 @@ export class Effect implements IDisposable {
      * @param onError Callback that will be called if an error occurs during shader compilation.
      * @param indexParameters Parameters to be used with Babylons include syntax to iterate over an array (eg. {lights: 10})
      */
-    constructor(baseName: any, attributesNamesOrOptions: string[] | EffectCreationOptions, uniformsNamesOrEngine: string[] | BaseEngine, samplers: Nullable<string[]> = null, engine?: BaseEngine, defines: Nullable<string> = null,
+    constructor(baseName: any, attributesNamesOrOptions: string[] | EffectCreationOptions, uniformsNamesOrEngine: string[] | ThinEngine, samplers: Nullable<string[]> = null, 
+        engine?: ThinEngine, defines: Nullable<string> = null,
         fallbacks: Nullable<EffectFallbacks> = null, onCompiled: Nullable<(effect: Effect) => void> = null, onError: Nullable<(effect: Effect, errors: string) => void> = null, indexParameters?: any) {
         this.name = baseName;
 

src/Misc/dds.ts

@@ -9,7 +9,7 @@ import { Scene } from '../scene';
 import { BaseTexture } from '../Materials/Textures/baseTexture';
 
 import "../Engines/Extensions/engine.cubeTexture";
-import { BaseEngine } from '../Engines/baseEngine';
+import { ThinEngine } from '../Engines/thinEngine';
 
 // Based on demo done by Brandon Jones - http://media.tojicode.com/webgl-samples/dds.html
 // All values and structures referenced from:
@@ -445,7 +445,7 @@ export class DDSTools {
      * Uploads DDS Levels to a Babylon Texture
      * @hidden
      */
-    public static UploadDDSLevels(engine: BaseEngine, texture: InternalTexture, arrayBuffer: any, info: DDSInfo, loadMipmaps: boolean, faces: number, lodIndex = -1, currentFace?: number) {
+    public static UploadDDSLevels(engine: ThinEngine, texture: InternalTexture, arrayBuffer: any, info: DDSInfo, loadMipmaps: boolean, faces: number, lodIndex = -1, currentFace?: number) {
         var sphericalPolynomialFaces: Nullable<Array<ArrayBufferView>> = null;
         if (info.sphericalPolynomial) {
             sphericalPolynomialFaces = new Array<ArrayBufferView>();
@@ -661,8 +661,8 @@ export class DDSTools {
     }
 }
 
-declare module "../Engines/baseEngine" {
-    export interface BaseEngine {
+declare module "../Engines/thinEngine" {
+    export interface ThinEngine {
         /**
          * Create a cube texture from prefiltered data (ie. the mipmaps contain ready to use data for PBR reflection)
          * @param rootUrl defines the url where the file to load is located
@@ -697,7 +697,7 @@ declare module "../Engines/baseEngine" {
  * @param createPolynomials defines wheter or not to create polynomails harmonics for the texture
  * @returns the cube texture as an InternalTexture
  */
-BaseEngine.prototype.createPrefilteredCubeTexture = function(rootUrl: string, scene: Nullable<Scene>, lodScale: number, lodOffset: number,
+ThinEngine.prototype.createPrefilteredCubeTexture = function(rootUrl: string, scene: Nullable<Scene>, lodScale: number, lodOffset: number,
     onLoad: Nullable<(internalTexture: Nullable<InternalTexture>) => void> = null,
     onError: Nullable<(message?: string, exception?: any) => void> = null,
     format?: number, forcedExtension: any = null,

tests/es6Modules/baseEngineOnly.ts

@@ -1,4 +0,0 @@
-import { BaseEngine } from "@babylonjs/core/Engines/baseEngine";
-
-const canvas = document.getElementById("renderCanvas") as HTMLCanvasElement;
-new BaseEngine(canvas);

tests/es6Modules/thinEngineOnly.ts

@@ -0,0 +1,4 @@
+import { ThinEngine } from "@babylonjs/core/Engines/thinEngine";
+
+const canvas = document.getElementById("renderCanvas") as HTMLCanvasElement;
+new ThinEngine(canvas);

tests/es6Modules/webpack.config.js

@@ -4,7 +4,7 @@ const config = require("../../Tools/Config/config");
 module.exports = {
     context: path.resolve(__dirname),
     entry: {
-        baseEngineOnly: path.resolve(__dirname, 'baseEngineOnly.ts'),
+        thinEngineOnly: path.resolve(__dirname, 'thinEngineOnly.ts'),
         // engineOnly: path.resolve(__dirname, 'engineOnly.ts'),
         // sceneOnly: path.resolve(__dirname, 'sceneOnly.ts'),
         // minGridMaterial: path.resolve(__dirname, 'minGridMaterial.ts'),