Coveralls logob
Coveralls logo
  • Home
  • Features
  • Pricing
  • Docs
  • Sign In

uber / deck.gl / 13030

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

Pull #3490

travis-ci-com

9181eb84f9c35729a3bad740fb7f9d93?size=18&default=identiconweb-flow
integrate mapbox's near plane fix
Pull Request #3490: [MapboxLayer] integrate mapbox-gl's near plane fix

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
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
}
Troubleshooting · Open an Issue · Sales · Support · ENTERPRISE · CAREERS · STATUS
BLOG · TWITTER · Legal & Privacy · Supported CI Services · What's a CI service? · Automated Testing

© 2019 Coveralls, LLC