@openglobus/og 0.11.7 → 0.11.8

package/src/og/scene/Planet.js

@@ -4,6 +4,7 @@
 
 "use strict";
 
+import * as utils from "../utils/shared.js";
 import * as shaders from "../shaders/drawnode.js";
 import * as math from "../math.js";
 import * as mercator from "../mercator.js";
@@ -335,6 +336,16 @@ export class Planet extends RenderNode {
          */
         this._specularTexture = null;
 
+        //TODO: replace to a function
+        let a = utils.createColorRGB(options.ambient, new Vec3(0.2, 0.2, 0.2));
+        let d = utils.createColorRGB(options.diffuse, new Vec3(0.8, 0.8, 0.8));
+        let s = utils.createColorRGB(options.specular, new Vec3(0.0003, 0.0003, 0.0003));
+        let shininess = options.shininess || 20.0;
+
+        this._ambient = new Float32Array([a.x, a.y, a.z]);
+        this._diffuse = new Float32Array([d.x, d.y, d.z]);
+        this._specular = new Float32Array([s.x, s.y, s.z, shininess]);
+
         /**
          * True for rendering night glowing texture.
          * @protected
@@ -371,14 +382,7 @@ export class Planet extends RenderNode {
         this._maxLodRatio = MAX_LOD;
         this._minLodRatio = MIN_LOD;
 
-        this._diffuseMaterialArr = new Float32Array(this.SLICE_SIZE_3 + 3);
-        this._ambientMaterialArr = new Float32Array(this.SLICE_SIZE_3 + 3);
-        this._specularMaterialArr = new Float32Array(this.SLICE_SIZE_4 + 4);
-
-        this._tileOffsetArr = new Float32Array(this.SLICE_SIZE_4);
-        this._visibleExtentOffsetArr = new Float32Array(this.SLICE_SIZE_4);
-        this._transparentColorArr = new Float32Array(this.SLICE_SIZE_4);
-        this._pickingColorArr = new Float32Array(this.SLICE_SIZE_3);
+        this._pickingColorArr = new Float32Array(this.SLICE_SIZE_4);
         this._samplerArr = new Int32Array(this.SLICE_SIZE);
         this._pickingMaskArr = new Int32Array(this.SLICE_SIZE);
 
@@ -619,11 +623,8 @@ export class Planet extends RenderNode {
         var h = this.renderer.handler;
 
         h.addProgram(shaders.drawnode_screen_nl(), true);
-
         //h.addProgram(shaders.drawnode_screen_wl(), true);
-
         h.addProgram(shaders.drawnode_screen_wl_webgl2(), true);
-
         h.addProgram(shaders.drawnode_colorPicking(), true);
         h.addProgram(shaders.drawnode_depth(), true);
         h.addProgram(shaders.drawnode_heightPicking(), true);
@@ -1075,7 +1076,9 @@ export class Planet extends RenderNode {
     frame() {
         this._renderScreenNodesPASS();
 
-        this._renderHeightPickingFramebufferPASS();
+        if (this.renderer.isActiveBackbuffers) {
+            this._renderHeightPickingFramebufferPASS();
+        }
 
         this.drawEntityCollections(this._frustumEntityCollections);
     }
@@ -1135,7 +1138,6 @@ export class Planet extends RenderNode {
         gl.enable(gl.BLEND);
         gl.blendEquation(gl.FUNC_ADD);
         gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-        //gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ZERO);
 
         if (this.lightEnabled) {
             h.programs.drawnode_screen_wl.activate();
@@ -1148,6 +1150,10 @@ export class Planet extends RenderNode {
             gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
             gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
 
+            gl.uniform3fv(shu.diffuse, this._diffuse);
+            gl.uniform3fv(shu.ambient, this._ambient);
+            gl.uniform4fv(shu.specular, this._specular);
+
             // bind night glowing material
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE);
             gl.bindTexture(
@@ -1163,34 +1169,6 @@ export class Planet extends RenderNode {
             gl.bindTexture(gl.TEXTURE_2D, this._specularTexture || this.transparentTexture);
             gl.uniform1i(shu.specularTexture, this.SLICE_SIZE + 1);
 
-            var b = this.baseLayer;
-            if (b) {
-                this._diffuseMaterialArr[0] = b.diffuse.x;
-                this._diffuseMaterialArr[1] = b.diffuse.y;
-                this._diffuseMaterialArr[2] = b.diffuse.z;
-
-                this._ambientMaterialArr[0] = b.ambient.x;
-                this._ambientMaterialArr[1] = b.ambient.y;
-                this._ambientMaterialArr[2] = b.ambient.z;
-
-                this._specularMaterialArr[0] = b.specular.x;
-                this._specularMaterialArr[1] = b.specular.y;
-                this._specularMaterialArr[2] = b.specular.z;
-                this._specularMaterialArr[3] = b.shininess;
-            } else {
-                this._diffuseMaterialArr[0] = 0.89;
-                this._diffuseMaterialArr[1] = 0.9;
-                this._diffuseMaterialArr[2] = 0.83;
-
-                this._ambientMaterialArr[0] = 0.0;
-                this._ambientMaterialArr[1] = 0.0;
-                this._ambientMaterialArr[2] = 0.0;
-
-                this._specularMaterialArr[0] = 0.0003;
-                this._specularMaterialArr[1] = 0.00012;
-                this._specularMaterialArr[2] = 0.00001;
-                this._specularMaterialArr[3] = 20.0;
-            }
         } else {
             h.programs.drawnode_screen_nl.activate();
             sh = h.programs.drawnode_screen_nl._program;
@@ -1368,6 +1346,7 @@ export class Planet extends RenderNode {
         let cam = renderer.activeCamera;
 
         gl.disable(gl.BLEND);
+        gl.disable(gl.POLYGON_OFFSET_FILL);
 
         gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
         gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
@@ -1386,7 +1365,6 @@ export class Planet extends RenderNode {
             rn[i].segment.depthRendering(sh, sl[0], 0);
         }
 
-        gl.enable(gl.POLYGON_OFFSET_FILL);
         for (let j = 1, len = sl.length; j < len; j++) {
             i = rn.length;
             gl.polygonOffset(0, -j);
@@ -1492,12 +1470,11 @@ export class Planet extends RenderNode {
      * Returns 3d cartesian coordinates on the relief planet by mouse cursor
      * position or null if mouse cursor is outside the planet.
      * @public
-     * @param {Boolean} [force=false] - Force framebuffer rendering.
      * @returns {Vec3} -
      */
-    getCartesianFromMouseTerrain(force) {
+    getCartesianFromMouseTerrain() {
         var ms = this.renderer.events.mouseState;
-        var distance = this.getDistanceFromPixel(ms, force);
+        var distance = this.getDistanceFromPixel(ms);
         if (distance) {
             return ms.direction.scaleTo(distance).addA(this.renderer.activeCamera.eye);
         }
@@ -1512,8 +1489,8 @@ export class Planet extends RenderNode {
      * @param {Boolean} [force=false] - Force framebuffer rendering.
      * @returns {Vec3} -
      */
-    getCartesianFromPixelTerrain(px, force) {
-        var distance = this.getDistanceFromPixel(px, force);
+    getCartesianFromPixelTerrain(px) {
+        var distance = this.getDistanceFromPixel(px);
         if (distance) {
             var direction = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
             return direction.scaleTo(distance).addA(this.renderer.activeCamera.eye);
@@ -1592,7 +1569,9 @@ export class Planet extends RenderNode {
 
         // HEIGHT
         this._heightPickingFramebuffer.activate();
-        this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
+        if (this._heightPickingFramebuffer.isComplete()) {
+            this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
+        }
         this._heightPickingFramebuffer.deactivate();
 
         let dist = decodeFloatFromRGBAArr(_tempPickingPix_);
@@ -1601,20 +1580,19 @@ export class Planet extends RenderNode {
             dist = this.getDistanceFromPixelEllipsoid(px) || 0;
         } else if (dist < DEPTH_DISTANCE) {
             r.screenDepthFramebuffer.activate();
-            r.screenDepthFramebuffer.readPixels(_tempDepthColor_, spx, spy, 0);
+            if (r.screenDepthFramebuffer.isComplete()) {
+                r.screenDepthFramebuffer.readPixels(_tempDepthColor_, spx, spy);
+                let screenPos = new Vec4(
+                    spx * 2.0 - 1.0,
+                    spy * 2.0 - 1.0,
+                    (_tempDepthColor_[0] / 255.0) * 2.0 - 1.0,
+                    1.0 * 2.0 - 1.0
+                );
+                let viewPosition = this.camera.frustums[0]._inverseProjectionMatrix.mulVec4(screenPos);
+                let dir = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
+                dist = -(viewPosition.z / viewPosition.w) / dir.dot(this.renderer.activeCamera.getForward());
+            }
             r.screenDepthFramebuffer.deactivate();
-
-            let screenPos = new Vec4(
-                spx * 2.0 - 1.0,
-                spy * 2.0 - 1.0,
-                (_tempDepthColor_[0] / 255.0) * 2.0 - 1.0,
-                1.0 * 2.0 - 1.0
-            );
-            let viewPosition = this.camera.frustums[0]._inverseProjectionMatrix.mulVec4(screenPos);
-            let dir = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
-            dist =
-                -(viewPosition.z / viewPosition.w) /
-                dir.dot(this.renderer.activeCamera.getForward());
         }
 
         return dist;

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 }