13030

Committed 26 Aug 2019 - 19:27 coverage decreased (-2.6%) to 80.38%

Build # 13030

Build Type

Pull #3490

travis-ci-com

Committed by

web-flow

Commit Message

integrate mapbox's near plane fix

Pull Request Pull Request #3490: [MapboxLayer] integrate mapbox-gl's near plane fix

Run Details

3369 of 4577 branches covered (73.61%)

Branch coverage included in aggregate %.

6877 of 8170 relevant lines covered (84.17%)

4644.76 hits per line

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

93.33

/modules/core/src/shaderlib/project/viewport-uniforms.js

// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

import * as mat4 from 'gl-matrix/mat4';
import * as vec4 from 'gl-matrix/vec4';

import {COORDINATE_SYSTEM} from '../../lib/constants';

import memoize from '../../utils/memoize';
import assert from '../../utils/assert';

import {PROJECT_COORDINATE_SYSTEM} from './constants';

// To quickly set a vector to zero
const ZERO_VECTOR = [0, 0, 0, 0];
// 4x4 matrix that drops 4th component of vector
const VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];
const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
const DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];
const DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];

// Based on viewport-mercator-project/test/fp32-limits.js
export const LNGLAT_AUTO_OFFSET_ZOOM_THRESHOLD = 12;

const getMemoizedViewportUniforms = memoize(calculateViewportUniforms);

function getShaderCoordinateSystem(coordinateSystem) {
  switch (coordinateSystem) {
    case COORDINATE_SYSTEM.LNGLAT:
    default:
      return PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET;

    case COORDINATE_SYSTEM.LNGLAT_DEPRECATED:
      return PROJECT_COORDINATE_SYSTEM.LNG_LAT;

    case COORDINATE_SYSTEM.METER_OFFSETS:
    case COORDINATE_SYSTEM.METERS:
      return PROJECT_COORDINATE_SYSTEM.METER_OFFSETS;

    case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
      return PROJECT_COORDINATE_SYSTEM.LNGLAT_OFFSETS;

    case COORDINATE_SYSTEM.IDENTITY:
      return PROJECT_COORDINATE_SYSTEM.IDENTITY;
  }
}

// The code that utilizes Matrix4 does the same calculation as their mat4 counterparts,
// has lower performance but provides error checking.
// Uncomment when debugging
function calculateMatrixAndOffset({
  // UNCHANGED
  viewport,
  // NEW PARAMS
  coordinateSystem,
  coordinateOrigin,
  coordinateZoom
}) {
  const {viewMatrixUncentered} = viewport;
  let {viewMatrix} = viewport;
  const {projectionMatrix} = viewport;
  let {viewProjectionMatrix} = viewport;

  let projectionCenter;
  let cameraPosCommon = viewport.cameraPosition;
  let shaderCoordinateSystem = getShaderCoordinateSystem(coordinateSystem);
  let shaderCoordinateOrigin = coordinateOrigin;

  if (shaderCoordinateSystem === PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET) {
    if (coordinateZoom < LNGLAT_AUTO_OFFSET_ZOOM_THRESHOLD) {
      // Use LNG_LAT projection if not zooming
      shaderCoordinateSystem = PROJECT_COORDINATE_SYSTEM.LNG_LAT;
    } else {
      // Use LNGLAT_AUTO_OFFSET
      const lng = Math.fround(viewport.longitude);
      const lat = Math.fround(viewport.latitude);
      shaderCoordinateOrigin = [lng, lat];
    }
  }
  if (shaderCoordinateSystem === PROJECT_COORDINATE_SYSTEM.IDENTITY) {
    // We only support 64-bit precision in the X and Y components of positions for now
    shaderCoordinateOrigin = [Math.fround(viewport.position[0]), Math.fround(viewport.position[1])];
  }

  shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0;

  switch (shaderCoordinateSystem) {
    case PROJECT_COORDINATE_SYSTEM.LNG_LAT:
      projectionCenter = ZERO_VECTOR;
      break;

    // TODO: make lighting work for meter offset mode
    case PROJECT_COORDINATE_SYSTEM.LNGLAT_OFFSETS:
    case PROJECT_COORDINATE_SYSTEM.METER_OFFSETS:
    case PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET:
    case PROJECT_COORDINATE_SYSTEM.IDENTITY:
      // Calculate transformed projectionCenter (using 64 bit precision JS)
      // This is the key to offset mode precision
      // (avoids doing this addition in 32 bit precision in GLSL)
      const positionCommonSpace = viewport.projectPosition(
        shaderCoordinateOrigin,
        Math.pow(2, coordinateZoom)
      );

      cameraPosCommon = [
        cameraPosCommon[0] - positionCommonSpace[0],
        cameraPosCommon[1] - positionCommonSpace[1],
        cameraPosCommon[2] - positionCommonSpace[2]
      ];

      positionCommonSpace[3] = 1;

      // projectionCenter = new Matrix4(viewProjectionMatrix)
      //   .transformVector([positionPixels[0], positionPixels[1], 0.0, 1.0]);
      projectionCenter = vec4.transformMat4([], positionCommonSpace, viewProjectionMatrix);

      // Always apply uncentered projection matrix if available (shader adds center)
      viewMatrix = viewMatrixUncentered || viewMatrix;

      // Zero out 4th coordinate ("after" model matrix) - avoids further translations
      // viewMatrix = new Matrix4(viewMatrixUncentered || viewMatrix)
      //   .multiplyRight(VECTOR_TO_POINT_MATRIX);
      viewProjectionMatrix = mat4.multiply([], projectionMatrix, viewMatrix);
      viewProjectionMatrix = mat4.multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX);
      break;

    default:
      throw new Error('Unknown projection mode');
  }

  return {
    viewMatrix,
    viewProjectionMatrix,
    projectionCenter,
    cameraPosCommon,
    shaderCoordinateSystem,
    shaderCoordinateOrigin
  };
}

