source.hpp

Go to the documentation of this file.

#pragma once
#ifndef OALPLUS_SOURCE_1303201647_HPP
#define OALPLUS_SOURCE_1303201647_HPP

#include <oalplus/config.hpp>
#include <oalplus/fwd.hpp>
#include <oalplus/alfunc.hpp>
#include <oalplus/math/angle.hpp>
#include <oalplus/math/vector.hpp>
#include <oalplus/error/basic.hpp>
#include <oalplus/object/wrapper.hpp>
#include <oalplus/object/sequence.hpp>
#include <oalplus/buffer.hpp>
#include <oalplus/source_state.hpp>
#include <oalplus/source_type.hpp>

#include <cassert>

namespace oalplus {


template <>
class ObjGenDelOps<tag::Source>
{
protected:
    static void Gen(tag::Generate, ALsizei count, ALuint* names)
    {
        assert(names != nullptr);
        OALPLUS_ALFUNC(GenSources)(count, names);
        OALPLUS_CHECK_SIMPLE(GenSources);
    }

    static void Delete(ALsizei count, ALuint* names)
    {
        assert(names != nullptr);
        OALPLUS_ALFUNC(DeleteSources)(count, names);
        OALPLUS_VERIFY_SIMPLE(DeleteSources);
    }

    static ALboolean IsA(ALuint name)
    {
        assert(name != 0);
        ALboolean result = OALPLUS_ALFUNC(IsSource)(name);
        OALPLUS_VERIFY_SIMPLE(IsSource);
        return result;
    }
};


template <>
class ObjectOps<tag::DirectState, tag::Source>
 : public ObjectName<tag::Source>
{
protected:
    ObjectOps(void) { }
public:

    void Play(void)
    {
        OALPLUS_ALFUNC(SourcePlay)(_name);
        OALPLUS_VERIFY(
            SourcePlay,
            ObjectError,
            Object(*this)
        );
    }


    void Pause(void)
    {
        OALPLUS_ALFUNC(SourcePause)(_name);
        OALPLUS_VERIFY(
            SourcePause,
            ObjectError,
            Object(*this)
        );
    }


    void Stop(void)
    {
        OALPLUS_ALFUNC(SourceStop)(_name);
        OALPLUS_VERIFY(
            SourceStop,
            ObjectError,
            Object(*this)
        );
    }


    void Rewind(void)
    {
        OALPLUS_ALFUNC(SourceRewind)(_name);
        OALPLUS_VERIFY(
            SourceRewind,
            ObjectError,
            Object(*this)
        );
    }


    SourceState State(void) const
    {
        ALint result = 0;
        OALPLUS_ALFUNC(GetSourceiv)(
            _name,
            AL_SOURCE_STATE,
            &result
        );
        OALPLUS_VERIFY(
            GetSourceiv,
            ObjectError,
            Object(*this)
        );
        return SourceState(result);
    }


    void Relative(bool value)
    {
        OALPLUS_ALFUNC(Sourcei)(
            _name,
            AL_SOURCE_RELATIVE,
            value?AL_TRUE:AL_FALSE
        );
        OALPLUS_VERIFY(
            Sourcei,
            ObjectError,
            Object(*this)
        );
    }


    bool Relative(void) const
    {
        ALint result;
        OALPLUS_ALFUNC(GetSourceiv)(
            _name,
            AL_SOURCE_RELATIVE,
            &result
        );
        OALPLUS_VERIFY(
            GetSourceiv,
            ObjectError,
            Object(*this)
        );
        return result == AL_TRUE;
    }


    void Type(SourceType type)
    {
        OALPLUS_ALFUNC(Sourcei)(
            _name,
            AL_SOURCE_TYPE,
            ALenum(type)
        );
        OALPLUS_VERIFY(
            Sourcei,
            ObjectError,
            Object(*this)
        );
    }


    SourceType Type(void) const
    {
        ALint result;
        OALPLUS_ALFUNC(GetSourceiv)(
            _name,
            AL_SOURCE_TYPE,
            &result
        );
        OALPLUS_VERIFY(
            GetSourceiv,
            ObjectError,
            Object(*this)
        );
        return SourceType(ALenum(result));
    }


    void Looping(bool value)
    {
        OALPLUS_ALFUNC(Sourcei)(
            _name,
            AL_LOOPING,
            value?AL_TRUE:AL_FALSE
        );
        OALPLUS_VERIFY(
            Sourcei,
            ObjectError,
            Object(*this)
        );
    }


    bool Looping(void) const
    {
        ALint result;
        OALPLUS_ALFUNC(GetSourceiv)(
            _name,
            AL_LOOPING,
            &result
        );
        OALPLUS_VERIFY(
            GetSourceiv,
            ObjectError,
            Object(*this)
        );
        return result == AL_TRUE;
    }


    void Buffer(const BufferName& buffer)
    {
        OALPLUS_ALFUNC(Sourcei)(
            _name,
            AL_BUFFER,
            GetALName(buffer)
        );
        OALPLUS_VERIFY(
            Sourcei,
            ObjectError,
            Object(*this)
        );
    }


    void DetachBuffers(void)
    {
        OALPLUS_ALFUNC(Sourcei)(
            _name,
            AL_BUFFER,
            0
        );
        OALPLUS_VERIFY(
            Sourcei,
            ObjectError,
            Object(*this)
        );
    }


    void QueueBuffers(const Sequence<BufferName>& buffers)
    {
        OALPLUS_ALFUNC(SourceQueueBuffers)(
            _name,
            buffers.size(),
            const_cast<ALuint*>(GetALNames(buffers))
        );
        OALPLUS_VERIFY(
            SourceQueueBuffers,
            ObjectError,
            Object(*this)
        );
    }


    void UnqueueBuffers(const Sequence<BufferName>& buffers)
    {
        OALPLUS_ALFUNC(SourceUnqueueBuffers)(
            _name,
            buffers.size(),
            const_cast<ALuint*>(GetALNames(buffers))
        );
        OALPLUS_VERIFY(
            SourceUnqueueBuffers,
            ObjectError,
            Object(*this)
        );
    }


    void Gain(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_GAIN,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat Gain(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_GAIN,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void MinGain(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_MIN_GAIN,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat MinGain(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_MIN_GAIN,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void MaxGain(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_MAX_GAIN,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat MaxGain(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_MAX_GAIN,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void ReferenceDistance(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_REFERENCE_DISTANCE,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat ReferenceDistance(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_REFERENCE_DISTANCE,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void RolloffFactor(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_ROLLOFF_FACTOR,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat RolloffFactor(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_ROLLOFF_FACTOR,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void MaxDistance(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_MAX_DISTANCE,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat MaxDistance(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_MAX_DISTANCE,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void Pitch(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_PITCH,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat Pitch(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_PITCH,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void Position(const Vec3f& dir)
    {
        OALPLUS_ALFUNC(Sourcefv)(
            _name,
            AL_POSITION,
            dir.Data()
        );
        OALPLUS_CHECK(
            Sourcefv,
            ObjectError,
            Object(*this)
        );
    }


    void Position(ALfloat x, ALfloat y, ALfloat z)
    {
        OALPLUS_ALFUNC(Source3f)(
            _name,
            AL_POSITION,
            x, y, z
        );
        OALPLUS_CHECK(
            Source3f,
            ObjectError,
            Object(*this)
        );
    }


    Vec3f Position(void) const
    {
        ALfloat result[3];
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_POSITION,
            result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return Vec3f(result);
    }


    void Velocity(const Vec3f& dir)
    {
        OALPLUS_ALFUNC(Sourcefv)(
            _name,
            AL_VELOCITY,
            dir.Data()
        );
        OALPLUS_CHECK(
            Sourcefv,
            ObjectError,
            Object(*this)
        );
    }


    void Velocity(ALfloat x, ALfloat y, ALfloat z)
    {
        OALPLUS_ALFUNC(Source3f)(
            _name,
            AL_VELOCITY,
            x, y, z
        );
        OALPLUS_CHECK(
            Source3f,
            ObjectError,
            Object(*this)
        );
    }


    Vec3f Velocity(void) const
    {
        ALfloat result[3];
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_VELOCITY,
            result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return Vec3f(result);
    }


    void Direction(const Vec3f& dir)
    {
        OALPLUS_ALFUNC(Sourcefv)(
            _name,
            AL_DIRECTION,
            dir.Data()
        );
        OALPLUS_CHECK(
            Sourcefv,
            ObjectError,
            Object(*this)
        );
    }


    void Direction(ALfloat x, ALfloat y, ALfloat z)
    {
        OALPLUS_ALFUNC(Source3f)(
            _name,
            AL_DIRECTION,
            x, y, z
        );
        OALPLUS_CHECK(
            Source3f,
            ObjectError,
            Object(*this)
        );
    }


    Vec3f Direction(void) const
    {
        ALfloat result[3];
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_DIRECTION,
            result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return Vec3f(result);
    }


    void ConeInnerAngle(Anglef angle)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_CONE_INNER_ANGLE,
            angle.ValueInDegrees()
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    Anglef ConeInnerAngle(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_CONE_INNER_ANGLE,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return Anglef::Degrees(result);
    }


    void ConeOuterAngle(Anglef angle)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_CONE_OUTER_ANGLE,
            angle.ValueInDegrees()
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    Anglef ConeOuterAngle(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_CONE_OUTER_ANGLE,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return Anglef::Degrees(result);
    }


    void ConeOuterGain(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_CONE_OUTER_GAIN,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    ALfloat ConeOuterGain(void) const
    {
        ALfloat result;
        OALPLUS_ALFUNC(GetSourcefv)(
            _name,
            AL_CONE_OUTER_GAIN,
            &result
        );
        OALPLUS_VERIFY(
            GetSourcefv,
            ObjectError,
            Object(*this)
        );
        return result;
    }


    void SecOffset(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_SEC_OFFSET,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    void SampleOffset(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_SAMPLE_OFFSET,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }


    void ByteOffset(ALfloat value)
    {
        OALPLUS_ALFUNC(Sourcef)(
            _name,
            AL_BYTE_OFFSET,
            value
        );
        OALPLUS_CHECK(
            Sourcef,
            ObjectError,
            Object(*this)
        );
    }

};

} // namespace oalplus
namespace oglplus {

template <>
class ObjGenDelOps<oalplus::tag::Source>
 : public oalplus::ObjGenDelOps<oalplus::tag::Source>
{ };

template <typename OpsTag>
class ObjectOps<OpsTag, oalplus::tag::Source>
 : public oalplus::ObjectOps<OpsTag, oalplus::tag::Source>
{ };

} // namespace oglplus
namespace oalplus {

typedef oglplus::ObjectOps<tag::DirectState, tag::Source>
    SourceOps;


typedef Object<SourceOps> Source;

} // namespace oalplus

#endif // include guard