@xeokit/xeokit-sdk 2.6.85-renderers-refactor-v2 → 2.6.86

package/src/viewer/scene/webgl/Sampler.js

@@ -0,0 +1,18 @@
+/**
+ * @desc A low-level component that represents a WebGL Sampler.
+ * @private
+ */
+class Sampler {
+
+    constructor(gl, location) {
+        this.bindTexture = function (texture, unit) {
+            if (texture.bind(unit)) {
+                gl.uniform1i(location, unit);
+                return true;
+            }
+            return false;
+        };
+    }
+}
+
+export {Sampler};

package/src/viewer/scene/webgl/Shader.js

@@ -0,0 +1,49 @@
+/**
+ * @desc Represents a vertex or fragment stage within a {@link Program}.
+ * @private
+ */
+class Shader {
+
+    constructor(gl, type, source) {
+
+        this.allocated = false;
+        this.compiled = false;
+        this.handle = gl.createShader(type);
+
+        if (!this.handle) {
+            this.errors = [
+                "Failed to allocate"
+            ];
+            return;
+        }
+
+        this.allocated = true;
+
+        gl.shaderSource(this.handle, source);
+        gl.compileShader(this.handle);
+
+        this.compiled = gl.getShaderParameter(this.handle, gl.COMPILE_STATUS);
+
+        if (!this.compiled) {
+
+            if (!gl.isContextLost()) { // Handled explicitly elsewhere, so won't re-handle here
+
+                const lines = source.split("\n");
+                const numberedLines = [];
+                for (let i = 0; i < lines.length; i++) {
+                    numberedLines.push((i + 1) + ": " + lines[i] + "\n");
+                }
+                this.errors = [];
+                this.errors.push("");
+                this.errors.push(gl.getShaderInfoLog(this.handle));
+                this.errors = this.errors.concat(numberedLines.join(""));
+            }
+        }
+    }
+
+    destroy() {
+
+    }
+}
+
+export {Shader};

package/src/viewer/scene/webgl/occlusion/OcclusionLayer.js