/**
 * Returns uniforms for shaders based on current projection
 * includes: projection matrix suitable for shaders
 *
 * TODO - Ensure this works with any viewport, not just WebMercatorViewports
 *
 * @param {WebMercatorViewport} viewport -
 * @return {Float32Array} - 4x4 projection matrix that can be used in shaders
 */
export function getUniformsFromViewport({
  viewport,
  devicePixelRatio = 1,
  modelMatrix = null,
  // Match Layer.defaultProps
  coordinateSystem = COORDINATE_SYSTEM.LNGLAT,
  coordinateOrigin = DEFAULT_COORDINATE_ORIGIN,
  wrapLongitude = false,
  // Deprecated
  projectionMode,
  positionOrigin
} = {}) {
  assert(viewport);

  return Object.assign(
    {
      project_uModelMatrix: modelMatrix || IDENTITY_MATRIX
    },
    getMemoizedViewportUniforms({
      viewport,
      devicePixelRatio,
      coordinateSystem,
      coordinateOrigin,
      wrapLongitude
    })
  );
}

function calculateViewportUniforms({
  viewport,
  devicePixelRatio,
  coordinateSystem,
  coordinateOrigin,
  wrapLongitude
}) {
  const coordinateZoom = viewport.zoom;

  const {
    projectionCenter,
    viewProjectionMatrix,
    cameraPosCommon,
    shaderCoordinateSystem,
    shaderCoordinateOrigin
  } = calculateMatrixAndOffset({
    coordinateSystem,
    coordinateOrigin,
    coordinateZoom,
    viewport
  });

  assert(viewProjectionMatrix, 'Viewport missing modelViewProjectionMatrix');

  // Calculate projection pixels per unit
  const distanceScales = viewport.getDistanceScales();

  const viewportSize = [viewport.width * devicePixelRatio, viewport.height * devicePixelRatio];

  const uniforms = {
    // Projection mode values
    project_uCoordinateSystem: shaderCoordinateSystem,
    project_uCenter: projectionCenter,
    project_uWrapLongitude: wrapLongitude,
    project_uAntimeridian: (viewport.longitude || 0) - 180,

    // Screen size
    project_uViewportSize: viewportSize,
    project_uDevicePixelRatio: devicePixelRatio,

    // Distance at which screen pixels are projected
    project_uFocalDistance: viewport.focalDistance || 1,
    project_uCommonUnitsPerMeter: distanceScales.pixelsPerMeter,
    project_uCommonUnitsPerWorldUnit: distanceScales.pixelsPerMeter,
    project_uCommonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2,
    project_uScale: viewport.scale, // This is the mercator scale (2 ** zoom)

    project_uViewProjectionMatrix: viewProjectionMatrix,

    // This is for lighting calculations
    project_uCameraPosition: cameraPosCommon
  };

  const distanceScalesAtOrigin = viewport.getDistanceScales(shaderCoordinateOrigin);
  switch (shaderCoordinateSystem) {
    case PROJECT_COORDINATE_SYSTEM.METER_OFFSETS:
      uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.pixelsPerMeter;
      uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.pixelsPerMeter2;
      break;

    case PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET:
      uniforms.project_uCoordinateOrigin = shaderCoordinateOrigin;
    // eslint-disable-line no-fallthrough
    case PROJECT_COORDINATE_SYSTEM.LNG_LAT:
    case PROJECT_COORDINATE_SYSTEM.LNGLAT_OFFSETS:
      uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.pixelsPerDegree;
      uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.pixelsPerDegree2;
      break;

    case PROJECT_COORDINATE_SYSTEM.IDENTITY:
      uniforms.project_uCoordinateOrigin = shaderCoordinateOrigin;
      break;

    default:
      break;
  }

  return uniforms;
}

