chromium/third_party/angle/src/libANGLE/Caps.cpp

//
// 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)
{ … }

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
{ … }

GLuint TextureCaps::getNearestSamples(GLuint requestedSamples) const
{ … }

TextureCaps GenerateMinimumTextureCaps(GLenum sizedInternalFormat,
                                       const Version &clientVersion,
                                       const Extensions &extensions)
{ … }

TextureCapsMap::TextureCapsMap() { … }

TextureCapsMap::~TextureCapsMap() { … }

void TextureCapsMap::insert(GLenum internalFormat, const TextureCaps &caps)
{ … }

void TextureCapsMap::clear()
{ … }

const TextureCaps &TextureCapsMap::get(GLenum internalFormat) const
{ … }

const TextureCaps &TextureCapsMap::get(angle::FormatID formatID) const
{ … }

TextureCaps &TextureCapsMap::get(angle::FormatID formatID)
{ … }

void TextureCapsMap::set(angle::FormatID formatID, const TextureCaps &caps)
{ … }

void InitMinimumTextureCapsMap(const Version &clientVersion,
                               const Extensions &extensions,
                               TextureCapsMap *capsMap)
{ … }

Extensions::Extensions() = default;

Extensions::Extensions(const Extensions &other) = default;

Extensions &Extensions::operator=(const Extensions &other) = default;

std::vector<std::string> Extensions::getStrings() const
{ … }

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)
{ … }

template <size_t N>
static bool GetFormatSupport(const TextureCapsMap &textureCaps,
                             const GLenum (&requiredFormats)[N],
                             bool requiresTexturing,
                             bool requiresFiltering,
                             bool requiresAttachingTexture,
                             bool requiresRenderbufferSupport,
                             bool requiresBlending)
{ … }

