@mapwhit/tilerenderer 0.47.1

package/src/gl/vertex_buffer.js

@@ -0,0 +1,101 @@
+const assert = require('assert');
+
+/**
+ * @enum {string} AttributeType
+ * @private
+ * @readonly
+ */
+const AttributeType = {
+  Int8: 'BYTE',
+  Uint8: 'UNSIGNED_BYTE',
+  Int16: 'SHORT',
+  Uint16: 'UNSIGNED_SHORT',
+  Int32: 'INT',
+  Uint32: 'UNSIGNED_INT',
+  Float32: 'FLOAT'
+};
+
+/**
+ * The `VertexBuffer` class turns a `StructArray` into a WebGL buffer. Each member of the StructArray's
+ * Struct type is converted to a WebGL atribute.
+ * @private
+ */
+class VertexBuffer {
+  /**
+   * @param dynamicDraw Whether this buffer will be repeatedly updated.
+   */
+  constructor(context, array, attributes, dynamicDraw) {
+    this.length = array.length;
+    this.attributes = attributes;
+    this.itemSize = array.bytesPerElement;
+    this.dynamicDraw = dynamicDraw;
+
+    this.context = context;
+    const gl = context.gl;
+    this.buffer = gl.createBuffer();
+    context.bindVertexBuffer.set(this.buffer);
+    gl.bufferData(gl.ARRAY_BUFFER, array.arrayBuffer, this.dynamicDraw ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW);
+
+    if (!this.dynamicDraw) {
+      delete array.arrayBuffer;
+    }
+  }
+
+  bind() {
+    this.context.bindVertexBuffer.set(this.buffer);
+  }
+
+  updateData(array) {
+    assert(array.length === this.length);
+    const gl = this.context.gl;
+    this.bind();
+    gl.bufferSubData(gl.ARRAY_BUFFER, 0, array.arrayBuffer);
+  }
+
+  enableAttributes(gl, program) {
+    for (let j = 0; j < this.attributes.length; j++) {
+      const member = this.attributes[j];
+      const attribIndex = program.attributes[member.name];
+      if (attribIndex !== undefined) {
+        gl.enableVertexAttribArray(attribIndex);
+      }
+    }
+  }
+
+  /**
+   * Set the attribute pointers in a WebGL context
+   * @param gl The WebGL context
+   * @param program The active WebGL program
+   * @param vertexOffset Index of the starting vertex of the segment
+   */
+  setVertexAttribPointers(gl, program, vertexOffset) {
+    for (let j = 0; j < this.attributes.length; j++) {
+      const member = this.attributes[j];
+      const attribIndex = program.attributes[member.name];
+
+      if (attribIndex !== undefined) {
+        gl.vertexAttribPointer(
+          attribIndex,
+          member.components,
+          gl[AttributeType[member.type]],
+          false,
+          this.itemSize,
+          member.offset + this.itemSize * (vertexOffset || 0)
+        );
+      }
+    }
+  }
+
+  /**
+   * Destroy the GL buffer bound to the given WebGL context
+   */
+  destroy() {
+    const gl = this.context.gl;
+    if (this.buffer) {
+      gl.deleteBuffer(this.buffer);
+      delete this.buffer;
+    }
+  }
+}
+
+module.exports = VertexBuffer;

package/src/index.js

@@ -0,0 +1,50 @@
+module.exports = {
+  version: require('../package.json').version,
+  setRTLTextPlugin: require('./source/rtl_text_plugin').setRTLTextPlugin,
+  Map: require('./ui/map'),
+  Style: require('./style/style'),
+  LngLat: require('./geo/lng_lat'),
+  LngLatBounds: require('./geo/lng_lat_bounds'),
+  Point: require('@mapbox/point-geometry'),
+  Evented: require('./util/evented').Evented,
+  config: require('./util/config'),
+
+  get workerCount() {
+    return this.config.WORKER_COUNT;
+  },
+
+  set workerCount(count) {
+    this.config.WORKER_COUNT = count;
+  },
+
+  get workerUrl() {
+    return this.config.WORKER_URL;
+  },
+
+  set workerUrl(url) {
+    this.config.WORKER_URL = url;
+  }
+};
+
+/**
+ * The version of Mapbox GL JS in use as specified in `package.json`,
+ * `CHANGELOG.md`, and the GitHub release.
+ *
+ * @var {string} version
+ */
+
+/**
+ * Sets the map's [RTL text plugin](https://www.mapbox.com/mapbox-gl-js/plugins/#mapbox-gl-rtl-text).
+ * Necessary for supporting languages like Arabic and Hebrew that are written right-to-left.
+ *
+ * @function setRTLTextPlugin
+ * @param {string} pluginURL URL pointing to the Mapbox RTL text plugin source.
+ * @param {Function} callback Called with an error argument if there is an error.
+ * @example
+ * mapboxgl.setRTLTextPlugin('https://api.mapbox.com/mapbox-gl-js/plugins/mapbox-gl-rtl-text/v0.1.2/mapbox-gl-rtl-text.js');
+ * @see [Add support for right-to-left scripts](https://www.mapbox.com/mapbox-gl-js/example/mapbox-gl-rtl-text/)
+ */
+
+// canary assert: used to confirm that asserts have been removed from production build
+const assert = require('assert');
+assert(true, 'canary assert');

package/src/render/draw_background.js

