kc3-lang/angle/include/platform/Feature.h

• Show log

  Commit

• Hash : 163e56e4
  Author :
  Date : 2022-09-20T00:40:55
  

  Allow feature overrides to end in * (wildcard)
  
  Makes it easier to apply overrides to features with long names.  Also
  works around Android's limit of 92 characters for debug properties.
  
  Bug: b/238024366
  Change-Id: I8f417287f92b2439de1a7b7d6abbaf9e61b405e8
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3906222
  Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
  

Download

• include/platform/Feature.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.
  //
  // Feature.h: Definition of structs to hold feature/workaround information.
  //
  
  #ifndef ANGLE_PLATFORM_FEATURE_H_
  #define ANGLE_PLATFORM_FEATURE_H_
  
  #include <map>
  #include <string>
  #include <vector>
  
  #define ANGLE_FEATURE_CONDITION(set, feature, cond)       \
      do                                                    \
      {                                                     \
          (set)->feature.enabled   = cond;                  \
          (set)->feature.condition = ANGLE_STRINGIFY(cond); \
      } while (0)
  
  namespace angle
  {
  
  enum class FeatureCategory
  {
      FrontendFeatures,
      FrontendWorkarounds,
      OpenGLWorkarounds,
      OpenGLFeatures,
      D3DWorkarounds,
      VulkanFeatures,
      VulkanWorkarounds,
      VulkanAppWorkarounds,
      MetalFeatures,
      MetalWorkarounds,
  };
  
  constexpr char kFeatureCategoryFrontendWorkarounds[]  = "Frontend workarounds";
  constexpr char kFeatureCategoryFrontendFeatures[]     = "Frontend features";
  constexpr char kFeatureCategoryOpenGLWorkarounds[]    = "OpenGL workarounds";
  constexpr char kFeatureCategoryOpenGLFeatures[]       = "OpenGL features";
  constexpr char kFeatureCategoryD3DWorkarounds[]       = "D3D workarounds";
  constexpr char kFeatureCategoryVulkanAppWorkarounds[] = "Vulkan app workarounds";
  constexpr char kFeatureCategoryVulkanWorkarounds[]    = "Vulkan workarounds";
  constexpr char kFeatureCategoryVulkanFeatures[]       = "Vulkan features";
  constexpr char kFeatureCategoryMetalFeatures[]        = "Metal features";
  constexpr char kFeatureCategoryMetalWorkarounds[]     = "Metal workarounds";
  constexpr char kFeatureCategoryUnknown[]              = "Unknown";
  
  inline const char *FeatureCategoryToString(const FeatureCategory &fc)
  {
      switch (fc)
      {
          case FeatureCategory::FrontendFeatures:
              return kFeatureCategoryFrontendFeatures;
              break;
  
          case FeatureCategory::FrontendWorkarounds:
              return kFeatureCategoryFrontendWorkarounds;
              break;
  
          case FeatureCategory::OpenGLWorkarounds:
              return kFeatureCategoryOpenGLWorkarounds;
              break;
  
          case FeatureCategory::OpenGLFeatures:
              return kFeatureCategoryOpenGLFeatures;
              break;
  
          case FeatureCategory::D3DWorkarounds:
              return kFeatureCategoryD3DWorkarounds;
              break;
  
          case FeatureCategory::VulkanFeatures:
              return kFeatureCategoryVulkanFeatures;
              break;
  
          case FeatureCategory::VulkanWorkarounds:
              return kFeatureCategoryVulkanWorkarounds;
              break;
  
          case FeatureCategory::VulkanAppWorkarounds:
              return kFeatureCategoryVulkanAppWorkarounds;
              break;
  
          case FeatureCategory::MetalFeatures:
              return kFeatureCategoryMetalFeatures;
              break;
  
          case FeatureCategory::MetalWorkarounds:
              return kFeatureCategoryMetalWorkarounds;
              break;
  
          default:
              return kFeatureCategoryUnknown;
              break;
      }
  }
  
  constexpr char kFeatureStatusEnabled[]  = "enabled";
  constexpr char kFeatureStatusDisabled[] = "disabled";
  
  inline const char *FeatureStatusToString(const bool &status)
  {
      if (status)
      {
          return kFeatureStatusEnabled;
      }
      return kFeatureStatusDisabled;
  }
  
  struct FeatureInfo;
  
  using FeatureMap  = std::map<std::string, FeatureInfo *>;
  using FeatureList = std::vector<const FeatureInfo *>;
  
  struct FeatureInfo
  {
      FeatureInfo(const FeatureInfo &other);
      FeatureInfo(const char *name,
                  const FeatureCategory &category,
                  const char *description,
                  FeatureMap *const mapPtr,
                  const char *bug);
      ~FeatureInfo();
  
      // The name of the workaround, lowercase, camel_case
      const char *const name;
  
      // The category that the workaround belongs to. Eg. "Vulkan workarounds"
      const FeatureCategory category;
  
      // A short description to be read by the user.
      const char *const description;
  
      // A link to the bug, if any
      const char *const bug;
  
      // Whether the workaround is enabled or not. Determined by heuristics like vendor ID and
      // version, but may be overriden to any value.
      bool enabled = false;
  
      // A stringified version of the condition used to set 'enabled'. ie "IsNvidia() && IsApple()"
      const char *condition;
  };
  
  inline FeatureInfo::FeatureInfo(const FeatureInfo &other) = default;
  inline FeatureInfo::FeatureInfo(const char *name,
                                  const FeatureCategory &category,
                                  const char *description,
                                  FeatureMap *const mapPtr,
                                  const char *bug = "")
      : name(name),
        category(category),
        description(description),
        bug(bug),
        enabled(false),
        condition("")
  {
      if (mapPtr != nullptr)
      {
          (*mapPtr)[std::string(name)] = this;
      }
  }
  
  inline FeatureInfo::~FeatureInfo() = default;
  
  struct FeatureSetBase
  {
    public:
      FeatureSetBase();
      ~FeatureSetBase();
  
    private:
      // Non-copyable
      FeatureSetBase(const FeatureSetBase &other)            = delete;
      FeatureSetBase &operator=(const FeatureSetBase &other) = delete;
  
    protected:
      FeatureMap members = FeatureMap();
  
    public:
      void overrideFeatures(const std::vector<std::string> &featureNames, bool enabled);
      void populateFeatureList(FeatureList *features) const;
  
      const FeatureMap &getFeatures() const { return members; }
  };
  
  inline FeatureSetBase::FeatureSetBase()  = default;
  inline FeatureSetBase::~FeatureSetBase() = default;
  
  }  // namespace angle
  
  #endif  // ANGLE_PLATFORM_WORKAROUND_H_
  

Download