Usue single type to resiolve drawmode

src/Engine/babylon.engine.ts

@@ -2408,41 +2408,72 @@
         }
 
         public draw(useTriangles: boolean, indexStart: number, indexCount: number, instancesCount?: number): void {
-            this.drawElementsType(useTriangles ? Engine.DrawType.TRIANGLES : Engine.DrawType.LINES, indexStart, indexCount, instancesCount);
+            this.drawElementsType(useTriangles ? Material.TriangleFillMode : Material.WireFrameFillMode, indexStart, indexCount, instancesCount);
         }
 
         public drawPointClouds(verticesStart: number, verticesCount: number, instancesCount?: number): void {
-            this.drawArraysType(Engine.DrawType.POINTS, verticesStart, verticesCount, instancesCount);
+            this.drawArraysType(Material.PointFillMode, verticesStart, verticesCount, instancesCount);
         }
 
         public drawUnIndexed(useTriangles: boolean, verticesStart: number, verticesCount: number, instancesCount?: number): void {
-            this.drawArraysType(useTriangles ? Engine.DrawType.TRIANGLES : Engine.DrawType.LINES, verticesStart, verticesCount, instancesCount);
+            this.drawArraysType(useTriangles ? Material.TriangleFillMode : Material.WireFrameFillMode, verticesStart, verticesCount, instancesCount);
         }
 
-        public drawElementsType(type: Engine.DrawType, indexStart: number, indexCount: number, instancesCount?: number): void {
+        public drawElementsType(fillMode: number, indexStart: number, indexCount: number, instancesCount?: number): void {
             // Apply states
             this.applyStates();
 
             this._drawCalls.addCount(1, false);
             // Render
+
+            const drawMode = this.DrawMode(fillMode);
             var indexFormat = this._uintIndicesCurrentlySet ? this._gl.UNSIGNED_INT : this._gl.UNSIGNED_SHORT;
             var mult = this._uintIndicesCurrentlySet ? 4 : 2;
             if (instancesCount) {
-                this._gl.drawElementsInstanced(type, indexCount, indexFormat, indexStart * mult, instancesCount);
+                this._gl.drawElementsInstanced(drawMode, indexCount, indexFormat, indexStart * mult, instancesCount);
             } else {
-                this._gl.drawElements(type, indexCount, indexFormat, indexStart * mult);
+                this._gl.drawElements(drawMode, indexCount, indexFormat, indexStart * mult);
             }
         }
 
-        public drawArraysType(type: Engine.DrawType, verticesStart: number, verticesCount: number, instancesCount?: number): void {
+        public drawArraysType(fillMode: number, verticesStart: number, verticesCount: number, instancesCount?: number): void {
             // Apply states
             this.applyStates();
             this._drawCalls.addCount(1, false);
 
+            const drawMode = this.DrawMode(fillMode);
             if (instancesCount) {
-                this._gl.drawArraysInstanced(type, verticesStart, verticesCount, instancesCount);
+                this._gl.drawArraysInstanced(drawMode, verticesStart, verticesCount, instancesCount);
             } else {
-                this._gl.drawArrays(type, verticesStart, verticesCount);
+                this._gl.drawArrays(drawMode, verticesStart, verticesCount);
+            }
+        }
+
+        private DrawMode(fillMode: number): number
+        {
+            switch (fillMode) {
+                // Triangle views
+                case Material.TriangleFillMode:
+                    return this._gl.TRIANGLES;
+                case Material.PointFillMode:
+                    return this._gl.POINTS;
+                case Material.WireFrameFillMode:
+                    return this._gl.LINES;
+                // Draw modes
+                case Material.PointListDrawMode:
+                    return this._gl.POINTS
+                case Material.LineListDrawMode:
+                    return this._gl.LINES;
+                case Material.LineLoopDrawMode:
+                    return this._gl.LINE_LOOP
+                case Material.LineStripDrawMode:
+                    return this._gl.LINE_STRIP
+                case Material.TriangleStripDrawMode:
+                    return this._gl.TRIANGLE_STRIP
+                case Material.TriangleFanDrawMode:
+                    return this._gl.TRIANGLE_FAN;
+                default:
+                    return this._gl.TRIANGLES;
             }
         }
 
@@ -5397,16 +5428,4 @@
             }
         }
     }
-
-    export namespace Engine {
-        export enum DrawType {
-            POINTS = 0,
-            LINES = 1,
-            LINE_LOOP = 2,
-            LINE_STRIP = 3,
-            TRIANGLES = 4,
-            TRIANGLE_STRIP = 5,
-            TRIANGLE_FAN = 6,
-        }
-    }
 }

src/Engine/babylon.nullEngine.ts

@@ -258,10 +258,10 @@
         public draw(useTriangles: boolean, indexStart: number, indexCount: number, instancesCount?: number): void {
         }
 