@@ -0,0 +1,60 @@
+const StencilMode = require('../gl/stencil_mode');
+const DepthMode = require('../gl/depth_mode');
+const CullFaceMode = require('../gl/cull_face_mode');
+const { backgroundUniformValues, backgroundPatternUniformValues } = require('./program/background_program');
+
+module.exports = drawBackground;
+
+function drawBackground(painter, sourceCache, layer) {
+  const color = layer.paint.get('background-color');
+  const opacity = layer.paint.get('background-opacity');
+
+  if (opacity === 0) return;
+
+  const context = painter.context;
+  const gl = context.gl;
+  const transform = painter.transform;
+  const tileSize = transform.tileSize;
+  const image = layer.paint.get('background-pattern');
+  if (painter.isPatternMissing(image)) return;
+
+  const pass =
+    !image && color.a === 1 && opacity === 1 && painter.opaquePassEnabledForLayer() ? 'opaque' : 'translucent';
+  if (painter.renderPass !== pass) return;
+
+  const stencilMode = StencilMode.disabled;
+  const depthMode = painter.depthModeForSublayer(0, pass === 'opaque' ? DepthMode.ReadWrite : DepthMode.ReadOnly);
+  const colorMode = painter.colorModeForRenderPass();
+
+  const program = painter.useProgram(image ? 'backgroundPattern' : 'background');
+
+  const tileIDs = transform.coveringTiles({ tileSize });
+
+  if (image) {
+    context.activeTexture.set(gl.TEXTURE0);
+    painter.imageManager.bind(painter.context);
+  }
+
+  const crossfade = layer.getCrossfadeParameters();
+  for (const tileID of tileIDs) {
+    const matrix = painter.transform.calculatePosMatrix(tileID.toUnwrapped());
+
+    const uniformValues = image
+      ? backgroundPatternUniformValues(matrix, opacity, painter, image, { tileID, tileSize }, crossfade)
+      : backgroundUniformValues(matrix, opacity, color);
+
+    program.draw(
+      context,
+      gl.TRIANGLES,
+      depthMode,
+      stencilMode,
+      colorMode,
+      CullFaceMode.disabled,
+      uniformValues,
+      layer.id,
+      painter.tileExtentBuffer,
+      painter.quadTriangleIndexBuffer,
+      painter.tileExtentSegments
+    );
+  }
+}

package/src/render/draw_circle.js

@@ -0,0 +1,55 @@
+const StencilMode = require('../gl/stencil_mode');
+const DepthMode = require('../gl/depth_mode');
+const CullFaceMode = require('../gl/cull_face_mode');
+const { circleUniformValues } = require('./program/circle_program');
+
+module.exports = drawCircles;
+
+function drawCircles(painter, sourceCache, layer, coords) {
+  if (painter.renderPass !== 'translucent') return;
+
+  const opacity = layer.paint.get('circle-opacity');
+  const strokeWidth = layer.paint.get('circle-stroke-width');
+  const strokeOpacity = layer.paint.get('circle-stroke-opacity');
+
+  if (opacity.constantOr(1) === 0 && (strokeWidth.constantOr(1) === 0 || strokeOpacity.constantOr(1) === 0)) {
+    return;
+  }
+
+  const context = painter.context;
+  const gl = context.gl;
+
+  const depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+  // Turn off stencil testing to allow circles to be drawn across boundaries,
+  // so that large circles are not clipped to tiles
+  const stencilMode = StencilMode.disabled;
+  const colorMode = painter.colorModeForRenderPass();
+
+  for (let i = 0; i < coords.length; i++) {
+    const coord = coords[i];
+
+    const tile = sourceCache.getTile(coord);
+    const bucket = tile.getBucket(layer);
+    if (!bucket) continue;
+
+    const programConfiguration = bucket.programConfigurations.get(layer.id);
+    const program = painter.useProgram('circle', programConfiguration);
+
+    program.draw(
+      context,
+      gl.TRIANGLES,
+      depthMode,
+      stencilMode,
+      colorMode,
+      CullFaceMode.disabled,
+      circleUniformValues(painter, coord, tile, layer),
+      layer.id,
+      bucket.layoutVertexBuffer,
+      bucket.indexBuffer,
+      bucket.segments,
+      layer.paint,
+      painter.transform.zoom,
+      programConfiguration
+    );
+  }
+}

package/src/render/draw_collision_debug.js

@@ -0,0 +1,45 @@
+const DepthMode = require('../gl/depth_mode');
+const StencilMode = require('../gl/stencil_mode');
+const CullFaceMode = require('../gl/cull_face_mode');
+const { collisionUniformValues } = require('./program/collision_program');
+
+module.exports = drawCollisionDebug;
+
+function drawCollisionDebugGeometry(painter, sourceCache, layer, coords, drawCircles) {
+  const context = painter.context;
+  const gl = context.gl;
+  const program = drawCircles ? painter.useProgram('collisionCircle') : painter.useProgram('collisionBox');
+
+  for (let i = 0; i < coords.length; i++) {
+    const coord = coords[i];
+    const tile = sourceCache.getTile(coord);
+    const bucket = tile.getBucket(layer);
+    if (!bucket) continue;
+    const buffers = drawCircles ? bucket.collisionCircle : bucket.collisionBox;
+    if (!buffers) continue;
+
+    program.draw(
+      context,
+      drawCircles ? gl.TRIANGLES : gl.LINES,
+      DepthMode.disabled,
+      StencilMode.disabled,
+      painter.colorModeForRenderPass(),
+      CullFaceMode.disabled,
+      collisionUniformValues(coord.posMatrix, painter.transform, tile),
+      layer.id,
+      buffers.layoutVertexBuffer,
+      buffers.indexBuffer,
+      buffers.segments,
+      null,
+      painter.transform.zoom,
+      null,
+      null,
+      buffers.collisionVertexBuffer
+    );
+  }
+}
+
+function drawCollisionDebug(painter, sourceCache, layer, coords) {
+  drawCollisionDebugGeometry(painter, sourceCache, layer, coords, false);
+  drawCollisionDebugGeometry(painter, sourceCache, layer, coords, true);
+}