kc3-lang/angle/src/common/PackedEnums.h

• Show log

  Commit

• Hash : 44286dc8
  Author :
  Date : 2018-09-12T11:03:05
  

  Allow an extra slot in PackedEnumMap.
  
  This can be used for fast lookups with InvalidEnum. Will be useful
  for optimizing valid primitive mode lookups.
  
  Bug: angleproject:2747
  Change-Id: I5d668863eb23d3c1eb85a775b3e9e46f25a0a335
  Reviewed-on: https://chromium-review.googlesource.com/1171504
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Frank Henigman <fjhenigman@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/common/PackedEnums.h

• // Copyright 2017 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.
  //
  // PackedGLEnums_autogen.h:
  //   Declares ANGLE-specific enums classes for GLEnum and functions operating
  //   on them.
  
  #ifndef COMMON_PACKEDGLENUMS_H_
  #define COMMON_PACKEDGLENUMS_H_
  
  #include "common/PackedEGLEnums_autogen.h"
  #include "common/PackedGLEnums_autogen.h"
  
  #include <array>
  #include <bitset>
  #include <cstddef>
  
  #include <EGL/egl.h>
  
  #include "common/bitset_utils.h"
  
  namespace angle
  {
  
  // Return the number of elements of a packed enum, including the InvalidEnum element.
  template <typename E>
  constexpr size_t EnumSize()
  {
      using UnderlyingType = typename std::underlying_type<E>::type;
      return static_cast<UnderlyingType>(E::EnumCount);
  }
  
  // Implementation of AllEnums which allows iterating over all the possible values for a packed enums
  // like so:
  //     for (auto value : AllEnums<MyPackedEnum>()) {
  //         // Do something with the enum.
  //     }
  
  template <typename E>
  class EnumIterator final
  {
    private:
      using UnderlyingType = typename std::underlying_type<E>::type;
  
    public:
      EnumIterator(E value) : mValue(static_cast<UnderlyingType>(value)) {}
      EnumIterator &operator++()
      {
          mValue++;
          return *this;
      }
      bool operator==(const EnumIterator &other) const { return mValue == other.mValue; }
      bool operator!=(const EnumIterator &other) const { return mValue != other.mValue; }
      E operator*() const { return static_cast<E>(mValue); }
  
    private:
      UnderlyingType mValue;
  };
  
  template <typename E>
  struct AllEnums
  {
      EnumIterator<E> begin() const { return {static_cast<E>(0)}; }
      EnumIterator<E> end() const { return {E::InvalidEnum}; }
  };
  
  // PackedEnumMap<E, T> is like an std::array<T, E::EnumCount> but is indexed with enum values. It
  // implements all of the std::array interface except with enum values instead of indices.
  template <typename E, typename T, size_t MaxSize = EnumSize<E>()>
  class PackedEnumMap
  {
      using UnderlyingType = typename std::underlying_type<E>::type;
      using Storage        = std::array<T, MaxSize>;
  
    public:
      // types:
      using value_type      = T;
      using pointer         = T *;
      using const_pointer   = const T *;
      using reference       = T &;
      using const_reference = const T &;
  
      using size_type       = size_t;
      using difference_type = ptrdiff_t;
  
      using iterator               = typename Storage::iterator;
      using const_iterator         = typename Storage::const_iterator;
      using reverse_iterator       = std::reverse_iterator<iterator>;
      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
  
      // No explicit construct/copy/destroy for aggregate type
      void fill(const T &u) { mPrivateData.fill(u); }
      void swap(PackedEnumMap<E, T> &a) noexcept { mPrivateData.swap(a.mPrivateData); }
  
      // iterators:
      iterator begin() noexcept { return mPrivateData.begin(); }
      const_iterator begin() const noexcept { return mPrivateData.begin(); }
      iterator end() noexcept { return mPrivateData.end(); }
      const_iterator end() const noexcept { return mPrivateData.end(); }
  
      reverse_iterator rbegin() noexcept { return mPrivateData.rbegin(); }
      const_reverse_iterator rbegin() const noexcept { return mPrivateData.rbegin(); }
      reverse_iterator rend() noexcept { return mPrivateData.rend(); }
      const_reverse_iterator rend() const noexcept { return mPrivateData.rend(); }
  
      // capacity:
      constexpr size_type size() const noexcept { return mPrivateData.size(); }
      constexpr size_type max_size() const noexcept { return mPrivateData.max_size(); }
      constexpr bool empty() const noexcept { return mPrivateData.empty(); }
  
      // element access:
      reference operator[](E n) { return mPrivateData[static_cast<UnderlyingType>(n)]; }
      const_reference operator[](E n) const { return mPrivateData[static_cast<UnderlyingType>(n)]; }
      const_reference at(E n) const { return mPrivateData.at(static_cast<UnderlyingType>(n)); }
      reference at(E n) { return mPrivateData.at(static_cast<UnderlyingType>(n)); }
  
      reference front() { return mPrivateData.front(); }
      const_reference front() const { return mPrivateData.front(); }
      reference back() { return mPrivateData.back(); }
      const_reference back() const { return mPrivateData.back(); }
  
      T *data() noexcept { return mPrivateData.data(); }
      const T *data() const noexcept { return mPrivateData.data(); }
  
      // Do not access this variable directly. It unfortunately must be public to use aggregate init.
      /* private: */ Storage mPrivateData;
  };
  
  // PackedEnumBitSetE> is like an std::bitset<E::EnumCount> but is indexed with enum values. It
  // implements the std::bitset interface except with enum values instead of indices.
  template <typename E, typename DataT = uint32_t>
  using PackedEnumBitSet = BitSetT<EnumSize<E>(), DataT, E>;
  
  }  // namespace angle
  
  namespace gl
  {
  
  TextureType TextureTargetToType(TextureTarget target);
  TextureTarget NonCubeTextureTypeToTarget(TextureType type);
  
  TextureTarget CubeFaceIndexToTextureTarget(size_t face);
  size_t CubeMapTextureTargetToFaceIndex(TextureTarget target);
  bool IsCubeMapFaceTarget(TextureTarget target);
  
  constexpr TextureTarget kCubeMapTextureTargetMin = TextureTarget::CubeMapPositiveX;
  constexpr TextureTarget kCubeMapTextureTargetMax = TextureTarget::CubeMapNegativeZ;
  constexpr TextureTarget kAfterCubeMapTextureTargetMax =
      static_cast<TextureTarget>(static_cast<uint8_t>(kCubeMapTextureTargetMax) + 1);
  struct AllCubeFaceTextureTargets
  {
      angle::EnumIterator<TextureTarget> begin() const { return kCubeMapTextureTargetMin; }
      angle::EnumIterator<TextureTarget> end() const { return kAfterCubeMapTextureTargetMax; }
  };
  
  constexpr ShaderType kGLES2ShaderTypeMin = ShaderType::Vertex;
  constexpr ShaderType kGLES2ShaderTypeMax = ShaderType::Fragment;
  constexpr ShaderType kAfterGLES2ShaderTypeMax =
      static_cast<ShaderType>(static_cast<uint8_t>(kGLES2ShaderTypeMax) + 1);
  struct AllGLES2ShaderTypes
  {
      angle::EnumIterator<ShaderType> begin() const { return kGLES2ShaderTypeMin; }
      angle::EnumIterator<ShaderType> end() const { return kAfterGLES2ShaderTypeMax; }
  };
  
  constexpr ShaderType kShaderTypeMin = ShaderType::Vertex;
  constexpr ShaderType kShaderTypeMax = ShaderType::Compute;
  constexpr ShaderType kAfterShaderTypeMax =
      static_cast<ShaderType>(static_cast<uint8_t>(kShaderTypeMax) + 1);
  struct AllShaderTypes
  {
      angle::EnumIterator<ShaderType> begin() const { return kShaderTypeMin; }
      angle::EnumIterator<ShaderType> end() const { return kAfterShaderTypeMax; }
  };
  
  constexpr size_t kGraphicsShaderCount = static_cast<size_t>(ShaderType::EnumCount) - 1u;
  // Arrange the shader types in the order of rendering pipeline
  constexpr std::array<ShaderType, kGraphicsShaderCount> kAllGraphicsShaderTypes = {
      ShaderType::Vertex, ShaderType::Geometry, ShaderType::Fragment};
  
  using ShaderBitSet = angle::PackedEnumBitSet<ShaderType, uint8_t>;
  static_assert(sizeof(ShaderBitSet) == sizeof(uint8_t), "Unexpected size");
  
  template <typename T>
  using ShaderMap = angle::PackedEnumMap<ShaderType, T>;
  
  TextureType SamplerTypeToTextureType(GLenum samplerType);
  
  bool IsMultisampled(gl::TextureType type);
  
  }  // namespace gl
  
  namespace egl
  {
  MessageType ErrorCodeToMessageType(EGLint errorCode);
  }  // namespace egl
  
  namespace egl_gl
  {
  gl::TextureTarget EGLCubeMapTargetToCubeMapTarget(EGLenum eglTarget);
  gl::TextureTarget EGLImageTargetToTextureTarget(EGLenum eglTarget);
  gl::TextureType EGLTextureTargetToTextureType(EGLenum eglTarget);
  }  // namespace egl_gl
  
  #endif  // COMMON_PACKEDGLENUMS_H_
  

Download