@openglobus/og 0.18.4 → 0.19.0

package/lib/js/renderer/Renderer.js

@@ -7,7 +7,6 @@ import { FontAtlas } from "../utils/FontAtlas";
 import { input } from "../input/input";
 import { isEmpty } from "../utils/shared";
 import { LabelWorker } from "../entity/LabelWorker";
-import { pickingMask } from "../shaders/pickingMask";
 import { randomi } from "../math";
 import { screenFrame } from "../shaders/screenFrame";
 import { toneMapping } from "../shaders/toneMapping";
@@ -197,7 +196,6 @@ class Renderer {
         this.screenFramePositionBuffer = null;
         this.screenTexture = {};
         this.outputTexture = null;
-        this._pickingMaskCoordinatesBuffer = null;
         this._skipDistanceFrame = false;
         this._distancePixelBuffer = null;
         this._skipPickingFrame = false;
@@ -418,7 +416,7 @@ class Renderer {
         });
         this.handler.addProgram(screenFrame());
         this.pickingFramebuffer = new Framebuffer(this.handler, {
-            width: 640, height: 480, depthComponent: "DEPTH_STENCIL", renderbufferTarget: "DEPTH_STENCIL_ATTACHMENT"
+            width: 640, height: 480
         });
         this.pickingFramebuffer.init();
         this._tempPickingPix_ = new Uint8Array(this.pickingFramebuffer.width * this.pickingFramebuffer.height * 4);
@@ -491,7 +489,6 @@ class Renderer {
             };
             this._initReadPixelsBuffers();
         }
-        this.handler.addProgram(pickingMask());
         this.handler.ONCANVASRESIZE = () => {
             this._resizeStart();
             this.events.dispatch(this.events.resize, this.handler.canvas);
@@ -505,7 +502,6 @@ class Renderer {
         };
         this.screenFramePositionBuffer = this.handler.createArrayBuffer(new Float32Array([1, 1, -1, 1, 1, -1, -1, -1]), 2, 4);
         this.outputTexture = this.screenTexture.screen;
-        this._pickingMaskCoordinatesBuffer = this.handler.createArrayBuffer(new Float32Array([0, 0]), 2, 1);
         this._initializeRenderNodes();
         this._initializeControls();
     }
