From 7387bb8c02ca6adb678c24ad604a15a35e80d384 Mon Sep 17 00:00:00 2001 From: Alex Cristici Date: Fri, 16 Feb 2024 20:29:53 +0200 Subject: [PATCH] Vertex attribute by index instead of map (#2116) Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> --- include/mbgl/gfx/drawable_atlases_tweaker.hpp | 1 - include/mbgl/gfx/drawable_builder.hpp | 7 +- include/mbgl/gfx/shader_group.hpp | 15 +- include/mbgl/gfx/vertex_attribute.hpp | 107 ++++----- include/mbgl/gl/drawable_gl.hpp | 3 +- include/mbgl/mtl/drawable.hpp | 3 +- include/mbgl/renderer/layer_tweaker.hpp | 1 - .../shaders/custom_drawable_layer_ubo.hpp | 6 +- include/mbgl/shaders/gl/shader_group_gl.hpp | 10 +- include/mbgl/shaders/gl/shader_info.hpp | 32 +++ include/mbgl/shaders/gl/shader_program_gl.hpp | 1 + include/mbgl/shaders/mtl/clipping_mask.hpp | 2 - include/mbgl/shaders/mtl/shader_group.hpp | 14 +- include/mbgl/shaders/mtl/shader_program.hpp | 5 +- include/mbgl/shaders/shader_defines.hpp | 174 +++++++++++++- include/mbgl/shaders/shader_program_base.hpp | 3 +- src/mbgl/gfx/drawable_builder.cpp | 3 +- src/mbgl/gfx/drawable_builder_impl.cpp | 16 +- src/mbgl/gfx/symbol_drawable_data.hpp | 3 - src/mbgl/gfx/vertex_attribute.cpp | 54 ++--- src/mbgl/gl/drawable_gl.cpp | 7 +- src/mbgl/gl/drawable_gl_builder.cpp | 2 +- src/mbgl/gl/drawable_gl_impl.hpp | 3 +- src/mbgl/gl/upload_pass.cpp | 6 +- src/mbgl/gl/vertex_attribute_gl.cpp | 8 +- src/mbgl/mtl/drawable.cpp | 13 +- src/mbgl/mtl/drawable_builder.cpp | 2 +- src/mbgl/mtl/drawable_impl.hpp | 3 +- src/mbgl/mtl/upload_pass.cpp | 4 +- src/mbgl/mtl/vertex_attribute.cpp | 8 +- .../renderer/layers/circle_layer_tweaker.cpp | 1 - .../layers/collision_layer_tweaker.hpp | 1 - .../layers/fill_extrusion_layer_tweaker.hpp | 1 - .../renderer/layers/fill_layer_tweaker.hpp | 1 - .../renderer/layers/heatmap_layer_tweaker.cpp | 1 - .../layers/heatmap_texture_layer_tweaker.cpp | 1 - .../layers/hillshade_layer_tweaker.cpp | 1 - .../hillshade_prepare_layer_tweaker.cpp | 1 - .../renderer/layers/raster_layer_tweaker.cpp | 1 - .../layers/render_background_layer.cpp | 2 + .../renderer/layers/render_circle_layer.cpp | 15 +- .../layers/render_fill_extrusion_layer.cpp | 18 +- .../renderer/layers/render_fill_layer.cpp | 30 +-- .../renderer/layers/render_heatmap_layer.cpp | 16 +- .../layers/render_hillshade_layer.cpp | 11 +- .../renderer/layers/render_line_layer.cpp | 110 ++++----- .../renderer/layers/render_raster_layer.cpp | 10 +- .../renderer/layers/render_symbol_layer.cpp | 57 ++--- .../renderer/layers/symbol_layer_tweaker.hpp | 1 - .../renderer/sources/render_tile_source.cpp | 23 +- src/mbgl/shaders/gl/shader_info.cpp | 212 ++++++++++++++++-- src/mbgl/shaders/gl/shader_program_gl.cpp | 9 +- src/mbgl/shaders/mtl/background.cpp | 2 +- src/mbgl/shaders/mtl/background_pattern.cpp | 2 +- src/mbgl/shaders/mtl/circle.cpp | 16 +- src/mbgl/shaders/mtl/clipping_mask.cpp | 4 +- src/mbgl/shaders/mtl/collision_box.cpp | 10 +- src/mbgl/shaders/mtl/collision_circle.cpp | 8 +- src/mbgl/shaders/mtl/custom_symbol_icon.cpp | 10 +- src/mbgl/shaders/mtl/debug.cpp | 2 +- src/mbgl/shaders/mtl/fill.cpp | 28 +-- src/mbgl/shaders/mtl/fill_extrusion.cpp | 10 +- .../shaders/mtl/fill_extrusion_pattern.cpp | 12 +- src/mbgl/shaders/mtl/heatmap.cpp | 6 +- src/mbgl/shaders/mtl/heatmap_texture.cpp | 2 +- src/mbgl/shaders/mtl/hillshade.cpp | 4 +- src/mbgl/shaders/mtl/hillshade_prepare.cpp | 4 +- src/mbgl/shaders/mtl/line.cpp | 56 ++--- src/mbgl/shaders/mtl/line_gradient.cpp | 14 +- src/mbgl/shaders/mtl/raster.cpp | 4 +- src/mbgl/shaders/mtl/shader_program.cpp | 14 +- src/mbgl/shaders/mtl/symbol_icon.cpp | 12 +- src/mbgl/shaders/mtl/symbol_sdf.cpp | 20 +- src/mbgl/shaders/mtl/symbol_text_and_icon.cpp | 18 +- .../style/layers/custom_drawable_layer.cpp | 41 ++-- src/mbgl/style/paint_property.hpp | 12 - test/util/hash.test.cpp | 6 +- 77 files changed, 781 insertions(+), 575 deletions(-) diff --git a/include/mbgl/gfx/drawable_atlases_tweaker.hpp b/include/mbgl/gfx/drawable_atlases_tweaker.hpp index 5d74eb45b..f988c697e 100644 --- a/include/mbgl/gfx/drawable_atlases_tweaker.hpp +++ b/include/mbgl/gfx/drawable_atlases_tweaker.hpp @@ -3,7 +3,6 @@ #include #include #include -#include #include #include diff --git a/include/mbgl/gfx/drawable_builder.hpp b/include/mbgl/gfx/drawable_builder.hpp index 3ec548416..5ec1f7c64 100644 --- a/include/mbgl/gfx/drawable_builder.hpp +++ b/include/mbgl/gfx/drawable_builder.hpp @@ -2,7 +2,6 @@ #include #include -#include #include #include #include @@ -137,8 +136,8 @@ public: /// Set the name given to new drawables void setDrawableName(std::string value) { drawableName = std::move(value); } - /// The attribute names for vertex/position attributes - void setVertexAttrNameId(const StringIdentity id) { vertexAttrNameId = id; } + /// The attribute id for vertex/position attribute + void setVertexAttrId(const size_t id) { vertexAttrId = id; } /// @brief Get the texture at the given internal ID. const gfx::Texture2DPtr& getTexture(size_t id) const; @@ -216,7 +215,7 @@ protected: protected: std::string name; std::string drawableName; - StringIdentity vertexAttrNameId; + std::size_t vertexAttrId; mbgl::RenderPass renderPass; bool enabled = true; bool enableColor = true; diff --git a/include/mbgl/gfx/shader_group.hpp b/include/mbgl/gfx/shader_group.hpp index a271c1b9b..89fc2cfc3 100644 --- a/include/mbgl/gfx/shader_group.hpp +++ b/include/mbgl/gfx/shader_group.hpp @@ -13,7 +13,7 @@ namespace mbgl { -using StringIdentity = std::size_t; +using StringIDSetsPair = std::pair, unordered_set>; namespace gfx { @@ -147,10 +147,9 @@ public: /// @param propertiesAsUniforms Set of data driven properties as uniforms. /// @param firstAttribName Name of the first attribute /// @return A `gfx::ShaderPtr` - virtual gfx::ShaderPtr getOrCreateShader( - gfx::Context&, - [[maybe_unused]] const mbgl::unordered_set& propertiesAsUniforms, - [[maybe_unused]] std::string_view firstAttribName = "a_pos") { + virtual gfx::ShaderPtr getOrCreateShader(gfx::Context&, + [[maybe_unused]] const StringIDSetsPair& propertiesAsUniforms, + [[maybe_unused]] std::string_view firstAttribName = "a_pos") { return {}; } @@ -162,9 +161,9 @@ protected: } /// Generate a map key for the specified combination of properties - PropertyHashType propertyHash(const mbgl::unordered_set& propertiesAsUniforms) { - const auto beg = propertiesAsUniforms.cbegin(); - const auto end = propertiesAsUniforms.cend(); + PropertyHashType propertyHash(const StringIDSetsPair& propertiesAsUniforms) { + const auto beg = propertiesAsUniforms.second.cbegin(); + const auto end = propertiesAsUniforms.second.cend(); return util::order_independent_hash(beg, end); } diff --git a/include/mbgl/gfx/vertex_attribute.hpp b/include/mbgl/gfx/vertex_attribute.hpp index dae588c77..4cb09d969 100644 --- a/include/mbgl/gfx/vertex_attribute.hpp +++ b/include/mbgl/gfx/vertex_attribute.hpp @@ -2,7 +2,6 @@ #include #include -#include #include #include @@ -33,6 +32,7 @@ class VertexAttributeArray; class VertexVectorBase; using UniqueVertexAttribute = std::unique_ptr; +using StringIDSetsPair = std::pair, unordered_set>; class VertexAttribute { public: @@ -279,15 +279,14 @@ protected: /// Stores a collection of vertex attributes by name class VertexAttributeArray { public: - using AttributeMap = mbgl::unordered_map>; - + using AttributeVector = std::array, shaders::maxVertexAttributeCountPerShader>; VertexAttributeArray() = default; VertexAttributeArray(VertexAttributeArray&&); VertexAttributeArray(const VertexAttributeArray&) = delete; // Would need to use the virtual assignment operator virtual ~VertexAttributeArray() = default; - /// Number of elements - std::size_t size() const { return attrs.size(); } + /// Number of maximum allocated elements + std::size_t allocatedSize() const { return attrs.size(); } /// Sum of element strides, and the total size of a vertex in the buffer std::size_t getTotalSize() const; @@ -295,64 +294,46 @@ public: /// Get the largest count value of the attribute elements std::size_t getMaxCount() const; - /// Add a new attribute element. - /// Returns a pointer to the new element on success, or null if the attribute already exists. - /// The result is valid only until the next non-const method call on this class. - const std::unique_ptr& get(const StringIdentity id) const; + /// Get a attribute element. + /// Returns a pointer to the element on success, or null if the attribute doesn't exists. + const std::unique_ptr& get(const size_t id) const; - /// Add a new attribute element. + /// Set a new attribute element or replace the existing one. /// Returns a pointer to the new element on success, or null if the attribute already exists. /// The result is valid only until the next non-const method call on this class. - /// @param count Number of items, zero for shared data - const std::unique_ptr& add(const StringIdentity id, - int index = -1, - AttributeDataType type = AttributeDataType::Invalid, - std::size_t count = 0); - - /// Add a new attribute element if it doesn't already exist. - /// Returns a pointer to the new element on success, or null if the type or count conflict with an existing entry. - /// The result is valid only until the next non-const method call on this class. /// @param index index to match, or -1 for any /// @param type type to match, or `Invalid` for any /// @param count Number of items, zero for shared data - const std::unique_ptr& getOrAdd(const StringIdentity id, - int index = -1, - AttributeDataType type = AttributeDataType::Invalid, - std::size_t count = 0); - - // Set a value if the element is present - template - bool set(const StringIdentity id, std::size_t i, T value) { - if (const auto& item = get(id)) { - return item->set(i, value); - } - return false; - } + const std::unique_ptr& set(const size_t id, + int index = -1, + AttributeDataType type = AttributeDataType::Invalid, + std::size_t count = 0); /// Indicates whether any values have changed virtual bool isDirty() const { - return std::any_of( - attrs.begin(), attrs.end(), [](const auto& kv) { return kv.second && kv.second->isDirty(); }); + return std::any_of(attrs.begin(), attrs.end(), [](const auto& attr) { return attr && attr->isDirty(); }); } /// Clear the collection void clear(); /// Do something with each attribute - template + template void visitAttributes(Func f) { - std::for_each(attrs.begin(), attrs.end(), [&](const auto& kv) { - if (kv.second) { - f(kv.first, *kv.second); + std::for_each(attrs.begin(), attrs.end(), [&](const auto& attr) { + if (attr) { + f(*attr); } }); } /// Call the provided delegate with each value, providing the override if one exists. - template &) */> + template &) */> void resolve(const VertexAttributeArray& overrides, Func delegate) const { - for (auto& kv : attrs) { - delegate(kv.first, *kv.second, overrides.get(kv.first)); + for (size_t id = 0; id < attrs.size(); id++) { + if (const auto& attr = attrs[id]) { + delegate(id, *attr, overrides.get(id)); + } } } @@ -368,14 +349,18 @@ public: template void readDataDrivenPaintProperties(const Binders& binders, const Evaluated& evaluated, - mbgl::unordered_set* propertiesAsUniforms) { + StringIDSetsPair* propertiesAsUniforms, + const size_t firstDataDrivenAttrId) { // Read each property in the type pack if (propertiesAsUniforms) { - propertiesAsUniforms->reserve(sizeof...(DataDrivenPaintProperty)); + propertiesAsUniforms->first.reserve(sizeof...(DataDrivenPaintProperty)); + propertiesAsUniforms->second.reserve(sizeof...(DataDrivenPaintProperty)); } + size_t dataDrivenAttrId = firstDataDrivenAttrId; (readDataDrivenPaintProperty(binders.template get(), isConstant(evaluated), - propertiesAsUniforms), + propertiesAsUniforms, + dataDrivenAttrId), ...); } @@ -388,12 +373,17 @@ public: template void readDataDrivenPaintProperties(const Binders& binders, const Evaluated& evaluated, - mbgl::unordered_set& propertiesAsUniforms) { + StringIDSetsPair& propertiesAsUniforms, + const size_t firstDataDrivenAttrId) { // Read each property in the type pack - propertiesAsUniforms.reserve(sizeof...(DataDrivenPaintProperty)); + propertiesAsUniforms.first.reserve(sizeof...(DataDrivenPaintProperty)); + propertiesAsUniforms.second.reserve(sizeof...(DataDrivenPaintProperty)); + + size_t dataDrivenAttrId = firstDataDrivenAttrId; (readDataDrivenPaintProperty(binders.template get(), isConstant(evaluated), - &propertiesAsUniforms), + &propertiesAsUniforms, + dataDrivenAttrId), ...); } @@ -407,28 +397,27 @@ protected: template void readDataDrivenPaintProperty(const Binder& binder, const bool isConstant, - mbgl::unordered_set* propertiesAsUniforms) { + StringIDSetsPair* propertiesAsUniforms, + size_t& dataDrivenAttrId) { if (!binder) { return; } // Consider each attribute name in the attribute (e.g., pattern_from, pattern_to) for (std::size_t attrIndex = 0; attrIndex < DataDrivenPaintProperty::AttributeNames.size(); ++attrIndex) { - auto& attributeNameID = DataDrivenPaintProperty::AttributeNameIDs[attrIndex]; - if (!attributeNameID) { - const auto& attributeName = DataDrivenPaintProperty::AttributeNames[attrIndex]; - attributeNameID = stringIndexer().get(attributePrefix + attributeName.data()); - } + const auto& attributeName = DataDrivenPaintProperty::AttributeNames[attrIndex]; // Apply the property, or add it to the uniforms collection if it's constant. if (!isConstant && binder->getVertexCount() > 0) { using Attribute = typename DataDrivenPaintProperty::Attribute; - const auto& attr = getOrAdd( - *attributeNameID, /*index=*/-1, /*type=*/gfx::AttributeDataType::Invalid, /*count=*/0); - applyPaintProperty(attrIndex, attr, binder); + if (const auto& attr = set(dataDrivenAttrId)) { + applyPaintProperty(attrIndex, attr, binder); + } } else if (propertiesAsUniforms) { - propertiesAsUniforms->emplace(*attributeNameID); + propertiesAsUniforms->first.emplace(attributeName); + propertiesAsUniforms->second.emplace(dataDrivenAttrId); } + dataDrivenAttrId++; } } @@ -459,8 +448,6 @@ protected: } } - const UniqueVertexAttribute& add(const StringIdentity id, std::unique_ptr&&); - virtual UniqueVertexAttribute create(int index, AttributeDataType dataType, std::size_t count) const { return std::make_unique(index, dataType, count); } @@ -470,7 +457,7 @@ protected: } protected: - AttributeMap attrs; + AttributeVector attrs; static const std::unique_ptr nullref; static const std::string attributePrefix; }; diff --git a/include/mbgl/gl/drawable_gl.hpp b/include/mbgl/gl/drawable_gl.hpp index 7da9372ba..6746939c2 100644 --- a/include/mbgl/gl/drawable_gl.hpp +++ b/include/mbgl/gl/drawable_gl.hpp @@ -5,7 +5,6 @@ #include #include #include -#include #include @@ -45,7 +44,7 @@ public: const gfx::UniformBufferArray& getUniformBuffers() const override; gfx::UniformBufferArray& mutableUniformBuffers() override; - void setVertexAttrNameId(const StringIdentity id); + void setVertexAttrId(const size_t id); void upload(gfx::UploadPass&); diff --git a/include/mbgl/mtl/drawable.hpp b/include/mbgl/mtl/drawable.hpp index 83370b782..a307b0b52 100644 --- a/include/mbgl/mtl/drawable.hpp +++ b/include/mbgl/mtl/drawable.hpp @@ -4,7 +4,6 @@ #include #include #include -#include #include @@ -45,7 +44,7 @@ public: const gfx::UniformBufferArray& getUniformBuffers() const override; gfx::UniformBufferArray& mutableUniformBuffers() override; - void setVertexAttrNameId(const StringIdentity); + void setVertexAttrId(const size_t); void upload(gfx::UploadPass&); diff --git a/include/mbgl/renderer/layer_tweaker.hpp b/include/mbgl/renderer/layer_tweaker.hpp index 347580466..ac64c2ff5 100644 --- a/include/mbgl/renderer/layer_tweaker.hpp +++ b/include/mbgl/renderer/layer_tweaker.hpp @@ -29,7 +29,6 @@ class RenderTree; class UnwrappedTileID; using mat4 = std::array; -using StringIdentity = std::size_t; /** Base class for layer tweakers, which manipulate layer group per frame diff --git a/include/mbgl/shaders/custom_drawable_layer_ubo.hpp b/include/mbgl/shaders/custom_drawable_layer_ubo.hpp index 36259ea81..8742c4bbb 100644 --- a/include/mbgl/shaders/custom_drawable_layer_ubo.hpp +++ b/include/mbgl/shaders/custom_drawable_layer_ubo.hpp @@ -27,9 +27,9 @@ struct alignas(16) CustomSymbolIconParametersUBO { static_assert(sizeof(CustomSymbolIconParametersUBO) == 3 * 16); enum { - idCustomSymbolIconDrawableUBO, - idCustomSymbolIconParametersUBO, - customDrawableUBOCount + idCustomSymbolDrawableUBO, + idCustomSymbolParametersUBO, + customSymbolUBOCount }; } // namespace shaders diff --git a/include/mbgl/shaders/gl/shader_group_gl.hpp b/include/mbgl/shaders/gl/shader_group_gl.hpp index 10677538e..15e402227 100644 --- a/include/mbgl/shaders/gl/shader_group_gl.hpp +++ b/include/mbgl/shaders/gl/shader_group_gl.hpp @@ -18,7 +18,7 @@ public: ~ShaderGroupGL() noexcept override = default; gfx::ShaderPtr getOrCreateShader(gfx::Context& context, - const mbgl::unordered_set& propertiesAsUniforms, + const StringIDSetsPair& propertiesAsUniforms, std::string_view firstAttribName) override { constexpr auto& name = shaders::ShaderSource::name; constexpr auto& vert = shaders::ShaderSource::vertex; @@ -38,11 +38,10 @@ public: // No match, we need to create the shader. std::string additionalDefines; - additionalDefines.reserve(propertiesAsUniforms.size() * 48); - for (const auto nameID : propertiesAsUniforms) { + additionalDefines.reserve(propertiesAsUniforms.first.size() * 48); + for (const auto propertyName : propertiesAsUniforms.first) { // We expect the names to be prefixed by "a_", but we need just the base here. - const auto prefixedAttrName = stringIndexer().get(nameID); - const auto* prefix = prefixedAttrName.data(); + const auto* prefix = propertyName.data(); if (prefix[0] == 'a' && prefix[1] == '_') { prefix += 2; } @@ -58,6 +57,7 @@ public: firstAttribName, shaders::ShaderInfo::uniformBlocks, shaders::ShaderInfo::textures, + shaders::ShaderInfo::attributes, vert, frag, additionalDefines); diff --git a/include/mbgl/shaders/gl/shader_info.hpp b/include/mbgl/shaders/gl/shader_info.hpp index 0ce68f3b6..e43174980 100644 --- a/include/mbgl/shaders/gl/shader_info.hpp +++ b/include/mbgl/shaders/gl/shader_info.hpp @@ -8,6 +8,12 @@ namespace mbgl { namespace shaders { +struct AttributeInfo { + AttributeInfo(std::string_view name, std::size_t id); + std::string_view name; + std::size_t id; +}; + struct UniformBlockInfo { UniformBlockInfo(std::string_view name, std::size_t id); std::string_view name; @@ -26,156 +32,182 @@ struct ShaderInfo; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; template <> struct ShaderInfo { + static const std::vector attributes; static const std::vector uniformBlocks; static const std::vector textures; }; diff --git a/include/mbgl/shaders/gl/shader_program_gl.hpp b/include/mbgl/shaders/gl/shader_program_gl.hpp index f1739f2d3..222049a17 100644 --- a/include/mbgl/shaders/gl/shader_program_gl.hpp +++ b/include/mbgl/shaders/gl/shader_program_gl.hpp @@ -35,6 +35,7 @@ public: const std::string_view firstAttribName, const std::vector& uniformBlocksInfo, const std::vector& texturesInfo, + const std::vector& attributesInfo, const std::string& vertexSource, const std::string& fragmentSource, const std::string& additionalDefines = "") noexcept(false); diff --git a/include/mbgl/shaders/mtl/clipping_mask.hpp b/include/mbgl/shaders/mtl/clipping_mask.hpp index 197f5c4f4..1ba32e282 100644 --- a/include/mbgl/shaders/mtl/clipping_mask.hpp +++ b/include/mbgl/shaders/mtl/clipping_mask.hpp @@ -1,8 +1,6 @@ #pragma once #include -#include -#include #include namespace mbgl { diff --git a/include/mbgl/shaders/mtl/shader_group.hpp b/include/mbgl/shaders/mtl/shader_group.hpp index a3b8e9904..f27abb256 100644 --- a/include/mbgl/shaders/mtl/shader_group.hpp +++ b/include/mbgl/shaders/mtl/shader_group.hpp @@ -16,19 +16,15 @@ namespace mbgl { namespace mtl { class ShaderGroupBase : public gfx::ShaderGroup { -public: - using StringIDSet = mbgl::unordered_set; - protected: ShaderGroupBase(const ProgramParameters& parameters_) : programParameters(parameters_) {} using DefinesMap = mbgl::unordered_map; - void addAdditionalDefines(const StringIDSet& propertiesAsUniforms, DefinesMap& additionalDefines) { - additionalDefines.reserve(propertiesAsUniforms.size()); - for (const auto nameID : propertiesAsUniforms) { + void addAdditionalDefines(const StringIDSetsPair& propertiesAsUniforms, DefinesMap& additionalDefines) { + additionalDefines.reserve(propertiesAsUniforms.first.size()); + for (const auto name : propertiesAsUniforms.first) { // We expect the names to be prefixed by "a_", but we need just the base here. - const auto name = stringIndexer().get(nameID); const auto* base = (name[0] == 'a' && name[1] == '_') ? &name[2] : name.data(); additionalDefines.insert(std::make_pair(std::string(uniformPrefix) + base, std::string())); } @@ -48,7 +44,7 @@ public: ~ShaderGroup() noexcept override = default; gfx::ShaderPtr getOrCreateShader(gfx::Context& gfxContext, - const mbgl::unordered_set& propertiesAsUniforms, + const StringIDSetsPair& propertiesAsUniforms, std::string_view /*firstAttribName*/) override { using ShaderSource = shaders::ShaderSource; constexpr auto& name = ShaderSource::name; @@ -78,7 +74,7 @@ public: using ShaderClass = shaders::ShaderSource; for (const auto& attrib : ShaderClass::attributes) { - if (!propertiesAsUniforms.count(attrib.nameID)) { + if (!propertiesAsUniforms.second.count(attrib.id)) { shader->initAttribute(attrib); } } diff --git a/include/mbgl/shaders/mtl/shader_program.hpp b/include/mbgl/shaders/mtl/shader_program.hpp index e11d47779..e40253f1c 100644 --- a/include/mbgl/shaders/mtl/shader_program.hpp +++ b/include/mbgl/shaders/mtl/shader_program.hpp @@ -14,11 +14,10 @@ namespace mbgl { namespace shaders { struct AttributeInfo { - AttributeInfo(std::size_t index, gfx::AttributeDataType dataType, std::string_view name); + AttributeInfo(std::size_t index, gfx::AttributeDataType dataType, std::size_t id); std::size_t index; gfx::AttributeDataType dataType; - std::string_view name; - StringIdentity nameID; + std::size_t id; }; struct UniformBlockInfo { UniformBlockInfo(std::size_t index, bool vertex, bool fragment, std::size_t size, std::size_t id); diff --git a/include/mbgl/shaders/shader_defines.hpp b/include/mbgl/shaders/shader_defines.hpp index 36e73c877..e033c0ea3 100644 --- a/include/mbgl/shaders/shader_defines.hpp +++ b/include/mbgl/shaders/shader_defines.hpp @@ -20,10 +20,17 @@ namespace mbgl { namespace shaders { +// UBO defines +enum { + idClippingMaskUBO, + clippingMaskUBOCount +}; + static constexpr auto maxUBOCountPerShader = std::max({static_cast(backgroundUBOCount), static_cast(circleUBOCount), + static_cast(clippingMaskUBOCount), static_cast(collisionUBOCount), - static_cast(customDrawableUBOCount), + static_cast(customSymbolUBOCount), static_cast(debugUBOCount), static_cast(fillUBOCount), static_cast(fillOutlineUBOCount), @@ -42,6 +49,7 @@ static constexpr auto maxUBOCountPerShader = std::max({static_cast(backg static_cast(rasterUBOCount), static_cast(symbolUBOCount)}); +// Texture defines enum { idBackgroundImageTexture, backgroundTextureCount @@ -51,13 +59,17 @@ enum { circleTextureCount }; +enum { + clippingMaskTextureCount +}; + enum { collisionTextureCount }; enum { - idCustomSymbolIconTexture, - customSymbolIconTextureCount + idCustomSymbolImageTexture, + customSymbolTextureCount }; enum { @@ -66,13 +78,13 @@ enum { }; enum { - idFillExtrusionImageTexture, - fillExtrusionTextureCount + idFillImageTexture, + fillTextureCount }; enum { - idFillImageTexture, - fillTextureCount + idFillExtrusionImageTexture, + fillExtrusionTextureCount }; enum { @@ -105,8 +117,9 @@ enum { static constexpr auto maxTextureCountPerShader = std::max({static_cast(backgroundTextureCount), static_cast(circleTextureCount), + static_cast(clippingMaskTextureCount), static_cast(collisionTextureCount), - static_cast(customSymbolIconTextureCount), + static_cast(customSymbolTextureCount), static_cast(debugTextureCount), static_cast(fillTextureCount), static_cast(fillExtrusionTextureCount), @@ -116,5 +129,150 @@ static constexpr auto maxTextureCountPerShader = std::max({static_cast(b static_cast(rasterTextureCount), static_cast(symbolTextureCount)}); +// Vertex attribute defines +enum { + idBackgroundPosVertexAttribute, + backgroundVertexAttributeCount +}; + +enum { + idCirclePosVertexAttribute, + + // Data driven + idCircleColorVertexAttribute, + idCircleRadiusVertexAttribute, + idCircleBlurVertexAttribute, + idCircleOpacityVertexAttribute, + idCircleStrokeColorVertexAttribute, + idCircleStrokeWidthVertexAttribute, + idCircleStrokeOpacityVertexAttribute, + + circleVertexAttributeCount +}; + +enum { + idClippingMaskPosVertexAttribute, + clippingMaskVertexAttributeCount +}; + +enum { + idCollisionPosVertexAttribute, + idCollisionAnchorPosVertexAttribute, + idCollisionExtrudeVertexAttribute, + idCollisionPlacedVertexAttribute, + idCollisionShiftVertexAttribute, + collisionVertexAttributeCount +}; + +enum { + idCustomSymbolPosVertexAttribute, + idCustomSymbolTexVertexAttribute, + customSymbolVertexAttributeCount +}; + +enum { + idDebugPosVertexAttribute, + debugVertexAttributeCount +}; + +enum { + idFillPosVertexAttribute, + + // Data driven + idFillColorVertexAttribute, + idFillOpacityVertexAttribute, + idFillOutlineColorVertexAttribute, + idFillPatternFromVertexAttribute, + idFillPatternToVertexAttribute, + + fillVertexAttributeCount +}; + +enum { + idFillExtrusionPosVertexAttribute, + idFillExtrusionNormalEdVertexAttribute, + + // Data driven + idFillExtrusionBaseVertexAttribute, + idFillExtrusionColorVertexAttribute, + idFillExtrusionHeightVertexAttribute, + idFillExtrusionPatternFromVertexAttribute, + idFillExtrusionPatternToVertexAttribute, + + fillExtrusionVertexAttributeCount +}; + +enum { + idHeatmapPosVertexAttribute, + + // Data driven + idHeatmapWeightVertexAttribute, + idHeatmapRadiusVertexAttribute, + + heatmapVertexAttributeCount +}; + +enum { + idHillshadePosVertexAttribute, + idHillshadeTexturePosVertexAttribute, + hillshadeVertexAttributeCount +}; + +enum { + idLinePosNormalVertexAttribute, + idLineDataVertexAttribute, + + // Data driven + idLineColorVertexAttribute, + idLineBlurVertexAttribute, + idLineOpacityVertexAttribute, + idLineGapWidthVertexAttribute, + idLineOffsetVertexAttribute, + idLineWidthVertexAttribute, + idLineFloorWidthVertexAttribute, + idLinePatternFromVertexAttribute, + idLinePatternToVertexAttribute, + + lineVertexAttributeCount +}; + +enum { + idRasterPosVertexAttribute, + idRasterTexturePosVertexAttribute, + rasterVertexAttributeCount +}; + +enum { + idSymbolPosOffsetVertexAttribute, + idSymbolDataVertexAttribute, + idSymbolPixelOffsetVertexAttribute, + idSymbolProjectedPosVertexAttribute, + idSymbolFadeOpacityVertexAttribute, + + // Data driven + idSymbolOpacityVertexAttribute, + idSymbolColorVertexAttribute, + idSymbolHaloColorVertexAttribute, + idSymbolHaloWidthVertexAttribute, + idSymbolHaloBlurVertexAttribute, + + symbolVertexAttributeCount +}; + +static constexpr auto maxVertexAttributeCountPerShader = std::max( + {static_cast(backgroundVertexAttributeCount), + static_cast(circleVertexAttributeCount), + static_cast(clippingMaskVertexAttributeCount), + static_cast(collisionVertexAttributeCount), + static_cast(customSymbolVertexAttributeCount), + static_cast(debugVertexAttributeCount), + static_cast(fillVertexAttributeCount), + static_cast(fillExtrusionVertexAttributeCount), + static_cast(heatmapVertexAttributeCount), + static_cast(hillshadeVertexAttributeCount), + static_cast(lineVertexAttributeCount), + static_cast(rasterVertexAttributeCount), + static_cast(symbolVertexAttributeCount)}); + } // namespace shaders } // namespace mbgl diff --git a/include/mbgl/shaders/shader_program_base.hpp b/include/mbgl/shaders/shader_program_base.hpp index ff7ff22dd..9bd778dfd 100644 --- a/include/mbgl/shaders/shader_program_base.hpp +++ b/include/mbgl/shaders/shader_program_base.hpp @@ -4,7 +4,6 @@ #include #include #include -#include #include #include @@ -19,7 +18,7 @@ protected: ~ShaderProgramBase() noexcept override = default; template - bool set(gfx::VertexAttributeArray& attrs, const StringIdentity id, std::size_t i, T value) { + bool set(gfx::VertexAttributeArray& attrs, const size_t id, std::size_t i, T value) { const auto& item = attrs.get(id); if (item && i < item->getCount()) { item->set(i, value); diff --git a/src/mbgl/gfx/drawable_builder.cpp b/src/mbgl/gfx/drawable_builder.cpp index 15fcc0bcf..72bff5023 100644 --- a/src/mbgl/gfx/drawable_builder.cpp +++ b/src/mbgl/gfx/drawable_builder.cpp @@ -5,7 +5,6 @@ #include #include #include -#include #include namespace mbgl { @@ -13,7 +12,7 @@ namespace gfx { DrawableBuilder::DrawableBuilder(std::string name_) : name(std::move(name_)), - vertexAttrNameId(stringIndexer().get("a_pos")), + vertexAttrId(0), renderPass(mbgl::RenderPass::Opaque), impl(std::make_unique()) {} diff --git a/src/mbgl/gfx/drawable_builder_impl.cpp b/src/mbgl/gfx/drawable_builder_impl.cpp index b1498a806..a8e88a66c 100644 --- a/src/mbgl/gfx/drawable_builder_impl.cpp +++ b/src/mbgl/gfx/drawable_builder_impl.cpp @@ -1,16 +1,18 @@ #include #include -#include -#include #include +#include #include +#include #include namespace mbgl { namespace gfx { +using namespace shaders; + DrawableBuilder::Impl::LineLayoutVertex DrawableBuilder::Impl::layoutVertex( Point p, Point e, bool round, bool up, int8_t dir, int32_t linesofar /*= 0*/) { /* @@ -61,18 +63,14 @@ void DrawableBuilder::Impl::addPolyline(gfx::DrawableBuilder& builder, void DrawableBuilder::Impl::setupForPolylines(gfx::Context& context, gfx::DrawableBuilder& builder) { // setup vertex attributes - static const StringIdentity idVertexAttribName = stringIndexer().get("a_pos_normal"); - static const StringIdentity idDataAttribName = stringIndexer().get("a_data"); - - builder.setVertexAttrNameId(idVertexAttribName); - + builder.setVertexAttrId(idLinePosNormalVertexAttribute); builder.setRawVertices({}, polylineVertices.elements(), gfx::AttributeDataType::Short2); auto attrs = context.createVertexAttributeArray(); using VertexVector = gfx::VertexVector; std::shared_ptr verts = std::make_shared(std::move(polylineVertices)); - if (const auto& attr = attrs->add(idVertexAttribName)) { + if (const auto& attr = attrs->set(idLinePosNormalVertexAttribute)) { attr->setSharedRawData(verts, offsetof(LineLayoutVertex, a1), /*vertexOffset=*/0, @@ -80,7 +78,7 @@ void DrawableBuilder::Impl::setupForPolylines(gfx::Context& context, gfx::Drawab gfx::AttributeDataType::Short2); } - if (const auto& attr = attrs->add(idDataAttribName)) { + if (const auto& attr = attrs->set(idLineDataVertexAttribute)) { attr->setSharedRawData(verts, offsetof(LineLayoutVertex, a2), /*vertexOffset=*/0, diff --git a/src/mbgl/gfx/symbol_drawable_data.hpp b/src/mbgl/gfx/symbol_drawable_data.hpp index 223106432..6688b39ec 100644 --- a/src/mbgl/gfx/symbol_drawable_data.hpp +++ b/src/mbgl/gfx/symbol_drawable_data.hpp @@ -13,9 +13,6 @@ enum class SymbolType : uint8_t; namespace gfx { struct SymbolDrawableData : public DrawableData { - constexpr static std::size_t LinearThreshold = 10; - using PropertyMapType = util::TinyUnorderedMap; - SymbolDrawableData(const bool isHalo_, const bool bucketVariablePlacement_, const style::SymbolType symbolType_, diff --git a/src/mbgl/gfx/vertex_attribute.cpp b/src/mbgl/gfx/vertex_attribute.cpp index 111e3e0b4..c69b4135f 100644 --- a/src/mbgl/gfx/vertex_attribute.cpp +++ b/src/mbgl/gfx/vertex_attribute.cpp @@ -93,65 +93,37 @@ VertexAttributeArray& VertexAttributeArray::operator=(VertexAttributeArray&& oth return *this; } -const std::unique_ptr& VertexAttributeArray::get(const StringIdentity id) const { - const auto result = attrs.find(id); - return (result != attrs.end()) ? result->second : nullref; +const std::unique_ptr& VertexAttributeArray::get(const size_t id) const { + return (id < attrs.size()) ? attrs[id] : nullref; } -const std::unique_ptr& VertexAttributeArray::add(const StringIdentity id, +const std::unique_ptr& VertexAttributeArray::set(const size_t id, int index, AttributeDataType dataType, std::size_t count) { - const auto result = attrs.insert(std::make_pair(id, std::unique_ptr())); - if (result.second) { - result.first->second = create(index, dataType, count); - return result.first->second; - } else { + assert(id < attrs.size()); + if (id >= attrs.size()) { return nullref; } -} - -const std::unique_ptr& VertexAttributeArray::getOrAdd(const StringIdentity id, - int index, - AttributeDataType dataType, - std::size_t count) { - const auto result = attrs.insert(std::make_pair(id, std::unique_ptr())); - auto& attr = result.first->second; - if (result.second) { - // inserted - attr = create(index, dataType, count); - } else { - // already present - assert(dataType == AttributeDataType::Invalid || attr->getDataType() == dataType); - assert((index < 0 || attr->getIndex() == index) && (count == 0 || attr->getCount() == count)); - } - return attr; + attrs[id] = create(index, dataType, count); + return attrs[id]; } std::size_t VertexAttributeArray::getTotalSize() const { - return std::accumulate(attrs.begin(), attrs.end(), std::size_t(0), [](const auto acc, const auto& kv) { - return acc + kv.second->getStride(); + return std::accumulate(attrs.begin(), attrs.end(), std::size_t(0), [](const auto acc, const auto& attr) { + return acc + (attr ? attr->getStride() : 0); }); } std::size_t VertexAttributeArray::getMaxCount() const { - return std::accumulate(attrs.begin(), attrs.end(), std::size_t(0), [](const auto acc, const auto& kv) { - return std::max(acc, kv.second->getCount()); + return std::accumulate(attrs.begin(), attrs.end(), std::size_t(0), [](const auto acc, const auto& attr) { + return std::max(acc, (attr ? attr->getCount() : 0)); }); } void VertexAttributeArray::clear() { - attrs.clear(); -} - -const UniqueVertexAttribute& VertexAttributeArray::add(const StringIdentity id, - std::unique_ptr&& attr) { - const auto result = attrs.insert(std::make_pair(id, std::unique_ptr())); - if (result.second) { - result.first->second = std::move(attr); - return result.first->second; - } else { - return nullref; + for (auto& attr : attrs) { + attr = nullptr; } } diff --git a/src/mbgl/gl/drawable_gl.cpp b/src/mbgl/gl/drawable_gl.cpp index 5b3ce61d4..f90d35326 100644 --- a/src/mbgl/gl/drawable_gl.cpp +++ b/src/mbgl/gl/drawable_gl.cpp @@ -8,7 +8,6 @@ #include #include #include -#include namespace mbgl { namespace gl { @@ -98,8 +97,8 @@ gfx::UniformBufferArray& DrawableGL::mutableUniformBuffers() { return impl->uniformBuffers; } -void DrawableGL::setVertexAttrNameId(const StringIdentity id) { - impl->idVertexAttrName = id; +void DrawableGL::setVertexAttrId(const size_t id) { + impl->vertexAttrId = id; } void DrawableGL::bindUniformBuffers() const { @@ -169,7 +168,7 @@ void DrawableGL::upload(gfx::UploadPass& uploadPass) { const auto& defaults = shader->getVertexAttributes(); const auto& overrides = *vertexAttributes; - const auto& indexAttribute = defaults.get(impl->idVertexAttrName); + const auto& indexAttribute = defaults.get(impl->vertexAttrId); const auto vertexAttributeIndex = static_cast(indexAttribute ? indexAttribute->getIndex() : -1); std::vector> vertexBuffers; diff --git a/src/mbgl/gl/drawable_gl_builder.cpp b/src/mbgl/gl/drawable_gl_builder.cpp index 1b43506c9..78547195c 100644 --- a/src/mbgl/gl/drawable_gl_builder.cpp +++ b/src/mbgl/gl/drawable_gl_builder.cpp @@ -23,7 +23,7 @@ std::unique_ptr DrawableGLBuilder::createSegment(gfx void DrawableGLBuilder::init() { auto& drawableGL = static_cast(*currentDrawable); - drawableGL.setVertexAttrNameId(vertexAttrNameId); + drawableGL.setVertexAttrId(vertexAttrId); if (impl->rawVerticesCount) { auto raw = impl->rawVertices; diff --git a/src/mbgl/gl/drawable_gl_impl.hpp b/src/mbgl/gl/drawable_gl_impl.hpp index f92e82be2..d72aea8a0 100644 --- a/src/mbgl/gl/drawable_gl_impl.hpp +++ b/src/mbgl/gl/drawable_gl_impl.hpp @@ -13,7 +13,6 @@ #include #include #include -#include #include #include @@ -49,7 +48,7 @@ public: gfx::CullFaceMode cullFaceMode; GLfloat pointSize = 0.0f; - StringIdentity idVertexAttrName = stringIndexer().get("a_pos"); + size_t vertexAttrId = 0; }; struct DrawableGL::DrawSegmentGL final : public gfx::Drawable::DrawSegment { diff --git a/src/mbgl/gl/upload_pass.cpp b/src/mbgl/gl/upload_pass.cpp index 0a7cb2a36..e0b71b6b9 100644 --- a/src/mbgl/gl/upload_pass.cpp +++ b/src/mbgl/gl/upload_pass.cpp @@ -192,7 +192,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings( const gfx::BufferUsageType usage, /*out*/ std::vector>& outBuffers) { AttributeBindingArray bindings; - bindings.resize(defaults.size()); + bindings.resize(defaults.allocatedSize()); constexpr std::size_t align = 16; constexpr std::uint8_t padding = 0; @@ -216,7 +216,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings( } // For each attribute in the program, with the corresponding default and optional override... - const auto resolveAttr = [&](const StringIdentity id, auto& defaultAttr, auto& overrideAttr) -> void { + const auto resolveAttr = [&](const size_t id, auto& defaultAttr, auto& overrideAttr) -> void { auto& effectiveAttr = overrideAttr ? *overrideAttr : defaultAttr; const auto& defaultGL = static_cast(defaultAttr); const auto stride = defaultAttr.getStride(); @@ -262,7 +262,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings( // something else, the binding is invalid // TODO: throw? Log::Warning(Event::General, - "Got " + util::toString(rawData.size()) + " bytes for attribute '" + stringIndexer().get(id) + + "Got " + util::toString(rawData.size()) + " bytes for attribute '" + util::toString(id) + "' (" + util::toString(defaultGL.getIndex()) + "), expected " + util::toString(stride) + " or " + util::toString(stride * vertexCount)); return; diff --git a/src/mbgl/gl/vertex_attribute_gl.cpp b/src/mbgl/gl/vertex_attribute_gl.cpp index 2f859fea3..386831a2e 100644 --- a/src/mbgl/gl/vertex_attribute_gl.cpp +++ b/src/mbgl/gl/vertex_attribute_gl.cpp @@ -183,15 +183,15 @@ const std::vector& VertexAttributeGL::getRaw(gfx::VertexAttribute& } bool VertexAttributeArrayGL::isDirty() const { - return std::any_of(attrs.begin(), attrs.end(), [](const auto& kv) { - if (kv.second) { + return std::any_of(attrs.begin(), attrs.end(), [](const auto& attr) { + if (attr) { // If we have shared data, the dirty flag from that overrides ours - const auto& glAttrib = static_cast(*kv.second); + const auto& glAttrib = static_cast(*attr); if (const auto& shared = glAttrib.getSharedRawData()) { return shared->getDirty(); } } - return kv.second && kv.second->isDirty(); + return attr && attr->isDirty(); }); } diff --git a/src/mbgl/mtl/drawable.cpp b/src/mbgl/mtl/drawable.cpp index e3380b472..6e5a85a3a 100644 --- a/src/mbgl/mtl/drawable.cpp +++ b/src/mbgl/mtl/drawable.cpp @@ -317,14 +317,13 @@ void Drawable::setVertices(std::vector&& data, std::size_t count, gfx:: if (!vertexAttributes) { vertexAttributes = std::make_shared(); } - if (auto& attrib = vertexAttributes->getOrAdd(impl->idVertexAttrName, /*index=*/-1, type)) { + if (auto& attrib = vertexAttributes->set(impl->vertexAttrId, /*index=*/-1, type)) { attrib->setRawData(std::move(data)); attrib->setStride(VertexAttribute::getStrideOf(type)); } else { using namespace std::string_literals; - Log::Warning( - Event::General, - "Vertex attribute type mismatch: "s + name + " / " + stringIndexer().get(impl->idVertexAttrName)); + Log::Warning(Event::General, + "Vertex attribute type mismatch: "s + name + " / " + util::toString(impl->vertexAttrId)); assert(false); } } @@ -338,8 +337,8 @@ gfx::UniformBufferArray& Drawable::mutableUniformBuffers() { return impl->uniformBuffers; } -void Drawable::setVertexAttrNameId(const StringIdentity value) { - impl->idVertexAttrName = value; +void Drawable::setVertexAttrId(const size_t id) { + impl->vertexAttrId = id; } void Drawable::bindAttributes(RenderPass& renderPass) const noexcept { @@ -540,7 +539,7 @@ void Drawable::upload(gfx::UploadPass& uploadPass_) { vertexBuffers); impl->attributeBuffers = std::move(vertexBuffers); - vertexAttributes->visitAttributes([](const auto&, gfx::VertexAttribute& attrib) { attrib.setDirty(false); }); + vertexAttributes->visitAttributes([](gfx::VertexAttribute& attrib) { attrib.setDirty(false); }); if (impl->attributeBindings != attributeBindings_) { impl->attributeBindings = std::move(attributeBindings_); diff --git a/src/mbgl/mtl/drawable_builder.cpp b/src/mbgl/mtl/drawable_builder.cpp index 632c6063d..f10186361 100644 --- a/src/mbgl/mtl/drawable_builder.cpp +++ b/src/mbgl/mtl/drawable_builder.cpp @@ -22,7 +22,7 @@ std::unique_ptr DrawableBuilder::createSegment(gfx:: void DrawableBuilder::init() { auto& drawable = static_cast(*currentDrawable); - drawable.setVertexAttrNameId(vertexAttrNameId); + drawable.setVertexAttrId(vertexAttrId); if (impl->rawVerticesCount) { auto raw = impl->rawVertices; diff --git a/src/mbgl/mtl/drawable_impl.hpp b/src/mbgl/mtl/drawable_impl.hpp index 88768b6f0..b9d826e92 100644 --- a/src/mbgl/mtl/drawable_impl.hpp +++ b/src/mbgl/mtl/drawable_impl.hpp @@ -15,7 +15,6 @@ #include #include #include -#include #include #include @@ -53,7 +52,7 @@ public: gfx::StencilMode stencilMode; gfx::CullFaceMode cullFaceMode; // GLfloat pointSize = 0.0f; - StringIdentity idVertexAttrName = stringIndexer().get("a_pos"); + std::size_t vertexAttrId = 0; VertexBufferResource* noBindingBuffer = nullptr; diff --git a/src/mbgl/mtl/upload_pass.cpp b/src/mbgl/mtl/upload_pass.cpp index b8e6ab7ca..1c6d4b829 100644 --- a/src/mbgl/mtl/upload_pass.cpp +++ b/src/mbgl/mtl/upload_pass.cpp @@ -158,7 +158,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings( const gfx::BufferUsageType usage, /*out*/ std::vector>& outBuffers) { gfx::AttributeBindingArray bindings; - bindings.resize(defaults.size()); + bindings.resize(defaults.allocatedSize()); constexpr std::size_t align = 16; constexpr std::uint8_t padding = 0; @@ -169,7 +169,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings( uint32_t vertexStride = 0; // For each attribute in the program, with the corresponding default and optional override... - const auto resolveAttr = [&](const StringIdentity id, auto& default_, auto& override_) -> void { + const auto resolveAttr = [&](const size_t id, auto& default_, auto& override_) -> void { auto& effectiveAttr = override_ ? *override_ : default_; const auto& defaultAttr = static_cast(default_); const auto stride = defaultAttr.getStride(); diff --git a/src/mbgl/mtl/vertex_attribute.cpp b/src/mbgl/mtl/vertex_attribute.cpp index b7647fccd..d30feea4b 100644 --- a/src/mbgl/mtl/vertex_attribute.cpp +++ b/src/mbgl/mtl/vertex_attribute.cpp @@ -34,15 +34,15 @@ const gfx::UniqueVertexBufferResource& VertexAttribute::getBuffer(gfx::VertexAtt } bool VertexAttributeArray::isDirty() const { - return std::any_of(attrs.begin(), attrs.end(), [](const auto& kv) { - if (kv.second) { + return std::any_of(attrs.begin(), attrs.end(), [](const auto& attr) { + if (attr) { // If we have shared data, the dirty flag from that overrides ours - const auto& attrib = static_cast(*kv.second); + const auto& attrib = static_cast(*attr); if (const auto& shared = attrib.getSharedRawData()) { return shared->getDirty(); } } - return kv.second && kv.second->isDirty(); + return attr && attr->isDirty(); }); } diff --git a/src/mbgl/renderer/layers/circle_layer_tweaker.cpp b/src/mbgl/renderer/layers/circle_layer_tweaker.cpp index 0af7eefd8..712b5fa82 100644 --- a/src/mbgl/renderer/layers/circle_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/circle_layer_tweaker.cpp @@ -9,7 +9,6 @@ #include #include #include -#include #if MLN_RENDER_BACKEND_METAL #include diff --git a/src/mbgl/renderer/layers/collision_layer_tweaker.hpp b/src/mbgl/renderer/layers/collision_layer_tweaker.hpp index 34ade8bf9..f3cc3305e 100644 --- a/src/mbgl/renderer/layers/collision_layer_tweaker.hpp +++ b/src/mbgl/renderer/layers/collision_layer_tweaker.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include diff --git a/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.hpp b/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.hpp index d6fffe219..6ada99854 100644 --- a/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.hpp +++ b/src/mbgl/renderer/layers/fill_extrusion_layer_tweaker.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include diff --git a/src/mbgl/renderer/layers/fill_layer_tweaker.hpp b/src/mbgl/renderer/layers/fill_layer_tweaker.hpp index 272a7cf40..a75279e0a 100644 --- a/src/mbgl/renderer/layers/fill_layer_tweaker.hpp +++ b/src/mbgl/renderer/layers/fill_layer_tweaker.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include diff --git a/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp b/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp index 983aaab73..2c3c925da 100644 --- a/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/heatmap_layer_tweaker.cpp @@ -9,7 +9,6 @@ #include #include #include -#include #if MLN_RENDER_BACKEND_METAL #include diff --git a/src/mbgl/renderer/layers/heatmap_texture_layer_tweaker.cpp b/src/mbgl/renderer/layers/heatmap_texture_layer_tweaker.cpp index 436e871be..f12002f56 100644 --- a/src/mbgl/renderer/layers/heatmap_texture_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/heatmap_texture_layer_tweaker.cpp @@ -9,7 +9,6 @@ #include #include #include -#include namespace mbgl { diff --git a/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp b/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp index ebffbb062..bc0b1557c 100644 --- a/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/hillshade_layer_tweaker.cpp @@ -8,7 +8,6 @@ #include #include #include -#include namespace mbgl { diff --git a/src/mbgl/renderer/layers/hillshade_prepare_layer_tweaker.cpp b/src/mbgl/renderer/layers/hillshade_prepare_layer_tweaker.cpp index 6ba4d4664..fea60775d 100644 --- a/src/mbgl/renderer/layers/hillshade_prepare_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/hillshade_prepare_layer_tweaker.cpp @@ -9,7 +9,6 @@ #include #include #include -#include namespace mbgl { diff --git a/src/mbgl/renderer/layers/raster_layer_tweaker.cpp b/src/mbgl/renderer/layers/raster_layer_tweaker.cpp index de19f3914..bd0e3c7f7 100644 --- a/src/mbgl/renderer/layers/raster_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/raster_layer_tweaker.cpp @@ -10,7 +10,6 @@ #include #include #include -#include namespace mbgl { diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp index 661a9e186..9a83beabc 100644 --- a/src/mbgl/renderer/layers/render_background_layer.cpp +++ b/src/mbgl/renderer/layers/render_background_layer.cpp @@ -29,6 +29,7 @@ namespace mbgl { using namespace style; +using namespace shaders; namespace { @@ -308,6 +309,7 @@ void RenderBackgroundLayer::update(gfx::ShaderRegistry& shaders, } auto verticesCopy = rawVertices; + builder->setVertexAttrId(idBackgroundPosVertexAttribute); builder->setRawVertices(std::move(verticesCopy), vertexCount, gfx::AttributeDataType::Short2); builder->setSegments(gfx::Triangles(), indexes.vector(), segs.data(), segs.size()); builder->flush(context); diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp index fe10a003d..469e2d5a5 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.cpp +++ b/src/mbgl/renderer/layers/render_circle_layer.cpp @@ -22,7 +22,6 @@ #include #include #include -#include #endif namespace mbgl { @@ -264,7 +263,6 @@ bool RenderCircleLayer::queryIntersectsFeature(const GeometryCoordinates& queryG namespace { constexpr auto CircleShaderGroupName = "CircleShader"; -const StringIdentity idVertexAttribName = stringIndexer().get("a_pos"); } // namespace @@ -314,7 +312,7 @@ void RenderCircleLayer::update(gfx::ShaderRegistry& shaders, [&](gfx::Drawable& drawable) { return drawable.getTileID() && !hasRenderTile(*drawable.getTileID()); }); const auto& evaluated = static_cast(*evaluatedProperties).evaluated; - mbgl::unordered_set propertiesAsUniforms; + StringIDSetsPair propertiesAsUniforms; for (const RenderTile& tile : *renderTiles) { const auto& tileID = tile.getOverscaledTileID(); @@ -367,7 +365,9 @@ void RenderCircleLayer::update(gfx::ShaderRegistry& shaders, const auto interpBuffer = context.createUniformBuffer(&interpolateUBO, sizeof(interpolateUBO)); - propertiesAsUniforms.clear(); + propertiesAsUniforms.first.clear(); + propertiesAsUniforms.second.clear(); + auto circleVertexAttrs = context.createVertexAttributeArray(); circleVertexAttrs->readDataDrivenPaintProperties( - paintPropertyBinders, evaluated, propertiesAsUniforms); + paintPropertyBinders, evaluated, propertiesAsUniforms, idCircleColorVertexAttribute); - if (!circleShaderGroup) { - continue; - } const auto circleShader = circleShaderGroup->getOrCreateShader(context, propertiesAsUniforms); if (!circleShader) { continue; } - if (const auto& attr = circleVertexAttrs->add(idVertexAttribName)) { + if (const auto& attr = circleVertexAttrs->set(idCirclePosVertexAttribute)) { attr->setSharedRawData(bucket.sharedVertices, offsetof(CircleLayoutVertex, a1), 0, diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp index 84db4916c..39325bfd2 100644 --- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp @@ -38,12 +38,6 @@ using namespace shaders; namespace { -#if MLN_DRAWABLE_RENDERER -const StringIdentity idPosAttribName = stringIndexer().get("a_pos"); -const StringIdentity idNormAttribName = stringIndexer().get("a_normal_ed"); - -#endif // MLN_DRAWABLE_RENDERER - inline const FillExtrusionLayer::Impl& impl_cast(const Immutable& impl) { assert(impl->getTypeInfo() == FillExtrusionLayer::Impl::staticTypeInfo()); return static_cast(*impl); @@ -338,7 +332,7 @@ void RenderFillExtrusionLayer::update(gfx::ShaderRegistry& shaders, tileLayerGroup->setStencilTiles(renderTiles); - mbgl::unordered_set propertiesAsUniforms; + StringIDSetsPair propertiesAsUniforms; for (const RenderTile& tile : *renderTiles) { const auto& tileID = tile.getOverscaledTileID(); @@ -408,13 +402,15 @@ void RenderFillExtrusionLayer::update(gfx::ShaderRegistry& shaders, continue; } - propertiesAsUniforms.clear(); + propertiesAsUniforms.first.clear(); + propertiesAsUniforms.second.clear(); auto vertexAttrs = context.createVertexAttributeArray(); vertexAttrs->readDataDrivenPaintProperties(binders, evaluated, propertiesAsUniforms); + FillExtrusionPattern>( + binders, evaluated, propertiesAsUniforms, idFillExtrusionBaseVertexAttribute); const auto shader = std::static_pointer_cast( shaderGroup->getOrCreateShader(context, propertiesAsUniforms)); @@ -473,14 +469,14 @@ void RenderFillExtrusionLayer::update(gfx::ShaderRegistry& shaders, } } - if (const auto& attr = vertexAttrs->add(idPosAttribName)) { + if (const auto& attr = vertexAttrs->set(idFillExtrusionPosVertexAttribute)) { attr->setSharedRawData(bucket.sharedVertices, offsetof(FillExtrusionLayoutVertex, a1), /*vertexOffset=*/0, sizeof(FillExtrusionLayoutVertex), gfx::AttributeDataType::Short2); } - if (const auto& attr = vertexAttrs->add(idNormAttribName)) { + if (const auto& attr = vertexAttrs->set(idFillExtrusionNormalEdVertexAttribute)) { attr->setSharedRawData(bucket.sharedVertices, offsetof(FillExtrusionLayoutVertex, a2), /*vertexOffset=*/0, diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index 361d183ab..d921ddb6f 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #include #endif @@ -49,8 +48,6 @@ constexpr auto FillOutlineTriangulatedShaderName = "LineBasicShader"; constexpr auto FillOutlineShaderName = "FillOutlineShader"; constexpr auto FillPatternShaderName = "FillPatternShader"; constexpr auto FillOutlinePatternShaderName = "FillOutlinePatternShader"; - -const StringIdentity idPosAttribName = stringIndexer().get("a_pos"); #endif // MLN_DRAWABLE_RENDERER inline const FillLayer::Impl& impl_cast(const Immutable& impl) { @@ -479,7 +476,7 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders, fillTileLayerGroup->setStencilTiles(renderTiles); - mbgl::unordered_set propertiesAsUniforms; + StringIDSetsPair propertiesAsUniforms; for (const RenderTile& tile : *renderTiles) { const auto& tileID = tile.getOverscaledTileID(); @@ -608,15 +605,16 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders, return atlasTweaker; }; - propertiesAsUniforms.clear(); + propertiesAsUniforms.first.clear(); + propertiesAsUniforms.second.clear(); // `Fill*Program` all use `style::FillPaintProperties` auto vertexAttrs = context.createVertexAttributeArray(); vertexAttrs->readDataDrivenPaintProperties( - binders, evaluated, propertiesAsUniforms); + binders, evaluated, propertiesAsUniforms, idFillColorVertexAttribute); const auto vertexCount = bucket.vertices.elements(); - if (const auto& attr = vertexAttrs->add(idPosAttribName)) { + if (const auto& attr = vertexAttrs->set(idFillPosVertexAttribute)) { attr->setSharedRawData(bucket.sharedVertices, offsetof(FillLayoutVertex, a1), /*vertexOffset=*/0, @@ -682,11 +680,9 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders, #if MLN_TRIANGULATE_FILL_OUTLINES const auto outlineTriangulatedShader = doOutline && !dataDrivenOutline ? [&]() -> auto { - static const mbgl::unordered_set outlinePropertiesAsUniforms{ - stringIndexer().get("a_color"), - stringIndexer().get("a_opacity"), - stringIndexer().get("a_width"), - }; + static const StringIDSetsPair outlinePropertiesAsUniforms{ + {"a_color", "a_opacity", "a_width"}, + {idLineColorVertexAttribute, idLineOpacityVertexAttribute, idLineWidthVertexAttribute}}; return std::static_pointer_cast( outlineTriangulatedShaderGroup->getOrCreateShader(context, outlinePropertiesAsUniforms)); }() @@ -694,21 +690,18 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders, auto createOutline = [&](auto& builder, Color color, float opacity) { if (doOutline && builder && bucket.sharedLineIndexes->elements()) { - static const StringIdentity idVertexAttribName = stringIndexer().get("a_pos_normal"); - static const StringIdentity idDataAttribName = stringIndexer().get("a_data"); - builder->setVertexAttrNameId(idVertexAttribName); builder->setShader(outlineTriangulatedShader); builder->setRawVertices({}, bucket.lineVertices.elements(), gfx::AttributeDataType::Short2); auto attrs = context.createVertexAttributeArray(); - if (const auto& attr = attrs->add(idVertexAttribName)) { + if (const auto& attr = attrs->set(idLinePosNormalVertexAttribute)) { attr->setSharedRawData(bucket.sharedLineVertices, offsetof(LineLayoutVertex, a1), /*vertexOffset=*/0, sizeof(LineLayoutVertex), gfx::AttributeDataType::Short2); } - if (const auto& attr = attrs->add(idDataAttribName)) { + if (const auto& attr = attrs->set(idLineDataVertexAttribute)) { attr->setSharedRawData(bucket.sharedLineVertices, offsetof(LineLayoutVertex, a2), /*vertexOffset=*/0, @@ -770,7 +763,6 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders, const size_t interpolateUBOId, const auto& interpolateUBO, FillVariant type) { - builder.setVertexAttrNameId(idPosAttribName); builder.flush(context); for (auto& drawable : builder.clearDrawables()) { @@ -897,7 +889,7 @@ void RenderFillLayer::update(gfx::ShaderRegistry& shaders, } const auto finish = [&](gfx::DrawableBuilder& builder, - const StringIdentity interpolateNameId, + const size_t interpolateNameId, const auto& interpolateUBO, const size_t tileUBOId, const auto& tileUBO, diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp index 9b7ecabc0..429e93436 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp @@ -24,7 +24,6 @@ #include #include #include -#include #endif namespace mbgl { @@ -278,8 +277,6 @@ namespace { constexpr auto HeatmapShaderGroupName = "HeatmapShader"; constexpr auto HeatmapTextureShaderGroupName = "HeatmapTextureShader"; -const StringIdentity idVertexAttribName = stringIndexer().get("a_pos"); - } // namespace using namespace shaders; @@ -345,9 +342,9 @@ void RenderHeatmapLayer::update(gfx::ShaderRegistry& shaders, [&](gfx::Drawable& drawable) { return drawable.getTileID() && !hasRenderTile(*drawable.getTileID()); }); const auto& evaluated = static_cast(*evaluatedProperties).evaluated; - std::optional> propertiesAsUniforms; + std::optional propertiesAsUniforms; #if !defined(NDEBUG) - std::optional> previousPropertiesAsUniforms; + std::optional previousPropertiesAsUniforms; #endif gfx::ShaderPtr heatmapShader; @@ -411,13 +408,14 @@ void RenderHeatmapLayer::update(gfx::ShaderRegistry& shaders, } #if !defined(NDEBUG) else { - propertiesAsUniforms->clear(); + propertiesAsUniforms->first.clear(); + propertiesAsUniforms->second.clear(); } #endif auto heatmapVertexAttrs = context.createVertexAttributeArray(); heatmapVertexAttrs->readDataDrivenPaintProperties( - paintPropertyBinders, evaluated, *propertiesAsUniforms); + paintPropertyBinders, evaluated, *propertiesAsUniforms, idHeatmapWeightVertexAttribute); #if !defined(NDEBUG) // We assume the properties are the same across tiles. @@ -435,7 +433,7 @@ void RenderHeatmapLayer::update(gfx::ShaderRegistry& shaders, } } - if (const auto& attr = heatmapVertexAttrs->add(idVertexAttribName)) { + if (const auto& attr = heatmapVertexAttrs->set(idHeatmapPosVertexAttribute)) { attr->setSharedRawData(bucket.sharedVertices, offsetof(HeatmapLayoutVertex, a1), /*vertexOffset=*/0, @@ -505,7 +503,7 @@ void RenderHeatmapLayer::update(gfx::ShaderRegistry& shaders, const auto textureVertexCount = sharedTextureVertices->elements(); auto textureVertexAttrs = context.createVertexAttributeArray(); - if (const auto& attr = textureVertexAttrs->add(idVertexAttribName)) { + if (const auto& attr = textureVertexAttrs->set(idHeatmapPosVertexAttribute)) { attr->setSharedRawData(sharedTextureVertices, offsetof(HeatmapLayoutVertex, a1), /*vertexOffset=*/0, diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp index f98e3f4ac..b5635cb5a 100644 --- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp +++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp @@ -295,9 +295,6 @@ void RenderHillshadeLayer::removeRenderTargets(UniqueChangeRequestVec& changes) static const std::string HillshadePrepareShaderGroupName = "HillshadePrepareShader"; static const std::string HillshadeShaderGroupName = "HillshadeShader"; -static const StringIdentity idPosAttribName = stringIndexer().get("a_pos"); -static const StringIdentity idTexturePosAttribName = stringIndexer().get("a_texture_pos"); - void RenderHillshadeLayer::update(gfx::ShaderRegistry& shaders, gfx::Context& context, [[maybe_unused]] const TransformState& state, @@ -358,14 +355,14 @@ void RenderHillshadeLayer::update(gfx::ShaderRegistry& shaders, if (!hillshadePrepareVertexAttrs) { hillshadePrepareVertexAttrs = context.createVertexAttributeArray(); - if (const auto& attr = hillshadePrepareVertexAttrs->add(idPosAttribName)) { + if (const auto& attr = hillshadePrepareVertexAttrs->set(idHillshadePosVertexAttribute)) { attr->setSharedRawData(staticDataSharedVertices, offsetof(HillshadeLayoutVertex, a1), 0, sizeof(HillshadeLayoutVertex), gfx::AttributeDataType::Short2); } - if (const auto& attr = hillshadePrepareVertexAttrs->add(idTexturePosAttribName)) { + if (const auto& attr = hillshadePrepareVertexAttrs->set(idHillshadeTexturePosVertexAttribute)) { attr->setSharedRawData(staticDataSharedVertices, offsetof(HillshadeLayoutVertex, a2), 0, @@ -465,14 +462,14 @@ void RenderHillshadeLayer::update(gfx::ShaderRegistry& shaders, if (!hillshadeVertexAttrs) { hillshadeVertexAttrs = context.createVertexAttributeArray(); - if (const auto& attr = hillshadeVertexAttrs->add(idPosAttribName)) { + if (const auto& attr = hillshadeVertexAttrs->set(idHillshadePosVertexAttribute)) { attr->setSharedRawData(vertices, offsetof(HillshadeLayoutVertex, a1), 0, sizeof(HillshadeLayoutVertex), gfx::AttributeDataType::Short2); } - if (const auto& attr = hillshadeVertexAttrs->getOrAdd(idTexturePosAttribName)) { + if (const auto& attr = hillshadeVertexAttrs->set(idHillshadeTexturePosVertexAttribute)) { attr->setSharedRawData(vertices, offsetof(HillshadeLayoutVertex, a2), 0, diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp index 918a4782f..d31051d74 100644 --- a/src/mbgl/renderer/layers/render_line_layer.cpp +++ b/src/mbgl/renderer/layers/render_line_layer.cpp @@ -30,7 +30,6 @@ #include #include #include -#include #endif namespace mbgl { @@ -47,8 +46,7 @@ inline const LineLayer::Impl& impl_cast(const Immutable& imp #if MLN_DRAWABLE_RENDERER -const StringIdentity idVertexAttribName = stringIndexer().get("a_pos_normal"); -const StringIdentity idDataAttribName = stringIndexer().get("a_data"); +const auto posNormalAttribName = "a_pos_normal"; #endif // MLN_DRAWABLE_RENDERER @@ -371,19 +369,6 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, layerGroup->addLayerTweaker(layerTweaker); } - if (!lineShaderGroup) { - lineShaderGroup = shaders.getShaderGroup("LineShader"); - } - if (!lineGradientShaderGroup) { - lineGradientShaderGroup = shaders.getShaderGroup("LineGradientShader"); - } - if (!linePatternShaderGroup) { - linePatternShaderGroup = shaders.getShaderGroup("LinePatternShader"); - } - if (!lineSDFShaderGroup) { - lineSDFShaderGroup = shaders.getShaderGroup("LineSDFShader"); - } - const RenderPass renderPass = static_cast(evaluatedProperties->renderPasses & ~mbgl::underlying_type(RenderPass::Opaque)); @@ -407,7 +392,6 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, : gfx::ColorMode::unblended()); builder->setCullFaceMode(gfx::CullFaceMode::disabled()); builder->setEnableStencil(true); - builder->setVertexAttrNameId(idVertexAttribName); return builder; }; @@ -417,7 +401,7 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, const auto vertexCount = bucket.vertices.elements(); builder.setRawVertices({}, vertexCount, gfx::AttributeDataType::Short4); - if (const auto& attr = vertexAttrs->add(idVertexAttribName)) { + if (const auto& attr = vertexAttrs->set(idLinePosNormalVertexAttribute)) { attr->setSharedRawData(bucket.sharedVertices, offsetof(LineLayoutVertex, a1), /*vertexOffset=*/0, @@ -425,7 +409,7 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, gfx::AttributeDataType::Short2); } - if (const auto& attr = vertexAttrs->add(idDataAttribName)) { + if (const auto& attr = vertexAttrs->set(idLineDataVertexAttribute)) { attr->setSharedRawData(bucket.sharedVertices, offsetof(LineLayoutVertex, a2), /*vertexOffset=*/0, @@ -442,7 +426,7 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, tileLayerGroup->setStencilTiles(renderTiles); - mbgl::unordered_set propertiesAsUniforms; + StringIDSetsPair propertiesAsUniforms; for (const RenderTile& tile : *renderTiles) { const auto& tileID = tile.getOverscaledTileID(); @@ -547,6 +531,7 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, const auto& linePatternValue = evaluated.get().constantOr(Faded{"", ""}); const std::optional patternPosA = tile.getPattern(linePatternValue.from.id()); const std::optional patternPosB = tile.getPattern(linePatternValue.to.id()); + paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade); auto getLinePatternTilePropertiesUBO = [&]() -> const LinePatternTilePropertiesUBO& { if (!linePatternTilePropertiesUBO) { @@ -600,24 +585,30 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, continue; } + propertiesAsUniforms.first.clear(); + propertiesAsUniforms.second.clear(); + + auto vertexAttrs = context.createVertexAttributeArray(); + vertexAttrs->readDataDrivenPaintProperties( + paintPropertyBinders, evaluated, propertiesAsUniforms, idLineColorVertexAttribute); + if (!evaluated.get().from.empty()) { + // dash array line (SDF) if (!lineSDFShaderGroup) { - continue; + lineSDFShaderGroup = shaders.getShaderGroup("LineSDFShader"); + if (!lineSDFShaderGroup) { + continue; + } } - // dash array line (SDF) - propertiesAsUniforms.clear(); - auto vertexAttrs = context.createVertexAttributeArray(); - vertexAttrs->readDataDrivenPaintProperties( - paintPropertyBinders, evaluated, propertiesAsUniforms); - - auto shader = lineSDFShaderGroup->getOrCreateShader(context, propertiesAsUniforms); + auto shader = lineSDFShaderGroup->getOrCreateShader(context, propertiesAsUniforms, posNormalAttribName); if (!shader) { continue; } @@ -644,24 +635,15 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, ++stats.drawablesAdded; } } else if (!unevaluated.get().isUndefined()) { + // pattern line if (!linePatternShaderGroup) { - continue; + linePatternShaderGroup = shaders.getShaderGroup("LinePatternShader"); + if (!linePatternShaderGroup) { + continue; + } } - // pattern line - paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade); - - propertiesAsUniforms.clear(); - auto vertexAttrs = context.createVertexAttributeArray(); - vertexAttrs->readDataDrivenPaintProperties( - paintPropertyBinders, evaluated, propertiesAsUniforms); - - auto shader = linePatternShaderGroup->getOrCreateShader(context, propertiesAsUniforms); + auto shader = linePatternShaderGroup->getOrCreateShader(context, propertiesAsUniforms, posNormalAttribName); if (!shader) { continue; } @@ -704,17 +686,16 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, } } } else if (!unevaluated.get().getValue().isUndefined()) { + // gradient line if (!lineGradientShaderGroup) { - continue; + lineGradientShaderGroup = shaders.getShaderGroup("LineGradientShader"); + if (!lineGradientShaderGroup) { + continue; + } } - // gradient line - propertiesAsUniforms.clear(); - auto vertexAttrs = context.createVertexAttributeArray(); - vertexAttrs->readDataDrivenPaintProperties( - paintPropertyBinders, evaluated, propertiesAsUniforms); - - auto shader = lineGradientShaderGroup->getOrCreateShader(context, propertiesAsUniforms); + auto shader = lineGradientShaderGroup->getOrCreateShader( + context, propertiesAsUniforms, posNormalAttribName); if (!shader) { continue; } @@ -753,18 +734,15 @@ void RenderLineLayer::update(gfx::ShaderRegistry& shaders, } } } else { + // simple line if (!lineShaderGroup) { - continue; + lineShaderGroup = shaders.getShaderGroup("LineShader"); + if (!lineShaderGroup) { + continue; + } } - // simple line - propertiesAsUniforms.clear(); - auto vertexAttrs = context.createVertexAttributeArray(); - vertexAttrs - ->readDataDrivenPaintProperties( - paintPropertyBinders, evaluated, propertiesAsUniforms); - - auto shader = lineShaderGroup->getOrCreateShader(context, propertiesAsUniforms); + auto shader = lineShaderGroup->getOrCreateShader(context, propertiesAsUniforms, posNormalAttribName); if (!shader) { continue; } diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp index e495030cb..23058ef9d 100644 --- a/src/mbgl/renderer/layers/render_raster_layer.cpp +++ b/src/mbgl/renderer/layers/render_raster_layer.cpp @@ -246,11 +246,6 @@ void RenderRasterLayer::layerIndexChanged(int32_t newLayerIndex, UniqueChangeReq changeLayerIndex(imageLayerGroup, newLayerIndex, changes); } -static const StringIdentity idPosAttribName = stringIndexer().get("a_pos"); -static const StringIdentity idTexturePosAttribName = stringIndexer().get("a_texture_pos"); -static const StringIdentity idTexImage0Name = stringIndexer().get("u_image0"); -static const StringIdentity idTexImage1Name = stringIndexer().get("u_image1"); - void RenderRasterLayer::update(gfx::ShaderRegistry& shaders, gfx::Context& context, const TransformState& /*state*/, @@ -305,7 +300,6 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders, builder->setDepthType(gfx::DepthMaskType::ReadOnly); builder->setColorMode(gfx::ColorMode::alphaBlended()); builder->setCullFaceMode(gfx::CullFaceMode::disabled()); - builder->setVertexAttrNameId(idPosAttribName); return builder; }; @@ -358,7 +352,7 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders, if (!vertexAttrs) { vertexAttrs = context.createVertexAttributeArray(); - if (auto& attr = vertexAttrs->add(idPosAttribName)) { + if (auto& attr = vertexAttrs->set(idRasterPosVertexAttribute)) { attr->setSharedRawData(vertices, offsetof(RasterLayoutVertex, a1), /*vertexOffset=*/0, @@ -366,7 +360,7 @@ void RenderRasterLayer::update(gfx::ShaderRegistry& shaders, gfx::AttributeDataType::Short2); } - if (auto& attr = vertexAttrs->add(idTexturePosAttribName)) { + if (auto& attr = vertexAttrs->set(idRasterTexturePosVertexAttribute)) { attr->setSharedRawData(vertices, offsetof(RasterLayoutVertex, a2), /*vertexOffset=*/0, diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp index ac3535b3d..fbdd68840 100644 --- a/src/mbgl/renderer/layers/render_symbol_layer.cpp +++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp @@ -760,34 +760,29 @@ SymbolDrawableTilePropsUBO buildTileUBO(const SymbolBucket& bucket, }; } -const auto idDataAttibName = stringIndexer().get("a_data"); const auto posOffsetAttribName = "a_pos_offset"; -const auto idPosOffsetAttribName = stringIndexer().get(posOffsetAttribName); -const auto idPixOffsetAttribName = stringIndexer().get("a_pixeloffset"); -const auto idProjPosAttribName = stringIndexer().get("a_projected_pos"); -const auto idFadeOpacityAttribName = stringIndexer().get("a_fade_opacity"); void updateTileAttributes(const SymbolBucket::Buffer& buffer, const bool isText, const SymbolBucket::PaintProperties& paintProps, const SymbolPaintProperties::PossiblyEvaluated& evaluated, gfx::VertexAttributeArray& attribs, - mbgl::unordered_set* propertiesAsUniforms) { - if (const auto& attr = attribs.getOrAdd(idPosOffsetAttribName)) { + StringIDSetsPair* propertiesAsUniforms) { + if (const auto& attr = attribs.set(idSymbolPosOffsetVertexAttribute)) { attr->setSharedRawData(buffer.sharedVertices, offsetof(SymbolLayoutVertex, a1), /*vertexOffset=*/0, sizeof(SymbolLayoutVertex), gfx::AttributeDataType::Short4); } - if (const auto& attr = attribs.getOrAdd(idDataAttibName)) { + if (const auto& attr = attribs.set(idSymbolDataVertexAttribute)) { attr->setSharedRawData(buffer.sharedVertices, offsetof(SymbolLayoutVertex, a2), /*vertexOffset=*/0, sizeof(SymbolLayoutVertex), gfx::AttributeDataType::UShort4); } - if (const auto& attr = attribs.getOrAdd(idPixOffsetAttribName)) { + if (const auto& attr = attribs.set(idSymbolPixelOffsetVertexAttribute)) { attr->setSharedRawData(buffer.sharedVertices, offsetof(SymbolLayoutVertex, a3), /*vertexOffset=*/0, @@ -795,7 +790,7 @@ void updateTileAttributes(const SymbolBucket::Buffer& buffer, gfx::AttributeDataType::Short4); } - if (const auto& attr = attribs.getOrAdd(idProjPosAttribName)) { + if (const auto& attr = attribs.set(idSymbolProjectedPosVertexAttribute)) { using Vertex = gfx::Vertex; attr->setSharedRawData(buffer.sharedDynamicVertices, offsetof(Vertex, a1), @@ -803,7 +798,7 @@ void updateTileAttributes(const SymbolBucket::Buffer& buffer, sizeof(Vertex), gfx::AttributeDataType::Float3); } - if (const auto& attr = attribs.getOrAdd(idFadeOpacityAttribName)) { + if (const auto& attr = attribs.set(idSymbolFadeOpacityVertexAttribute)) { using Vertex = gfx::Vertex; attr->setSharedRawData(buffer.sharedOpacityVertices, offsetof(Vertex, a1), @@ -814,10 +809,10 @@ void updateTileAttributes(const SymbolBucket::Buffer& buffer, if (isText) { attribs.readDataDrivenPaintProperties( - paintProps.textBinders, evaluated, propertiesAsUniforms); + paintProps.textBinders, evaluated, propertiesAsUniforms, idSymbolOpacityVertexAttribute); } else { attribs.readDataDrivenPaintProperties( - paintProps.iconBinders, evaluated, propertiesAsUniforms); + paintProps.iconBinders, evaluated, propertiesAsUniforms, idSymbolOpacityVertexAttribute); } } @@ -874,32 +869,26 @@ void updateTileDrawable(gfx::Drawable& drawable, } } -const StringIdentity idCollisionPosAttribName = stringIndexer().get("a_pos"); -const StringIdentity idCollisionAnchorPosAttribName = stringIndexer().get("a_anchor_pos"); -const StringIdentity idCollisionExtrudeAttribName = stringIndexer().get("a_extrude"); -const StringIdentity idCollisionPlacedAttribName = stringIndexer().get("a_placed"); -const StringIdentity idCollisionShiftAttribName = stringIndexer().get("a_shift"); - gfx::VertexAttributeArrayPtr getCollisionVertexAttributes(gfx::Context& context, const SymbolBucket::CollisionBuffer& buffer) { auto vertexAttrs = context.createVertexAttributeArray(); using LayoutVertex = gfx::Vertex; - if (const auto& attr = vertexAttrs->add(idCollisionPosAttribName)) { + if (const auto& attr = vertexAttrs->set(idCollisionPosVertexAttribute)) { attr->setSharedRawData(buffer.sharedVertices, offsetof(LayoutVertex, a1), /*vertexOffset=*/0, sizeof(LayoutVertex), gfx::AttributeDataType::Short2); } - if (const auto& attr = vertexAttrs->add(idCollisionAnchorPosAttribName)) { + if (const auto& attr = vertexAttrs->set(idCollisionAnchorPosVertexAttribute)) { attr->setSharedRawData(buffer.sharedVertices, offsetof(LayoutVertex, a2), /*vertexOffset=*/0, sizeof(LayoutVertex), gfx::AttributeDataType::Short2); } - if (const auto& attr = vertexAttrs->add(idCollisionExtrudeAttribName)) { + if (const auto& attr = vertexAttrs->set(idCollisionExtrudeVertexAttribute)) { attr->setSharedRawData(buffer.sharedVertices, offsetof(LayoutVertex, a3), /*vertexOffset=*/0, @@ -909,14 +898,14 @@ gfx::VertexAttributeArrayPtr getCollisionVertexAttributes(gfx::Context& context, using DynamicVertex = gfx::Vertex; - if (const auto& attr = vertexAttrs->add(idCollisionPlacedAttribName)) { + if (const auto& attr = vertexAttrs->set(idCollisionPlacedVertexAttribute)) { attr->setSharedRawData(buffer.sharedDynamicVertices, offsetof(DynamicVertex, a1), /*vertexOffset=*/0, sizeof(DynamicVertex), gfx::AttributeDataType::UShort2); } - if (const auto& attr = vertexAttrs->add(idCollisionShiftAttribName)) { + if (const auto& attr = vertexAttrs->set(idCollisionShiftVertexAttribute)) { attr->setSharedRawData(buffer.sharedDynamicVertices, offsetof(DynamicVertex, a2), /*vertexOffset=*/0, @@ -1061,9 +1050,8 @@ void RenderSymbolLayer::update(gfx::ShaderRegistry& shaders, collisionBuilder->setRenderPass(passes); collisionBuilder->setCullFaceMode(gfx::CullFaceMode::disabled()); collisionBuilder->setColorMode(gfx::ColorMode::alphaBlended()); - collisionBuilder->setVertexAttrNameId(idCollisionPosAttribName); - mbgl::unordered_set propertiesAsUniforms; + StringIDSetsPair propertiesAsUniforms; for (const RenderTile& tile : *renderTiles) { const auto& tileID = tile.getOverscaledTileID(); @@ -1106,8 +1094,7 @@ void RenderSymbolLayer::update(gfx::ShaderRegistry& shaders, if (hasCollisionBox) { const auto& collisionBox = isText ? bucket.textCollisionBox : bucket.iconCollisionBox; if (const auto shader = std::static_pointer_cast( - collisionBoxGroup->getOrCreateShader( - context, {}, stringIndexer().get(idCollisionPosAttribName)))) { + collisionBoxGroup->getOrCreateShader(context, {}))) { collisionBuilder->setDrawableName(layerCollisionPrefix + suffix + "box"); collisionBuilder->setShader(shader); addVertices(collisionBox->vertices().vector()); @@ -1123,8 +1110,7 @@ void RenderSymbolLayer::update(gfx::ShaderRegistry& shaders, if (hasCollisionCircle) { const auto& collisionCircle = isText ? bucket.textCollisionCircle : bucket.iconCollisionCircle; if (const auto shader = std::static_pointer_cast( - collisionCircleGroup->getOrCreateShader( - context, {}, stringIndexer().get(idCollisionPosAttribName)))) { + collisionCircleGroup->getOrCreateShader(context, {}))) { collisionBuilder->setDrawableName(layerCollisionPrefix + suffix + "circle"); collisionBuilder->setShader(shader); addVertices(collisionCircle->vertices().vector()); @@ -1158,7 +1144,8 @@ void RenderSymbolLayer::update(gfx::ShaderRegistry& shaders, return false; } - propertiesAsUniforms.clear(); + propertiesAsUniforms.first.clear(); + propertiesAsUniforms.second.clear(); const auto& evaluated = getEvaluated(renderData.layerProperties); updateTileDrawable( @@ -1257,7 +1244,9 @@ void RenderSymbolLayer::update(gfx::ShaderRegistry& shaders, const auto vertexCount = buffer.vertices().elements(); - propertiesAsUniforms.clear(); + propertiesAsUniforms.first.clear(); + propertiesAsUniforms.second.clear(); + auto attribs = context.createVertexAttributeArray(); updateTileAttributes(buffer, isText, bucketPaintProperties, evaluated, *attribs, &propertiesAsUniforms); @@ -1321,12 +1310,8 @@ void RenderSymbolLayer::update(gfx::ShaderRegistry& shaders, ((mbgl::underlying_type(passes) & mbgl::underlying_type(RenderPass::Translucent)) != 0) ? gfx::ColorMode::alphaBlended() : gfx::ColorMode::unblended()); - builder->setVertexAttrNameId(idPosOffsetAttribName); } - if (!shaderGroup) { - return; - } const auto shader = std::static_pointer_cast( shaderGroup->getOrCreateShader(context, propertiesAsUniforms, posOffsetAttribName)); if (!shader) { diff --git a/src/mbgl/renderer/layers/symbol_layer_tweaker.hpp b/src/mbgl/renderer/layers/symbol_layer_tweaker.hpp index 341d627ef..ce06420ee 100644 --- a/src/mbgl/renderer/layers/symbol_layer_tweaker.hpp +++ b/src/mbgl/renderer/layers/symbol_layer_tweaker.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp index a88e6741c..d4eceeccd 100644 --- a/src/mbgl/renderer/sources/render_tile_source.cpp +++ b/src/mbgl/renderer/sources/render_tile_source.cpp @@ -13,12 +13,12 @@ #include #include #include +#include #include #include #include #include #include -#include #include #include #include @@ -65,7 +65,6 @@ void TileSourceRenderItem::updateDebugDrawables(DebugLayerGroupMap& debugLayerGr if (!debugShader) { return; } - static const StringIdentity idVertexAttribName = stringIndexer().get("a_pos"); std::unique_ptr debugBuilder = [&]() -> std::unique_ptr { auto builder = context.createDrawableBuilder("debug-builder"); builder->setShader(debugShader); @@ -73,7 +72,7 @@ void TileSourceRenderItem::updateDebugDrawables(DebugLayerGroupMap& debugLayerGr builder->setEnableDepth(false); builder->setColorMode(gfx::ColorMode::unblended()); builder->setCullFaceMode(gfx::CullFaceMode::disabled()); - builder->setVertexAttrNameId(idVertexAttribName); + builder->setVertexAttrId(idDebugPosVertexAttribute); return builder; }(); @@ -83,14 +82,14 @@ void TileSourceRenderItem::updateDebugDrawables(DebugLayerGroupMap& debugLayerGr gfx::ShaderPtr polylineShader; const auto createPolylineShader = [&]() -> gfx::ShaderPtr { gfx::ShaderGroupPtr shaderGroup = shaders.getShaderGroup("LineShader"); - const mbgl::unordered_set propertiesAsUniforms{ - stringIndexer().get("a_color"), - stringIndexer().get("a_blur"), - stringIndexer().get("a_opacity"), - stringIndexer().get("a_gapwidth"), - stringIndexer().get("a_offset"), - stringIndexer().get("a_width"), - }; + const StringIDSetsPair propertiesAsUniforms{ + {"a_color", "a_blur", "a_opacity", "a_gapwidth", "a_offset", "a_width"}, + {idLineColorVertexAttribute, + idLineBlurVertexAttribute, + idLineOpacityVertexAttribute, + idLineGapWidthVertexAttribute, + idLineOffsetVertexAttribute, + idLineWidthVertexAttribute}}; return shaderGroup->getOrCreateShader(context, propertiesAsUniforms); }; @@ -102,7 +101,7 @@ void TileSourceRenderItem::updateDebugDrawables(DebugLayerGroupMap& debugLayerGr builder->setEnableDepth(false); builder->setColorMode(gfx::ColorMode::alphaBlended()); builder->setCullFaceMode(gfx::CullFaceMode::disabled()); - builder->setVertexAttrNameId(idVertexAttribName); + builder->setVertexAttrId(idLinePosNormalVertexAttribute); return builder; }; diff --git a/src/mbgl/shaders/gl/shader_info.cpp b/src/mbgl/shaders/gl/shader_info.cpp index 704e91585..e3c07bd41 100644 --- a/src/mbgl/shaders/gl/shader_info.cpp +++ b/src/mbgl/shaders/gl/shader_info.cpp @@ -5,6 +5,10 @@ namespace mbgl { namespace shaders { +AttributeInfo::AttributeInfo(std::string_view name_, std::size_t id_) + : name(name_), + id(id_) {} + UniformBlockInfo::UniformBlockInfo(std::string_view name_, std::size_t id_) : name(name_), id(id_), @@ -15,6 +19,9 @@ TextureInfo::TextureInfo(std::string_view name_, std::size_t id_) id(id_) {} // Background +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idBackgroundPosVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"BackgroundDrawableUBO", idBackgroundDrawableUBO}, UniformBlockInfo{"BackgroundLayerUBO", idBackgroundLayerUBO}, @@ -22,6 +29,10 @@ const std::vector ShaderInfo ShaderInfo::textures = {}; // Background Pattern +const std::vector ShaderInfo::attributes = + { + AttributeInfo{"a_pos", idBackgroundPosVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"BackgroundDrawableUBO", idBackgroundDrawableUBO}, @@ -32,6 +43,16 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos", idCirclePosVertexAttribute}, + AttributeInfo{"a_color", idCircleColorVertexAttribute}, + AttributeInfo{"a_radius", idCircleRadiusVertexAttribute}, + AttributeInfo{"a_blur", idCircleBlurVertexAttribute}, + AttributeInfo{"a_opacity", idCircleOpacityVertexAttribute}, + AttributeInfo{"a_stroke_color", idCircleStrokeColorVertexAttribute}, + AttributeInfo{"a_stroke_width", idCircleStrokeWidthVertexAttribute}, + AttributeInfo{"a_stroke_opacity", idCircleStrokeOpacityVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"CircleDrawableUBO", idCircleDrawableUBO}, UniformBlockInfo{"CirclePaintParamsUBO", idCirclePaintParamsUBO}, @@ -41,6 +62,13 @@ const std::vector ShaderInfo ShaderInfo::textures = {}; // Collision Box +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idCollisionPosVertexAttribute}, + AttributeInfo{"a_anchor_pos", idCollisionAnchorPosVertexAttribute}, + AttributeInfo{"a_extrude", idCollisionExtrudeVertexAttribute}, + AttributeInfo{"a_placed", idCollisionPlacedVertexAttribute}, + AttributeInfo{"a_shift", idCollisionShiftVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"CollisionBoxUBO", idCollisionUBO}, @@ -48,22 +76,36 @@ const std::vector ShaderInfo ShaderInfo::textures = {}; // Collision Circle -const std::vector - ShaderInfo::uniformBlocks = { - UniformBlockInfo{"CustomSymbolIconDrawableUBO", idCustomSymbolIconDrawableUBO}, - UniformBlockInfo{"CustomSymbolIconParametersUBO", idCustomSymbolIconParametersUBO}, +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idCollisionPosVertexAttribute}, + AttributeInfo{"a_anchor_pos", idCollisionAnchorPosVertexAttribute}, + AttributeInfo{"a_extrude", idCollisionExtrudeVertexAttribute}, + AttributeInfo{"a_placed", idCollisionPlacedVertexAttribute}, }; -const std::vector ShaderInfo::textures = { - TextureInfo{"u_texture", idSymbolImageTexture}, -}; - const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"CollisionCircleUBO", idCollisionUBO}, }; const std::vector ShaderInfo::textures = {}; +// Custom Symbol Icon +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idCustomSymbolPosVertexAttribute}, + AttributeInfo{"a_tex", idCustomSymbolTexVertexAttribute}, +}; +const std::vector + ShaderInfo::uniformBlocks = { + UniformBlockInfo{"CustomSymbolIconDrawableUBO", idCustomSymbolDrawableUBO}, + UniformBlockInfo{"CustomSymbolIconParametersUBO", idCustomSymbolParametersUBO}, +}; +const std::vector ShaderInfo::textures = { + TextureInfo{"u_texture", idCustomSymbolImageTexture}, +}; + // Debug +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idDebugPosVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"DebugUBO", idDebugUBO}, }; @@ -72,6 +114,11 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos", idFillPosVertexAttribute}, + AttributeInfo{"a_color", idFillColorVertexAttribute}, + AttributeInfo{"a_opacity", idFillOpacityVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"FillDrawableUBO", idFillDrawableUBO}, UniformBlockInfo{"FillEvaluatedPropsUBO", idFillEvaluatedPropsUBO}, @@ -80,6 +127,11 @@ const std::vector ShaderInfo ShaderInfo::textures = {}; // Fill Outline +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idFillPosVertexAttribute}, + AttributeInfo{"a_outline_color", idFillOutlineColorVertexAttribute}, + AttributeInfo{"a_opacity", idFillOpacityVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"FillOutlineDrawableUBO", idFillOutlineDrawableUBO}, @@ -89,6 +141,12 @@ const std::vector ShaderInfo ShaderInfo::textures = {}; // Fill Pattern +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idFillPosVertexAttribute}, + AttributeInfo{"a_opacity", idFillOpacityVertexAttribute}, + AttributeInfo{"a_pattern_from", idFillPatternFromVertexAttribute}, + AttributeInfo{"a_pattern_to", idFillPatternToVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"FillPatternDrawableUBO", idFillPatternDrawableUBO}, @@ -101,6 +159,13 @@ const std::vector ShaderInfo ShaderInfo::attributes = + { + AttributeInfo{"a_pos", idFillPosVertexAttribute}, + AttributeInfo{"a_opacity", idFillOpacityVertexAttribute}, + AttributeInfo{"a_pattern_from", idFillPatternFromVertexAttribute}, + AttributeInfo{"a_pattern_to", idFillPatternToVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"FillOutlinePatternDrawableUBO", idFillOutlinePatternDrawableUBO}, @@ -113,6 +178,13 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos", idFillExtrusionPosVertexAttribute}, + AttributeInfo{"a_normal_ed", idFillExtrusionNormalEdVertexAttribute}, + AttributeInfo{"a_base", idFillExtrusionBaseVertexAttribute}, + AttributeInfo{"a_height", idFillExtrusionHeightVertexAttribute}, + AttributeInfo{"a_color", idFillExtrusionColorVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"FillExtrusionDrawableUBO", idFillExtrusionDrawableUBO}, @@ -123,6 +195,15 @@ const std::vector const std::vector ShaderInfo::textures = {}; // Fill Extrusion Pattern +const std::vector + ShaderInfo::attributes = { + AttributeInfo{"a_pos", idFillExtrusionPosVertexAttribute}, + AttributeInfo{"a_normal_ed", idFillExtrusionNormalEdVertexAttribute}, + AttributeInfo{"a_base", idFillExtrusionBaseVertexAttribute}, + AttributeInfo{"a_height", idFillExtrusionHeightVertexAttribute}, + AttributeInfo{"a_pattern_from", idFillExtrusionPatternFromVertexAttribute}, + AttributeInfo{"a_pattern_to", idFillExtrusionPatternToVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"FillExtrusionDrawableUBO", idFillExtrusionDrawableUBO}, @@ -135,6 +216,11 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos", idHeatmapPosVertexAttribute}, + AttributeInfo{"a_weight", idHeatmapWeightVertexAttribute}, + AttributeInfo{"a_radius", idHeatmapRadiusVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"HeatmapDrawableUBO", idHeatmapDrawableUBO}, UniformBlockInfo{"HeatmapEvaluatedPropsUBO", idHeatmapEvaluatedPropsUBO}, @@ -143,6 +229,9 @@ const std::vector ShaderInfo ShaderInfo::textures = {}; // Heatmap Texture +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idHeatmapPosVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"HeatmapTextureDrawableUBO", idHeatmapTextureDrawableUBO}, @@ -153,6 +242,10 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos", idHillshadePosVertexAttribute}, + AttributeInfo{"a_texture_pos", idHillshadeTexturePosVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"HillshadePrepareDrawableUBO", idHillshadePrepareDrawableUBO}, @@ -162,6 +255,10 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos", idHillshadePosVertexAttribute}, + AttributeInfo{"a_texture_pos", idHillshadeTexturePosVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"HillshadeDrawableUBO", idHillshadeDrawableUBO}, UniformBlockInfo{"HillshadeEvaluatedPropsUBO", idHillshadeEvaluatedPropsUBO}, @@ -170,7 +267,35 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos_normal", idLinePosNormalVertexAttribute}, + AttributeInfo{"a_data", idLineDataVertexAttribute}, + AttributeInfo{"a_color", idLineColorVertexAttribute}, + AttributeInfo{"a_blur", idLineBlurVertexAttribute}, + AttributeInfo{"a_opacity", idLineOpacityVertexAttribute}, + AttributeInfo{"a_gapwidth", idLineGapWidthVertexAttribute}, + AttributeInfo{"a_offset", idLineOffsetVertexAttribute}, + AttributeInfo{"a_width", idLineWidthVertexAttribute}, +}; +const std::vector ShaderInfo::uniformBlocks = { + UniformBlockInfo{"LineDynamicUBO", idLineDynamicUBO}, + UniformBlockInfo{"LineUBO", idLineUBO}, + UniformBlockInfo{"LinePropertiesUBO", idLinePropertiesUBO}, + UniformBlockInfo{"LineInterpolationUBO", idLineInterpolationUBO}, +}; +const std::vector ShaderInfo::textures = {}; + // Line Gradient +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos_normal", idLinePosNormalVertexAttribute}, + AttributeInfo{"a_data", idLineDataVertexAttribute}, + AttributeInfo{"a_blur", idLineBlurVertexAttribute}, + AttributeInfo{"a_opacity", idLineOpacityVertexAttribute}, + AttributeInfo{"a_gapwidth", idLineGapWidthVertexAttribute}, + AttributeInfo{"a_offset", idLineOffsetVertexAttribute}, + AttributeInfo{"a_width", idLineWidthVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"LineDynamicUBO", idLineDynamicUBO}, @@ -183,6 +308,17 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos_normal", idLinePosNormalVertexAttribute}, + AttributeInfo{"a_data", idLineDataVertexAttribute}, + AttributeInfo{"a_blur", idLineBlurVertexAttribute}, + AttributeInfo{"a_opacity", idLineOpacityVertexAttribute}, + AttributeInfo{"a_offset", idLineOffsetVertexAttribute}, + AttributeInfo{"a_gapwidth", idLineGapWidthVertexAttribute}, + AttributeInfo{"a_width", idLineWidthVertexAttribute}, + AttributeInfo{"a_pattern_from", idLinePatternFromVertexAttribute}, + AttributeInfo{"a_pattern_to", idLinePatternToVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"LineDynamicUBO", idLineDynamicUBO}, @@ -196,6 +332,17 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos_normal", idLinePosNormalVertexAttribute}, + AttributeInfo{"a_data", idLineDataVertexAttribute}, + AttributeInfo{"a_color", idLineColorVertexAttribute}, + AttributeInfo{"a_blur", idLineBlurVertexAttribute}, + AttributeInfo{"a_opacity", idLineOpacityVertexAttribute}, + AttributeInfo{"a_gapwidth", idLineGapWidthVertexAttribute}, + AttributeInfo{"a_offset", idLineOffsetVertexAttribute}, + AttributeInfo{"a_width", idLineWidthVertexAttribute}, + AttributeInfo{"a_floorwidth", idLineFloorWidthVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"LineDynamicUBO", idLineDynamicUBO}, UniformBlockInfo{"LineSDFUBO", idLineSDFUBO}, @@ -206,16 +353,11 @@ const std::vector ShaderInfo ShaderInfo::uniformBlocks = { - UniformBlockInfo{"LineDynamicUBO", idLineDynamicUBO}, - UniformBlockInfo{"LineUBO", idLineUBO}, - UniformBlockInfo{"LinePropertiesUBO", idLinePropertiesUBO}, - UniformBlockInfo{"LineInterpolationUBO", idLineInterpolationUBO}, -}; -const std::vector ShaderInfo::textures = {}; - // Line Basic +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos_normal", idLinePosNormalVertexAttribute}, + AttributeInfo{"a_data", idLineDataVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"LineBasicUBO", idLineBasicUBO}, UniformBlockInfo{"LineBasicPropertiesUBO", idLineBasicPropertiesUBO}, @@ -223,6 +365,10 @@ const std::vector ShaderInfo ShaderInfo::textures = {}; // Raster +const std::vector ShaderInfo::attributes = { + AttributeInfo{"a_pos", idRasterPosVertexAttribute}, + AttributeInfo{"a_texture_pos", idRasterTexturePosVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"RasterDrawableUBO", idRasterDrawableUBO}, }; @@ -232,6 +378,14 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos_offset", idSymbolPosOffsetVertexAttribute}, + AttributeInfo{"a_data", idSymbolDataVertexAttribute}, + AttributeInfo{"a_pixeloffset", idSymbolPixelOffsetVertexAttribute}, + AttributeInfo{"a_projected_pos", idSymbolProjectedPosVertexAttribute}, + AttributeInfo{"a_fade_opacity", idSymbolFadeOpacityVertexAttribute}, + AttributeInfo{"a_opacity", idSymbolOpacityVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"SymbolDrawableUBO", idSymbolDrawableUBO}, UniformBlockInfo{"SymbolDynamicUBO", idSymbolDynamicUBO}, @@ -244,6 +398,18 @@ const std::vector ShaderInfo ShaderInfo::attributes = { + AttributeInfo{"a_pos_offset", idSymbolPosOffsetVertexAttribute}, + AttributeInfo{"a_data", idSymbolDataVertexAttribute}, + AttributeInfo{"a_pixeloffset", idSymbolPixelOffsetVertexAttribute}, + AttributeInfo{"a_projected_pos", idSymbolProjectedPosVertexAttribute}, + AttributeInfo{"a_fade_opacity", idSymbolFadeOpacityVertexAttribute}, + AttributeInfo{"a_fill_color", idSymbolColorVertexAttribute}, + AttributeInfo{"a_halo_color", idSymbolHaloColorVertexAttribute}, + AttributeInfo{"a_opacity", idSymbolOpacityVertexAttribute}, + AttributeInfo{"a_halo_width", idSymbolHaloWidthVertexAttribute}, + AttributeInfo{"a_halo_blur", idSymbolHaloBlurVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"SymbolDrawableUBO", idSymbolDrawableUBO}, @@ -257,6 +423,18 @@ const std::vector ShaderInfo ShaderInfo::attributes = + { + AttributeInfo{"a_pos_offset", idSymbolPosOffsetVertexAttribute}, + AttributeInfo{"a_data", idSymbolDataVertexAttribute}, + AttributeInfo{"a_projected_pos", idSymbolProjectedPosVertexAttribute}, + AttributeInfo{"a_fade_opacity", idSymbolFadeOpacityVertexAttribute}, + AttributeInfo{"a_fill_color", idSymbolColorVertexAttribute}, + AttributeInfo{"a_halo_color", idSymbolHaloColorVertexAttribute}, + AttributeInfo{"a_opacity", idSymbolOpacityVertexAttribute}, + AttributeInfo{"a_halo_width", idSymbolHaloWidthVertexAttribute}, + AttributeInfo{"a_halo_blur", idSymbolHaloBlurVertexAttribute}, +}; const std::vector ShaderInfo::uniformBlocks = { UniformBlockInfo{"SymbolDrawableUBO", idSymbolDrawableUBO}, diff --git a/src/mbgl/shaders/gl/shader_program_gl.cpp b/src/mbgl/shaders/gl/shader_program_gl.cpp index 2183bf91b..90ef0a891 100644 --- a/src/mbgl/shaders/gl/shader_program_gl.cpp +++ b/src/mbgl/shaders/gl/shader_program_gl.cpp @@ -71,11 +71,10 @@ gfx::AttributeDataType mapType(platform::GLenum attrType) { using namespace platform; -void addAttr( - VertexAttributeArrayGL& attrs, const StringIdentity id, GLint index, GLsizei length, GLint count, GLenum glType) { +void addAttr(VertexAttributeArrayGL& attrs, const size_t id, GLint index, GLsizei length, GLint count, GLenum glType) { const auto elementType = mapType(glType); if (elementType != gfx::AttributeDataType::Invalid && length > 0) { - if (const auto& newAttr = attrs.add(id, index, elementType, count)) { + if (const auto& newAttr = attrs.set(id, index, elementType, count)) { const auto& glAttr = static_cast(newAttr.get()); glAttr->setGLType(glType); } @@ -115,6 +114,7 @@ std::shared_ptr ShaderProgramGL::create( const std::string_view firstAttribName, const std::vector& uniformBlocksInfo, const std::vector& texturesInfo, + const std::vector& attributesInfo, const std::string& vertexSource, const std::string& fragmentSource, const std::string& additionalDefines) noexcept(false) { @@ -171,7 +171,8 @@ std::shared_ptr ShaderProgramGL::create( continue; } const GLint location = MBGL_CHECK_ERROR(glGetAttribLocation(program, name.data())); - addAttr(attrs, stringIndexer().get(name.data()), location, length, size, glType); + assert(attributesInfo[location].name == std::string_view(name.data())); + addAttr(attrs, attributesInfo[location].id, location, length, size, glType); } return std::make_shared( diff --git a/src/mbgl/shaders/mtl/background.cpp b/src/mbgl/shaders/mtl/background.cpp index e6a9d6e28..3effa4091 100644 --- a/src/mbgl/shaders/mtl/background.cpp +++ b/src/mbgl/shaders/mtl/background.cpp @@ -5,7 +5,7 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Float3, "a_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Float3, idBackgroundPosVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{1, true, false, sizeof(BackgroundDrawableUBO), idBackgroundDrawableUBO}, diff --git a/src/mbgl/shaders/mtl/background_pattern.cpp b/src/mbgl/shaders/mtl/background_pattern.cpp index aa6a7c704..6d2629ce1 100644 --- a/src/mbgl/shaders/mtl/background_pattern.cpp +++ b/src/mbgl/shaders/mtl/background_pattern.cpp @@ -6,7 +6,7 @@ namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Float3, "a_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Float3, idBackgroundPosVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/circle.cpp b/src/mbgl/shaders/mtl/circle.cpp index 426447ad5..f993b9ade 100644 --- a/src/mbgl/shaders/mtl/circle.cpp +++ b/src/mbgl/shaders/mtl/circle.cpp @@ -4,14 +4,14 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Float4, "a_color"}, - AttributeInfo{2, gfx::AttributeDataType::Float2, "a_radius"}, - AttributeInfo{3, gfx::AttributeDataType::Float2, "a_blur"}, - AttributeInfo{4, gfx::AttributeDataType::Float2, "a_opacity"}, - AttributeInfo{5, gfx::AttributeDataType::Float4, "a_stroke_color"}, - AttributeInfo{6, gfx::AttributeDataType::Float2, "a_stroke_width"}, - AttributeInfo{7, gfx::AttributeDataType::Float2, "a_stroke_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idCirclePosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Float4, idCircleColorVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float2, idCircleRadiusVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float2, idCircleBlurVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float2, idCircleOpacityVertexAttribute}, + AttributeInfo{5, gfx::AttributeDataType::Float4, idCircleStrokeColorVertexAttribute}, + AttributeInfo{6, gfx::AttributeDataType::Float2, idCircleStrokeWidthVertexAttribute}, + AttributeInfo{7, gfx::AttributeDataType::Float2, idCircleStrokeOpacityVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{8, true, false, sizeof(CircleDrawableUBO), idCircleDrawableUBO}, diff --git a/src/mbgl/shaders/mtl/clipping_mask.cpp b/src/mbgl/shaders/mtl/clipping_mask.cpp index bd2ba6237..e3eacf868 100644 --- a/src/mbgl/shaders/mtl/clipping_mask.cpp +++ b/src/mbgl/shaders/mtl/clipping_mask.cpp @@ -6,10 +6,10 @@ namespace shaders { using ShaderType = ShaderSource; const std::array ShaderType::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Float3, "a_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Float3, idClippingMaskPosVertexAttribute}, }; const std::array ShaderType::uniforms = { - UniformBlockInfo{1, true, false, sizeof(ClipUBO), 0}, + UniformBlockInfo{1, true, false, sizeof(ClipUBO), idClippingMaskUBO}, }; const std::array ShaderType::textures = {}; diff --git a/src/mbgl/shaders/mtl/collision_box.cpp b/src/mbgl/shaders/mtl/collision_box.cpp index c712f76b8..ac1eb8899 100644 --- a/src/mbgl/shaders/mtl/collision_box.cpp +++ b/src/mbgl/shaders/mtl/collision_box.cpp @@ -4,11 +4,11 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Short2, "a_anchor_pos"}, - AttributeInfo{2, gfx::AttributeDataType::Short2, "a_extrude"}, - AttributeInfo{3, gfx::AttributeDataType::UShort2, "a_placed"}, - AttributeInfo{4, gfx::AttributeDataType::Float2, "a_shift"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idCollisionPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Short2, idCollisionAnchorPosVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Short2, idCollisionExtrudeVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::UShort2, idCollisionPlacedVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float2, idCollisionShiftVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{5, true, true, sizeof(CollisionUBO), idCollisionUBO}, diff --git a/src/mbgl/shaders/mtl/collision_circle.cpp b/src/mbgl/shaders/mtl/collision_circle.cpp index 2979256b5..e62054bbf 100644 --- a/src/mbgl/shaders/mtl/collision_circle.cpp +++ b/src/mbgl/shaders/mtl/collision_circle.cpp @@ -5,10 +5,10 @@ namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Short2, "a_anchor_pos"}, - AttributeInfo{2, gfx::AttributeDataType::Short2, "a_extrude"}, - AttributeInfo{3, gfx::AttributeDataType::UShort2, "a_placed"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idCollisionPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Short2, idCollisionAnchorPosVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Short2, idCollisionExtrudeVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::UShort2, idCollisionPlacedVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/custom_symbol_icon.cpp b/src/mbgl/shaders/mtl/custom_symbol_icon.cpp index 4c1afaf79..145d2fc23 100644 --- a/src/mbgl/shaders/mtl/custom_symbol_icon.cpp +++ b/src/mbgl/shaders/mtl/custom_symbol_icon.cpp @@ -6,16 +6,16 @@ namespace shaders { const std::array ShaderSource::attributes = { // always attributes - AttributeInfo{0, gfx::AttributeDataType::Float2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Float2, "a_tex"}, + AttributeInfo{0, gfx::AttributeDataType::Float2, idCustomSymbolPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Float2, idCustomSymbolTexVertexAttribute}, }; const std::array ShaderSource::uniforms = { - UniformBlockInfo{2, true, false, sizeof(CustomSymbolIconDrawableUBO), idCustomSymbolIconDrawableUBO}, - UniformBlockInfo{3, true, false, sizeof(CustomSymbolIconParametersUBO), idCustomSymbolIconParametersUBO}, + UniformBlockInfo{2, true, false, sizeof(CustomSymbolIconDrawableUBO), idCustomSymbolDrawableUBO}, + UniformBlockInfo{3, true, false, sizeof(CustomSymbolIconParametersUBO), idCustomSymbolParametersUBO}, }; const std::array ShaderSource::textures = { - TextureInfo{0, idCustomSymbolIconTexture}, + TextureInfo{0, idCustomSymbolImageTexture}, }; } // namespace shaders diff --git a/src/mbgl/shaders/mtl/debug.cpp b/src/mbgl/shaders/mtl/debug.cpp index 017c0edb1..d2eac2a00 100644 --- a/src/mbgl/shaders/mtl/debug.cpp +++ b/src/mbgl/shaders/mtl/debug.cpp @@ -4,7 +4,7 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idDebugPosVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{1, true, true, sizeof(DebugUBO), idDebugUBO}, diff --git a/src/mbgl/shaders/mtl/fill.cpp b/src/mbgl/shaders/mtl/fill.cpp index 05ad0f24a..3bc99120b 100644 --- a/src/mbgl/shaders/mtl/fill.cpp +++ b/src/mbgl/shaders/mtl/fill.cpp @@ -4,9 +4,9 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Float4, "a_color"}, - AttributeInfo{2, gfx::AttributeDataType::Float2, "a_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Float4, idFillColorVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{3, true, false, sizeof(FillDrawableUBO), idFillDrawableUBO}, @@ -16,9 +16,9 @@ const std::array ShaderSource ShaderSource::textures = {}; const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Float4, "a_outline_color"}, - AttributeInfo{2, gfx::AttributeDataType::Float2, "a_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Float4, idFillOutlineColorVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{3, true, false, sizeof(FillOutlineDrawableUBO), idFillOutlineDrawableUBO}, @@ -28,10 +28,10 @@ const std::array ShaderSource ShaderSource::textures = {}; const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::UShort4, "a_pattern_from"}, - AttributeInfo{2, gfx::AttributeDataType::UShort4, "a_pattern_to"}, - AttributeInfo{3, gfx::AttributeDataType::Float2, "a_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UShort4, idFillPatternFromVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::UShort4, idFillPatternToVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{4, true, true, sizeof(FillPatternDrawableUBO), idFillPatternDrawableUBO}, @@ -45,10 +45,10 @@ const std::array ShaderSource ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::UShort4, "a_pattern_from"}, - AttributeInfo{2, gfx::AttributeDataType::UShort4, "a_pattern_to"}, - AttributeInfo{3, gfx::AttributeDataType::Float2, "a_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UShort4, idFillPatternFromVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::UShort4, idFillPatternToVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/fill_extrusion.cpp b/src/mbgl/shaders/mtl/fill_extrusion.cpp index b3dc1472e..e8223697a 100644 --- a/src/mbgl/shaders/mtl/fill_extrusion.cpp +++ b/src/mbgl/shaders/mtl/fill_extrusion.cpp @@ -4,11 +4,11 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Short4, "a_normal_ed"}, - AttributeInfo{2, gfx::AttributeDataType::Float4, "a_color"}, - AttributeInfo{3, gfx::AttributeDataType::Float, "a_base"}, - AttributeInfo{4, gfx::AttributeDataType::Float, "a_height"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idFillExtrusionPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Short4, idFillExtrusionNormalEdVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float4, idFillExtrusionColorVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float, idFillExtrusionBaseVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float, idFillExtrusionHeightVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/fill_extrusion_pattern.cpp b/src/mbgl/shaders/mtl/fill_extrusion_pattern.cpp index 3bd415ae7..3df13f684 100644 --- a/src/mbgl/shaders/mtl/fill_extrusion_pattern.cpp +++ b/src/mbgl/shaders/mtl/fill_extrusion_pattern.cpp @@ -6,12 +6,12 @@ namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Short4, "a_normal_ed"}, - AttributeInfo{2, gfx::AttributeDataType::Float, "a_base"}, - AttributeInfo{3, gfx::AttributeDataType::Float, "a_height"}, - AttributeInfo{4, gfx::AttributeDataType::UShort4, "a_pattern_from"}, - AttributeInfo{5, gfx::AttributeDataType::UShort4, "a_pattern_to"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idFillExtrusionPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Short4, idFillExtrusionNormalEdVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float, idFillExtrusionBaseVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float, idFillExtrusionHeightVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::UShort4, idFillExtrusionPatternFromVertexAttribute}, + AttributeInfo{5, gfx::AttributeDataType::UShort4, idFillExtrusionPatternToVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/heatmap.cpp b/src/mbgl/shaders/mtl/heatmap.cpp index 9f3d05853..0ac7738da 100644 --- a/src/mbgl/shaders/mtl/heatmap.cpp +++ b/src/mbgl/shaders/mtl/heatmap.cpp @@ -4,9 +4,9 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Float2, "a_weight"}, - AttributeInfo{2, gfx::AttributeDataType::Float2, "a_radius"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idHeatmapPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Float2, idHeatmapWeightVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float2, idHeatmapRadiusVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{3, true, false, sizeof(HeatmapDrawableUBO), idHeatmapDrawableUBO}, diff --git a/src/mbgl/shaders/mtl/heatmap_texture.cpp b/src/mbgl/shaders/mtl/heatmap_texture.cpp index 61f206750..944205d5e 100644 --- a/src/mbgl/shaders/mtl/heatmap_texture.cpp +++ b/src/mbgl/shaders/mtl/heatmap_texture.cpp @@ -5,7 +5,7 @@ namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idHeatmapPosVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/hillshade.cpp b/src/mbgl/shaders/mtl/hillshade.cpp index 3bc21b853..6353df65c 100644 --- a/src/mbgl/shaders/mtl/hillshade.cpp +++ b/src/mbgl/shaders/mtl/hillshade.cpp @@ -4,8 +4,8 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Short2, "a_texture_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idHillshadePosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Short2, idHillshadeTexturePosVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{2, true, true, sizeof(HillshadeDrawableUBO), idHillshadeDrawableUBO}, diff --git a/src/mbgl/shaders/mtl/hillshade_prepare.cpp b/src/mbgl/shaders/mtl/hillshade_prepare.cpp index 5aa84fa93..a4efc7701 100644 --- a/src/mbgl/shaders/mtl/hillshade_prepare.cpp +++ b/src/mbgl/shaders/mtl/hillshade_prepare.cpp @@ -5,8 +5,8 @@ namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Short2, "a_texture_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idHillshadePosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Short2, idHillshadeTexturePosVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/line.cpp b/src/mbgl/shaders/mtl/line.cpp index fed8f6dd5..72ddc1009 100644 --- a/src/mbgl/shaders/mtl/line.cpp +++ b/src/mbgl/shaders/mtl/line.cpp @@ -4,14 +4,14 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos_normal"}, - AttributeInfo{1, gfx::AttributeDataType::UByte4, "a_data"}, - AttributeInfo{2, gfx::AttributeDataType::Float4, "a_color"}, - AttributeInfo{3, gfx::AttributeDataType::Float2, "a_blur"}, - AttributeInfo{4, gfx::AttributeDataType::Float2, "a_opacity"}, - AttributeInfo{5, gfx::AttributeDataType::Float2, "a_gapwidth"}, - AttributeInfo{6, gfx::AttributeDataType::Float2, "a_offset"}, - AttributeInfo{7, gfx::AttributeDataType::Float2, "a_width"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float4, idLineColorVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute}, + AttributeInfo{5, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute}, + AttributeInfo{6, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute}, + AttributeInfo{7, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{8, true, false, sizeof(LineDynamicUBO), idLineDynamicUBO}, @@ -22,15 +22,15 @@ const std::array ShaderSource ShaderSource::textures = {}; const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos_normal"}, - AttributeInfo{1, gfx::AttributeDataType::UByte4, "a_data"}, - AttributeInfo{2, gfx::AttributeDataType::Float2, "a_blur"}, - AttributeInfo{3, gfx::AttributeDataType::Float2, "a_opacity"}, - AttributeInfo{4, gfx::AttributeDataType::Float2, "a_gapwidth"}, - AttributeInfo{5, gfx::AttributeDataType::Float2, "a_offset"}, - AttributeInfo{6, gfx::AttributeDataType::Float2, "a_width"}, - AttributeInfo{7, gfx::AttributeDataType::UShort4, "a_pattern_from"}, - AttributeInfo{8, gfx::AttributeDataType::UShort4, "a_pattern_to"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute}, + AttributeInfo{5, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute}, + AttributeInfo{6, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute}, + AttributeInfo{7, gfx::AttributeDataType::UShort4, idLinePatternFromVertexAttribute}, + AttributeInfo{8, gfx::AttributeDataType::UShort4, idLinePatternToVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{9, true, false, sizeof(LineDynamicUBO), idLinePatternDynamicUBO}, @@ -44,15 +44,15 @@ const std::array ShaderSource ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos_normal"}, - AttributeInfo{1, gfx::AttributeDataType::UByte4, "a_data"}, - AttributeInfo{2, gfx::AttributeDataType::Float4, "a_color"}, - AttributeInfo{3, gfx::AttributeDataType::Float2, "a_blur"}, - AttributeInfo{4, gfx::AttributeDataType::Float2, "a_opacity"}, - AttributeInfo{5, gfx::AttributeDataType::Float2, "a_gapwidth"}, - AttributeInfo{6, gfx::AttributeDataType::Float2, "a_offset"}, - AttributeInfo{7, gfx::AttributeDataType::Float2, "a_width"}, - AttributeInfo{8, gfx::AttributeDataType::Float2, "a_floorwidth"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float4, idLineColorVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute}, + AttributeInfo{5, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute}, + AttributeInfo{6, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute}, + AttributeInfo{7, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute}, + AttributeInfo{8, gfx::AttributeDataType::Float2, idLineFloorWidthVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{9, true, false, sizeof(LineDynamicUBO), idLineSDFDynamicUBO}, @@ -65,8 +65,8 @@ const std::array ShaderSource ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos_normal"}, - AttributeInfo{1, gfx::AttributeDataType::UByte4, "a_data"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{2, true, true, sizeof(LineBasicUBO), idLineBasicUBO}, diff --git a/src/mbgl/shaders/mtl/line_gradient.cpp b/src/mbgl/shaders/mtl/line_gradient.cpp index a3a4a1aa7..c44177070 100644 --- a/src/mbgl/shaders/mtl/line_gradient.cpp +++ b/src/mbgl/shaders/mtl/line_gradient.cpp @@ -4,13 +4,13 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos_normal"}, - AttributeInfo{1, gfx::AttributeDataType::UByte4, "a_data"}, - AttributeInfo{2, gfx::AttributeDataType::Float2, "a_blur"}, - AttributeInfo{3, gfx::AttributeDataType::Float2, "a_opacity"}, - AttributeInfo{4, gfx::AttributeDataType::Float2, "a_gapwidth"}, - AttributeInfo{5, gfx::AttributeDataType::Float2, "a_offset"}, - AttributeInfo{6, gfx::AttributeDataType::Float2, "a_width"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute}, + AttributeInfo{5, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute}, + AttributeInfo{6, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{7, true, false, sizeof(LineDynamicUBO), idLineGradientDynamicUBO}, diff --git a/src/mbgl/shaders/mtl/raster.cpp b/src/mbgl/shaders/mtl/raster.cpp index 0bb98a615..ccfd9b821 100644 --- a/src/mbgl/shaders/mtl/raster.cpp +++ b/src/mbgl/shaders/mtl/raster.cpp @@ -4,8 +4,8 @@ namespace mbgl { namespace shaders { const std::array ShaderSource::attributes = { - AttributeInfo{0, gfx::AttributeDataType::Short2, "a_pos"}, - AttributeInfo{1, gfx::AttributeDataType::Short2, "a_texture_pos"}, + AttributeInfo{0, gfx::AttributeDataType::Short2, idRasterPosVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::Short2, idRasterTexturePosVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{2, true, true, sizeof(RasterDrawableUBO), idRasterDrawableUBO}, diff --git a/src/mbgl/shaders/mtl/shader_program.cpp b/src/mbgl/shaders/mtl/shader_program.cpp index ca13c4acd..466854487 100644 --- a/src/mbgl/shaders/mtl/shader_program.cpp +++ b/src/mbgl/shaders/mtl/shader_program.cpp @@ -10,7 +10,6 @@ #include #include #include -#include #include #include @@ -24,11 +23,10 @@ using namespace std::string_literals; namespace mbgl { -shaders::AttributeInfo::AttributeInfo(std::size_t index_, gfx::AttributeDataType dataType_, std::string_view name_) +shaders::AttributeInfo::AttributeInfo(std::size_t index_, gfx::AttributeDataType dataType_, std::size_t id_) : index(index_), dataType(dataType_), - name(name_), - nameID(stringIndexer().get(name_)) {} + id(id_) {} shaders::UniformBlockInfo::UniformBlockInfo( std::size_t index_, bool vertex_, bool fragment_, std::size_t size_, std::size_t id_) @@ -195,19 +193,17 @@ void ShaderProgram::initAttribute(const shaders::AttributeInfo& info) { const auto index = static_cast(info.index); #if !defined(NDEBUG) // Indexes must be unique, if there's a conflict check the `attributes` array in the shader - vertexAttributes.visitAttributes( - [&](auto, const gfx::VertexAttribute& attrib) { assert(attrib.getIndex() != index); }); + vertexAttributes.visitAttributes([&](const gfx::VertexAttribute& attrib) { assert(attrib.getIndex() != index); }); uniformBlocks.visit([&](const gfx::UniformBlock& block) { assert(block.getIndex() != index); }); #endif - vertexAttributes.add(stringIndexer().get(info.name), index, info.dataType, 1); + vertexAttributes.set(info.id, index, info.dataType, 1); } void ShaderProgram::initUniformBlock(const shaders::UniformBlockInfo& info) { const auto index = static_cast(info.index); #if !defined(NDEBUG) // Indexes must be unique, if there's a conflict check the `attributes` array in the shader - vertexAttributes.visitAttributes( - [&](auto, const gfx::VertexAttribute& attrib) { assert(attrib.getIndex() != index); }); + vertexAttributes.visitAttributes([&](const gfx::VertexAttribute& attrib) { assert(attrib.getIndex() != index); }); uniformBlocks.visit([&](const gfx::UniformBlock& block) { assert(block.getIndex() != index); }); #endif if (const auto& block_ = uniformBlocks.set(info.id, index, info.size)) { diff --git a/src/mbgl/shaders/mtl/symbol_icon.cpp b/src/mbgl/shaders/mtl/symbol_icon.cpp index 556a29aeb..1681044bd 100644 --- a/src/mbgl/shaders/mtl/symbol_icon.cpp +++ b/src/mbgl/shaders/mtl/symbol_icon.cpp @@ -5,14 +5,14 @@ namespace shaders { const std::array ShaderSource::attributes = { // always attributes - AttributeInfo{0, gfx::AttributeDataType::Short4, "a_pos_offset"}, - AttributeInfo{1, gfx::AttributeDataType::UShort4, "a_data"}, - AttributeInfo{2, gfx::AttributeDataType::Short4, "a_pixeloffset"}, - AttributeInfo{3, gfx::AttributeDataType::Float3, "a_projected_pos"}, - AttributeInfo{4, gfx::AttributeDataType::Float, "a_fade_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short4, idSymbolPosOffsetVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UShort4, idSymbolDataVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Short4, idSymbolPixelOffsetVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float3, idSymbolProjectedPosVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float, idSymbolFadeOpacityVertexAttribute}, // sometimes uniforms - AttributeInfo{5, gfx::AttributeDataType::Float, "a_opacity"}, + AttributeInfo{5, gfx::AttributeDataType::Float, idSymbolOpacityVertexAttribute}, }; const std::array ShaderSource::uniforms = { UniformBlockInfo{6, true, true, sizeof(SymbolDrawableUBO), idSymbolDrawableUBO}, diff --git a/src/mbgl/shaders/mtl/symbol_sdf.cpp b/src/mbgl/shaders/mtl/symbol_sdf.cpp index f064ad620..48a9edb70 100644 --- a/src/mbgl/shaders/mtl/symbol_sdf.cpp +++ b/src/mbgl/shaders/mtl/symbol_sdf.cpp @@ -6,18 +6,18 @@ namespace shaders { const std::array ShaderSource::attributes = { // always attributes - AttributeInfo{0, gfx::AttributeDataType::Short4, "a_pos_offset"}, - AttributeInfo{1, gfx::AttributeDataType::UShort4, "a_data"}, - AttributeInfo{2, gfx::AttributeDataType::Short4, "a_pixeloffset"}, - AttributeInfo{3, gfx::AttributeDataType::Float3, "a_projected_pos"}, - AttributeInfo{4, gfx::AttributeDataType::Float, "a_fade_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short4, idSymbolPosOffsetVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UShort4, idSymbolDataVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Short4, idSymbolPixelOffsetVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float3, idSymbolProjectedPosVertexAttribute}, + AttributeInfo{4, gfx::AttributeDataType::Float, idSymbolFadeOpacityVertexAttribute}, // sometimes uniforms - AttributeInfo{5, gfx::AttributeDataType::Float4, "a_fill_color"}, - AttributeInfo{6, gfx::AttributeDataType::Float4, "a_halo_color"}, - AttributeInfo{7, gfx::AttributeDataType::Float, "a_opacity"}, - AttributeInfo{8, gfx::AttributeDataType::Float, "a_halo_width"}, - AttributeInfo{9, gfx::AttributeDataType::Float, "a_halo_blur"}, + AttributeInfo{5, gfx::AttributeDataType::Float4, idSymbolColorVertexAttribute}, + AttributeInfo{6, gfx::AttributeDataType::Float4, idSymbolHaloColorVertexAttribute}, + AttributeInfo{7, gfx::AttributeDataType::Float, idSymbolOpacityVertexAttribute}, + AttributeInfo{8, gfx::AttributeDataType::Float, idSymbolHaloWidthVertexAttribute}, + AttributeInfo{9, gfx::AttributeDataType::Float, idSymbolHaloBlurVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/shaders/mtl/symbol_text_and_icon.cpp b/src/mbgl/shaders/mtl/symbol_text_and_icon.cpp index 2cc4523ea..83b8d6459 100644 --- a/src/mbgl/shaders/mtl/symbol_text_and_icon.cpp +++ b/src/mbgl/shaders/mtl/symbol_text_and_icon.cpp @@ -6,17 +6,17 @@ namespace shaders { const std::array ShaderSource::attributes = { // always attributes - AttributeInfo{0, gfx::AttributeDataType::Short4, "a_pos_offset"}, - AttributeInfo{1, gfx::AttributeDataType::UShort4, "a_data"}, - AttributeInfo{2, gfx::AttributeDataType::Float3, "a_projected_pos"}, - AttributeInfo{3, gfx::AttributeDataType::Float, "a_fade_opacity"}, + AttributeInfo{0, gfx::AttributeDataType::Short4, idSymbolPosOffsetVertexAttribute}, + AttributeInfo{1, gfx::AttributeDataType::UShort4, idSymbolDataVertexAttribute}, + AttributeInfo{2, gfx::AttributeDataType::Float3, idSymbolProjectedPosVertexAttribute}, + AttributeInfo{3, gfx::AttributeDataType::Float, idSymbolFadeOpacityVertexAttribute}, // sometimes uniforms - AttributeInfo{4, gfx::AttributeDataType::Float4, "a_fill_color"}, - AttributeInfo{5, gfx::AttributeDataType::Float4, "a_halo_color"}, - AttributeInfo{6, gfx::AttributeDataType::Float, "a_opacity"}, - AttributeInfo{7, gfx::AttributeDataType::Float, "a_halo_width"}, - AttributeInfo{8, gfx::AttributeDataType::Float, "a_halo_blur"}, + AttributeInfo{4, gfx::AttributeDataType::Float4, idSymbolColorVertexAttribute}, + AttributeInfo{5, gfx::AttributeDataType::Float4, idSymbolHaloColorVertexAttribute}, + AttributeInfo{6, gfx::AttributeDataType::Float, idSymbolOpacityVertexAttribute}, + AttributeInfo{7, gfx::AttributeDataType::Float, idSymbolHaloWidthVertexAttribute}, + AttributeInfo{8, gfx::AttributeDataType::Float, idSymbolHaloBlurVertexAttribute}, }; const std::array ShaderSource::uniforms = { diff --git a/src/mbgl/style/layers/custom_drawable_layer.cpp b/src/mbgl/style/layers/custom_drawable_layer.cpp index 8e3554326..6f79ba910 100644 --- a/src/mbgl/style/layers/custom_drawable_layer.cpp +++ b/src/mbgl/style/layers/custom_drawable_layer.cpp @@ -13,7 +13,6 @@ #include #include #include -#include #include #include #include @@ -223,8 +222,8 @@ public: // set UBOs auto& uniforms = drawable.mutableUniformBuffers(); - uniforms.createOrUpdate(idCustomSymbolIconDrawableUBO, &drawableUBO, parameters.context); - uniforms.createOrUpdate(idCustomSymbolIconParametersUBO, ¶metersUBO, parameters.context); + uniforms.createOrUpdate(idCustomSymbolDrawableUBO, &drawableUBO, parameters.context); + uniforms.createOrUpdate(idCustomSymbolParametersUBO, ¶metersUBO, parameters.context); }; private: @@ -317,11 +316,8 @@ void CustomDrawableLayerHost::Interface::addFill(const GeometryCollection& geome gfx::generateFillBuffers(geometry, vertices, triangles, triangleSegments); // add to builder - static const StringIdentity idVertexAttribName = stringIndexer().get("a_pos"); - builder->setVertexAttrNameId(idVertexAttribName); - auto attrs = context.createVertexAttributeArray(); - if (const auto& attr = attrs->add(idVertexAttribName)) { + if (const auto& attr = attrs->set(idFillPosVertexAttribute)) { attr->setSharedRawData(sharedVertices, offsetof(FillLayoutVertex, a1), /*vertexOffset=*/0, @@ -377,19 +373,15 @@ void CustomDrawableLayerHost::Interface::addSymbol(const GeometryCoordinate& poi triangleSegments.emplace_back(Segment{0, 0, 4, 6}); // add to builder - static const StringIdentity idPositionAttribName = stringIndexer().get("a_pos"); - static const StringIdentity idTextureAttribName = stringIndexer().get("a_tex"); - builder->setVertexAttrNameId(idPositionAttribName); - auto attrs = context.createVertexAttributeArray(); - if (const auto& attr = attrs->add(idPositionAttribName)) { + if (const auto& attr = attrs->set(idCustomSymbolPosVertexAttribute)) { attr->setSharedRawData(sharedVertices, offsetof(CustomSymbolIcon, a_pos), /*vertexOffset=*/0, sizeof(CustomSymbolIcon), gfx::AttributeDataType::Float2); } - if (const auto& attr = attrs->add(idTextureAttribName)) { + if (const auto& attr = attrs->set(idCustomSymbolTexVertexAttribute)) { attr->setSharedRawData(sharedVertices, offsetof(CustomSymbolIcon, a_tex), /*vertexOffset=*/0, @@ -402,7 +394,7 @@ void CustomDrawableLayerHost::Interface::addSymbol(const GeometryCoordinate& poi // texture if (symbolOptions.texture) { - builder->setTexture(symbolOptions.texture, idCustomSymbolIconTexture); + builder->setTexture(symbolOptions.texture, idCustomSymbolImageTexture); } // create fill tweaker @@ -467,14 +459,13 @@ void CustomDrawableLayerHost::Interface::finish() { gfx::ShaderPtr CustomDrawableLayerHost::Interface::lineShaderDefault() const { gfx::ShaderGroupPtr shaderGroup = shaders.getShaderGroup("LineShader"); - const mbgl::unordered_set propertiesAsUniforms{ - stringIndexer().get("a_color"), - stringIndexer().get("a_blur"), - stringIndexer().get("a_opacity"), - stringIndexer().get("a_gapwidth"), - stringIndexer().get("a_offset"), - stringIndexer().get("a_width"), - }; + const StringIDSetsPair propertiesAsUniforms{{"a_color", "a_blur", "a_opacity", "a_gapwidth", "a_offset", "a_width"}, + {idLineColorVertexAttribute, + idLineBlurVertexAttribute, + idLineOpacityVertexAttribute, + idLineGapWidthVertexAttribute, + idLineOffsetVertexAttribute, + idLineWidthVertexAttribute}}; return shaderGroup->getOrCreateShader(context, propertiesAsUniforms); } @@ -482,10 +473,8 @@ gfx::ShaderPtr CustomDrawableLayerHost::Interface::lineShaderDefault() const { gfx::ShaderPtr CustomDrawableLayerHost::Interface::fillShaderDefault() const { gfx::ShaderGroupPtr shaderGroup = shaders.getShaderGroup("FillShader"); - const mbgl::unordered_set propertiesAsUniforms{ - stringIndexer().get("a_color"), - stringIndexer().get("a_opacity"), - }; + const StringIDSetsPair propertiesAsUniforms{{"a_color", "a_opacity"}, + {idFillColorVertexAttribute, idFillOpacityVertexAttribute}}; return shaderGroup->getOrCreateShader(context, propertiesAsUniforms); } diff --git a/src/mbgl/style/paint_property.hpp b/src/mbgl/style/paint_property.hpp index b7ac4ae4f..1b6f64c81 100644 --- a/src/mbgl/style/paint_property.hpp +++ b/src/mbgl/style/paint_property.hpp @@ -12,9 +12,6 @@ #include namespace mbgl { - -using StringIdentity = std::size_t; - namespace style { template @@ -46,12 +43,8 @@ public: using UniformList = TypeList; static constexpr const std::array AttributeNames = {A::name()}; - static std::array, 1> AttributeNameIDs; }; -template -std::array, 1> DataDrivenPaintProperty::AttributeNameIDs = {std::nullopt}; - template class CrossFadedDataDrivenPaintProperty { public: @@ -69,13 +62,8 @@ public: using UniformList = TypeList; static constexpr const std::array AttributeNames = {A1::name(), A2::name()}; - static std::array, 2> AttributeNameIDs; }; -template -std::array, 2> CrossFadedDataDrivenPaintProperty::AttributeNameIDs = { - std::nullopt, std::nullopt}; - template class CrossFadedPaintProperty { public: diff --git a/test/util/hash.test.cpp b/test/util/hash.test.cpp index b297df7be..033d2a0f0 100644 --- a/test/util/hash.test.cpp +++ b/test/util/hash.test.cpp @@ -94,16 +94,16 @@ void each_subset(const TSet& sofar, TIter beg, TIter end, TFunc f) { /// Ensure that no combination of attributes used by a shader definition produce a hash conflict template void checkShaderHashes() { - using AttribSet = mbgl::unordered_set; + using AttribSet = mbgl::unordered_set; AttribSet attributes; for (const auto& attrib : ShaderType::attributes) { - attributes.insert(attrib.nameID); + attributes.insert(attrib.id); } std::set subsetHashes; each_subset(AttribSet{}, attributes.cbegin(), attributes.cend(), [&](auto beg, auto end) { if (beg != end) { - std::vector subset(beg, end); + std::vector subset(beg, end); std::optional firstHash; do { const auto hash = util::order_independent_hash(subset.begin(), subset.end());