configs.hpp

Go to the documentation of this file.

#pragma once
#ifndef EGLPLUS_CONFIGS_1303292057_HPP
#define EGLPLUS_CONFIGS_1303292057_HPP

#include <eglplus/bitfield.hpp>
#include <eglplus/config_attrib.hpp>
#include <eglplus/color_buffer_type.hpp>
#include <eglplus/transparent_type.hpp>
#include <eglplus/config_caveat.hpp>
#include <eglplus/renderable_type_bit.hpp>
#include <eglplus/surface_type_bit.hpp>
#include <eglplus/attrib_list.hpp>
#include <eglplus/display.hpp>

#include <cassert>

namespace eglplus {

class Config;
::EGLConfig GetEGLHandle(const Config&);

class Config
{
private:
    Display _display;
    ::EGLConfig _handle;

    friend ::EGLConfig GetEGLHandle(const Config&);
public:
    Config(const Display& display, ::EGLConfig handle)
     : _display(display)
     , _handle(handle)
    { }


    EGLint GetAttrib(ConfigAttrib attrib) const
    {
        EGLint result = 0;
        EGLPLUS_EGLFUNC(GetConfigAttrib)(
            GetEGLHandle(_display),
            this->_handle,
            EGLint(EGLenum(attrib)),
            &result
        );
        EGLPLUS_VERIFY_SIMPLE(GetConfigAttrib);
        return result;
    }


    EGLint ConfigId(void) const
    {
        return GetAttrib(ConfigAttrib::ConfigId);
    }


    EGLint Id(void) const
    {
        return ConfigId();
    }


    EGLint BufferSize(void) const
    {
        return GetAttrib(ConfigAttrib::BufferSize);
    }


    EGLint RedSize(void) const
    {
        return GetAttrib(ConfigAttrib::RedSize);
    }


    EGLint GreenSize(void) const
    {
        return GetAttrib(ConfigAttrib::GreenSize);
    }


    EGLint BlueSize(void) const
    {
        return GetAttrib(ConfigAttrib::BlueSize);
    }


    EGLint LuminanceSize(void) const
    {
        return GetAttrib(ConfigAttrib::LuminanceSize);
    }


    EGLint AlphaSize(void) const
    {
        return GetAttrib(ConfigAttrib::AlphaSize);
    }


    EGLint DepthSize(void) const
    {
        return GetAttrib(ConfigAttrib::DepthSize);
    }


    EGLint StencilSize(void) const
    {
        return GetAttrib(ConfigAttrib::StencilSize);
    }


    EGLint MaxPbufferWidth(void) const
    {
        return GetAttrib(ConfigAttrib::MaxPbufferWidth);
    }


    EGLint MaxPbufferHeight(void) const
    {
        return GetAttrib(ConfigAttrib::MaxPbufferHeight);
    }


    EGLint MaxPbufferPixels(void) const
    {
        return GetAttrib(ConfigAttrib::MaxPbufferPixels);
    }


    EGLint MinSwapInterval(void) const
    {
        return GetAttrib(ConfigAttrib::MinSwapInterval);
    }


    EGLint MaxSwapInterval(void) const
    {
        return GetAttrib(ConfigAttrib::MaxSwapInterval);
    }


    EGLint NativeRenderable(void) const
    {
        return GetAttrib(ConfigAttrib::NativeRenderable);
    }


    eglplus::ConfigCaveat ConfigCaveat(void) const
    {
        return eglplus::ConfigCaveat(
            EGLenum(GetAttrib(ConfigAttrib::ConfigCaveat))
        );
    }


    eglplus::ConfigCaveat Caveat(void) const
    {
        return this->ConfigCaveat();
    }


    eglplus::ColorBufferType ColorBufferType(void) const
    {
        return eglplus::ColorBufferType(
            EGLenum(GetAttrib(ConfigAttrib::ColorBufferType))
        );
    }


    eglplus::TransparentType TransparentType(void) const
    {
        return eglplus::TransparentType(
            EGLenum(GetAttrib(ConfigAttrib::TransparentType))
        );
    }


