| // 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, size_t MaxSize = EnumSize<E>()> |
| struct AllEnums |
| { |
| EnumIterator<E> begin() const { return {static_cast<E>(0)}; } |
| EnumIterator<E> end() const { return {static_cast<E>(MaxSize)}; } |
| }; |
| |
| // 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: |
| using InitPair = std::pair<E, T>; |
| |
| constexpr PackedEnumMap() = default; |
| |
| constexpr PackedEnumMap(std::initializer_list<InitPair> init) : mPrivateData{} |
| { |
| // We use a for loop instead of range-for to work around a limitation in MSVC. |
| for (const InitPair *it = init.begin(); it != init.end(); ++it) |
| { |
| mPrivateData[static_cast<UnderlyingType>(it->first)] = it->second; |
| } |
| } |
| |
| // 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, MaxSize> &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) |
| { |
| ASSERT(static_cast<size_t>(n) < mPrivateData.size()); |
| return mPrivateData[static_cast<UnderlyingType>(n)]; |
| } |
| |
| constexpr const_reference operator[](E n) const |
| { |
| ASSERT(static_cast<size_t>(n) < mPrivateData.size()); |
| 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(); } |
| |
| bool operator==(const PackedEnumMap &rhs) const { return mPrivateData == rhs.mPrivateData; } |
| bool operator!=(const PackedEnumMap &rhs) const { return mPrivateData != rhs.mPrivateData; } |
| |
| template <typename SubT = T> |
| typename std::enable_if<std::is_integral<SubT>::value>::type operator+=( |
| const PackedEnumMap<E, SubT, MaxSize> &rhs) |
| { |
| for (E e : AllEnums<E, MaxSize>()) |
| { |
| at(e) += rhs[e]; |
| } |
| } |
| |
| 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 |
| |
| #define ANGLE_DEFINE_ID_TYPE(Type) \ |
| class Type; \ |
| struct Type##ID \ |
| { \ |
| GLuint value; \ |
| }; \ |
| template <> \ |
| struct ResourceTypeToID<Type> \ |
| { \ |
| using IDType = Type##ID; \ |
| }; \ |
| template <> \ |
| struct IsResourceIDType<Type##ID> \ |
| { \ |
| static constexpr bool value = true; \ |
| }; |
| |
| 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 std::array<ShaderType, 2> kAllGLES2ShaderTypes = {ShaderType::Vertex, |
| ShaderType::Fragment}; |
| |
| 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::TessControl, ShaderType::TessEvaluation, 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>; |
| |
| const char *ShaderTypeToString(ShaderType shaderType); |
| |
| TextureType SamplerTypeToTextureType(GLenum samplerType); |
| TextureType ImageTypeToTextureType(GLenum imageType); |
| |
| bool IsMultisampled(gl::TextureType type); |
| bool IsArrayTextureType(gl::TextureType type); |
| |
| bool IsStaticBufferUsage(BufferUsage useage); |
| |
| enum class PrimitiveMode : uint8_t |
| { |
| Points = 0x0, |
| Lines = 0x1, |
| LineLoop = 0x2, |
| LineStrip = 0x3, |
| Triangles = 0x4, |
| TriangleStrip = 0x5, |
| TriangleFan = 0x6, |
| Unused1 = 0x7, |
| Unused2 = 0x8, |
| Unused3 = 0x9, |
| LinesAdjacency = 0xA, |
| LineStripAdjacency = 0xB, |
| TrianglesAdjacency = 0xC, |
| TriangleStripAdjacency = 0xD, |
| Patches = 0xE, |
| |
| InvalidEnum = 0xF, |
| EnumCount = 0xF, |
| }; |
| |
| template <> |
| constexpr PrimitiveMode FromGLenum<PrimitiveMode>(GLenum from) |
| { |
| if (from >= static_cast<GLenum>(PrimitiveMode::EnumCount)) |
| { |
| return PrimitiveMode::InvalidEnum; |
| } |
| |
| return static_cast<PrimitiveMode>(from); |
| } |
| |
| constexpr GLenum ToGLenum(PrimitiveMode from) |
| { |
| return static_cast<GLenum>(from); |
| } |
| |
| static_assert(ToGLenum(PrimitiveMode::Points) == GL_POINTS, "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::Lines) == GL_LINES, "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::LineLoop) == GL_LINE_LOOP, "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::LineStrip) == GL_LINE_STRIP, "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::Triangles) == GL_TRIANGLES, "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::TriangleStrip) == GL_TRIANGLE_STRIP, |
| "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::TriangleFan) == GL_TRIANGLE_FAN, "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::LinesAdjacency) == GL_LINES_ADJACENCY, |
| "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::LineStripAdjacency) == GL_LINE_STRIP_ADJACENCY, |
| "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::TrianglesAdjacency) == GL_TRIANGLES_ADJACENCY, |
| "PrimitiveMode violation"); |
| static_assert(ToGLenum(PrimitiveMode::TriangleStripAdjacency) == GL_TRIANGLE_STRIP_ADJACENCY, |
| "PrimitiveMode violation"); |
| |
| std::ostream &operator<<(std::ostream &os, PrimitiveMode value); |
| |
| enum class DrawElementsType : size_t |
| { |
| UnsignedByte = 0, |
| UnsignedShort = 1, |
| UnsignedInt = 2, |
| InvalidEnum = 3, |
| EnumCount = 3, |
| }; |
| |
| template <> |
| constexpr DrawElementsType FromGLenum<DrawElementsType>(GLenum from) |
| { |
| |
| GLenum scaled = (from - GL_UNSIGNED_BYTE); |
| // This code sequence generates a ROR instruction on x86/arm. We want to check if the lowest bit |
| // of scaled is set and if (scaled >> 1) is greater than a non-pot value. If we rotate the |
| // lowest bit to the hightest bit both conditions can be checked with a single test. |
| static_assert(sizeof(GLenum) == 4, "Update (scaled << 31) to sizeof(GLenum) * 8 - 1"); |
| GLenum packed = (scaled >> 1) | (scaled << 31); |
| |
| // operator ? with a simple assignment usually translates to a cmov instruction and thus avoids |
| // a branch. |
| packed = (packed >= static_cast<GLenum>(DrawElementsType::EnumCount)) |
| ? static_cast<GLenum>(DrawElementsType::InvalidEnum) |
| : packed; |
| |
| return static_cast<DrawElementsType>(packed); |
| } |
| |
| constexpr GLenum ToGLenum(DrawElementsType from) |
| { |
| return ((static_cast<GLenum>(from) << 1) + GL_UNSIGNED_BYTE); |
| } |
| |
| #define ANGLE_VALIDATE_PACKED_ENUM(type, packed, glenum) \ |
| static_assert(ToGLenum(type::packed) == glenum, #type " violation"); \ |
| static_assert(FromGLenum<type>(glenum) == type::packed, #type " violation") |
| |
| ANGLE_VALIDATE_PACKED_ENUM(DrawElementsType, UnsignedByte, GL_UNSIGNED_BYTE); |
| ANGLE_VALIDATE_PACKED_ENUM(DrawElementsType, UnsignedShort, GL_UNSIGNED_SHORT); |
| ANGLE_VALIDATE_PACKED_ENUM(DrawElementsType, UnsignedInt, GL_UNSIGNED_INT); |
| |
| std::ostream &operator<<(std::ostream &os, DrawElementsType value); |
| |
| enum class BlendEquationType |
| { |
| Add = 0, // GLenum == 0x8006 |
| Min = 1, // GLenum == 0x8007 |
| Max = 2, // GLenum == 0x8008 |
| Unused = 3, |
| Subtract = 4, // GLenum == 0x800A |
| ReverseSubtract = 5, // GLenum == 0x800B |
| |
| Multiply = 6, // GLenum == 0x9294 |
| Screen = 7, // GLenum == 0x9295 |
| Overlay = 8, // GLenum == 0x9296 |
| Darken = 9, // GLenum == 0x9297 |
| Lighten = 10, // GLenum == 0x9298 |
| Colordodge = 11, // GLenum == 0x9299 |
| Colorburn = 12, // GLenum == 0x929A |
| Hardlight = 13, // GLenum == 0x929B |
| Softlight = 14, // GLenum == 0x929C |
| Unused2 = 15, |
| Difference = 16, // GLenum == 0x929E |
| Unused3 = 17, |
| Exclusion = 18, // GLenum == 0x92A0 |
| |
| HslHue = 19, // GLenum == 0x92AD |
| HslSaturation = 20, // GLenum == 0x92AE |
| HslColor = 21, // GLenum == 0x92AF |
| HslLuminosity = 22, // GLenum == 0x92B0 |
| |
| InvalidEnum = 23, |
| EnumCount = InvalidEnum |
| }; |
| |
| using BlendEquationBitSet = angle::PackedEnumBitSet<gl::BlendEquationType>; |
| |
| template <> |
| constexpr BlendEquationType FromGLenum<BlendEquationType>(GLenum from) |
| { |
| if (from <= GL_FUNC_REVERSE_SUBTRACT) |
| { |
| const GLenum scaled = (from - GL_FUNC_ADD); |
| return (scaled == static_cast<GLenum>(BlendEquationType::Unused)) |
| ? BlendEquationType::InvalidEnum |
| : static_cast<BlendEquationType>(scaled); |
| } |
| if (from <= GL_EXCLUSION_KHR) |
| { |
| const GLenum scaled = |
| (from - GL_MULTIPLY_KHR + static_cast<uint32_t>(BlendEquationType::Multiply)); |
| return (scaled == static_cast<GLenum>(BlendEquationType::Unused2) || |
| scaled == static_cast<GLenum>(BlendEquationType::Unused3)) |
| ? BlendEquationType::InvalidEnum |
| : static_cast<BlendEquationType>(scaled); |
| } |
| if (from <= GL_HSL_LUMINOSITY_KHR) |
| { |
| return static_cast<BlendEquationType>(from - GL_HSL_HUE_KHR + |
| static_cast<uint32_t>(BlendEquationType::HslHue)); |
| } |
| return BlendEquationType::InvalidEnum; |
| } |
| |
| constexpr GLenum ToGLenum(BlendEquationType from) |
| { |
| if (from <= BlendEquationType::ReverseSubtract) |
| { |
| return static_cast<GLenum>(from) + GL_FUNC_ADD; |
| } |
| if (from <= BlendEquationType::Exclusion) |
| { |
| return static_cast<GLenum>(from) - static_cast<GLenum>(BlendEquationType::Multiply) + |
| GL_MULTIPLY_KHR; |
| } |
| return static_cast<GLenum>(from) - static_cast<GLenum>(BlendEquationType::HslHue) + |
| GL_HSL_HUE_KHR; |
| } |
| |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Add, GL_FUNC_ADD); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Min, GL_MIN); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Max, GL_MAX); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Subtract, GL_FUNC_SUBTRACT); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, ReverseSubtract, GL_FUNC_REVERSE_SUBTRACT); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Multiply, GL_MULTIPLY_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Screen, GL_SCREEN_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Overlay, GL_OVERLAY_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Darken, GL_DARKEN_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Lighten, GL_LIGHTEN_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Colordodge, GL_COLORDODGE_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Colorburn, GL_COLORBURN_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Hardlight, GL_HARDLIGHT_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Softlight, GL_SOFTLIGHT_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Difference, GL_DIFFERENCE_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, Exclusion, GL_EXCLUSION_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, HslHue, GL_HSL_HUE_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, HslSaturation, GL_HSL_SATURATION_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, HslColor, GL_HSL_COLOR_KHR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendEquationType, HslLuminosity, GL_HSL_LUMINOSITY_KHR); |
| |
| std::ostream &operator<<(std::ostream &os, BlendEquationType value); |
| |
| enum class BlendFactorType |
| { |
| Zero = 0, // GLenum == 0 |
| One = 1, // GLenum == 1 |
| |
| MinSrcDstType = 2, |
| SrcColor = 2, // GLenum == 0x0300 |
| OneMinusSrcColor = 3, // GLenum == 0x0301 |
| SrcAlpha = 4, // GLenum == 0x0302 |
| OneMinusSrcAlpha = 5, // GLenum == 0x0303 |
| DstAlpha = 6, // GLenum == 0x0304 |
| OneMinusDstAlpha = 7, // GLenum == 0x0305 |
| DstColor = 8, // GLenum == 0x0306 |
| OneMinusDstColor = 9, // GLenum == 0x0307 |
| SrcAlphaSaturate = 10, // GLenum == 0x0308 |
| MaxSrcDstType = 10, |
| |
| MinConstantType = 11, |
| ConstantColor = 11, // GLenum == 0x8001 |
| OneMinusConstantColor = 12, // GLenum == 0x8002 |
| ConstantAlpha = 13, // GLenum == 0x8003 |
| OneMinusConstantAlpha = 14, // GLenum == 0x8004 |
| MaxConstantType = 14, |
| |
| // GL_EXT_blend_func_extended |
| |
| Src1Alpha = 15, // GLenum == 0x8589 |
| |
| Src1Color = 16, // GLenum == 0x88F9 |
| OneMinusSrc1Color = 17, // GLenum == 0x88FA |
| OneMinusSrc1Alpha = 18, // GLenum == 0x88FB |
| |
| InvalidEnum = 19, |
| EnumCount = 19 |
| }; |
| |
| template <> |
| constexpr BlendFactorType FromGLenum<BlendFactorType>(GLenum from) |
| { |
| if (from <= 1) |
| return static_cast<BlendFactorType>(from); |
| if (from >= GL_SRC_COLOR && from <= GL_SRC_ALPHA_SATURATE) |
| return static_cast<BlendFactorType>(from - GL_SRC_COLOR + 2); |
| if (from >= GL_CONSTANT_COLOR && from <= GL_ONE_MINUS_CONSTANT_ALPHA) |
| return static_cast<BlendFactorType>(from - GL_CONSTANT_COLOR + 11); |
| if (from == GL_SRC1_ALPHA_EXT) |
| return BlendFactorType::Src1Alpha; |
| if (from >= GL_SRC1_COLOR_EXT && from <= GL_ONE_MINUS_SRC1_ALPHA_EXT) |
| return static_cast<BlendFactorType>(from - GL_SRC1_COLOR_EXT + 16); |
| return BlendFactorType::InvalidEnum; |
| } |
| |
| constexpr GLenum ToGLenum(BlendFactorType from) |
| { |
| const GLenum value = static_cast<GLenum>(from); |
| if (value <= 1) |
| return value; |
| if (from >= BlendFactorType::MinSrcDstType && from <= BlendFactorType::MaxSrcDstType) |
| return value - 2 + GL_SRC_COLOR; |
| if (from >= BlendFactorType::MinConstantType && from <= BlendFactorType::MaxConstantType) |
| return value - 11 + GL_CONSTANT_COLOR; |
| if (from == BlendFactorType::Src1Alpha) |
| return GL_SRC1_ALPHA_EXT; |
| return value - 16 + GL_SRC1_COLOR_EXT; |
| } |
| |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, Zero, GL_ZERO); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, One, GL_ONE); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, SrcColor, GL_SRC_COLOR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusSrcColor, GL_ONE_MINUS_SRC_COLOR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, SrcAlpha, GL_SRC_ALPHA); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusSrcAlpha, GL_ONE_MINUS_SRC_ALPHA); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, DstAlpha, GL_DST_ALPHA); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusDstAlpha, GL_ONE_MINUS_DST_ALPHA); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, DstColor, GL_DST_COLOR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusDstColor, GL_ONE_MINUS_DST_COLOR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, SrcAlphaSaturate, GL_SRC_ALPHA_SATURATE); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, ConstantColor, GL_CONSTANT_COLOR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusConstantColor, GL_ONE_MINUS_CONSTANT_COLOR); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, ConstantAlpha, GL_CONSTANT_ALPHA); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusConstantAlpha, GL_ONE_MINUS_CONSTANT_ALPHA); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, Src1Alpha, GL_SRC1_ALPHA_EXT); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, Src1Color, GL_SRC1_COLOR_EXT); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusSrc1Color, GL_ONE_MINUS_SRC1_COLOR_EXT); |
| ANGLE_VALIDATE_PACKED_ENUM(BlendFactorType, OneMinusSrc1Alpha, GL_ONE_MINUS_SRC1_ALPHA_EXT); |
| |
| std::ostream &operator<<(std::ostream &os, BlendFactorType value); |
| |
| enum class VertexAttribType |
| { |
| Byte = 0, // GLenum == 0x1400 |
| UnsignedByte = 1, // GLenum == 0x1401 |
| Short = 2, // GLenum == 0x1402 |
| UnsignedShort = 3, // GLenum == 0x1403 |
| Int = 4, // GLenum == 0x1404 |
| UnsignedInt = 5, // GLenum == 0x1405 |
| Float = 6, // GLenum == 0x1406 |
| Unused1 = 7, // GLenum == 0x1407 |
| Unused2 = 8, // GLenum == 0x1408 |
| Unused3 = 9, // GLenum == 0x1409 |
| Unused4 = 10, // GLenum == 0x140A |
| HalfFloat = 11, // GLenum == 0x140B |
| Fixed = 12, // GLenum == 0x140C |
| MaxBasicType = 12, |
| UnsignedInt2101010 = 13, // GLenum == 0x8368 |
| HalfFloatOES = 14, // GLenum == 0x8D61 |
| Int2101010 = 15, // GLenum == 0x8D9F |
| UnsignedInt1010102 = 16, // GLenum == 0x8DF6 |
| Int1010102 = 17, // GLenum == 0x8DF7 |
| InvalidEnum = 18, |
| EnumCount = 18, |
| }; |
| |
| template <> |
| constexpr VertexAttribType FromGLenum<VertexAttribType>(GLenum from) |
| { |
| GLenum packed = from - GL_BYTE; |
| if (packed <= static_cast<GLenum>(VertexAttribType::MaxBasicType)) |
| return static_cast<VertexAttribType>(packed); |
| if (from == GL_UNSIGNED_INT_2_10_10_10_REV) |
| return VertexAttribType::UnsignedInt2101010; |
| if (from == GL_HALF_FLOAT_OES) |
| return VertexAttribType::HalfFloatOES; |
| if (from == GL_INT_2_10_10_10_REV) |
| return VertexAttribType::Int2101010; |
| if (from == GL_UNSIGNED_INT_10_10_10_2_OES) |
| return VertexAttribType::UnsignedInt1010102; |
| if (from == GL_INT_10_10_10_2_OES) |
| return VertexAttribType::Int1010102; |
| return VertexAttribType::InvalidEnum; |
| } |
| |
| constexpr GLenum ToGLenum(VertexAttribType from) |
| { |
| // This could be optimized using a constexpr table. |
| if (from == VertexAttribType::Int2101010) |
| return GL_INT_2_10_10_10_REV; |
| if (from == VertexAttribType::HalfFloatOES) |
| return GL_HALF_FLOAT_OES; |
| if (from == VertexAttribType::UnsignedInt2101010) |
| return GL_UNSIGNED_INT_2_10_10_10_REV; |
| if (from == VertexAttribType::UnsignedInt1010102) |
| return GL_UNSIGNED_INT_10_10_10_2_OES; |
| if (from == VertexAttribType::Int1010102) |
| return GL_INT_10_10_10_2_OES; |
| return static_cast<GLenum>(from) + GL_BYTE; |
| } |
| |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, Byte, GL_BYTE); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, UnsignedByte, GL_UNSIGNED_BYTE); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, Short, GL_SHORT); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, UnsignedShort, GL_UNSIGNED_SHORT); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, Int, GL_INT); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, UnsignedInt, GL_UNSIGNED_INT); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, Float, GL_FLOAT); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, HalfFloat, GL_HALF_FLOAT); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, Fixed, GL_FIXED); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, Int2101010, GL_INT_2_10_10_10_REV); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, HalfFloatOES, GL_HALF_FLOAT_OES); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, UnsignedInt2101010, GL_UNSIGNED_INT_2_10_10_10_REV); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, Int1010102, GL_INT_10_10_10_2_OES); |
| ANGLE_VALIDATE_PACKED_ENUM(VertexAttribType, UnsignedInt1010102, GL_UNSIGNED_INT_10_10_10_2_OES); |
| |
| std::ostream &operator<<(std::ostream &os, VertexAttribType value); |
| |
| enum class TessEvaluationType |
| { |
| Triangles = 0, |
| Quads = 1, |
| Isolines = 2, |
| EqualSpacing = 3, |
| FractionalEvenSpacing = 4, |
| FractionalOddSpacing = 5, |
| Cw = 6, |
| Ccw = 7, |
| PointMode = 8, |
| InvalidEnum = 9, |
| EnumCount = 9 |
| }; |
| |
| template <> |
| constexpr TessEvaluationType FromGLenum<TessEvaluationType>(GLenum from) |
| { |
| if (from == GL_TRIANGLES) |
| return TessEvaluationType::Triangles; |
| if (from == GL_QUADS) |
| return TessEvaluationType::Quads; |
| if (from == GL_ISOLINES) |
| return TessEvaluationType::Isolines; |
| if (from == GL_EQUAL) |
| return TessEvaluationType::EqualSpacing; |
| if (from == GL_FRACTIONAL_EVEN) |
| return TessEvaluationType::FractionalEvenSpacing; |
| if (from == GL_FRACTIONAL_ODD) |
| return TessEvaluationType::FractionalOddSpacing; |
| if (from == GL_CW) |
| return TessEvaluationType::Cw; |
| if (from == GL_CCW) |
| return TessEvaluationType::Ccw; |
| if (from == GL_TESS_GEN_POINT_MODE) |
| return TessEvaluationType::PointMode; |
| return TessEvaluationType::InvalidEnum; |
| } |
| |
| constexpr GLenum ToGLenum(TessEvaluationType from) |
| { |
| switch (from) |
| { |
| case TessEvaluationType::Triangles: |
| return GL_TRIANGLES; |
| case TessEvaluationType::Quads: |
| return GL_QUADS; |
| case TessEvaluationType::Isolines: |
| return GL_ISOLINES; |
| case TessEvaluationType::EqualSpacing: |
| return GL_EQUAL; |
| case TessEvaluationType::FractionalEvenSpacing: |
| return GL_FRACTIONAL_EVEN; |
| case TessEvaluationType::FractionalOddSpacing: |
| return GL_FRACTIONAL_ODD; |
| case TessEvaluationType::Cw: |
| return GL_CW; |
| case TessEvaluationType::Ccw: |
| return GL_CCW; |
| case TessEvaluationType::PointMode: |
| return GL_TESS_GEN_POINT_MODE; |
| default: |
| return GL_INVALID_ENUM; |
| } |
| } |
| |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, Triangles, GL_TRIANGLES); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, Quads, GL_QUADS); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, Isolines, GL_ISOLINES); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, EqualSpacing, GL_EQUAL); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, FractionalEvenSpacing, GL_FRACTIONAL_EVEN); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, FractionalOddSpacing, GL_FRACTIONAL_ODD); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, Cw, GL_CW); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, Ccw, GL_CCW); |
| ANGLE_VALIDATE_PACKED_ENUM(TessEvaluationType, PointMode, GL_TESS_GEN_POINT_MODE); |
| |
| std::ostream &operator<<(std::ostream &os, TessEvaluationType value); |
| |
| // Typesafe object handles. |
| |
| template <typename T> |
| struct ResourceTypeToID; |
| |
| template <typename T> |
| struct IsResourceIDType; |
| |
| #define ANGLE_GL_ID_TYPES_OP(X) \ |
| X(Buffer) \ |
| X(Context) \ |
| X(FenceNV) \ |
| X(Framebuffer) \ |
| X(MemoryObject) \ |
| X(Path) \ |
| X(ProgramPipeline) \ |
| X(Query) \ |
| X(Renderbuffer) \ |
| X(Sampler) \ |
| X(Semaphore) \ |
| X(Sync) \ |
| X(Texture) \ |
| X(TransformFeedback) \ |
| X(VertexArray) |
| |
| ANGLE_GL_ID_TYPES_OP(ANGLE_DEFINE_ID_TYPE) |
| |
| #undef ANGLE_GL_ID_TYPES_OP |
| |
| // Shaders and programs are a bit special as they share IDs. |
| struct ShaderProgramID |
| { |
| GLuint value; |
| }; |
| |
| template <> |
| struct IsResourceIDType<ShaderProgramID> |
| { |
| constexpr static bool value = true; |
| }; |
| |
| class Shader; |
| template <> |
| struct ResourceTypeToID<Shader> |
| { |
| using IDType = ShaderProgramID; |
| }; |
| |
| class Program; |
| template <> |
| struct ResourceTypeToID<Program> |
| { |
| using IDType = ShaderProgramID; |
| }; |
| |
| template <typename T> |
| struct ResourceTypeToID |
| { |
| using IDType = void; |
| }; |
| |
| template <typename T> |
| struct IsResourceIDType |
| { |
| static constexpr bool value = false; |
| }; |
| |
| template <typename T> |
| bool ValueEquals(T lhs, T rhs) |
| { |
| return lhs.value == rhs.value; |
| } |
| |
| // Util funcs for resourceIDs |
| template <typename T> |
| typename std::enable_if<IsResourceIDType<T>::value, bool>::type operator==(const T &lhs, |
| const T &rhs) |
| { |
| return lhs.value == rhs.value; |
| } |
| |
| template <typename T> |
| typename std::enable_if<IsResourceIDType<T>::value, bool>::type operator!=(const T &lhs, |
| const T &rhs) |
| { |
| return lhs.value != rhs.value; |
| } |
| |
| template <typename T> |
| typename std::enable_if<IsResourceIDType<T>::value, bool>::type operator<(const T &lhs, |
| const T &rhs) |
| { |
| return lhs.value < rhs.value; |
| } |
| |
| // Used to unbox typed values. |
| template <typename ResourceIDType> |
| GLuint GetIDValue(ResourceIDType id); |
| |
| template <> |
| inline GLuint GetIDValue(GLuint id) |
| { |
| return id; |
| } |
| |
| template <typename ResourceIDType> |
| inline GLuint GetIDValue(ResourceIDType id) |
| { |
| return id.value; |
| } |
| |
| struct UniformLocation |
| { |
| int value; |
| }; |
| |
| bool operator<(const UniformLocation &lhs, const UniformLocation &rhs); |
| |
| struct UniformBlockIndex |
| { |
| uint32_t value; |
| }; |
| |
| bool IsEmulatedCompressedFormat(GLenum format); |
| } // namespace gl |
| |
| namespace egl |
| { |
| MessageType ErrorCodeToMessageType(EGLint errorCode); |
| |
| struct Config; |
| class Device; |
| class Display; |
| class Image; |
| class Surface; |
| class Stream; |
| class Sync; |
| |
| #define ANGLE_EGL_ID_TYPES_OP(X) \ |
| X(Image) \ |
| X(Surface) \ |
| X(Sync) |
| |
| template <typename T> |
| struct ResourceTypeToID; |
| |
| template <typename T> |
| struct IsResourceIDType; |
| |
| ANGLE_EGL_ID_TYPES_OP(ANGLE_DEFINE_ID_TYPE) |
| |
| #undef ANGLE_EGL_ID_TYPES_OP |
| |
| template <> |
| struct IsResourceIDType<gl::ContextID> |
| { |
| static constexpr bool value = true; |
| }; |
| |
| template <typename T> |
| struct IsResourceIDType |
| { |
| static constexpr bool value = false; |
| }; |
| |
| // Util funcs for resourceIDs |
| template <typename T> |
| typename std::enable_if<IsResourceIDType<T>::value && !std::is_same<T, gl::ContextID>::value, |
| bool>::type |
| operator==(const T &lhs, const T &rhs) |
| { |
| return lhs.value == rhs.value; |
| } |
| |
| template <typename T> |
| typename std::enable_if<IsResourceIDType<T>::value && !std::is_same<T, gl::ContextID>::value, |
| bool>::type |
| operator<(const T &lhs, const T &rhs) |
| { |
| return lhs.value < rhs.value; |
| } |
| } // namespace egl |
| |
| #undef ANGLE_DEFINE_ID_TYPE |
| |
| namespace egl_gl |
| { |
| gl::TextureTarget EGLCubeMapTargetToCubeMapTarget(EGLenum eglTarget); |
| gl::TextureTarget EGLImageTargetToTextureTarget(EGLenum eglTarget); |
| gl::TextureType EGLTextureTargetToTextureType(EGLenum eglTarget); |
| } // namespace egl_gl |
| |
| namespace gl |
| { |
| // First case: handling packed enums. |
| template <typename EnumT, typename FromT> |
| typename std::enable_if<std::is_enum<EnumT>::value, EnumT>::type PackParam(FromT from) |
| { |
| return FromGLenum<EnumT>(from); |
| } |
| |
| // Second case: handling non-pointer resource ids. |
| template <typename EnumT, typename FromT> |
| typename std::enable_if<!std::is_pointer<FromT>::value && !std::is_enum<EnumT>::value, EnumT>::type |
| PackParam(FromT from) |
| { |
| return {from}; |
| } |
| |
| template <typename EnumT> |
| using IsEGLImage = std::is_same<EnumT, egl::ImageID>; |
| |
| template <typename EnumT> |
| using IsGLSync = std::is_same<EnumT, gl::SyncID>; |
| |
| template <typename EnumT> |
| using IsEGLSync = std::is_same<EnumT, egl::SyncID>; |
| |
| // Third case: handling EGLImage, GLSync and EGLSync pointer resource ids. |
| template <typename EnumT, typename FromT> |
| typename std::enable_if<IsEGLImage<EnumT>::value || IsGLSync<EnumT>::value || |
| IsEGLSync<EnumT>::value, |
| EnumT>::type |
| PackParam(FromT from) |
| { |
| return {static_cast<GLuint>(reinterpret_cast<uintptr_t>(from))}; |
| } |
| |
| // Fourth case: handling non-EGLImage non-GLsync resource ids. |
| template <typename EnumT, typename FromT> |
| typename std::enable_if<std::is_pointer<FromT>::value && !std::is_enum<EnumT>::value && |
| !IsEGLImage<EnumT>::value && !IsGLSync<EnumT>::value, |
| EnumT>::type |
| PackParam(FromT from) |
| { |
| static_assert(sizeof(typename std::remove_pointer<EnumT>::type) == |
| sizeof(typename std::remove_pointer<FromT>::type), |
| "Types have different sizes"); |
| static_assert( |
| std::is_same< |
| decltype(std::remove_pointer<EnumT>::type::value), |
| typename std::remove_const<typename std::remove_pointer<FromT>::type>::type>::value, |
| "Data types are different"); |
| return reinterpret_cast<EnumT>(from); |
| } |
| } // namespace gl |
| |
| #endif // COMMON_PACKEDGLENUMS_H_ |
