@openglobus/og 0.11.5 → 0.12.0

package/src/og/entity/LabelWorker.js

@@ -0,0 +1,218 @@
+"use strict";
+
+// import { QueueArray } from '../QueueArray.js';
+
+export const LOCK_UPDATE = -2;
+export const LOCK_FREE = -1;
+
+class LabelWorker {
+    constructor(numWorkers = 4) {
+        this._id = 0;
+        this._source = {};
+
+        this._freeWorkerQueue = []; //new QueueArray(numWorkers);
+        var labelProgramm = new Blob([_programm], { type: "application/javascript" });
+
+        var that = this;
+
+        for (let i = 0; i < numWorkers; i++) {
+            var w = new Worker(URL.createObjectURL(labelProgramm));
+            w.onmessage = function (e) {
+
+                let s = that._source[e.data.id];
+
+                if (s.label._lockId === LOCK_UPDATE) {
+                    that.make(s.handler, s.label);
+                } else {
+                    s.handler.workerCallback(e.data, s.label);
+                }
+
+                that._source[e.data.id] = null;
+                delete that._source[e.data.id];
+                that._freeWorkerQueue.unshift(this);
+
+                that.check();
+            };
+
+            this._freeWorkerQueue.push(w);
+        }
+
+        this._pendingQueue = []; //new QueueArray(512);
+    }
+
+    check() {
+        if (this._pendingQueue.length) {
+            var p = this._pendingQueue.pop();
+            this.make(p.handler, p.label);
+        }
+    }
+
+    make(handler, label) {
+
+        if (handler._entityCollection) {
+            let source = { handler: handler, label: label };
+
+            if (this._freeWorkerQueue.length) {
+                var w = this._freeWorkerQueue.pop();
+
+                this._source[this._id] = source;
+
+                let labelData = new Float32Array([
+                /*0*/this._id++,
+                /*1*/handler._maxLetters,
+                /*2*/label.getVisibility() ? 1 : 0,
+                /*3, 4, 5*/label._positionHigh.x, label._positionHigh.y, label._positionHigh.z,
+                /*6, 7, 8*/label._positionLow.x, label._positionLow.y, label._positionLow.z,
+                /*9*/label._size,
+                /*10, 11, 12*/label._offset.x, label._offset.y, label._offset.z,
+                /*13, 14, 15, 16*/label._color.x, label._color.y, label._color.z, label._color.w,
+                /*17*/label._rotation,
+                /*18, 19, 20*/label._alignedAxis.x, label._alignedAxis.y, label._alignedAxis.z,
+                /*21*/label._fontIndex,
+                /*22*/label._outline,
+                /*23, 24, 25, 26*/label._outlineColor.x, label._outlineColor.y, label._outlineColor.z, label._outlineColor.w,
+                /*27, 28, 29*/label._entity._pickingColor.x, label._entity._pickingColor.y, label._entity._pickingColor.z
+                ]);
+
+                label._lockId = this._id;
+
+                w.postMessage({
+                    labelData: labelData
+                }, [
+                    labelData.buffer,
+                ]);
+            } else {
+                this._pendingQueue.push(source);
+            }
+        }
+    }
+}
+
+const _programm = `'use strict';
+
+    function concatTypedArrays(dest, index, source) {
+        let len = source.length,
+            offset = index * len;
+        for(let i = 0; i < len; i++) {
+            dest[offset + i] = source[i];
+        }
+    }
+
+    self.onmessage = function (e) {
+        var labelData = e.data.labelData,
+            id = labelData[0],
+            maxLetters = labelData[1],
+            isVisible = labelData[2],
+            /*3, 4, 5*/_positionHigh_x = labelData[3], _positionHigh_y = labelData[4], _positionHigh_z = labelData[5],
+            /*6, 7, 8*/_positionLow_x = labelData[6], _positionLow_y = labelData[7], _positionLow_z = labelData[8],
+            /*9*/_size = labelData[9],
+            /*10, 11, 12*/_offset_x = labelData[10], _offset_y = labelData[11], _offset_z = labelData[12],
+            /*13, 14, 15, 16*/_color_x = labelData[13], _color_y = labelData[14], _color_z = labelData[15], _color_w = labelData[16],
+            /*17*/_rotation = labelData[17],
+            /*18, 19, 20*/_alignedAxis_x = labelData[18], _alignedAxis_y = labelData[19], _alignedAxis_z = labelData[20],
+            /*21*/_fontIndex = labelData[21],
+            /*22*/_outline = labelData[22],
+            /*23, 24, 25, 26*/_outlineColor_x = labelData[23], _outlineColor_y = labelData[24], _outlineColor_z = labelData[25], _outlineColor_w = labelData[26],
+            /*27, 28, 29*/_pickingColor_x = labelData[27], _pickingColor_y = labelData[28], _pickingColor_z = labelData[29]
+         
+
+        let _vertexArr = new Float32Array(maxLetters * 12),
+            _texCoordArr = new Float32Array(maxLetters * 24),
+            _gliphParamArr = new Float32Array(maxLetters * 24),
+            _positionHighArr = new Float32Array(maxLetters * 18),
+            _positionLowArr = new Float32Array(maxLetters * 18),
+            _sizeArr = new Float32Array(maxLetters * 6),
+            _offsetArr = new Float32Array(maxLetters * 18),
+            _rgbaArr = new Float32Array(maxLetters * 24),
+            _rotationArr = new Float32Array(maxLetters * 6),
+            _alignedAxisArr = new Float32Array(maxLetters * 18),
+            _fontIndexArr = new Float32Array(maxLetters * 6),
+            _outlineArr = new Float32Array(maxLetters * 6),
+            _noOutlineArr = new Float32Array(maxLetters * 6),
+            _outlineColorArr = new Float32Array(maxLetters * 24),
+            _pickingColorArr = new Float32Array(maxLetters * 18);
+        
+        for (var i = 0; i < maxLetters; i++) {
+            if (isVisible !== 0) {
+                concatTypedArrays(_vertexArr, i, [0, 0, 0, -1, 1, -1, 1, -1, 1, 0, 0, 0]);
+            } else {
+                concatTypedArrays(_vertexArr, i, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+            }
+
+            concatTypedArrays(_texCoordArr, i, [0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0]);
+            concatTypedArrays(_gliphParamArr, i, [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0]);
+
+            var x = _positionHigh_x, y = _positionHigh_y, z = _positionHigh_z, w;
+            concatTypedArrays(_positionHighArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _positionLow_x; y = _positionLow_y; z = _positionLow_z;
+            concatTypedArrays(_positionLowArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _size;
+            concatTypedArrays(_sizeArr, i, [x, x, x, x, x, x]);
+
+            x = _offset_x; y = _offset_y; z = _offset_z;
+            concatTypedArrays(_offsetArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _color_x; y = _color_y; z = _color_z; w = _color_w;
+            concatTypedArrays(_rgbaArr, i, [x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w]);
+
+            x = _rotation;
+            concatTypedArrays(_rotationArr, i, [x, x, x, x, x, x]);
+
+            x = _alignedAxis_x; y = _alignedAxis_y; z = _alignedAxis_z;
+            concatTypedArrays(_alignedAxisArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+
+            x = _fontIndex;
+            concatTypedArrays(_fontIndexArr, i, [x, x, x, x, x, x]);
+
+            x = _outline;
+            concatTypedArrays(_outlineArr, i, [x, x, x, x, x, x]);
+
+            w = 0.001;
+            concatTypedArrays(_noOutlineArr, i, [w, w, w, w, w, w]);
+
+            x = _outlineColor_x; y = _outlineColor_y; z = _outlineColor_z; w = _outlineColor_w;
+            concatTypedArrays(_outlineColorArr, i, [x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w]);
+
+            x = _pickingColor_x / 255; y = _pickingColor_y / 255; z = _pickingColor_z / 255;
+            concatTypedArrays(_pickingColorArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);
+        }
+
+        self.postMessage({
+                id: id,
+                vertexArr: _vertexArr,
+                texCoordArr: _texCoordArr,
+                gliphParamArr: _gliphParamArr,
+                positionHighArr: _positionHighArr,
+                positionLowArr: _positionLowArr,
+                sizeArr: _sizeArr,
+                offsetArr: _offsetArr,
+                rgbaArr: _rgbaArr,
+                rotationArr: _rotationArr,
+                alignedAxisArr: _alignedAxisArr,
+                fontIndexArr: _fontIndexArr,
+                outlineArr: _outlineArr,
+                noOutlineArr: _noOutlineArr,
+                outlineColorArr: _outlineColorArr,
+                pickingColorArr: _pickingColorArr
+             }, [
+                    _vertexArr.buffer,
+                    _texCoordArr.buffer,
+                    _gliphParamArr.buffer,
+                    _positionHighArr.buffer,
+                    _positionLowArr.buffer,
+                    _sizeArr.buffer,
+                    _offsetArr.buffer,
+                    _rgbaArr.buffer,
+                    _rotationArr.buffer,
+                    _alignedAxisArr.buffer,
+                    _fontIndexArr.buffer,
+                    _outlineArr.buffer,
+                    _noOutlineArr.buffer,
+                    _outlineColorArr.buffer,
+                    _pickingColorArr.buffer
+            ]);
+    }`;
+
+export { LabelWorker };