-        public drawElementsType(type: Engine.DrawType, indexStart: number, indexCount: number, instancesCount?: number): void {
+        public drawElementsType(fillMode: number, indexStart: number, indexCount: number, instancesCount?: number): void {
         }
 
-        public drawArraysType(type: Engine.DrawType, verticesStart: number, verticesCount: number, instancesCount?: number): void {
+        public drawArraysType(fillMode: number, verticesStart: number, verticesCount: number, instancesCount?: number): void {
         }
 
         public _createTexture(): WebGLTexture {

src/Layer/babylon.highlightlayer.ts

@@ -691,12 +691,12 @@
             if (this.outerGlow) {
                 currentEffect.setFloat("offset", 0);
                 engine.setStencilFunction(Engine.NOTEQUAL);
-                engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                engine.drawElementsType(Material.TriangleFillMode, 0, 6);
             }
             if (this.innerGlow) {
                 currentEffect.setFloat("offset", 1);
                 engine.setStencilFunction(Engine.EQUAL);
-                engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                engine.drawElementsType(Material.TriangleFillMode, 0, 6);
             }
 
             // Restore Cache

src/Layer/babylon.layer.ts

@@ -152,11 +152,11 @@
             // Draw order
             if (!this.alphaTest) {
                 engine.setAlphaMode(this.alphaBlendingMode);
-                engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                engine.drawElementsType(Material.TriangleFillMode, 0, 6);
                 engine.setAlphaMode(Engine.ALPHA_DISABLE);
             }
             else {
-                engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                engine.drawElementsType(Material.TriangleFillMode, 0, 6);
             }
 
             this.onAfterRenderObservable.notifyObservers(this);

src/LensFlare/babylon.lensFlareSystem.ts

@@ -234,7 +234,7 @@
                 this._effect.setFloat4("color", flare.color.r * intensity, flare.color.g * intensity, flare.color.b * intensity, 1.0);
 
                 // Draw order
-                engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                engine.drawElementsType(Material.TriangleFillMode, 0, 6);
             }
 
             engine.setDepthBuffer(true);

src/Materials/Textures/Procedurals/babylon.proceduralTexture.ts

@@ -335,7 +335,7 @@
                     engine.clear(scene.clearColor, true, true, true);
 
                     // Draw order
-                    engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                    engine.drawElementsType(Material.TriangleFillMode, 0, 6);
 
                     // Mipmaps
                     if (face === 5) {
@@ -352,7 +352,7 @@
                 engine.clear(scene.clearColor, true, true, true);
 
                 // Draw order
-                engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                engine.drawElementsType(Material.TriangleFillMode, 0, 6);
             }
 
             // Unbind

src/Materials/babylon.material.ts

@@ -402,33 +402,6 @@
             this.markAsDirty(Material.MiscDirtyFlag);
         }
 
-        public static fillModeToDrawType(fillMode: number): Engine.DrawType {
-            switch (fillMode) {
-                // Triangle views
-                case Material.TriangleFillMode:
-                    return Engine.DrawType.TRIANGLES;
-                case Material.PointFillMode:
-                    return Engine.DrawType.POINTS;
-                case Material.WireFrameFillMode:
-                    return Engine.DrawType.LINES;
-                // Draw modes
-                case Material.PointListDrawMode:
-                    return Engine.DrawType.POINTS
-                case Material.LineListDrawMode:
-                    return Engine.DrawType.LINES;
-                case Material.LineLoopDrawMode:
-                    return Engine.DrawType.LINE_LOOP
-                case Material.LineStripDrawMode:
-                    return Engine.DrawType.LINE_STRIP
-                case Material.TriangleStripDrawMode:
-                    return Engine.DrawType.TRIANGLE_STRIP
-                case Material.TriangleFanDrawMode:
-                    return Engine.DrawType.TRIANGLE_FAN;
-                default:
-                    return Engine.DrawType.TRIANGLES;
-            }
-        }
-
         public _effect: Nullable<Effect>;
         public _wasPreviouslyReady = false;
         private _useUBO: boolean;

src/Mesh/babylon.linesMesh.ts

@@ -112,7 +112,7 @@
             var engine = this.getScene().getEngine();
 
             // Draw order
-            engine.drawElementsType(Engine.DrawType.LINES, subMesh.indexStart, subMesh.indexCount);
+            engine.drawElementsType(Material.LineListDrawMode, subMesh.indexStart, subMesh.indexCount);
             return this;
         }
 

src/Mesh/babylon.mesh.ts

@@ -1061,15 +1061,14 @@
             let scene = this.getScene();
             let engine = scene.getEngine();
 
