@openglobus/og 0.11.8 → 0.12.0

package/src/og/quadTree/Node.js

@@ -7,7 +7,6 @@ import { Vec3 } from "../math/Vec3.js";
 import { MAX_LAT } from "../mercator.js";
 import { EPSG3857 } from "../proj/EPSG3857.js";
 import { EPSG4326 } from "../proj/EPSG4326.js";
-import { MAX_NORMAL_ZOOM } from "../segment/Segment.js";
 import { getMatrixSubArray, getMatrixSubArrayBoundsExt } from "../utils/shared.js";
 import {
     COMSIDE,
@@ -30,8 +29,6 @@ import {
     WALKTHROUGH
 } from "./quadTree.js";
 
-const VISIBLE_HEIGHT = 1400000.0;
-
 let _tempHigh = new Vec3(),
     _tempLow = new Vec3();
 
@@ -67,6 +64,7 @@ class Node {
 
     constructor(SegmentPrototype, planet, partId, parent, id, tileZoom, extent) {
         this.SegmentPrototype = SegmentPrototype;
+        planet._createdNodesCount++;
         this.planet = planet;
         this.parentNode = parent;
         this.partId = partId;
@@ -84,7 +82,6 @@ class Node {
         this._cameraInside = false;
         this.inFrustum = 0;
         this.createBounds();
-        this.planet._createdNodesCount++;
     }
 
     createChildrenNodes() {
@@ -102,45 +99,10 @@ class Node {
         var c = new LonLat(sw.lon + size_x, sw.lat + size_y);
         var nd = this.nodes;
 
-        nd[NW] = new Node(
-            this.SegmentPrototype,
-            p,
-            NW,
-            this,
-            id,
-            z,
-            new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat))
-        );
-
-        nd[NE] = new Node(
-            this.SegmentPrototype,
-            p,
-            NE,
-            this,
-            id,
-            z,
-            new Extent(c, new LonLat(ne.lon, ne.lat))
-        );
-
-        nd[SW] = new Node(
-            this.SegmentPrototype,
-            p,
-            SW,
-            this,
-            id,
-            z,
-            new Extent(new LonLat(sw.lon, sw.lat), c)
-        );
-
-        nd[SE] = new Node(
-            this.SegmentPrototype,
-            p,
-            SE,
-            this,
-            id,
-            z,
-            new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y))
-        );
+        nd[NW] = new Node(this.SegmentPrototype, p, NW, this, id, z, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)));
+        nd[NE] = new Node(this.SegmentPrototype, p, NE, this, id, z, new Extent(c, new LonLat(ne.lon, ne.lat)));
+        nd[SW] = new Node(this.SegmentPrototype, p, SW, this, id, z, new Extent(new LonLat(sw.lon, sw.lat), c));
+        nd[SE] = new Node(this.SegmentPrototype, p, SE, this, id, z, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)));
     }
 
     createBounds() {
@@ -153,6 +115,15 @@ class Node {
         } else {
             seg.createBoundsByParent();
         }
+
+        let x = seg.bsphere.center.x,
+            y = seg.bsphere.center.y,
+            z = seg.bsphere.center.z;
+
+        let length = 1.0 / Math.sqrt(x * x + y * y + z * z);
+        seg.centerNormal.x = x * length;
+        seg.centerNormal.y = y * length;
+        seg.centerNormal.z = z * length;
     }
 
     getState() {
@@ -204,15 +175,10 @@ class Node {
     }
 
     renderTree(cam, maxZoom, terrainReadySegment, stopLoading) {
-        if (
-            this.planet._renderedNodes.length >= MAX_RENDERED_NODES ||
-            this.planet._nodeCounterError_ > 2000
-        ) {
+        if (this.planet._renderedNodes.length >= MAX_RENDERED_NODES) {
             return;
         }
 
-        this.planet._nodeCounterError_++;
-
         this.state = WALKTHROUGH;
 
         this.neighbors[0] = null;
@@ -282,27 +248,49 @@ class Node {
         if (this.inFrustum || this._cameraInside || seg.tileZoom < 3) {
             let h = cam._lonLat.height;
 
-            let altVis =
-                cam.eye.distance(seg.bsphere.center) - seg.bsphere.radius <
-                VISIBLE_DISTANCE * Math.sqrt(h) ||
+            let eye = cam.eye;
+            let horizonDist = eye.length2() - this.planet.ellipsoid._b2;
+
+            let altVis = seg.tileZoom > 19 ||
                 (seg.tileZoom < 4 && !seg.terrainReady) ||
                 seg.tileZoom < 2;
 
+            if (h > 21000) {
+                altVis = altVis || eye.distance2(seg._sw) < horizonDist
+                    || eye.distance2(seg._nw) < horizonDist
+                    || eye.distance2(seg._ne) < horizonDist
+                    || eye.distance2(seg._se) < horizonDist;
+            } else {
+                altVis = altVis || cam.eye.distance(seg.bsphere.center) - seg.bsphere.radius < VISIBLE_DISTANCE * Math.sqrt(h);
+            }
+
             if ((this.inFrustum && (altVis || h > 10000.0)) || this._cameraInside) {
                 seg._collectVisibleNodes();
             }
 
             if (seg.tileZoom < 2 && seg.normalMapReady) {
                 this.traverseNodes(cam, maxZoom, terrainReadySegment, stopLoading);
-            } else if ((!maxZoom && seg.acceptForRendering(cam)) || seg.tileZoom === maxZoom || !altVis && maxZoom) {
-                this.prepareForRendering(cam, altVis, this.inFrustum, terrainReadySegment, stopLoading);
-            } else if (seg.tileZoom < planet.terrain._maxNodeZoom && seg.terrainReady) {
-                // Deleting terrainReady here, you have to remove
-                // this.appliedTerrainNodeId !== pn.nodeId in whileTerrainLoading,
-                // also have to fix createBoundsByParent(*)
+            } else if (seg.terrainReady && (
+                !maxZoom && cam.projectedSize(seg.bsphere.center, seg._plainRadius) < planet._lodSize ||
+                maxZoom && ((seg.tileZoom === maxZoom) || !altVis))) {
+
+                if (altVis) {
+                    seg.loadTile = true;
+                    this.renderNode(this.inFrustum, !this.inFrustum, terrainReadySegment, stopLoading);
+                } else {
+                    this.state = NOTRENDERING;
+                }
+
+            } else if (
+                seg.terrainReady &&
+                seg.tileZoom < planet.terrain._maxNodeZoom &&
+                (!maxZoom || maxZoom && cam.projectedSize(seg.bsphere.center, seg.bsphere.radius) > this.planet._maxLodSize)) {
                 this.traverseNodes(cam, maxZoom, seg, stopLoading);
+            } else if (altVis) {
+                seg.loadTile = false;
+                this.renderNode(this.inFrustum, !this.inFrustum, terrainReadySegment, stopLoading);
             } else {
-                this.prepareForRendering(cam, altVis, this.inFrustum, terrainReadySegment, stopLoading);
+                this.state = NOTRENDERING;
             }
         } else {
             this.state = NOTRENDERING;
@@ -322,39 +310,6 @@ class Node {
         n[3].renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
     }
 
-    prepareForRendering(
-        cam,
-        altVis,
-        inFrustum,
-        terrainReadySegment,
-        stopLoading
-    ) {
-        let seg = this.segment;
-
-        if (cam._lonLat.height < VISIBLE_HEIGHT) {
-            if (altVis) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else {
-                this.state = NOTRENDERING;
-            }
-        } else {
-            if (seg.tileZoom < 2) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else if (seg.tileZoom > MAX_NORMAL_ZOOM) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else if (
-                seg._swNorm.dot(cam._n) > 0.0 ||
-                seg._nwNorm.dot(cam._n) > 0.0 ||
-                seg._neNorm.dot(cam._n) > 0.0 ||
-                seg._seNorm.dot(cam._n) > 0.0
-            ) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else {
-                this.state = NOTRENDERING;
-            }
-        }
-    }
-
     renderNode(inFrustum, onlyTerrain, terrainReadySegment, stopLoading) {
         var seg = this.segment;
 
@@ -376,7 +331,7 @@ class Node {
         }
 
         // Create normal map texture
-        if (seg.planet.lightEnabled && !seg.normalMapReady && !seg.parentNormalMapReady) {
+        if (seg.planet.lightEnabled && !seg.normalMapReady /*&& !seg.parentNormalMapReady*/) {
             this.whileNormalMapCreating();
         }
 

package/src/og/quadTree/quadTree.js

@@ -1,7 +1,7 @@
 "use strict";
 
 export const VISIBLE_DISTANCE = 3570.0;
-export const MAX_RENDERED_NODES = 700;
+export const MAX_RENDERED_NODES = 1000;
 
 export const NW = 0;
 export const NE = 1;

package/src/og/renderer/Renderer.js

@@ -210,8 +210,6 @@ class Renderer {
 
         this._currentOutput = "screen";
 
-        this.isActiveBackbuffers = true;
-
         this.labelWorker = new LabelWorker();
     }
 
@@ -481,8 +479,8 @@ class Renderer {
         }
 
         this.handler.onCanvasResize = () => {
+            this.resize();
             this.events.dispatch(this.events.resize, this.handler.canvas);
-            this._resize();
         };
 
         this._screenFrameCornersBuffer = this.handler.createArrayBuffer(
@@ -509,7 +507,7 @@ class Renderer {
         }
     }
 
-    _resize() {
+    resize() {
         let c = this.handler.canvas;
         this.activeCamera.setAspectRatio(c.width / c.height);
         this.sceneFramebuffer.setSize(c.width, c.height);
@@ -744,7 +742,7 @@ class Renderer {
 
         let frustums = this.activeCamera.frustums;
 
-        let anyEvent = this.events.mouseState.anyEvent() && this.isActiveBackbuffers;
+        let anyEvent = this.events.mouseState.anyEvent();
 
         // Rendering scene nodes and entityCollections
         let rn = this._renderNodesArr;

package/src/og/scene/Planet.js

@@ -32,14 +32,16 @@ import { wgs84 } from "../ellipsoid/wgs84.js";
 import { NIGHT, SPECULAR } from "../res/images.js";
 import { Geoid } from "../terrain/Geoid.js";
 import { isUndef } from "../utils/shared.js";
+import { MAX_RENDERED_NODES } from "../quadTree/quadTree.js";
 
-const MAX_LOD = 1.0;
-const MIN_LOD = 0.75;
+const CUR_LOD_SIZE = 250; //px
+const MIN_LOD_SIZE = 312; //px
+const MAX_LOD_SIZE = 190; //px
 
 let _tempPickingPix_ = new Uint8Array(4),
     _tempDepthColor_ = new Uint8Array(4);
 
-const DEPTH_DISTANCE = 11;
+const DEPTH_DISTANCE = 11;//m
 
 /**
  * Maximum created nodes count. The more nodes count the more memory usage.
@@ -49,6 +51,8 @@ const DEPTH_DISTANCE = 11;
  */
 const MAX_NODES = 200;
 
+const HORIZON_TANGENT = 0.81;
+
 const EVENT_NAMES = [
     /**
      * Triggered before globe frame begins to render.
@@ -108,6 +112,13 @@ export class Planet extends RenderNode {
     constructor(options = {}) {
         super(options.name);
 
+        this._cameraFrustums = options.frustums || [
+            [1, 100 + 0.075],
+            [100, 1000 + 0.075],
+            [1000, 1e6 + 10000],
+            [1e6, 1e9]
+        ];
+
         /**
          * @public
          * @type {Ellipsoid}
@@ -378,9 +389,10 @@ export class Planet extends RenderNode {
          * @public
          * @type {number}
          */
-        this._lodRatio = MAX_LOD;
-        this._maxLodRatio = MAX_LOD;
-        this._minLodRatio = MIN_LOD;
+        this._lodSize = CUR_LOD_SIZE;
+        this._curLodSize = CUR_LOD_SIZE;
+        this._minLodSize = MIN_LOD_SIZE;
+        this._maxLodSize = MAX_LOD_SIZE;
 
         this._pickingColorArr = new Float32Array(this.SLICE_SIZE_4);
         this._samplerArr = new Int32Array(this.SLICE_SIZE);
@@ -397,11 +409,11 @@ export class Planet extends RenderNode {
 
         this._normalMapCreator = null;
 
-        this._terrainWorker = new TerrainWorker(2);
+        this._terrainWorker = new TerrainWorker(3);
 
-        this._plainSegmentWorker = new PlainSegmentWorker(2);
+        this._plainSegmentWorker = new PlainSegmentWorker(4);
 
-        this._tileLoader = new Loader(14);
+        this._tileLoader = new Loader(options.loadingBatchSize || 12);
 
         this._memKey = new Key();
 
@@ -433,11 +445,14 @@ export class Planet extends RenderNode {
         control.addTo(this.renderer);
     }
 
-    setRatioLod(maxLod, minLod) {
-        this._maxLodRatio = maxLod;
-        if (minLod) {
-            this._minLodRatio = minLod;
-        }
+    get lodSize() {
+        return this._lodSize;
+    }
+
+    setLodSize(currentLodSize, minLodSize, maxLodSize) {
+        this._maxLodSize = maxLodSize || this._maxLodSize;
+        this._minLodSize = minLodSize || this._minLodSize;
+        this._curLodSize = currentLodSize || this._curLodSize;
         this._renderCompletedActivated = false;
     }
 
@@ -717,6 +732,7 @@ export class Planet extends RenderNode {
         this.transparentTexture = this.renderer.handler.transparentTexture;
 
         this.camera = this.renderer.activeCamera = new PlanetCamera(this, {
+            frustums: this._cameraFrustums,
             eye: new Vec3(0, 0, 28000000),
             look: new Vec3(0, 0, 0),
             up: new Vec3(0, 1, 0),
@@ -981,16 +997,10 @@ export class Planet extends RenderNode {
     _collectRenderNodes() {
         let cam = this.camera;
 
-        this._lodRatio = math.lerp(
-            cam.slope < 0.0 ? 0.0 : cam.slope,
-            this._maxLodRatio,
-            this._minLodRatio
-        );
+        this._lodSize = math.lerp(cam.slope < 0.0 ? 0.0 : cam.slope, this._curLodSize, this._minLodSize);
 
         cam._insideSegment = null;
 
-        this._nodeCounterError_ = 0;
-
         // clear first
         this._clearRenderedNodeList();
 
@@ -1005,11 +1015,11 @@ export class Planet extends RenderNode {
 
         this._quadTree.renderTree(cam, 0, null);
 
-        if (
-            cam.slope > this.minEqualZoomCameraSlope &&
+        if (cam.slope > this.minEqualZoomCameraSlope &&
             cam._lonLat.height < this.maxEqualZoomAltitude &&
             cam._lonLat.height > this.minEqualZoomAltitude
         ) {
+
             this.minCurrZoom = this.maxCurrZoom;
 
             let temp = this._renderedNodes,
@@ -1026,7 +1036,8 @@ export class Planet extends RenderNode {
 
             for (var i = 0, len = temp.length; i < len; i++) {
                 var ri = temp[i];
-                if (ri.segment.tileZoom === this.maxCurrZoom) {
+                let ht = ri.segment.centerNormal.dot(cam._b);
+                if (ri.segment.tileZoom === this.maxCurrZoom || ht < HORIZON_TANGENT) {
                     this._renderedNodes.push(ri);
                     let k = 0,
                         inFrustum = ri.inFrustum;
@@ -1076,9 +1087,7 @@ export class Planet extends RenderNode {
     frame() {
         this._renderScreenNodesPASS();
 
-        if (this.renderer.isActiveBackbuffers) {
-            this._renderHeightPickingFramebufferPASS();
-        }
+        this._renderHeightPickingFramebufferPASS();
 
         this.drawEntityCollections(this._frustumEntityCollections);
     }
@@ -1156,11 +1165,8 @@ export class Planet extends RenderNode {
 
             // bind night glowing material
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE);
-            gl.bindTexture(
-                gl.TEXTURE_2D,
-                (this.camera._lonLat.height > 329958.0 &&
-                    (this._nightTexture || this.transparentTexture)) ||
-                this.transparentTexture
+            gl.bindTexture(gl.TEXTURE_2D,
+                (this.camera._lonLat.height > 329958.0 && (this._nightTexture || this.transparentTexture)) || this.transparentTexture
             );
             gl.uniform1i(shu.nightTexture, this.SLICE_SIZE);
 
@@ -1227,63 +1233,45 @@ export class Planet extends RenderNode {
      * @protected
      */
     _renderHeightPickingFramebufferPASS() {
-        this._heightPickingFramebuffer.activate();
+        if (!this.terrain.isEmpty) {
 
-        let sh;
-        let renderer = this.renderer;
-        let h = renderer.handler;
-        let gl = h.gl;
-        let cam = renderer.activeCamera;
-        let frustumIndex = cam.getCurrentFrustum();
+            this._heightPickingFramebuffer.activate();
 
-        if (frustumIndex === cam.FARTHEST_FRUSTUM_INDEX) {
-            gl.clearColor(0.0, 0.0, 0.0, 1.0);
-            gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
-        } else {
-            gl.clear(gl.DEPTH_BUFFER_BIT);
-        }
-
-        gl.enable(gl.CULL_FACE);
-        gl.blendEquation(gl.FUNC_ADD);
-        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
-        gl.enable(gl.BLEND);
+            let sh;
+            let renderer = this.renderer;
+            let h = renderer.handler;
+            let gl = h.gl;
+            let cam = renderer.activeCamera;
+            let frustumIndex = cam.getCurrentFrustum();
 
-        h.programs.drawnode_heightPicking.activate();
-        sh = h.programs.drawnode_heightPicking._program;
-        let shu = sh.uniforms;
+            if (frustumIndex === cam.FARTHEST_FRUSTUM_INDEX) {
+                gl.clearColor(0.0, 0.0, 0.0, 1.0);
+                gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+            } else {
+                gl.clear(gl.DEPTH_BUFFER_BIT);
+            }
 
-        gl.uniformMatrix4fv(shu.viewMatrix, false, renderer.activeCamera.getViewMatrix());
-        gl.uniformMatrix4fv(
-            shu.projectionMatrix,
-            false,
-            renderer.activeCamera.getProjectionMatrix()
-        );
+            h.programs.drawnode_heightPicking.activate();
+            sh = h.programs.drawnode_heightPicking._program;
+            let shu = sh.uniforms;
 
-        gl.uniform3fv(shu.eyePositionHigh, cam.eyeHigh);
-        gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
+            gl.uniformMatrix4fv(shu.viewMatrix, false, renderer.activeCamera.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, renderer.activeCamera.getProjectionMatrix());
 
-        // drawing planet nodes
-        var rn = this._renderedNodesInFrustum[frustumIndex],
-            sl = this._visibleTileLayerSlices;
+            gl.uniform3fv(shu.eyePositionHigh, cam.eyeHigh);
+            gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
 
-        let i = rn.length;
-        while (i--) {
-            rn[i].segment.heightPickingRendering(sh, sl[0], 0);
-        }
+            // drawing planet nodes
+            var rn = this._renderedNodesInFrustum[frustumIndex],
+                sl = this._visibleTileLayerSlices;
 
-        //gl.enable(gl.POLYGON_OFFSET_FILL);
-        for (let j = 1, len = sl.length; j < len; j++) {
-            i = rn.length;
-            //gl.polygonOffset(0, -j);
+            let i = rn.length;
             while (i--) {
-                rn[i].segment.heightPickingRendering(sh, sl[j], j, this.transparentTexture, true);
+                rn[i].segment.heightPickingRendering(sh, sl[0]);
             }
-        }
-        //gl.disable(gl.POLYGON_OFFSET_FILL);
 
-        gl.disable(gl.BLEND);
-
-        this._heightPickingFramebuffer.deactivate();
+            this._heightPickingFramebuffer.deactivate();
+        }
     }
 
     /**
@@ -1362,15 +1350,7 @@ export class Planet extends RenderNode {
 
         let i = rn.length;
         while (i--) {
-            rn[i].segment.depthRendering(sh, sl[0], 0);
-        }
-
-        for (let j = 1, len = sl.length; j < len; j++) {
-            i = rn.length;
-            gl.polygonOffset(0, -j);
-            while (i--) {
-                rn[i].segment.depthRendering(sh, sl[j], j, this.transparentTexture, true);
-            }
+            rn[i].segment.depthRendering(sh, sl[0]);
         }
     }
 
@@ -1561,41 +1541,48 @@ export class Planet extends RenderNode {
      * @returns {number} -
      */
     getDistanceFromPixel(px) {
-        let r = this.renderer,
-            cnv = this.renderer.handler.canvas;
+        if (this.terrain.isEmpty) {
+            return this.getDistanceFromPixelEllipsoid(px) || 0;
+        } else {
 
-        let spx = px.x / cnv.width,
-            spy = (cnv.height - px.y) / cnv.height;
+            let r = this.renderer,
+                cnv = this.renderer.handler.canvas;
 
-        // HEIGHT
-        this._heightPickingFramebuffer.activate();
-        if (this._heightPickingFramebuffer.isComplete()) {
-            this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
-        }
-        this._heightPickingFramebuffer.deactivate();
-
-        let dist = decodeFloatFromRGBAArr(_tempPickingPix_);
-
-        if (!(_tempPickingPix_[0] || _tempPickingPix_[1] || _tempPickingPix_[2])) {
-            dist = this.getDistanceFromPixelEllipsoid(px) || 0;
-        } else if (dist < DEPTH_DISTANCE) {
-            r.screenDepthFramebuffer.activate();
-            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());
+            let spx = px.x / cnv.width,
+                spy = (cnv.height - px.y) / cnv.height;
+
+            _tempPickingPix_[0] = _tempPickingPix_[1] = _tempPickingPix_[2] = 0.0;
+
+            let dist = 0;
+
+            // HEIGHT
+            this._heightPickingFramebuffer.activate();
+            if (this._heightPickingFramebuffer.isComplete()) {
+                this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
+                dist = decodeFloatFromRGBAArr(_tempPickingPix_);
             }
-            r.screenDepthFramebuffer.deactivate();
+            this._heightPickingFramebuffer.deactivate();
+
+            if (!(_tempPickingPix_[0] || _tempPickingPix_[1] || _tempPickingPix_[2])) {
+                dist = this.getDistanceFromPixelEllipsoid(px) || 0;
+            } else if (dist < DEPTH_DISTANCE) {
+                r.screenDepthFramebuffer.activate();
+                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();
+            }
+            return dist;
         }
-
-        return dist;
     }
 
     /**