@@ -644,17 +640,8 @@ class Renderer {
         let ec = this._entityCollections;
         if (ec.length) {
             this.enableBlendDefault();
-            //geoObject
-            let i = ec.length;
-            while (i--) {
-                let eci = ec[i];
-                if (ec[i]._fadingOpacity) {
-                    eci.events.dispatch(eci.events.draw, eci);
-                    ec[i].geoObjectHandler.draw();
-                }
-            }
             // pointClouds pass
-            i = ec.length;
+            let i = ec.length;
             while (i--) {
                 ec[i]._fadingOpacity && ec[i].pointCloudHandler.draw();
             }
@@ -669,10 +656,19 @@ class Renderer {
         if (ec.length) {
             let gl = this.handler.gl;
             this.enableBlendDefault();
+            // GeoObjects
+            let i = ec.length;
+            while (i--) {
+                let eci = ec[i];
+                if (ec[i]._fadingOpacity) {
+                    eci.events.dispatch(eci.events.draw, eci);
+                    ec[i].geoObjectHandler.draw();
+                }
+            }
             // billboards pass
             gl.activeTexture(gl.TEXTURE0);
             gl.bindTexture(gl.TEXTURE_2D, this.billboardsTextureAtlas.texture);
-            let i = ec.length;
+            i = ec.length;
             while (i--) {
                 let eci = ec[i];
                 eci._fadingOpacity && eci.billboardHandler.draw();
@@ -721,6 +717,7 @@ class Renderer {
         let h = this.handler, gl = h.gl;
         gl.clearColor(0.0, 0.0, 0.0, 1.0);
         gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+        this.enableBlendDefault();
         e.dispatch(e.draw, this);
         let frustums = this.activeCamera.frustums;
         let pointerEvent = e.pointerEvent() || this.activeCamera.isMoving;
@@ -742,6 +739,7 @@ class Renderer {
             }
             this._drawTransparentEntityCollections();
             this._clearEntityCollectionQueue();
+            e.dispatch(e.drawtransparent, this);
             if (pointerEvent) {
                 this._drawPickingBuffer();
                 this.__useDistanceFramebuffer__ && this._drawDistanceBuffer();
@@ -815,44 +813,24 @@ class Renderer {
         let gl = h.gl;
         if (this.activeCamera.isFirstPass) {
             gl.clearColor(0.0, 0.0, 0.0, 1.0);
-            gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+            gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
         }
         else {
-            gl.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+            gl.clear(gl.DEPTH_BUFFER_BIT);
         }
-        //
-        // draw picking mask
-        //
-        h.programs.pickingMask.activate();
-        let sh = h.programs.pickingMask._program;
-        let shu = sh.uniforms, sha = sh.attributes;
-        let /*ts = this.events.touchState,*/ ms = this.events.mouseState;
-        gl.disable(gl.DEPTH_TEST);
-        gl.enable(gl.STENCIL_TEST);
-        gl.colorMask(false, false, false, false);
-        gl.stencilFunc(gl.ALWAYS, 2, 0xFF);
-        gl.stencilOp(gl.REPLACE, gl.ZERO, gl.REPLACE);
-        gl.uniform2f(shu.offset, (ms.nx - 0.5) * 2, (0.5 - ms.ny) * 2);
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._pickingMaskCoordinatesBuffer);
-        gl.vertexAttribPointer(sha.coordinates, this._pickingMaskCoordinatesBuffer.itemSize, gl.FLOAT, false, 0, 0);
-        gl.drawArrays(gl.POINTS, 0, this._pickingMaskCoordinatesBuffer.numItems);
-        gl.enable(gl.DEPTH_TEST);
-        //
-        // draw picking scenes
-        //
-        gl.colorMask(true, true, true, true);
-        gl.stencilFunc(gl.EQUAL, 2, 0xFF);
-        gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
-        gl.disable(gl.BLEND);
         let dp = this._pickingCallbacks;
         for (let i = 0, len = dp.length; i < len; i++) {
+            //
+            // draw picking scenes, usually we don't need blending,
+            // but sometimes set it manually in the callbacks
+            //
+            gl.disable(gl.BLEND);
             /**
              * This callback renders picking frame.
              */
             dp[i].callback.call(dp[i].sender);
+            gl.enable(gl.BLEND);
         }
-        gl.enable(gl.BLEND);
-        gl.disable(gl.STENCIL_TEST);
         this.pickingFramebuffer.deactivate();
     }
     /**

package/lib/js/renderer/RendererEvents.d.ts

@@ -9,6 +9,7 @@ export type RendererEventsHandler = RendererEvents & EventsHandler<RendererEvent
 export declare function createRendererEvents(renderer: Renderer): RendererEvents;
 export type RendererEventsType = [
     "draw",
+    "drawtransparent",
     "postdraw",
     "resize",
     "resizeend",

package/lib/js/renderer/RendererEvents.js

@@ -11,8 +11,6 @@ export function createRendererEvents(renderer) {
 const LB_M = 0b0001;
 const RB_M = 0b0010;
 const MB_M = 0b0100;
-let __skipFrames__ = 0;
-const MAX_SKIP_FRAMES_ON_BLACK = 15;
 const ISBLACK = (c) => !(c[0] || c[1] || c[2]);
 const NOTBLACK = (c) => !!(c[0] || c[1] || c[2]);
 /**
@@ -454,11 +452,6 @@ class RendererEvents extends Events {
             else {
                 r.readPickingColor(ms.nx, 1 - ms.ny, t);
             }
-            // current is black
-            if (ISBLACK(t) && __skipFrames__++ < MAX_SKIP_FRAMES_ON_BLACK) {
-                return;
-            }
-            __skipFrames__ = 0;
             p[0] = c[0];
             p[1] = c[1];
             p[2] = c[2];
@@ -717,6 +710,11 @@ const RENDERER_EVENTS = [
      * @event og.RendererEvents#draw
      */
     "draw",
+    /**
+     * Triggered after all transparent object are drawn
+     * @event og.RendererEvents#drawtransparent
+     */
+    "drawtransparent",
     /**
      * Triggered after scene frame is rendered(after render nodes).
      * @event og.RendererEvents#postdraw

package/lib/js/scene/Planet.d.ts

@@ -23,6 +23,8 @@ import { TerrainWorker } from "../utils/TerrainWorker";
 import { Vec2, Vec3, NumberArray2, NumberArray3, NumberArray4 } from "../math/index";
 import { VectorTileCreator } from "../utils/VectorTileCreator";
 import { WebGLBufferExt, WebGLTextureExt, IDefaultTextureParams } from "../webgl/Handler";
+import { Program } from "../webgl/Program";
+import { Segment } from "../segment/Segment";
 export interface IPlanetParams {
     name?: string;
     ellipsoid?: Ellipsoid;
@@ -42,6 +44,7 @@ export interface IPlanetParams {
     maxGridSize?: number;
     maxLoadingRequests?: number;
     atmosphereEnabled?: boolean;
+    transitionOpacityEnabled?: boolean;
 }
 export type PlanetEventsList = [
     "draw",
@@ -176,6 +179,8 @@ export declare class Planet extends RenderNode {
      */
     _renderedNodes: Node[];
     _renderedNodesInFrustum: Node[][];
+    _fadingNodes: Map<number, Node>;
+    _fadingNodesInFrustum: Node[][];
     /**
      * Current visible mercator segments tree nodes array.
      * @public
@@ -306,7 +311,8 @@ export declare class Planet extends RenderNode {
      * @type {number}
      */
     nightTextureCoefficient: number;
-    protected _renderScreenNodesPASS: Function;
+    protected _renderScreenNodesPASS: () => void;
+    protected _renderScreenNodesWithHeightPASS: () => void;
     protected _atmosphereEnabled: boolean;
     protected _atmosphereMaxMinOpacity: Float32Array;
     solidTextureOne: WebGLTextureExt | null;
@@ -314,7 +320,15 @@ export declare class Planet extends RenderNode {
     protected _skipPreRender: boolean;
     protected _nightTextureSrc: string | null;
     protected _specularTextureSrc: string | null;
+    transitionTime: number;
+    _prevNodes: Map<number, Node>;
+    _currNodes: Map<number, Node>;
+    protected _transitionOpacityEnabled: boolean;
     constructor(options?: IPlanetParams);
+    /**
+     * Returns true if current terrain data set is loaded
+     */
+    get terrainReady(): boolean;
     get maxGridSize(): number;
     getNorthFrameRotation(cartesian: Vec3): Quat;
     set atmosphereMaxOpacity(opacity: number);
@@ -443,11 +457,18 @@ export declare class Planet extends RenderNode {
     protected _sortLayers(): void;
     protected _clearRenderedNodeList(): void;
     protected _clearRenderNodesInFrustum(): void;
+    protected _collectRenderedNodesMaxZoom(cam: PlanetCamera): void;
+    set transitionOpacityEnabled(isEnabled: boolean);
+    get transitionOpacityEnabled(): boolean;
     /**
      * Collects visible quad nodes.
      * @protected
      */
-    protected _collectRenderNodes(): void;
+    protected _collectRenderNodes(cam: PlanetCamera): void;
+    protected _renderScreenNodesPASSNoAtmos(): void;
+    protected _renderScreenNodesPASSAtmos(): void;
+    protected _renderScreenNodesWithHeightPASSNoAtmos(): void;
+    protected _renderScreenNodesWithHeightPASSAtmos(): void;
     protected _globalPreDraw(): void;
     /**
      * Render node callback.
@@ -456,6 +477,7 @@ export declare class Planet extends RenderNode {
     preFrame(): void;
     /**
      * Render node callback.
+     * Frame function is called for each renderer activrCamera frustum.
      * @public
      * @override
      */
@@ -463,8 +485,15 @@ export declare class Planet extends RenderNode {
     protected _checkRendercompleted(): void;
     lockQuadTree(): void;
     unlockQuadTree(): void;
-    protected _renderScreenNodesPASSNoAtmos(): void;
-    protected _renderScreenNodesPASSAtmos(): void;
+    protected _setUniformsNoAtmos(cam: PlanetCamera): Program;
+    protected _setUniformsAtmos(cam: PlanetCamera): Program;
+    protected _renderingFadingNodes: (nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number, outTransparentSegments?: Segment[]) => void;
+    protected _renderingFadingNodesNoDepth: (nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number) => void;
+    /**
+     * Drawing nodes
+     */
+    protected _renderingScreenNodes(sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
+    protected _renderingScreenNodesWithHeight(sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
     protected _renderDistanceFramebufferPASS(): void;
     protected _renderColorPickingFramebufferPASS(): void;
     protected _renderDepthFramebufferPASS(): void;