context.hpp

Go to the documentation of this file.

#pragma once
#ifndef OALPLUS_CONTEXT_1303201648_HPP
#define OALPLUS_CONTEXT_1303201648_HPP

#include <oalplus/config.hpp>
#include <oalplus/alfunc.hpp>
#include <oalplus/device.hpp>
#include <oalplus/distance_model.hpp>
#include <oalplus/context_attrib.hpp>
#include <oalplus/string_query.hpp>
#include <oalplus/attrib_list.hpp>
#include <oalplus/error/alc.hpp>

#include <oalplus/detail/sep_str_range.hpp>

namespace oalplus {

struct ContextValueTypeToContextAttrib
{
    static std::integral_constant<int, -1> MaxValueType(void);
};


typedef AttributeList<
    ContextAttrib,
    ContextValueTypeToContextAttrib,
    AttributeListTraits
> ContextAttribs;

typedef FinishedAttributeList<
    ContextAttrib,
    AttributeListTraits
> FinishedContextAttribs;


class ContextOps
{
protected:
    ::ALCdevice* _device;
    ::ALCcontext* _context;

    ContextOps(
        ::ALCdevice* device,
        ::ALCcontext* context
    ): _device(device)
     , _context(context)
    {
        assert(_device);
        assert(_context);
    }
public:

    static ContextOps Current(void);


    static const ALchar* GetString(StringQuery query)
    {
        const ALchar* str = OALPLUS_ALFUNC(GetString)(ALenum(query));
        OALPLUS_VERIFY_SIMPLE(GetString);
        return str;
    }


    static const char* Vendor(void)
    {
        return (const char*)GetString(StringQuery::Vendor);
    }


    static const char* Version(void)
    {
        return (const char*)GetString(StringQuery::Version);
    }


    static const char* Renderer(void)
    {
        return (const char*)GetString(StringQuery::Renderer);
    }

#if OALPLUS_DOCUMENTATION_ONLY

    static Range<String> Extensions(void);
#else
    static aux::SepStrRange Extensions(void)
    {
        return aux::SepStrRange(
            (const char*)GetString(StringQuery::Extensions)
        );
    }
#endif


    DeviceOps<tag::Playback> ContextsDevice(void) const
    {
        return DeviceOps<tag::Playback>(_device);
    }


    bool MakeCurrent(void)
    {
        bool result = OALPLUS_ALCFUNC(MakeContextCurrent)(_context);
        OALPLUS_VERIFY_SIMPLE_ALC(_device, MakeContextCurrent);
        return result;
    }


    void Process(void)
    {
        OALPLUS_ALCFUNC(ProcessContext)(_context);
        OALPLUS_VERIFY_SIMPLE_ALC(_device, ProcessContext);
    }


    void Suspend(void)
    {
        OALPLUS_ALCFUNC(SuspendContext)(_context);
        OALPLUS_VERIFY_SIMPLE_ALC(_device, SuspendContext);
    }


    static void DistanceModel(oalplus::DistanceModel dist_model)
    {
        OALPLUS_ALFUNC(DistanceModel(ALenum(dist_model)));
        OALPLUS_VERIFY_SIMPLE(DistanceModel);
    }


    static oalplus::DistanceModel DistanceModel(void)
    {
        ALint result;
        OALPLUS_ALFUNC(GetIntegerv(
            AL_DISTANCE_MODEL,
            &result
        ));
        OALPLUS_VERIFY_SIMPLE(GetIntegerv);
        return oalplus::DistanceModel(result);
    }


    static void DopplerFactor(ALfloat doppler_factor)
    {
        OALPLUS_ALFUNC(DopplerFactor(doppler_factor));
        OALPLUS_CHECK_SIMPLE(DopplerFactor);
    }


    static ALfloat DopplerFactor(void)
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetFloatv(
            AL_DOPPLER_FACTOR,
            &result
        ));
        OALPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }


    static void SpeedOfSound(ALfloat speed_of_sound)
    {
        OALPLUS_ALFUNC(SpeedOfSound(speed_of_sound));
        OALPLUS_CHECK_SIMPLE(SpeedOfSound);
    }


    static ALfloat SpeedOfSound(void)
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetFloatv(
            AL_SPEED_OF_SOUND,
            &result
        ));
        OALPLUS_VERIFY_SIMPLE(GetFloatv);
        return result;
    }
};

class Context
 : public ContextOps
{
private:
    Context(const Context&);
public:

    Context(const Device& device)
     : ContextOps(
        device._device,
        OALPLUS_ALCFUNC(CreateContext)(device._device, nullptr)
    )
    {
        OALPLUS_CHECK_SIMPLE_ALC(_device, CreateContext);
    }


    Context(
        const Device& device,
        const FinishedContextAttribs& attribs
    ): ContextOps(
        device._device,
        OALPLUS_ALCFUNC(CreateContext)(
            device._device,
            attribs.Get()
        )
    )
    {
        OALPLUS_CHECK_SIMPLE_ALC(_device, CreateContext);
    }

    Context(Context&& tmp)
     : ContextOps(tmp._device, tmp._context)
    {
        tmp._context = nullptr;
    }


    ~Context(void)
    {
        if(_context)
        {
            OALPLUS_ALCFUNC(MakeContextCurrent)(nullptr);
            OALPLUS_ALCFUNC(DestroyContext)(_context);
        }
    }
};

class CurrentContext
 : public Context
{
public:

    CurrentContext(const Device& device)
     : Context(device)
    {
        MakeCurrent();
    }


    CurrentContext(
        const Device& device,
        const FinishedContextAttribs& attribs
    ): Context(device, attribs)
    {
        MakeCurrent();
    }


    CurrentContext(CurrentContext&& tmp)
     : Context(static_cast<Context&&>(tmp))
    {
        if(_context) MakeCurrent();
    }
};

} // namespace oalplus

#endif // include guard