8310330075

Committed 16 Mar 2024 08:37PM UTC coverage: 87.276% (+0.9%) from 86.422%

Build # 8310330075

Build Type

Pull #8661

github

Committed by

web-flow

Commit Message

Merge dd5832167 into aa49b2351

Pull Request Pull Request #8661: Fix PostProcessEffect render to framebuffer

Run Details

5719 of 6408 branches covered (89.25%)

Branch coverage included in aggregate %.

8 of 8 new or added lines in 2 files covered. (100.0%)

23 existing lines in 3 files now uncovered.

49842 of 57253 relevant lines covered (87.06%)

2934.82 hits per line

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

96.81

/modules/core/src/passes/layers-pass.ts

import type {Device} from '@luma.gl/core';
import type {Framebuffer, RenderPass} from '@luma.gl/core';

import Pass from './pass';
import type Viewport from '../viewports/viewport';
import type View from '../views/view';
import type Layer from '../lib/layer';
import type {Effect} from '../lib/effect';

export type Rect = {x: number; y: number; width: number; height: number};

export type LayersPassRenderOptions = {
  /** @deprecated TODO v9 recommend we rename this to framebuffer to minimize confusion */
  target?: Framebuffer | null;
  isPicking?: boolean;
  pass: string;
  layers: Layer[];
  viewports: Viewport[];
  onViewportActive?: (viewport: Viewport) => void;
  cullRect?: Rect;
  views?: Record<string, View>;
  effects?: Effect[];
  /** If true, recalculates render index (z) from 0. Set to false if a stack of layers are rendered in multiple passes. */
  clearStack?: boolean;
  clearCanvas?: boolean;
  clearColor?: number[];
  layerFilter?: ((context: FilterContext) => boolean) | null;
  moduleParameters?: any;
  /** Stores returned results from Effect.preRender, for use downstream in the render pipeline */
  preRenderStats?: Record<string, any>;
};

type DrawLayerParameters = {
  shouldDrawLayer: boolean;
  layerRenderIndex?: number;
  moduleParameters?: any;
  layerParameters?: any;
};

export type FilterContext = {
  layer: Layer;
  viewport: Viewport;
  isPicking: boolean;
  renderPass: string;
  cullRect?: Rect;
};

export type RenderStats = {
  totalCount: number;
  visibleCount: number;
  compositeCount: number;
  pickableCount: number;
};

/** A Pass that renders all layers */
export default class LayersPass extends Pass {
  _lastRenderIndex: number = -1;

  render(options: LayersPassRenderOptions): any {
    // @ts-expect-error TODO - assuming WebGL context
    const [width, height] = this.device.canvasContext.getDrawingBufferSize();

    // Explicitly specify clearColor and clearDepth, overriding render pass defaults.
    const clearCanvas = options.clearCanvas ?? true;
    const clearColor = options.clearColor ?? (clearCanvas ? [0, 0, 0, 0] : false);
    const clearDepth = clearCanvas ? 1 : false;

    const renderPass = this.device.beginRenderPass({
      framebuffer: options.target,
      parameters: {
        viewport: [0, 0, width, height]
      },
      clearColor,
      clearDepth
    });

    try {
      return this._drawLayers(renderPass, options);
    } finally {
      renderPass.end();
    }
  }

  /** Draw a list of layers in a list of viewports */
  private _drawLayers(renderPass: RenderPass, options: LayersPassRenderOptions) {
    const {
      target,
      moduleParameters,
      viewports,
      views,
      onViewportActive,
      clearStack = true
    } = options;
    options.pass = options.pass || 'unknown';

    if (clearStack) {
      this._lastRenderIndex = -1;
    }

    const renderStats: RenderStats[] = [];

    for (const viewport of viewports) {
      const view = views && views[viewport.id];

      // Update context to point to this viewport
      onViewportActive?.(viewport);

      const drawLayerParams = this._getDrawLayerParams(viewport, options);

      // render this viewport
      const subViewports = viewport.subViewports || [viewport];
      for (const subViewport of subViewports) {
        const stats = this._drawLayersInViewport(
          renderPass,
          {
            target,
            moduleParameters,
            viewport: subViewport,
            view,
            pass: options.pass,
            layers: options.layers
          },
          drawLayerParams
        );
        renderStats.push(stats);
      }
    }
    return renderStats;
  }

  // When a viewport contains multiple subviewports (e.g. repeated web mercator map),
  // this is only done once for the parent viewport
  /* Resolve the parameters needed to draw each layer */
  protected _getDrawLayerParams(
    viewport: Viewport,
    {
      layers,
      pass,
      isPicking = false,
      layerFilter,
      cullRect,
      effects,
      moduleParameters
    }: LayersPassRenderOptions,
    /** Internal flag, true if only used to determine whether each layer should be drawn */
    evaluateShouldDrawOnly: boolean = false
  ): DrawLayerParameters[] {
    const drawLayerParams: DrawLayerParameters[] = [];
    const indexResolver = layerIndexResolver(this._lastRenderIndex + 1);
    const drawContext: FilterContext = {
      layer: layers[0],
      viewport,
      isPicking,
      renderPass: pass,
      cullRect
    };
    const layerFilterCache = {};
    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
      const layer = layers[layerIndex];
      // Check if we should draw layer
      const shouldDrawLayer = this._shouldDrawLayer(
        layer,
        drawContext,
        layerFilter,
        layerFilterCache
      );

      const layerParam: DrawLayerParameters = {
        shouldDrawLayer
      };

      if (shouldDrawLayer && !evaluateShouldDrawOnly) {
        // This is the "logical" index for ordering this layer in the stack
        // used to calculate polygon offsets
        // It can be the same as another layer
        layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer);

        layerParam.moduleParameters = this._getModuleParameters(
          layer,
          effects,
          pass,
          moduleParameters
        );
        layerParam.layerParameters = this.getLayerParameters(layer, layerIndex, viewport);
      }
      drawLayerParams[layerIndex] = layerParam;
    }
    return drawLayerParams;
  }

  // Draws a list of layers in one viewport
  // TODO - when picking we could completely skip rendering viewports that dont
  // intersect with the picking rect
  /* eslint-disable max-depth, max-statements */
  private _drawLayersInViewport(
    renderPass: RenderPass,
    {layers, moduleParameters: globalModuleParameters, pass, target, viewport, view},
    drawLayerParams
  ): RenderStats {
    const glViewport = getGLViewport(this.device, {
      moduleParameters: globalModuleParameters,
      target,
      viewport
    });

    // TODO v9 - remove WebGL specific logic
    if (view && view.props.clear) {
      const clearOpts = view.props.clear === true ? {color: true, depth: true} : view.props.clear;
      this.device.withParametersWebGL(
        {
          scissorTest: true,
          scissor: glViewport
        },
        () => this.device.clearWebGL(clearOpts)
      );
    }

    // render layers in normal colors
    const renderStatus = {
      totalCount: layers.length,
      visibleCount: 0,
      compositeCount: 0,
      pickableCount: 0
    };

    renderPass.setParameters({viewport: glViewport});

    // render layers in normal colors
    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
      const layer = layers[layerIndex] as Layer;
      const {shouldDrawLayer, layerRenderIndex, moduleParameters, layerParameters} =
        drawLayerParams[layerIndex];

      // Calculate stats
      if (shouldDrawLayer && layer.props.pickable) {
        renderStatus.pickableCount++;
      }
      if (layer.isComposite) {
        renderStatus.compositeCount++;
      } else if (shouldDrawLayer) {
        // Draw the layer
        renderStatus.visibleCount++;

        this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex);

        // overwrite layer.context.viewport with the sub viewport
        moduleParameters.viewport = viewport;

        // TODO v9 - we are sending renderPass both as a parameter and through the context.
        // Long-term, it is likely better not to have user defined layer methods have to access
        // the "global" layer context.
        layer.context.renderPass = renderPass;

        try {
          layer._drawLayer({
            renderPass,
            moduleParameters,
            uniforms: {layerIndex: layerRenderIndex},
            parameters: layerParameters
          });
        } catch (err) {
          layer.raiseError(err as Error, `drawing ${layer} to ${pass}`);
        }
      }
    }

    return renderStatus;
  }
  /* eslint-enable max-depth, max-statements */

  /* Methods for subclass overrides */
  shouldDrawLayer(layer: Layer): boolean {
    return true;
  }

  protected getModuleParameters(layer: Layer, effects?: Effect[]): any {
    return null;
  }

  protected getLayerParameters(layer: Layer, layerIndex: number, viewport: Viewport): any {
    return layer.props.parameters;
  }

  /* Private */
  private _shouldDrawLayer(
    layer: Layer,
    drawContext: FilterContext,
    layerFilter: ((params: FilterContext) => boolean) | undefined | null,
    layerFilterCache: Record<string, boolean>
  ) {
    const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer);

    if (!shouldDrawLayer) {
      return false;
    }

    drawContext.layer = layer;

    let parent = layer.parent;
    while (parent) {
      // @ts-ignore
      if (!parent.props.visible || !parent.filterSubLayer(drawContext)) {
        return false;
      }
      drawContext.layer = parent;
      parent = parent.parent;
    }

    if (layerFilter) {
      const rootLayerId = drawContext.layer.id;
      if (!(rootLayerId in layerFilterCache)) {
        layerFilterCache[rootLayerId] = layerFilter(drawContext);
      }
      if (!layerFilterCache[rootLayerId]) {
        return false;
      }
    }

    // If a layer is drawn, update its viewportChanged flag
    layer.activateViewport(drawContext.viewport);

    return true;
  }

  private _getModuleParameters(
    layer: Layer,
    effects: Effect[] | undefined,
    pass: string,
    overrides: any
  ): any {
    // @ts-expect-error TODO - assuming WebGL context
    const devicePixelRatio = this.device.canvasContext.cssToDeviceRatio();

    const moduleParameters = Object.assign(
      Object.create(layer.internalState?.propsInTransition || layer.props),
      {
        autoWrapLongitude: layer.wrapLongitude,
        viewport: layer.context.viewport,
        mousePosition: layer.context.mousePosition,
        picking: {
          isActive: 0
        },
        devicePixelRatio
      }
    );

    if (effects) {
      for (const effect of effects) {
        Object.assign(moduleParameters, effect.getModuleParameters?.(layer));
      }
    }

    return Object.assign(moduleParameters, this.getModuleParameters(layer, effects), overrides);
  }
}

// If the _index prop is defined, return a layer index that's relative to its parent
// Otherwise return the index of the layer among all rendered layers
// This is done recursively, i.e. if the user overrides a layer's default index,
// all its descendants will be resolved relative to that index.
// This implementation assumes that parent layers always appear before its children
// which is true if the layer array comes from the LayerManager
export function layerIndexResolver(
  startIndex: number = 0,
  layerIndices: Record<string, number> = {}
): (layer: Layer, isDrawn: boolean) => number {
  const resolvers = {};

  const resolveLayerIndex = (layer, isDrawn) => {
    const indexOverride = layer.props._offset;
    const layerId = layer.id;
    const parentId = layer.parent && layer.parent.id;

    let index;

    if (parentId && !(parentId in layerIndices)) {
      // Populate layerIndices with the parent layer's index
      resolveLayerIndex(layer.parent, false);
    }

    if (parentId in resolvers) {
      const resolver = (resolvers[parentId] =
        resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices));
      index = resolver(layer, isDrawn);
      resolvers[layerId] = resolver;
    } else if (Number.isFinite(indexOverride)) {
      index = indexOverride + (layerIndices[parentId] || 0);
      // Mark layer as needing its own resolver
      // We don't actually create it until it's used for the first time
      resolvers[layerId] = null;
    } else {
      index = startIndex;
    }

    if (isDrawn && index >= startIndex) {
      startIndex = index + 1;
    }

    layerIndices[layerId] = index;
    return index;
  };
  return resolveLayerIndex;
}

