D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SoundSystem/spSoundDevice.hpp

Go to the documentation of this file.

/*
 * Sound device header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_AUDIO_SOUNDDEVICE_H__
#define __SP_AUDIO_SOUNDDEVICE_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutput.hpp"
#include "SoundSystem/spSound.hpp"
#include "SoundSystem/spSoundEffect.hpp"
#include "FileFormats/Sound/spSoundLoader.hpp"

#include <list>
#include <stdio.h>


namespace sp
{

class SoftPixelDevice;

#if defined(SP_PLATFORM_LINUX)
class SoftPixelDeviceLinux;
#endif

namespace audio
{


/*
 * Enumerations
 */

enum ESoundDevices
{
    SOUNDDEVICE_AUTODETECT, 
    SOUNDDEVICE_OPENAL,     
    SOUNDDEVICE_XAUDIO2,    
    SOUNDDEVICE_OPENSLES,   
    SOUNDDEVICE_WINMM,      
    SOUNDDEVICE_DUMMY,      
};

enum ENoteNames
{
    NOTE_C          = 0,
    NOTE_H_SHARP    = 0,
    NOTE_C_SHARP    = 1,
    NOTE_D_FLAT     = 1,
    NOTE_D          = 2,
    NOTE_D_SHARP    = 3,
    NOTE_E_FLAT     = 3,
    NOTE_E          = 4,
    NOTE_F_FLAT     = 4,
    NOTE_F          = 5,
    NOTE_E_SHARP    = 5,
    NOTE_F_SHARP    = 6,
    NOTE_G_FLAT     = 6,
    NOTE_G          = 7,
    NOTE_G_SHARP    = 8,
    NOTE_A_FLAT     = 8,
    NOTE_A          = 9,
    NOTE_A_SHARP    = 10,
    NOTE_H_FLAT     = 10,
    NOTE_H          = 11,
    NOTE_C_FLAT     = 11,
};


class SP_EXPORT SoundDevice
{
    
    public:
        
        virtual ~SoundDevice();
        
        /* === Functions === */
        
        virtual io::stringc getVersion() const;
        
        virtual io::stringc getInterface() const = 0;
        
        void printConsoleHeader();
        
        virtual void updateSounds();
        
        virtual Sound* createSound() = 0;
        
        virtual Sound* loadSound(const io::stringc &Filename, u8 BufferCount = DEF_SOUND_BUFFERCOUNT);
        
        virtual void deleteSound(Sound* &SoundObject);
        
        virtual SoundEffect* createSoundEffect();
        virtual void deleteSoundDevice(SoundEffect* &SoundEffectObject);
        
        /* === Listener control === */
        
        virtual void setListenerPosition(const dim::vector3df &Position);
        
        virtual void setListenerVelocity(const dim::vector3df &Velocity);
        
        virtual void setListenerOrientation(const dim::matrix4f &Orientation);
        
        virtual void setListenerRange(const f32 NearDist, const f32 FarDist, const f32 NearVol, const f32 FarVol);
        virtual void getListenerRange(f32 &NearDist, f32 &FarDist, f32 &NearVol, f32 &FarVol) const;
        
        virtual void setListenerSpeed(f32 Speed);
        virtual f32 getListenerSpeed() const;
        
        virtual void setEffectSlot(SoundEffect* Sfx);
        
        /* === Low-level functions === */
        
        SAudioBufferPtr loadAudioPCMBuffer(const io::stringc &Filename);
        
        /* === Inline functions === */
        
        inline dim::vector3df getListenerPosition() const
        {
            return ListenerPosition_;
        }
        inline dim::vector3df getListenerVelocity() const
        {
            return ListenerVelocity_;
        }
        inline dim::matrix4f getListenerOrientation() const
        {
            return ListenerOrientation_;
        }
        
        inline SoundEffect* getEffectSlot() const
        {
            return ActiveEffectSlot_;
        }
        
        /* === Static functions === */
        
        static void setMelodySpeed(f32 Speed);
        
        static void playMelody(const ENoteNames Note, u8 Octave = 3, u32 Duration = 250, u32 Delay = 0);
        
        static void playMelody(io::stringc MelodyCmdStr);
        
    protected:
        
        friend class sp::SoftPixelDevice;
        
        #if defined(SP_PLATFORM_LINUX)
        friend class sp::SoftPixelDeviceLinux;
        #endif
        
        /* === Functions === */
        
        SoundDevice(const ESoundDevices DeviceType);
        
        virtual void updateSoundVolumetic(Sound* CurSound);
        
        /* === Members === */
        
        ESoundDevices DeviceType_;
        
        std::list<Sound*> SoundList_;
        std::list<SoundEffect*> SoundEffectList_;
        
        dim::vector3df ListenerPosition_;
        dim::vector3df ListenerVelocity_;
        dim::matrix4f ListenerOrientation_;
        
        f32 NearVol_, FarVol_, MiddleVol_;
        f32 NearDist_, FarDist_, MiddleDist_;
        
        f32 ListenerSpeed_;
        
        SoundEffect* ActiveEffectSlot_;
        
        static f32 MelodySpeed_;
        
};


} // /namespace audio

} // /namespace sp


#endif



// ================================================================================