11052248445

Committed 26 Sep 2024 12:30PM UTC coverage: 52.168% (-39.6%) from 91.729%

Build # 11052248445

Build Type

Pull #9161

github

Committed by

web-flow

Commit Message

Merge b0656a450 into 89458064c

Pull Request Pull Request #9161: chore: Bump to luma.gl@9.1.0-beta, math.gl@4.3.0

Run Details

1052 of 1431 branches covered (73.52%)

Branch coverage included in aggregate %.

13 of 14 new or added lines in 3 files covered. (92.86%)

24126 existing lines in 274 files now uncovered.

30956 of 59925 relevant lines covered (51.66%)

2.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.05

/modules/core/src/lib/deck-renderer.ts

import type {Device} from '@luma.gl/core';
import {Framebuffer} from '@luma.gl/core';
import debug from '../debug/index';
import DrawLayersPass from '../passes/draw-layers-pass';
import PickLayersPass from '../passes/pick-layers-pass';

import type Layer from './layer';
import type Viewport from '../viewports/viewport';
import type View from '../views/view';
import type {Effect, PostRenderOptions} from './effect';
import type {LayersPassRenderOptions, FilterContext} from '../passes/layers-pass';

const TRACE_RENDER_LAYERS = 'deckRenderer.renderLayers';

type LayerFilter = ((context: FilterContext) => boolean) | null;

export default class DeckRenderer {
  device: Device;
  layerFilter: LayerFilter;
  drawPickingColors: boolean;
  drawLayersPass: DrawLayersPass;
  pickLayersPass: PickLayersPass;

  private renderCount: number;
  private _needsRedraw: string | false;
  private renderBuffers: Framebuffer[];
  private lastPostProcessEffect: string | null;

  constructor(device: Device) {
    this.device = device;
    this.layerFilter = null;
    this.drawPickingColors = false;
    this.drawLayersPass = new DrawLayersPass(device);
    this.pickLayersPass = new PickLayersPass(device);
    this.renderCount = 0;
    this._needsRedraw = 'Initial render';
    this.renderBuffers = [];
    this.lastPostProcessEffect = null;
  }

  setProps(props: {layerFilter: LayerFilter; drawPickingColors: boolean}) {
    if (this.layerFilter !== props.layerFilter) {
      this.layerFilter = props.layerFilter;
      this._needsRedraw = 'layerFilter changed';
    }

    if (this.drawPickingColors !== props.drawPickingColors) {
      this.drawPickingColors = props.drawPickingColors;
      this._needsRedraw = 'drawPickingColors changed';
    }
  }

  renderLayers(opts: {
    pass: string;
    layers: Layer[];
    viewports: Viewport[];
    views: {[viewId: string]: View};
    onViewportActive: (viewport: Viewport) => void;
    effects: Effect[];
    target?: Framebuffer | null;
    layerFilter?: LayerFilter;
    clearStack?: boolean;
    clearCanvas?: boolean;
  }) {
    if (!opts.viewports.length) {
      return;
    }

    const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass;

    const renderOpts: LayersPassRenderOptions = {
      layerFilter: this.layerFilter,
      isPicking: this.drawPickingColors,
      ...opts
    };

    if (renderOpts.effects) {
      this._preRender(renderOpts.effects, renderOpts);
    }

    const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : renderOpts.target;
    if (this.lastPostProcessEffect) {
      renderOpts.clearColor = [0, 0, 0, 0];
      renderOpts.clearCanvas = true;
    }
    const renderStats = layerPass.render({...renderOpts, target: outputBuffer});

    if (renderOpts.effects) {
      this._postRender(renderOpts.effects, renderOpts);
    }

    this.renderCount++;

    debug(TRACE_RENDER_LAYERS, this, renderStats, opts);
  }

  needsRedraw(opts: {clearRedrawFlags: boolean} = {clearRedrawFlags: false}): string | false {
    const redraw = this._needsRedraw;
    if (opts.clearRedrawFlags) {
      this._needsRedraw = false;
    }
    return redraw;
  }

  finalize() {
    const {renderBuffers} = this;
    for (const buffer of renderBuffers) {
      buffer.delete();
    }
    renderBuffers.length = 0;
  }

  private _preRender(effects: Effect[], opts: LayersPassRenderOptions) {
    this.lastPostProcessEffect = null;
    opts.preRenderStats = opts.preRenderStats || {};

    for (const effect of effects) {
      opts.preRenderStats[effect.id] = effect.preRender(opts);
      if (effect.postRender) {
        this.lastPostProcessEffect = effect.id;
      }
    }

    if (this.lastPostProcessEffect) {
      this._resizeRenderBuffers();
    }
  }

