feat: establish formal raster particle source chain

include/mbgl/layermanager/raster_particle_layer_factory.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <mbgl/layermanager/layer_factory.hpp>
+
+namespace mbgl {
+
+class RasterParticleLayerFactory final : public LayerFactory {
+public:
+    const style::LayerTypeInfo* getTypeInfo() const noexcept override;
+    std::unique_ptr<style::Layer> createLayer(const std::string&,
+                                              const style::conversion::Convertible&) noexcept override;
+    std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept override;
+};
+
+} // namespace mbgl

include/mbgl/shaders/gl/particle_gpu_validation.hpp

@@ -56,7 +56,12 @@ void main() {
         // texture encodes canonical U-east/V-north at that geographic sample.
         vec2 position = previous.rg;
         if (previous.a < 0.5) position = v_uv;
-        vec2 velocity = texture(u_field_texture, position).rg * 2.0 - 1.0;
+        vec4 field = texture(u_field_texture, position);
+        vec2 velocity = field.rg * 2.0 - 1.0;
+        if (field.a < 0.5) {
+            position = v_uv;
+            velocity = vec2(0.0);
+        }
         position = fract(position + velocity * u_pass.y * 0.004);
         if (any(isnan(velocity))) position = v_uv;
         fragColor = vec4(position, fract(previous.b + 0.03125 * u_pass.y), 1.0);

include/mbgl/style/layers/raster_particle_layer.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <mbgl/style/layer.hpp>
+
+namespace mbgl::style {
+
+class RasterParticleLayer final : public Layer {
+public:
+    RasterParticleLayer(const std::string& layerID, const std::string& sourceID);
+    ~RasterParticleLayer() override;
+    bool isActive() const;
+    void setActive(bool);
+    uint8_t getMaskMode() const;
+    void setMaskMode(uint8_t);
+    class Impl;
+    const Impl& impl() const;
+    Mutable<Impl> mutableImpl() const;
+
+private:
+    explicit RasterParticleLayer(Immutable<Impl>);
+    std::optional<conversion::Error> setPropertyInternal(const std::string&, const conversion::Convertible&) override;
+    StyleProperty getProperty(const std::string&) const override;
+    Value serialize() const override;
+    std::unique_ptr<Layer> cloneRef(const std::string&) const override;
+    Mutable<Layer::Impl> mutableBaseImpl() const override;
+};
+
+} // namespace mbgl::style

include/mbgl/style/sources/raster_array_source.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <mbgl/style/source.hpp>
+
+#include <optional>
+
+namespace mbgl {
+class AsyncRequest;
+
+namespace style {
+
+class RasterArraySource final : public Source {
+public:
+    RasterArraySource(std::string id, std::string fixtureID, std::string metadataURL, std::string fieldURL);
+    ~RasterArraySource() override;
+
+    class Impl;
+    const Impl& impl() const;
+    void loadDescription(FileSource&) override;
+    bool supportsLayerType(const LayerTypeInfo*) const override;
+    mapbox::base::WeakPtr<Source> makeWeakPtr() override { return weakFactory.makeWeakPtr(); }
+
+protected:
+    Mutable<Source::Impl> createMutable() const noexcept override;
+
+private:
+    void tryLoad();
+
+    std::unique_ptr<AsyncRequest> metadataRequest;
+    std::unique_ptr<AsyncRequest> fieldRequest;
+    std::optional<std::string> metadata;
+    std::optional<std::vector<char>> fieldBytes;
+    uint64_t generation = 0;
+    mapbox::base::WeakPtrFactory<Source> weakFactory{this};
+};
+
+template <>
+inline bool Source::is<RasterArraySource>() const {
+    return getType() == SourceType::RasterArray;
+}
+
+} // namespace style
+} // namespace mbgl

include/mbgl/style/types.hpp

@@ -15,7 +15,8 @@ enum class SourceType : uint8_t {
     Video,
     Annotations,
     Image,
-    CustomVector
+    CustomVector,
+    RasterArray
 };
 
 enum class VisibilityType : bool {