summaryrefslogtreecommitdiffstats
path: root/gfx/angle/checkout/src/libANGLE/Caps.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/Caps.h')
-rw-r--r--gfx/angle/checkout/src/libANGLE/Caps.h786
1 files changed, 786 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/Caps.h b/gfx/angle/checkout/src/libANGLE/Caps.h
new file mode 100644
index 0000000000..03b4ef8c9a
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/Caps.h
@@ -0,0 +1,786 @@
+//
+// 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/gles_extensions_autogen.h"
+#include "libANGLE/renderer/Format.h"
+
+#include <array>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace gl
+{
+struct TextureCaps
+{
+ TextureCaps();
+ TextureCaps(const TextureCaps &other);
+ TextureCaps &operator=(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;
+
+ // Support for blend modes while being used as a framebuffer attachment
+ bool blendable = 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
+ angle::FormatMap<TextureCaps> 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);
+
+// Pointer to a boolean member 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();
+ Limitations(const Limitations &other);
+
+ Limitations &operator=(const Limitations &other);
+
+ // 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;
+
+ // Renderer always clamps constant blend color.
+ bool noUnclampedBlendColor = 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;
+
+ // Renderer doesn't support GL_TEXTURE_COMPARE_MODE=GL_NONE on a shadow sampler.
+ // TODO(http://anglebug.com/5231): add validation code to front-end.
+ bool noShadowSamplerCompareModeNone = false;
+
+ // PVRTC1 textures must be squares.
+ bool squarePvrtc1 = false;
+
+ // ETC1 texture support is emulated.
+ bool emulatedEtc1 = false;
+
+ // ASTC texture support is emulated.
+ bool emulatedAstc = false;
+
+ // No compressed TEXTURE_3D support.
+ bool noCompressedTexture3D = false;
+
+ // D3D does not support compressed textures where the base mip level is not a multiple of 4
+ bool compressedBaseMipLevelMultipleOfFour = false;
+
+ bool limitWebglMaxTextureSizeTo4096 = false;
+};
+
+struct TypePrecision
+{
+ TypePrecision();
+ TypePrecision(const TypePrecision &other);
+
+ TypePrecision &operator=(const TypePrecision &other);
+
+ void setIEEEFloat();
+ void setIEEEHalfFloat();
+ 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 &operator=(const Caps &other);
+
+ ~Caps();
+
+ // If the values could be got by using GetIntegeri_v, they should
+ // be GLint instead of GLuint and call LimitToInt() to ensure
+ // they will not overflow.
+
+ GLfloat minInterpolationOffset = 0;
+ GLfloat maxInterpolationOffset = 0;
+ GLint subPixelInterpolationOffsetBits = 0;
+
+ // ES 3.1 (April 29, 2015) 20.39: implementation dependent values
+ GLint64 maxElementIndex = 0;
+ GLint max3DTextureSize = 0;
+ GLint max2DTextureSize = 0;
+ GLint maxRectangleTextureSize = 0;
+ GLint maxArrayTextureLayers = 0;
+ GLfloat maxLODBias = 0.0f;
+ GLint maxCubeMapTextureSize = 0;
+ GLint 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.)
+ GLint maxDrawBuffers = 0;
+ GLint maxFramebufferWidth = 0;
+ GLint maxFramebufferHeight = 0;
+ GLint maxFramebufferSamples = 0;
+ GLint maxColorAttachments = 0;
+ GLint maxViewportWidth = 0;
+ GLint maxViewportHeight = 0;
+ GLint maxSampleMaskWords = 0;
+ GLint maxColorTextureSamples = 0;
+ GLint maxDepthTextureSamples = 0;
+ GLint maxIntegerSamples = 0;
+ GLint64 maxServerWaitTimeout = 0;
+
+ // ES 3.1 (April 29, 2015) Table 20.41: Implementation dependent values (cont.)
+ GLint maxVertexAttribRelativeOffset = 0;
+ GLint maxVertexAttribBindings = 0;
+ GLint maxVertexAttribStride = 0;
+ GLint maxElementsIndices = 0;
+ GLint 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<GLint> maxShaderUniformBlocks = {};
+ ShaderMap<GLint> maxShaderTextureImageUnits = {};
+ ShaderMap<GLint> maxShaderStorageBlocks = {};
+ ShaderMap<GLint> maxShaderUniformComponents = {};
+ ShaderMap<GLint> maxShaderAtomicCounterBuffers = {};
+ ShaderMap<GLint> maxShaderAtomicCounters = {};
+ ShaderMap<GLint> 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<GLint64> maxCombinedShaderUniformComponents = {};
+
+ // ES 3.1 (April 29, 2015) Table 20.43: Implementation dependent Vertex shader limits
+ GLint maxVertexAttributes = 0;
+ GLint maxVertexUniformVectors = 0;
+ GLint maxVertexOutputComponents = 0;
+
+ // ES 3.1 (April 29, 2015) Table 20.44: Implementation dependent Fragment shader limits
+ GLint maxFragmentUniformVectors = 0;
+ GLint maxFragmentInputComponents = 0;
+ GLint minProgramTextureGatherOffset = 0;
+ GLint maxProgramTextureGatherOffset = 0;
+ GLint minProgramTexelOffset = 0;
+ GLint maxProgramTexelOffset = 0;
+
+ // ES 3.1 (April 29, 2015) Table 20.45: implementation dependent compute shader limits
+ std::array<GLint, 3> maxComputeWorkGroupCount = {0, 0, 0};
+ std::array<GLint, 3> maxComputeWorkGroupSize = {0, 0, 0};
+ GLint maxComputeWorkGroupInvocations = 0;
+ GLint maxComputeSharedMemorySize = 0;
+
+ // ES 3.1 (April 29, 2015) Table 20.46: implementation dependent aggregate shader limits
+ GLint maxUniformBufferBindings = 0;
+ GLint64 maxUniformBlockSize = 0;
+ GLint uniformBufferOffsetAlignment = 0;
+ GLint maxCombinedUniformBlocks = 0;
+ GLint maxVaryingComponents = 0;
+ GLint maxVaryingVectors = 0;
+ GLint maxCombinedTextureImageUnits = 0;
+ GLint maxCombinedShaderOutputResources = 0;
+
+ // ES 3.1 (April 29, 2015) Table 20.47: implementation dependent aggregate shader limits (cont.)
+ GLint maxUniformLocations = 0;
+ GLint maxAtomicCounterBufferBindings = 0;
+ GLint maxAtomicCounterBufferSize = 0;
+ GLint maxCombinedAtomicCounterBuffers = 0;
+ GLint maxCombinedAtomicCounters = 0;
+ GLint maxImageUnits = 0;
+ GLint maxCombinedImageUniforms = 0;
+ GLint maxShaderStorageBufferBindings = 0;
+ GLint64 maxShaderStorageBlockSize = 0;
+ GLint maxCombinedShaderStorageBlocks = 0;
+ GLint shaderStorageBufferOffsetAlignment = 0;
+
+ // ES 3.1 (April 29, 2015) Table 20.48: implementation dependent transform feedback limits
+ GLint maxTransformFeedbackInterleavedComponents = 0;
+ GLint maxTransformFeedbackSeparateAttributes = 0;
+ GLint maxTransformFeedbackSeparateComponents = 0;
+
+ // ES 3.1 (April 29, 2015) Table 20.49: Framebuffer Dependent Values
+ GLint maxSamples = 0;
+
+ // GL_EXT_geometry_shader (May 31, 2016) Table 20.40: Implementation-Dependent Values (cont.)
+ GLint maxFramebufferLayers = 0;
+ GLint layerProvokingVertex = 0;
+
+ // GL_EXT_geometry_shader (May 31, 2016) Table 20.43gs: Implementation dependent geometry shader
+ // limits
+ GLint maxGeometryInputComponents = 0;
+ GLint maxGeometryOutputComponents = 0;
+ GLint maxGeometryOutputVertices = 0;
+ GLint maxGeometryTotalOutputComponents = 0;
+ GLint maxGeometryShaderInvocations = 0;
+
+ // GL_EXT_tessellation_shader
+ GLint maxTessControlInputComponents = 0;
+ GLint maxTessControlOutputComponents = 0;
+ GLint maxTessControlTotalOutputComponents = 0;
+
+ GLint maxTessPatchComponents = 0;
+ GLint maxPatchVertices = 0;
+ GLint maxTessGenLevel = 0;
+
+ GLint maxTessEvaluationInputComponents = 0;
+ GLint maxTessEvaluationOutputComponents = 0;
+
+ GLuint subPixelBits = 4;
+
+ // GL_EXT_blend_func_extended
+ GLuint maxDualSourceDrawBuffers = 0;
+
+ // GL_EXT_texture_filter_anisotropic
+ GLfloat maxTextureAnisotropy = 0.0f;
+
+ // GL_EXT_disjoint_timer_query
+ GLuint queryCounterBitsTimeElapsed = 0;
+ GLuint queryCounterBitsTimestamp = 0;
+
+ // OVR_multiview
+ GLuint maxViews = 1;
+
+ // GL_KHR_debug
+ GLuint maxDebugMessageLength = 0;
+ GLuint maxDebugLoggedMessages = 0;
+ GLuint maxDebugGroupStackDepth = 0;
+ GLuint maxLabelLength = 0;
+
+ // GL_APPLE_clip_distance/GL_EXT_clip_cull_distance
+ GLuint maxClipDistances = 0;
+ GLuint maxCullDistances = 0;
+ GLuint maxCombinedClipAndCullDistances = 0;
+
+ // GL_ANGLE_shader_pixel_local_storage
+ GLuint maxPixelLocalStoragePlanes = 0;
+ GLuint maxColorAttachmentsWithActivePixelLocalStorage = 0;
+ GLuint maxCombinedDrawBuffersAndPixelLocalStoragePlanes = 0;
+
+ // 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;
+
+ // ES 3.2 Table 20.41: Implementation Dependent Values (cont.)
+ GLint maxTextureBufferSize = 0;
+ GLint textureBufferOffsetAlignment = 0;
+};
+
+Caps GenerateMinimumCaps(const Version &clientVersion, const Extensions &extensions);
+} // namespace gl
+
+namespace egl
+{
+
+struct Caps
+{
+ Caps();
+
+ // Support for NPOT surfaces
+ bool textureNPOT;
+
+ // Support for Stencil8 configs
+ bool stencil8;
+};
+
+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_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_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_ANGLE_sync_control_rate
+ bool syncControlRateANGLE = 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_display_semaphore_share_group
+ bool displaySemaphoreShareGroup = false;
+
+ // EGL_ANGLE_create_context_client_arrays
+ bool createContextClientArrays = false;
+
+ // EGL_ANGLE_program_cache_control
+ bool programCacheControlANGLE = false;
+
+ // EGL_ANGLE_robust_resource_initialization
+ bool robustResourceInitializationANGLE = false;
+
+ // EGL_ANGLE_iosurface_client_buffer
+ bool iosurfaceClientBuffer = false;
+
+ // EGL_ANGLE_metal_texture_client_buffer
+ bool mtlTextureClientBuffer = 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_ANGLE_timestamp_surface_attribute
+ bool timestampSurfaceAttributeANGLE = 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_create_native_client_buffer
+ bool createNativeClientBufferANDROID = 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_IMG_context_priority
+ bool contextPriority = false;
+
+ // EGL_ANGLE_ggp_stream_descriptor
+ bool ggpStreamDescriptor = false;
+
+ // EGL_ANGLE_swap_with_frame_token
+ bool swapWithFrameToken = false;
+
+ // EGL_KHR_gl_colorspace
+ bool glColorspace = false;
+
+ // EGL_EXT_gl_colorspace_display_p3_linear
+ bool glColorspaceDisplayP3Linear = false;
+
+ // EGL_EXT_gl_colorspace_display_p3
+ bool glColorspaceDisplayP3 = false;
+
+ // EGL_EXT_gl_colorspace_scrgb
+ bool glColorspaceScrgb = false;
+
+ // EGL_EXT_gl_colorspace_scrgb_linear
+ bool glColorspaceScrgbLinear = false;
+
+ // EGL_EXT_gl_colorspace_display_p3_passthrough
+ bool glColorspaceDisplayP3Passthrough = false;
+
+ // EGL_ANGLE_colorspace_attribute_passthrough
+ bool eglColorspaceAttributePassthroughANGLE = false;
+
+ // EGL_ANDROID_framebuffer_target
+ bool framebufferTargetANDROID = false;
+
+ // EGL_EXT_image_gl_colorspace
+ bool imageGlColorspace = false;
+
+ // EGL_EXT_image_dma_buf_import
+ bool imageDmaBufImportEXT = false;
+
+ // EGL_EXT_image_dma_buf_import_modifiers
+ bool imageDmaBufImportModifiersEXT = false;
+
+ // EGL_NOK_texture_from_pixmap
+ bool textureFromPixmapNOK = false;
+
+ // EGL_NV_robustness_video_memory_purge
+ bool robustnessVideoMemoryPurgeNV = false;
+
+ // EGL_KHR_reusable_sync
+ bool reusableSyncKHR = false;
+
+ // EGL_ANGLE_external_context_and_surface
+ bool externalContextAndSurface = false;
+
+ // EGL_EXT_buffer_age
+ bool bufferAgeEXT = false;
+
+ // EGL_KHR_mutable_render_buffer
+ bool mutableRenderBufferKHR = false;
+
+ // EGL_EXT_protected_content
+ bool protectedContentEXT = false;
+
+ // EGL_ANGLE_create_surface_swap_interval
+ bool createSurfaceSwapIntervalANGLE = false;
+
+ // EGL_ANGLE_context_virtualization
+ bool contextVirtualizationANGLE = false;
+
+ // EGL_KHR_lock_surface3
+ bool lockSurface3KHR = false;
+
+ // EGL_ANGLE_vulkan_image
+ bool vulkanImageANGLE = false;
+
+ // EGL_ANGLE_metal_create_context_ownership_identity
+ bool metalCreateContextOwnershipIdentityANGLE = false;
+
+ // EGL_KHR_partial_update
+ bool partialUpdateKHR = false;
+
+ // EGL_ANGLE_sync_mtl_shared_event
+ bool mtlSyncSharedEventANGLE = 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;
+
+ // EGL_ANGLE_device_eagl
+ bool deviceEAGL = false;
+
+ // EGL_ANGLE_device_metal
+ bool deviceMetal = false;
+
+ // EGL_ANGLE_device_vulkan
+ bool deviceVulkan = 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_KHR_platform_gbm
+ bool platformGbmKHR = false;
+
+ // EGL_EXT_platform_wayland
+ bool platformWaylandEXT = 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_device_context_volatile_eagl
+ bool platformANGLEDeviceContextVolatileEagl = false;
+
+ // EGL_ANGLE_platform_angle_device_context_volatile_cgl
+ bool platformANGLEDeviceContextVolatileCgl = false;
+
+ // EGL_ANGLE_platform_angle_device_id
+ bool platformANGLEDeviceId = 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_feature_control
+ bool featureControlANGLE = false;
+
+ // EGL_ANGLE_platform_angle_device_type_swiftshader
+ bool platformANGLEDeviceTypeSwiftShader = false;
+
+ // EGL_ANGLE_platform_angle_device_type_egl_angle
+ bool platformANGLEDeviceTypeEGLANGLE = false;
+
+ // EGL_EXT_device_query
+ bool deviceQueryEXT = false;
+
+ // EGL_ANGLE_display_power_preference
+ bool displayPowerPreferenceANGLE = false;
+};
+
+} // namespace egl
+
+#endif // LIBANGLE_CAPS_H_