@openglobus/og 0.11.5 → 0.12.0

package/src/og/scene/RenderNode.js

@@ -1,7 +1,7 @@
-'use strict';
+"use strict";
 
-import { BaseNode } from './BaseNode.js';
-import { Events } from '../Events.js';
+import { BaseNode } from "./BaseNode.js";
+import { Events } from "../Events.js";
 
 /**
  * Render node is a logical part of a render mechanism. Represents scene rendering.
@@ -98,8 +98,7 @@ class RenderNode extends BaseNode {
             n = this.name;
 
         if (r) {
-            if (r.renderNodes[n] &&
-                r.renderNodes[n].isEqual(this)) {
+            if (r.renderNodes[n] && r.renderNodes[n].isEqual(this)) {
                 r.renderNodes[n] = null;
                 delete r.renderNodes[n];
             }
@@ -195,7 +194,10 @@ class RenderNode extends BaseNode {
 
         if (this.renderer) {
             if (this._isActive && this._pickingId === -1) {
-                this._pickingId = this.renderer.addPickingCallback(this, this._entityCollectionPickingCallback);
+                this._pickingId = this.renderer.addPickingCallback(
+                    this,
+                    this._entityCollectionPickingCallback
+                );
             } else if (!this._isActive && this._pickingId !== -1) {
                 this.renderer.removePickingCallback(this._pickingId);
                 this._pickingId = -1;
@@ -277,7 +279,6 @@ class RenderNode extends BaseNode {
      */
     drawPickingEntityCollections(ec) {
         if (ec.length) {
-
             var gl = this.renderer.handler.gl;
 
             gl.disable(gl.CULL_FACE);
@@ -292,6 +293,12 @@ class RenderNode extends BaseNode {
                 ec[i]._fadingOpacity && ec[i].billboardHandler.drawPicking();
             }
 
+            // geoObject pass
+            i = ec.length;
+            while (i--) {
+                ec[i]._fadingOpacity && ec[i].geoObjectHandler.drawPicking();
+            }
+
             // label pass
             i = ec.length;
             while (i--) {
@@ -344,4 +351,4 @@ class RenderNode extends BaseNode {
     }
 }
 
-export { RenderNode };
+export { RenderNode };

package/src/og/segment/Segment.js

@@ -12,26 +12,11 @@ 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";
-
-export const MAX_NORMAL_ZOOM = 7;
+import { Slice } from "./Slice.js";
 
 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(),
@@ -54,8 +39,6 @@ _V[E] = true;
 _V[S] = false;
 _V[W] = true;
 
-window.BBSC = 100;
-
 /**
  * Planet segment Web Mercator tile class that stored and rendered with quad tree.
  * @class
@@ -110,10 +93,17 @@ class Segment {
          */
         this.bbox = new Box();
 
-        this._swNorm = null;
-        this._nwNorm = null;
-        this._seNorm = null;
-        this._neNorm = null;
+        //this._swNorm = null;
+        //this._nwNorm = null;
+        //this._seNorm = null;
+        //this._neNorm = null;
+
+        this._sw = new Vec3();
+        this._nw = new Vec3();
+        this._se = new Vec3();
+        this._ne = new Vec3();
+
+        this.centerNormal = new Vec3();
 
         /**
          * Geographical extent.
@@ -241,7 +231,7 @@ class Segment {
         this._inTheQueue = false;
         this._appliedNeighborsZoom = [0, 0, 0, 0];
 
-        this._renderingSlices = [];
+        this._slices = [];
 
         this._indexBuffer = null;
 
@@ -250,19 +240,6 @@ class Segment {
         this.plainProcessing = false;
     }
 
-    /**
-     * Returns that segment good for rendering with camera by current lod ratio.
-     * @public
-     * @param {Camera} camera - Camera object.
-     * @returns {boolean} -
-     */
-    acceptForRendering(camera) {
-        return (
-            camera.projectedSize(this.bsphere.center, this._plainRadius) <
-            256 / this.planet._lodRatio
-        );
-    }
-
     /**
      * Returns entity terrain point.
      * @public
@@ -946,12 +923,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 +967,6 @@ class Segment {
         this.vertexPositionBufferLow = null;
         this.vertexTextureCoordBuffer = null;
 
-        this._tileOffsetArr = null;
-        this._visibleExtentOffsetArr = null;
-
         this._projection = null;
         this._appliedNeighborsZoom = null;
 
@@ -1013,22 +987,19 @@ class Segment {
         var coord_sw = ellipsoid.geodeticToCartesian(extent.southWest.lon, extent.southWest.lat);
         var coord_ne = ellipsoid.geodeticToCartesian(extent.northEast.lon, extent.northEast.lat);
 
-        // check for zoom
-        if (this.tileZoom <= MAX_NORMAL_ZOOM) {
-            var coord_nw = ellipsoid.geodeticToCartesian(
-                extent.southWest.lon,
-                extent.northEast.lat
-            );
-            var coord_se = ellipsoid.geodeticToCartesian(
-                extent.northEast.lon,
-                extent.southWest.lat
-            );
+        var coord_nw = ellipsoid.geodeticToCartesian(
+            extent.southWest.lon,
+            extent.northEast.lat
+        );
+        var coord_se = ellipsoid.geodeticToCartesian(
+            extent.northEast.lon,
+            extent.southWest.lat
+        );
 
-            this._swNorm = coord_sw.normal();
-            this._nwNorm = coord_nw.normal();
-            this._neNorm = coord_ne.normal();
-            this._seNorm = coord_se.normal();
-        }
+        this._sw.copy(coord_sw);
+        this._nw.copy(coord_nw);
+        this._ne.copy(coord_ne);
+        this._se.copy(coord_se);
 
         this.setBoundingVolume3v(coord_sw, coord_ne);
     }
@@ -1057,31 +1028,30 @@ class Segment {
                 this.bsphere.center.z = pn.segment.bsphere.center.z;
                 this.bsphere.radius = pn.segment.bsphere.radius;
 
-                if (this.tileZoom <= MAX_NORMAL_ZOOM) {
-                    let i0 = gridSize * offsetY;
-                    let j0 = gridSize * offsetX;
+                let i0 = gridSize * offsetY;
+                let j0 = gridSize * offsetX;
 
-                    let pnGsOne = pn.segment.gridSize + 1;
+                let pnGsOne = pn.segment.gridSize + 1;
 
-                    let ind_sw = 3 * ((i0 + gridSize) * pnGsOne + j0),
-                        ind_nw = 3 * (i0 * pnGsOne + j0),
-                        ind_ne = 3 * (i0 * pnGsOne + j0 + gridSize),
-                        ind_se = 3 * ((i0 + gridSize) * pnGsOne + j0 + gridSize);
+                let ind_sw = 3 * ((i0 + gridSize) * pnGsOne + j0),
+                    ind_nw = 3 * (i0 * pnGsOne + j0),
+                    ind_ne = 3 * (i0 * pnGsOne + j0 + gridSize),
+                    ind_se = 3 * ((i0 + gridSize) * pnGsOne + j0 + gridSize);
 
-                    let pVerts = pn.segment.tempVertices;
+                let pVerts = pn.segment.tempVertices;
 
-                    let v_sw = new Vec3(pVerts[ind_sw], pVerts[ind_sw + 1], pVerts[ind_sw + 2]),
-                        v_ne = new Vec3(pVerts[ind_ne], pVerts[ind_ne + 1], pVerts[ind_ne + 2]);
+                let v_sw = new Vec3(pVerts[ind_sw], pVerts[ind_sw + 1], pVerts[ind_sw + 2]),
+                    v_ne = new Vec3(pVerts[ind_ne], pVerts[ind_ne + 1], pVerts[ind_ne + 2]);
 
-                    // check for segment zoom
-                    let v_nw = new Vec3(pVerts[ind_nw], pVerts[ind_nw + 1], pVerts[ind_nw + 2]),
-                        v_se = new Vec3(pVerts[ind_se], pVerts[ind_se + 1], pVerts[ind_se + 2]);
+                // check for segment zoom
+                let v_nw = new Vec3(pVerts[ind_nw], pVerts[ind_nw + 1], pVerts[ind_nw + 2]),
+                    v_se = new Vec3(pVerts[ind_se], pVerts[ind_se + 1], pVerts[ind_se + 2]);
+
+                this._sw.copy(v_sw);
+                this._nw.copy(v_nw);
+                this._ne.copy(v_ne);
+                this._se.copy(v_se);
 
-                    this._swNorm = v_sw.normal();
-                    this._nwNorm = v_nw.normal();
-                    this._neNorm = v_ne.normal();
-                    this._seNorm = v_se.normal();
-                }
             } else {
                 let pseg = pn.segment;
 
@@ -1104,10 +1074,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 +1261,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 +1454,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 +1482,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 +1499,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 +1516,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);
@@ -1608,7 +1531,7 @@ class Segment {
         }
     }
 
-    heightPickingRendering(sh, layerSlice, sliceIndex, defaultTexture, isOverlay) {
+    heightPickingRendering(sh, layerSlice) {
         var gl = this.handler.gl;
         var sha = sh.attributes,
             shu = sh.uniforms;
@@ -1616,11 +1539,6 @@ class Segment {
         var pm = this.materials,
             p = this.planet;
 
-        // First always draw whole planet base layer segment with solid texture.
-        gl.activeTexture(gl.TEXTURE0 + p.SLICE_SIZE);
-        gl.bindTexture(gl.TEXTURE_2D, defaultTexture || p.solidTextureOne);
-        gl.uniform1i(shu.defaultTexture, p.SLICE_SIZE);
-
         var currHeight;
         if (layerSlice) {
             currHeight = layerSlice[0]._height;
@@ -1628,53 +1546,16 @@ class Segment {
             currHeight = 0;
         }
 
-        var n = 0;
-
-        var slice = this._renderingSlices[sliceIndex];
+        gl.uniform1f(shu.height, currHeight);
 
-        var notEmpty = false;
-
-        for (n = 0; n < slice.layers.length; n++) {
-            notEmpty = true;
-            p._samplerArr[n] = n;
-            gl.activeTexture(gl.TEXTURE0 + n);
-            gl.bindTexture(gl.TEXTURE_2D, pm[slice.layers[n]._id].texture || p.transparentTexture);
-        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
+        gl.vertexAttribPointer(sha.aVertexPositionHigh, this.vertexPositionBufferHigh.itemSize, gl.FLOAT, false, 0, 0);
 
-        if (notEmpty || !isOverlay) {
-            gl.uniform1i(shu.samplerCount, n);
-            gl.uniform1f(shu.height, currHeight);
-            gl.uniform1iv(shu.samplerArr, p._samplerArr);
-            gl.uniform4fv(shu.tileOffsetArr, slice.tileOffsetArr);
-            gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
-            gl.uniform4fv(shu.transparentColorArr, slice.transparentColorArr);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferLow);
+        gl.vertexAttribPointer(sha.aVertexPositionLow, this.vertexPositionBufferLow.itemSize, gl.FLOAT, false, 0, 0);
 
-            gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
-            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.bindBuffer(gl.ARRAY_BUFFER, this.vertexTextureCoordBuffer);
-            gl.vertexAttribPointer(sha.aTextureCoord, 2, gl.UNSIGNED_SHORT, true, 0, 0);
-
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
-            gl.drawElements(gl.TRIANGLE_STRIP, this._indexBuffer.numItems, gl.UNSIGNED_INT, 0);
-        }
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
+        gl.drawElements(gl.TRIANGLE_STRIP, this._indexBuffer.numItems, gl.UNSIGNED_INT, 0);
     }
 
     colorPickingRendering(sh, layerSlice, sliceIndex, defaultTexture, isOverlay) {
@@ -1694,9 +1575,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 +1600,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);
@@ -1753,19 +1625,11 @@ class Segment {
         }
     }
 
-    depthRendering(sh, layerSlice, sliceIndex, defaultTexture, isOverlay) {
+    depthRendering(sh, layerSlice) {
         var gl = this.handler.gl;
         var sha = sh.attributes,
             shu = sh.uniforms;
 
-        var pm = this.materials,
-            p = this.planet;
-
-        // First always draw whole planet base layer segment with solid texture.
-        gl.activeTexture(gl.TEXTURE0 + p.SLICE_SIZE);
-        gl.bindTexture(gl.TEXTURE_2D, defaultTexture || p.solidTextureOne);
-        gl.uniform1i(shu.defaultTexture, p.SLICE_SIZE);
-
         var currHeight;
         if (layerSlice) {
             currHeight = layerSlice[0]._height;
@@ -1773,62 +1637,23 @@ class Segment {
             currHeight = 0;
         }
 
-        var n = 0;
+        gl.uniform1f(shu.height, currHeight);
 
-        var slice = this._renderingSlices[sliceIndex];
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
+        gl.vertexAttribPointer(sha.aVertexPositionHigh, this.vertexPositionBufferHigh.itemSize, gl.FLOAT, false, 0, 0);
 
-        var notEmpty = false;
-
-        for (n = 0; n < slice.layers.length; n++) {
-            notEmpty = true;
-            p._samplerArr[n] = n;
-            gl.activeTexture(gl.TEXTURE0 + n);
-            gl.bindTexture(gl.TEXTURE_2D, pm[slice.layers[n]._id].texture || p.transparentTexture);
-        }
-
-        if (notEmpty || !isOverlay) {
-            gl.uniform1i(shu.samplerCount, n);
-            gl.uniform1f(shu.height, currHeight);
-            gl.uniform1iv(shu.samplerArr, p._samplerArr);
-            gl.uniform4fv(shu.tileOffsetArr, slice.tileOffsetArr);
-            gl.uniform4fv(shu.visibleExtentOffsetArr, slice.visibleExtentOffsetArr);
-            gl.uniform4fv(shu.transparentColorArr, slice.transparentColorArr);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferLow);
+        gl.vertexAttribPointer(sha.aVertexPositionLow, this.vertexPositionBufferLow.itemSize, gl.FLOAT, false, 0, 0);
 
-            gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBufferHigh);
-            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.bindBuffer(gl.ARRAY_BUFFER, this.vertexTextureCoordBuffer);
-            gl.vertexAttribPointer(sha.aTextureCoord, 2, gl.UNSIGNED_SHORT, true, 0, 0);
-
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
-            gl.drawElements(gl.TRIANGLE_STRIP, this._indexBuffer.numItems, gl.UNSIGNED_INT, 0);
-        }
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
+        gl.drawElements(gl.TRIANGLE_STRIP, this._indexBuffer.numItems, gl.UNSIGNED_INT, 0);
     }
 
     _getIndexBuffer() {
         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 }