remove linejoin shader

The previous commit switched to using triangles for drawing round joins.

src/mbgl/geometry/elements_buffer.cpp

@@ -14,8 +14,3 @@ void LineElementsBuffer::add(element_type a, element_type b) {
     elements[0] = a;
     elements[1] = b;
 }
-
-void PointElementsBuffer::add(element_type a) {
-    uint16_t *data = static_cast<element_type *>(addElement());
-    data[0] = a;
-}

src/mbgl/geometry/elements_buffer.hpp

@@ -44,16 +44,6 @@ public:
     void add(element_type a, element_type b);
 };
 
-class PointElementsBuffer : public Buffer<
-    2, // bytes per point (1 unsigned short)
-    GL_ELEMENT_ARRAY_BUFFER
-> {
-public:
-    typedef uint16_t element_type;
-
-    void add(element_type a);
-};
-
 }
 
 #endif

src/mbgl/map/tile_parser.cpp

@@ -172,8 +172,7 @@ std::unique_ptr<Bucket> TileParser::createFillBucket(const GeometryTileLayer& la
 std::unique_ptr<Bucket> TileParser::createLineBucket(const GeometryTileLayer& layer,
                                                      const StyleBucket& bucket_desc) {
     auto bucket = util::make_unique<LineBucket>(tile.lineVertexBuffer,
-                                                tile.triangleElementsBuffer,
-                                                tile.pointElementsBuffer);
+                                                tile.triangleElementsBuffer);
 
     const float z = tile.id.z;
     auto& layout = bucket->layout;

src/mbgl/map/vector_tile_data.hpp

@@ -50,7 +50,6 @@ protected:
 
     TriangleElementsBuffer triangleElementsBuffer;
     LineElementsBuffer lineElementsBuffer;
-    PointElementsBuffer pointElementsBuffer;
 
     // Holds the buckets of this tile.
     // They contain the location offsets in the buffers stored above

src/mbgl/renderer/line_bucket.cpp

@@ -16,23 +16,18 @@ using namespace mbgl;
 
 
 LineBucket::LineBucket(LineVertexBuffer &vertexBuffer_,
-                       TriangleElementsBuffer &triangleElementsBuffer_,
-                       PointElementsBuffer &pointElementsBuffer_)
+                       TriangleElementsBuffer &triangleElementsBuffer_)
     : vertexBuffer(vertexBuffer_),
       triangleElementsBuffer(triangleElementsBuffer_),
-      pointElementsBuffer(pointElementsBuffer_),
       vertex_start(vertexBuffer_.index()),
-      triangle_elements_start(triangleElementsBuffer_.index()),
-      point_elements_start(pointElementsBuffer_.index()) {
-}
+      triangle_elements_start(triangleElementsBuffer_.index()) {
+};
 
 LineBucket::~LineBucket() {
     // Do not remove. header file only contains forward definitions to unique pointers.
 }
 
 
