kc3-lang/angle/src/libANGLE/OverlayWidgets.h

• Show log

  Commit

• Hash : da9390d6
  Author :
  Date : 2022-06-08T22:38:18
  

  Vulkan: Fix the VulkanRenderPassBufferCount overlay widget
  
  This widget was declared as a histogram, but used as a graph.  The
  graph's add() interface is made hidden in histograms to avoid such
  mistakes in the future.
  
  Bug: angleproject:4950
  Change-Id: I95a1b6badbe27b870273589271b13c454c8a4e56
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3697438
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/OverlayWidgets.h

• //
  // Copyright 2019 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // OverlayWidgets.h:
  //    Defines the Overlay* widget classes and corresponding enums.
  //
  
  #ifndef LIBANGLE_OVERLAYWIDGETS_H_
  #define LIBANGLE_OVERLAYWIDGETS_H_
  
  #include "common/angleutils.h"
  #include "libANGLE/Overlay_autogen.h"
  
  namespace gl
  {
  class Overlay;
  class OverlayState;
  
  namespace overlay_impl
  {
  class AppendWidgetDataHelper;
  }  // namespace overlay_impl
  
  enum class WidgetType
  {
      // Text types:
  
      // A total count of some event.
      Count,
      // A single line of ASCII text.  Retains content until changed.
      Text,
      // A per-second value.
      PerSecond,
  
      // Graph types:
  
      // A graph of the last N values.
      RunningGraph,
      // A histogram of the last N values (values between 0 and 1).
      RunningHistogram,
  
      InvalidEnum,
      EnumCount = InvalidEnum,
  };
  
  namespace overlay
  {
  class Text;
  class Widget
  {
    public:
      virtual ~Widget() {}
  
      virtual const Text *getDescriptionWidget() const;
  
    protected:
      WidgetType type;
      // Whether this item should be drawn.
      bool enabled = false;
  
      // For text items, size of the font.  This is a value in [0, overlay::kFontMipCount) which
      // determines the font size to use.
      int fontSize;
  
      // The area covered by the item, predetermined by the overlay class.  Negative values
      // indicate offset from the left/bottom of the image.
      int32_t coords[4];
      float color[4];
  
      // In some cases, a widget may need to match its contents (e.g. graph height scaling) with
      // another related widget.  In such a case, this pointer will point to the widget it needs to
      // match to.
      Widget *matchToWidget;
  
      friend class gl::Overlay;
      friend class gl::OverlayState;
      friend class overlay_impl::AppendWidgetDataHelper;
  };
  
  class Count : public Widget
  {
    public:
      ~Count() override {}
      void add(uint64_t n) { count += n; }
      void set(uint64_t n) { count = n; }
      void reset() { count = 0; }
  
    protected:
      uint64_t count = 0;
  
      friend class gl::Overlay;
      friend class overlay_impl::AppendWidgetDataHelper;
  };
  
  class PerSecond : public Count
  {
    public:
      ~PerSecond() override {}
  
    protected:
      uint64_t lastPerSecondCount = 0;
  
      friend class gl::Overlay;
      friend class overlay_impl::AppendWidgetDataHelper;
  };
  
  class Text : public Widget
  {
    public:
      ~Text() override {}
      void set(std::string &&str) { text = std::move(str); }
  
    protected:
      std::string text;
  
      friend class overlay_impl::AppendWidgetDataHelper;
  };
  
  class RunningGraph : public Widget
  {
    public:
      // Out of line constructor to satisfy chromium-style.
      RunningGraph(size_t n);
      ~RunningGraph() override;
  
      void add(uint64_t n)
      {
          if (!ignoreFirstValue)
          {
              runningValues[lastValueIndex] += n;
          }
      }
  
      void next()
      {
          if (ignoreFirstValue)
          {
              ignoreFirstValue = false;
          }
          else
          {
              lastValueIndex                = (lastValueIndex + 1) % runningValues.size();
              runningValues[lastValueIndex] = 0;
          }
      }
  
      const Text *getDescriptionWidget() const override;
  
    protected:
      std::vector<uint64_t> runningValues;
      size_t lastValueIndex = 0;
      Text description;
      bool ignoreFirstValue = true;
  
      friend class gl::Overlay;
      friend class gl::OverlayState;
      friend class overlay_impl::AppendWidgetDataHelper;
  };
  
  class RunningHistogram : public RunningGraph
  {
    public:
      RunningHistogram(size_t n) : RunningGraph(n) {}
      ~RunningHistogram() override {}
  
      void set(float n)
      {
          ASSERT(n >= 0.0f && n <= 1.0f);
          uint64_t rank =
              n == 1.0f ? runningValues.size() - 1 : static_cast<uint64_t>(n * runningValues.size());
  
          runningValues[lastValueIndex] = rank;
      }
  
    private:
      // Do not use the add() function from RunningGraph
      using RunningGraph::add;
  };
  
  // If overlay is disabled, all the above classes would be replaced with Mock, turning them into
  // noop.
  class Mock
  {
    public:
      void reset() const {}
      template <typename T>
      void set(T) const
      {}
      template <typename T>
      void add(T) const
      {}
      void next() const {}
  };
  
  }  // namespace overlay
  
  }  // namespace gl
  
  #endif  // LIBANGLE_OVERLAYWIDGETS_H_
  

Download