tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add attribute buffer index to support multiple attributes interleaved in single buffer bind [Core optimization] (#4241)

Browse Source 
Co-authored-by: Adrian Cojocaru <adrian.cojocaru92@yahoo.com>
This commit is contained in:
Alex Cristici
2026-04-28 19:00:37 +03:00
committed by GitHub
parent 29f90974f0
commit 86eff40b65
50 changed files with 388 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
include/mbgl/mtl/vertex_attribute.hpp
View File

@@ -17,13 +17,23 @@ public:
: gfx::VertexAttribute(index_, dataType_, count_) {}
VertexAttribute(const VertexAttribute& other) = delete;
VertexAttribute(VertexAttribute&& other)
: gfx::VertexAttribute(std::move(other)) {}
: gfx::VertexAttribute(std::move(other)),
bufferIndex(other.bufferIndex) {}
~VertexAttribute() override = default;
/// @brief Get the bufer index of the vertex attribute
int getBufferIndex() const { return bufferIndex; }
/// @brief Set the buffer index of the vertex attribute
void setBufferIndex(int value) { bufferIndex = value; }
static const gfx::UniqueVertexBufferResource& getBuffer(gfx::VertexAttribute&,
UploadPass&,
const gfx::BufferUsageType,
bool forceUpdate);
protected:
int bufferIndex = 0;
};
/// Stores a collection of vertex attributes by name
@@ -39,6 +49,11 @@ public:
}
VertexAttributeArray& operator=(const VertexAttributeArray& other) = delete;
const std::unique_ptr<gfx::VertexAttribute>& set(const size_t id,
int index,
gfx::AttributeDataType type,
int bufferIndex);
/// Indicates whether any values have changed
bool isModifiedAfter(std::chrono::duration<double> time) const;

4
include/mbgl/shaders/mtl/background.hpp
View File

@@ -87,7 +87,7 @@ struct ShaderSource<BuiltIn::BackgroundShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(backgroundUBOCount + 0)]];
short2 position [[attribute(0)]];
};
struct FragmentStage {
@@ -130,7 +130,7 @@ struct ShaderSource<BuiltIn::BackgroundPatternShader, gfx::Backend::Type::Metal>
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(backgroundUBOCount + 0)]];
short2 position [[attribute(0)]];
};
struct FragmentStage {

16
include/mbgl/shaders/mtl/circle.hpp
View File

@@ -66,28 +66,28 @@ struct ShaderSource<BuiltIn::CircleShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(circleUBOCount + 0)]];
short2 position [[attribute(0)]];
#if !defined(HAS_UNIFORM_u_color)
float4 color [[attribute(circleUBOCount + 1)]];
float4 color [[attribute(1)]];
#endif
#if !defined(HAS_UNIFORM_u_radius)
float2 radius [[attribute(circleUBOCount + 2)]];
float2 radius [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_blur)
float2 blur [[attribute(circleUBOCount + 3)]];
float2 blur [[attribute(3)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(circleUBOCount + 4)]];
float2 opacity [[attribute(4)]];
#endif
#if !defined(HAS_UNIFORM_u_stroke_color)
float4 stroke_color [[attribute(circleUBOCount + 5)]];
float4 stroke_color [[attribute(5)]];
#endif
#if !defined(HAS_UNIFORM_u_stroke_width)
float2 stroke_width [[attribute(circleUBOCount + 6)]];
float2 stroke_width [[attribute(6)]];
#endif
#if !defined(HAS_UNIFORM_u_stroke_opacity)
float2 stroke_opacity [[attribute(circleUBOCount + 7)]];
float2 stroke_opacity [[attribute(7)]];
#endif
};

2
include/mbgl/shaders/mtl/clipping_mask.hpp
View File

@@ -49,7 +49,7 @@ struct ShaderSource<BuiltIn::ClippingMaskProgram, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(clippingMaskUBOCount + 0)]];
short2 position [[attribute(0)]];
};
struct FragmentStage {

18
include/mbgl/shaders/mtl/collision.hpp
View File

@@ -45,11 +45,11 @@ struct ShaderSource<BuiltIn::CollisionBoxShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(collisionUBOCount + 0)]];
short2 anchor_pos [[attribute(collisionUBOCount + 1)]];
short2 extrude [[attribute(collisionUBOCount + 2)]];
ushort2 placed [[attribute(collisionUBOCount + 3)]];
float2 shift [[attribute(collisionUBOCount + 4)]];
short2 pos [[attribute(0)]];
short2 anchor_pos [[attribute(1)]];
short2 extrude [[attribute(2)]];
ushort2 placed [[attribute(3)]];
float2 shift [[attribute(4)]];
};
struct FragmentStage {
@@ -119,10 +119,10 @@ struct ShaderSource<BuiltIn::CollisionCircleShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(collisionUBOCount + 0)]];
short2 anchor_pos [[attribute(collisionUBOCount + 1)]];
short2 extrude [[attribute(collisionUBOCount + 2)]];
ushort2 placed [[attribute(collisionUBOCount + 3)]];
short2 pos [[attribute(0)]];
short2 anchor_pos [[attribute(1)]];
short2 extrude [[attribute(2)]];
ushort2 placed [[attribute(3)]];
};
struct FragmentStage {

4
include/mbgl/shaders/mtl/color_relief.hpp
View File

@@ -56,8 +56,8 @@ struct ShaderSource<BuiltIn::ColorReliefShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(colorReliefUBOCount + 0)]];
short2 texture_pos [[attribute(colorReliefUBOCount + 1)]];
short2 pos [[attribute(0)]];
short2 texture_pos [[attribute(1)]];
};
struct FragmentStage {

4
include/mbgl/shaders/mtl/custom_geometry.hpp
View File

@@ -37,8 +37,8 @@ struct ShaderSource<BuiltIn::CustomGeometryShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
float3 position [[attribute(customGeometryUBOCount + 0)]];
float2 uv [[attribute(customGeometryUBOCount + 1)]];
float3 position [[attribute(0)]];
float2 uv [[attribute(1)]];
};
struct FragmentStage {

4
include/mbgl/shaders/mtl/custom_symbol_icon.hpp
View File

@@ -46,8 +46,8 @@ struct ShaderSource<BuiltIn::CustomSymbolIconShader, gfx::Backend::Type::Metal>
static constexpr auto source = R"(
struct VertexStage {
float2 a_pos [[attribute(customSymbolUBOCount + 0)]];
float2 a_tex [[attribute(customSymbolUBOCount + 1)]];
float2 a_pos [[attribute(0)]];
float2 a_tex [[attribute(1)]];
};
struct FragmentStage {

2
include/mbgl/shaders/mtl/debug.hpp
View File

@@ -41,7 +41,7 @@ struct ShaderSource<BuiltIn::DebugShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(debugUBOCount + 0)]];
short2 pos [[attribute(0)]];
};
struct FragmentStage {

32
include/mbgl/shaders/mtl/fill.hpp
View File

@@ -154,13 +154,13 @@ struct ShaderSource<BuiltIn::FillShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(fillUBOCount + 0)]];
short2 position [[attribute(0)]];
#if !defined(HAS_UNIFORM_u_color)
float4 color [[attribute(fillUBOCount + 1)]];
float4 color [[attribute(1)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(fillUBOCount + 2)]];
float2 opacity [[attribute(2)]];
#endif
};
@@ -229,9 +229,9 @@ struct ShaderSource<BuiltIn::FillOutlineShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(fillUBOCount + 0)]];
float4 outline_color [[attribute(fillUBOCount + 1)]];
float2 opacity [[attribute(fillUBOCount + 2)]];
short2 position [[attribute(0)]];
float4 outline_color [[attribute(1)]];
float2 opacity [[attribute(2)]];
};
struct FragmentStage {
@@ -308,16 +308,16 @@ struct ShaderSource<BuiltIn::FillPatternShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(fillUBOCount + 0)]];
short2 position [[attribute(0)]];
#if !defined(HAS_UNIFORM_u_pattern_from)
ushort4 pattern_from [[attribute(fillUBOCount + 1)]];
ushort4 pattern_from [[attribute(1)]];
#endif
#if !defined(HAS_UNIFORM_u_pattern_to)
ushort4 pattern_to [[attribute(fillUBOCount + 2)]];
ushort4 pattern_to [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(fillUBOCount + 3)]];
float2 opacity [[attribute(3)]];
#endif
};
@@ -451,16 +451,16 @@ struct ShaderSource<BuiltIn::FillOutlinePatternShader, gfx::Backend::Type::Metal
static constexpr auto source = R"(
struct VertexStage {
short2 position [[attribute(fillUBOCount + 0)]];
short2 position [[attribute(0)]];
#if !defined(HAS_UNIFORM_u_pattern_from)
ushort4 pattern_from [[attribute(fillUBOCount + 1)]];
ushort4 pattern_from [[attribute(1)]];
#endif
#if !defined(HAS_UNIFORM_u_pattern_to)
ushort4 pattern_to [[attribute(fillUBOCount + 2)]];
ushort4 pattern_to [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(fillUBOCount + 3)]];
float2 opacity [[attribute(3)]];
#endif
};
@@ -606,8 +606,8 @@ struct ShaderSource<BuiltIn::FillOutlineTriangulatedShader, gfx::Backend::Type::
static constexpr auto source = R"(
struct VertexStage {
short2 pos_normal [[attribute(fillUBOCount + 0)]];
uchar4 data [[attribute(fillUBOCount + 1)]];
short2 pos_normal [[attribute(0)]];
uchar4 data [[attribute(1)]];
};
struct FragmentStage {

22
include/mbgl/shaders/mtl/fill_extrusion.hpp
View File

@@ -77,17 +77,17 @@ struct ShaderSource<BuiltIn::FillExtrusionShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(fillExtrusionUBOCount + 0)]];
short4 normal_ed [[attribute(fillExtrusionUBOCount + 1)]];
short2 pos [[attribute(0)]];
short4 normal_ed [[attribute(1)]];
#if !defined(HAS_UNIFORM_u_color)
float4 color [[attribute(fillExtrusionUBOCount + 2)]];
float4 color [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_base)
float base [[attribute(fillExtrusionUBOCount + 3)]];
float base [[attribute(3)]];
#endif
#if !defined(HAS_UNIFORM_u_height)
float height [[attribute(fillExtrusionUBOCount + 4)]];
float height [[attribute(4)]];
#endif
};
@@ -198,20 +198,20 @@ struct ShaderSource<BuiltIn::FillExtrusionPatternShader, gfx::Backend::Type::Met
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(fillExtrusionUBOCount + 0)]];
short4 normal_ed [[attribute(fillExtrusionUBOCount + 1)]];
short2 pos [[attribute(0)]];
short4 normal_ed [[attribute(1)]];
#if !defined(HAS_UNIFORM_u_base)
float base [[attribute(fillExtrusionUBOCount + 2)]];
float base [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_height)
float height [[attribute(fillExtrusionUBOCount + 3)]];
float height [[attribute(3)]];
#endif
#if !defined(HAS_UNIFORM_u_pattern_from)
ushort4 pattern_from [[attribute(fillExtrusionUBOCount + 4)]];
ushort4 pattern_from [[attribute(4)]];
#endif
#if !defined(HAS_UNIFORM_u_pattern_to)
ushort4 pattern_to [[attribute(fillExtrusionUBOCount + 5)]];
ushort4 pattern_to [[attribute(5)]];
#endif
};