@@ -6,7 +6,9 @@ import {ArrayBuf} from "../ArrayBuf.js";
  */
 class OcclusionLayer {
 
-    constructor(origin) {
+    constructor(scene, origin) {
+
+        this.scene = scene;
         this.aabb = math.AABB3();
         this.origin = math.vec3(origin);
         this.originHash = this.origin.join();
@@ -20,9 +22,11 @@ class OcclusionLayer {
         this.lenPositionsBuf = 0;
         this.indicesBuf = null;
         this.sectionPlanesActive = [];
+        this.culledBySectionPlanes = false;
         this.occlusionTestList = [];           // List of
         this.lenOcclusionTestList = 0;
         this.pixels = [];
+        this.aabbDirty = false;
         this.markerListDirty = false;
         this.positionsDirty = true;
         this.occlusionTestListDirty = false;
@@ -51,82 +55,150 @@ class OcclusionLayer {
         this.numMarkers--;
     }
 
-    update(gl, markerInView) {
+    update() {
         if (this.markerListDirty) {
-            this.numMarkers = 0;
-            for (var id in this.markers) {
-                if (this.markers.hasOwnProperty(id)) {
-                    this.markerList[this.numMarkers] = this.markers[id];
-                    this.markerIndices[id] = this.numMarkers;
-                    this.numMarkers++;
-                }
-            }
-            this.markerList.length = this.numMarkers;
+            this._buildMarkerList();
             this.markerListDirty = false;
             this.positionsDirty = true;
             this.occlusionTestListDirty = true;
         }
-
         if (this.positionsDirty) { //////////////  TODO: Don't rebuild this when positions change, very wasteful
-            let j = 0;
-            for (let i = 0; i < this.numMarkers; i++) {
-                if (this.markerList[i]) {
-                    const marker = this.markerList[i];
-                    const worldPos = marker.rtcPos;
-                    this.positions[j++] = worldPos[0];
-                    this.positions[j++] = worldPos[1];
-                    this.positions[j++] = worldPos[2];
-                    this.indices[i] = i;
-                }
-            }
-            this.positions.length = this.numMarkers * 3;
-            this.indices.length = this.numMarkers;
+            this._buildPositions();
             this.positionsDirty = false;
+            this.aabbDirty = true;
+            this.vbosDirty = true;
+        }
+        if (this.aabbDirty) {
+            this._buildAABB();
+            this.aabbDirty = false;
+        }
+        if (this.vbosDirty) {
+            this._buildVBOs();
+            this.vbosDirty = false;
+        }
+        if (this.occlusionTestListDirty) {
+            this._buildOcclusionTestList();
+        }
+        this._updateActiveSectionPlanes();
+    }
 
-            const aabb = this.aabb;
-            math.collapseAABB3(aabb);
-            math.expandAABB3Points3(aabb, this.positions);
-            const origin = this.origin;
-            aabb[0] += origin[0];
-            aabb[1] += origin[1];
-            aabb[2] += origin[2];
-            aabb[3] += origin[0];
-            aabb[4] += origin[1];
-            aabb[5] += origin[2];
-
-            if (this.positionsBuf && (this.lenPositionsBuf !== this.positions.length)) {
-                this.positionsBuf.destroy();
-                this.positionsBuf = null;
-                this.indicesBuf.destroy();
-                this.indicesBuf = null;
+    _buildMarkerList() {
+        this.numMarkers = 0;
+        for (var id in this.markers) {
+            if (this.markers.hasOwnProperty(id)) {
+                this.markerList[this.numMarkers] = this.markers[id];
+                this.markerIndices[id] = this.numMarkers;
+                this.numMarkers++;
             }
+        }
+        this.markerList.length = this.numMarkers;
+    }
 
-            const positionsArr = new Float32Array(this.positions);
-            if (this.positionsBuf) {
-                this.positionsBuf.setData(positionsArr); // Just updating buffer elements, don't need to reallocate; Indices don't need updating
-            } else {
-                this.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, positionsArr, positionsArr.length, 3, gl.STATIC_DRAW);
-                this.indicesBuf = new ArrayBuf(gl, gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(this.indices), this.indices.length, 1, gl.STATIC_DRAW);
-                this.lenPositionsBuf = this.positions.length;
+    _buildPositions() {
+        let j = 0;
+        for (let i = 0; i < this.numMarkers; i++) {
+            if (this.markerList[i]) {
+                const marker = this.markerList[i];
+                const worldPos = marker.rtcPos;
+                this.positions[j++] = worldPos[0];
+                this.positions[j++] = worldPos[1];
+                this.positions[j++] = worldPos[2];
+                this.indices[i] = i;
             }
         }
+        this.positions.length = this.numMarkers * 3;
+        this.indices.length = this.numMarkers;
+    }
 
-        if (this.occlusionTestListDirty) {
-            let lenPixels = 0;
-            this.lenOcclusionTestList = 0;
-            for (let i = 0; i < this.numMarkers; i++) {
-                const marker = this.markerList[i];
-                if ((marker.entity && !marker.entity.visible) || (! markerInView(marker))) {
-                    marker._setVisible(false);
-                } else if (marker.occludable) {
-                    this.occlusionTestList[this.lenOcclusionTestList++] = marker;
-                    this.pixels[lenPixels++] = marker.canvasPos[0];
-                    this.pixels[lenPixels++] = marker.canvasPos[1];
+    _buildAABB() {
+        const aabb = this.aabb;
+        math.collapseAABB3(aabb);
+        math.expandAABB3Points3(aabb, this.positions);
+        const origin = this.origin;
+        aabb[0] += origin[0];
+        aabb[1] += origin[1];
+        aabb[2] += origin[2];
+        aabb[3] += origin[0];
+        aabb[4] += origin[1];
+        aabb[5] += origin[2];
+    }
+
+    _buildVBOs() {
+        if (this.positionsBuf) {
+            if (this.lenPositionsBuf === this.positions.length) { // Just updating buffer elements, don't need to reallocate
+                this.positionsBuf.setData(new Float32Array(this.positions)); // Indices don't need updating
+                return;
+            }
+            this.positionsBuf.destroy();
+            this.positionsBuf = null;
+            this.indicesBuf.destroy();
+            this.indicesBuf = null;
+        }
+        const gl = this.scene.canvas.gl;
+        const lenPositions = this.numMarkers * 3;
+        const lenIndices = this.numMarkers;
+        this.positionsBuf = new ArrayBuf(gl, gl.ARRAY_BUFFER, new Float32Array(this.positions), lenPositions, 3, gl.STATIC_DRAW);
+        this.indicesBuf = new ArrayBuf(gl, gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(this.indices), lenIndices, 1, gl.STATIC_DRAW);
+        this.lenPositionsBuf = this.positions.length;
+    }
+
+    _buildOcclusionTestList() {
+        const canvas = this.scene.canvas;
+        const near = this.scene.camera.perspective.near; // Assume near enough to ortho near
+        const boundary = canvas.boundary;
+        const canvasWidth = boundary[2];
+        const canvasHeight = boundary[3];
+        let lenPixels = 0;
+        this.lenOcclusionTestList = 0;
+        for (let i = 0; i < this.numMarkers; i++) {
+            const marker = this.markerList[i];
+            const viewPos = marker.viewPos;
+            if (viewPos[2] > -near) { // Clipped by near plane
+                marker._setVisible(false);
+                continue;
+            }
+            const canvasPos = marker.canvasPos;
+            const canvasX = canvasPos[0];
+            const canvasY = canvasPos[1];
+            if ((canvasX + 10) < 0 || (canvasY + 10) < 0 || (canvasX - 10) > canvasWidth || (canvasY - 10) > canvasHeight) {
+                marker._setVisible(false);
+                continue;
+            }
+            if (marker.entity && !marker.entity.visible) {
+                marker._setVisible(false);
+                continue;
+            }
+            if (marker.occludable) {
+                this.occlusionTestList[this.lenOcclusionTestList++] = marker;
+                this.pixels[lenPixels++] = canvasX;
+                this.pixels[lenPixels++] = canvasY;
+                continue;
+            }
+            marker._setVisible(true);
+        }
+    }
+
+    _updateActiveSectionPlanes() {
+        const sectionPlanes = this.scene._sectionPlanesState.sectionPlanes;
+        const numSectionPlanes = sectionPlanes.length;
+        if (numSectionPlanes > 0) {
+            for (let i = 0; i < numSectionPlanes; i++) {
+                const sectionPlane = sectionPlanes[i];
+                if (!sectionPlane.active) {
+                    this.sectionPlanesActive[i] = false;
                 } else {
-                    marker._setVisible(true);
+                    const intersect = math.planeAABB3Intersect(sectionPlane.dir, sectionPlane.dist, this.aabb);
+                    const outside = (intersect === -1);
+                    if (outside) {
+                        this.culledBySectionPlanes = true;
+                        return;
+                    }
+                    const intersecting = (intersect === 0);
+                    this.sectionPlanesActive[i] = intersecting;
                 }
             }
         }
+        this.culledBySectionPlanes = false;
     }
 
     destroy() {