@mapwhit/tilerenderer 0.47.1

package/src/gl/context.js

@@ -0,0 +1,193 @@
+const IndexBuffer = require('./index_buffer');
+
+const VertexBuffer = require('./vertex_buffer');
+const Framebuffer = require('./framebuffer');
+const ColorMode = require('./color_mode');
+const { deepEqual } = require('../util/object');
+const {
+  ClearColor,
+  ClearDepth,
+  ClearStencil,
+  ColorMask,
+  DepthMask,
+  StencilMask,
+  StencilFunc,
+  StencilOp,
+  StencilTest,
+  DepthRange,
+  DepthTest,
+  DepthFunc,
+  Blend,
+  BlendFunc,
+  BlendColor,
+  CullFace,
+  CullFaceSide,
+  FrontFace,
+  Program,
+  ActiveTextureUnit,
+  Viewport,
+  BindFramebuffer,
+  BindRenderbuffer,
+  BindTexture,
+  BindVertexBuffer,
+  BindElementBuffer,
+  BindVertexArrayOES,
+  PixelStoreUnpack,
+  PixelStoreUnpackPremultiplyAlpha
+} = require('./value');
+
+class Context {
+  constructor(gl) {
+    this.gl = gl;
+    this.extVertexArrayObject = this.gl.getExtension('OES_vertex_array_object');
+
+    this.clearColor = new ClearColor(this);
+    this.clearDepth = new ClearDepth(this);
+    this.clearStencil = new ClearStencil(this);
+    this.colorMask = new ColorMask(this);
+    this.depthMask = new DepthMask(this);
+    this.stencilMask = new StencilMask(this);
+    this.stencilFunc = new StencilFunc(this);
+    this.stencilOp = new StencilOp(this);
+    this.stencilTest = new StencilTest(this);
+    this.depthRange = new DepthRange(this);
+    this.depthTest = new DepthTest(this);
+    this.depthFunc = new DepthFunc(this);
+    this.blend = new Blend(this);
+    this.blendFunc = new BlendFunc(this);
+    this.blendColor = new BlendColor(this);
+    this.cullFace = new CullFace(this);
+    this.cullFaceSide = new CullFaceSide(this);
+    this.frontFace = new FrontFace(this);
+    this.program = new Program(this);
+    this.activeTexture = new ActiveTextureUnit(this);
+    this.viewport = new Viewport(this);
+    this.bindFramebuffer = new BindFramebuffer(this);
+    this.bindRenderbuffer = new BindRenderbuffer(this);
+    this.bindTexture = new BindTexture(this);
+    this.bindVertexBuffer = new BindVertexBuffer(this);
+    this.bindElementBuffer = new BindElementBuffer(this);
+    this.bindVertexArrayOES = this.extVertexArrayObject && new BindVertexArrayOES(this);
+    this.pixelStoreUnpack = new PixelStoreUnpack(this);
+    this.pixelStoreUnpackPremultiplyAlpha = new PixelStoreUnpackPremultiplyAlpha(this);
+
+    this.extTextureFilterAnisotropic =
+      gl.getExtension('EXT_texture_filter_anisotropic') ||
+      gl.getExtension('MOZ_EXT_texture_filter_anisotropic') ||
+      gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic');
+    if (this.extTextureFilterAnisotropic) {
+      this.extTextureFilterAnisotropicMax = gl.getParameter(
+        this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT
+      );
+    }
+
+    this.extTextureHalfFloat = gl.getExtension('OES_texture_half_float');
+    if (this.extTextureHalfFloat) {
+      gl.getExtension('OES_texture_half_float_linear');
+    }
+  }
+
+  createIndexBuffer(array, dynamicDraw) {
+    return new IndexBuffer(this, array, dynamicDraw);
+  }
+
+  createVertexBuffer(array, attributes, dynamicDraw) {
+    return new VertexBuffer(this, array, attributes, dynamicDraw);
+  }
+
+  createRenderbuffer(storageFormat, width, height) {
+    const gl = this.gl;
+
+    const rbo = gl.createRenderbuffer();
+    this.bindRenderbuffer.set(rbo);
+    gl.renderbufferStorage(gl.RENDERBUFFER, storageFormat, width, height);
+    this.bindRenderbuffer.set(null);
+
+    return rbo;
+  }
+
+  createFramebuffer(width, height) {
+    return new Framebuffer(this, width, height);
+  }
+
+  clear({ color, depth }) {
+    const gl = this.gl;
+    let mask = 0;
+
+    if (color) {
+      mask |= gl.COLOR_BUFFER_BIT;
+      this.clearColor.set(color);
+      this.colorMask.set([true, true, true, true]);
+    }
+
+    if (typeof depth !== 'undefined') {
+      mask |= gl.DEPTH_BUFFER_BIT;
+
+      // Workaround for platforms where clearDepth doesn't seem to work
+      // without reseting the depthRange. See https://github.com/mapbox/mapbox-gl-js/issues/3437
+      this.depthRange.set([0, 1]);
+
+      this.clearDepth.set(depth);
+      this.depthMask.set(true);
+    }
+
+    // See note in Painter#clearStencil: implement this the easy way once GPU bug/workaround is fixed upstream
+    // if (typeof stencil !== 'undefined') {
+    //     mask |= gl.STENCIL_BUFFER_BIT;
+    //     this.clearStencil.set(stencil);
+    //     this.stencilMask.set(0xFF);
+    // }
+
+    gl.clear(mask);
+  }
+
+  setCullFace(cullFaceMode) {
+    if (cullFaceMode.enable === false) {
+      this.cullFace.set(false);
+    } else {
+      this.cullFace.set(true);
+      this.cullFaceSide.set(cullFaceMode.mode);
+      this.frontFace.set(cullFaceMode.frontFace);
+    }
+  }
+
+  setDepthMode(depthMode) {
+    if (depthMode.func === this.gl.ALWAYS && !depthMode.mask) {
+      this.depthTest.set(false);
+    } else {
+      this.depthTest.set(true);
+      this.depthFunc.set(depthMode.func);
+      this.depthMask.set(depthMode.mask);
+      this.depthRange.set(depthMode.range);
+    }
+  }
+
+  setStencilMode(stencilMode) {
+    if (stencilMode.test.func === this.gl.ALWAYS && !stencilMode.mask) {
+      this.stencilTest.set(false);
+    } else {
+      this.stencilTest.set(true);
+      this.stencilMask.set(stencilMode.mask);
+      this.stencilOp.set([stencilMode.fail, stencilMode.depthFail, stencilMode.pass]);
+      this.stencilFunc.set({
+        func: stencilMode.test.func,
+        ref: stencilMode.ref,
+        mask: stencilMode.test.mask
+      });
+    }
+  }
+
+  setColorMode(colorMode) {
+    if (deepEqual(colorMode.blendFunction, ColorMode.Replace)) {
+      this.blend.set(false);
+    } else {
+      this.blend.set(true);
+      this.blendFunc.set(colorMode.blendFunction);
+      this.blendColor.set(colorMode.blendColor);
+    }
+
+    this.colorMask.set(colorMode.mask);
+  }
+}
+
+module.exports = Context;