6
include/mbgl/shaders/mtl/heatmap.hpp
View File

@@ -53,13 +53,13 @@ struct ShaderSource<BuiltIn::HeatmapShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(heatmapUBOCount + 0)]];
short2 pos [[attribute(0)]];
#if !defined(HAS_UNIFORM_u_weight)
float2 weight [[attribute(heatmapUBOCount + 1)]];
float2 weight [[attribute(1)]];
#endif
#if !defined(HAS_UNIFORM_u_radius)
float2 radius [[attribute(heatmapUBOCount + 2)]];
float2 radius [[attribute(2)]];
#endif
};

2
include/mbgl/shaders/mtl/heatmap_texture.hpp
View File

@@ -40,7 +40,7 @@ struct ShaderSource<BuiltIn::HeatmapTextureShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(heatmapTextureUBOCount + 0)]];
short2 pos [[attribute(0)]];
};
struct FragmentStage {

4
include/mbgl/shaders/mtl/hillshade.hpp
View File

@@ -68,8 +68,8 @@ struct ShaderSource<BuiltIn::HillshadeShader, gfx::Backend::Type::Metal> {
#define BASIC 4
struct VertexStage {
short2 pos [[attribute(hillshadeUBOCount + 0)]];
short2 texture_pos [[attribute(hillshadeUBOCount + 1)]];
short2 pos [[attribute(0)]];
short2 texture_pos [[attribute(1)]];
};
struct FragmentStage {

4
include/mbgl/shaders/mtl/hillshade_prepare.hpp
View File

@@ -46,8 +46,8 @@ struct ShaderSource<BuiltIn::HillshadePrepareShader, gfx::Backend::Type::Metal>
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(hillshadePrepareUBOCount + 0)]];
short2 texture_pos [[attribute(hillshadePrepareUBOCount + 1)]];
short2 pos [[attribute(0)]];
short2 texture_pos [[attribute(1)]];
};
struct FragmentStage {

66
include/mbgl/shaders/mtl/line.hpp
View File

@@ -186,26 +186,26 @@ struct ShaderSource<BuiltIn::LineShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos_normal [[attribute(lineUBOCount + 0)]];
uchar4 data [[attribute(lineUBOCount + 1)]];
short2 pos_normal [[attribute(0)]];
uchar4 data [[attribute(1)]];
#if !defined(HAS_UNIFORM_u_color)
float4 color [[attribute(lineUBOCount + 2)]];
float4 color [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_blur)
float2 blur [[attribute(lineUBOCount + 3)]];
float2 blur [[attribute(3)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(lineUBOCount + 4)]];
float2 opacity [[attribute(4)]];
#endif
#if !defined(HAS_UNIFORM_u_gapwidth)
float2 gapwidth [[attribute(lineUBOCount + 5)]];
float2 gapwidth [[attribute(5)]];
#endif
#if !defined(HAS_UNIFORM_u_offset)
float2 offset [[attribute(lineUBOCount + 6)]];
float2 offset [[attribute(6)]];
#endif
#if !defined(HAS_UNIFORM_u_width)
float2 width [[attribute(lineUBOCount + 7)]];
float2 width [[attribute(7)]];
#endif
};
@@ -366,22 +366,22 @@ struct ShaderSource<BuiltIn::LineGradientShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos_normal [[attribute(lineUBOCount + 0)]];
uchar4 data [[attribute(lineUBOCount + 1)]];
short2 pos_normal [[attribute(0)]];
uchar4 data [[attribute(1)]];
#if !defined(HAS_UNIFORM_u_blur)
float2 blur [[attribute(lineUBOCount + 2)]];
float2 blur [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(lineUBOCount + 3)]];
float2 opacity [[attribute(3)]];
#endif
#if !defined(HAS_UNIFORM_u_gapwidth)
float2 gapwidth [[attribute(lineUBOCount + 4)]];
float2 gapwidth [[attribute(4)]];
#endif
#if !defined(HAS_UNIFORM_u_offset)
float2 offset [[attribute(lineUBOCount + 5)]];
float2 offset [[attribute(5)]];
#endif
#if !defined(HAS_UNIFORM_u_width)
float2 width [[attribute(lineUBOCount + 6)]];
float2 width [[attribute(6)]];
#endif
};
@@ -533,29 +533,29 @@ struct ShaderSource<BuiltIn::LinePatternShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos_normal [[attribute(lineUBOCount + 0)]];
uchar4 data [[attribute(lineUBOCount + 1)]];
short2 pos_normal [[attribute(0)]];
uchar4 data [[attribute(1)]];
#if !defined(HAS_UNIFORM_u_blur)
float2 blur [[attribute(lineUBOCount + 2)]];
float2 blur [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(lineUBOCount + 3)]];
float2 opacity [[attribute(3)]];
#endif
#if !defined(HAS_UNIFORM_u_gapwidth)
float2 gapwidth [[attribute(lineUBOCount + 4)]];
float2 gapwidth [[attribute(4)]];
#endif
#if !defined(HAS_UNIFORM_u_offset)
float2 offset [[attribute(lineUBOCount + 5)]];
float2 offset [[attribute(5)]];
#endif
#if !defined(HAS_UNIFORM_u_width)
float2 width [[attribute(lineUBOCount + 6)]];
float2 width [[attribute(6)]];
#endif
#if !defined(HAS_UNIFORM_u_pattern_from)
ushort4 pattern_from [[attribute(lineUBOCount + 7)]];
ushort4 pattern_from [[attribute(7)]];
#endif
#if !defined(HAS_UNIFORM_u_pattern_to)
ushort4 pattern_to [[attribute(lineUBOCount + 8)]];
ushort4 pattern_to [[attribute(8)]];
#endif
};
@@ -770,29 +770,29 @@ struct ShaderSource<BuiltIn::LineSDFShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos_normal [[attribute(lineUBOCount + 0)]];
uchar4 data [[attribute(lineUBOCount + 1)]];
short2 pos_normal [[attribute(0)]];
uchar4 data [[attribute(1)]];
#if !defined(HAS_UNIFORM_u_color)
float4 color [[attribute(lineUBOCount + 2)]];
float4 color [[attribute(2)]];
#endif
#if !defined(HAS_UNIFORM_u_blur)
float2 blur [[attribute(lineUBOCount + 3)]];
float2 blur [[attribute(3)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float2 opacity [[attribute(lineUBOCount + 4)]];
float2 opacity [[attribute(4)]];
#endif
#if !defined(HAS_UNIFORM_u_gapwidth)
float2 gapwidth [[attribute(lineUBOCount + 5)]];
float2 gapwidth [[attribute(5)]];
#endif
#if !defined(HAS_UNIFORM_u_offset)
float2 offset [[attribute(lineUBOCount + 6)]];
float2 offset [[attribute(6)]];
#endif
#if !defined(HAS_UNIFORM_u_width)
float2 width [[attribute(lineUBOCount + 7)]];
float2 width [[attribute(7)]];
#endif
#if !defined(HAS_UNIFORM_u_floorwidth)
float2 floorwidth [[attribute(lineUBOCount + 8)]];
float2 floorwidth [[attribute(8)]];
#endif
};

6
include/mbgl/shaders/mtl/location_indicator.hpp
View File

@@ -37,7 +37,7 @@ struct ShaderSource<BuiltIn::LocationIndicatorShader, gfx::Backend::Type::Metal>
static constexpr auto source = R"(
struct VertexStage {
float2 position [[attribute(locationIndicatorUBOCount + 0)]];
float2 position [[attribute(0)]];
};
struct FragmentStage {
@@ -73,8 +73,8 @@ struct ShaderSource<BuiltIn::LocationIndicatorTexturedShader, gfx::Backend::Type
static constexpr auto source = R"(
struct VertexStage {
float2 position [[attribute(locationIndicatorUBOCount + 0)]];
float2 uv [[attribute(locationIndicatorUBOCount + 1)]];
float2 position [[attribute(0)]];
float2 uv [[attribute(1)]];
};
struct FragmentStage {

4
include/mbgl/shaders/mtl/raster.hpp
View File

@@ -55,8 +55,8 @@ struct ShaderSource<BuiltIn::RasterShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
short2 pos [[attribute(rasterUBOCount + 0)]];
short2 texture_pos [[attribute(rasterUBOCount + 1)]];
short2 pos [[attribute(0)]];
short2 texture_pos [[attribute(1)]];
};
struct FragmentStage {

23
include/mbgl/shaders/mtl/shader_program.hpp
View File

@@ -12,28 +12,22 @@
namespace mbgl {
namespace shaders {
struct UniformBlockInfo {
constexpr UniformBlockInfo(bool vertex_, bool fragment_, std::size_t size_, std::size_t id_)
: index(id_),
vertex(vertex_),
fragment(fragment_),
size(size_),
id(id_) {}
std::size_t index;
bool vertex;
bool fragment;
std::size_t size;
std::size_t id;
};
struct AttributeInfo {
constexpr AttributeInfo(std::size_t index_, gfx::AttributeDataType dataType_, std::size_t id_)
constexpr AttributeInfo(std::size_t index_,
gfx::AttributeDataType dataType_,
std::size_t bufferIndex_,
std::size_t id_)
: index(index_),
dataType(dataType_),
bufferIndex(bufferIndex_),
id(id_) {}
std::size_t index;
gfx::AttributeDataType dataType;
std::size_t bufferIndex;
std::size_t id;
};
struct TextureInfo {
constexpr TextureInfo(std::size_t index_, std::size_t id_)
: index(index_),
@@ -41,6 +35,7 @@ struct TextureInfo {
std::size_t index;
std::size_t id;
};
} // namespace shaders
namespace mtl {
class RenderableResource;

50
include/mbgl/shaders/mtl/symbol.hpp
View File

@@ -89,14 +89,14 @@ struct ShaderSource<BuiltIn::SymbolIconShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
float4 pos_offset [[attribute(symbolUBOCount + 0)]];
float4 data [[attribute(symbolUBOCount + 1)]];
float4 pixeloffset [[attribute(symbolUBOCount + 2)]];
float3 projected_pos [[attribute(symbolUBOCount + 3)]];
float fade_opacity [[attribute(symbolUBOCount + 4)]];
float4 pos_offset [[attribute(0)]];
float4 data [[attribute(1)]];
float4 pixeloffset [[attribute(2)]];
float3 projected_pos [[attribute(3)]];
float fade_opacity [[attribute(4)]];
#if !defined(HAS_UNIFORM_u_opacity)
float opacity [[attribute(symbolUBOCount + 5)]];
float opacity [[attribute(5)]];
#endif
};
@@ -245,26 +245,26 @@ struct ShaderSource<BuiltIn::SymbolSDFShader, gfx::Backend::Type::Metal> {
static constexpr auto source = R"(
struct VertexStage {
float4 pos_offset [[attribute(symbolUBOCount + 0)]];
float4 data [[attribute(symbolUBOCount + 1)]];
float4 pixeloffset [[attribute(symbolUBOCount + 2)]];
float3 projected_pos [[attribute(symbolUBOCount + 3)]];
float fade_opacity [[attribute(symbolUBOCount + 4)]];
float4 pos_offset [[attribute(0)]];
float4 data [[attribute(1)]];
float4 pixeloffset [[attribute(2)]];
float3 projected_pos [[attribute(3)]];
float fade_opacity [[attribute(4)]];
#if !defined(HAS_UNIFORM_u_fill_color)
float4 fill_color [[attribute(symbolUBOCount + 5)]];
float4 fill_color [[attribute(5)]];
#endif
#if !defined(HAS_UNIFORM_u_halo_color)
float4 halo_color [[attribute(symbolUBOCount + 6)]];
float4 halo_color [[attribute(6)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float opacity [[attribute(symbolUBOCount + 7)]];
float opacity [[attribute(7)]];
#endif
#if !defined(HAS_UNIFORM_u_halo_width)
float halo_width [[attribute(symbolUBOCount + 8)]];
float halo_width [[attribute(8)]];
#endif
#if !defined(HAS_UNIFORM_u_halo_blur)
float halo_blur [[attribute(symbolUBOCount + 9)]];
float halo_blur [[attribute(9)]];
#endif
};
@@ -481,25 +481,25 @@ struct ShaderSource<BuiltIn::SymbolTextAndIconShader, gfx::Backend::Type::Metal>
#define ICON 0.0
struct VertexStage {
float4 pos_offset [[attribute(symbolUBOCount + 0)]];
float4 data [[attribute(symbolUBOCount + 1)]];
float3 projected_pos [[attribute(symbolUBOCount + 2)]];
float fade_opacity [[attribute(symbolUBOCount + 3)]];
float4 pos_offset [[attribute(0)]];
float4 data [[attribute(1)]];
float3 projected_pos [[attribute(2)]];
float fade_opacity [[attribute(3)]];
#if !defined(HAS_UNIFORM_u_fill_color)
float4 fill_color [[attribute(symbolUBOCount + 4)]];
float4 fill_color [[attribute(4)]];
#endif
#if !defined(HAS_UNIFORM_u_halo_color)
float4 halo_color [[attribute(symbolUBOCount + 5)]];
float4 halo_color [[attribute(5)]];
#endif
#if !defined(HAS_UNIFORM_u_opacity)
float opacity [[attribute(symbolUBOCount + 6)]];
float opacity [[attribute(6)]];
#endif
#if !defined(HAS_UNIFORM_u_halo_width)
float halo_width [[attribute(symbolUBOCount + 7)]];
float halo_width [[attribute(7)]];
#endif
#if !defined(HAS_UNIFORM_u_halo_blur)
float halo_blur [[attribute(symbolUBOCount + 8)]];
float halo_blur [[attribute(8)]];
#endif
};

8
include/mbgl/shaders/mtl/widevector.hpp
View File

@@ -110,9 +110,9 @@ typedef struct
struct VertexTriWideVecB
{
// x, y offset around the center
float3 screenPos [[attribute(wideVectorUBOCount + 0)]];
float4 color [[attribute(wideVectorUBOCount + 1)]];
int index [[attribute(wideVectorUBOCount + 2)]];
float3 screenPos [[attribute(0)]];
float4 color [[attribute(1)]];
int index [[attribute(2)]];
};
// Wide vector vertex passed to fragment shader (new version)
@@ -222,7 +222,7 @@ vertex ProjVertexTriWideVecPerf vertexTri_wideVecPerf(
constant Uniforms &uniforms [[ buffer(idWideVectorUniformsUBO) ]],
constant UniformWideVec &wideVec [[ buffer(idWideVectorUniformWideVecUBO) ]],
uint instanceID [[ instance_id ]],
constant VertexTriWideVecInstance *wideVecInsts [[ buffer(wideVectorUBOCount + 3) ]])
constant VertexTriWideVecInstance *wideVecInsts [[ buffer(wideVectorUBOCount + 1) ]])
{
ProjVertexTriWideVecPerf outVert = {
.position = discardPt,

5
src/mbgl/gfx/attribute.hpp
View File

@@ -119,10 +119,12 @@ public:
uint32_t vertexStride;
const VertexBufferResource* vertexBufferResource;
uint32_t vertexOffset;
uint32_t bufferIndex;
friend bool operator==(const AttributeBinding& lhs, const AttributeBinding& rhs) {
return lhs.attribute == rhs.attribute && lhs.vertexStride == rhs.vertexStride &&
lhs.vertexBufferResource == rhs.vertexBufferResource && lhs.vertexOffset == rhs.vertexOffset;
lhs.vertexBufferResource == rhs.vertexBufferResource && lhs.vertexOffset == rhs.vertexOffset &&
lhs.bufferIndex == rhs.bufferIndex;
}
bool operator!=(const AttributeBinding& rhs) const { return !(*this == rhs); }
@@ -293,6 +295,7 @@ AttributeBinding attributeBinding(const VertexBuffer<detail::VertexType<As...>>&
Descriptor::data.stride,
&buffer.getResource(),
0,
0,
};
}

3
src/mbgl/gl/upload_pass.cpp
View File

@@ -167,6 +167,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/* vertexStride = */ vertexStride,
/* vertexBufferResource = */ nullptr, // buffer details established later
/* vertexOffset = */ 0,
/*.bufferIndex = */ 0,
};
}
@@ -187,6 +188,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ effectiveAttr.getSharedStride(),
/*.vertexBufferResource = */ buffer.get(),
/*.vertexOffset = */ effectiveAttr.getSharedVertexOffset(),
/*.bufferIndex = */ 0,
};
return;
}
@@ -230,6 +232,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/* vertexStride = */ static_cast<uint32_t>(stride),
/* vertexBufferResource = */ nullptr, // buffer details established later
/* vertexOffset = */ 0,
/*.bufferIndex = */ 0,
};
pad(allData, align, padding);

13
src/mbgl/mtl/context.cpp
View File

@@ -366,20 +366,19 @@ bool Context::renderTileClippingMasks(gfx::RenderPass& renderPass,
if (!clipMaskPipelineState) {
// A vertex descriptor tells Metal what's in the vertex buffer
auto vertDesc = NS::RetainPtr(MTL::VertexDescriptor::vertexDescriptor());
auto attribDesc = NS::TransferPtr(MTL::VertexAttributeDescriptor::alloc()->init());
auto layoutDesc = NS::TransferPtr(MTL::VertexBufferLayoutDescriptor::alloc()->init());
if (!vertDesc || !attribDesc || !layoutDesc) {
if (!vertDesc) {
return false;
}
attribDesc->setBufferIndex(ShaderClass::attributes[0].index);
const auto& attribDesc = vertDesc->attributes()->object(ShaderClass::attributes[0].index);
attribDesc->setBufferIndex(ShaderClass::attributes[0].bufferIndex);
attribDesc->setOffset(0);
attribDesc->setFormat(MTL::VertexFormatShort2);
const auto& layoutDesc = vertDesc->layouts()->object(ShaderClass::attributes[0].bufferIndex);
layoutDesc->setStride(static_cast<NS::UInteger>(vertexSize));
layoutDesc->setStepFunction(MTL::VertexStepFunctionPerVertex);
layoutDesc->setStepRate(1);
vertDesc->attributes()->setObject(attribDesc.get(), ShaderClass::attributes[0].index);
vertDesc->layouts()->setObject(layoutDesc.get(), ShaderClass::attributes[0].index);
// Create a render pipeline state, telling Metal how to render the primitives
const std::size_t hash = mbgl::util::hash(ShaderClass::attributes[0].index,
@@ -422,7 +421,7 @@ bool Context::renderTileClippingMasks(gfx::RenderPass& renderPass,
mtlRenderPass.setCullMode(MTL::CullModeNone);
mtlRenderPass.bindVertex(vertexRes, /*offset=*/0, ShaderClass::attributes[0].index);
mtlRenderPass.bindVertex(vertexRes, /*offset=*/0, ShaderClass::attributes[0].bufferIndex);
// Instancing is disabled for now because the `[[stencil]]` attribute in the fragment shader output
// that we need to apply a different stencil value for each tile causes a problem on some older (A8-A11)

32
src/mbgl/mtl/drawable.cpp
View File

@@ -398,28 +398,24 @@ void Drawable::setVertexAttrId(const size_t id) {
}
void Drawable::bindAttributes(RenderPass& renderPass) const {
NS::UInteger attributeIndex = 0;
for (const auto& binding : impl->attributeBindings) {
const auto* buffer = static_cast<const mtl::VertexBufferResource*>(binding ? binding->vertexBufferResource
: nullptr);
if (buffer && buffer->get()) {
assert(binding->vertexStride * impl->vertexCount <= getBufferSize(binding->vertexBufferResource));
renderPass.bindVertex(buffer->get(), /*offset=*/0, attributeIndex);
renderPass.bindVertex(buffer->get(), /*offset=*/0, binding->bufferIndex);
}
attributeIndex += 1;
}
}
void Drawable::bindInstanceAttributes(RenderPass& renderPass) const {
NS::UInteger attributeIndex = 0;
for (const auto& binding : impl->instanceBindings) {
if (binding.has_value()) {
const auto* buffer = static_cast<const mtl::VertexBufferResource*>(binding->vertexBufferResource);
if (buffer && buffer->get()) {
renderPass.bindVertex(buffer->get(), /*offset=*/0, attributeIndex);
renderPass.bindVertex(buffer->get(), /*offset=*/0, binding->bufferIndex);
}
}
attributeIndex += 1;
}
}
@@ -602,20 +598,22 @@ void Drawable::upload(gfx::UploadPass& uploadPass_) {
}
}
auto attribDesc = NS::TransferPtr(MTL::VertexAttributeDescriptor::alloc()->init());
attribDesc->setBufferIndex(index);
const auto& attribDesc = vertDesc->attributes()->object(index);
attribDesc->setBufferIndex(binding->bufferIndex);
attribDesc->setOffset(static_cast<NS::UInteger>(binding->attribute.offset));
attribDesc->setFormat(mtlVertexTypeOf(binding->attribute.dataType));
assert(binding->vertexStride > 0);
auto layoutDesc = NS::TransferPtr(MTL::VertexBufferLayoutDescriptor::alloc()->init());
layoutDesc->setStride(static_cast<NS::UInteger>(binding->vertexStride));
layoutDesc->setStepFunction(binding->vertexBufferResource ? MTL::VertexStepFunctionPerVertex
: MTL::VertexStepFunctionConstant);
layoutDesc->setStepRate(binding->vertexBufferResource ? 1 : 0);
vertDesc->attributes()->setObject(attribDesc.get(), index);
vertDesc->layouts()->setObject(layoutDesc.get(), index);
const auto& layoutDesc = vertDesc->layouts()->object(binding->bufferIndex);
if (!layoutDesc->stride()) {
assert(binding->vertexStride > 0);
layoutDesc->setStride(static_cast<NS::UInteger>(binding->vertexStride));
layoutDesc->setStepFunction(binding->vertexBufferResource ? MTL::VertexStepFunctionPerVertex
: MTL::VertexStepFunctionConstant);
layoutDesc->setStepRate(binding->vertexBufferResource ? 1 : 0);
} else {
assert(layoutDesc->stride() == static_cast<NS::UInteger>(binding->vertexStride));
assert(layoutDesc->stepRate() == (binding->vertexBufferResource ? 1 : 0));
}
mbgl::util::hash_combine(hash,
mbgl::util::hash(index,

4
src/mbgl/mtl/upload_pass.cpp
View File

@@ -142,6 +142,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
auto& effectiveAttr = override_ ? *override_ : default_;
const auto& defaultAttr = static_cast<const VertexAttribute&>(default_);
const auto index = static_cast<std::size_t>(defaultAttr.getIndex());
const auto bufferIndex = static_cast<uint32_t>(defaultAttr.getBufferIndex());
bindings.resize(std::max(bindings.size(), index + 1));
@@ -154,6 +155,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
.vertexStride = static_cast<uint32_t>(VertexAttribute::getStrideOf(defaultAttr.getDataType())),
.vertexBufferResource = nullptr,
.vertexOffset = 0,
.bufferIndex = bufferIndex,
};
return;
}
@@ -168,6 +170,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ effectiveAttr.getSharedStride(),
/*.vertexBufferResource = */ buffer_.get(),
/*.vertexOffset = */ effectiveAttr.getSharedVertexOffset(),
/*.bufferIndex = */ bufferIndex,
};
return;
}
@@ -182,6 +185,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ static_cast<uint32_t>(effectiveAttr.getStride()),
/*.vertexBufferResource = */ buffer_.get(),
/*.vertexOffset = */ 0,
/*.bufferIndex = */ bufferIndex,
};
return;
}

11
src/mbgl/mtl/vertex_attribute.cpp
View File

@@ -35,5 +35,16 @@ const gfx::UniqueVertexBufferResource& VertexAttribute::getBuffer(gfx::VertexAtt
return attrib_.getBuffer();
}
const std::unique_ptr<gfx::VertexAttribute>& VertexAttributeArray::set(const size_t id,
int index,
gfx::AttributeDataType dataType,
int bufferIndex) {
auto& attrib = gfx::VertexAttributeArray::set(id, index, dataType, 1);
if (attrib) {
static_cast<VertexAttribute*>(attrib.get())->setBufferIndex(bufferIndex);
}
return attrib;
}
} // namespace mtl
} // namespace mbgl

4
src/mbgl/shaders/mtl/background.cpp
View File

@@ -10,7 +10,7 @@ namespace shaders {
using BackgroundShaderSource = ShaderSource<BuiltIn::BackgroundShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 1> BackgroundShaderSource::attributes = {
AttributeInfo{backgroundUBOCount + 0, gfx::AttributeDataType::Float3, idBackgroundPosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Float3, backgroundUBOCount + 0, idBackgroundPosVertexAttribute},
};
const std::array<TextureInfo, 0> BackgroundShaderSource::textures = {};
@@ -20,7 +20,7 @@ const std::array<TextureInfo, 0> BackgroundShaderSource::textures = {};
using BackgroundPatternShaderSource = ShaderSource<BuiltIn::BackgroundPatternShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 1> BackgroundPatternShaderSource::attributes = {
AttributeInfo{backgroundUBOCount + 0, gfx::AttributeDataType::Float3, idBackgroundPosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Float3, backgroundUBOCount + 0, idBackgroundPosVertexAttribute},
};
const std::array<TextureInfo, 1> BackgroundPatternShaderSource::textures = {TextureInfo{0, idBackgroundImageTexture}};

18
src/mbgl/shaders/mtl/circle.cpp
View File

@@ -7,14 +7,16 @@ namespace shaders {
using CircleShaderSource = ShaderSource<BuiltIn::CircleShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 8> CircleShaderSource::attributes = {
AttributeInfo{circleUBOCount + 0, gfx::AttributeDataType::Short2, idCirclePosVertexAttribute},
AttributeInfo{circleUBOCount + 1, gfx::AttributeDataType::Float4, idCircleColorVertexAttribute},
AttributeInfo{circleUBOCount + 2, gfx::AttributeDataType::Float2, idCircleRadiusVertexAttribute},
AttributeInfo{circleUBOCount + 3, gfx::AttributeDataType::Float2, idCircleBlurVertexAttribute},
AttributeInfo{circleUBOCount + 4, gfx::AttributeDataType::Float2, idCircleOpacityVertexAttribute},
AttributeInfo{circleUBOCount + 5, gfx::AttributeDataType::Float4, idCircleStrokeColorVertexAttribute},
AttributeInfo{circleUBOCount + 6, gfx::AttributeDataType::Float2, idCircleStrokeWidthVertexAttribute},
AttributeInfo{circleUBOCount + 7, gfx::AttributeDataType::Float2, idCircleStrokeOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, circleUBOCount + 0, idCirclePosVertexAttribute},
// Data driven
AttributeInfo{1, gfx::AttributeDataType::Float4, circleUBOCount + 1, idCircleColorVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Float2, circleUBOCount + 1, idCircleRadiusVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float2, circleUBOCount + 1, idCircleBlurVertexAttribute},
AttributeInfo{4, gfx::AttributeDataType::Float2, circleUBOCount + 1, idCircleOpacityVertexAttribute},
AttributeInfo{5, gfx::AttributeDataType::Float4, circleUBOCount + 1, idCircleStrokeColorVertexAttribute},
AttributeInfo{6, gfx::AttributeDataType::Float2, circleUBOCount + 1, idCircleStrokeWidthVertexAttribute},
AttributeInfo{7, gfx::AttributeDataType::Float2, circleUBOCount + 1, idCircleStrokeOpacityVertexAttribute},
};
const std::array<TextureInfo, 0> CircleShaderSource::textures = {};

2
src/mbgl/shaders/mtl/clipping_mask.cpp
View File

@@ -6,7 +6,7 @@ namespace shaders {
using ClippingMaskShaderSource = ShaderSource<BuiltIn::ClippingMaskProgram, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 1> ClippingMaskShaderSource::attributes = {
AttributeInfo{clippingMaskUBOCount + 0, gfx::AttributeDataType::Float3, idClippingMaskPosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Float3, clippingMaskUBOCount + 0, idClippingMaskPosVertexAttribute},
};
const std::array<TextureInfo, 0> ClippingMaskShaderSource::textures = {};

22
src/mbgl/shaders/mtl/collision.cpp
View File

@@ -10,11 +10,13 @@ namespace shaders {
using CollisionBoxShaderSource = ShaderSource<BuiltIn::CollisionBoxShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 5> CollisionBoxShaderSource::attributes = {
AttributeInfo{collisionUBOCount + 0, gfx::AttributeDataType::Short2, idCollisionPosVertexAttribute},
AttributeInfo{collisionUBOCount + 1, gfx::AttributeDataType::Short2, idCollisionAnchorPosVertexAttribute},
AttributeInfo{collisionUBOCount + 2, gfx::AttributeDataType::Short2, idCollisionExtrudeVertexAttribute},
AttributeInfo{collisionUBOCount + 3, gfx::AttributeDataType::UShort2, idCollisionPlacedVertexAttribute},
AttributeInfo{collisionUBOCount + 4, gfx::AttributeDataType::Float2, idCollisionShiftVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, collisionUBOCount + 0, idCollisionPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Short2, collisionUBOCount + 0, idCollisionAnchorPosVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Short2, collisionUBOCount + 0, idCollisionExtrudeVertexAttribute},
// Dynamic
AttributeInfo{3, gfx::AttributeDataType::UShort2, collisionUBOCount + 1, idCollisionPlacedVertexAttribute},
AttributeInfo{4, gfx::AttributeDataType::Float2, collisionUBOCount + 1, idCollisionShiftVertexAttribute},
};
const std::array<TextureInfo, 0> CollisionBoxShaderSource::textures = {};
@@ -24,10 +26,12 @@ const std::array<TextureInfo, 0> CollisionBoxShaderSource::textures = {};
using CollisionCircleShaderSource = ShaderSource<BuiltIn::CollisionCircleShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 4> CollisionCircleShaderSource::attributes = {
AttributeInfo{collisionUBOCount + 0, gfx::AttributeDataType::Short2, idCollisionPosVertexAttribute},
AttributeInfo{collisionUBOCount + 1, gfx::AttributeDataType::Short2, idCollisionAnchorPosVertexAttribute},
AttributeInfo{collisionUBOCount + 2, gfx::AttributeDataType::Short2, idCollisionExtrudeVertexAttribute},
AttributeInfo{collisionUBOCount + 3, gfx::AttributeDataType::UShort2, idCollisionPlacedVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, collisionUBOCount + 0, idCollisionPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Short2, collisionUBOCount + 0, idCollisionAnchorPosVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Short2, collisionUBOCount + 0, idCollisionExtrudeVertexAttribute},
// Dynamic
AttributeInfo{3, gfx::AttributeDataType::UShort2, collisionUBOCount + 1, idCollisionPlacedVertexAttribute},
};
const std::array<TextureInfo, 0> CollisionCircleShaderSource::textures = {};

4
src/mbgl/shaders/mtl/color_relief.cpp
View File

@@ -8,8 +8,8 @@ namespace shaders {
using ColorReliefShaderSource = ShaderSource<BuiltIn::ColorReliefShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> ColorReliefShaderSource::attributes = {
AttributeInfo{colorReliefUBOCount + 0, gfx::AttributeDataType::Short2, idColorReliefPosVertexAttribute},
AttributeInfo{colorReliefUBOCount + 1, gfx::AttributeDataType::Short2, idColorReliefTexturePosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, colorReliefUBOCount + 0, idColorReliefPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Short2, colorReliefUBOCount + 0, idColorReliefTexturePosVertexAttribute},
};
const std::array<TextureInfo, 3> ColorReliefShaderSource::textures = {
TextureInfo{0, idColorReliefImageTexture},

4
src/mbgl/shaders/mtl/custom_geometry.cpp
View File

@@ -7,8 +7,8 @@ namespace shaders {
using CustomGeometryShaderSource = ShaderSource<BuiltIn::CustomGeometryShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> CustomGeometryShaderSource::attributes = {
AttributeInfo{customGeometryUBOCount + 0, gfx::AttributeDataType::Float3, idCustomGeometryPosVertexAttribute},
AttributeInfo{customGeometryUBOCount + 1, gfx::AttributeDataType::Float2, idCustomGeometryTexVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Float3, customGeometryUBOCount + 0, idCustomGeometryPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Float2, customGeometryUBOCount + 0, idCustomGeometryTexVertexAttribute},
};
const std::array<TextureInfo, 1> CustomGeometryShaderSource::textures = {TextureInfo{0, idCustomGeometryTexture}};

4
src/mbgl/shaders/mtl/custom_symbol_icon.cpp
View File

@@ -7,8 +7,8 @@ namespace shaders {
using CustomSymbolIconShaderSource = ShaderSource<BuiltIn::CustomSymbolIconShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> CustomSymbolIconShaderSource::attributes = {
AttributeInfo{customSymbolUBOCount + 0, gfx::AttributeDataType::Float2, idCustomSymbolPosVertexAttribute},
AttributeInfo{customSymbolUBOCount + 1, gfx::AttributeDataType::Float2, idCustomSymbolTexVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Float2, customSymbolUBOCount + 0, idCustomSymbolPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Float2, customSymbolUBOCount + 0, idCustomSymbolTexVertexAttribute},
};
const std::array<TextureInfo, 1> CustomSymbolIconShaderSource::textures = {
TextureInfo{0, idCustomSymbolImageTexture},

2
src/mbgl/shaders/mtl/debug.cpp
View File

@@ -7,7 +7,7 @@ namespace shaders {
using DebugShaderSource = ShaderSource<BuiltIn::DebugShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 1> DebugShaderSource::attributes = {
AttributeInfo{debugUBOCount + 0, gfx::AttributeDataType::Short2, idDebugPosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, debugUBOCount + 0, idDebugPosVertexAttribute},
};
const std::array<TextureInfo, 1> DebugShaderSource::textures = {
TextureInfo{0, idDebugOverlayTexture},

40
src/mbgl/shaders/mtl/fill.cpp
View File

@@ -10,9 +10,11 @@ namespace shaders {
using FillShaderSource = ShaderSource<BuiltIn::FillShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 3> FillShaderSource::attributes = {
AttributeInfo{fillUBOCount + 0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute},
AttributeInfo{fillUBOCount + 1, gfx::AttributeDataType::Float4, idFillColorVertexAttribute},
AttributeInfo{fillUBOCount + 2, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, fillUBOCount + 0, idFillPosVertexAttribute},
// Data driven
AttributeInfo{1, gfx::AttributeDataType::Float4, fillUBOCount + 1, idFillColorVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Float2, fillUBOCount + 1, idFillOpacityVertexAttribute},
};
const std::array<TextureInfo, 0> FillShaderSource::textures = {};
@@ -22,9 +24,11 @@ const std::array<TextureInfo, 0> FillShaderSource::textures = {};
using FillOutlineShaderSource = ShaderSource<BuiltIn::FillOutlineShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 3> FillOutlineShaderSource::attributes = {
AttributeInfo{fillUBOCount + 0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute},
AttributeInfo{fillUBOCount + 1, gfx::AttributeDataType::Float4, idFillOutlineColorVertexAttribute},
AttributeInfo{fillUBOCount + 2, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, fillUBOCount + 0, idFillPosVertexAttribute},
// Data driven
AttributeInfo{1, gfx::AttributeDataType::Float4, fillUBOCount + 1, idFillOutlineColorVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Float2, fillUBOCount + 1, idFillOpacityVertexAttribute},
};
const std::array<TextureInfo, 0> FillOutlineShaderSource::textures = {};
@@ -34,10 +38,12 @@ const std::array<TextureInfo, 0> FillOutlineShaderSource::textures = {};
using FillPatternShaderSource = ShaderSource<BuiltIn::FillPatternShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 4> FillPatternShaderSource::attributes = {
AttributeInfo{fillUBOCount + 0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute},
AttributeInfo{fillUBOCount + 1, gfx::AttributeDataType::UShort4, idFillPatternFromVertexAttribute},
AttributeInfo{fillUBOCount + 2, gfx::AttributeDataType::UShort4, idFillPatternToVertexAttribute},
AttributeInfo{fillUBOCount + 3, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, fillUBOCount + 0, idFillPosVertexAttribute},
// Data driven
AttributeInfo{1, gfx::AttributeDataType::UShort4, fillUBOCount + 1, idFillPatternFromVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::UShort4, fillUBOCount + 1, idFillPatternToVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float2, fillUBOCount + 1, idFillOpacityVertexAttribute},
};
const std::array<TextureInfo, 1> FillPatternShaderSource::textures = {
TextureInfo{0, idFillImageTexture},
@@ -49,10 +55,12 @@ const std::array<TextureInfo, 1> FillPatternShaderSource::textures = {
using FillOutlinePatternShaderSource = ShaderSource<BuiltIn::FillOutlinePatternShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 4> FillOutlinePatternShaderSource::attributes = {
AttributeInfo{fillUBOCount + 0, gfx::AttributeDataType::Short2, idFillPosVertexAttribute},
AttributeInfo{fillUBOCount + 1, gfx::AttributeDataType::UShort4, idFillPatternFromVertexAttribute},
AttributeInfo{fillUBOCount + 2, gfx::AttributeDataType::UShort4, idFillPatternToVertexAttribute},
AttributeInfo{fillUBOCount + 3, gfx::AttributeDataType::Float2, idFillOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, fillUBOCount + 0, idFillPosVertexAttribute},
// Data driven
AttributeInfo{1, gfx::AttributeDataType::UShort4, fillUBOCount + 1, idFillPatternFromVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::UShort4, fillUBOCount + 1, idFillPatternToVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float2, fillUBOCount + 1, idFillOpacityVertexAttribute},
};
const std::array<TextureInfo, 1> FillOutlinePatternShaderSource::textures = {
TextureInfo{0, idFillImageTexture},
@@ -65,8 +73,8 @@ using FillOutlineTriangulatedShaderSource =
ShaderSource<BuiltIn::FillOutlineTriangulatedShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> FillOutlineTriangulatedShaderSource::attributes = {
AttributeInfo{fillUBOCount + 0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute},
AttributeInfo{fillUBOCount + 1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, fillUBOCount + 0, idLinePosNormalVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UByte4, fillUBOCount + 0, idLineDataVertexAttribute},
};
const std::array<TextureInfo, 0> FillOutlineTriangulatedShaderSource::textures = {};

27
src/mbgl/shaders/mtl/fill_extrusion.cpp
View File

@@ -10,11 +10,13 @@ namespace shaders {
using FillExtrusionShaderSource = ShaderSource<BuiltIn::FillExtrusionShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 5> FillExtrusionShaderSource::attributes = {
AttributeInfo{fillExtrusionUBOCount + 0, gfx::AttributeDataType::Short2, idFillExtrusionPosVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 1, gfx::AttributeDataType::Short4, idFillExtrusionNormalEdVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 2, gfx::AttributeDataType::Float4, idFillExtrusionColorVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 3, gfx::AttributeDataType::Float, idFillExtrusionBaseVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 4, gfx::AttributeDataType::Float, idFillExtrusionHeightVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, fillExtrusionUBOCount + 0, idFillExtrusionPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Short4, fillExtrusionUBOCount + 0, idFillExtrusionNormalEdVertexAttribute},
// Data driven
AttributeInfo{2, gfx::AttributeDataType::Float4, fillExtrusionUBOCount + 1, idFillExtrusionColorVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float, fillExtrusionUBOCount + 1, idFillExtrusionBaseVertexAttribute},
AttributeInfo{4, gfx::AttributeDataType::Float, fillExtrusionUBOCount + 1, idFillExtrusionHeightVertexAttribute},
};
const std::array<TextureInfo, 0> FillExtrusionShaderSource::textures = {};
@@ -24,13 +26,16 @@ const std::array<TextureInfo, 0> FillExtrusionShaderSource::textures = {};
using FillExtrusionPatternShaderSource = ShaderSource<BuiltIn::FillExtrusionPatternShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 6> FillExtrusionPatternShaderSource::attributes = {
AttributeInfo{fillExtrusionUBOCount + 0, gfx::AttributeDataType::Short2, idFillExtrusionPosVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 1, gfx::AttributeDataType::Short4, idFillExtrusionNormalEdVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 2, gfx::AttributeDataType::Float, idFillExtrusionBaseVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 3, gfx::AttributeDataType::Float, idFillExtrusionHeightVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, fillExtrusionUBOCount + 0, idFillExtrusionPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Short4, fillExtrusionUBOCount + 0, idFillExtrusionNormalEdVertexAttribute},
// Data driven
AttributeInfo{2, gfx::AttributeDataType::Float, fillExtrusionUBOCount + 1, idFillExtrusionBaseVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float, fillExtrusionUBOCount + 1, idFillExtrusionHeightVertexAttribute},
AttributeInfo{
fillExtrusionUBOCount + 4, gfx::AttributeDataType::UShort4, idFillExtrusionPatternFromVertexAttribute},
AttributeInfo{fillExtrusionUBOCount + 5, gfx::AttributeDataType::UShort4, idFillExtrusionPatternToVertexAttribute},
4, gfx::AttributeDataType::UShort4, fillExtrusionUBOCount + 1, idFillExtrusionPatternFromVertexAttribute},
AttributeInfo{
5, gfx::AttributeDataType::UShort4, fillExtrusionUBOCount + 1, idFillExtrusionPatternToVertexAttribute},
};
const std::array<TextureInfo, 1> FillExtrusionPatternShaderSource::textures = {
TextureInfo{0, idFillExtrusionImageTexture},

8
src/mbgl/shaders/mtl/heatmap.cpp
View File

@@ -7,9 +7,11 @@ namespace shaders {
using HeatmapShaderSource = ShaderSource<BuiltIn::HeatmapShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 3> HeatmapShaderSource::attributes = {
AttributeInfo{heatmapUBOCount + 0, gfx::AttributeDataType::Short2, idHeatmapPosVertexAttribute},
AttributeInfo{heatmapUBOCount + 1, gfx::AttributeDataType::Float2, idHeatmapWeightVertexAttribute},
AttributeInfo{heatmapUBOCount + 2, gfx::AttributeDataType::Float2, idHeatmapRadiusVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, heatmapUBOCount + 0, idHeatmapPosVertexAttribute},
// Data driven
AttributeInfo{1, gfx::AttributeDataType::Float2, heatmapUBOCount + 1, idHeatmapWeightVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Float2, heatmapUBOCount + 1, idHeatmapRadiusVertexAttribute},
};
const std::array<TextureInfo, 0> HeatmapShaderSource::textures = {};

2
src/mbgl/shaders/mtl/heatmap_texture.cpp
View File

@@ -7,7 +7,7 @@ namespace shaders {
using HeatmapTextureShaderSource = ShaderSource<BuiltIn::HeatmapTextureShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 1> HeatmapTextureShaderSource::attributes = {
AttributeInfo{heatmapTextureUBOCount + 0, gfx::AttributeDataType::Short2, idHeatmapPosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, heatmapTextureUBOCount + 0, idHeatmapPosVertexAttribute},
};
const std::array<TextureInfo, 2> HeatmapTextureShaderSource::textures = {
TextureInfo{0, idHeatmapImageTexture},

4
src/mbgl/shaders/mtl/hillshade.cpp
View File

@@ -7,8 +7,8 @@ namespace shaders {
using HillshadeShaderSource = ShaderSource<BuiltIn::HillshadeShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> HillshadeShaderSource::attributes = {
AttributeInfo{hillshadeUBOCount + 0, gfx::AttributeDataType::Short2, idHillshadePosVertexAttribute},
AttributeInfo{hillshadeUBOCount + 1, gfx::AttributeDataType::Short2, idHillshadeTexturePosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, hillshadeUBOCount + 0, idHillshadePosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Short2, hillshadeUBOCount + 0, idHillshadeTexturePosVertexAttribute},
};
const std::array<TextureInfo, 1> HillshadeShaderSource::textures = {
TextureInfo{0, idHillshadeImageTexture},

5
src/mbgl/shaders/mtl/hillshade_prepare.cpp
View File

@@ -7,8 +7,9 @@ namespace shaders {
using HillshadePrepareShaderSource = ShaderSource<BuiltIn::HillshadePrepareShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> HillshadePrepareShaderSource::attributes = {
AttributeInfo{hillshadePrepareUBOCount + 0, gfx::AttributeDataType::Short2, idHillshadePosVertexAttribute},
AttributeInfo{hillshadePrepareUBOCount + 1, gfx::AttributeDataType::Short2, idHillshadeTexturePosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, hillshadePrepareUBOCount + 0, idHillshadePosVertexAttribute},
AttributeInfo{
1, gfx::AttributeDataType::Short2, hillshadePrepareUBOCount + 0, idHillshadeTexturePosVertexAttribute},
};
const std::array<TextureInfo, 1> HillshadePrepareShaderSource::textures = {
TextureInfo{0, idHillshadeImageTexture},

74
src/mbgl/shaders/mtl/line.cpp
View File

@@ -10,14 +10,16 @@ namespace shaders {
using LineShaderSource = ShaderSource<BuiltIn::LineShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 8> LineShaderSource::attributes = {
AttributeInfo{lineUBOCount + 0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute},
AttributeInfo{lineUBOCount + 1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute},
AttributeInfo{lineUBOCount + 2, gfx::AttributeDataType::Float4, idLineColorVertexAttribute},
AttributeInfo{lineUBOCount + 3, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute},
AttributeInfo{lineUBOCount + 4, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute},
AttributeInfo{lineUBOCount + 5, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute},
AttributeInfo{lineUBOCount + 6, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute},
AttributeInfo{lineUBOCount + 7, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, lineUBOCount + 0, idLinePosNormalVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UByte4, lineUBOCount + 0, idLineDataVertexAttribute},
// Data driven
AttributeInfo{2, gfx::AttributeDataType::Float4, lineUBOCount + 1, idLineColorVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineBlurVertexAttribute},
AttributeInfo{4, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOpacityVertexAttribute},
AttributeInfo{5, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineGapWidthVertexAttribute},
AttributeInfo{6, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOffsetVertexAttribute},
AttributeInfo{7, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineWidthVertexAttribute},
};
const std::array<TextureInfo, 0> LineShaderSource::textures = {};
@@ -27,13 +29,15 @@ const std::array<TextureInfo, 0> LineShaderSource::textures = {};
using LineGradientShaderSource = ShaderSource<BuiltIn::LineGradientShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 7> LineGradientShaderSource::attributes = {
AttributeInfo{lineUBOCount + 0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute},
AttributeInfo{lineUBOCount + 1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute},
AttributeInfo{lineUBOCount + 2, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute},
AttributeInfo{lineUBOCount + 3, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute},
AttributeInfo{lineUBOCount + 4, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute},
AttributeInfo{lineUBOCount + 5, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute},
AttributeInfo{lineUBOCount + 6, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, lineUBOCount + 0, idLinePosNormalVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UByte4, lineUBOCount + 0, idLineDataVertexAttribute},
// Data driven
AttributeInfo{2, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineBlurVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOpacityVertexAttribute},
AttributeInfo{4, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineGapWidthVertexAttribute},
AttributeInfo{5, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOffsetVertexAttribute},
AttributeInfo{6, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineWidthVertexAttribute},
};
const std::array<TextureInfo, 1> LineGradientShaderSource::textures = {
TextureInfo{0, idLineImageTexture},
@@ -45,15 +49,17 @@ const std::array<TextureInfo, 1> LineGradientShaderSource::textures = {
using LinePatternShaderSource = ShaderSource<BuiltIn::LinePatternShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 9> LinePatternShaderSource::attributes = {
AttributeInfo{lineUBOCount + 0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute},
AttributeInfo{lineUBOCount + 1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute},
AttributeInfo{lineUBOCount + 2, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute},
AttributeInfo{lineUBOCount + 3, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute},
AttributeInfo{lineUBOCount + 4, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute},
AttributeInfo{lineUBOCount + 5, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute},
AttributeInfo{lineUBOCount + 6, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute},
AttributeInfo{lineUBOCount + 7, gfx::AttributeDataType::UShort4, idLinePatternFromVertexAttribute},
AttributeInfo{lineUBOCount + 8, gfx::AttributeDataType::UShort4, idLinePatternToVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, lineUBOCount + 0, idLinePosNormalVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UByte4, lineUBOCount + 0, idLineDataVertexAttribute},
// Data driven
AttributeInfo{2, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineBlurVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOpacityVertexAttribute},
AttributeInfo{4, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineGapWidthVertexAttribute},
AttributeInfo{5, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOffsetVertexAttribute},
AttributeInfo{6, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineWidthVertexAttribute},
AttributeInfo{7, gfx::AttributeDataType::UShort4, lineUBOCount + 1, idLinePatternFromVertexAttribute},
AttributeInfo{8, gfx::AttributeDataType::UShort4, lineUBOCount + 1, idLinePatternToVertexAttribute},
};
const std::array<TextureInfo, 1> LinePatternShaderSource::textures = {
TextureInfo{0, idLineImageTexture},
@@ -65,15 +71,17 @@ const std::array<TextureInfo, 1> LinePatternShaderSource::textures = {
using LineSDFShaderSource = ShaderSource<BuiltIn::LineSDFShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 9> LineSDFShaderSource::attributes = {
AttributeInfo{lineUBOCount + 0, gfx::AttributeDataType::Short2, idLinePosNormalVertexAttribute},
AttributeInfo{lineUBOCount + 1, gfx::AttributeDataType::UByte4, idLineDataVertexAttribute},
AttributeInfo{lineUBOCount + 2, gfx::AttributeDataType::Float4, idLineColorVertexAttribute},
AttributeInfo{lineUBOCount + 3, gfx::AttributeDataType::Float2, idLineBlurVertexAttribute},
AttributeInfo{lineUBOCount + 4, gfx::AttributeDataType::Float2, idLineOpacityVertexAttribute},
AttributeInfo{lineUBOCount + 5, gfx::AttributeDataType::Float2, idLineGapWidthVertexAttribute},
AttributeInfo{lineUBOCount + 6, gfx::AttributeDataType::Float2, idLineOffsetVertexAttribute},
AttributeInfo{lineUBOCount + 7, gfx::AttributeDataType::Float2, idLineWidthVertexAttribute},
AttributeInfo{lineUBOCount + 8, gfx::AttributeDataType::Float2, idLineFloorWidthVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, lineUBOCount + 0, idLinePosNormalVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UByte4, lineUBOCount + 0, idLineDataVertexAttribute},
// Data driven
AttributeInfo{2, gfx::AttributeDataType::Float4, lineUBOCount + 1, idLineColorVertexAttribute},
AttributeInfo{3, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineBlurVertexAttribute},
AttributeInfo{4, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOpacityVertexAttribute},
AttributeInfo{5, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineGapWidthVertexAttribute},
AttributeInfo{6, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineOffsetVertexAttribute},
AttributeInfo{7, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineWidthVertexAttribute},
AttributeInfo{8, gfx::AttributeDataType::Float2, lineUBOCount + 1, idLineFloorWidthVertexAttribute},
};
const std::array<TextureInfo, 1> LineSDFShaderSource::textures = {
TextureInfo{0, idLineImageTexture},

8
src/mbgl/shaders/mtl/location_indicator.cpp
View File

@@ -7,14 +7,16 @@ namespace shaders {
using LocationIndicatorShaderSource = ShaderSource<BuiltIn::LocationIndicatorShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 1> LocationIndicatorShaderSource::attributes = {AttributeInfo{
locationIndicatorUBOCount + 0, gfx::AttributeDataType::Float2, idLocationIndicatorPosVertexAttribute}};
0, gfx::AttributeDataType::Float2, locationIndicatorUBOCount + 0, idLocationIndicatorPosVertexAttribute}};
using LocationIndicatorTexturedShaderSource =
ShaderSource<BuiltIn::LocationIndicatorTexturedShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> LocationIndicatorTexturedShaderSource::attributes = {
AttributeInfo{locationIndicatorUBOCount + 0, gfx::AttributeDataType::Float2, idLocationIndicatorPosVertexAttribute},
AttributeInfo{locationIndicatorUBOCount + 1, gfx::AttributeDataType::Float2, idLocationIndicatorTexVertexAttribute},
AttributeInfo{
0, gfx::AttributeDataType::Float2, locationIndicatorUBOCount + 0, idLocationIndicatorPosVertexAttribute},
AttributeInfo{
1, gfx::AttributeDataType::Float2, locationIndicatorUBOCount + 1, idLocationIndicatorTexVertexAttribute},
};
const std::array<TextureInfo, 1> LocationIndicatorTexturedShaderSource::textures = {

4
src/mbgl/shaders/mtl/raster.cpp
View File

@@ -7,8 +7,8 @@ namespace shaders {
using RasterShaderSource = ShaderSource<BuiltIn::RasterShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 2> RasterShaderSource::attributes = {
AttributeInfo{rasterUBOCount + 0, gfx::AttributeDataType::Short2, idRasterPosVertexAttribute},
AttributeInfo{rasterUBOCount + 1, gfx::AttributeDataType::Short2, idRasterTexturePosVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short2, rasterUBOCount + 0, idRasterPosVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::Short2, rasterUBOCount + 0, idRasterTexturePosVertexAttribute},
};
const std::array<TextureInfo, 2> RasterShaderSource::textures = {
TextureInfo{0, idRasterImage0Texture},

6
src/mbgl/shaders/mtl/shader_program.cpp
View File

@@ -185,23 +185,25 @@ std::optional<size_t> ShaderProgram::getSamplerLocation(const size_t id) const {
void ShaderProgram::initAttribute(const shaders::AttributeInfo& info) {
const auto index = static_cast<int>(info.index);
const auto bufferIndex = static_cast<int>(info.bufferIndex);
#if !defined(NDEBUG)
// Indexes must be unique, if there's a conflict check the `attributes` array in the shader
vertexAttributes.visitAttributes([&](const gfx::VertexAttribute& attrib) { assert(attrib.getIndex() != index); });
instanceAttributes.visitAttributes([&](const gfx::VertexAttribute& attrib) { assert(attrib.getIndex() != index); });
#endif
vertexAttributes.set(info.id, index, info.dataType, 1);
vertexAttributes.set(info.id, index, info.dataType, bufferIndex);
}
void ShaderProgram::initInstanceAttribute(const shaders::AttributeInfo& info) {
// Index is the block index of the instance attribute
const auto index = static_cast<int>(info.index);
const auto bufferIndex = static_cast<int>(info.bufferIndex);
#if !defined(NDEBUG)
// Indexes must not be reused by regular attributes or uniform blocks
// More than one instance attribute can have the same index, if they share the block
vertexAttributes.visitAttributes([&](const gfx::VertexAttribute& attrib) { assert(attrib.getIndex() != index); });
#endif
instanceAttributes.set(info.id, index, info.dataType, 1);
instanceAttributes.set(info.id, index, info.dataType, bufferIndex);
}
void ShaderProgram::initTexture(const shaders::TextureInfo& info) {

71
src/mbgl/shaders/mtl/symbol.cpp
View File

@@ -10,15 +10,18 @@ namespace shaders {
using SymbolIconShaderSource = ShaderSource<BuiltIn::SymbolIconShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 6> SymbolIconShaderSource::attributes = {
// always attributes
AttributeInfo{symbolUBOCount + 0, gfx::AttributeDataType::Short4, idSymbolPosOffsetVertexAttribute},
AttributeInfo{symbolUBOCount + 1, gfx::AttributeDataType::UShort4, idSymbolDataVertexAttribute},
AttributeInfo{symbolUBOCount + 2, gfx::AttributeDataType::Short4, idSymbolPixelOffsetVertexAttribute},
AttributeInfo{symbolUBOCount + 3, gfx::AttributeDataType::Float3, idSymbolProjectedPosVertexAttribute},
AttributeInfo{symbolUBOCount + 4, gfx::AttributeDataType::Float, idSymbolFadeOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short4, symbolUBOCount + 0, idSymbolPosOffsetVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UShort4, symbolUBOCount + 0, idSymbolDataVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Short4, symbolUBOCount + 0, idSymbolPixelOffsetVertexAttribute},
// sometimes uniforms
AttributeInfo{symbolUBOCount + 5, gfx::AttributeDataType::Float, idSymbolOpacityVertexAttribute},
// Dynamic
AttributeInfo{3, gfx::AttributeDataType::Float3, symbolUBOCount + 1, idSymbolProjectedPosVertexAttribute},
// Opacity
AttributeInfo{4, gfx::AttributeDataType::Float, symbolUBOCount + 2, idSymbolFadeOpacityVertexAttribute},
// Data driven
AttributeInfo{5, gfx::AttributeDataType::Float, symbolUBOCount + 3, idSymbolOpacityVertexAttribute},
};
const std::array<TextureInfo, 1> SymbolIconShaderSource::textures = {
TextureInfo{0, idSymbolImageTexture},
@@ -30,19 +33,22 @@ const std::array<TextureInfo, 1> SymbolIconShaderSource::textures = {
using SymbolSDFShaderSource = ShaderSource<BuiltIn::SymbolSDFShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 10> SymbolSDFShaderSource::attributes = {
// always attributes
AttributeInfo{symbolUBOCount + 0, gfx::AttributeDataType::Short4, idSymbolPosOffsetVertexAttribute},
AttributeInfo{symbolUBOCount + 1, gfx::AttributeDataType::UShort4, idSymbolDataVertexAttribute},
AttributeInfo{symbolUBOCount + 2, gfx::AttributeDataType::Short4, idSymbolPixelOffsetVertexAttribute},
AttributeInfo{symbolUBOCount + 3, gfx::AttributeDataType::Float3, idSymbolProjectedPosVertexAttribute},
AttributeInfo{symbolUBOCount + 4, gfx::AttributeDataType::Float, idSymbolFadeOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short4, symbolUBOCount + 0, idSymbolPosOffsetVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UShort4, symbolUBOCount + 0, idSymbolDataVertexAttribute},
AttributeInfo{2, gfx::AttributeDataType::Short4, symbolUBOCount + 0, idSymbolPixelOffsetVertexAttribute},
// sometimes uniforms
AttributeInfo{symbolUBOCount + 5, gfx::AttributeDataType::Float4, idSymbolColorVertexAttribute},
AttributeInfo{symbolUBOCount + 6, gfx::AttributeDataType::Float4, idSymbolHaloColorVertexAttribute},
AttributeInfo{symbolUBOCount + 7, gfx::AttributeDataType::Float, idSymbolOpacityVertexAttribute},
AttributeInfo{symbolUBOCount + 8, gfx::AttributeDataType::Float, idSymbolHaloWidthVertexAttribute},
AttributeInfo{symbolUBOCount + 9, gfx::AttributeDataType::Float, idSymbolHaloBlurVertexAttribute},
// Dynamic
AttributeInfo{3, gfx::AttributeDataType::Float3, symbolUBOCount + 1, idSymbolProjectedPosVertexAttribute},
// Opacity
AttributeInfo{4, gfx::AttributeDataType::Float, symbolUBOCount + 2, idSymbolFadeOpacityVertexAttribute},
// Data driven
AttributeInfo{5, gfx::AttributeDataType::Float4, symbolUBOCount + 3, idSymbolColorVertexAttribute},
AttributeInfo{6, gfx::AttributeDataType::Float4, symbolUBOCount + 3, idSymbolHaloColorVertexAttribute},
AttributeInfo{7, gfx::AttributeDataType::Float, symbolUBOCount + 3, idSymbolOpacityVertexAttribute},
AttributeInfo{8, gfx::AttributeDataType::Float, symbolUBOCount + 3, idSymbolHaloWidthVertexAttribute},
AttributeInfo{9, gfx::AttributeDataType::Float, symbolUBOCount + 3, idSymbolHaloBlurVertexAttribute},
};
const std::array<TextureInfo, 1> SymbolSDFShaderSource::textures = {
TextureInfo{0, idSymbolImageTexture},
@@ -54,18 +60,21 @@ const std::array<TextureInfo, 1> SymbolSDFShaderSource::textures = {
using SymbolTextAndIconShaderSource = ShaderSource<BuiltIn::SymbolTextAndIconShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 9> SymbolTextAndIconShaderSource::attributes = {
// always attributes
AttributeInfo{symbolUBOCount + 0, gfx::AttributeDataType::Short4, idSymbolPosOffsetVertexAttribute},
AttributeInfo{symbolUBOCount + 1, gfx::AttributeDataType::UShort4, idSymbolDataVertexAttribute},
AttributeInfo{symbolUBOCount + 2, gfx::AttributeDataType::Float3, idSymbolProjectedPosVertexAttribute},
AttributeInfo{symbolUBOCount + 3, gfx::AttributeDataType::Float, idSymbolFadeOpacityVertexAttribute},
AttributeInfo{0, gfx::AttributeDataType::Short4, symbolUBOCount + 0, idSymbolPosOffsetVertexAttribute},
AttributeInfo{1, gfx::AttributeDataType::UShort4, symbolUBOCount + 0, idSymbolDataVertexAttribute},
// sometimes uniforms
AttributeInfo{symbolUBOCount + 4, gfx::AttributeDataType::Float4, idSymbolColorVertexAttribute},
AttributeInfo{symbolUBOCount + 5, gfx::AttributeDataType::Float4, idSymbolHaloColorVertexAttribute},
AttributeInfo{symbolUBOCount + 6, gfx::AttributeDataType::Float, idSymbolOpacityVertexAttribute},
AttributeInfo{symbolUBOCount + 7, gfx::AttributeDataType::Float, idSymbolHaloWidthVertexAttribute},
AttributeInfo{symbolUBOCount + 8, gfx::AttributeDataType::Float, idSymbolHaloBlurVertexAttribute},
// Dynamic
AttributeInfo{2, gfx::AttributeDataType::Float3, symbolUBOCount + 1, idSymbolProjectedPosVertexAttribute},
// Opacity
AttributeInfo{3, gfx::AttributeDataType::Float, symbolUBOCount + 2, idSymbolFadeOpacityVertexAttribute},
// Data driven
AttributeInfo{4, gfx::AttributeDataType::Float4, symbolUBOCount + 3, idSymbolColorVertexAttribute},
AttributeInfo{5, gfx::AttributeDataType::Float4, symbolUBOCount + 3, idSymbolHaloColorVertexAttribute},
AttributeInfo{6, gfx::AttributeDataType::Float, symbolUBOCount + 3, idSymbolOpacityVertexAttribute},
AttributeInfo{7, gfx::AttributeDataType::Float, symbolUBOCount + 3, idSymbolHaloWidthVertexAttribute},
AttributeInfo{8, gfx::AttributeDataType::Float, symbolUBOCount + 3, idSymbolHaloBlurVertexAttribute},
};
const std::array<TextureInfo, 2> SymbolTextAndIconShaderSource::textures = {
TextureInfo{0, idSymbolImageTexture},

14
src/mbgl/shaders/mtl/widevector.cpp
View File

@@ -7,15 +7,15 @@ namespace shaders {
using WideVectorShaderSource = ShaderSource<BuiltIn::WideVectorShader, gfx::Backend::Type::Metal>;
const std::array<AttributeInfo, 3> WideVectorShaderSource::attributes = {
AttributeInfo{wideVectorUBOCount + 0, gfx::AttributeDataType::Float3, idWideVectorScreenPos},
AttributeInfo{wideVectorUBOCount + 1, gfx::AttributeDataType::Float4, idWideVectorColor},
AttributeInfo{wideVectorUBOCount + 2, gfx::AttributeDataType::Int, idWideVectorIndex},
AttributeInfo{0, gfx::AttributeDataType::Float3, wideVectorUBOCount + 0, idWideVectorScreenPos},
AttributeInfo{1, gfx::AttributeDataType::Float4, wideVectorUBOCount + 0, idWideVectorColor},
AttributeInfo{2, gfx::AttributeDataType::Int, wideVectorUBOCount + 0, idWideVectorIndex},
};
const std::array<AttributeInfo, 4> WideVectorShaderSource::instanceAttributes = {
AttributeInfo{wideVectorUBOCount + 3, gfx::AttributeDataType::Float3, idWideVectorInstanceCenter},
AttributeInfo{wideVectorUBOCount + 3, gfx::AttributeDataType::Float4, idWideVectorInstanceColor},
AttributeInfo{wideVectorUBOCount + 3, gfx::AttributeDataType::Int, idWideVectorInstancePrevious},
AttributeInfo{wideVectorUBOCount + 3, gfx::AttributeDataType::Int, idWideVectorInstanceNext},
AttributeInfo{3, gfx::AttributeDataType::Float3, wideVectorUBOCount + 1, idWideVectorInstanceCenter},
AttributeInfo{4, gfx::AttributeDataType::Float4, wideVectorUBOCount + 1, idWideVectorInstanceColor},
AttributeInfo{5, gfx::AttributeDataType::Int, wideVectorUBOCount + 1, idWideVectorInstancePrevious},
AttributeInfo{6, gfx::AttributeDataType::Int, wideVectorUBOCount + 1, idWideVectorInstanceNext},
};
const std::array<TextureInfo, 0> WideVectorShaderSource::textures = {};

3
src/mbgl/vulkan/upload_pass.cpp
View File

@@ -122,6 +122,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ static_cast<uint32_t>(VertexAttribute::getStrideOf(defaultAttr.getDataType())),
/*.vertexBufferResource = */ nullptr,
/*.vertexOffset = */ 0,
/*.bufferIndex = */ 0,
};
return;
}
@@ -136,6 +137,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ effectiveAttr.getSharedStride(),
/*.vertexBufferResource = */ buffer.get(),
/*.vertexOffset = */ effectiveAttr.getSharedVertexOffset(),
/*.bufferIndex = */ 0,
};
return;
}
@@ -150,6 +152,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ static_cast<uint32_t>(effectiveAttr.getStride()),
/*.vertexBufferResource = */ buffer.get(),
/*.vertexOffset = */ 0,
/*.bufferIndex = */ 0,
};
return;
}

3
src/mbgl/webgpu/context.cpp
View File

@@ -460,7 +460,8 @@ gfx::AttributeBindingArray Context::getOrCreateVertexBindings(gfx::Context&,
result[index] = {/*.attribute = */ {attr.getDataType(), /*offset=*/0},
/*.vertexStride = */ static_cast<uint32_t>(attr.getStride()),
/*.vertexBufferResource = */ bufferResource.get(),
/*.vertexOffset = */ 0};
/*.vertexOffset = */ 0,
/*.bufferIndex = */ 0};
}
}
});

3
src/mbgl/webgpu/upload_pass.cpp
View File

@@ -187,6 +187,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ static_cast<uint32_t>(stride),
/*.vertexBufferResource = */ dummyBuffer.get(),
/*.vertexOffset = */ 0,
/*.bufferIndex = */ 0,
};
// Store the buffer so it doesn't get destroyed
@@ -205,6 +206,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ effectiveAttr.getSharedStride(),
/*.vertexBufferResource = */ buffer_.get(),
/*.vertexOffset = */ effectiveAttr.getSharedVertexOffset(),
/*.bufferIndex = */ 0,
};
return;
}
@@ -219,6 +221,7 @@ gfx::AttributeBindingArray UploadPass::buildAttributeBindings(
/*.vertexStride = */ static_cast<uint32_t>(effectiveAttr.getStride()),
/*.vertexBufferResource = */ buffer_.get(),
/*.vertexOffset = */ 0,
/*.bufferIndex = */ 0,
};
return;
}