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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jonah Ryan-Davis
  Date : 2019-11-14 16:49:02
  Hash : a829c0b9
  Message : Expose EGL_CHROMIUM_sync_control via GLX_OML_sync_control On GLX, we can expose the EGL_CHROMIUM_sync_control extension by forwarding to GLX_OML_sync_control when it's available. This will help with accurate vsync times for Chrome Bug: 1020252 Change-Id: I9b1e8cf0f8b1a548cc7cc7202fac2d0cdb01d74d Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1918104 Commit-Queue: Jonah Ryan-Davis <jonahr@google.com> Reviewed-by: Corentin Wallez <cwallez@chromium.org>

• src/libANGLE/Caps.h

• //
  // Copyright 2014 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.
  //
  
  #ifndef LIBANGLE_CAPS_H_
  #define LIBANGLE_CAPS_H_
  
  #include "angle_gl.h"
  #include "libANGLE/Version.h"
  #include "libANGLE/angletypes.h"
  #include "libANGLE/renderer/Format.h"
  
  #include <array>
  #include <map>
  #include <set>
  #include <string>
  #include <vector>
  
  namespace gl
  {
  
  struct Extensions;
  
  struct TextureCaps
  {
      TextureCaps();
      TextureCaps(const TextureCaps &other);
      ~TextureCaps();
  
      // Supports for basic texturing: glTexImage, glTexSubImage, etc
      bool texturable = false;
  
      // Support for linear or anisotropic filtering
      bool filterable = false;
  
      // Support for being used as a framebuffer attachment, i.e. glFramebufferTexture2D
      bool textureAttachment = false;
  
      // Support for being used as a renderbuffer format, i.e. glFramebufferRenderbuffer
      bool renderbuffer = false;
  
      // Set of supported sample counts, only guaranteed to be valid in ES3.
      SupportedSampleSet sampleCounts;
  
      // Get the maximum number of samples supported
      GLuint getMaxSamples() const;
  
      // Get the number of supported samples that is at least as many as requested.  Returns 0 if
      // there are no sample counts available
      GLuint getNearestSamples(GLuint requestedSamples) const;
  };
  
  TextureCaps GenerateMinimumTextureCaps(GLenum internalFormat,
                                         const Version &clientVersion,
                                         const Extensions &extensions);
  
  class TextureCapsMap final : angle::NonCopyable
  {
    public:
      TextureCapsMap();
      ~TextureCapsMap();
  
      // These methods are deprecated. Please use angle::Format for new features.
      void insert(GLenum internalFormat, const TextureCaps &caps);
      const TextureCaps &get(GLenum internalFormat) const;
  
      void clear();
  
      // Prefer using angle::Format methods.
      const TextureCaps &get(angle::FormatID formatID) const;
      void set(angle::FormatID formatID, const TextureCaps &caps);
  
    private:
      TextureCaps &get(angle::FormatID formatID);
  
      // Indexed by angle::FormatID
      std::array<TextureCaps, angle::kNumANGLEFormats> mFormatData;
  };
  
  void InitMinimumTextureCapsMap(const Version &clientVersion,
                                 const Extensions &extensions,
                                 TextureCapsMap *capsMap);
  
  // Returns true if all the formats required to support GL_ANGLE_compressed_texture_etc are
  // present. Does not determine if they are natively supported without decompression.
  bool DetermineCompressedTextureETCSupport(const TextureCapsMap &textureCaps);
  
  struct Extensions
  {
      Extensions();
      Extensions(const Extensions &other);
  
      // Generate a vector of supported extension strings
      std::vector<std::string> getStrings() const;
  
      // Set all texture related extension support based on the supported textures.
      // Determines support for:
      // GL_OES_packed_depth_stencil
      // GL_OES_rgb8_rgba8
      // GL_EXT_texture_format_BGRA8888
      // GL_EXT_color_buffer_half_float,
      // GL_OES_texture_half_float, GL_OES_texture_half_float_linear
      // GL_OES_texture_float, GL_OES_texture_float_linear
      // GL_EXT_texture_rg
      // GL_EXT_texture_compression_dxt1, GL_ANGLE_texture_compression_dxt3,
      // GL_ANGLE_texture_compression_dxt5
      // GL_KHR_texture_compression_astc_ldr, GL_OES_texture_compression_astc.
      //     NOTE: GL_KHR_texture_compression_astc_hdr must be enabled separately. Support for the
      //           HDR profile cannot be determined from the format enums alone.
      // GL_OES_compressed_ETC1_RGB8_texture
      // GL_EXT_sRGB
      // GL_ANGLE_depth_texture, GL_OES_depth32
      // GL_EXT_color_buffer_float
      // GL_EXT_texture_norm16
      // GL_EXT_texture_compression_bptc
      void setTextureExtensionSupport(const TextureCapsMap &textureCaps);
  
      // indicate if any depth texture extension is available
      bool depthTextureAny() const { return (depthTextureANGLE || depthTextureOES); }
  
      // ES2 Extension support
  
      // GL_OES_element_index_uint
      bool elementIndexUint = false;
  
      // GL_OES_packed_depth_stencil
      bool packedDepthStencil = false;
  
      // GL_OES_get_program_binary
      bool getProgramBinary = false;
  
      // GL_OES_rgb8_rgba8
      // Implies that TextureCaps for GL_RGB8 and GL_RGBA8 exist
      bool rgb8rgba8 = false;
  
      // GL_EXT_texture_format_BGRA8888
      // Implies that TextureCaps for GL_BGRA8 exist
      bool textureFormatBGRA8888 = false;
  
      // GL_EXT_read_format_bgra
      bool readFormatBGRA = false;
  
      // GL_NV_pixel_buffer_object
      bool pixelBufferObject = false;
  
      // GL_OES_mapbuffer and GL_EXT_map_buffer_range
      bool mapBuffer      = false;
      bool mapBufferRange = false;
  
      // GL_EXT_color_buffer_half_float
      // Together with GL_OES_texture_half_float in a GLES 2.0 context, implies that half-float
      // textures are renderable.
      bool colorBufferHalfFloat = false;
  
      // GL_OES_texture_half_float and GL_OES_texture_half_float_linear
      // Implies that TextureCaps for GL_RGB16F, GL_RGBA16F, GL_ALPHA32F_EXT, GL_LUMINANCE32F_EXT and
      // GL_LUMINANCE_ALPHA32F_EXT exist
      bool textureHalfFloat       = false;
      bool textureHalfFloatLinear = false;
  
      // GL_EXT_texture_type_2_10_10_10_REV
      bool textureFormat2101010REV = false;
  
      // GL_OES_texture_float and GL_OES_texture_float_linear
      // Implies that TextureCaps for GL_RGB32F, GL_RGBA32F, GL_ALPHA16F_EXT, GL_LUMINANCE16F_EXT and
      // GL_LUMINANCE_ALPHA16F_EXT exist
      bool textureFloat       = false;
      bool textureFloatLinear = false;
  
      // GL_EXT_texture_rg
      // Implies that TextureCaps for GL_R8, GL_RG8 (and floating point R/RG texture formats if
      // floating point extensions are also present) exist
      bool textureRG = false;
  
      // GL_EXT_texture_compression_dxt1, GL_ANGLE_texture_compression_dxt3 and
      // GL_ANGLE_texture_compression_dxt5 Implies that TextureCaps exist for
      // GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
      // GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE and GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE
      bool textureCompressionDXT1 = false;
      bool textureCompressionDXT3 = false;
      bool textureCompressionDXT5 = false;
  
      // GL_EXT_texture_compression_s3tc_srgb
      // Implies that TextureCaps exist for GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,
      // GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, and
      // GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
      bool textureCompressionS3TCsRGB = false;
  
      // GL_KHR_texture_compression_astc_ldr
      bool textureCompressionASTCLDRKHR = false;
  
      // GL_KHR_texture_compression_astc_hdr
      bool textureCompressionASTCHDRKHR = false;
  
      // GL_OES_texture_compression_astc
      bool textureCompressionASTCOES = false;
  
      // GL_EXT_texture_compression_bptc
      bool textureCompressionBPTC = false;
  
      // GL_OES_compressed_ETC1_RGB8_texture
      // Implies that TextureCaps for GL_ETC1_RGB8_OES exist
      bool compressedETC1RGB8Texture = false;
  
      // OES_compressed_ETC2_RGB8_texture
      bool compressedETC2RGB8Texture = false;
  
      // OES_compressed_ETC2_sRGB8_texture
      bool compressedETC2sRGB8Texture = false;
  
      // OES_compressed_ETC2_punchthroughA_RGBA8_texture
      bool compressedETC2PunchthroughARGB8Texture = false;
  
      // OES_compressed_ETC2_punchthroughA_sRGB8_alpha_texture
      bool compressedETC2PunchthroughAsRGB8AlphaTexture = false;
  
      // OES_compressed_ETC2_RGBA8_texture
      bool compressedETC2RGBA8Texture = false;
  
      // OES_compressed_ETC2_sRGB8_alpha8_texture
      bool compressedETC2sRGB8Alpha8Texture = false;
  
      // OES_compressed_EAC_R11_unsigned_texture
      bool compressedEACR11UnsignedTexture = false;
  
      // OES_compressed_EAC_R11_signed_texture
      bool compressedEACR11SignedTexture = false;
  
      // OES_compressed_EAC_RG11_unsigned_texture
      bool compressedEACRG11UnsignedTexture = false;
  
      // OES_compressed_EAC_RG11_signed_texture
      bool compressedEACRG11SignedTexture = false;
  
      // ANGLE_compressed_texture_etc
      // ONLY exposed if ETC texture formats are natively supported without decompression
      // Backends should enable this extension explicitly. It is not enabled with
      // setTextureExtensionSupport, use DetermineCompressedTextureETCSupport to check if all of the
      // individual formats required to support this extension are available.
      bool compressedTextureETC = false;
  
      // GL_IMG_texture_compression_pvrtc
      bool compressedTexturePVRTC = false;
  
      // GL_EXT_pvrtc_sRGB
      bool compressedTexturePVRTCsRGB = false;
  
      // GL_EXT_sRGB
      // Implies that TextureCaps for GL_SRGB8_ALPHA8 and GL_SRGB8 exist
      // TODO: Don't advertise this extension in ES3
      bool sRGB = false;
  
      // GL_ANGLE_depth_texture
      bool depthTextureANGLE = false;
  
      // OES_depth_texture
      bool depthTextureOES = false;
  
      // GL_OES_depth24
      // Allows DEPTH_COMPONENT24_OES as a valid Renderbuffer format.
      bool depth24OES = false;
  
      // GL_OES_depth32
      // Allows DEPTH_COMPONENT32_OES as a valid Renderbuffer format.
      bool depth32 = false;
  
      // GL_OES_texture_3D
      bool texture3DOES = false;
  
      // GL_EXT_texture_storage
      bool textureStorage = false;
  
      // GL_OES_texture_npot
      bool textureNPOT = false;
  
      // GL_EXT_draw_buffers
      bool drawBuffers = false;
  
      // GL_EXT_texture_filter_anisotropic
      bool textureFilterAnisotropic = false;
      GLfloat maxTextureAnisotropy  = 0.0f;
  
      // GL_EXT_occlusion_query_boolean
      bool occlusionQueryBoolean = false;
  
      // GL_NV_fence
      bool fence = false;
  
      // GL_EXT_disjoint_timer_query
      bool disjointTimerQuery            = false;
      GLuint queryCounterBitsTimeElapsed = 0;
      GLuint queryCounterBitsTimestamp   = 0;
  
      // GL_EXT_robustness
      bool robustness = false;
  
      // GL_KHR_robust_buffer_access_behavior
      bool robustBufferAccessBehavior = false;
  
      // GL_EXT_blend_minmax
      bool blendMinMax = false;
  
      // GL_ANGLE_framebuffer_blit
      bool framebufferBlit = false;
  
      // GL_ANGLE_framebuffer_multisample
      bool framebufferMultisample = false;
  
      // GL_EXT_multisampled_render_to_texture
      bool multisampledRenderToTexture = false;
  
      // GL_ANGLE_instanced_arrays
      bool instancedArraysANGLE = false;
      // GL_EXT_instanced_arrays
      bool instancedArraysEXT = false;
      // Any version of the instanced arrays extension
      bool instancedArraysAny() const { return (instancedArraysANGLE || instancedArraysEXT); }
  
      // GL_ANGLE_pack_reverse_row_order
      bool packReverseRowOrder = false;
  
      // GL_OES_standard_derivatives
      bool standardDerivatives = false;
  
      // GL_EXT_shader_texture_lod
      bool shaderTextureLOD = false;
  
      // GL_EXT_frag_depth
      bool fragDepth = false;
  
      // OVR_multiview
      bool multiview  = false;
      GLuint maxViews = 1;
  
      // OVR_multiview2
      bool multiview2 = false;
  
      // GL_ANGLE_texture_usage
      bool textureUsage = false;
  
      // GL_ANGLE_translated_shader_source
      bool translatedShaderSource = false;
  
      // GL_OES_fbo_render_mipmap
      bool fboRenderMipmap = false;
  
      // GL_EXT_discard_framebuffer
      bool discardFramebuffer = false;
  
      // EXT_debug_marker
      bool debugMarker = false;
  
      // GL_OES_EGL_image
      bool eglImage = false;
  
      // GL_OES_EGL_image_external
      bool eglImageExternal = false;
  
      // GL_OES_EGL_image_external_essl3
      bool eglImageExternalEssl3 = false;
  
      // GL_OES_EGL_sync
      bool eglSync = false;
  
      // GL_EXT_memory_object
      bool memoryObject = false;
  
      // GL_EXT_memory_object_fd
      bool memoryObjectFd = false;
  
      // GL_EXT_semaphore
      bool semaphore = false;
  
      // GL_EXT_semaphore_fd
      bool semaphoreFd = false;
  
      // NV_EGL_stream_consumer_external
      bool eglStreamConsumerExternal = false;
  
      // EXT_unpack_subimage
      bool unpackSubimage = false;
  
      // NV_pack_subimage
      bool packSubimage = false;
  
      // GL_OES_vertex_half_float
      bool vertexHalfFloat = false;
  
      // GL_OES_vertex_array_object
      bool vertexArrayObject = false;
  
      // GL_OES_vertex_type_10_10_10_2
      bool vertexAttribType1010102 = false;
  
      // GL_KHR_debug
      bool debug                     = false;
      GLuint maxDebugMessageLength   = 0;
      GLuint maxDebugLoggedMessages  = 0;
      GLuint maxDebugGroupStackDepth = 0;
      GLuint maxLabelLength          = 0;
  
      // KHR_no_error
      bool noError = false;
  
      // GL_ANGLE_lossy_etc_decode
      bool lossyETCDecode = false;
  
      // GL_CHROMIUM_bind_uniform_location
      bool bindUniformLocation = false;
  
      // GL_CHROMIUM_sync_query
      bool syncQuery = false;
  
      // GL_CHROMIUM_copy_texture
      bool copyTexture = false;
  
      // GL_CHROMIUM_copy_compressed_texture
      bool copyCompressedTexture = false;
  
      // GL_ANGLE_copy_texture_3d
      bool copyTexture3d = false;
  
      // GL_ANGLE_webgl_compatibility
      bool webglCompatibility = false;
  
      // GL_ANGLE_request_extension
      bool requestExtension = false;
  
      // GL_CHROMIUM_bind_generates_resource
      bool bindGeneratesResource = false;
  
      // GL_ANGLE_robust_client_memory
      bool robustClientMemory = false;
  
      // GL_OES_texture_border_clamp
      bool textureBorderClamp = false;
  
      // GL_EXT_texture_sRGB_decode
      bool textureSRGBDecode = false;
  
      // GL_EXT_sRGB_write_control
      bool sRGBWriteControl = false;
  
      // GL_CHROMIUM_color_buffer_float_rgb
      bool colorBufferFloatRGB = false;
  
      // GL_CHROMIUM_color_buffer_float_rgba
      bool colorBufferFloatRGBA = false;
  
      // ES3 Extension support
  
      // GL_EXT_color_buffer_float
      bool colorBufferFloat = false;
  
      // GL_EXT_multisample_compatibility.
      // written against ES 3.1 but can apply to earlier versions.
      bool multisampleCompatibility = false;
  
      // GL_CHROMIUM_framebuffer_mixed_samples
      bool framebufferMixedSamples = false;
  
      // GL_EXT_texture_norm16
      // written against ES 3.1 but can apply to ES 3.0 as well.
      bool textureNorm16 = false;
  
      // GL_CHROMIUM_path_rendering
      bool pathRendering = false;
  
      // GL_OES_surfaceless_context
      bool surfacelessContext = false;
  
      // GL_ANGLE_client_arrays
      bool clientArrays = false;
  
      // GL_ANGLE_robust_resource_initialization
      bool robustResourceInitialization = false;
  
      // GL_ANGLE_program_cache_control
      bool programCacheControl = false;
  
      // GL_ANGLE_texture_rectangle
      bool textureRectangle = false;
  
      // GL_EXT_geometry_shader
      bool geometryShader = false;
  
      // GLES1 emulation: GLES1 extensions
      // GL_OES_point_size_array
      bool pointSizeArray = false;
  
      // GL_OES_texture_cube_map
      bool textureCubeMap = false;
  
      // GL_OES_point_sprite
      bool pointSprite = false;
  
      // GL_OES_draw_texture
      bool drawTexture = false;
  
      // EGL_ANGLE_explicit_context GL subextensions
      // GL_ANGLE_explicit_context_gles1
      bool explicitContextGles1 = false;
      // GL_ANGLE_explicit_context
      bool explicitContext = false;
  
      // GL_KHR_parallel_shader_compile
      bool parallelShaderCompile = false;
  
      // GL_OES_texture_storage_multisample_2d_array
      bool textureStorageMultisample2DArray = false;
  
      // GL_ANGLE_multiview_multisample
      bool multiviewMultisample = false;
  
      // GL_EXT_blend_func_extended
      bool blendFuncExtended          = false;
      GLuint maxDualSourceDrawBuffers = 0;
  
      // GL_EXT_float_blend
      bool floatBlend = false;
  
      // GL_ANGLE_memory_size
      bool memorySize = false;
  
      // GL_ANGLE_texture_multisample
      bool textureMultisample = false;
  
      // GL_ANGLE_multi_draw
      bool multiDraw = false;
  
      // GL_ANGLE_provoking_vertex
      bool provokingVertex = false;
  
      // GL_CHROMIUM_lose_context
      bool loseContextCHROMIUM = false;
  
      // GL_ANGLE_texture_external_update
      bool textureExternalUpdateANGLE = false;
  
      // GL_ANGLE_base_vertex_base_instance
      bool baseVertexBaseInstance = false;
  
      // GL_ANGLE_get_image
      bool getImageANGLE = false;
  };
  
  // Pointer to a boolean memeber of the Extensions struct
  using ExtensionBool = bool Extensions::*;
  
  struct ExtensionInfo
  {
      // If this extension can be enabled or disabled  with glRequestExtension
      // (GL_ANGLE_request_extension)
      bool Requestable = false;
      bool Disablable  = false;
  
      // Pointer to a boolean member of the Extensions struct
      ExtensionBool ExtensionsMember = nullptr;
  };
  
  using ExtensionInfoMap = std::map<std::string, ExtensionInfo>;
  const ExtensionInfoMap &GetExtensionInfoMap();
  
  struct Limitations
  {
      Limitations();
  
      // Renderer doesn't support gl_FrontFacing in fragment shaders
      bool noFrontFacingSupport = false;
  
      // Renderer doesn't support GL_SAMPLE_ALPHA_TO_COVERAGE
      bool noSampleAlphaToCoverageSupport = false;
  
      // In glVertexAttribDivisorANGLE, attribute zero must have a zero divisor
      bool attributeZeroRequiresZeroDivisorInEXT = false;
  
      // Unable to support different values for front and back faces for stencil refs and masks
      bool noSeparateStencilRefsAndMasks = false;
  
      // Renderer doesn't support non-constant indexing loops in fragment shader
      bool shadersRequireIndexedLoopValidation = false;
  
      // Renderer doesn't support Simultaneous use of GL_CONSTANT_ALPHA/GL_ONE_MINUS_CONSTANT_ALPHA
      // and GL_CONSTANT_COLOR/GL_ONE_MINUS_CONSTANT_COLOR blend functions.
      bool noSimultaneousConstantColorAndAlphaBlendFunc = false;
  
      // D3D9 does not support flexible varying register packing.
      bool noFlexibleVaryingPacking = false;
  
      // D3D does not support having multiple transform feedback outputs go to the same buffer.
      bool noDoubleBoundTransformFeedbackBuffers = false;
  
      // D3D does not support vertex attribute aliasing
      bool noVertexAttributeAliasing = false;
  };
  
  struct TypePrecision
  {
      TypePrecision();
      TypePrecision(const TypePrecision &other);
  
      void setIEEEFloat();
      void setTwosComplementInt(unsigned int bits);
      void setSimulatedFloat(unsigned int range, unsigned int precision);
      void setSimulatedInt(unsigned int range);
  
      void get(GLint *returnRange, GLint *returnPrecision) const;
  
      std::array<GLint, 2> range = {0, 0};
      GLint precision            = 0;
  };
  
  struct Caps
  {
      Caps();
      Caps(const Caps &other);
      ~Caps();
  
      // ES 3.1 (April 29, 2015) 20.39: implementation dependent values
      GLuint64 maxElementIndex       = 0;
      GLuint max3DTextureSize        = 0;
      GLuint max2DTextureSize        = 0;
      GLuint maxRectangleTextureSize = 0;
      GLuint maxArrayTextureLayers   = 0;
      GLfloat maxLODBias             = 0.0f;
      GLuint maxCubeMapTextureSize   = 0;
      GLuint maxRenderbufferSize     = 0;
      GLfloat minAliasedPointSize    = 1.0f;
      GLfloat maxAliasedPointSize    = 1.0f;
      GLfloat minAliasedLineWidth    = 0.0f;
      GLfloat maxAliasedLineWidth    = 0.0f;
  
      // ES 3.1 (April 29, 2015) 20.40: implementation dependent values (cont.)
      GLuint maxDrawBuffers         = 0;
      GLuint maxFramebufferWidth    = 0;
      GLuint maxFramebufferHeight   = 0;
      GLuint maxFramebufferSamples  = 0;
      GLuint maxColorAttachments    = 0;
      GLuint maxViewportWidth       = 0;
      GLuint maxViewportHeight      = 0;
      GLuint maxSampleMaskWords     = 0;
      GLuint maxColorTextureSamples = 0;
      GLuint maxDepthTextureSamples = 0;
      GLuint maxIntegerSamples      = 0;
      GLuint64 maxServerWaitTimeout = 0;
  
      // ES 3.1 (April 29, 2015) Table 20.41: Implementation dependent values (cont.)
      GLint maxVertexAttribRelativeOffset = 0;
      GLuint maxVertexAttribBindings      = 0;
      GLint maxVertexAttribStride         = 0;
      GLuint maxElementsIndices           = 0;
      GLuint maxElementsVertices          = 0;
      std::vector<GLenum> compressedTextureFormats;
      std::vector<GLenum> programBinaryFormats;
      std::vector<GLenum> shaderBinaryFormats;
      TypePrecision vertexHighpFloat;
      TypePrecision vertexMediumpFloat;
      TypePrecision vertexLowpFloat;
      TypePrecision vertexHighpInt;
      TypePrecision vertexMediumpInt;
      TypePrecision vertexLowpInt;
      TypePrecision fragmentHighpFloat;
      TypePrecision fragmentMediumpFloat;
      TypePrecision fragmentLowpFloat;
      TypePrecision fragmentHighpInt;
      TypePrecision fragmentMediumpInt;
      TypePrecision fragmentLowpInt;
  
      // Implementation dependent limits required on all shader types.
      // TODO(jiawei.shao@intel.com): organize all such limits into ShaderMap.
      // ES 3.1 (April 29, 2015) Table 20.43: Implementation dependent Vertex shader limits
      // ES 3.1 (April 29, 2015) Table 20.44: Implementation dependent Fragment shader limits
      // ES 3.1 (April 29, 2015) Table 20.45: implementation dependent compute shader limits
      // GL_EXT_geometry_shader (May 31, 2016) Table 20.43gs: Implementation dependent geometry shader
      // limits
      // GL_EXT_geometry_shader (May 31, 2016) Table 20.46: Implementation dependent aggregate shader
      // limits
      ShaderMap<GLuint> maxShaderUniformBlocks        = {};
      ShaderMap<GLuint> maxShaderTextureImageUnits    = {};
      ShaderMap<GLuint> maxShaderStorageBlocks        = {};
      ShaderMap<GLuint> maxShaderUniformComponents    = {};
      ShaderMap<GLuint> maxShaderAtomicCounterBuffers = {};
      ShaderMap<GLuint> maxShaderAtomicCounters       = {};
      ShaderMap<GLuint> maxShaderImageUniforms        = {};
      // Note that we can query MAX_COMPUTE_UNIFORM_COMPONENTS and MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT
      // by GetIntegerv, but we can only use GetInteger64v on MAX_VERTEX_UNIFORM_COMPONENTS and
      // MAX_FRAGMENT_UNIFORM_COMPONENTS. Currently we use GLuint64 to store all these values so that
      // we can put them together into one ShaderMap.
      ShaderMap<GLuint64> maxCombinedShaderUniformComponents = {};
  
      // ES 3.1 (April 29, 2015) Table 20.43: Implementation dependent Vertex shader limits
      GLuint maxVertexAttributes       = 0;
      GLuint maxVertexUniformVectors   = 0;
      GLuint maxVertexOutputComponents = 0;
  
      // ES 3.1 (April 29, 2015) Table 20.44: Implementation dependent Fragment shader limits
      GLuint maxFragmentUniformVectors     = 0;
      GLuint maxFragmentInputComponents    = 0;
      GLint minProgramTextureGatherOffset  = 0;
      GLuint maxProgramTextureGatherOffset = 0;
      GLint minProgramTexelOffset          = 0;
      GLint maxProgramTexelOffset          = 0;
  
      // ES 3.1 (April 29, 2015) Table 20.45: implementation dependent compute shader limits
      std::array<GLuint, 3> maxComputeWorkGroupCount = {0, 0, 0};
      std::array<GLuint, 3> maxComputeWorkGroupSize  = {0, 0, 0};
      GLuint maxComputeWorkGroupInvocations          = 0;
      GLuint maxComputeSharedMemorySize              = 0;
  
      // ES 3.1 (April 29, 2015) Table 20.46: implementation dependent aggregate shader limits
      GLuint maxUniformBufferBindings         = 0;
      GLuint64 maxUniformBlockSize            = 0;
      GLuint uniformBufferOffsetAlignment     = 0;
      GLuint maxCombinedUniformBlocks         = 0;
      GLuint maxVaryingComponents             = 0;
      GLuint maxVaryingVectors                = 0;
      GLuint maxCombinedTextureImageUnits     = 0;
      GLuint maxCombinedShaderOutputResources = 0;
  
      // ES 3.1 (April 29, 2015) Table 20.47: implementation dependent aggregate shader limits (cont.)
      GLuint maxUniformLocations                = 0;
      GLuint maxAtomicCounterBufferBindings     = 0;
      GLuint maxAtomicCounterBufferSize         = 0;
      GLuint maxCombinedAtomicCounterBuffers    = 0;
      GLuint maxCombinedAtomicCounters          = 0;
      GLuint maxImageUnits                      = 0;
      GLuint maxCombinedImageUniforms           = 0;
      GLuint maxShaderStorageBufferBindings     = 0;
      GLuint64 maxShaderStorageBlockSize        = 0;
      GLuint maxCombinedShaderStorageBlocks     = 0;
      GLuint shaderStorageBufferOffsetAlignment = 0;
  
      // ES 3.1 (April 29, 2015) Table 20.48: implementation dependent transform feedback limits
      GLuint maxTransformFeedbackInterleavedComponents = 0;
      GLuint maxTransformFeedbackSeparateAttributes    = 0;
      GLuint maxTransformFeedbackSeparateComponents    = 0;
  
      // ES 3.1 (April 29, 2015) Table 20.49: Framebuffer Dependent Values
      GLuint maxSamples = 0;
  
      // GL_EXT_geometry_shader (May 31, 2016) Table 20.40: Implementation-Dependent Values (cont.)
      GLuint maxFramebufferLayers = 0;
      GLuint layerProvokingVertex = 0;
  
      // GL_EXT_geometry_shader (May 31, 2016) Table 20.43gs: Implementation dependent geometry shader
      // limits
      GLuint maxGeometryInputComponents       = 0;
      GLuint maxGeometryOutputComponents      = 0;
      GLuint maxGeometryOutputVertices        = 0;
      GLuint maxGeometryTotalOutputComponents = 0;
      GLuint maxGeometryShaderInvocations     = 0;
  
      GLuint subPixelBits = 4;
  
      // GLES1 emulation: Caps for ES 1.1. Taken from Table 6.20 / 6.22 in the OpenGL ES 1.1 spec.
      GLuint maxMultitextureUnits                 = 0;
      GLuint maxClipPlanes                        = 0;
      GLuint maxLights                            = 0;
      static constexpr int GlobalMatrixStackDepth = 16;
      GLuint maxModelviewMatrixStackDepth         = 0;
      GLuint maxProjectionMatrixStackDepth        = 0;
      GLuint maxTextureMatrixStackDepth           = 0;
      GLfloat minSmoothPointSize                  = 0.0f;
      GLfloat maxSmoothPointSize                  = 0.0f;
      GLfloat minSmoothLineWidth                  = 0.0f;
      GLfloat maxSmoothLineWidth                  = 0.0f;
  };
  
  Caps GenerateMinimumCaps(const Version &clientVersion, const Extensions &extensions);
  }  // namespace gl
  
  namespace egl
  {
  
  struct Caps
  {
      Caps();
  
      // Support for NPOT surfaces
      bool textureNPOT;
  };
  
  struct DisplayExtensions
  {
      DisplayExtensions();
  
      // Generate a vector of supported extension strings
      std::vector<std::string> getStrings() const;
  
      // EGL_EXT_create_context_robustness
      bool createContextRobustness = false;
  
      // EGL_ANGLE_d3d_share_handle_client_buffer
      bool d3dShareHandleClientBuffer = false;
  
      // EGL_ANGLE_d3d_texture_client_buffer
      bool d3dTextureClientBuffer = false;
  
      // EGL_ANGLE_surface_d3d_texture_2d_share_handle
      bool surfaceD3DTexture2DShareHandle = false;
  
      // EGL_ANGLE_query_surface_pointer
      bool querySurfacePointer = false;
  
      // EGL_ANGLE_window_fixed_size
      bool windowFixedSize = false;
  
      // EGL_ANGLE_keyed_mutex
      bool keyedMutex = false;
  
      // EGL_ANGLE_surface_orientation
      bool surfaceOrientation = false;
  
      // EGL_NV_post_sub_buffer
      bool postSubBuffer = false;
  
      // EGL_KHR_create_context
      bool createContext = false;
  
      // EGL_EXT_device_query
      bool deviceQuery = false;
  
      // EGL_KHR_image
      bool image = false;
  
      // EGL_KHR_image_base
      bool imageBase = false;
  
      // EGL_KHR_image_pixmap
      bool imagePixmap = false;
  
      // EGL_KHR_gl_texture_2D_image
      bool glTexture2DImage = false;
  
      // EGL_KHR_gl_texture_cubemap_image
      bool glTextureCubemapImage = false;
  
      // EGL_KHR_gl_texture_3D_image
      bool glTexture3DImage = false;
  
      // EGL_KHR_gl_renderbuffer_image
      bool glRenderbufferImage = false;
  
      // EGL_KHR_get_all_proc_addresses
      bool getAllProcAddresses = false;
  
      // EGL_ANGLE_flexible_surface_compatibility
      bool flexibleSurfaceCompatibility = false;
  
      // EGL_ANGLE_direct_composition
      bool directComposition = false;
  
      // EGL_ANGLE_windows_ui_composition
      bool windowsUIComposition = false;
  
      // KHR_create_context_no_error
      bool createContextNoError = false;
  
      // EGL_KHR_stream
      bool stream = false;
  
      // EGL_KHR_stream_consumer_gltexture
      bool streamConsumerGLTexture = false;
  
      // EGL_NV_stream_consumer_gltexture_yuv
      bool streamConsumerGLTextureYUV = false;
  
      // EGL_ANGLE_stream_producer_d3d_texture
      bool streamProducerD3DTexture = false;
  
      // EGL_KHR_fence_sync
      bool fenceSync = false;
  
      // EGL_KHR_wait_sync
      bool waitSync = false;
  
      // EGL_ANGLE_create_context_webgl_compatibility
      bool createContextWebGLCompatibility = false;
  
      // EGL_CHROMIUM_create_context_bind_generates_resource
      bool createContextBindGeneratesResource = false;
  
      // EGL_CHROMIUM_sync_control
      bool syncControlCHROMIUM = false;
  
      // EGL_KHR_swap_buffers_with_damage
      bool swapBuffersWithDamage = false;
  
      // EGL_EXT_pixel_format_float
      bool pixelFormatFloat = false;
  
      // EGL_KHR_surfaceless_context
      bool surfacelessContext = false;
  
      // EGL_ANGLE_display_texture_share_group
      bool displayTextureShareGroup = false;
  
      // EGL_ANGLE_create_context_client_arrays
      bool createContextClientArrays = false;
  
      // EGL_ANGLE_program_cache_control
      bool programCacheControl = false;
  
      // EGL_ANGLE_robust_resource_initialization
      bool robustResourceInitialization = false;
  
      // EGL_ANGLE_iosurface_client_buffer
      bool iosurfaceClientBuffer = false;
  
      // EGL_ANGLE_create_context_extensions_enabled
      bool createContextExtensionsEnabled = false;
  
      // EGL_ANDROID_presentation_time
      bool presentationTime = false;
  
      // EGL_ANDROID_blob_cache
      bool blobCache = false;
  
      // EGL_ANDROID_image_native_buffer
      bool imageNativeBuffer = false;
  
      // EGL_ANDROID_get_frame_timestamps
      bool getFrameTimestamps = false;
  
      // EGL_ANDROID_recordable
      bool recordable = false;
  
      // EGL_ANGLE_power_preference
      bool powerPreference = false;
  
      // EGL_ANGLE_image_d3d11_texture
      bool imageD3D11Texture = false;
  
      // EGL_ANDROID_get_native_client_buffer
      bool getNativeClientBufferANDROID = false;
  
      // EGL_ANDROID_native_fence_sync
      bool nativeFenceSyncANDROID = false;
  
      // EGL_ANGLE_create_context_backwards_compatible
      bool createContextBackwardsCompatible = false;
  
      // EGL_KHR_no_config_context
      bool noConfigContext = false;
  
      // EGL_ANGLE_ggp_stream_descriptor
      bool ggpStreamDescriptor = false;
  
      // EGL_ANGLE_swap_with_frame_token
      bool swapWithFrameToken = false;
  };
  
  struct DeviceExtensions
  {
      DeviceExtensions();
  
      // Generate a vector of supported extension strings
      std::vector<std::string> getStrings() const;
  
      // EGL_ANGLE_device_d3d
      bool deviceD3D = false;
  
      // EGL_ANGLE_device_cgl
      bool deviceCGL = false;
  };
  
  struct ClientExtensions
  {
      ClientExtensions();
      ClientExtensions(const ClientExtensions &other);
  
      // Generate a vector of supported extension strings
      std::vector<std::string> getStrings() const;
  
      // EGL_EXT_client_extensions
      bool clientExtensions = false;
  
      // EGL_EXT_platform_base
      bool platformBase = false;
  
      // EGL_EXT_platform_device
      bool platformDevice = false;
  
      // EGL_ANGLE_platform_angle
      bool platformANGLE = false;
  
      // EGL_ANGLE_platform_angle_d3d
      bool platformANGLED3D = false;
  
      // EGL_ANGLE_platform_angle_d3d11on12
      bool platformANGLED3D11ON12 = false;
  
      // EGL_ANGLE_platform_angle_opengl
      bool platformANGLEOpenGL = false;
  
      // EGL_ANGLE_platform_angle_null
      bool platformANGLENULL = false;
  
      // EGL_ANGLE_platform_angle_vulkan
      bool platformANGLEVulkan = false;
  
      // EGL_ANGLE_platform_angle_metal
      bool platformANGLEMetal = false;
  
      // EGL_ANGLE_platform_angle_context_virtualization
      bool platformANGLEContextVirtualization = false;
  
      // EGL_ANGLE_device_creation
      bool deviceCreation = false;
  
      // EGL_ANGLE_device_creation_d3d11
      bool deviceCreationD3D11 = false;
  
      // EGL_ANGLE_x11_visual
      bool x11Visual = false;
  
      // EGL_ANGLE_experimental_present_path
      bool experimentalPresentPath = false;
  
      // EGL_KHR_client_get_all_proc_addresses
      bool clientGetAllProcAddresses = false;
  
      // EGL_KHR_debug
      bool debug = false;
  
      // EGL_ANGLE_explicit_context
      bool explicitContext = false;
  
      // EGL_ANGLE_feature_control
      bool featureControlANGLE = false;
  
      // EGL_ANGLE_platform_angle_device_type_swiftshader
      bool platformANGLEDeviceTypeSwiftShader = false;
  };
  
  }  // namespace egl
  
  #endif  // LIBANGLE_CAPS_H_