-            var drawType: Engine.DrawType = Material.fillModeToDrawType(fillMode);
             if (this._unIndexed || fillMode == Material.PointFillMode) {
                 // or triangles as points
-                engine.drawArraysType(drawType, subMesh.verticesStart, subMesh.verticesCount, instancesCount);
+                engine.drawArraysType(fillMode, subMesh.verticesStart, subMesh.verticesCount, instancesCount);
             } else if (fillMode == Material.WireFrameFillMode) {
                 // Triangles as wireframe
-                engine.drawElementsType(drawType, 0, subMesh.linesIndexCount, instancesCount);
+                engine.drawElementsType(fillMode, 0, subMesh.linesIndexCount, instancesCount);
             } else {
-                engine.drawElementsType(drawType, subMesh.indexStart, subMesh.indexCount, instancesCount);
+                engine.drawElementsType(fillMode, subMesh.indexStart, subMesh.indexCount, instancesCount);
             }
 
             if (scene._isAlternateRenderingEnabled && !alternate) {

src/Particles/babylon.gpuParticleSystem.ts

@@ -151,7 +151,7 @@
             this._engine.bindTransformFeedbackBuffer(this._targetBuffer.getBuffer());
             this._engine.setRasterizerState(false);
             this._engine.beginTransformFeedback();
-            this._engine.drawArraysType(Engine.DrawType.POINTS, 0, this._capacity);
+            this._engine.drawArraysType(Material.PointListDrawMode, 0, this._capacity);
             this._engine.endTransformFeedback();
             this._engine.setRasterizerState(true);
             this._engine.bindTransformFeedbackBuffer(null);
@@ -163,7 +163,7 @@
             this._engine.bindVertexArrayObject(this._targetVAO, null);
 
             // Render
-            this._engine.drawArraysType(Engine.DrawType.POINTS, 0, this._capacity);            
+            this._engine.drawArraysType(Material.PointListDrawMode, 0, this._capacity);            
 
             // Switch VAOs
             let tmpVAO = this._sourceVAO;

src/Particles/babylon.particleSystem.ts

@@ -560,7 +560,7 @@
                 engine.setDepthWrite(true);
             }
 
-            engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, this.particles.length * 6);
+            engine.drawElementsType(Material.TriangleFillMode, 0, this.particles.length * 6);
             engine.setAlphaMode(Engine.ALPHA_DISABLE);
 
             return this.particles.length;

src/PostProcess/babylon.postProcessManager.ts

@@ -95,7 +95,7 @@
                     engine.bindBuffers(this._vertexBuffers, this._indexBuffer, effect);
 
                     // Draw order
-                    engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                    engine.drawElementsType(Material.TriangleFillMode, 0, 6);
 
                     pp.onAfterRenderObservable.notifyObservers(effect);
                 }
@@ -145,7 +145,7 @@
                     engine.bindBuffers(this._vertexBuffers, this._indexBuffer, effect);
 
                     // Draw order
-                    engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, 6);
+                    engine.drawElementsType(Material.TriangleFillMode, 0, 6);
 
                     pp.onAfterRenderObservable.notifyObservers(effect);
                 }

src/Rendering/babylon.boundingBoxRenderer.ts

@@ -85,7 +85,7 @@
                     this._colorShader.bind(worldMatrix);
 
                     // Draw order
-                    engine.drawElementsType(Engine.DrawType.LINES, 0, 24);
+                    engine.drawElementsType(Material.TriangleFillMode, 0, 24);
                 }
 
                 // Front
@@ -95,7 +95,7 @@
                 this._colorShader.bind(worldMatrix);
 
                 // Draw order
-                engine.drawElementsType(Engine.DrawType.LINES, 0, 24);
+                engine.drawElementsType(Material.TriangleFillMode, 0, 24);
             }
             this._colorShader.unbind();
             engine.setDepthFunctionToLessOrEqual();
@@ -131,7 +131,7 @@
             this._scene.resetCachedMaterial();
             this._colorShader.bind(worldMatrix);
 
-            engine.drawElementsType(Engine.DrawType.LINES, 0, 24);
+            engine.drawElementsType(Material.TriangleFillMode, 0, 24);
 
             this._colorShader.unbind();
             engine.setDepthFunctionToLessOrEqual();

src/Rendering/babylon.edgesRenderer.ts

@@ -324,7 +324,7 @@
             this._lineShader.bind(this._source.getWorldMatrix());
 
             // Draw order
-            engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, this._indicesCount);
+            engine.drawElementsType(Material.TriangleFillMode, 0, this._indicesCount);
             this._lineShader.unbind();
             engine.setDepthWrite(true);
         }

src/Sprites/babylon.spriteManager.ts

@@ -250,12 +250,12 @@
             engine.setDepthFunctionToLessOrEqual();
             effect.setBool("alphaTest", true);
             engine.setColorWrite(false);
-            engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, max * 6);
+            engine.drawElementsType(Material.TriangleFillMode, 0, max * 6);
             engine.setColorWrite(true);
             effect.setBool("alphaTest", false);
 
             engine.setAlphaMode(Engine.ALPHA_COMBINE);
-            engine.drawElementsType(Engine.DrawType.TRIANGLES, 0, max * 6);
+            engine.drawElementsType(Material.TriangleFillMode, 0, max * 6);
             engine.setAlphaMode(Engine.ALPHA_DISABLE);
         }