csyjk 1.1.1 → 1.2.2

package/src/lib/gltf/assets/yjkkit-sdk/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/lib/gltf/assets/yjkkit-sdk/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/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/webgl/Texture2D.js

@@ -0,0 +1,217 @@
+import {utils} from '../utils.js';
+import {webglEnums} from './webglEnums.js';
+
+function getGLEnum(gl, name, defaultVal) {
+    if (name === undefined) {
+        return defaultVal;
+    }
+    const glName = webglEnums[name];
+    if (glName === undefined) {
+        return defaultVal;
+    }
+    return gl[glName];
+}
+
+const color = new Uint8Array([0, 0, 0, 1]);
+
+function clampImageSize(image, numPixels) {
+    const n = image.width * image.height;
+    if (n > numPixels) {
+        const ratio = numPixels / n;
+        const width = image.width * ratio;
+        const height = image.height * ratio;
+        const canvas = document.createElement("canvas");
+        canvas.width = nextHighestPowerOfTwo(width);
+        canvas.height = nextHighestPowerOfTwo(height);
+        const ctx = canvas.getContext("2d");
+        ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height);
+        image = canvas;
+    }
+    return image;
+}
+
+function ensureImageSizePowerOfTwo(image) {
+    if (!isPowerOfTwo(image.width) || !isPowerOfTwo(image.height)) {
+        const canvas = document.createElement("canvas");
+        canvas.width = nextHighestPowerOfTwo(image.width);
+        canvas.height = nextHighestPowerOfTwo(image.height);
+        const ctx = canvas.getContext("2d");
+        ctx.drawImage(image,
+            0, 0, image.width, image.height,
+            0, 0, canvas.width, canvas.height);
+        image = canvas;
+    }
+    return image;
+}
+
+function isPowerOfTwo(x) {
+    return (x & (x - 1)) === 0;
+}
+
+function nextHighestPowerOfTwo(x) {
+    --x;
+    for (let i = 1; i < 32; i <<= 1) {
+        x = x | x >> i;
+    }
+    return x + 1;
+}
+
+/**
+ * @desc A low-level component that represents a 2D WebGL texture.
+ *
+ * @private
+ */
+class Texture2D {
+
+    constructor(gl, target) {
+        this.gl = gl;
+        this.target = target || gl.TEXTURE_2D;
+        this.texture = gl.createTexture();
+        this.setPreloadColor([0, 0, 0, 0]); // Prevents "there is no texture bound to the unit 0" error
+        this.allocated = true;
+    }
+
+    setPreloadColor(value) {
+
+        if (!value) {
+            color[0] = 0;
+            color[1] = 0;
+            color[2] = 0;
+            color[3] = 255;
+        } else {
+            color[0] = Math.floor(value[0] * 255);
+            color[1] = Math.floor(value[1] * 255);
+            color[2] = Math.floor(value[2] * 255);
+            color[3] = Math.floor((value[3] !== undefined ? value[3] : 1) * 255);
+        }
+
+        const gl = this.gl;
+
+        gl.bindTexture(this.target, this.texture);
+        gl.texParameteri(this.target, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(this.target, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+
+        if (this.target === gl.TEXTURE_CUBE_MAP) {
+
+            const faces = [
+                gl.TEXTURE_CUBE_MAP_POSITIVE_X,
+                gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
+                gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
+                gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+                gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
+                gl.TEXTURE_CUBE_MAP_NEGATIVE_Z
+            ];
+
+            for (let i = 0, len = faces.length; i < len; i++) {
+                gl.texImage2D(faces[i], 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);
+            }
+
+        } else {
+            gl.texImage2D(this.target, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, color);
+        }
+
+        gl.bindTexture(this.target, null);
+    }
+
+    setTarget(target) {
+        this.target = target || this.gl.TEXTURE_2D;
+    }
+
+    setImage(image, props) {
+        const gl = this.gl;
+        gl.bindTexture(this.target, this.texture);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, props.flipY);
+        if (this.target === gl.TEXTURE_CUBE_MAP) {
+            if (utils.isArray(image)) {
+                const images = image;
+                const faces = [
+                    gl.TEXTURE_CUBE_MAP_POSITIVE_X,
+                    gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
+                    gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
+                    gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+                    gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
+                    gl.TEXTURE_CUBE_MAP_NEGATIVE_Z
+                ];
+                for (let i = 0, len = faces.length; i < len; i++) {
+                    gl.texImage2D(faces[i], 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, images[i]);
+                }
+            }
+        } else {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+        }
+        gl.bindTexture(this.target, null);
+    }
+
+    setProps(props) {
+        const gl = this.gl;
+        gl.bindTexture(this.target, this.texture);
+        if (props.minFilter) {
+            const minFilter = getGLEnum(gl, props.minFilter);
+            if (minFilter) {
+                gl.texParameteri(this.target, gl.TEXTURE_MIN_FILTER, minFilter);
+                if (minFilter === gl.NEAREST_MIPMAP_NEAREST ||
+                    minFilter === gl.LINEAR_MIPMAP_NEAREST ||
+                    minFilter === gl.NEAREST_MIPMAP_LINEAR ||
+                    minFilter === gl.LINEAR_MIPMAP_LINEAR) {
+
+                    gl.generateMipmap(this.target);
+                }
+            }
+        }
+        if (props.magFilter) {
+            const magFilter = getGLEnum(gl, props.magFilter);
+            if (magFilter) {
+                gl.texParameteri(this.target, gl.TEXTURE_MAG_FILTER, magFilter);
+            }
+        }
+        if (props.wrapS) {
+            const wrapS = getGLEnum(gl, props.wrapS);
+            if (wrapS) {
+                gl.texParameteri(this.target, gl.TEXTURE_WRAP_S, wrapS);
+            }
+        }
+        if (props.wrapT) {
+            const wrapT = getGLEnum(gl, props.wrapT);
+            if (wrapT) {
+                gl.texParameteri(this.target, gl.TEXTURE_WRAP_T, wrapT);
+            }
+        }
+        gl.bindTexture(this.target, null);
+    }
+
+    bind(unit) {
+        if (!this.allocated) {
+            return;
+        }
+        if (this.texture) {
+            const gl = this.gl;
+            gl.activeTexture(gl["TEXTURE" + unit]);
+            gl.bindTexture(this.target, this.texture);
+            return true;
+        }
+        return false;
+    }
+
+    unbind(unit) {
+        if (!this.allocated) {
+            return;
+        }
+        if (this.texture) {
+            const gl = this.gl;
+            gl.activeTexture(gl["TEXTURE" + unit]);
+            gl.bindTexture(this.target, null);
+        }
+    }
+
+    destroy() {
+        if (!this.allocated) {
+            return;
+        }
+        if (this.texture) {
+            this.gl.deleteTexture(this.texture);
+            this.texture = null;
+        }
+    }
+}
+
+export {Texture2D};

package/src/lib/gltf/assets/yjkkit-sdk/src/viewer/scene/webgl/occlusion/OcclusionLayer.js

@@ -0,0 +1,214 @@
+import {math} from "../../math/math.js";
+import {ArrayBuf} from "../ArrayBuf.js";
+
+class OcclusionLayer {
+
+    constructor(scene, rtcCenter) {
+
+        this.scene = scene;
+        this.aabb = math.AABB3();
+        this.rtcCenter = math.vec3(rtcCenter);
+        this.rtcCenterHash = this.rtcCenter.join();
+        this.numMarkers = 0;
+        this.markers = {};
+        this.markerList = [];                  // Ordered array of Markers
+        this.markerIndices = {};               // ID map of Marker indices in _markerList
+        this.positions = [];                   // Packed array of World-space marker positions
+        this.indices = [];                     // Indices corresponding to array above
+        this.positionsBuf = null;
+        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;
+    }
+
+    addMarker(marker) {
+        this.markers[marker.id] = marker;
+        this.markerListDirty = true;
+        this.numMarkers++;
+    }
+
+    markerWorldPosUpdated(marker) {
+        if (!this.markers[marker.id]) { // Not added
+            return;
+        }
+        const i = this.markerIndices[marker.id];
+        this.positions[i * 3 + 0] = marker.worldPos[0];
+        this.positions[i * 3 + 1] = marker.worldPos[1];
+        this.positions[i * 3 + 2] = marker.worldPos[2];
+        this.positionsDirty = true; // TODO: avoid reallocating VBO each time
+    }
+
+    removeMarker(marker) {
+        delete this.markers[marker.id];
+        this.markerListDirty = true;
+        this.numMarkers--;
+    }
+
+    update() {
+        if (this.markerListDirty) {
+            this._buildMarkerList();
+            this.markerListDirty = false;
+            this.positionsDirty = true;
+            this.occlusionTestListDirty = true;
+        }
+        if (this.positionsDirty) { //////////////  TODO: Don't rebuild this when positions change, very wasteful
+            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();
+    }
+
+    _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;
+    }
+
+    _buildPositions() {
+        let j = 0;
+        for (let i = 0; i < this.numMarkers; i++) {
+            if (this.markerList[i]) {
+                const marker = this.markerList[i];
+                const worldPos = marker.worldPos;
+                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;
+    }
+
+    _buildAABB() {
+        const aabb = this.aabb;
+        math.collapseAABB3(aabb);
+        math.expandAABB3Points3(aabb, this.positions);
+        const rtcCenter = this.rtcCenter;
+        aabb[0] += rtcCenter[0];
+        aabb[1] += rtcCenter[1];
+        aabb[2] += rtcCenter[2];
+        aabb[3] += rtcCenter[0];
+        aabb[4] += rtcCenter[1];
+        aabb[5] += rtcCenter[2];
+    }
+
+    _buildVBOs() {
+        if (this.positionsBuf) {
+            if (this.lenPositionsBuf === this.positions.length) { // Just updating buffer elements, don't need to reallocate
+                this.positionsBuf.setData(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 {
+                    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() {
+        this.markers = {};
+        this.markerList.length = 0;
+        if (this.positionsBuf) {
+            this.positionsBuf.destroy();
+        }
+        if (this.indicesBuf) {
+            this.indicesBuf.destroy();
+        }
+    }
+}
+
+
+export {OcclusionLayer};