package/src/gl/cull_face_mode.js

@@ -0,0 +1,22 @@
+const BACK = 0x0405;
+const CCW = 0x0901;
+
+class CullFaceMode {
+  enable;
+  mode;
+  frontFace;
+
+  constructor(enable, mode, frontFace) {
+    this.enable = enable;
+    this.mode = mode;
+    this.frontFace = frontFace;
+  }
+
+  static disabled;
+  static backCCW;
+}
+
+CullFaceMode.disabled = new CullFaceMode(false, BACK, CCW);
+CullFaceMode.backCCW = new CullFaceMode(true, BACK, CCW);
+
+module.exports = CullFaceMode;

package/src/gl/depth_mode.js

@@ -0,0 +1,18 @@
+const ALWAYS = 0x0207;
+
+class DepthMode {
+  // DepthMask enums
+
+  constructor(depthFunc, depthMask, depthRange) {
+    this.func = depthFunc;
+    this.mask = depthMask;
+    this.range = depthRange;
+  }
+}
+
+DepthMode.ReadOnly = false;
+DepthMode.ReadWrite = true;
+
+DepthMode.disabled = new DepthMode(ALWAYS, DepthMode.ReadOnly, [0, 1]);
+
+module.exports = DepthMode;

package/src/gl/framebuffer.js

