@itwin/core-frontend 3.0.0-dev.98 → 3.0.0

package/lib/cjs/render/webgl/Mesh.js

@@ -7,90 +7,37 @@
  * @module WebGL
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SurfaceGeometry = exports.wantMaterials = exports.PolylineEdgeGeometry = exports.SilhouetteEdgeGeometry = exports.EdgeGeometry = exports.MeshGeometry = exports.MeshGraphic = exports.MeshRenderGeometry = exports.MeshData = void 0;
+exports.MeshGraphic = exports.MeshRenderGeometry = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
-const core_common_1 = require("@itwin/core-common");
-const VertexTable_1 = require("../primitives/VertexTable");
-const RenderMemory_1 = require("../RenderMemory");
-const AttributeMap_1 = require("./AttributeMap");
+const SurfaceParams_1 = require("../primitives/SurfaceParams");
 const CachedGeometry_1 = require("./CachedGeometry");
-const LineCode_1 = require("./LineCode");
-const GL_1 = require("./GL");
 const Graphic_1 = require("./Graphic");
-const AttributeBuffers_1 = require("./AttributeBuffers");
 const InstancedGeometry_1 = require("./InstancedGeometry");
-const Material_1 = require("./Material");
 const Primitive_1 = require("./Primitive");
-const System_1 = require("./System");
-const VertexLUT_1 = require("./VertexLUT");
-/** @internal */
-class MeshData {
-    constructor(lut, params, viOrigin) {
-        this.lut = lut;
-        this.viewIndependentOrigin = viOrigin;
-        this.hasFeatures = core_common_1.FeatureIndexType.Empty !== params.vertices.featureIndexType;
-        if (core_common_1.FeatureIndexType.Uniform === params.vertices.featureIndexType)
-            this.uniformFeatureId = params.vertices.uniformFeatureID;
-        if (undefined !== params.surface.textureMapping) {
-            this.texture = params.surface.textureMapping.texture;
-            this._textureAlwaysDisplayed = params.surface.textureMapping.alwaysDisplayed;
-        }
-        else {
-            this.texture = undefined;
-            this._textureAlwaysDisplayed = false;
-        }
-        this.materialInfo = (0, Material_1.createMaterialInfo)(params.surface.material);
-        this.type = params.surface.type;
-        this.fillFlags = params.surface.fillFlags;
-        this.isPlanar = params.isPlanar;
-        this.hasBakedLighting = params.surface.hasBakedLighting;
-        this.hasFixedNormals = params.surface.hasFixedNormals;
-        const edges = params.edges;
-        this.edgeWidth = undefined !== edges ? edges.weight : 1;
-        this.edgeLineCode = LineCode_1.LineCode.valueFromLinePixels(undefined !== edges ? edges.linePixels : core_common_1.LinePixels.Solid);
-    }
-    static create(params, viOrigin) {
-        const lut = VertexLUT_1.VertexLUT.createFromVertexTable(params.vertices, params.auxChannels);
-        return undefined !== lut ? new MeshData(lut, params, viOrigin) : undefined;
-    }
-    get isDisposed() { return undefined === this.texture && this.lut.isDisposed; }
-    dispose() {
-        (0, core_bentley_1.dispose)(this.lut);
-        if (this._ownsTexture)
-            this.texture.dispose();
-    }
-    get isGlyph() { return undefined !== this.texture && this.texture.isGlyph; }
-    get isTextureAlwaysDisplayed() { return this.isGlyph || this._textureAlwaysDisplayed; }
-    // Returns true if no one else owns this texture. Implies that the texture should be disposed when this object is disposed, and the texture's memory should be tracked as belonging to this object.
-    get _ownsTexture() {
-        var _a;
-        return undefined !== this.texture && !((_a = this.texture) === null || _a === void 0 ? void 0 : _a.hasOwner);
-    }
-    collectStatistics(stats) {
-        stats.addVertexTable(this.lut.bytesUsed);
-        if (this._ownsTexture)
-            stats.addTexture(this.texture.bytesUsed);
-    }
-}
-exports.MeshData = MeshData;
+const EdgeGeometry_1 = require("./EdgeGeometry");
+const IndexedEdgeGeometry_1 = require("./IndexedEdgeGeometry");
+const SurfaceGeometry_1 = require("./SurfaceGeometry");
+const MeshData_1 = require("./MeshData");
 /** @internal */
 class MeshRenderGeometry {
     constructor(data, params) {
         this.data = data;
         this.range = params.vertices.qparams.computeRange();
-        this.surface = SurfaceGeometry.create(data, params.surface.indices);
+        this.surface = SurfaceGeometry_1.SurfaceGeometry.create(data, params.surface.indices);
         const edges = params.edges;
-        if (!edges || data.type === VertexTable_1.SurfaceType.VolumeClassifier)
+        if (!edges || data.type === SurfaceParams_1.SurfaceType.VolumeClassifier)
             return;
         if (edges.silhouettes)
-            this.silhouetteEdges = SilhouetteEdgeGeometry.createSilhouettes(data, edges.silhouettes);
+            this.silhouetteEdges = EdgeGeometry_1.SilhouetteEdgeGeometry.createSilhouettes(data, edges.silhouettes);
         if (edges.segments)
-            this.segmentEdges = EdgeGeometry.create(data, edges.segments);
+            this.segmentEdges = EdgeGeometry_1.EdgeGeometry.create(data, edges.segments);
         if (edges.polylines)
-            this.polylineEdges = PolylineEdgeGeometry.create(data, edges.polylines);
+            this.polylineEdges = EdgeGeometry_1.PolylineEdgeGeometry.create(data, edges.polylines);
+        if (edges.indexed)
+            this.indexedEdges = IndexedEdgeGeometry_1.IndexedEdgeGeometry.create(data, edges.indexed);
     }
     static create(params, viewIndependentOrigin) {
-        const data = MeshData.create(params, viewIndependentOrigin);
+        const data = MeshData_1.MeshData.create(params, viewIndependentOrigin);
         return data ? new this(data, params) : undefined;
     }
     dispose() {
@@ -99,14 +46,16 @@ class MeshRenderGeometry {
         (0, core_bentley_1.dispose)(this.segmentEdges);
         (0, core_bentley_1.dispose)(this.silhouetteEdges);
         (0, core_bentley_1.dispose)(this.polylineEdges);
+        (0, core_bentley_1.dispose)(this.indexedEdges);
     }
     collectStatistics(stats) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         this.data.collectStatistics(stats);
         (_a = this.surface) === null || _a === void 0 ? void 0 : _a.collectStatistics(stats);
         (_b = this.segmentEdges) === null || _b === void 0 ? void 0 : _b.collectStatistics(stats);
         (_c = this.silhouetteEdges) === null || _c === void 0 ? void 0 : _c.collectStatistics(stats);
         (_d = this.polylineEdges) === null || _d === void 0 ? void 0 : _d.collectStatistics(stats);
+        (_e = this.indexedEdges) === null || _e === void 0 ? void 0 : _e.collectStatistics(stats);
     }
 }
 exports.MeshRenderGeometry = MeshRenderGeometry;