1	// Copyright (c) 2015 - 2017 Uber Technologies, Inc.	16×
2	//
3	// Permission is hereby granted, free of charge, to any person obtaining a copy
4	// of this software and associated documentation files (the "Software"), to deal
5	// in the Software without restriction, including without limitation the rights
6	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7	// copies of the Software, and to permit persons to whom the Software is
8	// furnished to do so, subject to the following conditions:
9	//
10	// The above copyright notice and this permission notice shall be included in
11	// all copies or substantial portions of the Software.
12	//
13	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19	// THE SOFTWARE.
20
21	import * as mat4 from 'gl-matrix/mat4';
22	import * as vec4 from 'gl-matrix/vec4';
23
24	import {COORDINATE_SYSTEM} from '../../lib/constants';
25
26	import memoize from '../../utils/memoize';
27	import assert from '../../utils/assert';
28
29	import {PROJECT_COORDINATE_SYSTEM} from './constants';
30
31	// To quickly set a vector to zero
32	const ZERO_VECTOR = [0, 0, 0, 0];	1×
33	// 4x4 matrix that drops 4th component of vector
34	const VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];	1×
35	const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];	1×
36	const DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];	1×
37	const DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];	1×
38
39	// Based on viewport-mercator-project/test/fp32-limits.js
40	export const LNGLAT_AUTO_OFFSET_ZOOM_THRESHOLD = 12;	1×
41
42	const getMemoizedViewportUniforms = memoize(calculateViewportUniforms);	1×
43
44	function getShaderCoordinateSystem(coordinateSystem) {
45	switch (coordinateSystem) {	26×
46	case COORDINATE_SYSTEM.LNGLAT:
47	default:
48	return PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET;	14×
49
50	case COORDINATE_SYSTEM.LNGLAT_DEPRECATED:
51	return PROJECT_COORDINATE_SYSTEM.LNG_LAT;	4×
52
53	case COORDINATE_SYSTEM.METER_OFFSETS:
54	case COORDINATE_SYSTEM.METERS:
55	return PROJECT_COORDINATE_SYSTEM.METER_OFFSETS;	3×
56
57	case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
58	return PROJECT_COORDINATE_SYSTEM.LNGLAT_OFFSETS;	3×
59
60	case COORDINATE_SYSTEM.IDENTITY:
61	return PROJECT_COORDINATE_SYSTEM.IDENTITY;	2×
62	}
63	}
64
65	// The code that utilizes Matrix4 does the same calculation as their mat4 counterparts,
66	// has lower performance but provides error checking.
67	// Uncomment when debugging
68	function calculateMatrixAndOffset({
69	// UNCHANGED
70	viewport,
71	// NEW PARAMS
72	coordinateSystem,
73	coordinateOrigin,
74	coordinateZoom
75	}) {
76	const {viewMatrixUncentered} = viewport;	26×
77	let {viewMatrix} = viewport;	26×
78	const {projectionMatrix} = viewport;	26×
79	let {viewProjectionMatrix} = viewport;	26×
80
81	let projectionCenter;
82	let cameraPosCommon = viewport.cameraPosition;	26×
83	let shaderCoordinateSystem = getShaderCoordinateSystem(coordinateSystem);	26×
84	let shaderCoordinateOrigin = coordinateOrigin;	26×
85
86	if (shaderCoordinateSystem === PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET) {	26×
87	if (coordinateZoom < LNGLAT_AUTO_OFFSET_ZOOM_THRESHOLD) {	14×
88	// Use LNG_LAT projection if not zooming
89	shaderCoordinateSystem = PROJECT_COORDINATE_SYSTEM.LNG_LAT;	8×
90	} else {
91	// Use LNGLAT_AUTO_OFFSET
92	const lng = Math.fround(viewport.longitude);	6×
93	const lat = Math.fround(viewport.latitude);	6×
94	shaderCoordinateOrigin = [lng, lat];	6×
95	}
96	}
97	if (shaderCoordinateSystem === PROJECT_COORDINATE_SYSTEM.IDENTITY) {	26×
98	// We only support 64-bit precision in the X and Y components of positions for now
99	shaderCoordinateOrigin = [Math.fround(viewport.position[0]), Math.fround(viewport.position[1])];	2×
100	}
101
102	shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] \|\| 0;	26×
103
104	switch (shaderCoordinateSystem) {	Branches [[5, 5]] missed. 26×
105	case PROJECT_COORDINATE_SYSTEM.LNG_LAT:
106	projectionCenter = ZERO_VECTOR;	12×
107	break;	12×
108
109	// TODO: make lighting work for meter offset mode
110	case PROJECT_COORDINATE_SYSTEM.LNGLAT_OFFSETS:
111	case PROJECT_COORDINATE_SYSTEM.METER_OFFSETS:
112	case PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET:
113	case PROJECT_COORDINATE_SYSTEM.IDENTITY:
114	// Calculate transformed projectionCenter (using 64 bit precision JS)
115	// This is the key to offset mode precision
116	// (avoids doing this addition in 32 bit precision in GLSL)
117	const positionCommonSpace = viewport.projectPosition(	14×
118	shaderCoordinateOrigin,
119	Math.pow(2, coordinateZoom)
120	);
121
122	cameraPosCommon = [	14×
123	cameraPosCommon[0] - positionCommonSpace[0],
124	cameraPosCommon[1] - positionCommonSpace[1],
125	cameraPosCommon[2] - positionCommonSpace[2]
126	];
127
128	positionCommonSpace[3] = 1;	14×
129
130	// projectionCenter = new Matrix4(viewProjectionMatrix)
131	// .transformVector([positionPixels[0], positionPixels[1], 0.0, 1.0]);
132	projectionCenter = vec4.transformMat4([], positionCommonSpace, viewProjectionMatrix);	14×
133
134	// Always apply uncentered projection matrix if available (shader adds center)
135	viewMatrix = viewMatrixUncentered \|\| viewMatrix;	Branches [[6, 1]] missed. 14×
136
137	// Zero out 4th coordinate ("after" model matrix) - avoids further translations
138	// viewMatrix = new Matrix4(viewMatrixUncentered \|\| viewMatrix)
139	// .multiplyRight(VECTOR_TO_POINT_MATRIX);
140	viewProjectionMatrix = mat4.multiply([], projectionMatrix, viewMatrix);	14×
141	viewProjectionMatrix = mat4.multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX);	14×
142	break;	14×
143
144	default:
UNCOV 145	throw new Error('Unknown projection mode');	!
146	}
147
148	return {	26×
149	viewMatrix,
150	viewProjectionMatrix,
151	projectionCenter,
152	cameraPosCommon,
153	shaderCoordinateSystem,
154	shaderCoordinateOrigin
155	};
156	}
157
158	/**
159	* Returns uniforms for shaders based on current projection
160	* includes: projection matrix suitable for shaders
161	*
162	* TODO - Ensure this works with any viewport, not just WebMercatorViewports
163	*
164	* @param {WebMercatorViewport} viewport -
165	* @return {Float32Array} - 4x4 projection matrix that can be used in shaders
166	*/
167	export function getUniformsFromViewport({	Branches [[7, 0]] missed.
168	viewport,
169	devicePixelRatio = 1,
170	modelMatrix = null,
171	// Match Layer.defaultProps
172	coordinateSystem = COORDINATE_SYSTEM.LNGLAT,
173	coordinateOrigin = DEFAULT_COORDINATE_ORIGIN,
174	wrapLongitude = false,
175	// Deprecated
176	projectionMode,
177	positionOrigin
178	} = {}) {
179	assert(viewport);	484×
180
181	return Object.assign(	484×
182	{
183	project_uModelMatrix: modelMatrix \|\| IDENTITY_MATRIX
184	},
185	getMemoizedViewportUniforms({
186	viewport,
187	devicePixelRatio,
188	coordinateSystem,
189	coordinateOrigin,
190	wrapLongitude
191	})
192	);
193	}
194
195	function calculateViewportUniforms({
196	viewport,
197	devicePixelRatio,
198	coordinateSystem,
199	coordinateOrigin,
200	wrapLongitude
201	}) {
202	const coordinateZoom = viewport.zoom;	26×
203
204	const {
205	projectionCenter,
206	viewProjectionMatrix,
207	cameraPosCommon,
208	shaderCoordinateSystem,
209	shaderCoordinateOrigin
210	} = calculateMatrixAndOffset({	26×
211	coordinateSystem,
212	coordinateOrigin,
213	coordinateZoom,
214	viewport
215	});
216
217	assert(viewProjectionMatrix, 'Viewport missing modelViewProjectionMatrix');	26×
218
219	// Calculate projection pixels per unit
220	const distanceScales = viewport.getDistanceScales();	26×
221
222	const viewportSize = [viewport.width * devicePixelRatio, viewport.height * devicePixelRatio];	26×
223
224	const uniforms = {	26×
225	// Projection mode values
226	project_uCoordinateSystem: shaderCoordinateSystem,
227	project_uCenter: projectionCenter,
228	project_uWrapLongitude: wrapLongitude,
229	project_uAntimeridian: (viewport.longitude \|\| 0) - 180,
230
231	// Screen size
232	project_uViewportSize: viewportSize,
233	project_uDevicePixelRatio: devicePixelRatio,
234
235	// Distance at which screen pixels are projected
236	project_uFocalDistance: viewport.focalDistance \|\| 1,	Branches [[15, 1]] missed.
237	project_uCommonUnitsPerMeter: distanceScales.pixelsPerMeter,
238	project_uCommonUnitsPerWorldUnit: distanceScales.pixelsPerMeter,
239	project_uCommonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2,
240	project_uScale: viewport.scale, // This is the mercator scale (2 ** zoom)
241
242	project_uViewProjectionMatrix: viewProjectionMatrix,
243
244	// This is for lighting calculations
245	project_uCameraPosition: cameraPosCommon
246	};
247
248	const distanceScalesAtOrigin = viewport.getDistanceScales(shaderCoordinateOrigin);	26×
249	switch (shaderCoordinateSystem) {	Branches [[16, 5]] missed. 26×
250	case PROJECT_COORDINATE_SYSTEM.METER_OFFSETS:
251	uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.pixelsPerMeter;	3×
252	uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.pixelsPerMeter2;	3×
253	break;	3×
254
255	case PROJECT_COORDINATE_SYSTEM.LNGLAT_AUTO_OFFSET:
256	uniforms.project_uCoordinateOrigin = shaderCoordinateOrigin;	6×
257	// eslint-disable-line no-fallthrough
258	case PROJECT_COORDINATE_SYSTEM.LNG_LAT:
259	case PROJECT_COORDINATE_SYSTEM.LNGLAT_OFFSETS:
260	uniforms.project_uCommonUnitsPerWorldUnit = distanceScalesAtOrigin.pixelsPerDegree;	21×
261	uniforms.project_uCommonUnitsPerWorldUnit2 = distanceScalesAtOrigin.pixelsPerDegree2;	21×
262	break;	21×
263
264	case PROJECT_COORDINATE_SYSTEM.IDENTITY:
265	uniforms.project_uCoordinateOrigin = shaderCoordinateOrigin;	2×
266	break;	2×
267
268	default:
UNCOV 269	break;	!
270	}
271
272	return uniforms;	26×
273	}

uber / deck.gl / 13030

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