@@ -0,0 +1,28 @@
+const { ColorAttachment, DepthAttachment } = require('./value');
+
+class Framebuffer {
+  constructor(context, width, height) {
+    this.context = context;
+    this.width = width;
+    this.height = height;
+    const gl = context.gl;
+    const fbo = (this.framebuffer = gl.createFramebuffer());
+
+    this.colorAttachment = new ColorAttachment(context, fbo);
+    this.depthAttachment = new DepthAttachment(context, fbo);
+  }
+
+  destroy() {
+    const gl = this.context.gl;
+
+    const texture = this.colorAttachment.get();
+    if (texture) gl.deleteTexture(texture);
+
+    const renderbuffer = this.depthAttachment.get();
+    if (renderbuffer) gl.deleteRenderbuffer(renderbuffer);
+
+    gl.deleteFramebuffer(this.framebuffer);
+  }
+}
+
+module.exports = Framebuffer;

package/src/gl/index_buffer.js

@@ -0,0 +1,52 @@
+const assert = require('assert');
+
+class IndexBuffer {
+  constructor(context, array, dynamicDraw) {
+    this.context = context;
+    const gl = context.gl;
+    this.buffer = gl.createBuffer();
+    this.dynamicDraw = Boolean(dynamicDraw);
+
+    this.unbindVAO();
+
+    context.bindElementBuffer.set(this.buffer);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, array.arrayBuffer, this.dynamicDraw ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW);
+
+    if (!this.dynamicDraw) {
+      delete array.arrayBuffer;
+    }
+  }
+
+  unbindVAO() {
+    // The bound index buffer is part of vertex array object state. We don't want to
+    // modify whatever VAO happens to be currently bound, so make sure the default
+    // vertex array provided by the context is bound instead.
+    if (this.context.extVertexArrayObject) {
+      this.context.bindVertexArrayOES.set(null);
+    }
+  }
+
+  bind() {
+    this.context.bindElementBuffer.set(this.buffer);
+  }
+
+  updateData(array) {
+    const gl = this.context.gl;
+    assert(this.dynamicDraw);
+    // The right VAO will get this buffer re-bound later in VertexArrayObject#bind
+    // See https://github.com/mapbox/mapbox-gl-js/issues/5620
+    this.unbindVAO();
+    this.bind();
+    gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, array.arrayBuffer);
+  }
+
+  destroy() {
+    const gl = this.context.gl;
+    if (this.buffer) {
+      gl.deleteBuffer(this.buffer);
+      delete this.buffer;
+    }
+  }
+}
+
+module.exports = IndexBuffer;

package/src/gl/stencil_mode.js

@@ -0,0 +1,17 @@
+const ALWAYS = 0x0207;
+const KEEP = 0x1e00;
+
+class StencilMode {
+  constructor(test, ref, mask, fail, depthFail, pass) {
+    this.test = test;
+    this.ref = ref;
+    this.mask = mask;
+    this.fail = fail;
+    this.depthFail = depthFail;
+    this.pass = pass;
+  }
+}
+
+StencilMode.disabled = new StencilMode({ func: ALWAYS, mask: 0 }, 0, 0, KEEP, KEEP, KEEP);
+
+module.exports = StencilMode;