archive-gh-me/openglobus
1
0
Fork 0
mirror of https://github.com/openglobus/openglobus.git synced 2025-12-08 19:25:27 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #907 from openglobus/857_shadows-screenRender

Browse Source 
test before mr
This commit is contained in:
Michael Gevlich 2025-07-23 14:25:44 +04:00 committed by GitHub
commit be32f09e63
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 80 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
sandbox/osm.js
View File

@ -87,24 +87,19 @@ globus.planet.addControl(new control.KeyboardNavigation({
}) })
); );
let toneMappingFramebufferPreview = new control.FramebufferPreview({ // let toneMappingFramebufferPreview = new control.FramebufferPreview({
title: "toneMappingFramebuffer", // title: "toneMappingFramebuffer",
framebuffer: globus.renderer.toneMappingFramebuffer, // framebuffer: globus.renderer.toneMappingFramebuffer,
flippedUV: true // flippedUV: true
}); // });
globus.planet.addControl(toneMappingFramebufferPreview); // globus.planet.addControl(toneMappingFramebufferPreview);
let pickingFramebufferPreview = new control.FramebufferPreview({ // let pickingFramebufferPreview = new control.FramebufferPreview({
title: "pickingFramebuffer", // title: "pickingFramebuffer",
framebuffer: globus.renderer.pickingFramebuffer, // framebuffer: globus.renderer.pickingFramebuffer,
flippedUV: true // flippedUV: true
}); // });
globus.planet.addControl(pickingFramebufferPreview); // globus.planet.addControl(pickingFramebufferPreview);
globus.planet.addControl(new control.KeyboardNavigation({
camera: depthHandler.camera
}));
globus.planet.renderer.controls.SimpleSkyBackground.colorOne = "black"; globus.planet.renderer.controls.SimpleSkyBackground.colorOne = "black";
globus.planet.renderer.controls.SimpleSkyBackground.colorTwo = "black"; globus.planet.renderer.controls.SimpleSkyBackground.colorTwo = "black";

22
src/control/cameraDepthHandler/CameraDepthHandler.ts
View File