package/src/og/entity/Object3d.js

@@ -0,0 +1,504 @@
+/* eslint-disable no-param-reassign */
+"use strict";
+
+import { htmlColorToFloat32Array } from "../utils/shared.js";
+import { Vec3 } from "../math/Vec3.js";
+
+function getColor(color) {
+    if (color instanceof Array) {
+        return color;
+    } else if (typeof color === "string") {
+        return htmlColorToFloat32Array(color);
+    }
+    return [1.0, 1.0, 1.0, 1.0];
+}
+
+class Object3d {
+    constructor(data) {
+        this._name = data.name || "noname";
+        this._vertices = data.vertices || [];
+        this._texCoords = [];
+
+        this.color = getColor(data.color);
+
+        if (data.scale) {
+            Object3d.scale(this._vertices, data.scale);
+        }
+
+        if (data.indexes) {
+            this._indexes = data.indexes || [];
+            this._normals = data.normals || [];
+        } else {
+            this._normals = Object3d.getNormals(this._vertices);
+        }
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get vertices() {
+        return this._vertices;
+    }
+
+    get normals() {
+        return this._normals;
+    }
+
+    get indexes() {
+        return this._indexes;
+    }
+
+    get indices() {
+        return this._indexes;
+    }
+
+    static scale(vertices, s) {
+        for (let i = 0; i < vertices.length; i++) {
+            vertices[i] *= s;
+        }
+    }
+
+    static centroid(vertices) {
+        let minX = 1000.0,
+            minY = 1000.0,
+            minZ = 1000.0,
+            maxX = -1000.0,
+            maxY = -1000.0,
+            maxZ = -1000.0;
+
+        for (let i = 0; i < vertices.length; i += 3) {
+            let x = vertices[i],
+                y = vertices[i + 1],
+                z = vertices[i + 2];
+            if (x < minX) minX = x;
+            if (y < minY) minY = y;
+            if (z < minZ) minZ = z;
+            if (x > maxX) maxX = x;
+            if (y > maxY) maxY = y;
+            if (z > maxZ) maxZ = z;
+        }
+
+        return [minX + (maxX - minX) * 0.5, minY + (maxY - minY) * 0.5, minZ + (maxZ - minZ) * 0.5];
+    }
+
+    static translate(vertices, v) {
+        for (let i = 0; i < vertices.length; i += 3) {
+            vertices[i] -= v[0];
+            vertices[i + 1] -= v[1];
+            vertices[i + 2] -= v[2];
+        }
+    }
+
+    static getNormals(vertices) {
+        let res = new Array(vertices.length);
+
+        for (var i = 0; i < vertices.length; i += 9) {
+            let t03 = i,
+                t13 = i + 3,
+                t23 = i + 6,
+                v0_x = vertices[t03],
+                v0_y = vertices[t03 + 1],
+                v0_z = vertices[t03 + 2],
+                v1_x = vertices[t13],
+                v1_y = vertices[t13 + 1],
+                v1_z = vertices[t13 + 2],
+                v2_x = vertices[t23],
+                v2_y = vertices[t23 + 1],
+                v2_z = vertices[t23 + 2],
+                vv0_x = v1_x - v0_x,
+                vv0_y = v1_y - v0_y,
+                vv0_z = v1_z - v0_z,
+                vv1_x = v2_x - v0_x,
+                vv1_y = v2_y - v0_y,
+                vv1_z = v2_z - v0_z,
+                n_x = vv0_y * vv1_z - vv0_z * vv1_y,
+                n_y = vv0_z * vv1_x - vv0_x * vv1_z,
+                n_z = vv0_x * vv1_y - vv0_y * vv1_x;
+
+            let l = Math.sqrt(n_x * n_x + n_y * n_y + n_z * n_z);
+
+            n_x /= l;
+            n_y /= l;
+            n_z /= l;
+
+            res[t03] = n_x;
+            res[t03 + 1] = n_y;
+            res[t03 + 2] = n_z;
+
+            res[t13] = n_x;
+            res[t13 + 1] = n_y;
+            res[t13 + 2] = n_z;
+
+            res[t23] = n_x;
+            res[t23 + 1] = n_y;
+            res[t23 + 2] = n_z;
+        }
+
+        return res;
+    }
+
+    static createSphere(
+        lonBands = 16,
+        latBands = 16,
+        radius = 1.0,
+        offsetX = 0,
+        offsetY = 0,
+        offsetZ = 0
+    ) {
+        let vertices = [],
+            indexes = [],
+            normals = [];
+
+        for (let latNumber = 0; latNumber <= latBands; latNumber++) {
+            var theta = (latNumber * Math.PI) / latBands;
+            var sinTheta = Math.sin(theta);
+            var cosTheta = Math.cos(theta);
+
+            for (let longNumber = 0; longNumber <= lonBands; longNumber++) {
+                var phi = (longNumber * 2 * Math.PI) / lonBands;
+                var sinPhi = Math.sin(phi);
+                var cosPhi = Math.cos(phi);
+                var x = cosPhi * sinTheta + offsetX;
+                var y = cosTheta + offsetY;
+                var z = sinPhi * sinTheta + offsetZ;
+                //var u = 1 - (longNumber / lonBands);
+                //var v = latNumber / latBands;
+                normals.push(x);
+                normals.push(y);
+                normals.push(z);
+                //texCoords.push(u);
+                //texCoords.push(v);
+                vertices.push(radius * x);
+                vertices.push(radius * y);
+                vertices.push(radius * z);
+            }
+        }
+
+        for (let latNumber = 0; latNumber < latBands; latNumber++) {
+            for (let longNumber = 0; longNumber < lonBands; longNumber++) {
+                var first = latNumber * (lonBands + 1) + longNumber;
+                var second = first + lonBands + 1;
+
+                indexes.push(first);
+                indexes.push(first + 1);
+                indexes.push(second);
+
+                indexes.push(second);
+                indexes.push(first + 1);
+                indexes.push(second + 1);
+            }
+        }
+
+        return new Object3d({
+            vertices: vertices,
+            normals: normals,
+            indexes: indexes
+        });
+    }
+
+    static createDisc(
+        radius = 1.0,
+        height = 0.0,
+        radialSegments = 8,
+        isTop = true,
+        startIndex = 0,
+        offsetX = 0,
+        offsetY,
+        offsetZ = 0
+    ) {
+        let vertices = [],
+            indexes = [],
+            normals = [];
+
+        let thetaStart = 0.0,
+            thetaLength = Math.PI * 2;
+
+        let sign = isTop === true ? 1.0 : -1.0;
+
+        let centerIndexStart = startIndex;
+
+        for (let x = 1; x <= radialSegments; x++) {
+            vertices.push(0 + offsetX, height * sign + offsetY, 0 + offsetZ);
+            normals.push(0, sign, 0);
+            //texCoords.push(0.5, 0.5);
+            startIndex++;
+        }
+
+        let centerIndexEnd = startIndex;
+
+        for (let x = 0; x <= radialSegments; x++) {
+            let u = x / radialSegments;
+            let theta = u * thetaLength + thetaStart;
+
+            let cosTheta = Math.cos(theta);
+            let sinTheta = Math.sin(theta);
+
+            vertices.push(
+                radius * sinTheta + offsetX,
+                height * sign + offsetY,
+                radius * cosTheta + offsetZ
+            );
+            normals.push(0, sign, 0);
+            //texCoords.push((cosTheta * 0.5) + 0.5, (sinTheta * 0.5 * sign) + 0.5);
+
+            startIndex++;
+        }
+
+        for (let x = 0; x < radialSegments; x++) {
+            let c = centerIndexStart + x,
+                i = centerIndexEnd + x;
+            if (isTop === true) {
+                indexes.push(i, i + 1, c);
+            } else {
+                indexes.push(i + 1, i, c);
+            }
+        }
+
+        return new Object3d({
+            vertices: vertices,
+            normals: normals,
+            indexes: indexes
+        });
+    }
+
+    static createCylinder(
+        radiusTop = 1.0,
+        radiusBottom = 1.0,
+        height = 1.0,
+        radialSegments = 32,
+        heightSegments = 1.0,
+        isTop = true,
+        isBottom = true,
+        offsetX = 0,
+        offsetY = 0,
+        offsetZ = 0
+    ) {
+        let vertices = [],
+            indexes = [],
+            normals = [];
+
+        let thetaStart = 0.0,
+            thetaLength = Math.PI * 2;
+
+        let index = 0;
+        let indexArray = [];
+
+        let normal = new Vec3();
+
+        var slope = (radiusBottom - radiusTop) / height;
+
+        for (let y = 0; y <= heightSegments; y++) {
+            let indexRow = [];
+
+            let v = y / heightSegments;
+
+            let radius = v * (radiusBottom - radiusTop) + radiusTop;
+
+            for (let x = 0; x <= radialSegments; x++) {
+                let u = x / radialSegments;
+
+                let theta = u * thetaLength + thetaStart;
+
+                let sinTheta = Math.sin(theta),
+                    cosTheta = Math.cos(theta);
+
+                vertices.push(
+                    radius * sinTheta + offsetX,
+                    -v * height + height + offsetY,
+                    radius * cosTheta + offsetZ
+                );
+
+                normal.set(sinTheta, slope, cosTheta).normalize();
+                normals.push(normal.x, normal.y, normal.z);
+
+                //texCoords.push(u, 1 - v);
+
+                indexRow.push(index++);
+            }
+            indexArray.push(indexRow);
+        }
+
+        for (let x = 0; x < radialSegments; x++) {
+            for (let y = 0; y < heightSegments; y++) {
+                let a = indexArray[y][x],
+                    b = indexArray[y + 1][x],
+                    c = indexArray[y + 1][x + 1],
+                    d = indexArray[y][x + 1];
+
+                indexes.push(a, b, d);
+                indexes.push(b, c, d);
+            }
+        }
+
+        if (radiusTop !== 0.0 && isTop) {
+            let cap = Object3d.createDisc(
+                radiusTop,
+                height,
+                radialSegments,
+                true,
+                index,
+                offsetX,
+                offsetY,
+                offsetZ
+            );
+            vertices.push(...cap.vertices);
+            normals.push(...cap.normals);
+            indexes.push(...cap.indexes);
+        }
+
+        if (radiusBottom !== 0.0 && isBottom) {
+            let cap = Object3d.createDisc(
+                radiusBottom,
+                0,
+                radialSegments,
+                false,
+                index + (isTop ? 1 + 2 * radialSegments : 0),
+                offsetX,
+                offsetY,
+                offsetZ
+            );
+            vertices.push(...cap.vertices);
+            normals.push(...cap.normals);
+            indexes.push(...cap.indexes);
+        }
+
+        return new Object3d({
+            vertices: vertices,
+            normals: normals,
+            indexes: indexes
+        });
+    }
+
+    static createCube(length = 1, height = 1, depth = 1, xOffset = 0, yOffset = 0, zOffset = 0) {
+        let l = length * 0.5 + xOffset,
+            h = height * 0.5 + yOffset,
+            d = depth * 0.5 + zOffset;
+
+        return new Object3d({
+            vertices: [
+                //bottom
+                -l,
+                -h,
+                d,
+                l,
+                -h,
+                -d,
+                l,
+                -h,
+                d,
+                -l,
+                -h,
+                d,
+                -l,
+                -h,
+                -d,
+                l,
+                -h,
+                -d,
+
+                //top
+                -l,
+                h,
+                d,
+                l,
+                h,
+                d,
+                l,
+                h,
+                -d,
+                -l,
+                h,
+                d,
+                l,
+                h,
+                -d,
+                -l,
+                h,
+                -d,
+
+                //front
+                -l,
+                -h,
+                d,
+                l,
+                -h,
+                d,
+                -l,
+                h,
+                d,
+                -l,
+                h,
+                d,
+                l,
+                -h,
+                d,
+                l,
+                h,
+                d,
+
+                //back
+                -l,
+                -h,
+                -d,
+                -l,
+                h,
+                -d,
+                l,
+                -h,
+                -d,
+                -l,
+                h,
+                -d,
+                l,
+                h,
+                -d,
+                l,
+                -h,
+                -d,
+
+                //left
+                l,
+                -h,
+                d,
+                l,
+                -h,
+                -d,
+                l,
+                h,
+                d,
+                l,
+                h,
+                d,
+                l,
+                -h,
+                -d,
+                l,
+                h,
+                -d,
+
+                //right
+                -l,
+                -h,
+                d,
+                -l,
+                h,
+                d,
+                -l,
+                -h,
+                -d,
+                -l,
+                h,
+                d,
+                -l,
+                h,
+                -d,
+                -l,
+                -h,
+                -d
+            ]
+        });
+    }
+}
+
+export { Object3d };