1367 lines
62 KiB
C++
1367 lines
62 KiB
C++
//
|
|
// 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.
|
|
//
|
|
|
|
#include "libANGLE/Caps.h"
|
|
|
|
#include "common/angleutils.h"
|
|
#include "common/debug.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() = default;
|
|
|
|
TextureCaps::TextureCaps(const TextureCaps &other) = default;
|
|
|
|
TextureCaps &TextureCaps::operator=(const TextureCaps &other) = default;
|
|
|
|
TextureCaps::~TextureCaps() = default;
|
|
|
|
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.filterable = internalFormatInfo.filterSupport(clientVersion, extensions);
|
|
caps.textureAttachment = internalFormatInfo.textureAttachmentSupport(clientVersion, extensions);
|
|
caps.renderbuffer = internalFormatInfo.renderbufferSupport(clientVersion, extensions);
|
|
caps.blendable = internalFormatInfo.blendSupport(clientVersion, extensions);
|
|
|
|
caps.sampleCounts.insert(0);
|
|
if (internalFormatInfo.isRequiredRenderbufferFormat(clientVersion))
|
|
{
|
|
if ((clientVersion.major >= 3 && clientVersion.minor >= 1) ||
|
|
(clientVersion.major >= 3 && !internalFormatInfo.isInt()))
|
|
{
|
|
caps.sampleCounts.insert(4);
|
|
}
|
|
}
|
|
|
|
return caps;
|
|
}
|
|
|
|
TextureCapsMap::TextureCapsMap() {}
|
|
|
|
TextureCapsMap::~TextureCapsMap() {}
|
|
|
|
void TextureCapsMap::insert(GLenum internalFormat, const TextureCaps &caps)
|
|
{
|
|
angle::FormatID formatID = angle::Format::InternalFormatToID(internalFormat);
|
|
get(formatID) = caps;
|
|
}
|
|
|
|
void TextureCapsMap::clear()
|
|
{
|
|
mFormatData.fill(TextureCaps());
|
|
}
|
|
|
|
const TextureCaps &TextureCapsMap::get(GLenum internalFormat) const
|
|
{
|
|
angle::FormatID formatID = angle::Format::InternalFormatToID(internalFormat);
|
|
return get(formatID);
|
|
}
|
|
|
|
const TextureCaps &TextureCapsMap::get(angle::FormatID formatID) const
|
|
{
|
|
return mFormatData[formatID];
|
|
}
|
|
|
|
TextureCaps &TextureCapsMap::get(angle::FormatID formatID)
|
|
{
|
|
return mFormatData[formatID];
|
|
}
|
|
|
|
void TextureCapsMap::set(angle::FormatID formatID, const TextureCaps &caps)
|
|
{
|
|
get(formatID) = caps;
|
|
}
|
|
|
|
void InitMinimumTextureCapsMap(const Version &clientVersion,
|
|
const Extensions &extensions,
|
|
TextureCapsMap *capsMap)
|
|
{
|
|
for (GLenum internalFormat : GetAllSizedInternalFormats())
|
|
{
|
|
capsMap->insert(internalFormat,
|
|
GenerateMinimumTextureCaps(internalFormat, clientVersion, extensions));
|
|
}
|
|
}
|
|
|
|
Extensions::Extensions() = default;
|
|
|
|
Extensions::Extensions(const Extensions &other) = default;
|
|
|
|
Extensions &Extensions::operator=(const Extensions &other) = default;
|
|
|
|
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() = default;
|
|
Limitations::Limitations(const Limitations &other) = default;
|
|
|
|
Limitations &Limitations::operator=(const Limitations &other) = default;
|
|
|
|
static bool GetFormatSupportBase(const TextureCapsMap &textureCaps,
|
|
const GLenum *requiredFormats,
|
|
size_t requiredFormatsSize,
|
|
bool requiresTexturing,
|
|
bool requiresFiltering,
|
|
bool requiresAttachingTexture,
|
|
bool requiresRenderbufferSupport,
|
|
bool requiresBlending)
|
|
{
|
|
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 (requiresAttachingTexture && !cap.textureAttachment)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (requiresRenderbufferSupport && !cap.renderbuffer)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (requiresBlending && !cap.blendable)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <size_t N>
|
|
static bool GetFormatSupport(const TextureCapsMap &textureCaps,
|
|
const GLenum (&requiredFormats)[N],
|
|
bool requiresTexturing,
|
|
bool requiresFiltering,
|
|
bool requiresAttachingTexture,
|
|
bool requiresRenderbufferSupport,
|
|
bool requiresBlending)
|
|
{
|
|
return GetFormatSupportBase(textureCaps, requiredFormats, N, requiresTexturing,
|
|
requiresFiltering, requiresAttachingTexture,
|
|
requiresRenderbufferSupport, requiresBlending);
|
|
}
|
|
|
|
// Check for GL_OES_packed_depth_stencil support
|
|
static bool DeterminePackedDepthStencilSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_DEPTH24_STENCIL8,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, false, true, true, false);
|
|
}
|
|
|
|
// Checks for GL_NV_read_depth support
|
|
static bool DetermineReadDepthSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_DEPTH_COMPONENT16,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, false, false);
|
|
}
|
|
|
|
// Checks for GL_NV_read_stencil support
|
|
static bool DetermineReadStencilSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_STENCIL_INDEX8,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, false, true, false, false);
|
|
}
|
|
|
|
// Checks for GL_NV_depth_buffer_float2 support
|
|
static bool DetermineDepthBufferFloat2Support(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_DEPTH_COMPONENT32F,
|
|
GL_DEPTH32F_STENCIL8,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, false, false);
|
|
}
|
|
|
|
// Checks for GL_OES_rgb8_rgba8 support
|
|
static bool DetermineRGB8AndRGBA8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGB8,
|
|
GL_RGBA8,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, false, false, true, false);
|
|
}
|
|
|
|
// 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, true, false);
|
|
}
|
|
|
|
// Checks for GL_EXT_read_format_bgra support
|
|
static bool DetermineBGRAReadFormatSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_BGRA8_EXT,
|
|
// TODO(http://anglebug.com/4302): GL_EXT_read_format_bgra specifies 2 more types, which are
|
|
// currently ignored. The equivalent formats would be: GL_BGRA4_ANGLEX, GL_BGR5_A1_ANGLEX
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, true, false);
|
|
}
|
|
|
|
// Checks for GL_OES_color_buffer_half_float support
|
|
static bool DetermineColorBufferHalfFloatSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
// EXT_color_buffer_half_float issue #2 states that an implementation doesn't need to support
|
|
// rendering to any of the formats but is expected to be able to render to at least one. WebGL
|
|
// requires that at least RGBA16F is renderable so we make the same requirement.
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGBA16F,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, false, true, true, false);
|
|
}
|
|
|
|
// Checks for GL_OES_texture_half_float support
|
|
static bool DetermineHalfFloatTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGBA16F, GL_RGB16F, GL_LUMINANCE_ALPHA16F_EXT, GL_LUMINANCE16F_EXT, GL_ALPHA16F_EXT,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, false, false, false);
|
|
}
|
|
|
|
// Checks for GL_OES_texture_half_float_linear support
|
|
static bool DetermineHalfFloatTextureFilteringSupport(const TextureCapsMap &textureCaps,
|
|
bool checkLegacyFormats)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {GL_RGBA16F, GL_RGB16F};
|
|
// If GL_OES_texture_half_float is present, this extension must also support legacy formats
|
|
// introduced by that extension
|
|
constexpr GLenum requiredFormatsES2[] = {GL_LUMINANCE_ALPHA16F_EXT, GL_LUMINANCE16F_EXT,
|
|
GL_ALPHA16F_EXT};
|
|
|
|
if (checkLegacyFormats &&
|
|
!GetFormatSupport(textureCaps, requiredFormatsES2, false, true, false, false, false))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, true, false, false, false);
|
|
}
|
|
|
|
// Checks for GL_OES_texture_float support
|
|
static bool DetermineFloatTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGBA32F, GL_RGB32F, GL_LUMINANCE_ALPHA32F_EXT, GL_LUMINANCE32F_EXT, GL_ALPHA32F_EXT,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, false, false, false);
|
|
}
|
|
|
|
// Checks for GL_OES_texture_float_linear support
|
|
static bool DetermineFloatTextureFilteringSupport(const TextureCapsMap &textureCaps,
|
|
bool checkLegacyFormats)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGBA32F,
|
|
GL_RGB32F,
|
|
};
|
|
// If GL_OES_texture_float is present, this extension must also support legacy formats
|
|
// introduced by that extension
|
|
constexpr GLenum requiredFormatsES2[] = {
|
|
GL_LUMINANCE_ALPHA32F_EXT,
|
|
GL_LUMINANCE32F_EXT,
|
|
GL_ALPHA32F_EXT,
|
|
};
|
|
|
|
if (checkLegacyFormats &&
|
|
!GetFormatSupport(textureCaps, requiredFormatsES2, false, true, false, false, false))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, true, false, false, false);
|
|
}
|
|
|
|
// Checks for GL_EXT_texture_rg support
|
|
static bool DetermineRGTextureSupport(const TextureCapsMap &textureCaps,
|
|
bool checkHalfFloatFormats,
|
|
bool checkFloatFormats)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_R8,
|
|
GL_RG8,
|
|
};
|
|
constexpr GLenum requiredHalfFloatFormats[] = {
|
|
GL_R16F,
|
|
GL_RG16F,
|
|
};
|
|
constexpr GLenum requiredFloatFormats[] = {
|
|
GL_R32F,
|
|
GL_RG32F,
|
|
};
|
|
|
|
if (checkHalfFloatFormats &&
|
|
!GetFormatSupport(textureCaps, requiredHalfFloatFormats, true, false, false, false, false))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (checkFloatFormats &&
|
|
!GetFormatSupport(textureCaps, requiredFloatFormats, true, false, false, false, false))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, true, true, false);
|
|
}
|
|
|
|
static bool DetermineTextureFormat2101010Support(const TextureCapsMap &textureCaps)
|
|
{
|
|
// GL_EXT_texture_type_2_10_10_10_REV specifies both RGBA and RGB support whereas desktop GL
|
|
// only specifies RGBA support, so check both RGBA and RGB before marking as supported.
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGB10_A2,
|
|
GL_RGB10_UNORM_ANGLEX,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_EXT_texture_compression_dxt1 support
|
|
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, false, false);
|
|
}
|
|
|
|
// Check for GL_ANGLE_texture_compression_dxt3 support
|
|
static bool DetermineDXT3TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_ANGLE_texture_compression_dxt5 support
|
|
static bool DetermineDXT5TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_EXT_texture_compression_s3tc_srgb support
|
|
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, false, false);
|
|
}
|
|
|
|
// Check for GL_KHR_texture_compression_astc_ldr support
|
|
static bool DetermineASTCLDRTextureSupport(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, false, false);
|
|
}
|
|
|
|
// Check for GL_OES_texture_compression_astc support
|
|
static bool DetermineASTCOESTExtureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
if (!DetermineASTCLDRTextureSupport(textureCaps))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// The OES version of the extension also requires the 3D ASTC formats
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGBA_ASTC_3x3x3_OES, GL_COMPRESSED_RGBA_ASTC_4x3x3_OES,
|
|
GL_COMPRESSED_RGBA_ASTC_4x4x3_OES, GL_COMPRESSED_RGBA_ASTC_4x4x4_OES,
|
|
GL_COMPRESSED_RGBA_ASTC_5x4x4_OES, GL_COMPRESSED_RGBA_ASTC_5x5x4_OES,
|
|
GL_COMPRESSED_RGBA_ASTC_5x5x5_OES, GL_COMPRESSED_RGBA_ASTC_6x5x5_OES,
|
|
GL_COMPRESSED_RGBA_ASTC_6x6x5_OES, GL_COMPRESSED_RGBA_ASTC_6x6x6_OES,
|
|
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES,
|
|
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES,
|
|
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES,
|
|
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES,
|
|
GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_ETC1_RGB8_OES support
|
|
static bool DetermineETC1RGB8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_ETC1_RGB8_OES,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_ETC2_RGB8_texture support
|
|
static bool DetermineETC2RGB8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGB8_ETC2,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_ETC2_sRGB8_texture support
|
|
static bool DetermineETC2sRGB8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_SRGB8_ETC2,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_ETC2_punchthroughA_RGBA8_texture support
|
|
static bool DetermineETC2PunchthroughARGB8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_ETC2_punchthroughA_sRGB8_alpha_texture support
|
|
static bool DetermineETC2PunchthroughAsRGB8AlphaTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_ETC2_RGBA8_texture support
|
|
static bool DetermineETC2RGBA8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGBA8_ETC2_EAC,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_ETC2_sRGB8_alpha8_texture support
|
|
static bool DetermineETC2sRGB8Alpha8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_EAC_R11_unsigned_texture support
|
|
static bool DetermineEACR11UnsignedTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_R11_EAC,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_EAC_R11_signed_texture support
|
|
static bool DetermineEACR11SignedTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_SIGNED_R11_EAC,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_EAC_RG11_unsigned_texture support
|
|
static bool DetermineEACRG11UnsignedTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RG11_EAC,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for OES_compressed_EAC_RG11_signed_texture support
|
|
static bool DetermineEACRG11SignedTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_SIGNED_RG11_EAC,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_EXT_sRGB support
|
|
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, false, false) &&
|
|
GetFormatSupport(textureCaps, requiredRenderFormats, true, false, true, true, false);
|
|
}
|
|
|
|
// Check for GL_EXT_texture_sRGB_R8 support
|
|
static bool DetermineSRGBR8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFilterFormats[] = {GL_SR8_EXT};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFilterFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_EXT_texture_sRGB_RG8 support
|
|
static bool DetermineSRGBRG8TextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFilterFormats[] = {GL_SRG8_EXT};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFilterFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_ANGLE_depth_texture support
|
|
static bool DetermineDepthTextureANGLESupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_DEPTH_COMPONENT16,
|
|
#if !defined(ANGLE_PLATFORM_IOS) && \
|
|
(!defined(ANGLE_PLATFORM_MACCATALYST) || !defined(ANGLE_CPU_ARM64))
|
|
// anglebug.com/6082
|
|
// TODO(dino): Temporarily Removing the need for GL_DEPTH_COMPONENT32_OES
|
|
// because it is not supported on iOS.
|
|
// TODO(dino): I think this needs to be a runtime check when running an iOS app on Mac.
|
|
GL_DEPTH_COMPONENT32_OES,
|
|
#endif
|
|
GL_DEPTH24_STENCIL8_OES,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, false, false);
|
|
}
|
|
|
|
// Check for GL_OES_depth_texture support
|
|
static bool DetermineDepthTextureOESSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_DEPTH_COMPONENT16,
|
|
#if !defined(ANGLE_PLATFORM_IOS) && \
|
|
(!defined(ANGLE_PLATFORM_MACCATALYST) || !defined(ANGLE_CPU_ARM64))
|
|
// anglebug.com/6082
|
|
// TODO(dino): Temporarily Removing the need for GL_DEPTH_COMPONENT32_OES
|
|
// because it is not supported on iOS.
|
|
// TODO(dino): I think this needs to be a runtime check when running an iOS app on Mac.
|
|
GL_DEPTH_COMPONENT32_OES,
|
|
#endif
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, true, false);
|
|
}
|
|
|
|
// Check for GL_OES_depth24
|
|
static bool DetermineDepth24OESSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_DEPTH_COMPONENT24_OES,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, false, false, true, false);
|
|
}
|
|
|
|
// Check for GL_OES_depth32 support
|
|
static bool DetermineDepth32Support(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_DEPTH_COMPONENT32_OES,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, false, true, true, false);
|
|
}
|
|
|
|
// Check for GL_CHROMIUM_color_buffer_float_rgb support
|
|
static bool DetermineColorBufferFloatRGBSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGB32F,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, false, false);
|
|
}
|
|
|
|
// Check for GL_CHROMIUM_color_buffer_float_rgba support
|
|
static bool DetermineColorBufferFloatRGBASupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_RGBA32F,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, true, false);
|
|
}
|
|
|
|
// Check for GL_EXT_color_buffer_float support
|
|
static bool DetermineColorBufferFloatSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum nonBlendableFormats[] = {
|
|
GL_R32F,
|
|
GL_RG32F,
|
|
GL_RGBA32F,
|
|
};
|
|
|
|
constexpr GLenum blendableFormats[] = {
|
|
GL_R16F,
|
|
GL_RG16F,
|
|
GL_RGBA16F,
|
|
GL_R11F_G11F_B10F,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, nonBlendableFormats, true, false, true, true, false) &&
|
|
GetFormatSupport(textureCaps, blendableFormats, true, false, true, true, true);
|
|
}
|
|
|
|
// Check for GL_EXT_float_blend support
|
|
static bool DetermineFloatBlendSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_R32F,
|
|
GL_RG32F,
|
|
GL_RGBA32F,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, false, true, true, true);
|
|
}
|
|
|
|
// Check for GL_EXT_texture_norm16 support
|
|
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, false, false) &&
|
|
GetFormatSupport(textureCaps, requiredRenderFormats, true, false, true, true, false);
|
|
}
|
|
|
|
// Check for EXT_texture_compression_rgtc support
|
|
static bool DetermineRGTCTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RED_RGTC1_EXT, GL_COMPRESSED_SIGNED_RED_RGTC1_EXT,
|
|
GL_COMPRESSED_RED_GREEN_RGTC2_EXT, GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for EXT_texture_compression_bptc support
|
|
static bool DetermineBPTCTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGBA_BPTC_UNORM_EXT, GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT,
|
|
GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT, GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_IMG_texture_compression_pvrtc support
|
|
static bool DeterminePVRTCTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
|
|
GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Check for GL_EXT_pvrtc_sRGB support
|
|
static bool DeterminePVRTCsRGBTextureSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT, GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT,
|
|
GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT, GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
bool DetermineCompressedTextureETCSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {GL_COMPRESSED_R11_EAC,
|
|
GL_COMPRESSED_SIGNED_R11_EAC,
|
|
GL_COMPRESSED_RG11_EAC,
|
|
GL_COMPRESSED_SIGNED_RG11_EAC,
|
|
GL_COMPRESSED_RGB8_ETC2,
|
|
GL_COMPRESSED_SRGB8_ETC2,
|
|
GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
|
|
GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
|
|
GL_COMPRESSED_RGBA8_ETC2_EAC,
|
|
GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, true, true, false, false, false);
|
|
}
|
|
|
|
// Checks for GL_OES_texture_stencil8 support
|
|
static bool DetermineStencilIndex8Support(const TextureCapsMap &textureCaps)
|
|
{
|
|
constexpr GLenum requiredFormats[] = {
|
|
GL_STENCIL_INDEX8,
|
|
};
|
|
|
|
return GetFormatSupport(textureCaps, requiredFormats, false, false, true, false, false);
|
|
}
|
|
|
|
void Extensions::setTextureExtensionSupport(const TextureCapsMap &textureCaps)
|
|
{
|
|
// TODO(ynovikov): rgb8Rgba8OES, colorBufferHalfFloatEXT, textureHalfFloatOES,
|
|
// textureHalfFloatLinearOES, textureFloatOES, textureFloatLinearOES, textureRgEXT, sRGB,
|
|
// colorBufferFloatRgbCHROMIUM, colorBufferFloatRgbaCHROMIUM and colorBufferFloatEXT were
|
|
// verified. Verify the rest.
|
|
packedDepthStencilOES = DeterminePackedDepthStencilSupport(textureCaps);
|
|
rgb8Rgba8OES = DetermineRGB8AndRGBA8TextureSupport(textureCaps);
|
|
readDepthNV = DetermineReadDepthSupport(textureCaps);
|
|
readStencilNV = DetermineReadStencilSupport(textureCaps);
|
|
depthBufferFloat2NV = DetermineDepthBufferFloat2Support(textureCaps);
|
|
textureFormatBGRA8888EXT = DetermineBGRA8TextureSupport(textureCaps);
|
|
readFormatBgraEXT = DetermineBGRAReadFormatSupport(textureCaps);
|
|
textureHalfFloatOES = DetermineHalfFloatTextureSupport(textureCaps);
|
|
textureHalfFloatLinearOES =
|
|
DetermineHalfFloatTextureFilteringSupport(textureCaps, textureHalfFloatOES);
|
|
textureFloatOES = DetermineFloatTextureSupport(textureCaps);
|
|
textureFloatLinearOES = DetermineFloatTextureFilteringSupport(textureCaps, textureFloatOES);
|
|
textureRgEXT = DetermineRGTextureSupport(textureCaps, textureHalfFloatOES, textureFloatOES);
|
|
colorBufferHalfFloatEXT =
|
|
textureHalfFloatOES && DetermineColorBufferHalfFloatSupport(textureCaps);
|
|
textureType2101010REVEXT = DetermineTextureFormat2101010Support(textureCaps);
|
|
textureCompressionDxt1EXT = DetermineDXT1TextureSupport(textureCaps);
|
|
textureCompressionDxt3ANGLE = DetermineDXT3TextureSupport(textureCaps);
|
|
textureCompressionDxt5ANGLE = DetermineDXT5TextureSupport(textureCaps);
|
|
textureCompressionS3tcSrgbEXT = DetermineS3TCsRGBTextureSupport(textureCaps);
|
|
textureCompressionAstcLdrKHR = DetermineASTCLDRTextureSupport(textureCaps);
|
|
textureCompressionAstcOES = DetermineASTCOESTExtureSupport(textureCaps);
|
|
compressedETC1RGB8TextureOES = DetermineETC1RGB8TextureSupport(textureCaps);
|
|
compressedETC2RGB8TextureOES = DetermineETC2RGB8TextureSupport(textureCaps);
|
|
compressedETC2SRGB8TextureOES = DetermineETC2sRGB8TextureSupport(textureCaps);
|
|
compressedETC2PunchthroughARGBA8TextureOES =
|
|
DetermineETC2PunchthroughARGB8TextureSupport(textureCaps);
|
|
compressedETC2PunchthroughASRGB8AlphaTextureOES =
|
|
DetermineETC2PunchthroughAsRGB8AlphaTextureSupport(textureCaps);
|
|
compressedETC2RGBA8TextureOES = DetermineETC2RGBA8TextureSupport(textureCaps);
|
|
compressedETC2SRGB8Alpha8TextureOES = DetermineETC2sRGB8Alpha8TextureSupport(textureCaps);
|
|
compressedEACR11UnsignedTextureOES = DetermineEACR11UnsignedTextureSupport(textureCaps);
|
|
compressedEACR11SignedTextureOES = DetermineEACR11SignedTextureSupport(textureCaps);
|
|
compressedEACRG11UnsignedTextureOES = DetermineEACRG11UnsignedTextureSupport(textureCaps);
|
|
compressedEACRG11SignedTextureOES = DetermineEACRG11SignedTextureSupport(textureCaps);
|
|
sRGBEXT = DetermineSRGBTextureSupport(textureCaps);
|
|
textureSRGBR8EXT = DetermineSRGBR8TextureSupport(textureCaps);
|
|
textureSRGBRG8EXT = DetermineSRGBRG8TextureSupport(textureCaps);
|
|
depthTextureANGLE = DetermineDepthTextureANGLESupport(textureCaps);
|
|
depthTextureOES = DetermineDepthTextureOESSupport(textureCaps);
|
|
depth24OES = DetermineDepth24OESSupport(textureCaps);
|
|
depth32OES = DetermineDepth32Support(textureCaps);
|
|
colorBufferFloatRgbCHROMIUM = DetermineColorBufferFloatRGBSupport(textureCaps);
|
|
colorBufferFloatRgbaCHROMIUM = DetermineColorBufferFloatRGBASupport(textureCaps);
|
|
colorBufferFloatEXT = DetermineColorBufferFloatSupport(textureCaps);
|
|
floatBlendEXT = DetermineFloatBlendSupport(textureCaps);
|
|
textureNorm16EXT = DetermineTextureNorm16Support(textureCaps);
|
|
textureCompressionRgtcEXT = DetermineRGTCTextureSupport(textureCaps);
|
|
textureCompressionBptcEXT = DetermineBPTCTextureSupport(textureCaps);
|
|
textureCompressionPvrtcIMG = DeterminePVRTCTextureSupport(textureCaps);
|
|
pvrtcSRGBEXT = DeterminePVRTCsRGBTextureSupport(textureCaps);
|
|
textureStencil8OES = DetermineStencilIndex8Support(textureCaps);
|
|
}
|
|
|
|
TypePrecision::TypePrecision() = default;
|
|
|
|
TypePrecision::TypePrecision(const TypePrecision &other) = default;
|
|
|
|
TypePrecision &TypePrecision::operator=(const TypePrecision &other) = default;
|
|
|
|
void TypePrecision::setIEEEFloat()
|
|
{
|
|
range = {{127, 127}};
|
|
precision = 23;
|
|
}
|
|
|
|
void TypePrecision::setIEEEHalfFloat()
|
|
{
|
|
range = {{15, 15}};
|
|
precision = 10;
|
|
}
|
|
|
|
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() = default;
|
|
Caps::Caps(const Caps &other) = default;
|
|
Caps::~Caps() = default;
|
|
Caps &Caps::operator=(const Caps &other) = default;
|
|
|
|
Caps GenerateMinimumCaps(const Version &clientVersion, const Extensions &extensions)
|
|
{
|
|
Caps caps;
|
|
|
|
// GLES1 emulation (Minimums taken from Table 6.20 / 6.22 (ES 1.1 spec))
|
|
if (clientVersion < Version(2, 0))
|
|
{
|
|
caps.maxMultitextureUnits = 2;
|
|
caps.maxLights = 8;
|
|
caps.maxClipPlanes = 1;
|
|
|
|
caps.maxModelviewMatrixStackDepth = 16;
|
|
caps.maxProjectionMatrixStackDepth = 2;
|
|
caps.maxTextureMatrixStackDepth = 2;
|
|
|
|
caps.minSmoothPointSize = 1.0f;
|
|
caps.maxSmoothPointSize = 1.0f;
|
|
}
|
|
|
|
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.maxShaderTextureImageUnits[ShaderType::Fragment] = 8;
|
|
caps.maxFragmentUniformVectors = 16;
|
|
caps.maxRenderbufferSize = 1;
|
|
|
|
// Table 3.35
|
|
caps.maxSamples = 4;
|
|
}
|
|
|
|
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.maxShaderUniformComponents[ShaderType::Vertex] = 1024;
|
|
caps.maxVertexUniformVectors = 256;
|
|
caps.maxShaderUniformBlocks[ShaderType::Vertex] = limits::kMinimumShaderUniformBlocks;
|
|
caps.maxVertexOutputComponents = limits::kMinimumVertexOutputComponents;
|
|
caps.maxShaderTextureImageUnits[ShaderType::Vertex] = 16;
|
|
|
|
// Table 6.32
|
|
caps.maxShaderUniformComponents[ShaderType::Fragment] = 896;
|
|
caps.maxFragmentUniformVectors = 224;
|
|
caps.maxShaderUniformBlocks[ShaderType::Fragment] = limits::kMinimumShaderUniformBlocks;
|
|
caps.maxFragmentInputComponents = 60;
|
|
caps.maxShaderTextureImageUnits[ShaderType::Fragment] = 16;
|
|
caps.minProgramTexelOffset = -8;
|
|
caps.maxProgramTexelOffset = 7;
|
|
|
|
// Table 6.33
|
|
caps.maxUniformBufferBindings = 24;
|
|
caps.maxUniformBlockSize = 16384;
|
|
caps.uniformBufferOffsetAlignment = 256;
|
|
caps.maxCombinedUniformBlocks = 24;
|
|
caps.maxVaryingComponents = 60;
|
|
caps.maxVaryingVectors = 15;
|
|
caps.maxCombinedTextureImageUnits = 32;
|
|
|
|
// Table 6.34
|
|
caps.maxTransformFeedbackInterleavedComponents = 64;
|
|
caps.maxTransformFeedbackSeparateAttributes = 4;
|
|
caps.maxTransformFeedbackSeparateComponents = 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.maxShaderAtomicCounterBuffers[ShaderType::Vertex] = 0;
|
|
caps.maxShaderAtomicCounters[ShaderType::Vertex] = 0;
|
|
caps.maxShaderImageUniforms[ShaderType::Vertex] = 0;
|
|
caps.maxShaderStorageBlocks[ShaderType::Vertex] = 0;
|
|
|
|
// Table 20.44
|
|
caps.maxShaderUniformComponents[ShaderType::Fragment] = 1024;
|
|
caps.maxFragmentUniformVectors = 256;
|
|
caps.maxShaderAtomicCounterBuffers[ShaderType::Fragment] = 0;
|
|
caps.maxShaderAtomicCounters[ShaderType::Fragment] = 0;
|
|
caps.maxShaderImageUniforms[ShaderType::Fragment] = 0;
|
|
caps.maxShaderStorageBlocks[ShaderType::Fragment] = 0;
|
|
caps.minProgramTextureGatherOffset = 0;
|
|
caps.maxProgramTextureGatherOffset = 0;
|
|
|
|
// Table 20.45
|
|
caps.maxComputeWorkGroupCount = {{65535, 65535, 65535}};
|
|
caps.maxComputeWorkGroupSize = {{128, 128, 64}};
|
|
caps.maxComputeWorkGroupInvocations = 12;
|
|
caps.maxShaderUniformBlocks[ShaderType::Compute] = limits::kMinimumShaderUniformBlocks;
|
|
caps.maxShaderTextureImageUnits[ShaderType::Compute] = 16;
|
|
caps.maxComputeSharedMemorySize = 16384;
|
|
caps.maxShaderUniformComponents[ShaderType::Compute] = 1024;
|
|
caps.maxShaderAtomicCounterBuffers[ShaderType::Compute] = 1;
|
|
caps.maxShaderAtomicCounters[ShaderType::Compute] = 8;
|
|
caps.maxShaderImageUniforms[ShaderType::Compute] = 4;
|
|
caps.maxShaderStorageBlocks[ShaderType::Compute] = 4;
|
|
|
|
// Table 20.46
|
|
caps.maxUniformBufferBindings = 36;
|
|
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;
|
|
}
|
|
|
|
if (extensions.textureRectangleANGLE)
|
|
{
|
|
caps.maxRectangleTextureSize = 64;
|
|
}
|
|
|
|
if (extensions.geometryShaderAny())
|
|
{
|
|
// Table 20.40 (GL_EXT_geometry_shader)
|
|
caps.maxFramebufferLayers = 256;
|
|
caps.layerProvokingVertex = GL_LAST_VERTEX_CONVENTION_EXT;
|
|
|
|
// Table 20.43gs (GL_EXT_geometry_shader)
|
|
caps.maxShaderUniformComponents[ShaderType::Geometry] = 1024;
|
|
caps.maxShaderUniformBlocks[ShaderType::Geometry] = limits::kMinimumShaderUniformBlocks;
|
|
caps.maxGeometryInputComponents = 64;
|
|
caps.maxGeometryOutputComponents = 64;
|
|
caps.maxGeometryOutputVertices = 256;
|
|
caps.maxGeometryTotalOutputComponents = 1024;
|
|
caps.maxShaderTextureImageUnits[ShaderType::Geometry] = 16;
|
|
caps.maxShaderAtomicCounterBuffers[ShaderType::Geometry] = 0;
|
|
caps.maxShaderAtomicCounters[ShaderType::Geometry] = 0;
|
|
caps.maxShaderStorageBlocks[ShaderType::Geometry] = 0;
|
|
caps.maxGeometryShaderInvocations = 32;
|
|
|
|
// Table 20.46 (GL_EXT_geometry_shader)
|
|
caps.maxShaderImageUniforms[ShaderType::Geometry] = 0;
|
|
|
|
// Table 20.46 (GL_EXT_geometry_shader)
|
|
caps.maxUniformBufferBindings = 48;
|
|
caps.maxCombinedUniformBlocks = 36;
|
|
caps.maxCombinedTextureImageUnits = 64;
|
|
}
|
|
|
|
if (extensions.tessellationShaderEXT)
|
|
{
|
|
// Table 20.43 "Implementation Dependent Tessellation Shader Limits"
|
|
caps.maxTessControlInputComponents = 64;
|
|
caps.maxTessControlOutputComponents = 64;
|
|
caps.maxShaderTextureImageUnits[ShaderType::TessControl] = 16;
|
|
caps.maxShaderUniformComponents[ShaderType::TessControl] = 1024;
|
|
caps.maxTessControlTotalOutputComponents = 2048;
|
|
caps.maxShaderImageUniforms[ShaderType::TessControl] = 0;
|
|
caps.maxShaderAtomicCounters[ShaderType::TessControl] = 0;
|
|
caps.maxShaderAtomicCounterBuffers[ShaderType::TessControl] = 0;
|
|
|
|
caps.maxTessPatchComponents = 120;
|
|
caps.maxPatchVertices = 32;
|
|
caps.maxTessGenLevel = 64;
|
|
|
|
caps.maxTessEvaluationInputComponents = 64;
|
|
caps.maxTessEvaluationOutputComponents = 64;
|
|
caps.maxShaderTextureImageUnits[ShaderType::TessEvaluation] = 16;
|
|
caps.maxShaderUniformComponents[ShaderType::TessEvaluation] = 1024;
|
|
caps.maxShaderImageUniforms[ShaderType::TessEvaluation] = 0;
|
|
caps.maxShaderAtomicCounters[ShaderType::TessEvaluation] = 0;
|
|
caps.maxShaderAtomicCounterBuffers[ShaderType::TessEvaluation] = 0;
|
|
|
|
// Table 20.46 "Implementation Dependent Aggregate Shader Limits"
|
|
caps.maxUniformBufferBindings = 72;
|
|
caps.maxCombinedUniformBlocks = 60;
|
|
caps.maxCombinedTextureImageUnits = 96;
|
|
}
|
|
|
|
for (ShaderType shaderType : AllShaderTypes())
|
|
{
|
|
caps.maxCombinedShaderUniformComponents[shaderType] =
|
|
caps.maxShaderUniformBlocks[shaderType] *
|
|
static_cast<GLuint>(caps.maxUniformBlockSize / 4) +
|
|
caps.maxShaderUniformComponents[shaderType];
|
|
}
|
|
|
|
return caps;
|
|
}
|
|
} // namespace gl
|
|
|
|
namespace egl
|
|
{
|
|
|
|
Caps::Caps() = default;
|
|
|
|
DisplayExtensions::DisplayExtensions() = default;
|
|
|
|
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_ANGLE_windows_ui_composition", windowsUIComposition, &extensionStrings);
|
|
InsertExtensionString("EGL_NV_post_sub_buffer", postSubBuffer, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_create_context", createContext, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_image", image, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_image_base", imageBase, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_image_pixmap", imagePixmap, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_image_gl_colorspace", imageGlColorspace, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_gl_colorspace", glColorspace, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_gl_colorspace_scrgb", glColorspaceScrgb, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_gl_colorspace_scrgb_linear", glColorspaceScrgbLinear, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_gl_colorspace_display_p3", glColorspaceDisplayP3, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_gl_colorspace_display_p3_linear", glColorspaceDisplayP3Linear, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_gl_colorspace_display_p3_passthrough", glColorspaceDisplayP3Passthrough, &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_KHR_fence_sync", fenceSync, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_wait_sync", waitSync, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_stream_producer_d3d_texture", streamProducerD3DTexture, &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", syncControlCHROMIUM, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_sync_control_rate", syncControlRateANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_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_display_semaphore_share_group", displaySemaphoreShareGroup, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_create_context_client_arrays", createContextClientArrays, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_program_cache_control", programCacheControlANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_robust_resource_initialization", robustResourceInitializationANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_iosurface_client_buffer", iosurfaceClientBuffer, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_metal_texture_client_buffer", mtlTextureClientBuffer, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_create_context_extensions_enabled", createContextExtensionsEnabled, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_presentation_time", presentationTime, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_blob_cache", blobCache, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_framebuffer_target", framebufferTargetANDROID, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_image_native_buffer", imageNativeBuffer, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_get_frame_timestamps", getFrameTimestamps, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_recordable", recordable, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_power_preference", powerPreference, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_image_d3d11_texture", imageD3D11Texture, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_create_native_client_buffer", createNativeClientBufferANDROID, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_get_native_client_buffer", getNativeClientBufferANDROID, &extensionStrings);
|
|
InsertExtensionString("EGL_ANDROID_native_fence_sync", nativeFenceSyncANDROID, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_create_context_backwards_compatible", createContextBackwardsCompatible, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_no_config_context", noConfigContext, &extensionStrings);
|
|
InsertExtensionString("EGL_IMG_context_priority", contextPriority, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_create_context_no_error", createContextNoError, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_image_dma_buf_import", imageDmaBufImportEXT, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_image_dma_buf_import_modifiers", imageDmaBufImportModifiersEXT, &extensionStrings);
|
|
InsertExtensionString("EGL_NOK_texture_from_pixmap", textureFromPixmapNOK, &extensionStrings);
|
|
InsertExtensionString("EGL_NV_robustness_video_memory_purge", robustnessVideoMemoryPurgeNV, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_reusable_sync", reusableSyncKHR, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_external_context_and_surface", externalContextAndSurface, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_buffer_age", bufferAgeEXT, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_mutable_render_buffer", mutableRenderBufferKHR, &extensionStrings);
|
|
InsertExtensionString("EGL_EXT_protected_content", protectedContentEXT, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_create_surface_swap_interval", createSurfaceSwapIntervalANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_context_virtualization", contextVirtualizationANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_lock_surface3", lockSurface3KHR, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_vulkan_image", vulkanImageANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_metal_create_context_ownership_identity", metalCreateContextOwnershipIdentityANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_KHR_partial_update", partialUpdateKHR, &extensionStrings);
|
|
// clang-format on
|
|
|
|
return extensionStrings;
|
|
}
|
|
|
|
DeviceExtensions::DeviceExtensions() = default;
|
|
|
|
std::vector<std::string> DeviceExtensions::getStrings() const
|
|
{
|
|
std::vector<std::string> extensionStrings;
|
|
|
|
// clang-format off
|
|
// | Extension name | Supported flag | Output vector |
|
|
InsertExtensionString("EGL_ANGLE_device_d3d", deviceD3D, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_device_cgl", deviceCGL, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_device_eagl", deviceEAGL, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_device_metal", deviceMetal, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_device_vulkan", deviceVulkan, &extensionStrings);
|
|
|
|
// clang-format on
|
|
|
|
return extensionStrings;
|
|
}
|
|
|
|
ClientExtensions::ClientExtensions() = default;
|
|
ClientExtensions::ClientExtensions(const ClientExtensions &other) = default;
|
|
|
|
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_device_query", deviceQueryEXT, &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_d3d11on12", platformANGLED3D11ON12, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_platform_angle_device_type_egl_angle", platformANGLEDeviceTypeEGLANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_platform_angle_device_type_swiftshader", platformANGLEDeviceTypeSwiftShader, &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_platform_angle_metal", platformANGLEMetal, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_platform_device_context_volatile_eagl", platformANGLEDeviceContextVolatileEagl, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_platform_device_context_volatile_cgl", platformANGLEDeviceContextVolatileCgl, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_platform_angle_device_id", platformANGLEDeviceId, &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);
|
|
InsertExtensionString("EGL_KHR_debug", debug, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_feature_control", featureControlANGLE, &extensionStrings);
|
|
InsertExtensionString("EGL_ANGLE_display_power_preference", displayPowerPreferenceANGLE, &extensionStrings);
|
|
// clang-format on
|
|
|
|
return extensionStrings;
|
|
}
|
|
|
|
} // namespace egl
|