  private _resizeRenderBuffers() {
    const {renderBuffers} = this;
    const size = this.device.canvasContext!.getDrawingBufferSize();
    if (renderBuffers.length === 0) {
      [0, 1].map(i => {
        const texture = this.device.createTexture({
          sampler: {minFilter: 'linear', magFilter: 'linear'}
        });
        renderBuffers.push(
          this.device.createFramebuffer({
            id: `deck-renderbuffer-${i}`,
            colorAttachments: [texture]
          })
        );
      });
    }
    for (const buffer of renderBuffers) {
      buffer.resize(size);
    }
  }

  private _postRender(effects: Effect[], opts: LayersPassRenderOptions) {
    const {renderBuffers} = this;
    const params: PostRenderOptions = {
      ...opts,
      inputBuffer: renderBuffers[0],
      swapBuffer: renderBuffers[1]
    };
    for (const effect of effects) {
      if (effect.postRender) {
        // If not the last post processing effect, unset the target so that
        // it only renders between the swap buffers
        params.target = effect.id === this.lastPostProcessEffect ? opts.target : undefined;
        const buffer = effect.postRender(params);
        // Buffer cannot be null if target is unset
        params.inputBuffer = buffer!;
        params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0];
      }
    }
  }
}

1	import type {Device} from '@luma.gl/core';	1✔
2	import {Framebuffer} from '@luma.gl/core';	1✔
3	import debug from '../debug/index';	1✔
4	import DrawLayersPass from '../passes/draw-layers-pass';	1✔
5	import PickLayersPass from '../passes/pick-layers-pass';	1✔
6		1✔
7	import type Layer from './layer';	1✔
8	import type Viewport from '../viewports/viewport';	1✔
9	import type View from '../views/view';	1✔
10	import type {Effect, PostRenderOptions} from './effect';	1✔
11	import type {LayersPassRenderOptions, FilterContext} from '../passes/layers-pass';	1✔
12		1✔
13	const TRACE_RENDER_LAYERS = 'deckRenderer.renderLayers';	1✔
14		1✔
15	type LayerFilter = ((context: FilterContext) => boolean) \| null;	1✔
16		1✔
17	export default class DeckRenderer {	1✔
18	device: Device;	1✔
19	layerFilter: LayerFilter;	1✔
20	drawPickingColors: boolean;	1✔
21	drawLayersPass: DrawLayersPass;	1✔
22	pickLayersPass: PickLayersPass;	1✔
23		1✔
24	private renderCount: number;	1✔
25	private _needsRedraw: string \| false;	1✔
26	private renderBuffers: Framebuffer[];	1✔
27	private lastPostProcessEffect: string \| null;	1✔
28		1✔
29	constructor(device: Device) {	1✔
30	this.device = device;	1✔
31	this.layerFilter = null;	1✔
32	this.drawPickingColors = false;	1✔
33	this.drawLayersPass = new DrawLayersPass(device);	1✔
34	this.pickLayersPass = new PickLayersPass(device);	1✔
35	this.renderCount = 0;	1✔
36	this._needsRedraw = 'Initial render';	1✔
37	this.renderBuffers = [];	1✔
38	this.lastPostProcessEffect = null;	1✔
39	}	1✔
40		1✔
41	setProps(props: {layerFilter: LayerFilter; drawPickingColors: boolean}) {	1✔
42	if (this.layerFilter !== props.layerFilter) {	1!
UNCOV 43	this.layerFilter = props.layerFilter;	×
UNCOV 44	this._needsRedraw = 'layerFilter changed';	×
UNCOV 45	}	×
46		1✔
47	if (this.drawPickingColors !== props.drawPickingColors) {	1!
48	this.drawPickingColors = props.drawPickingColors;	×
49	this._needsRedraw = 'drawPickingColors changed';	×
50	}	×
51	}	1✔
52		1✔
53	renderLayers(opts: {	1✔
54	pass: string;	3✔
55	layers: Layer[];	3✔
56	viewports: Viewport[];	3✔
57	views: {[viewId: string]: View};	3✔
58	onViewportActive: (viewport: Viewport) => void;	3✔
59	effects: Effect[];	3✔
60	target?: Framebuffer \| null;	3✔
61	layerFilter?: LayerFilter;	3✔
62	clearStack?: boolean;	3✔
63	clearCanvas?: boolean;	3✔
64	}) {	3✔
65	if (!opts.viewports.length) {	3!
UNCOV 66	return;	×
UNCOV 67	}	×
68		3✔
69	const layerPass = this.drawPickingColors ? this.pickLayersPass : this.drawLayersPass;	3!
70		3✔
71	const renderOpts: LayersPassRenderOptions = {	3✔
72	layerFilter: this.layerFilter,	3✔
73	isPicking: this.drawPickingColors,	3✔
74	...opts	3✔
75	};	3✔
76		3✔
77	if (renderOpts.effects) {	3✔
78	this._preRender(renderOpts.effects, renderOpts);	3✔
79	}	3✔
80		3✔
81	const outputBuffer = this.lastPostProcessEffect ? this.renderBuffers[0] : renderOpts.target;	3!
82	if (this.lastPostProcessEffect) {	3!
UNCOV 83	renderOpts.clearColor = [0, 0, 0, 0];	×
UNCOV 84	renderOpts.clearCanvas = true;	×
UNCOV 85	}	×
86	const renderStats = layerPass.render({...renderOpts, target: outputBuffer});	3✔
87		3✔
88	if (renderOpts.effects) {	3✔
89	this._postRender(renderOpts.effects, renderOpts);	3✔
90	}	3✔
91		3✔
92	this.renderCount++;	3✔
93		3✔
94	debug(TRACE_RENDER_LAYERS, this, renderStats, opts);	3✔
95	}	3✔
96		1✔
97	needsRedraw(opts: {clearRedrawFlags: boolean} = {clearRedrawFlags: false}): string \| false {	1✔
UNCOV 98	const redraw = this._needsRedraw;	×
UNCOV 99	if (opts.clearRedrawFlags) {	×
UNCOV 100	this._needsRedraw = false;	×
UNCOV 101	}	×
UNCOV 102	return redraw;	×
UNCOV 103	}	×
104		1✔
105	finalize() {	1✔
106	const {renderBuffers} = this;	1✔
107	for (const buffer of renderBuffers) {	1!
UNCOV 108	buffer.delete();	×
UNCOV 109	}	×
110	renderBuffers.length = 0;	1✔
111	}	1✔
112		1✔
113	private _preRender(effects: Effect[], opts: LayersPassRenderOptions) {	1✔
114	this.lastPostProcessEffect = null;	3✔
115	opts.preRenderStats = opts.preRenderStats \|\| {};	3✔
116		3✔
117	for (const effect of effects) {	3!
UNCOV 118	opts.preRenderStats[effect.id] = effect.preRender(opts);	×
UNCOV 119	if (effect.postRender) {	×
UNCOV 120	this.lastPostProcessEffect = effect.id;	×
UNCOV 121	}	×
UNCOV 122	}	×
123		3✔
124	if (this.lastPostProcessEffect) {	3!
UNCOV 125	this._resizeRenderBuffers();	×
UNCOV 126	}	×
127	}	3✔
128		1✔
129	private _resizeRenderBuffers() {	1✔
UNCOV 130	const {renderBuffers} = this;	×
UNCOV 131	const size = this.device.canvasContext!.getDrawingBufferSize();	×
UNCOV 132	if (renderBuffers.length === 0) {	×
UNCOV 133	[0, 1].map(i => {	×
UNCOV 134	const texture = this.device.createTexture({	×
UNCOV 135	sampler: {minFilter: 'linear', magFilter: 'linear'}	×
UNCOV 136	});	×
UNCOV 137	renderBuffers.push(	×
UNCOV 138	this.device.createFramebuffer({	×
UNCOV 139	id: `deck-renderbuffer-${i}`,	×
UNCOV 140	colorAttachments: [texture]	×
UNCOV 141	})	×
UNCOV 142	);	×
UNCOV 143	});	×
UNCOV 144	}	×
UNCOV 145	for (const buffer of renderBuffers) {	×
UNCOV 146	buffer.resize(size);	×
UNCOV 147	}	×
UNCOV 148	}	×
149		1✔
150	private _postRender(effects: Effect[], opts: LayersPassRenderOptions) {	1✔
151	const {renderBuffers} = this;	3✔
152	const params: PostRenderOptions = {	3✔
153	...opts,	3✔
154	inputBuffer: renderBuffers[0],	3✔
155	swapBuffer: renderBuffers[1]	3✔
156	};	3✔
157	for (const effect of effects) {	3!
UNCOV 158	if (effect.postRender) {	×
UNCOV 159	// If not the last post processing effect, unset the target so that	×
UNCOV 160	// it only renders between the swap buffers	×
UNCOV 161	params.target = effect.id === this.lastPostProcessEffect ? opts.target : undefined;	×
UNCOV 162	const buffer = effect.postRender(params);	×
UNCOV 163	// Buffer cannot be null if target is unset	×
UNCOV 164	params.inputBuffer = buffer!;	×
UNCOV 165	params.swapBuffer = buffer === renderBuffers[0] ? renderBuffers[1] : renderBuffers[0];	×
UNCOV 166	}	×
UNCOV 167	}	×
168	}	3✔
169	}	1✔

visgl / deck.gl / 11052248445

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous