13779

Committed 18 Sep 2019 - 0:00 coverage decreased (-2.9%) to 79.902%

Build # 13779

Build Type

Pull #3623

travis-ci-com

Committed by

web-flow

Commit Message

beta.2

Pull Request Pull Request #3623: Bump dependency versions

Run Details

3405 of 4619 branches covered (73.72%)

Branch coverage included in aggregate %.

7031 of 8442 relevant lines covered (83.29%)

5687.45 hits per line

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

82.47

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

import GL from '@luma.gl/constants';
import Pass from './pass';
import {clear, setParameters, withParameters, cssToDeviceRatio} from '@luma.gl/core';

export default class LayersPass extends Pass {
  render(params) {
    const gl = this.gl;

    return withParameters(gl, {framebuffer: params.outputBuffer}, () => this.drawLayers(params));
  }

  // PRIVATE
  // Draw a list of layers in a list of viewports
  drawLayers({
    layers,
    viewports,
    views,
    onViewportActive,
    deviceRect = null,
    parameters = {},
    pass = 'draw',
    redrawReason = '',
    clearCanvas = true,
    effects,
    effectProps
  }) {
    const gl = this.gl;
    if (clearCanvas) {
      this.clearCanvas(gl);
    }

    const renderStats = [];

    viewports.forEach((viewportOrDescriptor, i) => {
      const viewport = this.getViewportFromDescriptor(viewportOrDescriptor);
      const view = views && views[viewport.id];

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

      // render this viewport
      const stats = this.drawLayersInViewport(gl, {
        layers,
        viewport,
        view,
        deviceRect,
        parameters,
        pass,
        redrawReason,
        effects,
        effectProps
      });
      renderStats.push(stats);
    });
    return renderStats;
  }

  // Draws a list of layers in one viewport
  // TODO - when picking we could completely skip rendering viewports that dont
  // intersect with the picking rect
  drawLayersInViewport(
    gl,
    {
      layers,
      viewport,
      view,
      deviceRect = null,
      parameters = {},
      pass = 'draw',
      redrawReason = '',
      effects,
      effectProps
    }
  ) {
    const glViewport = this.getGLViewport(gl, {viewport});

    if (view && view.props.clear) {
      const clearOpts = view.props.clear === true ? {color: true, depth: true} : view.props.clear;
      withParameters(
        gl,
        {
          scissorTest: true,
          scissor: glViewport
        },
        () => clear(gl, clearOpts)
      );
    }

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

    setParameters(gl, parameters || {});

    // render layers in normal colors
    layers.forEach((layer, layerIndex) => {
      // Check if we should draw layer
      const shouldDrawLayer = this.shouldDrawLayer(layer, viewport);

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

      // Draw the layer
      if (shouldDrawLayer) {
        renderStatus.visibleCount++;

        this.drawLayerInViewport({
          gl,
          layer,
          layerIndex,
          glViewport,
          parameters,
          effects,
          effectProps
        });
      }
    });

    return renderStatus;
  }

  drawLayerInViewport({gl, layer, layerIndex, glViewport, parameters, effects, effectProps}) {
    const moduleParameters = this.getModuleParameters(layer, effects, effectProps);
    const uniforms = Object.assign({}, layer.context.uniforms, {layerIndex});
    const layerParameters = this.getLayerParameters(layer, layerIndex, glViewport, parameters);

    layer.drawLayer({
      moduleParameters,
      uniforms,
      parameters: layerParameters
    });
  }

  // Get a viewport from a viewport descriptor (which can be a plain viewport)
  getViewportFromDescriptor(viewportOrDescriptor) {
    return viewportOrDescriptor.viewport ? viewportOrDescriptor.viewport : viewportOrDescriptor;
  }

  shouldDrawLayer(layer, viewport) {
    const layerFilter = this.props.layerFilter;
    let shouldDrawLayer = !layer.isComposite && layer.props.visible;

    if (shouldDrawLayer && layerFilter) {
      shouldDrawLayer = layerFilter({layer, viewport, isPicking: false});
    }
    return shouldDrawLayer;
  }

  getModuleParameters(layer) {
    const moduleParameters = Object.assign(Object.create(layer.props), {
      viewport: layer.context.viewport,
      mousePosition: layer.context.mousePosition,
      pickingActive: 0,
      devicePixelRatio: cssToDeviceRatio(this.gl)
    });
    return moduleParameters;
  }

  getLayerParameters(layer, layerIndex, glViewport, parameters) {
    // All parameter resolving is done here instead of the layer
    // Blend parameters must not be overridden
    const layerParameters = Object.assign({}, layer.props.parameters || {}, parameters);

    Object.assign(layerParameters, {
      viewport: glViewport
    });
    return layerParameters;
  }

  // Convert viewport top-left CSS coordinates to bottom up WebGL coordinates
  getGLViewport(gl, {viewport}) {
    // TODO - dummy default for node
    // Fallback to width/height when clientWidth/clientHeight are 0 or undefined.
    const height = gl.canvas ? gl.canvas.clientHeight || gl.canvas.height : 100;
    // Convert viewport top-left CSS coordinates to bottom up WebGL coordinates
    const dimensions = viewport;
    const pixelRatio = cssToDeviceRatio(this.gl);
    return [
      dimensions.x * pixelRatio,
      (height - dimensions.y - dimensions.height) * pixelRatio,
      dimensions.width * pixelRatio,
      dimensions.height * pixelRatio
    ];
  }

  clearCanvas(gl) {
    const width = gl.drawingBufferWidth;
    const height = gl.drawingBufferHeight;
    // clear depth and color buffers, restoring transparency
    withParameters(gl, {viewport: [0, 0, width, height]}, () => {
      gl.clear(GL.COLOR_BUFFER_BIT | GL.DEPTH_BUFFER_BIT);
    });
  }
}

1	import GL from '@luma.gl/constants';	13×
2	import Pass from './pass';
3	import {clear, setParameters, withParameters, cssToDeviceRatio} from '@luma.gl/core';
4
5	export default class LayersPass extends Pass {
6	render(params) {
7	const gl = this.gl;	606×
8
9	return withParameters(gl, {framebuffer: params.outputBuffer}, () => this.drawLayers(params));	606×
10	}
11
12	// PRIVATE
13	// Draw a list of layers in a list of viewports
14	drawLayers({
15	layers,
16	viewports,
17	views,
18	onViewportActive,
19	deviceRect = null,
20	parameters = {},
21	pass = 'draw',
22	redrawReason = '',
23	clearCanvas = true,
24	effects,
25	effectProps
26	}) {
27	const gl = this.gl;	612×
28	if (clearCanvas) {	Branches [[5, 1]] missed. 612×
29	this.clearCanvas(gl);	612×
30	}
31
32	const renderStats = [];	612×
33
34	viewports.forEach((viewportOrDescriptor, i) => {	612×
35	const viewport = this.getViewportFromDescriptor(viewportOrDescriptor);	613×
36	const view = views && views[viewport.id];	613×
37
38	// Update context to point to this viewport
39	onViewportActive(viewport);	613×
40
41	// render this viewport
42	const stats = this.drawLayersInViewport(gl, {	613×
43	layers,
44	viewport,
45	view,
46	deviceRect,
47	parameters,
48	pass,
49	redrawReason,
50	effects,
51	effectProps
52	});
53	renderStats.push(stats);	613×
54	});
55	return renderStats;	612×
56	}
57
58	// Draws a list of layers in one viewport
59	// TODO - when picking we could completely skip rendering viewports that dont
60	// intersect with the picking rect
61	drawLayersInViewport(
62	gl,
63	{
64	layers,
65	viewport,
66	view,
67	deviceRect = null,	Branches [[7, 0]] missed.
68	parameters = {},	Branches [[8, 0]] missed.
69	pass = 'draw',	Branches [[9, 0]] missed.
70	redrawReason = '',	Branches [[10, 0]] missed.
71	effects,
72	effectProps
73	}
74	) {
75	const glViewport = this.getGLViewport(gl, {viewport});	613×
76
77	if (view && view.props.clear) {	Branches [[11, 0]] missed. 613×
UNCOV 78	const clearOpts = view.props.clear === true ? {color: true, depth: true} : view.props.clear;	Branches [[13, 0], [13, 1]] missed. !
UNCOV 79	withParameters(	!
80	gl,
81	{
82	scissorTest: true,
83	scissor: glViewport
84	},
UNCOV 85	() => clear(gl, clearOpts)	!
86	);
87	}
88
89	// render layers in normal colors
90	const renderStatus = {	613×
91	totalCount: layers.length,
92	visibleCount: 0,
93	compositeCount: 0,
94	pickableCount: 0
95	};
96
97	setParameters(gl, parameters \|\| {});	Branches [[14, 1]] missed. 613×
98
99	// render layers in normal colors
100	layers.forEach((layer, layerIndex) => {	613×
101	// Check if we should draw layer
102	const shouldDrawLayer = this.shouldDrawLayer(layer, viewport);	1,211×
103
104	// Calculate stats
105	if (shouldDrawLayer && layer.props.pickable) {	1,211×
106	renderStatus.pickableCount++;	40×
107	}
108	if (layer.isComposite) {	1,211×
109	renderStatus.compositeCount++;	462×
110	}
111
112	// Draw the layer
113	if (shouldDrawLayer) {	1,211×
114	renderStatus.visibleCount++;	749×
115
116	this.drawLayerInViewport({	749×
117	gl,
118	layer,
119	layerIndex,
120	glViewport,
121	parameters,
122	effects,
123	effectProps
124	});
125	}
126	});
127
128	return renderStatus;	613×
129	}
130
131	drawLayerInViewport({gl, layer, layerIndex, glViewport, parameters, effects, effectProps}) {
132	const moduleParameters = this.getModuleParameters(layer, effects, effectProps);	749×
133	const uniforms = Object.assign({}, layer.context.uniforms, {layerIndex});	749×
134	const layerParameters = this.getLayerParameters(layer, layerIndex, glViewport, parameters);	749×
135
136	layer.drawLayer({	749×
137	moduleParameters,
138	uniforms,
139	parameters: layerParameters
140	});
141	}
142
143	// Get a viewport from a viewport descriptor (which can be a plain viewport)
144	getViewportFromDescriptor(viewportOrDescriptor) {
145	return viewportOrDescriptor.viewport ? viewportOrDescriptor.viewport : viewportOrDescriptor;	Branches [[19, 0]] missed. 613×
146	}
147
148	shouldDrawLayer(layer, viewport) {
149	const layerFilter = this.props.layerFilter;	1,203×
150	let shouldDrawLayer = !layer.isComposite && layer.props.visible;	1,203×
151
152	if (shouldDrawLayer && layerFilter) {	Branches [[21, 0]] missed. 1,203×
UNCOV 153	shouldDrawLayer = layerFilter({layer, viewport, isPicking: false});	!
154	}
155	return shouldDrawLayer;	1,203×
156	}
157
158	getModuleParameters(layer) {
159	const moduleParameters = Object.assign(Object.create(layer.props), {	738×
160	viewport: layer.context.viewport,
161	mousePosition: layer.context.mousePosition,
162	pickingActive: 0,
163	devicePixelRatio: cssToDeviceRatio(this.gl)
164	});
165	return moduleParameters;	738×
166	}
167
168	getLayerParameters(layer, layerIndex, glViewport, parameters) {
169	// All parameter resolving is done here instead of the layer
170	// Blend parameters must not be overridden
171	const layerParameters = Object.assign({}, layer.props.parameters \|\| {}, parameters);	Branches [[23, 1]] missed. 742×
172
173	Object.assign(layerParameters, {	742×
174	viewport: glViewport
175	});
176	return layerParameters;	742×
177	}
178
179	// Convert viewport top-left CSS coordinates to bottom up WebGL coordinates
180	getGLViewport(gl, {viewport}) {
181	// TODO - dummy default for node
182	// Fallback to width/height when clientWidth/clientHeight are 0 or undefined.
183	const height = gl.canvas ? gl.canvas.clientHeight \|\| gl.canvas.height : 100;	Branches [[24, 1]] missed. 613×
184	// Convert viewport top-left CSS coordinates to bottom up WebGL coordinates
185	const dimensions = viewport;	613×
186	const pixelRatio = cssToDeviceRatio(this.gl);	613×
187	return [	613×
188	dimensions.x * pixelRatio,
189	(height - dimensions.y - dimensions.height) * pixelRatio,
190	dimensions.width * pixelRatio,
191	dimensions.height * pixelRatio
192	];
193	}
194
195	clearCanvas(gl) {
196	const width = gl.drawingBufferWidth;	612×
197	const height = gl.drawingBufferHeight;	612×
198	// clear depth and color buffers, restoring transparency
199	withParameters(gl, {viewport: [0, 0, width, height]}, () => {	612×
200	gl.clear(GL.COLOR_BUFFER_BIT \| GL.DEPTH_BUFFER_BIT);	612×
201	});
202	}
203	}

uber / deck.gl / 13779

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