@@ -121,6 +70,7 @@ class MeshGraphic extends Graphic_1.Graphic {
         this.addPrimitive(geometry.segmentEdges);
         this.addPrimitive(geometry.silhouetteEdges);
         this.addPrimitive(geometry.polylineEdges);
+        this.addPrimitive(geometry.indexedEdges);
     }
     static create(geometry, instances) {
         var _a;
@@ -166,394 +116,4 @@ class MeshGraphic extends Graphic_1.Graphic {
     get surfaceType() { return this.meshData.type; }
 }
 exports.MeshGraphic = MeshGraphic;
-/** Defines one aspect of the geometry of a mesh (surface or edges)
- * @internal
- */
-class MeshGeometry extends CachedGeometry_1.LUTGeometry {
-    constructor(mesh, numIndices) {
-        super(mesh.viewIndependentOrigin);
-        this._numIndices = numIndices;
-        this.mesh = mesh;
-    }
-    get asMesh() { return this; }
-    _getLineWeight(params) { return this.computeEdgeWeight(params); }
-    // Convenience accessors...
-    get edgeWidth() { return this.mesh.edgeWidth; }
-    get edgeLineCode() { return this.mesh.edgeLineCode; }
-    get hasFeatures() { return this.mesh.hasFeatures; }
-    get surfaceType() { return this.mesh.type; }
-    get fillFlags() { return this.mesh.fillFlags; }
-    get isPlanar() { return this.mesh.isPlanar; }
-    get colorInfo() { return this.mesh.lut.colorInfo; }
-    get uniformColor() { return this.colorInfo.isUniform ? this.colorInfo.uniform : undefined; }
-    get texture() { return this.mesh.texture; }
-    get hasBakedLighting() { return this.mesh.hasBakedLighting; }
-    get hasFixedNormals() { return this.mesh.hasFixedNormals; }
-    get lut() { return this.mesh.lut; }
-    get hasScalarAnimation() { return this.mesh.lut.hasScalarAnimation; }
-    computeEdgeWeight(params) {
-        return params.target.computeEdgeWeight(params.renderPass, this.edgeWidth);
-    }
-    computeEdgeLineCode(params) {
-        return params.target.computeEdgeLineCode(params.renderPass, this.edgeLineCode);
-    }
-    computeEdgeColor(target) {
-        return target.computeEdgeColor(this.colorInfo);
-    }
-    computeEdgePass(target) {
-        if (target.isDrawingShadowMap)
-            return 255 /* None */;
-        const vf = target.currentViewFlags;
-        if (core_common_1.RenderMode.SmoothShade === vf.renderMode && !vf.visibleEdges) {
-            return 255 /* None */;
-        }
-        // Only want translucent edges in wireframe mode.
-        const isTranslucent = core_common_1.RenderMode.Wireframe === vf.renderMode && vf.transparency && this.colorInfo.hasTranslucency;
-        return isTranslucent ? 7 /* Translucent */ : 2 /* OpaqueLinear */;
-    }
-}
-exports.MeshGeometry = MeshGeometry;
-/** @internal */
-class EdgeGeometry extends MeshGeometry {
-    constructor(indices, endPointAndQuadsIndices, numIndices, mesh) {
-        super(mesh, numIndices);
-        this.buffers = AttributeBuffers_1.BuffersContainer.create();
-        const attrPos = AttributeMap_1.AttributeMap.findAttribute("a_pos", 4 /* Edge */, false);
-        const attrEndPointAndQuadIndices = AttributeMap_1.AttributeMap.findAttribute("a_endPointAndQuadIndices", 4 /* Edge */, false);
-        (0, core_bentley_1.assert)(attrPos !== undefined);
-        (0, core_bentley_1.assert)(attrEndPointAndQuadIndices !== undefined);
-        this.buffers.addBuffer(indices, [AttributeBuffers_1.BufferParameters.create(attrPos.location, 3, GL_1.GL.DataType.UnsignedByte, false, 0, 0, false)]);
-        this.buffers.addBuffer(endPointAndQuadsIndices, [AttributeBuffers_1.BufferParameters.create(attrEndPointAndQuadIndices.location, 4, GL_1.GL.DataType.UnsignedByte, false, 0, 0, false)]);
-        this._indices = indices;
-        this._endPointAndQuadIndices = endPointAndQuadsIndices;
-    }
-    get lutBuffers() { return this.buffers; }
-    get asSurface() { return undefined; }
-    get asEdge() { return this; }
-    get asSilhouette() { return undefined; }
-    static create(mesh, edges) {
-        const indexBuffer = AttributeBuffers_1.BufferHandle.createArrayBuffer(edges.indices.data);
-        const endPointBuffer = AttributeBuffers_1.BufferHandle.createArrayBuffer(edges.endPointAndQuadIndices);
-        return undefined !== indexBuffer && undefined !== endPointBuffer ? new EdgeGeometry(indexBuffer, endPointBuffer, edges.indices.length, mesh) : undefined;
-    }
-    get isDisposed() {
-        return this.buffers.isDisposed
-            && this._indices.isDisposed
-            && this._endPointAndQuadIndices.isDisposed;
-    }
-    dispose() {
-        (0, core_bentley_1.dispose)(this.buffers);
-        (0, core_bentley_1.dispose)(this._indices);
-        (0, core_bentley_1.dispose)(this._endPointAndQuadIndices);
-    }
-    collectStatistics(stats) {
-        stats.addVisibleEdges(this._indices.bytesUsed + this._endPointAndQuadIndices.bytesUsed);
-    }
-    _draw(numInstances, instanceBuffersContainer) {
-        const bufs = instanceBuffersContainer !== undefined ? instanceBuffersContainer : this.buffers;
-        bufs.bind();
-        System_1.System.instance.drawArrays(GL_1.GL.PrimitiveType.Triangles, 0, this._numIndices, numInstances);
-        bufs.unbind();
-    }
-    _wantWoWReversal(_target) { return true; }
-    _getLineCode(params) { return this.computeEdgeLineCode(params); }
-    get techniqueId() { return 4 /* Edge */; }
-    getRenderPass(target) { return this.computeEdgePass(target); }
-    get renderOrder() { return this.isPlanar ? 14 /* PlanarEdge */ : 6 /* Edge */; }
-    getColor(target) { return this.computeEdgeColor(target); }
-    get endPointAndQuadIndices() { return this._endPointAndQuadIndices; }
-    wantMonochrome(target) {
-        return target.currentViewFlags.renderMode === core_common_1.RenderMode.Wireframe;
-    }
-}
-exports.EdgeGeometry = EdgeGeometry;
-/** @internal */
-class SilhouetteEdgeGeometry extends EdgeGeometry {
-    constructor(indices, endPointAndQuadsIndices, normalPairs, numIndices, mesh) {
-        super(indices, endPointAndQuadsIndices, numIndices, mesh);
-        const attrNormals = AttributeMap_1.AttributeMap.findAttribute("a_normals", 5 /* SilhouetteEdge */, false);
-        (0, core_bentley_1.assert)(attrNormals !== undefined);
-        this.buffers.addBuffer(normalPairs, [AttributeBuffers_1.BufferParameters.create(attrNormals.location, 4, GL_1.GL.DataType.UnsignedByte, false, 0, 0, false)]);
-        this._normalPairs = normalPairs;
-    }
-    get asSilhouette() { return this; }
-    static createSilhouettes(mesh, params) {
-        const indexBuffer = AttributeBuffers_1.BufferHandle.createArrayBuffer(params.indices.data);
-        const endPointBuffer = AttributeBuffers_1.BufferHandle.createArrayBuffer(params.endPointAndQuadIndices);
-        const normalsBuffer = AttributeBuffers_1.BufferHandle.createArrayBuffer(params.normalPairs);
-        return undefined !== indexBuffer && undefined !== endPointBuffer && undefined !== normalsBuffer ? new SilhouetteEdgeGeometry(indexBuffer, endPointBuffer, normalsBuffer, params.indices.length, mesh) : undefined;
-    }
-    get isDisposed() { return super.isDisposed && this._normalPairs.isDisposed; }
-    dispose() {
-        super.dispose();
-        (0, core_bentley_1.dispose)(this._normalPairs);
-    }
-    collectStatistics(stats) {
-        stats.addSilhouetteEdges(this._indices.bytesUsed + this._endPointAndQuadIndices.bytesUsed + this._normalPairs.bytesUsed);
-    }
-    get techniqueId() { return 5 /* SilhouetteEdge */; }
-    get renderOrder() { return this.isPlanar ? 15 /* PlanarSilhouette */ : 7 /* Silhouette */; }
-    get normalPairs() { return this._normalPairs; }
-}
-exports.SilhouetteEdgeGeometry = SilhouetteEdgeGeometry;
-/** @internal */
-class PolylineEdgeGeometry extends MeshGeometry {
-    constructor(numIndices, buffers, mesh) {
-        super(mesh, numIndices);
-        this._buffers = buffers;
-    }
-    get lutBuffers() { return this._buffers.buffers; }
-    static create(mesh, polyline) {
-        const buffers = CachedGeometry_1.PolylineBuffers.create(polyline);
-        return undefined !== buffers ? new PolylineEdgeGeometry(polyline.indices.length, buffers, mesh) : undefined;
-    }
-    get isDisposed() { return this._buffers.isDisposed; }
-    dispose() {
-        (0, core_bentley_1.dispose)(this._buffers);
-    }
-    collectStatistics(stats) {
-        this._buffers.collectStatistics(stats, RenderMemory_1.RenderMemory.BufferType.PolylineEdges);
-    }
-    _wantWoWReversal(_target) { return true; }
-    _getLineWeight(params) { return this.computeEdgeWeight(params); }
-    _getLineCode(params) { return this.computeEdgeLineCode(params); }
-    getColor(target) { return this.computeEdgeColor(target); }
-    get techniqueId() { return 1 /* Polyline */; }
-    getRenderPass(target) { return this.computeEdgePass(target); }
-    get renderOrder() { return this.isPlanar ? 14 /* PlanarEdge */ : 6 /* Edge */; }
-    get polylineBuffers() { return this._buffers; }
-    wantMonochrome(target) {
-        return target.currentViewFlags.renderMode === core_common_1.RenderMode.Wireframe;
-    }
-    _draw(numInstances, instanceBuffersContainer) {
-        const gl = System_1.System.instance;
-        const bufs = instanceBuffersContainer !== undefined ? instanceBuffersContainer : this._buffers.buffers;
-        bufs.bind();
-        gl.drawArrays(GL_1.GL.PrimitiveType.Triangles, 0, this._numIndices, numInstances);
-        bufs.unbind();
-    }
-}
-exports.PolylineEdgeGeometry = PolylineEdgeGeometry;
-/** @internal */
-function wantMaterials(vf) {
-    return vf.materials && core_common_1.RenderMode.SmoothShade === vf.renderMode;
-}
-exports.wantMaterials = wantMaterials;
-function wantLighting(vf) {
-    return core_common_1.RenderMode.SmoothShade === vf.renderMode && vf.lighting;
-}
-/** @internal */
-class SurfaceGeometry extends MeshGeometry {
-    constructor(indices, numIndices, mesh) {
-        super(mesh, numIndices);
-        this._buffers = AttributeBuffers_1.BuffersContainer.create();
-        const attrPos = AttributeMap_1.AttributeMap.findAttribute("a_pos", 0 /* Surface */, false);
-        (0, core_bentley_1.assert)(undefined !== attrPos);
-        this._buffers.addBuffer(indices, [AttributeBuffers_1.BufferParameters.create(attrPos.location, 3, GL_1.GL.DataType.UnsignedByte, false, 0, 0, false)]);
-        this._indices = indices;
-    }
-    get lutBuffers() { return this._buffers; }
-    static create(mesh, indices) {
-        const indexBuffer = AttributeBuffers_1.BufferHandle.createArrayBuffer(indices.data);
-        return undefined !== indexBuffer ? new SurfaceGeometry(indexBuffer, indices.length, mesh) : undefined;
-    }
-    get isDisposed() {
-        return this._buffers.isDisposed
-            && this._indices.isDisposed;
-    }
-    dispose() {
-        (0, core_bentley_1.dispose)(this._buffers);
-        (0, core_bentley_1.dispose)(this._indices);
-    }
-    collectStatistics(stats) {
-        stats.addSurface(this._indices.bytesUsed);
-    }
-    get isLit() { return VertexTable_1.SurfaceType.Lit === this.surfaceType || VertexTable_1.SurfaceType.TexturedLit === this.surfaceType; }
-    get isTexturedType() { return VertexTable_1.SurfaceType.Textured === this.surfaceType || VertexTable_1.SurfaceType.TexturedLit === this.surfaceType; }
-    get hasTexture() { return this.isTexturedType && undefined !== this.texture; }
-    get isGlyph() { return this.mesh.isGlyph; }
-    get alwaysRenderTranslucent() { return this.isGlyph; }
-    get isTileSection() { return undefined !== this.texture && this.texture.isTileSection; }
-    get isClassifier() { return VertexTable_1.SurfaceType.VolumeClassifier === this.surfaceType; }
-    get supportsThematicDisplay() {
-        return !this.isGlyph;
-    }
-    get allowColorOverride() {
-        // Text background color should not be overridden by feature symbology overrides - otherwise it becomes unreadable...
-        // We don't actually know if we have text.
-        // We do know that text background color uses blanking fill. So do ImageGraphics, so they're also going to forbid overriding their color.
-        return core_common_1.FillFlags.Blanking !== (this.fillFlags & core_common_1.FillFlags.Blanking);
-    }
-    get asSurface() { return this; }
-    get asEdge() { return undefined; }
-    get asSilhouette() { return undefined; }
-    _draw(numInstances, instanceBuffersContainer) {
-        const system = System_1.System.instance;
-        // If we can't write depth in the fragment shader, use polygonOffset to force blanking regions to draw behind.
-        const offset = 2 /* BlankingRegion */ === this.renderOrder && !system.supportsLogZBuffer;
-        if (offset) {
-            system.context.enable(GL_1.GL.POLYGON_OFFSET_FILL);
-            system.context.polygonOffset(1.0, 1.0);
-        }
-        const bufs = instanceBuffersContainer !== undefined ? instanceBuffersContainer : this._buffers;
-        bufs.bind();
-        const primType = system.drawSurfacesAsWiremesh ? GL_1.GL.PrimitiveType.Lines : GL_1.GL.PrimitiveType.Triangles;
-        system.drawArrays(primType, 0, this._numIndices, numInstances);
-        bufs.unbind();
-        if (offset)
-            system.context.disable(GL_1.GL.POLYGON_OFFSET_FILL);
-    }
-    wantMixMonochromeColor(target) {
-        // Text relies on white-on-white reversal.
-        return !this.isGlyph && (this.isLitSurface || this.wantTextures(target, this.hasTexture));
-    }
-    get techniqueId() { return 0 /* Surface */; }
-    get isLitSurface() { return this.isLit; }
-    get hasBakedLighting() { return this.mesh.hasBakedLighting; }
-    get hasFixedNormals() { return this.mesh.hasFixedNormals; }
-    get renderOrder() {
-        if (core_common_1.FillFlags.Behind === (this.fillFlags & core_common_1.FillFlags.Behind))
-            return 2 /* BlankingRegion */;
-        let order = this.isLit ? 4 /* LitSurface */ : 3 /* UnlitSurface */;
-        if (this.isPlanar)
-            order = order | 8 /* PlanarBit */;
-        return order;
-    }
-    getColor(target) {
-        if (core_common_1.FillFlags.Background === (this.fillFlags & core_common_1.FillFlags.Background))
-            return target.uniforms.style.backgroundColorInfo;
-        else
-            return this.colorInfo;
-    }
-    getRenderPass(target) {
-        // Classifiers have a dedicated pass
-        if (this.isClassifier)
-            return 5 /* Classification */;
-        const opaquePass = this.isPlanar ? 3 /* OpaquePlanar */ : 4 /* OpaqueGeneral */;
-        // When reading pixels, glyphs are always opaque. Otherwise always transparent (for anti-aliasing).
-        if (this.isGlyph)
-            return target.isReadPixelsInProgress ? opaquePass : 7 /* Translucent */;
-        const vf = target.currentViewFlags;
-        // When rendering thematic isolines, we need translucency because they have anti-aliasing.
-        if (target.wantThematicDisplay && this.supportsThematicDisplay && target.uniforms.thematic.wantIsoLines)
-            return 7 /* Translucent */;
-        // In wireframe, unless fill is explicitly enabled for planar region, surface does not draw
-        if (core_common_1.RenderMode.Wireframe === vf.renderMode && !this.mesh.isTextureAlwaysDisplayed) {
-            const fillFlags = this.fillFlags;
-            const showFill = core_common_1.FillFlags.Always === (fillFlags & core_common_1.FillFlags.Always) || (vf.fill && core_common_1.FillFlags.ByView === (fillFlags & core_common_1.FillFlags.ByView));
-            if (!showFill)
-                return 255 /* None */;
-        }
-        // If transparency disabled by render mode or view flag, always draw opaque.
-        if (!vf.transparency || core_common_1.RenderMode.SolidFill === vf.renderMode || core_common_1.RenderMode.HiddenLine === vf.renderMode)
-            return opaquePass;
-        // We have 3 sources of alpha: the material, the texture, and the color.
-        // Base alpha comes from the material if it overrides it; otherwise from the color.
-        // The texture's alpha is multiplied by the base alpha.
-        // So we must draw in the translucent pass if the texture has transparency OR the base alpha is less than 1.
-        let hasAlpha = false;
-        const mat = wantMaterials(vf) ? this.mesh.materialInfo : undefined;
-        if (undefined !== mat && mat.overridesAlpha)
-            hasAlpha = mat.hasTranslucency;
-        else
-            hasAlpha = this.getColor(target).hasTranslucency;
-        if (!hasAlpha) {
-            const tex = this.wantTextures(target, true) ? this.texture : undefined;
-            hasAlpha = undefined !== tex && tex.hasTranslucency;
-        }
-        return hasAlpha ? 7 /* Translucent */ : opaquePass;
-    }
-    _wantWoWReversal(target) {
-        const fillFlags = this.fillFlags;
-        if (core_common_1.FillFlags.None !== (fillFlags & core_common_1.FillFlags.Background))
-            return false; // fill color explicitly from background
-        if (core_common_1.FillFlags.None !== (fillFlags & core_common_1.FillFlags.Always))
-            return true; // fill displayed even in wireframe
-        const vf = target.currentViewFlags;
-        if (core_common_1.RenderMode.Wireframe === vf.renderMode || vf.visibleEdges)
-            return false; // never invert surfaces when edges are displayed
-        if (this.isLit && wantLighting(vf))
-            return false;
-        // Don't invert white pixels of textures...
-        return !this.wantTextures(target, this.hasTexture);
-    }
-    get materialInfo() { return this.mesh.materialInfo; }
-    useTexture(params) {
-        return this.wantTextures(params.target, this.hasTexture);
-    }
-    computeSurfaceFlags(params, flags) {
-        const target = params.target;
-        const vf = target.currentViewFlags;
-        const useMaterial = wantMaterials(vf);
-        flags[3 /* IgnoreMaterial */] = useMaterial ? 0 : 1;
-        flags[9 /* HasMaterialAtlas */] = useMaterial && this.hasMaterialAtlas ? 1 : 0;
-        flags[1 /* ApplyLighting */] = 0;
-        flags[8 /* NoFaceFront */] = 0;
-        flags[6 /* HasColorAndNormal */] = 0;
-        if (this.isLit) {
-            flags[2 /* HasNormals */] = 1;
-            if (wantLighting(vf)) {
-                flags[1 /* ApplyLighting */] = 1;
-                if (this.hasFixedNormals)
-                    flags[8 /* NoFaceFront */] = 1;
-            }
-            // Textured meshes store normal in place of color index.
-            // Untextured lit meshes store normal where textured meshes would store UV coords.
-            // Tell shader where to find normal.
-            if (!this.isTexturedType) {
-                flags[6 /* HasColorAndNormal */] = 1;
-            }
-        }
-        else {
-            flags[2 /* HasNormals */] = 0;
-        }
-        flags[0 /* HasTexture */] = this.useTexture(params) ? 1 : 0;
-        // The transparency threshold controls how transparent a surface must be to allow light to pass through; more opaque surfaces cast shadows.
-        flags[4 /* TransparencyThreshold */] = params.target.isDrawingShadowMap ? 1 : 0;
-        flags[5 /* BackgroundFill */] = 0;
-        switch (params.renderPass) {
-            // NB: We need this for opaque pass due to SolidFill (must compute transparency, discard below threshold, render opaque at or above threshold)
-            case 2 /* OpaqueLinear */:
-            case 3 /* OpaquePlanar */:
-            case 4 /* OpaqueGeneral */:
-            case 7 /* Translucent */:
-            case 11 /* WorldOverlay */:
-            case 1 /* OpaqueLayers */:
-            case 6 /* TranslucentLayers */:
-            case 10 /* OverlayLayers */: {
-                const mode = vf.renderMode;
-                if (!this.isGlyph && (core_common_1.RenderMode.HiddenLine === mode || core_common_1.RenderMode.SolidFill === mode)) {
-                    flags[4 /* TransparencyThreshold */] = 1;
-                    if (core_common_1.RenderMode.HiddenLine === mode && core_common_1.FillFlags.Always !== (this.fillFlags & core_common_1.FillFlags.Always)) {
-                        // fill flags test for text - doesn't render with bg fill in hidden line mode.
-                        flags[5 /* BackgroundFill */] = 1;
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    wantTextures(target, surfaceTextureExists) {
-        if (this.hasScalarAnimation && undefined !== target.analysisTexture)
-            return true;
-        if (!surfaceTextureExists)
-            return false;
-        if (this.mesh.isTextureAlwaysDisplayed)
-            return true;
-        if (this.supportsThematicDisplay && target.wantThematicDisplay)
-            return false;
-        const fill = this.fillFlags;
-        const flags = target.currentViewFlags;
-        // ###TODO need to distinguish between gradient fill and actual textures...
-        switch (flags.renderMode) {
-            case core_common_1.RenderMode.SmoothShade:
-                return flags.textures;
-            case core_common_1.RenderMode.Wireframe:
-                return core_common_1.FillFlags.Always === (fill & core_common_1.FillFlags.Always) || (flags.fill && core_common_1.FillFlags.ByView === (fill & core_common_1.FillFlags.ByView));
-            default:
-                return core_common_1.FillFlags.Always === (fill & core_common_1.FillFlags.Always);
-        }
-    }
-}
-exports.SurfaceGeometry = SurfaceGeometry;
 //# sourceMappingURL=Mesh.js.map