// Check for GL_OES_packed_depth_stencil support
static bool DeterminePackedDepthStencilSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_NV_read_depth support
static bool DetermineReadDepthSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_NV_read_stencil support
static bool DetermineReadStencilSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_NV_depth_buffer_float2 support
static bool DetermineDepthBufferFloat2Support(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_OES_rgb8_rgba8 support
static bool DetermineRGB8AndRGBA8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_EXT_texture_format_BGRA8888 support
static bool DetermineBGRA8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_EXT_read_format_bgra support
static bool DetermineBGRAReadFormatSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_OES_color_buffer_half_float support
static bool DetermineColorBufferHalfFloatSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_OES_texture_half_float support
static bool DetermineHalfFloatTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_OES_texture_half_float_linear support
static bool DetermineHalfFloatTextureFilteringSupport(const TextureCapsMap &textureCaps,
                                                      bool checkLegacyFormats)
{ … }

// Checks for GL_OES_texture_float support
static bool DetermineFloatTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_OES_texture_float_linear support
static bool DetermineFloatTextureFilteringSupport(const TextureCapsMap &textureCaps,
                                                  bool checkLegacyFormats)
{ … }

// Checks for GL_EXT_texture_rg support
static bool DetermineRGTextureSupport(const TextureCapsMap &textureCaps,
                                      bool checkHalfFloatFormats,
                                      bool checkFloatFormats)
{ … }

static bool DetermineTextureFormat2101010Support(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_texture_compression_dxt1 support
static bool DetermineDXT1TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_ANGLE_texture_compression_dxt3 support
static bool DetermineDXT3TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_ANGLE_texture_compression_dxt5 support
static bool DetermineDXT5TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_texture_compression_s3tc_srgb support
static bool DetermineS3TCsRGBTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_KHR_texture_compression_astc_ldr support
static bool DetermineASTCLDRTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_OES_texture_compression_astc support
static bool DetermineASTCOESTExtureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_ETC1_RGB8_OES support
static bool DetermineETC1RGB8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_ETC2_RGB8_texture support
static bool DetermineETC2RGB8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_ETC2_sRGB8_texture support
static bool DetermineETC2sRGB8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_ETC2_punchthroughA_RGBA8_texture support
static bool DetermineETC2PunchthroughARGB8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_ETC2_punchthroughA_sRGB8_alpha_texture support
static bool DetermineETC2PunchthroughAsRGB8AlphaTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_ETC2_RGBA8_texture support
static bool DetermineETC2RGBA8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_ETC2_sRGB8_alpha8_texture support
static bool DetermineETC2sRGB8Alpha8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_EAC_R11_unsigned_texture support
static bool DetermineEACR11UnsignedTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_EAC_R11_signed_texture support
static bool DetermineEACR11SignedTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_EAC_RG11_unsigned_texture support
static bool DetermineEACRG11UnsignedTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for OES_compressed_EAC_RG11_signed_texture support
static bool DetermineEACRG11SignedTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_sRGB support
static bool DetermineSRGBTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_texture_sRGB_R8 support
static bool DetermineSRGBR8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_texture_sRGB_RG8 support
static bool DetermineSRGBRG8TextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_ANGLE_depth_texture support
static bool DetermineDepthTextureANGLESupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_OES_depth_texture support
static bool DetermineDepthTextureOESSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_OES_depth24
static bool DetermineDepth24OESSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_OES_depth32 support
static bool DetermineDepth32Support(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_CHROMIUM_color_buffer_float_rgb support
static bool DetermineColorBufferFloatRGBSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_CHROMIUM_color_buffer_float_rgba support
static bool DetermineColorBufferFloatRGBASupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_color_buffer_float support
static bool DetermineColorBufferFloatSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_float_blend support
static bool DetermineFloatBlendSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_texture_norm16 support
static bool DetermineTextureNorm16Support(const TextureCapsMap &textureCaps)
{ … }

// Check for EXT_texture_compression_rgtc support
static bool DetermineRGTCTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for EXT_texture_compression_bptc support
static bool DetermineBPTCTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_IMG_texture_compression_pvrtc support
static bool DeterminePVRTCTextureSupport(const TextureCapsMap &textureCaps)
{ … }

// Check for GL_EXT_pvrtc_sRGB support
static bool DeterminePVRTCsRGBTextureSupport(const TextureCapsMap &textureCaps)
{ … }

bool DetermineCompressedTextureETCSupport(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_OES_texture_stencil8 support
static bool DetermineStencilIndex8Support(const TextureCapsMap &textureCaps)
{ … }

// Checks for GL_QCOM_render_shared_exponent support
static bool DetermineRenderSharedExponentSupport(const TextureCapsMap &textureCaps)
{ … }

static bool DetermineRenderSnormSupport(const TextureCapsMap &textureCaps, bool textureNorm16EXT)
{ … }

void Extensions::setTextureExtensionSupport(const TextureCapsMap &textureCaps)
{ … }

TypePrecision::TypePrecision() = default;

TypePrecision::TypePrecision(const TypePrecision &other) = default;

TypePrecision &TypePrecision::operator=(const TypePrecision &other) = default;

void TypePrecision::setIEEEFloat()
{ … }

void TypePrecision::setIEEEHalfFloat()
{ … }

void TypePrecision::setTwosComplementInt(unsigned int bits)
{ … }

void TypePrecision::setSimulatedFloat(unsigned int r, unsigned int p)
{ … }

void TypePrecision::setSimulatedInt(unsigned int r)
{ … }

void TypePrecision::get(GLint *returnRange, GLint *returnPrecision) const
{ … }

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)
{ … }
}  // namespace gl

namespace egl
{

Caps::Caps() = default;

DisplayExtensions::DisplayExtensions() = default;

std::vector<std::string> DisplayExtensions::getStrings() const
{ … }

DeviceExtensions::DeviceExtensions() = default;

std::vector<std::string> DeviceExtensions::getStrings() const
{ … }

ClientExtensions::ClientExtensions()                              = default;
ClientExtensions::ClientExtensions(const ClientExtensions &other) = default;

std::vector<std::string> ClientExtensions::getStrings() const
{ … }

}  // namespace egl