@openglobus/og 0.11.4 → 0.11.8

package/src/og/segment/Segment.js

@@ -12,26 +12,13 @@ import { Box } from "../bv/Box.js";
 import { Vec3 } from "../math/Vec3.js";
 import * as segmentHelper from "../segment/segmentHelper.js";
 import { getMatrixSubArray } from "../utils/shared.js";
+import { Slice } from "./Slice.js";
 
 export const MAX_NORMAL_ZOOM = 7;
 
 var _tempHigh = new Vec3();
 var _tempLow = new Vec3();
 
-var _RenderingSlice = function (p) {
-    this.layers = [];
-    this.tileOffsetArr = new Float32Array(p.SLICE_SIZE_4);
-    this.visibleExtentOffsetArr = new Float32Array(p.SLICE_SIZE_4);
-    this.transparentColorArr = new Float32Array(p.SLICE_SIZE_4);
-
-    this.clear = function () {
-        this.layers = null;
-        this.tileOffsetArr = null;
-        this.visibleExtentOffsetArr = null;
-        this.transparentColorArr = null;
-    };
-};
-
 let _v0 = new Vec3(),
     _v1 = new Vec3(),
     _v2 = new Vec3(),
@@ -241,7 +228,7 @@ class Segment {
         this._inTheQueue = false;
         this._appliedNeighborsZoom = [0, 0, 0, 0];
 
-        this._renderingSlices = [];
+        this._slices = [];
 
         this._indexBuffer = null;
 
@@ -946,12 +933,12 @@ class Segment {
 
         this.clearSegment();
 
-        var i = this._renderingSlices.length;
+        var i = this._slices.length;
         while (i--) {
-            this._renderingSlices[i].clear();
+            this._slices[i].clear();
         }
 
-        this._renderingSlices = null;
+        this._slices = null;
 
         this.node = null;
 
@@ -990,9 +977,6 @@ class Segment {
         this.vertexPositionBufferLow = null;
         this.vertexTextureCoordBuffer = null;
 
-        this._tileOffsetArr = null;
-        this._visibleExtentOffsetArr = null;
-
         this._projection = null;
         this._appliedNeighborsZoom = null;
 
@@ -1104,10 +1088,10 @@ class Segment {
                     v_rb = new Vec3(bigOne[9], bigOne[10], bigOne[11]);
 
                 let vn = new Vec3(
-                        bigOne[3] - bigOne[0],
-                        bigOne[4] - bigOne[1],
-                        bigOne[5] - bigOne[2]
-                    ),
+                    bigOne[3] - bigOne[0],
+                    bigOne[4] - bigOne[1],
+                    bigOne[5] - bigOne[2]
+                ),
                     vw = new Vec3(
                         bigOne[6] - bigOne[0],
                         bigOne[7] - bigOne[1],
@@ -1291,13 +1275,13 @@ class Segment {
             n.sideSize[2] =
             n.sideSize[3] =
             this.gridSize =
-                p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize;
+            p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize;
 
         n.sideSizeLog2[0] =
             n.sideSizeLog2[1] =
             n.sideSizeLog2[2] =
             n.sideSizeLog2[3] =
-                Math.log2(p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize);
+            Math.log2(p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize);
 
         if (this.tileZoom <= p.terrain.maxZoom) {
             var nmc = this.planet._normalMapCreator;
@@ -1484,11 +1468,12 @@ class Segment {
 
         var notEmpty = false;
 
-        var slice = this._renderingSlices[sliceIndex];
+        var slice = this._slices[sliceIndex];
 
         if (!slice) {
-            slice = this._renderingSlices[sliceIndex] = new _RenderingSlice(p);
+            slice = this._slices[sliceIndex] = new Slice(this);
         } else {
+            //TODO: optimization!!!
             slice.layers = [];
         }
 
@@ -1511,40 +1496,7 @@ class Segment {
                     this.planet._renderCompleted = false;
                 }
 
-                slice.layers.push(li);
-
-                var n4 = n * 4,
-                    n3 = n * 3;
-
-                var arr = li.applyMaterial(m);
-                slice.tileOffsetArr[n4] = arr[0];
-                slice.tileOffsetArr[n4 + 1] = arr[1];
-                slice.tileOffsetArr[n4 + 2] = arr[2];
-                slice.tileOffsetArr[n4 + 3] = arr[3];
-
-                arr = this._getLayerExtentOffset(li);
-                slice.visibleExtentOffsetArr[n4] = arr[0];
-                slice.visibleExtentOffsetArr[n4 + 1] = arr[1];
-                slice.visibleExtentOffsetArr[n4 + 2] = arr[2];
-                slice.visibleExtentOffsetArr[n4 + 3] = arr[3];
-
-                slice.transparentColorArr[n4] = li.transparentColor[0];
-                slice.transparentColorArr[n4 + 1] = li.transparentColor[1];
-                slice.transparentColorArr[n4 + 2] = li.transparentColor[2];
-                slice.transparentColorArr[n4 + 3] = li.opacity;
-
-                p._diffuseMaterialArr[n3 + 3] = li.diffuse.x;
-                p._diffuseMaterialArr[n3 + 1 + 3] = li.diffuse.y;
-                p._diffuseMaterialArr[n3 + 2 + 3] = li.diffuse.z;
-
-                p._ambientMaterialArr[n3 + 3] = li.ambient.x;
-                p._ambientMaterialArr[n3 + 1 + 3] = li.ambient.y;
-                p._ambientMaterialArr[n3 + 2 + 3] = li.ambient.z;
-
-                p._specularMaterialArr[n4 + 4] = li.specular.x;
-                p._specularMaterialArr[n4 + 1 + 4] = li.specular.y;
-                p._specularMaterialArr[n4 + 2 + 4] = li.specular.z;
-                p._specularMaterialArr[n4 + 3 + 4] = li.shininess;
+                slice.append(li, m);
 
                 p._samplerArr[n] = n;
 
@@ -1561,9 +1513,12 @@ class Segment {
             gl.uniform1i(shu.samplerCount, n);
             gl.uniform1f(shu.height, currHeight);
             gl.uniform1iv(shu.samplerArr, p._samplerArr);
+
+            //slice.uniform(gl, shu);
+
             gl.uniform4fv(shu.tileOffsetArr, slice.tileOffsetArr);
-            gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
-            gl.uniform4fv(shu.transparentColorArr, slice.transparentColorArr);
+            gl.uniform1fv(shu.layerOpacityArr, slice.layerOpacityArr);
+            //gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
 
             // bind normalmap texture
             if (p.lightEnabled) {
@@ -1575,30 +1530,12 @@ class Segment {
 
                 // bind segment specular and night material texture coordinates
                 gl.uniform4fv(shu.uGlobalTextureCoord, this._globalTextureCoordinates);
-
-                gl.uniform3fv(shu.diffuseMaterial, p._diffuseMaterialArr);
-                gl.uniform3fv(shu.ambientMaterial, p._ambientMaterialArr);
-                gl.uniform4fv(shu.specularMaterial, p._specularMaterialArr);
             }
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionHigh,
-                this.vertexPositionBufferHigh.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionHigh, this.vertexPositionBufferHigh.itemSize, gl.FLOAT, false, 0, 0);
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferLow);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionLow,
-                this.vertexPositionBufferLow.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionLow, this.vertexPositionBufferLow.itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexTextureCoordBuffer);
             gl.vertexAttribPointer(sha.aTextureCoord, 2, gl.UNSIGNED_SHORT, true, 0, 0);
@@ -1628,13 +1565,13 @@ class Segment {
             currHeight = 0;
         }
 
-        var n = 0;
-
-        var slice = this._renderingSlices[sliceIndex];
+        var slice = this._slices[sliceIndex];
 
         var notEmpty = false;
 
-        for (n = 0; n < slice.layers.length; n++) {
+        let len = slice.layers.length;
+
+        for (let n = 0; n < len; n++) {
             notEmpty = true;
             p._samplerArr[n] = n;
             gl.activeTexture(gl.TEXTURE0 + n);
@@ -1642,32 +1579,21 @@ class Segment {
         }
 
         if (notEmpty || !isOverlay) {
-            gl.uniform1i(shu.samplerCount, n);
+            gl.uniform1i(shu.samplerCount, len);
             gl.uniform1f(shu.height, currHeight);
             gl.uniform1iv(shu.samplerArr, p._samplerArr);
+
+            //slice.uniform(gl, shu);
+
             gl.uniform4fv(shu.tileOffsetArr, slice.tileOffsetArr);
-            gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
-            gl.uniform4fv(shu.transparentColorArr, slice.transparentColorArr);
+            gl.uniform1fv(shu.layerOpacityArr, slice.layerOpacityArr);
+            //gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionHigh,
-                this.vertexPositionBufferHigh.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionHigh, this.vertexPositionBufferHigh.itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferLow);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionLow,
-                this.vertexPositionBufferLow.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionLow, this.vertexPositionBufferLow.itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexTextureCoordBuffer);
             gl.vertexAttribPointer(sha.aTextureCoord, 2, gl.UNSIGNED_SHORT, true, 0, 0);
@@ -1694,9 +1620,11 @@ class Segment {
 
         var notEmpty = false;
 
-        var slice = this._renderingSlices[sliceIndex];
+        var slice = this._slices[sliceIndex];
+
+        let len = slice.layers.length;
 
-        for (var n = 0; n < slice.layers.length; n++) {
+        for (let n = 0; n < len; n++) {
             notEmpty = true;
 
             var li = slice.layers[n];
@@ -1717,33 +1645,22 @@ class Segment {
         }
 
         if (notEmpty || !isOverlay) {
-            gl.uniform1i(shu.samplerCount, n);
+            gl.uniform1i(shu.samplerCount, len);
             gl.uniform1f(shu.height, currHeight);
             gl.uniform1iv(shu.samplerArr, p._samplerArr);
             gl.uniform1iv(shu.pickingMaskArr, p._pickingMaskArr);
-            gl.uniform4fv(shu.tileOffsetArr, slice.tileOffsetArr);
-            gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
-            gl.uniform4fv(shu.transparentColorArr, slice.transparentColorArr);
             gl.uniform4fv(shu.pickingColorArr, p._pickingColorArr);
 
+            //slice.uniform(gl, shu);
+
+            gl.uniform4fv(shu.tileOffsetArr, slice.tileOffsetArr);
+            gl.uniform1fv(shu.layerOpacityArr, slice.layerOpacityArr);
+            //gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
+
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionHigh,
-                this.vertexPositionBufferHigh.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionHigh, this.vertexPositionBufferHigh.itemSize, gl.FLOAT, false, 0, 0);
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferLow);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionLow,
-                this.vertexPositionBufferLow.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionLow, this.vertexPositionBufferLow.itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexTextureCoordBuffer);
             gl.vertexAttribPointer(sha.aTextureCoord, 2, gl.UNSIGNED_SHORT, true, 0, 0);
@@ -1773,13 +1690,13 @@ class Segment {
             currHeight = 0;
         }
 
-        var n = 0;
-
-        var slice = this._renderingSlices[sliceIndex];
+        var slice = this._slices[sliceIndex];
 
         var notEmpty = false;
 
-        for (n = 0; n < slice.layers.length; n++) {
+        let len = slice.layers.length;
+
+        for (let n = 0; n < len; n++) {
             notEmpty = true;
             p._samplerArr[n] = n;
             gl.activeTexture(gl.TEXTURE0 + n);
@@ -1787,32 +1704,21 @@ class Segment {
         }
 
         if (notEmpty || !isOverlay) {
-            gl.uniform1i(shu.samplerCount, n);
+            gl.uniform1i(shu.samplerCount, len);
             gl.uniform1f(shu.height, currHeight);
             gl.uniform1iv(shu.samplerArr, p._samplerArr);
+
+            //slice.uniform(gl, shu);
+
             gl.uniform4fv(shu.tileOffsetArr, slice.tileOffsetArr);
-            gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
-            gl.uniform4fv(shu.transparentColorArr, slice.transparentColorArr);
+            gl.uniform1fv(shu.layerOpacityArr, slice.layerOpacityArr);
+            //gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionHigh,
-                this.vertexPositionBufferHigh.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionHigh, this.vertexPositionBufferHigh.itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferLow);
-            gl.vertexAttribPointer(
-                sha.aVertexPositionLow,
-                this.vertexPositionBufferLow.itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(sha.aVertexPositionLow, this.vertexPositionBufferLow.itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexTextureCoordBuffer);
             gl.vertexAttribPointer(sha.aTextureCoord, 2, gl.UNSIGNED_SHORT, true, 0, 0);
@@ -1826,9 +1732,7 @@ class Segment {
         var s = this.node.sideSizeLog2;
         var cache = this.planet._indexesCache[Math.log2(this.gridSize)][s[0]][s[1]][s[2]][s[3]];
         if (!cache.buffer) {
-            let indexes = segmentHelper
-                .getInstance()
-                .createSegmentIndexes(Math.log2(this.gridSize), [s[0], s[1], s[2], s[3]]);
+            let indexes = segmentHelper.getInstance().createSegmentIndexes(Math.log2(this.gridSize), [s[0], s[1], s[2], s[3]]);
             cache.buffer = this.planet.renderer.handler.createElementArrayBuffer(indexes, 1);
             this.planet._indexesCacheToRemoveCounter++;
             indexes = null;

package/src/og/segment/Slice.js

@@ -0,0 +1,45 @@
+'use strict';
+
+class Slice {
+    constructor(segment) {
+        this.segment = segment;
+        this.layers = [];
+        this.tileOffsetArr = new Float32Array(segment.planet.SLICE_SIZE_4);
+        this.layerOpacityArr = new Float32Array(segment.planet.SLICE_SIZE);
+        this.init();
+    }
+
+    init() {}
+
+    clear() {
+        this.layers = null;
+        this.tileOffsetArr = null;
+        this.layerOpacityArr = null;
+        //this.visibleExtentOffsetArr = null;
+    }
+
+    append(layer, material) {
+        let n = this.layers.length;
+
+        this.layers.push(layer);
+
+        this.layerOpacityArr[n] = layer.opacity;
+
+        let n4 = n * 4;
+
+        let arr = layer.applyMaterial(material);
+        this.tileOffsetArr[n4] = arr[0];
+        this.tileOffsetArr[n4 + 1] = arr[1];
+        this.tileOffsetArr[n4 + 2] = arr[2];
+        this.tileOffsetArr[n4 + 3] = arr[3];
+
+        //arr = this.segment._getLayerExtentOffset(layer);
+        //slice.visibleExtentOffsetArr[n4] = arr[0];
+        //slice.visibleExtentOffsetArr[n4 + 1] = arr[1];
+        //slice.visibleExtentOffsetArr[n4 + 2] = arr[2];
+        //slice.visibleExtentOffsetArr[n4 + 3] = arr[3];
+
+    }
+}
+
+export { Slice }