blob: 0b97fb5df4cbd2da456d0c3020ac998d623e90d6 [file] [log] [blame]
//
// Copyright (c) 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.
//
#include "libANGLE/Caps.h"
#include "common/debug.h"
#include "common/angleutils.h"
#include "libANGLE/formatutils.h"
#include "angle_gl.h"
#include <algorithm>
#include <sstream>
static void InsertExtensionString(const std::string &extension, bool supported, std::vector<std::string> *extensionVector)
{
if (supported)
{
extensionVector->push_back(extension);
}
}
namespace gl
{
TextureCaps::TextureCaps()
: texturable(false),
filterable(false),
renderable(false),
sampleCounts()
{
}
GLuint TextureCaps::getMaxSamples() const
{
return !sampleCounts.empty() ? *sampleCounts.rbegin() : 0;
}
GLuint TextureCaps::getNearestSamples(GLuint requestedSamples) const
{
if (requestedSamples == 0)
{
return 0;
}
for (SupportedSampleSet::const_iterator i = sampleCounts.begin(); i != sampleCounts.end(); i++)
{
GLuint samples = *i;
if (samples >= requestedSamples)
{
return samples;
}
}
return 0;
}
TextureCaps GenerateMinimumTextureCaps(GLenum sizedInternalFormat,
const Version &clientVersion,
const Extensions &extensions)
{
TextureCaps caps;
const InternalFormat &internalFormatInfo = GetSizedInternalFormatInfo(sizedInternalFormat);
caps.texturable = internalFormatInfo.textureSupport(clientVersion, extensions);
caps.renderable = internalFormatInfo.renderSupport(clientVersion, extensions);
caps.filterable = internalFormatInfo.filterSupport(clientVersion, extensions);
caps.sampleCounts.insert(0);
return caps;
}
void TextureCapsMap::insert(GLenum internalFormat, const TextureCaps &caps)
{
mCapsMap[internalFormat] = caps;
}
void TextureCapsMap::remove(GLenum internalFormat)
{
InternalFormatToCapsMap::iterator i = mCapsMap.find(internalFormat);
if (i != mCapsMap.end())
{
mCapsMap.erase(i);
}
}
void TextureCapsMap::clear()
{
mCapsMap.clear();
}
const TextureCaps &TextureCapsMap::get(GLenum internalFormat) const
{
static TextureCaps defaultUnsupportedTexture;
InternalFormatToCapsMap::const_iterator iter = mCapsMap.find(internalFormat);
return (iter != mCapsMap.end()) ? iter->second : defaultUnsupportedTexture;
}
TextureCapsMap::const_iterator TextureCapsMap::begin() const
{
return mCapsMap.begin();
}
TextureCapsMap::const_iterator TextureCapsMap::end() const
{
return mCapsMap.end();
}
size_t TextureCapsMap::size() const
{
return mCapsMap.size();
}
TextureCapsMap GenerateMinimumTextureCapsMap(const Version &clientVersion,
const Extensions &extensions)
{
TextureCapsMap capsMap;
for (GLenum internalFormat : GetAllSizedInternalFormats())
{
capsMap.insert(internalFormat,
GenerateMinimumTextureCaps(internalFormat, clientVersion, extensions));
}
return capsMap;
}
Extensions::Extensions()
: elementIndexUint(false),
packedDepthStencil(false),
getProgramBinary(false),
rgb8rgba8(false),
textureFormatBGRA8888(false),
readFormatBGRA(false),
pixelBufferObject(false),
mapBuffer(false),
mapBufferRange(false),
colorBufferHalfFloat(false),
textureHalfFloat(false),
textureHalfFloatLinear(false),
textureFloat(false),
textureFloatLinear(false),
textureRG(false),
textureCompressionDXT1(false),
textureCompressionDXT3(false),
textureCompressionDXT5(false),
textureCompressionS3TCsRGB(false),
textureCompressionASTCHDR(false),
textureCompressionASTCLDR(false),
compressedETC1RGB8Texture(false),
sRGB(false),
depthTextures(false),
depth32(false),
textureStorage(false),
textureNPOT(false),
drawBuffers(false),
textureFilterAnisotropic(false),
maxTextureAnisotropy(0.0f),
occlusionQueryBoolean(false),
fence(false),
timerQuery(false),
disjointTimerQuery(false),
queryCounterBitsTimeElapsed(0),
queryCounterBitsTimestamp(0),
robustness(false),
blendMinMax(false),
framebufferBlit(false),
framebufferMultisample(false),
instancedArrays(false),
packReverseRowOrder(false),
standardDerivatives(false),
shaderTextureLOD(false),
shaderFramebufferFetch(false),
ARMshaderFramebufferFetch(false),
NVshaderFramebufferFetch(false),
fragDepth(false),
textureUsage(false),
translatedShaderSource(false),
fboRenderMipmap(false),
discardFramebuffer(false),
debugMarker(false),
eglImage(false),
eglImageExternal(false),
eglImageExternalEssl3(false),
eglStreamConsumerExternal(false),
unpackSubimage(false),
packSubimage(false),
vertexArrayObject(false),
debug(false),
maxDebugMessageLength(0),
maxDebugLoggedMessages(0),
maxDebugGroupStackDepth(0),
maxLabelLength(0),
noError(false),
lossyETCDecode(false),
bindUniformLocation(false),
syncQuery(false),
copyTexture(false),
copyCompressedTexture(false),
webglCompatibility(false),
requestExtension(false),
bindGeneratesResource(false),
robustClientMemory(false),
textureSRGBDecode(false),
sRGBWriteControl(false),
colorBufferFloatRGB(false),
colorBufferFloatRGBA(false),
colorBufferFloat(false),
multisampleCompatibility(false),
framebufferMixedSamples(false),
textureNorm16(false),
pathRendering(false),
surfacelessContext(false),
clientArrays(false),
robustResourceInitialization(false)
{
}
std::vector<std::string> Extensions::getStrings() const
{
std::vector<std::string> extensionStrings;
for (const auto &extensionInfo : GetExtensionInfoMap())
{
if (this->*(extensionInfo.second.ExtensionsMember))
{
extensionStrings.push_back(extensionInfo.first);
}
}
return extensionStrings;
}
Limitations::Limitations()
: noFrontFacingSupport(false),
noSampleAlphaToCoverageSupport(false),
attributeZeroRequiresZeroDivisorInEXT(false),
noSeparateStencilRefsAndMasks(false),
shadersRequireIndexedLoopValidation(false),
noSimultaneousConstantColorAndAlphaBlendFunc(false)
{
}
static bool GetFormatSupportBase(const TextureCapsMap &textureCaps,
const GLenum *requiredFormats,
size_t requiredFormatsSize,
bool requiresTexturing,
bool requiresFiltering,
bool requiresRendering)
{
for (size_t i = 0; i < requiredFormatsSize; i++)
{
const TextureCaps &cap = textureCaps.get(requiredFormats[i]);
if (requiresTexturing && !cap.texturable)
{
return false;
}
if (requiresFiltering && !cap.filterable)
{
return false;
}
if (requiresRendering && !cap.renderable)
{
return false;
}
}
return true;
}
template <size_t N>
static bool GetFormatSupport(const TextureCapsMap &textureCaps,
const GLenum (&requiredFormats)[N],
bool requiresTexturing,
bool requiresFiltering,
bool requiresRendering)
{
return GetFormatSupportBase(textureCaps, requiredFormats, N, requiresTexturing,
requiresFiltering, requiresRendering);
}
// Check for GL_OES_packed_depth_stencil
static bool DeterminePackedDepthStencilSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_DEPTH24_STENCIL8,
};
return GetFormatSupport(textureCaps, requiredFormats, false, false, true);
}
// Checks for GL_OES_rgb8_rgba8 support
static bool DetermineRGB8AndRGBA8TextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGB8, GL_RGBA8,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, true);
}
// Checks for GL_EXT_texture_format_BGRA8888 support
static bool DetermineBGRA8TextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_BGRA8_EXT,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, true);
}
// Checks for GL_OES_color_buffer_half_float support
static bool DetermineColorBufferHalfFloatSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGBA16F, GL_RGB16F, GL_RG16F, GL_R16F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, false, true);
}
// Checks for GL_OES_texture_half_float support
static bool DetermineHalfFloatTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGB16F, GL_RGBA16F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, false, false);
}
// Checks for GL_OES_texture_half_float_linear support
static bool DetermineHalfFloatTextureFilteringSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGB16F, GL_RGBA16F,
};
return DetermineHalfFloatTextureSupport(textureCaps) &&
GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Checks for GL_OES_texture_float support
static bool DetermineFloatTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGB32F, GL_RGBA32F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, false, false);
}
// Checks for GL_OES_texture_float_linear support
static bool DetermineFloatTextureFilteringSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGB32F, GL_RGBA32F,
};
return DetermineFloatTextureSupport(textureCaps) &&
GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Checks for GL_EXT_texture_rg support
static bool DetermineRGHalfFloatTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_R16F, GL_RG16F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
static bool DetermineRGFloatTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_R32F, GL_RG32F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
static bool DetermineRGTextureSupport(const TextureCapsMap &textureCaps, bool checkHalfFloatFormats, bool checkFloatFormats)
{
if (checkHalfFloatFormats && !DetermineRGHalfFloatTextureSupport(textureCaps))
{
return false;
}
if (checkFloatFormats && !DetermineRGFloatTextureSupport(textureCaps))
{
return false;
}
constexpr GLenum requiredFormats[] = {
GL_R8, GL_RG8,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Check for GL_EXT_texture_compression_dxt1
static bool DetermineDXT1TextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Check for GL_ANGLE_texture_compression_dxt3
static bool DetermineDXT3TextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Check for GL_ANGLE_texture_compression_dxt5
static bool DetermineDXT5TextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Check for GL_EXT_texture_compression_s3tc_srgb
static bool DetermineS3TCsRGBTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Check for GL_KHR_texture_compression_astc_hdr and GL_KHR_texture_compression_astc_ldr
static bool DetermineASTCTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_COMPRESSED_RGBA_ASTC_4x4_KHR, GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
GL_COMPRESSED_RGBA_ASTC_5x5_KHR, GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
GL_COMPRESSED_RGBA_ASTC_6x6_KHR, GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
GL_COMPRESSED_RGBA_ASTC_8x6_KHR, GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
GL_COMPRESSED_RGBA_ASTC_10x5_KHR, GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
GL_COMPRESSED_RGBA_ASTC_10x8_KHR, GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
GL_COMPRESSED_RGBA_ASTC_12x10_KHR, GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Check for GL_ETC1_RGB8_OES
static bool DetermineETC1RGB8TextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_ETC1_RGB8_OES,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, false);
}
// Check for GL_ANGLE_texture_compression_dxt5
static bool DetermineSRGBTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFilterFormats[] = {
GL_SRGB8, GL_SRGB8_ALPHA8,
};
constexpr GLenum requiredRenderFormats[] = {
GL_SRGB8_ALPHA8,
};
return GetFormatSupport(textureCaps, requiredFilterFormats, true, true, false) &&
GetFormatSupport(textureCaps, requiredRenderFormats, true, false, true);
}
// Check for GL_ANGLE_depth_texture
static bool DetermineDepthTextureSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT32_OES, GL_DEPTH24_STENCIL8_OES,
};
return GetFormatSupport(textureCaps, requiredFormats, true, true, true);
}
// Check for GL_OES_depth32
static bool DetermineDepth32Support(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_DEPTH_COMPONENT32_OES,
};
return GetFormatSupport(textureCaps, requiredFormats, false, false, true);
}
// Check for GL_CHROMIUM_color_buffer_float_rgb
static bool DetermineColorBufferFloatRGBSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGB32F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, false, true);
}
// Check for GL_CHROMIUM_color_buffer_float_rgba
static bool DetermineColorBufferFloatRGBASupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_RGBA32F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, false, true);
}
// Check for GL_EXT_color_buffer_float
static bool DetermineColorBufferFloatSupport(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFormats[] = {
GL_R16F, GL_RG16F, GL_RGBA16F, GL_R32F, GL_RG32F, GL_RGBA32F, GL_R11F_G11F_B10F,
};
return GetFormatSupport(textureCaps, requiredFormats, true, false, true);
}
// Check for GL_EXT_texture_norm16
static bool DetermineTextureNorm16Support(const TextureCapsMap &textureCaps)
{
constexpr GLenum requiredFilterFormats[] = {
GL_R16_EXT, GL_RG16_EXT, GL_RGB16_EXT, GL_RGBA16_EXT,
GL_R16_SNORM_EXT, GL_RG16_SNORM_EXT, GL_RGB16_SNORM_EXT, GL_RGBA16_SNORM_EXT,
};
constexpr GLenum requiredRenderFormats[] = {
GL_R16_EXT, GL_RG16_EXT, GL_RGBA16_EXT,
};
return GetFormatSupport(textureCaps, requiredFilterFormats, true, true, false) &&
GetFormatSupport(textureCaps, requiredRenderFormats, true, false, true);
}
void Extensions::setTextureExtensionSupport(const TextureCapsMap &textureCaps)
{
packedDepthStencil = DeterminePackedDepthStencilSupport(textureCaps);
rgb8rgba8 = DetermineRGB8AndRGBA8TextureSupport(textureCaps);
textureFormatBGRA8888 = DetermineBGRA8TextureSupport(textureCaps);
colorBufferHalfFloat = DetermineColorBufferHalfFloatSupport(textureCaps);
textureHalfFloat = DetermineHalfFloatTextureSupport(textureCaps);
textureHalfFloatLinear = DetermineHalfFloatTextureFilteringSupport(textureCaps);
textureFloat = DetermineFloatTextureSupport(textureCaps);
textureFloatLinear = DetermineFloatTextureFilteringSupport(textureCaps);
#if defined(OS_STARBOARD)
textureRG = false;
#else
textureRG = DetermineRGTextureSupport(textureCaps, textureHalfFloat, textureFloat);
#endif // OS_STARBOARD
textureCompressionDXT1 = DetermineDXT1TextureSupport(textureCaps);
textureCompressionDXT3 = DetermineDXT3TextureSupport(textureCaps);
textureCompressionDXT5 = DetermineDXT5TextureSupport(textureCaps);
textureCompressionS3TCsRGB = DetermineS3TCsRGBTextureSupport(textureCaps);
textureCompressionASTCHDR = DetermineASTCTextureSupport(textureCaps);
textureCompressionASTCLDR = textureCompressionASTCHDR;
compressedETC1RGB8Texture = DetermineETC1RGB8TextureSupport(textureCaps);
sRGB = DetermineSRGBTextureSupport(textureCaps);
depthTextures = DetermineDepthTextureSupport(textureCaps);
depth32 = DetermineDepth32Support(textureCaps);
colorBufferFloatRGB = DetermineColorBufferFloatRGBSupport(textureCaps);
colorBufferFloatRGBA = DetermineColorBufferFloatRGBASupport(textureCaps);
colorBufferFloat = DetermineColorBufferFloatSupport(textureCaps);
textureNorm16 = DetermineTextureNorm16Support(textureCaps);
}
const ExtensionInfoMap &GetExtensionInfoMap()
{
auto buildExtensionInfoMap = []() {
auto enableableExtension = [](ExtensionInfo::ExtensionBool member) {
ExtensionInfo info;
info.Requestable = true;
info.ExtensionsMember = member;
return info;
};
auto esOnlyExtension = [](ExtensionInfo::ExtensionBool member) {
ExtensionInfo info;
info.ExtensionsMember = member;
return info;
};
// clang-format off
ExtensionInfoMap map;
map["GL_OES_element_index_uint"] = enableableExtension(&Extensions::elementIndexUint);
map["GL_OES_packed_depth_stencil"] = esOnlyExtension(&Extensions::packedDepthStencil);
map["GL_OES_get_program_binary"] = esOnlyExtension(&Extensions::getProgramBinary);
map["GL_OES_rgb8_rgba8"] = esOnlyExtension(&Extensions::rgb8rgba8);
map["GL_EXT_texture_format_BGRA8888"] = esOnlyExtension(&Extensions::textureFormatBGRA8888);
map["GL_EXT_read_format_bgra"] = esOnlyExtension(&Extensions::readFormatBGRA);
map["GL_NV_pixel_buffer_object"] = esOnlyExtension(&Extensions::pixelBufferObject);
map["GL_OES_mapbuffer"] = esOnlyExtension(&Extensions::mapBuffer);
map["GL_EXT_map_buffer_range"] = esOnlyExtension(&Extensions::mapBufferRange);
map["GL_EXT_color_buffer_half_float"] = enableableExtension(&Extensions::colorBufferHalfFloat);
map["GL_OES_texture_half_float"] = enableableExtension(&Extensions::textureHalfFloat);
map["GL_OES_texture_half_float_linear"] = enableableExtension(&Extensions::textureHalfFloatLinear);
map["GL_OES_texture_float"] = enableableExtension(&Extensions::textureFloat);
map["GL_OES_texture_float_linear"] = enableableExtension(&Extensions::textureFloatLinear);
map["GL_EXT_texture_rg"] = esOnlyExtension(&Extensions::textureRG);
map["GL_EXT_texture_compression_dxt1"] = esOnlyExtension(&Extensions::textureCompressionDXT1);
map["GL_ANGLE_texture_compression_dxt3"] = esOnlyExtension(&Extensions::textureCompressionDXT3);
map["GL_ANGLE_texture_compression_dxt5"] = esOnlyExtension(&Extensions::textureCompressionDXT5);
map["GL_EXT_texture_compression_s3tc_srgb"] = esOnlyExtension(&Extensions::textureCompressionS3TCsRGB);
map["GL_KHR_texture_compression_astc_hdr"] = esOnlyExtension(&Extensions::textureCompressionASTCHDR);
map["GL_KHR_texture_compression_astc_ldr"] = esOnlyExtension(&Extensions::textureCompressionASTCLDR);
map["GL_OES_compressed_ETC1_RGB8_texture"] = esOnlyExtension(&Extensions::compressedETC1RGB8Texture);
map["GL_EXT_sRGB"] = esOnlyExtension(&Extensions::sRGB);
map["GL_ANGLE_depth_texture"] = esOnlyExtension(&Extensions::depthTextures);
map["GL_OES_depth32"] = esOnlyExtension(&Extensions::depth32);
map["GL_EXT_texture_storage"] = esOnlyExtension(&Extensions::textureStorage);
map["GL_OES_texture_npot"] = enableableExtension(&Extensions::textureNPOT);
map["GL_EXT_draw_buffers"] = enableableExtension(&Extensions::drawBuffers);
map["GL_EXT_texture_filter_anisotropic"] = enableableExtension(&Extensions::textureFilterAnisotropic);
map["GL_EXT_occlusion_query_boolean"] = esOnlyExtension(&Extensions::occlusionQueryBoolean);
map["GL_NV_fence"] = esOnlyExtension(&Extensions::fence);
map["GL_ANGLE_timer_query"] = esOnlyExtension(&Extensions::timerQuery);
map["GL_EXT_disjoint_timer_query"] = esOnlyExtension(&Extensions::disjointTimerQuery);
map["GL_EXT_robustness"] = esOnlyExtension(&Extensions::robustness);
map["GL_EXT_blend_minmax"] = esOnlyExtension(&Extensions::blendMinMax);
map["GL_ANGLE_framebuffer_blit"] = esOnlyExtension(&Extensions::framebufferBlit);
map["GL_ANGLE_framebuffer_multisample"] = esOnlyExtension(&Extensions::framebufferMultisample);
map["GL_ANGLE_instanced_arrays"] = esOnlyExtension(&Extensions::instancedArrays);
map["GL_ANGLE_pack_reverse_row_order"] = esOnlyExtension(&Extensions::packReverseRowOrder);
map["GL_OES_standard_derivatives"] = enableableExtension(&Extensions::standardDerivatives);
map["GL_EXT_shader_texture_lod"] = enableableExtension(&Extensions::shaderTextureLOD);
map["GL_NV_shader_framebuffer_fetch"] = esOnlyExtension(&Extensions::NVshaderFramebufferFetch);
map["GL_ARM_shader_framebuffer_fetch"] = esOnlyExtension(&Extensions::ARMshaderFramebufferFetch);
map["GL_EXT_shader_framebuffer_fetch"] = esOnlyExtension(&Extensions::shaderFramebufferFetch);
map["GL_EXT_frag_depth"] = enableableExtension(&Extensions::fragDepth);
map["GL_ANGLE_texture_usage"] = esOnlyExtension(&Extensions::textureUsage);
map["GL_ANGLE_translated_shader_source"] = esOnlyExtension(&Extensions::translatedShaderSource);
map["GL_OES_fbo_render_mipmap"] = esOnlyExtension(&Extensions::fboRenderMipmap);
map["GL_EXT_discard_framebuffer"] = esOnlyExtension(&Extensions::discardFramebuffer);
map["GL_EXT_debug_marker"] = esOnlyExtension(&Extensions::debugMarker);
map["GL_OES_EGL_image"] = esOnlyExtension(&Extensions::eglImage);
map["GL_OES_EGL_image_external"] = esOnlyExtension(&Extensions::eglImageExternal);
map["GL_OES_EGL_image_external_essl3"] = esOnlyExtension(&Extensions::eglImageExternalEssl3);
map["GL_NV_EGL_stream_consumer_external"] = esOnlyExtension(&Extensions::eglStreamConsumerExternal);
map["GL_EXT_unpack_subimage"] = esOnlyExtension(&Extensions::unpackSubimage);
map["GL_NV_pack_subimage"] = esOnlyExtension(&Extensions::packSubimage);
map["GL_EXT_color_buffer_float"] = enableableExtension(&Extensions::colorBufferFloat);
map["GL_OES_vertex_array_object"] = esOnlyExtension(&Extensions::vertexArrayObject);
map["GL_KHR_debug"] = esOnlyExtension(&Extensions::debug);
// TODO(jmadill): Enable this when complete.
//map["GL_KHR_no_error"] = esOnlyExtension(&Extensions::noError);
map["GL_ANGLE_lossy_etc_decode"] = esOnlyExtension(&Extensions::lossyETCDecode);
map["GL_CHROMIUM_bind_uniform_location"] = esOnlyExtension(&Extensions::bindUniformLocation);
map["GL_CHROMIUM_sync_query"] = esOnlyExtension(&Extensions::syncQuery);
map["GL_CHROMIUM_copy_texture"] = esOnlyExtension(&Extensions::copyTexture);
map["GL_CHROMIUM_copy_compressed_texture"] = esOnlyExtension(&Extensions::copyCompressedTexture);
map["GL_ANGLE_webgl_compatibility"] = esOnlyExtension(&Extensions::webglCompatibility);
map["GL_ANGLE_request_extension"] = esOnlyExtension(&Extensions::requestExtension);
map["GL_CHROMIUM_bind_generates_resource"] = esOnlyExtension(&Extensions::bindGeneratesResource);
map["GL_ANGLE_robust_client_memory"] = esOnlyExtension(&Extensions::robustClientMemory);
map["GL_EXT_texture_sRGB_decode"] = esOnlyExtension(&Extensions::textureSRGBDecode);
map["GL_EXT_sRGB_write_control"] = esOnlyExtension(&Extensions::sRGBWriteControl);
map["GL_CHROMIUM_color_buffer_float_rgb"] = enableableExtension(&Extensions::colorBufferFloatRGB);
map["GL_CHROMIUM_color_buffer_float_rgba"] = enableableExtension(&Extensions::colorBufferFloatRGBA);
map["GL_EXT_multisample_compatibility"] = esOnlyExtension(&Extensions::multisampleCompatibility);
map["GL_CHROMIUM_framebuffer_mixed_samples"] = esOnlyExtension(&Extensions::framebufferMixedSamples);
map["GL_EXT_texture_norm16"] = esOnlyExtension(&Extensions::textureNorm16);
map["GL_CHROMIUM_path_rendering"] = esOnlyExtension(&Extensions::pathRendering);
map["GL_OES_surfaceless_context"] = esOnlyExtension(&Extensions::surfacelessContext);
map["GL_ANGLE_client_arrays"] = esOnlyExtension(&Extensions::clientArrays);
map["GL_ANGLE_robust_resource_initialization"] = esOnlyExtension(&Extensions::robustResourceInitialization);
// clang-format on
return map;
};
static const ExtensionInfoMap extensionInfo = buildExtensionInfoMap();
return extensionInfo;
}
TypePrecision::TypePrecision() : range({{0, 0}}), precision(0)
{
}
void TypePrecision::setIEEEFloat()
{
range = {{127, 127}};
precision = 23;
}
void TypePrecision::setTwosComplementInt(unsigned int bits)
{
range = {{static_cast<GLint>(bits) - 1, static_cast<GLint>(bits) - 2}};
precision = 0;
}
void TypePrecision::setSimulatedFloat(unsigned int r, unsigned int p)
{
range = {{static_cast<GLint>(r), static_cast<GLint>(r)}};
precision = static_cast<GLint>(p);
}
void TypePrecision::setSimulatedInt(unsigned int r)
{
range = {{static_cast<GLint>(r), static_cast<GLint>(r)}};
precision = 0;
}
void TypePrecision::get(GLint *returnRange, GLint *returnPrecision) const
{
std::copy(range.begin(), range.end(), returnRange);
*returnPrecision = precision;
}
Caps::Caps()
: maxElementIndex(0),
max3DTextureSize(0),
max2DTextureSize(0),
maxArrayTextureLayers(0),
maxLODBias(0),
maxCubeMapTextureSize(0),
maxRenderbufferSize(0),
minAliasedPointSize(0),
maxAliasedPointSize(0),
minAliasedLineWidth(0),
maxAliasedLineWidth(0),
// Table 20.40
maxDrawBuffers(0),
maxFramebufferWidth(0),
maxFramebufferHeight(0),
maxFramebufferSamples(0),
maxColorAttachments(0),
maxViewportWidth(0),
maxViewportHeight(0),
maxSampleMaskWords(0),
maxColorTextureSamples(0),
maxDepthTextureSamples(0),
maxIntegerSamples(0),
maxServerWaitTimeout(0),
// Table 20.41
maxVertexAttribRelativeOffset(0),
maxVertexAttribBindings(0),
maxVertexAttribStride(0),
maxElementsIndices(0),
maxElementsVertices(0),
// Table 20.43
maxVertexAttributes(0),
maxVertexUniformComponents(0),
maxVertexUniformVectors(0),
maxVertexUniformBlocks(0),
maxVertexOutputComponents(0),
maxVertexTextureImageUnits(0),
maxVertexAtomicCounterBuffers(0),
maxVertexAtomicCounters(0),
maxVertexImageUniforms(0),
maxVertexShaderStorageBlocks(0),
// Table 20.44
maxFragmentUniformComponents(0),
maxFragmentUniformVectors(0),
maxFragmentUniformBlocks(0),
maxFragmentInputComponents(0),
maxTextureImageUnits(0),
maxFragmentAtomicCounterBuffers(0),
maxFragmentAtomicCounters(0),
maxFragmentImageUniforms(0),
maxFragmentShaderStorageBlocks(0),
minProgramTextureGatherOffset(0),
maxProgramTextureGatherOffset(0),
minProgramTexelOffset(0),
maxProgramTexelOffset(0),
// Table 20.45
maxComputeWorkGroupInvocations(0),
maxComputeUniformBlocks(0),
maxComputeTextureImageUnits(0),
maxComputeSharedMemorySize(0),
maxComputeUniformComponents(0),
maxComputeAtomicCounterBuffers(0),
maxComputeAtomicCounters(0),
maxComputeImageUniforms(0),
maxCombinedComputeUniformComponents(0),
maxComputeShaderStorageBlocks(0),
// Table 20.46
maxUniformBufferBindings(0),
maxUniformBlockSize(0),
uniformBufferOffsetAlignment(0),
maxCombinedUniformBlocks(0),
maxCombinedVertexUniformComponents(0),
maxCombinedFragmentUniformComponents(0),
maxVaryingComponents(0),
maxVaryingVectors(0),
maxCombinedTextureImageUnits(0),
maxCombinedShaderOutputResources(0),
// Table 20.47
maxUniformLocations(0),
maxAtomicCounterBufferBindings(0),
maxAtomicCounterBufferSize(0),
maxCombinedAtomicCounterBuffers(0),
maxCombinedAtomicCounters(0),
maxImageUnits(0),
maxCombinedImageUniforms(0),
maxShaderStorageBufferBindings(0),
maxShaderStorageBlockSize(0),
maxCombinedShaderStorageBlocks(0),
shaderStorageBufferOffsetAlignment(0),
// Table 20.48
maxTransformFeedbackInterleavedComponents(0),
maxTransformFeedbackSeparateAttributes(0),
maxTransformFeedbackSeparateComponents(0),
// Table 20.49
maxSamples(0)
{
for (size_t i = 0; i < 3; ++i)
{
maxComputeWorkGroupCount[i] = 0;
maxComputeWorkGroupSize[i] = 0;
}
}
Caps GenerateMinimumCaps(const Version &clientVersion)
{
Caps caps;
if (clientVersion >= Version(2, 0))
{
// Table 6.18
caps.max2DTextureSize = 64;
caps.maxCubeMapTextureSize = 16;
caps.maxViewportWidth = caps.max2DTextureSize;
caps.maxViewportHeight = caps.max2DTextureSize;
caps.minAliasedPointSize = 1;
caps.maxAliasedPointSize = 1;
caps.minAliasedLineWidth = 1;
caps.maxAliasedLineWidth = 1;
// Table 6.19
caps.vertexHighpFloat.setSimulatedFloat(62, 16);
caps.vertexMediumpFloat.setSimulatedFloat(14, 10);
caps.vertexLowpFloat.setSimulatedFloat(1, 8);
caps.vertexHighpInt.setSimulatedInt(16);
caps.vertexMediumpInt.setSimulatedInt(10);
caps.vertexLowpInt.setSimulatedInt(8);
caps.fragmentHighpFloat.setSimulatedFloat(62, 16);
caps.fragmentMediumpFloat.setSimulatedFloat(14, 10);
caps.fragmentLowpFloat.setSimulatedFloat(1, 8);
caps.fragmentHighpInt.setSimulatedInt(16);
caps.fragmentMediumpInt.setSimulatedInt(10);
caps.fragmentLowpInt.setSimulatedInt(8);
// Table 6.20
caps.maxVertexAttributes = 8;
caps.maxVertexUniformVectors = 128;
caps.maxVaryingVectors = 8;
caps.maxCombinedTextureImageUnits = 8;
caps.maxTextureImageUnits = 8;
caps.maxFragmentUniformVectors = 16;
caps.maxRenderbufferSize = 1;
}
if (clientVersion >= Version(3, 0))
{
// Table 6.28
caps.maxElementIndex = (1 << 24) - 1;
caps.max3DTextureSize = 256;
caps.max2DTextureSize = 2048;
caps.maxArrayTextureLayers = 256;
caps.maxLODBias = 2.0f;
caps.maxCubeMapTextureSize = 2048;
caps.maxRenderbufferSize = 2048;
caps.maxDrawBuffers = 4;
caps.maxColorAttachments = 4;
caps.maxViewportWidth = caps.max2DTextureSize;
caps.maxViewportHeight = caps.max2DTextureSize;
// Table 6.29
caps.compressedTextureFormats.push_back(GL_COMPRESSED_R11_EAC);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_SIGNED_R11_EAC);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_RG11_EAC);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_SIGNED_RG11_EAC);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_RGB8_ETC2);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_SRGB8_ETC2);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_RGBA8_ETC2_EAC);
caps.compressedTextureFormats.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC);
caps.vertexHighpFloat.setIEEEFloat();
caps.vertexHighpInt.setTwosComplementInt(32);
caps.vertexMediumpInt.setTwosComplementInt(16);
caps.vertexLowpInt.setTwosComplementInt(8);
caps.fragmentHighpFloat.setIEEEFloat();
caps.fragmentHighpInt.setSimulatedInt(32);
caps.fragmentMediumpInt.setTwosComplementInt(16);
caps.fragmentLowpInt.setTwosComplementInt(8);
caps.maxServerWaitTimeout = 0;
// Table 6.31
caps.maxVertexAttributes = 16;
caps.maxVertexUniformComponents = 1024;
caps.maxVertexUniformVectors = 256;
caps.maxVertexUniformBlocks = 12;
caps.maxVertexOutputComponents = 64;
caps.maxVertexTextureImageUnits = 16;
// Table 6.32
caps.maxFragmentUniformComponents = 896;
caps.maxFragmentUniformVectors = 224;
caps.maxFragmentUniformBlocks = 12;
caps.maxFragmentInputComponents = 60;
caps.maxTextureImageUnits = 16;
caps.minProgramTexelOffset = -8;
caps.maxProgramTexelOffset = 7;
// Table 6.33
caps.maxUniformBufferBindings = 24;
caps.maxUniformBlockSize = 16384;
caps.uniformBufferOffsetAlignment = 256;
caps.maxCombinedUniformBlocks = 24;
caps.maxCombinedVertexUniformComponents =
caps.maxVertexUniformBlocks * (caps.maxUniformBlockSize / 4) +
caps.maxVertexUniformComponents;
caps.maxCombinedFragmentUniformComponents =
caps.maxFragmentUniformBlocks * (caps.maxUniformBlockSize / 4) +
caps.maxFragmentUniformComponents;
caps.maxVaryingComponents = 60;
caps.maxVaryingVectors = 15;
caps.maxCombinedTextureImageUnits = 32;
// Table 6.34
caps.maxTransformFeedbackInterleavedComponents = 64;
caps.maxTransformFeedbackSeparateAttributes = 4;
caps.maxTransformFeedbackSeparateComponents = 4;
// Table 3.35
caps.maxSamples = 4;
}
if (clientVersion >= Version(3, 1))
{
// Table 20.40
caps.maxFramebufferWidth = 2048;
caps.maxFramebufferHeight = 2048;
caps.maxFramebufferSamples = 4;
caps.maxSampleMaskWords = 1;
caps.maxColorTextureSamples = 1;
caps.maxDepthTextureSamples = 1;
caps.maxIntegerSamples = 1;
// Table 20.41
caps.maxVertexAttribRelativeOffset = 2047;
caps.maxVertexAttribBindings = 16;
caps.maxVertexAttribStride = 2048;
// Table 20.43
caps.maxVertexAtomicCounterBuffers = 0;
caps.maxVertexAtomicCounters = 0;
caps.maxVertexImageUniforms = 0;
caps.maxVertexShaderStorageBlocks = 0;
// Table 20.44
caps.maxFragmentUniformComponents = 1024;
caps.maxFragmentUniformVectors = 256;
caps.maxFragmentAtomicCounterBuffers = 0;
caps.maxFragmentAtomicCounters = 0;
caps.maxFragmentImageUniforms = 0;
caps.maxFragmentShaderStorageBlocks = 0;
caps.minProgramTextureGatherOffset = 0;
caps.maxProgramTextureGatherOffset = 0;
// Table 20.45
caps.maxComputeWorkGroupCount = {{65535, 65535, 65535}};
caps.maxComputeWorkGroupSize = {{128, 128, 64}};
caps.maxComputeWorkGroupInvocations = 12;
caps.maxComputeUniformBlocks = 12;
caps.maxComputeTextureImageUnits = 16;
caps.maxComputeSharedMemorySize = 16384;
caps.maxComputeUniformComponents = 1024;
caps.maxComputeAtomicCounterBuffers = 1;
caps.maxComputeAtomicCounters = 8;
caps.maxComputeImageUniforms = 4;
caps.maxCombinedComputeUniformComponents =
caps.maxComputeUniformBlocks * static_cast<GLuint>(caps.maxUniformBlockSize / 4) +
caps.maxComputeUniformComponents;
caps.maxComputeShaderStorageBlocks = 4;
// Table 20.46
caps.maxUniformBufferBindings = 36;
caps.maxCombinedFragmentUniformComponents =
caps.maxFragmentUniformBlocks * (caps.maxUniformBlockSize / 4) +
caps.maxFragmentUniformComponents;
caps.maxCombinedTextureImageUnits = 48;
caps.maxCombinedShaderOutputResources = 4;
// Table 20.47
caps.maxUniformLocations = 1024;
caps.maxAtomicCounterBufferBindings = 1;
caps.maxAtomicCounterBufferSize = 32;
caps.maxCombinedAtomicCounterBuffers = 1;
caps.maxCombinedAtomicCounters = 8;
caps.maxImageUnits = 4;
caps.maxCombinedImageUniforms = 4;
caps.maxShaderStorageBufferBindings = 4;
caps.maxShaderStorageBlockSize = 1 << 27;
caps.maxCombinedShaderStorageBlocks = 4;
caps.shaderStorageBufferOffsetAlignment = 256;
}
return caps;
}
}
namespace egl
{
Caps::Caps()
: textureNPOT(false)
{
}
DisplayExtensions::DisplayExtensions()
: createContextRobustness(false),
d3dShareHandleClientBuffer(false),
d3dTextureClientBuffer(false),
surfaceD3DTexture2DShareHandle(false),
querySurfacePointer(false),
windowFixedSize(false),
keyedMutex(false),
surfaceOrientation(false),
postSubBuffer(false),
createContext(false),
deviceQuery(false),
image(false),
imageBase(false),
imagePixmap(false),
glTexture2DImage(false),
glTextureCubemapImage(false),
glTexture3DImage(false),
glRenderbufferImage(false),
getAllProcAddresses(false),
flexibleSurfaceCompatibility(false),
directComposition(false),
createContextNoError(false),
stream(false),
streamConsumerGLTexture(false),
streamConsumerGLTextureYUV(false),
streamProducerD3DTextureNV12(false),
createContextWebGLCompatibility(false),
createContextBindGeneratesResource(false),
getSyncValues(false),
swapBuffersWithDamage(false),
pixelFormatFloat(false),
surfacelessContext(false),
displayTextureShareGroup(false),
createContextClientArrays(false),
createContextRobustResourceInitialization(false)
{
}
std::vector<std::string> DisplayExtensions::getStrings() const
{
std::vector<std::string> extensionStrings;
// clang-format off
// | Extension name | Supported flag | Output vector |
InsertExtensionString("EGL_EXT_create_context_robustness", createContextRobustness, &extensionStrings);
InsertExtensionString("EGL_ANGLE_d3d_share_handle_client_buffer", d3dShareHandleClientBuffer, &extensionStrings);
InsertExtensionString("EGL_ANGLE_d3d_texture_client_buffer", d3dTextureClientBuffer, &extensionStrings);
InsertExtensionString("EGL_ANGLE_surface_d3d_texture_2d_share_handle", surfaceD3DTexture2DShareHandle, &extensionStrings);
InsertExtensionString("EGL_ANGLE_query_surface_pointer", querySurfacePointer, &extensionStrings);
InsertExtensionString("EGL_ANGLE_window_fixed_size", windowFixedSize, &extensionStrings);
InsertExtensionString("EGL_ANGLE_keyed_mutex", keyedMutex, &extensionStrings);
InsertExtensionString("EGL_ANGLE_surface_orientation", surfaceOrientation, &extensionStrings);
InsertExtensionString("EGL_ANGLE_direct_composition", directComposition, &extensionStrings);
InsertExtensionString("EGL_NV_post_sub_buffer", postSubBuffer, &extensionStrings);
InsertExtensionString("EGL_KHR_create_context", createContext, &extensionStrings);
InsertExtensionString("EGL_EXT_device_query", deviceQuery, &extensionStrings);
InsertExtensionString("EGL_KHR_image", image, &extensionStrings);
InsertExtensionString("EGL_KHR_image_base", imageBase, &extensionStrings);
InsertExtensionString("EGL_KHR_image_pixmap", imagePixmap, &extensionStrings);
InsertExtensionString("EGL_KHR_gl_texture_2D_image", glTexture2DImage, &extensionStrings);
InsertExtensionString("EGL_KHR_gl_texture_cubemap_image", glTextureCubemapImage, &extensionStrings);
InsertExtensionString("EGL_KHR_gl_texture_3D_image", glTexture3DImage, &extensionStrings);
InsertExtensionString("EGL_KHR_gl_renderbuffer_image", glRenderbufferImage, &extensionStrings);
InsertExtensionString("EGL_KHR_get_all_proc_addresses", getAllProcAddresses, &extensionStrings);
InsertExtensionString("EGL_KHR_stream", stream, &extensionStrings);
InsertExtensionString("EGL_KHR_stream_consumer_gltexture", streamConsumerGLTexture, &extensionStrings);
InsertExtensionString("EGL_NV_stream_consumer_gltexture_yuv", streamConsumerGLTextureYUV, &extensionStrings);
InsertExtensionString("EGL_ANGLE_flexible_surface_compatibility", flexibleSurfaceCompatibility, &extensionStrings);
InsertExtensionString("EGL_ANGLE_stream_producer_d3d_texture_nv12", streamProducerD3DTextureNV12, &extensionStrings);
InsertExtensionString("EGL_ANGLE_create_context_webgl_compatibility", createContextWebGLCompatibility, &extensionStrings);
InsertExtensionString("EGL_CHROMIUM_create_context_bind_generates_resource", createContextBindGeneratesResource, &extensionStrings);
InsertExtensionString("EGL_CHROMIUM_sync_control", getSyncValues, &extensionStrings);
InsertExtensionString("EGL_EXT_swap_buffers_with_damage", swapBuffersWithDamage, &extensionStrings);
InsertExtensionString("EGL_EXT_pixel_format_float", pixelFormatFloat, &extensionStrings);
InsertExtensionString("EGL_KHR_surfaceless_context", surfacelessContext, &extensionStrings);
InsertExtensionString("EGL_ANGLE_display_texture_share_group", displayTextureShareGroup, &extensionStrings);
InsertExtensionString("EGL_ANGLE_create_context_client_arrays", createContextClientArrays, &extensionStrings);
InsertExtensionString("EGL_ANGLE_create_context_robust_resource_initialization", createContextRobustResourceInitialization, &extensionStrings);
// TODO(jmadill): Enable this when complete.
//InsertExtensionString("KHR_create_context_no_error", createContextNoError, &extensionStrings);
// clang-format on
return extensionStrings;
}
DeviceExtensions::DeviceExtensions()
: deviceD3D(false)
{
}
std::vector<std::string> DeviceExtensions::getStrings() const
{
std::vector<std::string> extensionStrings;
// | Extension name | Supported flag | Output vector |
InsertExtensionString("EGL_ANGLE_device_d3d", deviceD3D, &extensionStrings);
return extensionStrings;
}
ClientExtensions::ClientExtensions()
: clientExtensions(false),
platformBase(false),
platformDevice(false),
platformANGLE(false),
platformANGLED3D(false),
platformANGLEOpenGL(false),
platformANGLEVulkan(false),
deviceCreation(false),
deviceCreationD3D11(false),
x11Visual(false),
experimentalPresentPath(false),
clientGetAllProcAddresses(false)
{
}
std::vector<std::string> ClientExtensions::getStrings() const
{
std::vector<std::string> extensionStrings;
// clang-format off
// | Extension name | Supported flag | Output vector |
InsertExtensionString("EGL_EXT_client_extensions", clientExtensions, &extensionStrings);
InsertExtensionString("EGL_EXT_platform_base", platformBase, &extensionStrings);
InsertExtensionString("EGL_EXT_platform_device", platformDevice, &extensionStrings);
InsertExtensionString("EGL_ANGLE_platform_angle", platformANGLE, &extensionStrings);
InsertExtensionString("EGL_ANGLE_platform_angle_d3d", platformANGLED3D, &extensionStrings);
InsertExtensionString("EGL_ANGLE_platform_angle_opengl", platformANGLEOpenGL, &extensionStrings);
InsertExtensionString("EGL_ANGLE_platform_angle_null", platformANGLENULL, &extensionStrings);
InsertExtensionString("EGL_ANGLE_platform_angle_vulkan", platformANGLEVulkan, &extensionStrings);
InsertExtensionString("EGL_ANGLE_device_creation", deviceCreation, &extensionStrings);
InsertExtensionString("EGL_ANGLE_device_creation_d3d11", deviceCreationD3D11, &extensionStrings);
InsertExtensionString("EGL_ANGLE_x11_visual", x11Visual, &extensionStrings);
InsertExtensionString("EGL_ANGLE_experimental_present_path", experimentalPresentPath, &extensionStrings);
InsertExtensionString("EGL_KHR_client_get_all_proc_addresses", clientGetAllProcAddresses, &extensionStrings);
// clang-format on
return extensionStrings;
}
}