test: add core particle render layer validation

src/mbgl/renderer/layers/render_particle_validation_layer.cpp

@@ -0,0 +1,132 @@
+#include <mbgl/renderer/layers/render_particle_validation_layer.hpp>
+
+#include <mbgl/gfx/context.hpp>
+#include <mbgl/gfx/drawable.hpp>
+#include <mbgl/gfx/drawable_builder.hpp>
+#include <mbgl/gfx/drawable_tweaker.hpp>
+#include <mbgl/map/transform_state.hpp>
+#include <mbgl/renderer/layer_group.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
+#include <mbgl/renderer/render_pass.hpp>
+#include <mbgl/style/types.hpp>
+#include <mbgl/util/logging.hpp>
+
+#include <sstream>
+
+namespace mbgl {
+
+namespace {
+const style::ParticleValidationLayer::Impl& impl(const Immutable<style::Layer::Impl>& value) {
+    assert(value->getTypeInfo() == style::ParticleValidationLayer::Impl::staticTypeInfo());
+    return static_cast<const style::ParticleValidationLayer::Impl&>(*value);
+}
+
+class ParticleValidationDrawableTweaker final : public gfx::DrawableTweaker {
+public:
+    ParticleValidationDrawableTweaker(std::string id_, bool active_, int32_t layerIndex_)
+        : id(std::move(id_)),
+          active(active_),
+          layerIndex(layerIndex_) {}
+
+    ~ParticleValidationDrawableTweaker() override {
+        Log::Info(Event::Render,
+                  "ParticleValidation: validation drawable destroy id=" + id +
+                      " validationFrames=" + std::to_string(validationFrameCount));
+    }
+
+    void init(gfx::Drawable&) override {}
+
+    void execute(gfx::Drawable&, PaintParameters& parameters) override {
+        if (parameters.pass != RenderPass::Translucent) {
+            return;
+        }
+
+        ++validationFrameCount;
+        if (validationFrameCount != 1 && validationFrameCount % 60 != 0) {
+            return;
+        }
+
+        const auto size = parameters.state.getSize();
+        const auto& matrix = parameters.transformParams.projMatrix;
+        std::ostringstream message;
+        message << "ParticleValidation: render frame=" << validationFrameCount << " mapFrame=" << parameters.frameCount
+                << " state=" << (active ? "ACTIVE" : "STATIC") << " repaint=" << (active ? "requested" : "stopped")
+                << " pass=translucent" << " layerIndex=" << layerIndex << " currentLayer=" << parameters.currentLayer
+                << " viewport=" << size.width << 'x' << size.height << " zoom=" << parameters.state.getZoom()
+                << " bearing=" << parameters.state.getBearing() << " pitch=" << parameters.state.getPitch() << " proj=["
+                << matrix[0] << ',' << matrix[5] << ',' << matrix[12] << ',' << matrix[13] << ']';
+        Log::Info(Event::Render, message.str());
+    }
+
+private:
+    std::string id;
+    bool active;
+    int32_t layerIndex;
+    uint64_t validationFrameCount = 0;
+};
+} // namespace
+
+RenderParticleValidationLayer::RenderParticleValidationLayer(Immutable<style::ParticleValidationLayer::Impl> impl_)
+    : RenderLayer(makeMutable<style::ParticleValidationLayerProperties>(impl_, impl_->active)) {
+    Log::Info(Event::Render,
+              "ParticleValidation: RenderLayer create id=" + getID() + " source-less=true pass=translucent");
+}
+
+RenderParticleValidationLayer::~RenderParticleValidationLayer() {
+    Log::Info(Event::Render, "ParticleValidation: RenderLayer destroy id=" + getID());
+}
+
+void RenderParticleValidationLayer::evaluate(const PropertyEvaluationParameters&) {
+    const bool active = impl(baseImpl).active;
+    auto properties = makeMutable<style::ParticleValidationLayerProperties>(
+        staticImmutableCast<style::ParticleValidationLayer::Impl>(baseImpl), active);
+    passes = RenderPass::Translucent;
+    properties->renderPasses = mbgl::underlying_type(passes);
+    evaluatedProperties = std::move(properties);
+
+    Log::Info(Event::Render,
+              "ParticleValidation: state=" + std::string(active ? "ACTIVE" : "STATIC") + " id=" + getID() +
+                  " layerIndex=" + std::to_string(getLayerIndex()));
+}
+
+bool RenderParticleValidationLayer::needsRepaint() const {
+    const auto& properties = static_cast<const style::ParticleValidationLayerProperties&>(*evaluatedProperties);
+    return properties.active && baseImpl->visibility != style::VisibilityType::None;
+}
+
+void RenderParticleValidationLayer::update(gfx::ShaderRegistry&,
+                                           gfx::Context& context,
+                                           const TransformState&,
+                                           const std::shared_ptr<UpdateParameters>&,
+                                           const RenderTree&,
+                                           UniqueChangeRequestVec& changes) {
+    if (!layerGroup) {
+        if (auto group = context.createLayerGroup(layerIndex, 1, getID())) {
+            setLayerGroup(std::move(group), changes);
+        }
+    }
+    if (!layerGroup) {
+        return;
+    }
+
+    auto* group = static_cast<LayerGroup*>(layerGroup.get());
+    if (group->getDrawableCount() != 0) {
+        return;
+    }
+
+    const bool active = static_cast<const style::ParticleValidationLayerProperties&>(*evaluatedProperties).active;
+    auto builder = context.createDrawableBuilder(getID());
+    auto& drawable = builder->getCurrentDrawable(true);
+    drawable->setIsCustom(true);
+    drawable->setRenderPass(RenderPass::Translucent);
+    drawable->addTweaker(std::make_shared<ParticleValidationDrawableTweaker>(getID(), active, getLayerIndex()));
+    auto drawables = builder->clearDrawables();
+    group->addDrawable(std::move(drawables.front()));
+    ++stats.drawablesAdded;
+
+    Log::Info(Event::Render,
+              "ParticleValidation: validation drawable create id=" + getID() +
+                  " layerIndex=" + std::to_string(getLayerIndex()) + " pass=translucent");
+}
+
+} // namespace mbgl