snd_openal_new.h

/*
===========================================================================
Copyright (C) 2024 the OpenMoHAA team
 
This file is part of OpenMoHAA source code.
 
OpenMoHAA source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
 
OpenMoHAA source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
 
#pragma once
 
#include "qal.h"
 
#undef OPENAL
 
typedef int          S32;
typedef unsigned int U32;
 
#define MAX_STREAM_BUFFERS              16
#define MAX_BUFFER_SAMPLES              16384
 
typedef enum {
    FADE_NONE,
    FADE_IN,
    FADE_OUT
} fade_t;
 
typedef struct {
    vec3_t vOrigin;
    vec3_t vRelativeOrigin;
    vec3_t vVelocity;
 
    sfx_t   *pSfx;
    qboolean bPlaying;
 
    int   iChannel;
    float fVolume;
    float fPitch;
 
    int      iStartTime;
    qboolean bInUse;
    qboolean bCombine;
 
    float fBaseVolume;
    float fMinDist;
    float fMaxDist;
    int   iFlags;
} openal_loop_sound_t;
 
struct openal_channel {
    sfx_t *pSfx;
    int    iEntNum;
    int    iEntChannel;
    vec3_t vOrigin;
 
    float fVolume;
    int   iBaseRate;
    float fNewPitchMult;
    float fMinDist;
    float fMaxDist;
 
    int iStartTime;
    int iTime;
    int iEndTime;
    int iFlags;
    int iPausedOffset;
 
    int song_number;
 
    fade_t fading;
    int    fade_time;
    int    fade_start_time;
 
    ALuint   source;
    ALuint   buffer;
    ALubyte *bufferdata;
 
public:
    void         play();
    virtual void stop();
    void         pause();
 
    void  set_no_3d();
    void  set_3d();
    void  set_no_virtualization();
    void  set_virtualization();
 
    void set_gain(float gain);
    void set_velocity(float v0, float v1, float v2);
    void set_position(float v0, float v1, float v2);
 
    bool is_free();
    bool is_paused();
    bool is_playing();
 
    void         force_free();
    virtual bool set_sfx(sfx_t *pSfx);
 
    void start_sample();
    void stop_sample();
    void resume_sample();
    void end_sample();
 
    void set_sample_pan(S32 pan);
    void set_sample_playback_rate(S32 pan);
    S32  sample_playback_rate();
 
    S32          sample_volume();
    virtual U32  sample_offset();
    U32          sample_ms_offset();
    U32          sample_loop_count();
    virtual void set_sample_offset(U32 offset);
    void         set_sample_ms_offset(U32 offset);
    virtual void set_sample_loop_count(S32 count);
    void         set_sample_loop_block(S32 start_offset, S32 end_offset);
 
    U32 sample_status();
 
public:
    virtual void update();
 
    virtual U32 buffer_frequency() const;
};
 
struct openal_channel_two_d_stream : public openal_channel {
private:
    char         fileName[64];
    void        *streamHandle;
    unsigned int buffers[MAX_STREAM_BUFFERS];
    unsigned int currentBuf;
    unsigned int sampleLoopCount;
    unsigned int sampleLooped;
    unsigned int streamNextOffset;
    bool         streaming;
 
public:
    openal_channel_two_d_stream();
    ~openal_channel_two_d_stream();
 
    void stop() override;
    bool set_sfx(sfx_t *pSfx) override;
    void set_sample_loop_count(S32 count) override;
    void update() override;
    U32  sample_offset() override;
    void set_sample_offset(U32 offset) override;
 
    bool queue_stream(const char *fileName);
 
protected:
    U32 buffer_frequency() const override;
 
private:
    void clear_stream();
 
    unsigned int getQueueLength() const;
    unsigned int getCurrentStreamPosition() const;
    unsigned int getBitsPerSample() const;
};
 
struct openal_movie_channel : public openal_channel {
 
};
 
struct openal_internal_t {
    openal_channel              chan_3D[MAX_SOUNDSYSTEM_CHANNELS_3D];
    openal_channel              chan_2D[MAX_SOUNDSYSTEM_CHANNELS_2D];
    openal_channel_two_d_stream chan_2D_stream[MAX_SOUNDSYSTEM_CHANNELS_2D_STREAM];
    openal_channel_two_d_stream chan_song[MAX_SOUNDSYSTEM_SONGS];
    openal_channel_two_d_stream chan_mp3;
    openal_channel_two_d_stream chan_trig_music;
    openal_channel_two_d_stream chan_movie;
 
    // Pointers to channels
    openal_channel *channel[MAX_SOUNDSYSTEM_CHANNELS];
 
    openal_loop_sound_t loop_sounds[MAX_SOUNDSYSTEM_LOOP_SOUNDS];
 
    openal_channel movieChannel;
    sfx_t          movieSFX;
 
    char tm_filename[MAX_RES_NAME];
    int  tm_loopcount;
};
 
#ifdef __cplusplus
extern "C" {
#endif
 
    qboolean S_OPENAL_Init();
    void     S_OPENAL_Shutdown();
    void     S_OPENAL_StartSound(
            const vec3_t vOrigin,
            int          iEntNum,
            int          iEntChannel,
            sfxHandle_t  sfxHandle,
            float        fVolume,
            float        fMinDist,
            float        fPitch,
            float        fMaxDist,
            qboolean     bStreamed
        );
    void S_OPENAL_AddLoopingSound(
        const vec3_t vOrigin,
        const vec3_t vVelocity,
        sfxHandle_t  sfxHandle,
        float        fVolume,
        float        fMinDist,
        float        fMaxDist,
        float        fPitch,
        int          iFlags
    );
    void S_OPENAL_ClearLoopingSounds();
    void S_OPENAL_StopSound(int iEntNum, int iEntChannel);
    void S_OPENAL_StopAllSounds(qboolean bStopMusic);
    void S_OPENAL_Respatialize(int iEntNum, const vec3_t vHeadPos, const vec3_t vAxis[3]);
    void S_OPENAL_SetReverb(int iType, float fLevel);
    void S_OPENAL_Update();
 
    const char  *S_OPENAL_GetMusicFilename();
    int          S_OPENAL_GetMusicLoopCount();
    unsigned int S_OPENAL_GetMusicOffset();
 
#ifdef __cplusplus
}
#endif