// Convert viewport top-left CSS coordinates to bottom up WebGL coordinates
function getGLViewport(
  device: Device,
  {
    moduleParameters,
    target,
    viewport
  }: {
    moduleParameters: any;
    target?: Framebuffer;
    viewport: Viewport;
  }
): [number, number, number, number] {
  const pixelRatio =
    (moduleParameters && moduleParameters.devicePixelRatio) ||
    // @ts-expect-error TODO - assuming WebGL context
    device.canvasContext.cssToDeviceRatio();

  // Default framebuffer is used when writing to canvas
  // @ts-expect-error TODO - assuming WebGL context
  const [, drawingBufferHeight] = device.canvasContext.getDrawingBufferSize();
  const height = target ? target.height : drawingBufferHeight;

  // Convert viewport top-left CSS coordinates to bottom up WebGL coordinates
  const dimensions = viewport;
  return [
    dimensions.x * pixelRatio,
    height - (dimensions.y + dimensions.height) * pixelRatio,
    dimensions.width * pixelRatio,
    dimensions.height * pixelRatio
  ];
}

1	import type {Device} from '@luma.gl/core';	1✔
2	import type {Framebuffer, RenderPass} from '@luma.gl/core';	1✔
3		1✔
4	import Pass from './pass';	1✔
5	import type Viewport from '../viewports/viewport';	1✔
6	import type View from '../views/view';	1✔
7	import type Layer from '../lib/layer';	1✔
8	import type {Effect} from '../lib/effect';	1✔
9		1✔
10	export type Rect = {x: number; y: number; width: number; height: number};	1✔
11		1✔
12	export type LayersPassRenderOptions = {	1✔
13	/** @deprecated TODO v9 recommend we rename this to framebuffer to minimize confusion */	1✔
14	target?: Framebuffer \| null;	1✔
15	isPicking?: boolean;	1✔
16	pass: string;	1✔
17	layers: Layer[];	1✔
18	viewports: Viewport[];	1✔
19	onViewportActive?: (viewport: Viewport) => void;	1✔
20	cullRect?: Rect;	1✔
21	views?: Record<string, View>;	1✔
22	effects?: Effect[];	1✔
23	/** If true, recalculates render index (z) from 0. Set to false if a stack of layers are rendered in multiple passes. */	1✔
24	clearStack?: boolean;	1✔
25	clearCanvas?: boolean;	1✔
26	clearColor?: number[];	1✔
27	layerFilter?: ((context: FilterContext) => boolean) \| null;	1✔
28	moduleParameters?: any;	1✔
29	/** Stores returned results from Effect.preRender, for use downstream in the render pipeline */	1✔
30	preRenderStats?: Record<string, any>;	1✔
31	};	1✔
32		1✔
33	type DrawLayerParameters = {	1✔
34	shouldDrawLayer: boolean;	1✔
35	layerRenderIndex?: number;	1✔
36	moduleParameters?: any;	1✔
37	layerParameters?: any;	1✔
38	};	1✔
39		1✔
40	export type FilterContext = {	1✔
41	layer: Layer;	1✔
42	viewport: Viewport;	1✔
43	isPicking: boolean;	1✔
44	renderPass: string;	1✔
45	cullRect?: Rect;	1✔
46	};	1✔
47		1✔
48	export type RenderStats = {	1✔
49	totalCount: number;	1✔
50	visibleCount: number;	1✔
51	compositeCount: number;	1✔
52	pickableCount: number;	1✔
53	};	1✔
54		1✔
55	/** A Pass that renders all layers */	1✔
56	export default class LayersPass extends Pass {	231✔
57	_lastRenderIndex: number = -1;	231✔
58		1✔
59	render(options: LayersPassRenderOptions): any {	1✔
60	// @ts-expect-error TODO - assuming WebGL context	1,003✔
61	const [width, height] = this.device.canvasContext.getDrawingBufferSize();	1,003✔
62		1,003✔
63	// Explicitly specify clearColor and clearDepth, overriding render pass defaults.	1,003✔
64	const clearCanvas = options.clearCanvas ?? true;	1,003✔
65	const clearColor = options.clearColor ?? (clearCanvas ? [0, 0, 0, 0] : false);	1,003✔
66	const clearDepth = clearCanvas ? 1 : false;	1,003✔
67		1,003✔
68	const renderPass = this.device.beginRenderPass({	1,003✔
69	framebuffer: options.target,	1,003✔
70	parameters: {	1,003✔
71	viewport: [0, 0, width, height]	1,003✔
72	},	1,003✔
73	clearColor,	1,003✔
74	clearDepth	1,003✔
75	});	1,003✔
76		1,003✔
77	try {	1,003✔
78	return this._drawLayers(renderPass, options);	1,003✔
79	} finally {	1,003✔
80	renderPass.end();	1,003✔
81	}	1,003✔
82	}	1,003✔
83		1✔
84	/** Draw a list of layers in a list of viewports */	1✔
85	private _drawLayers(renderPass: RenderPass, options: LayersPassRenderOptions) {	1✔
86	const {	1,003✔
87	target,	1,003✔
88	moduleParameters,	1,003✔
89	viewports,	1,003✔
90	views,	1,003✔
91	onViewportActive,	1,003✔
92	clearStack = true	1,003✔
93	} = options;	1,003✔
94	options.pass = options.pass \|\| 'unknown';	1,003✔
95		1,003✔
96	if (clearStack) {	1,003✔
97	this._lastRenderIndex = -1;	1,003✔
98	}	1,003✔
99		1,003✔
100	const renderStats: RenderStats[] = [];	1,003✔
101		1,003✔
102	for (const viewport of viewports) {	1,003✔
103	const view = views && views[viewport.id];	1,005✔
104		1,005✔
105	// Update context to point to this viewport	1,005✔
106	onViewportActive?.(viewport);	1,005✔
107		1,005✔
108	const drawLayerParams = this._getDrawLayerParams(viewport, options);	1,005✔
109		1,005✔
110	// render this viewport	1,005✔
111	const subViewports = viewport.subViewports \|\| [viewport];	1,005✔
112	for (const subViewport of subViewports) {	1,005✔
113	const stats = this._drawLayersInViewport(	1,037✔
114	renderPass,	1,037✔
115	{	1,037✔
116	target,	1,037✔
117	moduleParameters,	1,037✔
118	viewport: subViewport,	1,037✔
119	view,	1,037✔
120	pass: options.pass,	1,037✔
121	layers: options.layers	1,037✔
122	},	1,037✔
123	drawLayerParams	1,037✔
124	);	1,037✔
125	renderStats.push(stats);	1,037✔
126	}	1,037✔
127	}	1,005✔
128	return renderStats;	1,003✔
129	}	1,003✔
130		1✔
131	// When a viewport contains multiple subviewports (e.g. repeated web mercator map),	1✔
132	// this is only done once for the parent viewport	1✔
133	/* Resolve the parameters needed to draw each layer */	1✔
134	protected _getDrawLayerParams(	1✔
135	viewport: Viewport,	1,005✔
136	{	1,005✔
137	layers,	1,005✔
138	pass,	1,005✔
139	isPicking = false,	1,005✔
140	layerFilter,	1,005✔
141	cullRect,	1,005✔
142	effects,	1,005✔
143	moduleParameters	1,005✔
144	}: LayersPassRenderOptions,	1,005✔
145	/** Internal flag, true if only used to determine whether each layer should be drawn */	1,005✔
146	evaluateShouldDrawOnly: boolean = false	1,005✔
147	): DrawLayerParameters[] {	1,005✔
148	const drawLayerParams: DrawLayerParameters[] = [];	1,005✔
149	const indexResolver = layerIndexResolver(this._lastRenderIndex + 1);	1,005✔
150	const drawContext: FilterContext = {	1,005✔
151	layer: layers[0],	1,005✔
152	viewport,	1,005✔
153	isPicking,	1,005✔
154	renderPass: pass,	1,005✔
155	cullRect	1,005✔
156	};	1,005✔
157	const layerFilterCache = {};	1,005✔
158	for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {	1,005✔
159	const layer = layers[layerIndex];	2,370✔
160	// Check if we should draw layer	2,370✔
161	const shouldDrawLayer = this._shouldDrawLayer(	2,370✔
162	layer,	2,370✔
163	drawContext,	2,370✔
164	layerFilter,	2,370✔
165	layerFilterCache	2,370✔
166	);	2,370✔
167		2,370✔
168	const layerParam: DrawLayerParameters = {	2,370✔
169	shouldDrawLayer	2,370✔
170	};	2,370✔
171		2,370✔
172	if (shouldDrawLayer && !evaluateShouldDrawOnly) {	2,370✔
173	// This is the "logical" index for ordering this layer in the stack	2,323✔
174	// used to calculate polygon offsets	2,323✔
175	// It can be the same as another layer	2,323✔
176	layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer);	2,323✔
177		2,323✔
178	layerParam.moduleParameters = this._getModuleParameters(	2,323✔
179	layer,	2,323✔
180	effects,	2,323✔
181	pass,	2,323✔
182	moduleParameters	2,323✔
183	);	2,323✔
184	layerParam.layerParameters = this.getLayerParameters(layer, layerIndex, viewport);	2,323✔
185	}	2,323✔
186	drawLayerParams[layerIndex] = layerParam;	2,370✔
187	}	2,370✔
188	return drawLayerParams;	1,005✔
189	}	1,005✔
190		1✔
191	// Draws a list of layers in one viewport	1✔
192	// TODO - when picking we could completely skip rendering viewports that dont	1✔
193	// intersect with the picking rect	1✔
194	/* eslint-disable max-depth, max-statements */	1✔
195	private _drawLayersInViewport(	1✔
196	renderPass: RenderPass,	1,037✔
197	{layers, moduleParameters: globalModuleParameters, pass, target, viewport, view},	1,037✔
198	drawLayerParams	1,037✔
199	): RenderStats {	1,037✔
200	const glViewport = getGLViewport(this.device, {	1,037✔
201	moduleParameters: globalModuleParameters,	1,037✔
202	target,	1,037✔
203	viewport	1,037✔
204	});	1,037✔
205		1,037✔
206	// TODO v9 - remove WebGL specific logic	1,037✔
207	if (view && view.props.clear) {	1,037!
UNCOV 208	const clearOpts = view.props.clear === true ? {color: true, depth: true} : view.props.clear;	×
209	this.device.withParametersWebGL(	×
210	{	×
211	scissorTest: true,	×
212	scissor: glViewport	×
213	},	×
214	() => this.device.clearWebGL(clearOpts)	×
215	);	×
216	}	×
217		1,037✔
218	// render layers in normal colors	1,037✔
219	const renderStatus = {	1,037✔
220	totalCount: layers.length,	1,037✔
221	visibleCount: 0,	1,037✔
222	compositeCount: 0,	1,037✔
223	pickableCount: 0	1,037✔
224	};	1,037✔
225		1,037✔
226	renderPass.setParameters({viewport: glViewport});	1,037✔
227		1,037✔
228	// render layers in normal colors	1,037✔
229	for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {	1,037✔
230	const layer = layers[layerIndex] as Layer;	2,424✔
231	const {shouldDrawLayer, layerRenderIndex, moduleParameters, layerParameters} =	2,424✔
232	drawLayerParams[layerIndex];	2,424✔
233		2,424✔
234	// Calculate stats	2,424✔
235	if (shouldDrawLayer && layer.props.pickable) {	2,424✔
236	renderStatus.pickableCount++;	129✔
237	}	129✔
238	if (layer.isComposite) {	2,424✔
239	renderStatus.compositeCount++;	796✔
240	} else if (shouldDrawLayer) {	2,424✔
241	// Draw the layer	1,591✔
242	renderStatus.visibleCount++;	1,591✔
243		1,591✔
244	this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex);	1,591✔
245		1,591✔
246	// overwrite layer.context.viewport with the sub viewport	1,591✔
247	moduleParameters.viewport = viewport;	1,591✔
248		1,591✔
249	// TODO v9 - we are sending renderPass both as a parameter and through the context.	1,591✔
250	// Long-term, it is likely better not to have user defined layer methods have to access	1,591✔
251	// the "global" layer context.	1,591✔
252	layer.context.renderPass = renderPass;	1,591✔
253		1,591✔
254	try {	1,591✔
255	layer._drawLayer({	1,591✔
256	renderPass,	1,591✔
257	moduleParameters,	1,591✔
258	uniforms: {layerIndex: layerRenderIndex},	1,591✔
259	parameters: layerParameters	1,591✔
260	});	1,591✔
261	} catch (err) {	1,591!
UNCOV 262	layer.raiseError(err as Error, `drawing ${layer} to ${pass}`);	×
UNCOV 263	}	×
264	}	1,591✔
265	}	2,424✔
266		1,037✔
267	return renderStatus;	1,037✔
268	}	1,037✔
269	/* eslint-enable max-depth, max-statements */	1✔
270		1✔
271	/* Methods for subclass overrides */	1✔
272	shouldDrawLayer(layer: Layer): boolean {	1✔
UNCOV 273	return true;	×
UNCOV 274	}	×
275		1✔
276	protected getModuleParameters(layer: Layer, effects?: Effect[]): any {	1✔
277	return null;	2,302✔
278	}	2,302✔
279		1✔
280	protected getLayerParameters(layer: Layer, layerIndex: number, viewport: Viewport): any {	1✔
281	return layer.props.parameters;	2,311✔
282	}	2,311✔
283		1✔
284	/* Private */	1✔
285	private _shouldDrawLayer(	1✔
286	layer: Layer,	2,370✔
287	drawContext: FilterContext,	2,370✔
288	layerFilter: ((params: FilterContext) => boolean) \| undefined \| null,	2,370✔
289	layerFilterCache: Record<string, boolean>	2,370✔
290	) {	2,370✔
291	const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer);	2,370✔
292		2,370✔
293	if (!shouldDrawLayer) {	2,370✔
294	return false;	4✔
295	}	4✔
296		2,366✔
297	drawContext.layer = layer;	2,366✔
298		2,366✔
299	let parent = layer.parent;	2,366✔
300	while (parent) {	2,370✔
301	// @ts-ignore	1,943✔
302	if (!parent.props.visible \|\| !parent.filterSubLayer(drawContext)) {	1,943✔
303	return false;	35✔
304	}	35✔
305	drawContext.layer = parent;	1,908✔
306	parent = parent.parent;	1,908✔
307	}	1,908✔
308		2,331✔
309	if (layerFilter) {	2,370✔
310	const rootLayerId = drawContext.layer.id;	22✔
311	if (!(rootLayerId in layerFilterCache)) {	22✔
312	layerFilterCache[rootLayerId] = layerFilter(drawContext);	16✔
313	}	16✔
314	if (!layerFilterCache[rootLayerId]) {	22✔
315	return false;	8✔
316	}	8✔
317	}	22✔
318		2,323✔
319	// If a layer is drawn, update its viewportChanged flag	2,323✔
320	layer.activateViewport(drawContext.viewport);	2,323✔
321		2,323✔
322	return true;	2,323✔
323	}	2,370✔
324		1✔
325	private _getModuleParameters(	1✔
326	layer: Layer,	2,323✔
327	effects: Effect[] \| undefined,	2,323✔
328	pass: string,	2,323✔
329	overrides: any	2,323✔
330	): any {	2,323✔
331	// @ts-expect-error TODO - assuming WebGL context	2,323✔
332	const devicePixelRatio = this.device.canvasContext.cssToDeviceRatio();	2,323✔
333		2,323✔
334	const moduleParameters = Object.assign(	2,323✔
335	Object.create(layer.internalState?.propsInTransition \|\| layer.props),	2,323!
336	{	2,323✔
337	autoWrapLongitude: layer.wrapLongitude,	2,323✔
338	viewport: layer.context.viewport,	2,323✔
339	mousePosition: layer.context.mousePosition,	2,323✔
340	picking: {	2,323✔
341	isActive: 0	2,323✔
342	},	2,323✔
343	devicePixelRatio	2,323✔
344	}	2,323✔
345	);	2,323✔
346		2,323✔
347	if (effects) {	2,323✔
348	for (const effect of effects) {	2,296✔
349	Object.assign(moduleParameters, effect.getModuleParameters?.(layer));	634✔
350	}	634✔
351	}	2,296✔
352		2,323✔
353	return Object.assign(moduleParameters, this.getModuleParameters(layer, effects), overrides);	2,323✔
354	}	2,323✔
355	}	1✔
356		1✔
357	// If the _index prop is defined, return a layer index that's relative to its parent	1✔
358	// Otherwise return the index of the layer among all rendered layers	1✔
359	// This is done recursively, i.e. if the user overrides a layer's default index,	1✔
360	// all its descendants will be resolved relative to that index.	1✔
361	// This implementation assumes that parent layers always appear before its children	1✔
362	// which is true if the layer array comes from the LayerManager	1✔
363	export function layerIndexResolver(	1✔
364	startIndex: number = 0,	1,090✔
365	layerIndices: Record<string, number> = {}	1,090✔
366	): (layer: Layer, isDrawn: boolean) => number {	1,090✔
367	const resolvers = {};	1,090✔
368		1,090✔
369	const resolveLayerIndex = (layer, isDrawn) => {	1,090✔
370	const indexOverride = layer.props._offset;	2,571✔
371	const layerId = layer.id;	2,571✔
372	const parentId = layer.parent && layer.parent.id;	2,571✔
373		2,571✔
374	let index;	2,571✔
375		2,571✔
376	if (parentId && !(parentId in layerIndices)) {	2,571✔
377	// Populate layerIndices with the parent layer's index	13✔
378	resolveLayerIndex(layer.parent, false);	13✔
379	}	13✔
380		2,571✔
381	if (parentId in resolvers) {	2,571✔
382	const resolver = (resolvers[parentId] =	164✔
383	resolvers[parentId] \|\| layerIndexResolver(layerIndices[parentId], layerIndices));	164✔
384	index = resolver(layer, isDrawn);	164✔
385	resolvers[layerId] = resolver;	164✔
386	} else if (Number.isFinite(indexOverride)) {	2,571✔
387	index = indexOverride + (layerIndices[parentId] \|\| 0);	260✔
388	// Mark layer as needing its own resolver	260✔
389	// We don't actually create it until it's used for the first time	260✔
390	resolvers[layerId] = null;	260✔
391	} else {	2,407✔
392	index = startIndex;	2,147✔
393	}	2,147✔
394		2,571✔
395	if (isDrawn && index >= startIndex) {	2,571✔
396	startIndex = index + 1;	2,150✔
397	}	2,150✔
398		2,571✔
399	layerIndices[layerId] = index;	2,571✔
400	return index;	2,571✔
401	};	2,571✔
402	return resolveLayerIndex;	1,090✔
403	}	1,090✔
404		1✔
405	// Convert viewport top-left CSS coordinates to bottom up WebGL coordinates	1✔
406	function getGLViewport(	1,037✔
407	device: Device,	1,037✔
408	{	1,037✔
409	moduleParameters,	1,037✔
410	target,	1,037✔
411	viewport	1,037✔
412	}: {	1,037✔
413	moduleParameters: any;	1,037✔
414	target?: Framebuffer;	1,037✔
415	viewport: Viewport;	1,037✔
416	}	1,037✔
417	): [number, number, number, number] {	1,037✔
418	const pixelRatio =	1,037✔
419	(moduleParameters && moduleParameters.devicePixelRatio) \|\|	1,037✔
420	// @ts-expect-error TODO - assuming WebGL context	1,033✔
421	device.canvasContext.cssToDeviceRatio();	1,033✔
422		1,037✔
423	// Default framebuffer is used when writing to canvas	1,037✔
424	// @ts-expect-error TODO - assuming WebGL context	1,037✔
425	const [, drawingBufferHeight] = device.canvasContext.getDrawingBufferSize();	1,037✔
426	const height = target ? target.height : drawingBufferHeight;	1,037✔
427		1,037✔
428	// Convert viewport top-left CSS coordinates to bottom up WebGL coordinates	1,037✔
429	const dimensions = viewport;	1,037✔
430	return [	1,037✔
431	dimensions.x * pixelRatio,	1,037✔
432	height - (dimensions.y + dimensions.height) * pixelRatio,	1,037✔
433	dimensions.width * pixelRatio,	1,037✔
434	dimensions.height * pixelRatio	1,037✔
435	];	1,037✔
436	}	1,037✔

visgl / deck.gl / 8310330075

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