@xeokit/xeokit-sdk 2.4.0-alpha-81 → 2.4.0-alpha-82

package/src/viewer/scene/model/vbo/pointsBatching/PointsBatchingLayer.js

@@ -0,0 +1,753 @@
+import {ENTITY_FLAGS} from '../../ENTITY_FLAGS.js';
+import {RENDER_PASSES} from '../../RENDER_PASSES.js';
+
+import {math} from "../../../math/math.js";
+import {RenderState} from "../../../webgl/RenderState.js";
+import {ArrayBuf} from "../../../webgl/ArrayBuf.js";
+import {geometryCompressionUtils} from "../../../math/geometryCompressionUtils.js";
+import {getPointsBatchingRenderers} from "./PointsBatchingRenderers.js";
+import {PointsBatchingBuffer} from "./PointsBatchingBuffer.js";
+import {quantizePositions} from "../../compression.js";
+
+const tempVec3a = math.vec4();
+const tempVec3b = math.vec4();
+const tempVec4a = math.vec4([0, 0, 0, 1]);
+const tempVec4b = math.vec4([0, 0, 0, 1]);
+const tempVec4c = math.vec4([0, 0, 0, 1]);
+const tempOBB3 = math.OBB3();
+
+/**
+ * @private
+ */
+class PointsBatchingLayer {
+
+    /**
+     * @param model
+     * @param cfg
+     * @param cfg.layerIndex
+     * @param cfg.positionsDecodeMatrix
+     * @param cfg.maxGeometryBatchSize
+     * @param cfg.origin
+     * @param cfg.scratchMemory
+     */
+    constructor(cfg) {
+
+        /**
+         * Owner model
+         * @type {VBOSceneModel}
+         */
+        this.model = cfg.model;
+
+        /**
+         * State sorting key.
+         * @type {string}
+         */
+        this.sortId = "PointsBatchingLayer";
+
+        /**
+         * Index of this PointsBatchingLayer in {@link VBOSceneModel#_layerList}.
+         * @type {Number}
+         */
+        this.layerIndex = cfg.layerIndex;
+
+        this._pointsBatchingRenderers = getPointsBatchingRenderers(cfg.model.scene);
+
+        this._buffer = new PointsBatchingBuffer(cfg.maxGeometryBatchSize);
+        this._scratchMemory = cfg.scratchMemory;
+
+        this._state = new RenderState({
+            positionsBuf: null,
+            offsetsBuf: null,
+            colorsBuf: null,
+            flagsBuf: null,
+            positionsDecodeMatrix: math.mat4(),
+            origin: null
+        });
+
+        // These counts are used to avoid unnecessary render passes
+        this._numPortions = 0;
+        this._numVisibleLayerPortions = 0;
+        this._numTransparentLayerPortions = 0;
+        this._numXRayedLayerPortions = 0;
+        this._numSelectedLayerPortions = 0;
+        this._numHighlightedLayerPortions = 0;
+        this._numClippableLayerPortions = 0;
+        this._numPickableLayerPortions = 0;
+        this._numCulledLayerPortions = 0;
+
+        this._modelAABB = math.collapseAABB3(); // Model-space AABB
+        this._portions = [];
+
+        this._finalized = false;
+
+        if (cfg.positionsDecodeMatrix) {
+            this._state.positionsDecodeMatrix.set(cfg.positionsDecodeMatrix);
+            this._preCompressedPositionsExpected = true;
+        } else {
+            this._preCompressedPositionsExpected = false;
+        }
+
+        if (cfg.origin) {
+            this._state.origin = math.vec3(cfg.origin);
+        }
+
+        /**
+         * The axis-aligned World-space boundary of this PointsBatchingLayer's positions.
+         * @type {*|Float64Array}
+         */
+        this.aabb = math.collapseAABB3();
+    }
+
+    /**
+     * Tests if there is room for another portion in this PointsBatchingLayer.
+     *
+     * @param lenPositions Number of positions we'd like to create in the portion.
+     * @returns {Boolean} True if OK to create another portion.
+     */
+    canCreatePortion(lenPositions) {
+        if (this._finalized) {
+            throw "Already finalized";
+        }
+        return ((this._buffer.positions.length + lenPositions) < (this._buffer.maxVerts * 3));
+    }
+
+    /**
+     * Creates a new portion within this PointsBatchingLayer, returns the new portion ID.
+     *
+     * Gives the portion the specified geometry, color and matrix.
+     *
+     * @param cfg.positions Flat float Local-space positions array.
+     * @param cfg.positionsCompressed Flat quantized positions array - decompressed with PointsBatchingLayer positionsDecodeMatrix
+     * @param [cfg.colorsCompressed] Quantized RGB colors [0..255,0..255,0..255,0..255]
+     * @param [cfg.colors] Flat float colors array.
+     * @param cfg.color Float RGB color [0..1,0..1,0..1]
+     * @param [cfg.meshMatrix] Flat float 4x4 matrix
+     * @param cfg.worldAABB Flat float AABB World-space AABB
+     * @param cfg.pickColor Quantized pick color
+     * @returns {number} Portion ID
+     */
+    createPortion(cfg) {
+
+        if (this._finalized) {
+            throw "Already finalized";
+        }
+
+        const positions = cfg.positions;
+        const positionsCompressed = cfg.positionsCompressed;
+        const color = cfg.color;
+        const colorsCompressed = cfg.colorsCompressed;
+        const colors = cfg.colors;
+        const meshMatrix = cfg.meshMatrix;
+        const worldAABB = cfg.worldAABB;
+        const pickColor = cfg.pickColor;
+
+        const buffer = this._buffer;
+        const positionsIndex = buffer.positions.length;
+        const vertsIndex = positionsIndex / 3;
+
+        let numVerts;
+
+        if (this._preCompressedPositionsExpected) {
+
+            if (!positionsCompressed) {
+                throw "positionsCompressed expected";
+            }
+
+            for (let i = 0, len = positionsCompressed.length; i < len; i++) {
+                buffer.positions.push(positionsCompressed[i]);
+            }
+
+            const bounds = geometryCompressionUtils.getPositionsBounds(positionsCompressed);
+
+            const min = geometryCompressionUtils.decompressPosition(bounds.min, this._state.positionsDecodeMatrix, tempVec3a);
+            const max = geometryCompressionUtils.decompressPosition(bounds.max, this._state.positionsDecodeMatrix, tempVec3b);
+
+            worldAABB[0] = min[0];
+            worldAABB[1] = min[1];
+            worldAABB[2] = min[2];
+            worldAABB[3] = max[0];
+            worldAABB[4] = max[1];
+            worldAABB[5] = max[2];
+
+            numVerts = positionsCompressed.length / 3;
+
+        } else {
+
+            if (!positions) {
+                throw "positions expected";
+            }
+
+            numVerts = positions.length / 3;
+
+            const lenPositions = positions.length;
+            const positionsBase = buffer.positions.length;
+
+            for (let i = 0, len = positions.length; i < len; i++) {
+                buffer.positions.push(positions[i]);
+            }
+
+            if (meshMatrix) {
+
+                for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
+
+                    tempVec4a[0] = buffer.positions[i + 0];
+                    tempVec4a[1] = buffer.positions[i + 1];
+                    tempVec4a[2] = buffer.positions[i + 2];
+
+                    math.transformPoint4(meshMatrix, tempVec4a, tempVec4b);
+
+                    buffer.positions[i + 0] = tempVec4b[0];
+                    buffer.positions[i + 1] = tempVec4b[1];
+                    buffer.positions[i + 2] = tempVec4b[2];
+
+                    math.expandAABB3Point3(this._modelAABB, tempVec4b);
+                        math.expandAABB3Point3(worldAABB, tempVec4b);
+                }
+
+            } else {
+
+                for (let i = positionsBase, len = positionsBase + lenPositions; i < len; i += 3) {
+
+                    tempVec4a[0] = buffer.positions[i + 0];
+                    tempVec4a[1] = buffer.positions[i + 1];
+                    tempVec4a[2] = buffer.positions[i + 2];
+
+                    math.expandAABB3Point3(this._modelAABB, tempVec4a);
+                        math.expandAABB3Point3(worldAABB, tempVec4a);
+                }
+            }
+        }
+
+        if (this._state.origin) {
+            const origin = this._state.origin;
+            worldAABB[0] += origin[0];
+            worldAABB[1] += origin[1];
+            worldAABB[2] += origin[2];
+            worldAABB[3] += origin[0];
+            worldAABB[4] += origin[1];
+            worldAABB[5] += origin[2];
+        }
+
+        math.expandAABB3(this.aabb, worldAABB);
+
+        if (colorsCompressed) {
+            for (let i = 0, len = colorsCompressed.length; i < len; i++) {
+                buffer.colors.push(colorsCompressed[i]);
+            }
+
+        } else if (colors) {
+            for (let i = 0, len = colors.length; i < len; i++) {
+                buffer.colors.push(colors[i] * 255);
+            }
+
+        } else if (color) {
+
+            const r = color[0]; // Color is pre-quantized by VBOSceneModel
+            const g = color[1];
+            const b = color[2];
+            const a = 1.0;
+
+            for (let i = 0; i < numVerts; i++) {
+                buffer.colors.push(r);
+                buffer.colors.push(g);
+                buffer.colors.push(b);
+                buffer.colors.push(a);
+            }
+        }
+
+        {
+            const pickColorsBase = buffer.pickColors.length;
+            const lenPickColors = numVerts * 4;
+            for (let i = pickColorsBase, len = pickColorsBase + lenPickColors; i < len; i += 4) {
+                buffer.pickColors.push(pickColor[0]);
+                buffer.pickColors.push(pickColor[1]);
+                buffer.pickColors.push(pickColor[2]);
+                buffer.pickColors.push(pickColor[3]);
+            }
+        }
+
+        if (this.model.scene.entityOffsetsEnabled) {
+            for (let i = 0; i < numVerts; i++) {
+                buffer.offsets.push(0);
+                buffer.offsets.push(0);
+                buffer.offsets.push(0);
+            }
+        }
+
+        const portionId = this._portions.length / 2;
+
+        this._portions.push(vertsIndex);
+        this._portions.push(numVerts);
+
+        this._numPortions++;
+        this.model.numPortions++;
+
+        return portionId;
+    }
+
+    /**
+     * Builds batch VBOs from appended geometries.
+     * No more portions can then be created.
+     */
+    finalize() {
+
+        if (this._finalized) {
+            return;
+        }
+
+        const state = this._state;
+        const gl = this.model.scene.canvas.gl;
+        const buffer = this._buffer;
+
+        if (buffer.positions.length > 0) {
+            if (this._preCompressedPositionsExpected) {
+                const positions = new Uint16Array(buffer.positions);
+                state.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positions, buffer.positions.length, 3, gl.STATIC_DRAW);
+            } else {
+                const positions = new Float32Array(buffer.positions);
+                const quantizedPositions = quantizePositions(positions, this._modelAABB, state.positionsDecodeMatrix);
+                state.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, quantizedPositions, buffer.positions.length, 3, gl.STATIC_DRAW);
+            }
+        }
+
+        if (buffer.colors.length > 0) {
+            const colors = new Uint8Array(buffer.colors);
+            let normalized = false;
+            state.colorsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, colors, buffer.colors.length, 4, gl.STATIC_DRAW, normalized);
+        }
+
+        if (buffer.positions.length > 0) { // Because we build flags arrays here, get their length from the positions array
+            const flagsLength = buffer.positions.length / 3;
+            const flags = new Float32Array(flagsLength);
+            let notNormalized = false;
+            state.flagsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, flags, flags.length, 1, gl.DYNAMIC_DRAW, notNormalized);
+        }
+
+        if (buffer.pickColors.length > 0) {
+            const pickColors = new Uint8Array(buffer.pickColors);
+            let normalized = false;
+            state.pickColorsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, pickColors, buffer.pickColors.length, 4, gl.STATIC_DRAW, normalized);
+        }
+
+        if (this.model.scene.entityOffsetsEnabled) {
+            if (buffer.offsets.length > 0) {
+                const offsets = new Float32Array(buffer.offsets);
+                state.offsetsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, offsets, buffer.offsets.length, 3, gl.DYNAMIC_DRAW);
+            }
+        }
+
+        this._buffer = null;
+        this._finalized = true;
+    }
+
+    initFlags(portionId, flags, meshTransparent) {
+        if (flags & ENTITY_FLAGS.VISIBLE) {
+            this._numVisibleLayerPortions++;
+            this.model.numVisibleLayerPortions++;
+        }
+        if (flags & ENTITY_FLAGS.HIGHLIGHTED) {
+            this._numHighlightedLayerPortions++;
+            this.model.numHighlightedLayerPortions++;
+        }
+        if (flags & ENTITY_FLAGS.XRAYED) {
+            this._numXRayedLayerPortions++;
+            this.model.numXRayedLayerPortions++;
+        }
+        if (flags & ENTITY_FLAGS.SELECTED) {
+            this._numSelectedLayerPortions++;
+            this.model.numSelectedLayerPortions++;
+        }
+        if (flags & ENTITY_FLAGS.CLIPPABLE) {
+            this._numClippableLayerPortions++;
+            this.model.numClippableLayerPortions++;
+        }
+        if (flags & ENTITY_FLAGS.PICKABLE) {
+            this._numPickableLayerPortions++;
+            this.model.numPickableLayerPortions++;
+        }
+        if (flags & ENTITY_FLAGS.CULLED) {
+            this._numCulledLayerPortions++;
+            this.model.numCulledLayerPortions++;
+        }
+        if (meshTransparent) {
+            this._numTransparentLayerPortions++;
+            this.model.numTransparentLayerPortions++;
+        }
+        this._setFlags(portionId, flags, meshTransparent);
+    }
+
+    setVisible(portionId, flags, transparent) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (flags & ENTITY_FLAGS.VISIBLE) {
+            this._numVisibleLayerPortions++;
+            this.model.numVisibleLayerPortions++;
+        } else {
+            this._numVisibleLayerPortions--;
+            this.model.numVisibleLayerPortions--;
+        }
+        this._setFlags(portionId, flags, transparent);
+    }
+
+    setHighlighted(portionId, flags, transparent) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (flags & ENTITY_FLAGS.HIGHLIGHTED) {
+            this._numHighlightedLayerPortions++;
+            this.model.numHighlightedLayerPortions++;
+        } else {
+            this._numHighlightedLayerPortions--;
+            this.model.numHighlightedLayerPortions--;
+        }
+        this._setFlags(portionId, flags, transparent);
+    }
+
+    setXRayed(portionId, flags, transparent) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (flags & ENTITY_FLAGS.XRAYED) {
+            this._numXRayedLayerPortions++;
+            this.model.numXRayedLayerPortions++;
+        } else {
+            this._numXRayedLayerPortions--;
+            this.model.numXRayedLayerPortions--;
+        }
+        this._setFlags(portionId, flags, transparent);
+    }
+
+    setSelected(portionId, flags, transparent) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (flags & ENTITY_FLAGS.SELECTED) {
+            this._numSelectedLayerPortions++;
+            this.model.numSelectedLayerPortions++;
+        } else {
+            this._numSelectedLayerPortions--;
+            this.model.numSelectedLayerPortions--;
+        }
+        this._setFlags(portionId, flags, transparent);
+    }
+
+    setEdges(portionId, flags, transparent) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        // Not applicable to point clouds
+    }
+
+    setClippable(portionId, flags) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (flags & ENTITY_FLAGS.CLIPPABLE) {
+            this._numClippableLayerPortions++;
+            this.model.numClippableLayerPortions++;
+        } else {
+            this._numClippableLayerPortions--;
+            this.model.numClippableLayerPortions--;
+        }
+        this._setFlags(portionId, flags);
+    }
+
+    setCulled(portionId, flags, transparent) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (flags & ENTITY_FLAGS.CULLED) {
+            this._numCulledLayerPortions++;
+            this.model.numCulledLayerPortions++;
+        } else {
+            this._numCulledLayerPortions--;
+            this.model.numCulledLayerPortions--;
+        }
+        this._setFlags(portionId, flags, transparent);
+    }
+
+    setCollidable(portionId, flags) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+    }
+
+    setPickable(portionId, flags, transparent) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (flags & ENTITY_FLAGS.PICKABLE) {
+            this._numPickableLayerPortions++;
+            this.model.numPickableLayerPortions++;
+        } else {
+            this._numPickableLayerPortions--;
+            this.model.numPickableLayerPortions--;
+        }
+        this._setFlags(portionId, flags, transparent);
+    }
+
+    setColor(portionId, color) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        const portionsIdx = portionId * 2;
+        const vertexBase = this._portions[portionsIdx];
+        const numVerts = this._portions[portionsIdx + 1];
+        const firstColor = vertexBase * 4;
+        const lenColor = numVerts * 4;
+        const tempArray = this._scratchMemory.getUInt8Array(lenColor);
+        const r = color[0];
+        const g = color[1];
+        const b = color[2];
+        for (let i = 0; i < lenColor; i += 4) {
+            tempArray[i + 0] = r;
+            tempArray[i + 1] = g;
+            tempArray[i + 2] = b;
+        }
+        this._state.colorsBuf.setData(tempArray, firstColor, lenColor);
+    }
+
+    setTransparent(portionId, flags, transparent) {
+        if (transparent) {
+            this._numTransparentLayerPortions++;
+            this.model.numTransparentLayerPortions++;
+        } else {
+            this._numTransparentLayerPortions--;
+            this.model.numTransparentLayerPortions--;
+        }
+        this._setFlags(portionId, flags, transparent);
+    }
+
+    /**
+     * flags are 4bits values encoded on a 32bit base. color flag on the first 4 bits, silhouette flag on the next 4 bits and so on for edge, pick and clippable.
+     */
+    _setFlags(portionId, flags, transparent) {
+
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+
+        const portionsIdx = portionId * 2;
+        const vertexBase = this._portions[portionsIdx];
+        const numVerts = this._portions[portionsIdx + 1];
+        const firstFlag = vertexBase;
+        const lenFlags = numVerts;
+        const tempArray = this._scratchMemory.getFloat32Array(lenFlags);
+
+        const visible = !!(flags & ENTITY_FLAGS.VISIBLE);
+        const xrayed = !!(flags & ENTITY_FLAGS.XRAYED);
+        const highlighted = !!(flags & ENTITY_FLAGS.HIGHLIGHTED);
+        const selected = !!(flags & ENTITY_FLAGS.SELECTED);
+        const pickable = !!(flags & ENTITY_FLAGS.PICKABLE);
+        const culled = !!(flags & ENTITY_FLAGS.CULLED);
+
+        let colorFlag;
+        if (!visible || culled || xrayed
+            || (highlighted && !this.model.scene.highlightMaterial.glowThrough)
+            || (selected && !this.model.scene.selectedMaterial.glowThrough) ) {
+            colorFlag = RENDER_PASSES.NOT_RENDERED;
+        } else {
+            if (transparent) {
+                colorFlag = RENDER_PASSES.COLOR_TRANSPARENT;
+            } else {
+                colorFlag = RENDER_PASSES.COLOR_OPAQUE;
+            }
+        }
+
+        let silhouetteFlag;
+        if (!visible || culled) {
+            silhouetteFlag = RENDER_PASSES.NOT_RENDERED;
+        } else if (selected) {
+            silhouetteFlag = RENDER_PASSES.SILHOUETTE_SELECTED;
+        } else if (highlighted) {
+            silhouetteFlag = RENDER_PASSES.SILHOUETTE_HIGHLIGHTED;
+        } else if (xrayed) {
+            silhouetteFlag = RENDER_PASSES.SILHOUETTE_XRAYED;
+        } else {
+            silhouetteFlag = RENDER_PASSES.NOT_RENDERED;
+        }
+
+        let pickFlag = (visible && !culled && pickable) ? RENDER_PASSES.PICK : RENDER_PASSES.NOT_RENDERED;
+
+        const clippableFlag = !!(flags & ENTITY_FLAGS.CLIPPABLE) ? 1 : 0;
+
+        for (let i = 0; i < lenFlags; i++) {
+            let vertFlag = 0;
+            vertFlag |= colorFlag;
+            vertFlag |= silhouetteFlag << 4;
+            // no edges
+            vertFlag |= pickFlag << 12;
+            vertFlag |= clippableFlag << 16;
+    
+            tempArray[i] = vertFlag;
+        }
+
+        this._state.flagsBuf.setData(tempArray, firstFlag);
+    }
+
+    setOffset(portionId, offset) {
+        if (!this._finalized) {
+            throw "Not finalized";
+        }
+        if (!this.model.scene.entityOffsetsEnabled) {
+            this.model.error("Entity#offset not enabled for this Viewer"); // See Viewer entityOffsetsEnabled
+            return;
+        }
+        const portionsIdx = portionId * 2;
+        const vertexBase = this._portions[portionsIdx];
+        const numVerts = this._portions[portionsIdx + 1];
+        const firstOffset = vertexBase * 3;
+        const lenOffsets = numVerts * 3;
+        const tempArray = this._scratchMemory.getFloat32Array(lenOffsets);
+        const x = offset[0];
+        const y = offset[1];
+        const z = offset[2];
+        for (let i = 0; i < lenOffsets; i += 3) {
+            tempArray[i + 0] = x;
+            tempArray[i + 1] = y;
+            tempArray[i + 2] = z;
+        }
+        this._state.offsetsBuf.setData(tempArray, firstOffset, lenOffsets);
+    }
+
+    //-- NORMAL RENDERING ----------------------------------------------------------------------------------------------
+
+    drawColorOpaque(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0 || this._numTransparentLayerPortions === this._numPortions || this._numXRayedLayerPortions === this._numPortions) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.colorRenderer) {
+            this._pointsBatchingRenderers.colorRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+        }
+    }
+
+    drawColorTransparent(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0 || this._numTransparentLayerPortions === 0 || this._numXRayedLayerPortions === this._numPortions) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.colorRenderer) {
+            this._pointsBatchingRenderers.colorRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_TRANSPARENT);
+        }
+    }
+
+    // -- RENDERING SAO POST EFFECT TARGETS ----------------------------------------------------------------------------
+
+    drawDepth(renderFlags, frameCtx) {
+    }
+
+    drawNormals(renderFlags, frameCtx) {
+    }
+
+    // -- EMPHASIS RENDERING -------------------------------------------------------------------------------------------
+
+    drawSilhouetteXRayed(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0 || this._numXRayedLayerPortions === 0) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.silhouetteRenderer) {
+            this._pointsBatchingRenderers.silhouetteRenderer.drawLayer(frameCtx, this, RENDER_PASSES.SILHOUETTE_XRAYED);
+        }
+    }
+
+    drawSilhouetteHighlighted(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0 || this._numHighlightedLayerPortions === 0) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.silhouetteRenderer) {
+            this._pointsBatchingRenderers.silhouetteRenderer.drawLayer(frameCtx, this, RENDER_PASSES.SILHOUETTE_HIGHLIGHTED);
+        }
+    }
+
+    drawSilhouetteSelected(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0 || this._numSelectedLayerPortions === 0) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.silhouetteRenderer) {
+            this._pointsBatchingRenderers.silhouetteRenderer.drawLayer(frameCtx, this, RENDER_PASSES.SILHOUETTE_SELECTED);
+        }
+    }
+
+    //-- EDGES RENDERING -----------------------------------------------------------------------------------------------
+
+    drawEdgesColorOpaque(renderFlags, frameCtx) {
+    }
+
+    drawEdgesColorTransparent(renderFlags, frameCtx) {
+    }
+
+    drawEdgesHighlighted(renderFlags, frameCtx) {
+    }
+
+    drawEdgesSelected(renderFlags, frameCtx) {
+    }
+
+    drawEdgesXRayed(renderFlags, frameCtx) {
+    }
+
+    //---- PICKING ----------------------------------------------------------------------------------------------------
+
+    drawPickMesh(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.pickMeshRenderer) {
+            this._pointsBatchingRenderers.pickMeshRenderer.drawLayer(frameCtx, this, RENDER_PASSES.PICK);
+        }
+    }
+
+    drawPickDepths(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.pickDepthRenderer) {
+            this._pointsBatchingRenderers.pickDepthRenderer.drawLayer(frameCtx, this, RENDER_PASSES.PICK);
+        }
+    }
+
+    drawPickNormals(renderFlags, frameCtx) {
+    }
+
+    //---- OCCLUSION TESTING -------------------------------------------------------------------------------------------
+
+    drawOcclusion(renderFlags, frameCtx) {
+        if (this._numCulledLayerPortions === this._numPortions || this._numVisibleLayerPortions === 0) {
+            return;
+        }
+        if (this._pointsBatchingRenderers.occlusionRenderer) {
+            this._pointsBatchingRenderers.occlusionRenderer.drawLayer(frameCtx, this, RENDER_PASSES.COLOR_OPAQUE);
+        }
+    }
+
+    //---- SHADOWS -----------------------------------------------------------------------------------------------------
+
+    drawShadow(renderFlags, frameCtx) {
+    }
+
+    destroy() {
+        const state = this._state;
+        if (state.positionsBuf) {
+            state.positionsBuf.destroy();
+            state.positionsBuf = null;
+        }
+        if (state.offsetsBuf) {
+            state.offsetsBuf.destroy();
+            state.offsetsBuf = null;
+        }
+        if (state.colorsBuf) {
+            state.colorsBuf.destroy();
+            state.colorsBuf = null;
+        }
+        if (state.flagsBuf) {
+            state.flagsBuf.destroy();
+            state.flagsBuf = null;
+        }
+        if (state.pickColorsBuf) {
+            state.pickColorsBuf.destroy();
+            state.pickColorsBuf = null;
+        }
+        state.destroy();
+    }
+}
+
+export {PointsBatchingLayer};