blob: e0268d038d31a33949a2541db600d0e9b7389c6e [file] [log] [blame]
//
// Copyright (c) 2002-2010 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.
//
// Config.cpp: Implements the egl::Config class, describing the format, type
// and size for an egl::Surface. Implements EGLConfig and related functionality.
// [EGL 1.5] section 3.4 page 19.
#include "libANGLE/Config.h"
#include "libANGLE/AttributeMap.h"
#include <algorithm>
#include <vector>
#include "angle_gl.h"
#include <EGL/eglext.h>
#include "common/debug.h"
namespace egl
{
Config::Config()
: renderTargetFormat(GL_NONE),
depthStencilFormat(GL_NONE),
bufferSize(0),
redSize(0),
greenSize(0),
blueSize(0),
luminanceSize(0),
alphaSize(0),
alphaMaskSize(0),
bindToTextureRGB(EGL_FALSE),
bindToTextureRGBA(EGL_FALSE),
colorBufferType(EGL_NONE),
configCaveat(EGL_NONE),
configID(0),
conformant(0),
depthSize(0),
level(0),
matchNativePixmap(EGL_FALSE),
maxPBufferWidth(0),
maxPBufferHeight(0),
maxPBufferPixels(0),
maxSwapInterval(0),
minSwapInterval(0),
nativeRenderable(EGL_FALSE),
nativeVisualID(0),
nativeVisualType(0),
renderableType(0),
sampleBuffers(0),
samples(0),
stencilSize(0),
surfaceType(0),
transparentType(EGL_NONE),
transparentRedValue(0),
transparentGreenValue(0),
transparentBlueValue(0),
optimalOrientation(0),
colorComponentType(EGL_COLOR_COMPONENT_TYPE_FIXED_EXT)
{
}
EGLint ConfigSet::add(const Config &config)
{
// Set the config's ID to a small number that starts at 1 ([EGL 1.5] section 3.4)
EGLint id = static_cast<EGLint>(mConfigs.size()) + 1;
Config copyConfig(config);
copyConfig.configID = id;
mConfigs.insert(std::make_pair(id, copyConfig));
return id;
}
const Config &ConfigSet::get(EGLint id) const
{
ASSERT(mConfigs.find(id) != mConfigs.end());
return mConfigs.find(id)->second;
}
void ConfigSet::clear()
{
mConfigs.clear();
}
size_t ConfigSet::size() const
{
return mConfigs.size();
}
bool ConfigSet::contains(const Config *config) const
{
for (auto i = mConfigs.begin(); i != mConfigs.end(); i++)
{
const Config &item = i->second;
if (config == &item)
{
return true;
}
}
return false;
}
// Function object used by STL sorting routines for ordering Configs according to [EGL 1.5] section 3.4.1.2 page 28.
class ConfigSorter
{
public:
explicit ConfigSorter(const AttributeMap &attributeMap)
: mWantRed(false),
mWantGreen(false),
mWantBlue(false),
mWantAlpha(false),
mWantLuminance(false)
{
scanForWantedComponents(attributeMap);
}
bool operator()(const Config *x, const Config *y) const
{
return (*this)(*x, *y);
}
bool operator()(const Config &x, const Config &y) const
{
#define SORT(attribute) \
if (x.attribute != y.attribute) \
{ \
return x.attribute < y.attribute; \
}
static_assert(EGL_NONE < EGL_SLOW_CONFIG && EGL_SLOW_CONFIG < EGL_NON_CONFORMANT_CONFIG, "Unexpected EGL enum value.");
SORT(configCaveat);
static_assert(EGL_COLOR_COMPONENT_TYPE_FIXED_EXT < EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
"Unexpected order of EGL enums.");
SORT(colorComponentType);
static_assert(EGL_RGB_BUFFER < EGL_LUMINANCE_BUFFER, "Unexpected EGL enum value.");
SORT(colorBufferType);
// By larger total number of color bits, only considering those that are requested to be > 0.
EGLint xComponentsSize = wantedComponentsSize(x);
EGLint yComponentsSize = wantedComponentsSize(y);
if (xComponentsSize != yComponentsSize)
{
return xComponentsSize > yComponentsSize;
}
SORT(bufferSize);
SORT(sampleBuffers);
SORT(samples);
SORT(depthSize);
SORT(stencilSize);
SORT(alphaMaskSize);
SORT(nativeVisualType);
SORT(configID);
#undef SORT
return false;
}
private:
void scanForWantedComponents(const AttributeMap &attributeMap)
{
// [EGL 1.5] section 3.4.1.2 page 30
// Sorting rule #3: by larger total number of color bits, not considering
// components that are 0 or don't-care.
for (auto attribIter = attributeMap.begin(); attribIter != attributeMap.end(); attribIter++)
{
EGLAttrib attributeKey = attribIter->first;
EGLAttrib attributeValue = attribIter->second;
if (attributeKey != 0 && attributeValue != EGL_DONT_CARE)
{
switch (attributeKey)
{
case EGL_RED_SIZE: mWantRed = true; break;
case EGL_GREEN_SIZE: mWantGreen = true; break;
case EGL_BLUE_SIZE: mWantBlue = true; break;
case EGL_ALPHA_SIZE: mWantAlpha = true; break;
case EGL_LUMINANCE_SIZE: mWantLuminance = true; break;
}
}
}
}
EGLint wantedComponentsSize(const Config &config) const
{
EGLint total = 0;
if (mWantRed) total += config.redSize;
if (mWantGreen) total += config.greenSize;
if (mWantBlue) total += config.blueSize;
if (mWantAlpha) total += config.alphaSize;
if (mWantLuminance) total += config.luminanceSize;
return total;
}
bool mWantRed;
bool mWantGreen;
bool mWantBlue;
bool mWantAlpha;
bool mWantLuminance;
};
std::vector<const Config*> ConfigSet::filter(const AttributeMap &attributeMap) const
{
std::vector<const Config*> result;
result.reserve(mConfigs.size());
for (auto configIter = mConfigs.begin(); configIter != mConfigs.end(); configIter++)
{
const Config &config = configIter->second;
bool match = true;
for (auto attribIter = attributeMap.begin(); attribIter != attributeMap.end(); attribIter++)
{
EGLAttrib attributeKey = attribIter->first;
EGLAttrib attributeValue = attribIter->second;
switch (attributeKey)
{
case EGL_BUFFER_SIZE: match = config.bufferSize >= attributeValue; break;
case EGL_ALPHA_SIZE: match = config.alphaSize >= attributeValue; break;
case EGL_BLUE_SIZE: match = config.blueSize >= attributeValue; break;
case EGL_GREEN_SIZE: match = config.greenSize >= attributeValue; break;
case EGL_RED_SIZE: match = config.redSize >= attributeValue; break;
case EGL_DEPTH_SIZE: match = config.depthSize >= attributeValue; break;
case EGL_STENCIL_SIZE: match = config.stencilSize >= attributeValue; break;
case EGL_CONFIG_CAVEAT: match = config.configCaveat == (EGLenum)attributeValue; break;
case EGL_CONFIG_ID: match = config.configID == attributeValue; break;
case EGL_LEVEL: match = config.level >= attributeValue; break;
case EGL_NATIVE_RENDERABLE: match = config.nativeRenderable == (EGLBoolean)attributeValue; break;
case EGL_NATIVE_VISUAL_TYPE: match = config.nativeVisualType == attributeValue; break;
case EGL_SAMPLES: match = config.samples >= attributeValue; break;
case EGL_SAMPLE_BUFFERS: match = config.sampleBuffers >= attributeValue; break;
case EGL_SURFACE_TYPE: match = (config.surfaceType & attributeValue) == attributeValue; break;
case EGL_TRANSPARENT_TYPE: match = config.transparentType == (EGLenum)attributeValue; break;
case EGL_TRANSPARENT_BLUE_VALUE: match = config.transparentBlueValue == attributeValue; break;
case EGL_TRANSPARENT_GREEN_VALUE: match = config.transparentGreenValue == attributeValue; break;
case EGL_TRANSPARENT_RED_VALUE: match = config.transparentRedValue == attributeValue; break;
case EGL_BIND_TO_TEXTURE_RGB: match = config.bindToTextureRGB == (EGLBoolean)attributeValue; break;
case EGL_BIND_TO_TEXTURE_RGBA: match = config.bindToTextureRGBA == (EGLBoolean)attributeValue; break;
case EGL_MIN_SWAP_INTERVAL: match = config.minSwapInterval == attributeValue; break;
case EGL_MAX_SWAP_INTERVAL: match = config.maxSwapInterval == attributeValue; break;
case EGL_LUMINANCE_SIZE: match = config.luminanceSize >= attributeValue; break;
case EGL_ALPHA_MASK_SIZE: match = config.alphaMaskSize >= attributeValue; break;
case EGL_COLOR_BUFFER_TYPE: match = config.colorBufferType == (EGLenum)attributeValue; break;
case EGL_RENDERABLE_TYPE: match = (config.renderableType & attributeValue) == attributeValue; break;
case EGL_MATCH_NATIVE_PIXMAP: match = false; UNIMPLEMENTED(); break;
case EGL_CONFORMANT: match = (config.conformant & attributeValue) == attributeValue; break;
case EGL_MAX_PBUFFER_WIDTH: match = config.maxPBufferWidth >= attributeValue; break;
case EGL_MAX_PBUFFER_HEIGHT: match = config.maxPBufferHeight >= attributeValue; break;
case EGL_MAX_PBUFFER_PIXELS: match = config.maxPBufferPixels >= attributeValue; break;
case EGL_OPTIMAL_SURFACE_ORIENTATION_ANGLE:
match = config.optimalOrientation == attributeValue;
break;
case EGL_COLOR_COMPONENT_TYPE_EXT:
match = config.colorComponentType == static_cast<EGLenum>(attributeValue);
break;
default: UNREACHABLE();
}
if (!match)
{
break;
}
}
if (match)
{
result.push_back(&config);
}
}
// Sort the result
std::sort(result.begin(), result.end(), ConfigSorter(attributeMap));
return result;
}
}