-typedef uint16_t PointElement;
-
 void LineBucket::addGeometry(const GeometryCollection& geometryCollection) {
     for (auto& line : geometryCollection) {
         addGeometry(line);
@@ -282,25 +277,6 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
         group.vertex_length += vertex_count;
         group.elements_length += triangleStore.size();
     }
-    /*
-
-    // Store the line join/cap groups.
-    {
-        if (!pointGroups.size() || (pointGroups.back()->vertex_length + vertex_count > 65535)) {
-            // Move to a new group because the old one can't hold the geometry.
-            pointGroups.emplace_back(util::make_unique<point_group_type>());
-        }
-
-        assert(pointGroups.back());
-        point_group_type& group = *pointGroups.back();
-        for (const auto point : point_store) {
-            pointElementsBuffer.add(group.vertex_length + point);
-        }
-
-        group.vertex_length += vertex_count;
-        group.elements_length += point_store.size();
-    }
-    */
 }
 
 void LineBucket::addCurrentVertex(const Coordinate& currentVertex, float flip, double distance,
@@ -335,19 +311,7 @@ void LineBucket::render(Painter &painter, const StyleLayer &layer_desc, const Ti
 }
 
 bool LineBucket::hasData() const {
-    return !triangleGroups.empty() || !pointGroups.empty();
-}
-
-bool LineBucket::hasPoints() const {
-    if (!pointGroups.empty()) {
-        for (const auto& group : pointGroups) {
-            assert(group);
-            if (group->elements_length) {
-                return true;
-            }
-        }
-    }
-    return false;
+    return !triangleGroups.empty();
 }
 
 void LineBucket::drawLines(LineShader& shader) {
@@ -394,18 +358,3 @@ void LineBucket::drawLinePatterns(LinepatternShader& shader) {
         elements_index += group->elements_length * triangleElementsBuffer.itemSize;
     }
 }
-
-void LineBucket::drawPoints(LinejoinShader& shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
-    char *elements_index = BUFFER_OFFSET(point_elements_start * pointElementsBuffer.itemSize);
-    for (auto& group : pointGroups) {
-        assert(group);
-        if (!group->elements_length) {
-            continue;
-        }
-        group->array[0].bind(shader, vertexBuffer, pointElementsBuffer, vertex_index);
-        MBGL_CHECK_ERROR(glDrawElements(GL_POINTS, group->elements_length, GL_UNSIGNED_SHORT, elements_index));
-        vertex_index += group->vertex_length * vertexBuffer.itemSize;
-        elements_index += group->elements_length * pointElementsBuffer.itemSize;
-    }
-}

src/mbgl/renderer/line_bucket.hpp

@@ -18,18 +18,14 @@ class Style;
 class LineVertexBuffer;
 class TriangleElementsBuffer;
 class LineShader;
-class LinejoinShader;
 class LineSDFShader;
 class LinepatternShader;
 
 class LineBucket : public Bucket {
     typedef ElementGroup<3> triangle_group_type;
-    typedef ElementGroup<1> point_group_type;
 
 public:
-    LineBucket(LineVertexBuffer &vertexBuffer,
-               TriangleElementsBuffer &triangleElementsBuffer,
-               PointElementsBuffer &pointElementsBuffer);
+    LineBucket(LineVertexBuffer &vertexBuffer, TriangleElementsBuffer &triangleElementsBuffer);
     ~LineBucket() override;
 
     void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
@@ -39,12 +35,9 @@ public:
     void addGeometry(const GeometryCollection&);
     void addGeometry(const std::vector<Coordinate>& line);
 
-    bool hasPoints() const;
-
     void drawLines(LineShader& shader);
     void drawLineSDF(LineSDFShader& shader);
     void drawLinePatterns(LinepatternShader& shader);
-    void drawPoints(LinejoinShader& shader);
 
 private:
     struct TriangleElement {
@@ -61,18 +54,15 @@ public:
 private:
     LineVertexBuffer& vertexBuffer;
     TriangleElementsBuffer& triangleElementsBuffer;
-    PointElementsBuffer& pointElementsBuffer;
 
     const size_t vertex_start;
     const size_t triangle_elements_start;
-    const size_t point_elements_start;
 
     int32_t e1;
     int32_t e2;
     int32_t e3;
 
     std::vector<std::unique_ptr<triangle_group_type>> triangleGroups;
-    std::vector<std::unique_ptr<point_group_type>> pointGroups;
 };
 
 }

src/mbgl/renderer/painter.cpp

@@ -62,7 +62,6 @@ void Painter::setup() {
     assert(plainShader);
     assert(outlineShader);
     assert(lineShader);
-    assert(linejoinShader);
     assert(linepatternShader);
     assert(patternShader);
     assert(rasterShader);
@@ -96,7 +95,6 @@ void Painter::setupShaders() {
     if (!plainShader) plainShader = util::make_unique<PlainShader>();
     if (!outlineShader) outlineShader = util::make_unique<OutlineShader>();
     if (!lineShader) lineShader = util::make_unique<LineShader>();
-    if (!linejoinShader) linejoinShader = util::make_unique<LinejoinShader>();
     if (!linesdfShader) linesdfShader = util::make_unique<LineSDFShader>();
     if (!linepatternShader) linepatternShader = util::make_unique<LinepatternShader>();
     if (!patternShader) patternShader = util::make_unique<PatternShader>();
@@ -112,7 +110,6 @@ void Painter::deleteShaders() {
     plainShader = nullptr;
     outlineShader = nullptr;
     lineShader = nullptr;
-    linejoinShader = nullptr;
     linepatternShader = nullptr;
     patternShader = nullptr;
     iconShader = nullptr;

src/mbgl/renderer/painter.hpp

@@ -13,7 +13,6 @@
 #include <mbgl/shader/outline_shader.hpp>
 #include <mbgl/shader/pattern_shader.hpp>
 #include <mbgl/shader/line_shader.hpp>
-#include <mbgl/shader/linejoin_shader.hpp>
 #include <mbgl/shader/linesdf_shader.hpp>
 #include <mbgl/shader/linepattern_shader.hpp>
 #include <mbgl/shader/icon_shader.hpp>
@@ -199,7 +198,6 @@ public:
     std::unique_ptr<PlainShader> plainShader;
     std::unique_ptr<OutlineShader> outlineShader;
     std::unique_ptr<LineShader> lineShader;
-    std::unique_ptr<LinejoinShader> linejoinShader;
     std::unique_ptr<LineSDFShader> linesdfShader;
     std::unique_ptr<LinepatternShader> linepatternShader;
     std::unique_ptr<PatternShader> patternShader;

src/mbgl/renderer/painter_line.cpp

@@ -51,29 +51,6 @@ void Painter::renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const
 
     depthRange(strata, 1.0f);
 
-    // We're only drawing end caps + round line joins if the line is > 2px. Otherwise, they aren't visible anyway.
-    if (bucket.hasPoints() && outset > 1.0f) {
-        useProgram(linejoinShader->program);
-        linejoinShader->u_matrix = vtxMatrix;
-        linejoinShader->u_color = color;
-        linejoinShader->u_world = {{
-            state.getFramebufferWidth() * 0.5f,
-            state.getFramebufferHeight() * 0.5f
-        }};
-        linejoinShader->u_linewidth = {{
-            ((outset - 0.25f) * state.getPixelRatio()),
-            ((inset - 0.25f) * state.getPixelRatio())
-        }};
-
-        float pointSize = std::ceil(state.getPixelRatio() * outset * 2.0);
-#if defined(GL_ES_VERSION_2_0)
-        linejoinShader->u_size = pointSize;
-#else
-        MBGL_CHECK_ERROR(glPointSize(pointSize));
-#endif
-        bucket.drawPoints(*linejoinShader);
-    }
-
     if (properties.dash_array.from.size()) {
 
         useProgram(linesdfShader->program);

src/mbgl/shader/linejoin.fragment.glsl

@@ -1,14 +0,0 @@
-uniform vec4 u_color;
-uniform vec2 u_linewidth;
-
-varying vec2 v_pos;
-
-void main() {
-    float dist = length(v_pos - gl_FragCoord.xy);
-
-    // Calculate the antialiasing fade factor. This is either when fading in
-    // the line in case of an offset line (v_linewidth.t) or when fading out
-    // (v_linewidth.s)
-    float alpha = clamp(min(dist - (u_linewidth.t - 1.0), u_linewidth.s - dist), 0.0, 1.0);
-    gl_FragColor = u_color * alpha;
-}

src/mbgl/shader/linejoin.vertex.glsl

@@ -1,13 +0,0 @@
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-uniform vec2 u_world;
-uniform float u_size;
-
-varying vec2 v_pos;
-
-void main() {
-    gl_Position = u_matrix * vec4(floor(a_pos / 2.0), 0.0, 1.0);
-    v_pos = (gl_Position.xy + 1.0) * u_world;
-    gl_PointSize = u_size;
-}

src/mbgl/shader/linejoin_shader.cpp

@@ -1,22 +0,0 @@
-#include <mbgl/shader/linejoin_shader.hpp>
-#include <mbgl/shader/shaders.hpp>
-#include <mbgl/platform/gl.hpp>
-
-#include <cstdio>
-
-using namespace mbgl;
-
-LinejoinShader::LinejoinShader()
-    : Shader(
-        "linejoin",
-        shaders[LINEJOIN_SHADER].vertex,
-        shaders[LINEJOIN_SHADER].fragment
-    ) {
-    a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
-}
-
-void LinejoinShader::bind(char *offset) {
-    MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-    // Note: We're referring to the vertices in a line array, which are 8 bytes long!
-    MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
-}

src/mbgl/shader/linejoin_shader.hpp

@@ -1,27 +0,0 @@
-#ifndef MBGL_SHADER_SHADER_LINEJOIN
-#define MBGL_SHADER_SHADER_LINEJOIN
-
-#include <mbgl/shader/shader.hpp>
-#include <mbgl/shader/uniform.hpp>
-
-namespace mbgl {
-
-class LinejoinShader : public Shader {
-public:
-    LinejoinShader();
-
-    void bind(char *offset);
-
-    UniformMatrix<4>              u_matrix    = {"u_matrix",    *this};
-    Uniform<std::array<float, 4>> u_color     = {"u_color",     *this};
-    Uniform<std::array<float, 2>> u_world     = {"u_world",     *this};
-    Uniform<std::array<float, 2>> u_linewidth = {"u_linewidth", *this};
-    Uniform<float>                u_size      = {"u_size",      *this};
-
-private:
-    int32_t a_pos = -1;
-};
-
-}
-
-#endif