@ -52,7 +52,7 @@ export interface ICameraDepthHandlerParams extends IControlParams {
export class CameraDepthHandler extends Control { export class CameraDepthHandler extends Control {
protected _depthCameraFrameHandler: CameraFrameHandler | null; protected _frameHandler: CameraFrameHandler | null;
protected _frameComposer: CameraFrameComposer; protected _frameComposer: CameraFrameComposer;
public readonly cameraGeoImage: GeoImage; public readonly cameraGeoImage: GeoImage;
@ -65,7 +65,7 @@ export class CameraDepthHandler extends Control {
super(params); super(params);
this._frameComposer = new CameraFrameComposer(); this._frameComposer = new CameraFrameComposer();
this._depthCameraFrameHandler = null; this._frameHandler = null;
this.cameraGeoImage = new GeoImage(`cameraGeoImage:${this.__id}`, { this.cameraGeoImage = new GeoImage(`cameraGeoImage:${this.__id}`, {
src: "test4.jpg", src: "test4.jpg",
@ -97,8 +97,8 @@ export class CameraDepthHandler extends Control {
} }
public get camera(): Camera | undefined { public get camera(): Camera | undefined {
if (this._depthCameraFrameHandler) { if (this._frameHandler) {
return this._depthCameraFrameHandler.camera; return this._frameHandler.camera;
} }
} }
@ -125,7 +125,7 @@ export class CameraDepthHandler extends Control {
useDepth: true useDepth: true
}); });
this._depthCameraFrameHandler = new CameraFrameHandler({ this._frameHandler = new CameraFrameHandler({
camera: this._createCamera(), camera: this._createCamera(),
frameBuffer: depthFramebuffer, frameBuffer: depthFramebuffer,
frameHandler: this._depthHandlerCallback frameHandler: this._depthHandlerCallback
@ -137,7 +137,7 @@ export class CameraDepthHandler extends Control {
this.renderer.addControl(this._frameComposer); this.renderer.addControl(this._frameComposer);
} }
this._frameComposer.add(this._depthCameraFrameHandler); this._frameComposer.add(this._frameHandler);
if (this.planet) { if (this.planet) {
@ -161,8 +161,8 @@ export class CameraDepthHandler extends Control {
} }
public get framebuffer(): Framebuffer | undefined { public get framebuffer(): Framebuffer | undefined {
if (this._depthCameraFrameHandler) { if (this._frameHandler) {
return this._depthCameraFrameHandler.frameBuffer; return this._frameHandler.frameBuffer;
} }
} }
@ -235,9 +235,9 @@ export class CameraDepthHandler extends Control {
} }
public getCartesianFromPixelTerrain(x: number, y: number): Vec3 | undefined { public getCartesianFromPixelTerrain(x: number, y: number): Vec3 | undefined {
if (this._depthCameraFrameHandler) { if (this._frameHandler) {
let framebuffer = this._depthCameraFrameHandler.frameBuffer; let framebuffer = this._frameHandler.frameBuffer;
let camera = this._depthCameraFrameHandler.camera; let camera = this._frameHandler.camera;
let distance = getDistanceFromPixel(x, y, camera, framebuffer); let distance = getDistanceFromPixel(x, y, camera, framebuffer);
if (distance === 0) { if (distance === 0) {
return; return;

95
src/scene/Planet.ts
View File

@ -1105,7 +1105,7 @@ export class Planet extends RenderNode {
let sh = this._setUniformsNoAtmos(cam); let sh = this._setUniformsNoAtmos(cam);
// //
// PASS 0: rendering base slice of layers, which is often zero height // PASS 0: rendering base slice of layers, which is often zero height
this._renderingScreenNodes(sh, cam); this._renderingScreenNodes(this.quadTreeStrategy, sh, cam, this.quadTreeStrategy._renderedNodesInFrustum[cam.currentFrustumIndex]);
} }
protected _renderScreenNodesPASSAtmos() { protected _renderScreenNodesPASSAtmos() {
@ -1113,7 +1113,7 @@ export class Planet extends RenderNode {
let sh = this._setUniformsAtmos(cam); let sh = this._setUniformsAtmos(cam);
// //
// PASS 0: rendering base slice of layers, which is often zero height // PASS 0: rendering base slice of layers, which is often zero height
this._renderingScreenNodes(sh, cam); this._renderingScreenNodes(this.quadTreeStrategy, sh, cam, this.quadTreeStrategy._renderedNodesInFrustum[cam.currentFrustumIndex]);
} }
protected _renderScreenNodesWithHeightPASSNoAtmos() { protected _renderScreenNodesWithHeightPASSNoAtmos() {
@ -1121,7 +1121,7 @@ export class Planet extends RenderNode {
let sh = this._setUniformsNoAtmos(cam); let sh = this._setUniformsNoAtmos(cam);
// //
// PASS 1: rendering slices, and layers with heights, without transition opacity effect // PASS 1: rendering slices, and layers with heights, without transition opacity effect
this._renderingScreenNodesWithHeight(sh, cam); this._renderingScreenNodesWithHeight(this.quadTreeStrategy, sh, cam, this.quadTreeStrategy._renderedNodesInFrustum[cam.currentFrustumIndex]);
} }
protected _renderScreenNodesWithHeightPASSAtmos() { protected _renderScreenNodesWithHeightPASSAtmos() {
@ -1129,7 +1129,7 @@ export class Planet extends RenderNode {
let sh = this._setUniformsAtmos(cam); let sh = this._setUniformsAtmos(cam);
// //
// PASS 1: rendering slices, and layers with heights, without transition opacity effect // PASS 1: rendering slices, and layers with heights, without transition opacity effect
this._renderingScreenNodesWithHeight(sh, cam); this._renderingScreenNodesWithHeight(this.quadTreeStrategy, sh, cam, this.quadTreeStrategy._renderedNodesInFrustum[cam.currentFrustumIndex]);
} }
protected _globalPreDraw() { protected _globalPreDraw() {
@ -1346,14 +1346,23 @@ export class Planet extends RenderNode {
return sh; return sh;
} }
protected _renderingFadingNodes = (nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number, outTransparentSegments?: Segment[], outOpaqueSegments?: Segment[]) => { protected _renderingFadingNodes = (
quadTreeStrategy: QuadTreeStrategy,
nodes: Map<number, boolean>,
sh: Program,
currentNode: Node,
sl: Layer[],
sliceIndex: number,
outTransparentSegments?: Segment[],
outOpaqueSegments?: Segment[]
) => {
let isFirstPass = sliceIndex === 0; let isFirstPass = sliceIndex === 0;
let isEq = this.terrain!.equalizeVertices; let isEq = this.terrain!.equalizeVertices;
for (let j = 0, len = currentNode._fadingNodes.length; j < len; j++) { for (let j = 0, len = currentNode._fadingNodes.length; j < len; j++) {
let f = currentNode._fadingNodes[j].segment; let f = currentNode._fadingNodes[j].segment;
if (this.quadTreeStrategy._fadingNodes.has(currentNode._fadingNodes[0].__id) && !nodes.has(f.node.__id)) { if (quadTreeStrategy._fadingNodes.has(currentNode._fadingNodes[0].__id) && !nodes.has(f.node.__id)) {
nodes.set(f.node.__id, true); nodes.set(f.node.__id, true);
if (f._transitionOpacity < 1.0) { if (f._transitionOpacity < 1.0) {
@ -1372,7 +1381,15 @@ export class Planet extends RenderNode {
} }
} }
protected _renderingFadingNodesNoDepth = (nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number, outOpaqueSegments?: Segment[]) => { protected _renderingFadingNodesNoDepth = (
quadTreeStrategy: QuadTreeStrategy,
nodes: Map<number, boolean>,
sh: Program,
currentNode: Node,
sl: Layer[],
sliceIndex: number,
outOpaqueSegments?: Segment[]
) => {
let isFirstPass = sliceIndex === 0; let isFirstPass = sliceIndex === 0;
let isEq = this.terrain!.equalizeVertices; let isEq = this.terrain!.equalizeVertices;
@ -1382,7 +1399,7 @@ export class Planet extends RenderNode {
for (let j = 0, len = currentNode._fadingNodes.length; j < len; j++) { for (let j = 0, len = currentNode._fadingNodes.length; j < len; j++) {
let f = currentNode._fadingNodes[j].segment; let f = currentNode._fadingNodes[j].segment;
if (this.quadTreeStrategy._fadingNodes.has(currentNode._fadingNodes[0].__id) && !nodes.has(f.node.__id)) { if (quadTreeStrategy._fadingNodes.has(currentNode._fadingNodes[0].__id) && !nodes.has(f.node.__id)) {
nodes.set(f.node.__id, true); nodes.set(f.node.__id, true);
if (isFirstPass) { if (isFirstPass) {
isEq && f.equalize(); isEq && f.equalize();
@ -1398,25 +1415,29 @@ export class Planet extends RenderNode {
gl.enable(gl.DEPTH_TEST); gl.enable(gl.DEPTH_TEST);
} }
protected static __refreshLayersFadingOpacity__(layersRef: Layer[], minCurrZoom: number, maxCurrZoom: number) {
for (let i = layersRef.length - 1; i >= 0; --i) {
let li = layersRef[i];
if (li._fading && li._refreshFadingOpacity(minCurrZoom, maxCurrZoom)) {
layersRef.splice(i, 1);
}
}
}
/** /**
* Drawing nodes * Drawing nodes
*/ */
protected _renderingScreenNodes(sh: Program, cam: PlanetCamera) { protected _renderingScreenNodes(
quadTreeStrategy: QuadTreeStrategy,
let renderedNodes = this.quadTreeStrategy._renderedNodesInFrustum[cam.currentFrustumIndex]; sh: Program,
cam: PlanetCamera,
let firstPass = cam.isFirstPass; renderedNodes: Node[]
) {
let sl = this._visibleTileLayerSlices; let sl = this._visibleTileLayerSlices;
if (sl.length) { if (sl.length && cam.isFirstPass) {
let sli = sl[0]; Planet.__refreshLayersFadingOpacity__(sl[0], quadTreeStrategy.minCurrZoom, quadTreeStrategy.maxCurrZoom);
for (let i = sli.length - 1; i >= 0; --i) {
let li = sli[i];
if (li._fading && firstPass && li._refreshFadingOpacity(this.quadTreeStrategy.minCurrZoom, this.quadTreeStrategy.maxCurrZoom)) {
sli.splice(i, 1);
}
}
} }
let nodes = new Map<number, boolean>; let nodes = new Map<number, boolean>;
@ -1430,14 +1451,14 @@ export class Planet extends RenderNode {
// as the segments with equalized sides, which means that there are no gaps // as the segments with equalized sides, which means that there are no gaps
// between currently rendered neighbours // between currently rendered neighbours
// //
this.quadTreeStrategy._fadingOpaqueSegments = []; quadTreeStrategy._fadingOpaqueSegments = [];
if (cam.slope > 0.8 || !this.terrain || this.terrain.isEmpty /*|| cam.getAltitude() > 10000*/) { if (cam.slope > 0.8 || !this.terrain || this.terrain.isEmpty /*|| cam.getAltitude() > 10000*/) {
while (i--) { while (i--) {
let ri = renderedNodes[i]; let ri = renderedNodes[i];
let s = ri.segment; let s = ri.segment;
this._renderingFadingNodesNoDepth(nodes, sh, ri, sl[0], 0, this.quadTreeStrategy._fadingOpaqueSegments); this._renderingFadingNodesNoDepth(quadTreeStrategy, nodes, sh, ri, sl[0], 0, quadTreeStrategy._fadingOpaqueSegments);
isEq && s.equalize(); isEq && s.equalize();
s.readyToEngage && s.engage(); s.readyToEngage && s.engage();
@ -1452,7 +1473,7 @@ export class Planet extends RenderNode {
let ri = renderedNodes[i]; let ri = renderedNodes[i];
let s = ri.segment; let s = ri.segment;
this._renderingFadingNodes(nodes, sh, ri, sl[0], 0, transparentSegments, this.quadTreeStrategy._fadingOpaqueSegments); this._renderingFadingNodes(quadTreeStrategy, nodes, sh, ri, sl[0], 0, transparentSegments, quadTreeStrategy._fadingOpaqueSegments);
if (s._transitionOpacity < 1) { if (s._transitionOpacity < 1) {
transparentSegments.push(s); transparentSegments.push(s);
@ -1474,17 +1495,16 @@ export class Planet extends RenderNode {
tj.screenRendering(sh, sl[0], 0); tj.screenRendering(sh, sl[0], 0);
} }
} }
} }
protected _renderingScreenNodesWithHeight(sh: Program, cam: PlanetCamera) { protected _renderingScreenNodesWithHeight(
quadTreeStrategy: QuadTreeStrategy,
let renderedNodes = this.quadTreeStrategy._renderedNodesInFrustum[cam.currentFrustumIndex]; sh: Program,
cam: PlanetCamera,
renderedNodes: Node[]
) {
let gl = this.renderer!.handler.gl!; let gl = this.renderer!.handler.gl!;
let firstPass = cam.isFirstPass;
let sl = this._visibleTileLayerSlices;
gl.enable(gl.POLYGON_OFFSET_FILL); gl.enable(gl.POLYGON_OFFSET_FILL);
gl.disable(gl.CULL_FACE); gl.disable(gl.CULL_FACE);
@ -1492,20 +1512,19 @@ export class Planet extends RenderNode {
let nodes = new Map<number, boolean>; let nodes = new Map<number, boolean>;
let transparentSegments: Segment[] = []; let transparentSegments: Segment[] = [];
let sl = this._visibleTileLayerSlices;
for (let j = 1, len = sl.length; j < len; j++) { for (let j = 1, len = sl.length; j < len; j++) {
let slj = sl[j];
for (let i = slj.length - 1; i >= 0; --i) { if (cam.isFirstPass) {
let li = slj[i]; Planet.__refreshLayersFadingOpacity__(sl[j], quadTreeStrategy.minCurrZoom, quadTreeStrategy.maxCurrZoom);
if (li._fading && firstPass && li._refreshFadingOpacity(this.quadTreeStrategy.minCurrZoom, this.quadTreeStrategy.maxCurrZoom)) {
slj.splice(i, 1);
}
} }
gl.polygonOffset(0, -j); gl.polygonOffset(0, -j);
let i = renderedNodes.length; let i = renderedNodes.length;
while (i--) { while (i--) {
let ri = renderedNodes[i]; let ri = renderedNodes[i];
this._renderingFadingNodes(nodes, sh, ri, sl[j], j, transparentSegments); this._renderingFadingNodes(quadTreeStrategy, nodes, sh, ri, sl[j], j, transparentSegments);
if (ri.segment._transitionOpacity < 1) { if (ri.segment._transitionOpacity < 1) {
ri.segment.initSlice(j); ri.segment.initSlice(j);
} else { } else {