csyjk 1.2.2 → 2.2.2

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

@@ -1,18 +0,0 @@
-/**
- * @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

@@ -1,49 +0,0 @@
-/**
- * @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

@@ -1,217 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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};