    Bitfield<eglplus::RenderableTypeBit> RenderableTypes(void) const
    {
        return Bitfield<eglplus::RenderableTypeBit>(
            EGLenum(GetAttrib(ConfigAttrib::RenderableType))
        );
    }


    bool HasRenderableType(eglplus::RenderableTypeBit type) const
    {
        EGLenum a = GetAttrib(ConfigAttrib::RenderableType);
        EGLenum b = EGLenum(type);
        return (a & b) == b;
    }


    Bitfield<eglplus::SurfaceTypeBit> SurfaceTypes(void) const
    {
        return Bitfield<eglplus::SurfaceTypeBit>(
            EGLenum(GetAttrib(ConfigAttrib::SurfaceType))
        );
    }


    bool HasSurfaceType(eglplus::SurfaceTypeBit type) const
    {
        EGLenum a = GetAttrib(ConfigAttrib::SurfaceType);
        EGLenum b = EGLenum(type);
        return (a & b) == b;
    }


    Bitfield<eglplus::RenderableTypeBit> Conformant(void) const
    {
        return Bitfield<eglplus::RenderableTypeBit>(
            GetAttrib(ConfigAttrib::Conformant)
        );
    }


    bool IsConformantTo(eglplus::RenderableTypeBit type) const
    {
        EGLenum a = GetAttrib(ConfigAttrib::Conformant);
        EGLenum b = EGLenum(type);
        return (a & b) == b;
    }
};

inline ::EGLConfig GetEGLHandle(const Config& config)
{
    return config._handle;
}

struct ConfigValueTypeToConfigAttrib
{
    static ColorBufferType
    ValueType(std::integral_constant<int, 0>);
    ConfigAttrib operator()(ColorBufferType) const
    {
        return ConfigAttrib::ColorBufferType;
    }

    static ConfigCaveat
    ValueType(std::integral_constant<int, 1>);
    ConfigAttrib operator()(ConfigCaveat) const
    {
        return ConfigAttrib::ConfigCaveat;
    }

    static RenderableTypeBit
    ValueType(std::integral_constant<int, 2>);
    ConfigAttrib operator()(RenderableTypeBit) const
    {
        return ConfigAttrib::RenderableType;
    }

    static SurfaceTypeBit
    ValueType(std::integral_constant<int, 3>);
    ConfigAttrib operator()(SurfaceTypeBit) const
    {
        return ConfigAttrib::SurfaceType;
    }

    static TransparentType
    ValueType(std::integral_constant<int, 4>);
    ConfigAttrib operator()(TransparentType) const
    {
        return ConfigAttrib::TransparentType;
    }

    static std::integral_constant<int, 4> MaxValueType(void);
};

typedef AttributeList<
    ConfigAttrib,
    ConfigValueTypeToConfigAttrib,
    AttributeListTraits
> ConfigAttribs;

typedef FinishedAttributeList<
    ConfigAttrib,
    AttributeListTraits
> FinishedConfigAttribs;

class Configs
{
private:
    Display _display;
    std::vector<EGLConfig> _configs;

    struct _config_range_conv
    {
        Display _display;

        _config_range_conv(const Display& display)
         : _display(display)
        { }

        Config operator()(EGLConfig handle) const
        {
            return Config(_display, handle);
        }
    };

    void _get_all(void);
    void _choose(const FinishedConfigAttribs& attribs);
public:
    Configs(const Display& display)
     : _display(display)
    {
        _get_all();
    }

    Configs(const Display& display, const FinishedConfigAttribs& attribs)
     : _display(display)
    {
        _choose(attribs);
    }

    typedef aux::ConvIterRange<
        std::vector<EGLConfig>::const_iterator,
        Config,
        _config_range_conv
    > ConfigRange;

    ConfigRange All(void) const
    {
        return ConfigRange(
            _config_range_conv(_display),
            _configs.begin(),
            _configs.end()
        );
    }

    bool Empty(void) const
    {
        return _configs.empty();
    }


    Config First(void) const
    {
        assert(!Empty());
        return Config(_display, _configs.front());
    }
};

} // namespace eglplus

#if !EGLPLUS_LINK_LIBRARY || defined(EGLPLUS_IMPLEMENTING_LIBRARY)
#include <eglplus/configs.ipp>
#endif

#endif // include guard