Sound.h

Go to the documentation of this file.

#pragma once

#include <vector>

#include "bass.h"  //c:\Source\BASS\c\ removed and added to the projects additional include dirs
#include "gui.h"
#include "Config/SoundConfig.h"
#include "GameState.h"

struct Sdelayedeffects
{
        int soundEnum;
        float volume;
        float delay;
};

struct Sloopingeffects
{
        unsigned char array;
        int vehicleId;
        int soundEnum;
};

enum SOUNDS // any changes to this must be done to the const char array below
{
        SOUND_COCKPITSTART,
        SOUND_COCKPITAMBIENT,
        SOUND_COCKPITLAND,
        SOUND_COCKPITLEVEL, // getting called too often
        SOUND_COCKPITENGINELEFT,
        SOUND_COCKPITENGINERIGHT,
        SOUND_COCKPITENGINECENTER,

        SOUND_AURALUNITTESTA, // this is the first one
        SOUND_AURALUNITTESTB,
        SOUND_COCKPITLOWFUEL,
        SOUND_COCKPITLIGHTOFF,
        SOUND_COCKPITLIGHTON,
        SOUND_STALL,
        SOUND_OVERSPEED,
        SOUND_GPWSSINKRATE,
        SOUND_GPWSPULLUP,
        SOUND_GPWSTERRAINTERRAIN,
        SOUND_GPWSTOOLOWTERRAIN,
        SOUND_GPWSTOOLOWGEAR,
        SOUND_GPWSTOOLOWFLAPS,
        SOUND_GPWSBANKANGLE,
        SOUND_GPWSGLIDESLOPE,
        SOUND_GPWSRETARD,
        SOUND_GPWSTEN,
        SOUND_GPWSTWENTY,
        SOUND_GPWSTHIRTY,
        SOUND_GPWSFORTY,
        SOUND_GPWSFIFTY,
        SOUND_GPWSONEHUNDRED,
        SOUND_GPWSTWOHUNDRED,
        SOUND_GPWSMINIMUMS,
        SOUND_GPWSFIVEHUNDRED,
        SOUND_GPWSONETHOUSAND,
        SOUND_GPWSROTATE,
        SOUND_GPWSDONTSINK,
        SOUND_GPWSPOSITIVERATE,
        SOUND_GPWSWINDSHEARWARNING,
        SOUND_GPWSWINDSHEARCAUTION,
        SOUND_TCASCLEAR,
        SOUND_TCASTRAFFIC,
        SOUND_TCASCLIMB,
        SOUND_TCASDESCEND,
        SOUND_TCASMONITOR,
        SOUND_MONROECARGOBAY,
        SOUND_MONROEALLMOORINGSCLEARED,
        SOUND_MONROEGEARDOWN,
        SOUND_MONROEGEARUP,
        SOUND_CONFIGBRAKE,
        SOUND_CONFIGAF,
        SOUND_CONFIGFLAPS,
        SOUND_CONFIGTRIM,
        SOUND_MONROEHULLIONIZATION,
        SOUND_MONROESOUNDBARRIER,
        SOUND_SCANNERSYNC,
        SOUND_FORWARDTHRUST,
        SOUND_REVERSETHRUST,
        SOUND_CABINPRESSURE,
        SOUND_AURALUNITOKAY, // this is the last one

        SOUND_PEOPLEGRUNT1,
        SOUND_PEOPLEGRUNT2,
        SOUND_PEOPLEGRUNT3,

        SOUND_THUNDER, // start of thunder series
        SOUND_THUNDER1,
        SOUND_THUNDER2,
        SOUND_THUNDER3,
        SOUND_THUNDER4,
        SOUND_THUNDER5,
        SOUND_THUNDER6,
        SOUND_THUNDER7,
        SOUND_THUNDER8,
        SOUND_THUNDER9,
        SOUND_THUNDER10,
        SOUND_THUNDER11,
        SOUND_THUNDER12,
        SOUND_THUNDER13,
        SOUND_THUNDER14, // end of thunder series
        SOUND_PRECIP0,
        SOUND_PRECIP1,
        SOUND_PRECIP2,
        SOUND_PRECIP3,
        SOUND_PRECIP4,
        SOUND_WIND,
        SOUND_SPEAKERPOP,

        SOUND_MOUSEOVER, // able to move over faster than # of instances
        SOUND_MOUSECLICK,
        SOUND_SNAPSHOT,
        SOUND_CHAT,
        SOUND_LOGON,
        SOUND_LOGOFF,
        SOUND_NEWMSG,
        SOUND_REPAIR,
        SOUND_CHACHING,
        SOUND_INFORMATION,
        SOUND_CONSTRUCTION,
        SOUND_SUCCESS,
        SOUND_TAXI,
        SOUND_SCANNING,
        SOUND_NEWSFLASH,
        SOUND_HOLIDAYBELLS, // @todo could combine these two to just a holiday
        SOUND_HOLIDAYHOWL,

        SOUND_APALTITUDE,
        SOUND_AOA,
        SOUND_APCAVALRY,
        SOUND_APCCHORD,
        SOUND_CYCLETARGET,
        SOUND_MIDWAYTARGET,
        SOUND_PROXIMITY,
        SOUND_OUTERMARKER,
        SOUND_MIDDLEMARKER,
        SOUND_INNERMARKER,
        SOUND_MASTERWARNING,
        SOUND_MASTERCAUTION,

        SOUND_DOCKANNOUNCE1, // @todo only ever need to load CPOC or TAC...
        SOUND_DOCKANNOUNCE2,
        SOUND_DOCKANNOUNCE3,
        SOUND_DOCKANNOUNCE4,
        SOUND_DOCKANNOUNCE5,
        SOUND_DOCKANNOUNCE6,
        SOUND_DOCKANNOUNCE7,
        SOUND_DOCKANNOUNCE8,
        SOUND_DOCKANNOUNCE9,
        SOUND_DOCKANNOUNCE10,
        SOUND_DOCKANNOUNCE11,
        SOUND_DOCKANNOUNCE12,
        SOUND_DOCKEVAC,
        SOUND_DOCKCHIME,

        SOUND_CPOCANNOUNCE1,
        SOUND_CPOCANNOUNCE2,
        SOUND_CPOCANNOUNCE3,
        SOUND_CPOCANNOUNCE4,
        SOUND_CPOCANNOUNCE5,
        SOUND_CPOCANNOUNCE6,
        SOUND_CPOCANNOUNCE7,
        SOUND_CPOCANNOUNCE8,
        SOUND_CPOCANNOUNCE9,
        SOUND_CPOCANNOUNCE10,
        SOUND_CPOCANNOUNCE11,
        SOUND_CPOCANNOUNCE12,
        SOUND_CPOCEVAC,
        SOUND_CPOCCHIME,

        SOUND_DOCK,
        SOUND_UNDOCK,

        SOUND_FLAPMOTOR,
        SOUND_DOOROPEN,
        SOUND_DOORCLOSE,
        SOUND_GEARRETRACT,
        SOUND_GEAREXTEND,

        // outside
        SOUND_DIHV,
        SOUND_MINING,
        SOUND_SHORE,
        SOUND_FARMING,
        SOUND_INDUSTRIAL,
        SOUND_FIREWORKLAUNCH1,
        SOUND_FIREWORKLAUNCH2,
        SOUND_FIREWORKLAUNCH3,
        SOUND_FIREWORKEXPLODE1,
        SOUND_FIREWORKEXPLODE2,
        SOUND_FIREWORKEXPLODE3,
        SOUND_SONICBOOM,
        SOUND_WDEATH1,
        SOUND_WDEATH2,
        SOUND_GDEATH1,
        SOUND_GDEATH2,
        SOUND_ODEATH1,
        SOUND_ODEATH2,
        SOUND_TDEATH1,
        SOUND_TDEATH2,
        SOUND_COLLISION1,
        SOUND_COLLISION2,
        SOUND_TIRESKID,
        SOUND_GEARSHIFT,
        SOUND_GEARGRIND,
        SOUND_WLAND1,
        SOUND_WLAND2,
        SOUND_GEARWIND,
        SOUND_FLAPWIND,
        SOUND_DOPPLER,
        SOUND_DOPPLER2,
        SOUND_HORNCAR,
        SOUND_ECTO1,
        SOUND_HORNMAMMOTH,
        SOUND_HORNTRUCK,
        SOUND_BACKUP,
        SOUND_AIRBRAKEON,
        SOUND_AIRBRAKEOFF,
        SOUND_BACKUPMAMMOTH,
        SOUND_AIRBRAKEONMAMMOTH,
        SOUND_AIRBRAKEOFFMAMMOTH,
        SOUND_POLICECHIRP,
        SOUND_THRUST,
        SOUND_GROUNDSCRAPELOOP,
        SOUND_GROUNDSCRAPESTOP,
        SOUND_ROADNOISELOOP,

        SOUND_PEOPLEDEATH,

        SOUND_HOLIDAY2018,
        SOUND_HOLIDAY2019,

        SOUND_EXPLODE1,
        SOUND_EXPLODE2,
        SOUND_EXPLODE3,
        SOUND_EXPLODE4,
        SOUND_EXPLODE5,
        SOUND_EXPLODEINT1,
        SOUND_EXPLODEINT2,
        SOUND_EXPLODEINT3,
        SOUND_EXPLODERING,
        SOUND_SHOCKWAVE,

        SOUND_WEAPON1,
        SOUND_WEAPON2,
        SOUND_WEAPON3,

        SOUND_RADIOCUT1,
        SOUND_RADIOCUT2,
        SOUND_RADIOCUT3,
        SOUND_RADIOCUT4,
        SOUND_RADIOCUT5,
        SOUND_RADIOCUT6,

        SOUND_RADIOCARRIER0, // ATC
        SOUND_RADIOCARRIER1,
        SOUND_RADIOCARRIER2,
        SOUND_RADIOCARRIER3,
        SOUND_RADIOCARRIER4,
        SOUND_RADIOCARRIER5,
        SOUND_RADIOCARRIER6,
        SOUND_RADIOCARRIER7,
        SOUND_RADIOCARRIER8,
        SOUND_RADIOCARRIER9,
        SOUND_RADIOCARRIER10,
        SOUND_RADIOCARRIER11,

        SOUND_STATIONID2,

        SOUND_ENUMERATION
};

class Sound
{
        GameClass* game = nullptr;

        const float minrate = 100, maxrate = 100000;

        HSTREAM radio = NULL;
        HSTREAM comms = NULL;

        HSAMPLE sound_sample[SOUND_ENUMERATION];
        HCHANNEL sound_channel[SOUND_ENUMERATION];
        float sound_length[SOUND_ENUMERATION];
        float sound_rate[SOUND_ENUMERATION]{};
        char sound_device[SOUND_ENUMERATION];
        SoundConfig* sound_config[SOUND_ENUMERATION];
        static char* sound_path[SOUND_ENUMERATION];
        float sound_volume[SOUND_ENUMERATION];

        char currentSoundDevice = -2;
        char currentRadioDevice = -2;

        bool g_bRadioPlaying = false;
        short oldstation = -1;
        char oldtitle[99] = { 0 };
        char metadata[999] = { 0 };
        char stationIdentification = rand() % 3;

        int excludeFromGlobalAttenuate = -1; // could be ringing in ears, could be holiday effect
        float globalAttenuate = 1.0f;
        float gaTimer = 0.0f;
        float gaTimeToFadeOut = 0.0f;
        float gaTimeToHold = 0.0f;
        float gaTimeToFadeIn = 0.0f;
        float gaVolumeAdj = 0.0f;
        float exTimeToFadeIn = 0.0f;
        float exTimeToHold = 0.0f;
        float exTimeToFadeOut = 0.0f;

        float oldvolume = 0.0f, oldFrequencyMod = 1.0f, oldPan = 0.0f;
        float oldvolume2 = 0.0f, oldFrequencyMod2 = 1.0f, oldPan2 = 0.0f;
        float headpan = 0.0f;

        std::vector<Sdelayedeffects> delayedeffects;
        std::vector<Sloopingeffects> loopingeffects;

        void LoadSound(int soundEnum, SoundConfig* device = nullptr);
        void Trace(const char* msg, Logger::Level severity = Logger::Level::Info) const;
        void FrameMoveDelayedEffects(float elapsedTime);
        void FrameMoveDopplerEffects(float elapsedTime);

        bool issuedWarning = false;

public:
        HSTREAM g_pSoundIntro = NULL;
        HSYNC hsync = NULL;

        bool loopintro = true;
        GameState musicstage = GameState::STATUS_SPLASH;
        float musicleft = 0.0f, musicdone = 0.0f;
        short station = 0;
        std::vector<std::string> deviceNames;
        std::vector<GUID> deviceGuids;

        Sound(GameClass* gameptr);

        void EnumDevices();
        void Init();
        void InitDevice(SoundConfig* deviceConfig);
        void Close();
        void PlayAudioData(unsigned char* data, size_t length);
        void GlobalAttenuate(float prmGaTimeToFadeOut, float prmGaTimeToHold, float prmGaTimeToFadeIn, int soundEnum,
                float prmExTimeToFadeIn, float prmExTimeToHold, float prmExTimeToFadeOut, float volumeAdj = 1.0f);
        void ChangeVolume(SoundConfig* config, float modVolume);
        void ChangeVolume(int soundEnum, float modVolume);
        float Play(int soundEnum);
        void Reset();
        void PlayEx(int soundEnum, bool loop, float volume = 1.0f, float frequencyMod = 1.0f, float pan = 0.0f, bool restart = true);
        void Stop(int soundEnum);
        void AddLoopingVehicleSound(int soundEnum, unsigned char array);
        void RemoveLoopingVehicleSound(int soundEnum, unsigned char array);
        void LegacySoundRequestUniverse(SServerPacket datapacket);
        void AddDelayedSound(int soundEnum, float delay, float volume = 1.0f);
        void ChangeCockpit(bool force);
        //static float GetProgress(HSTREAM stream);
        void FrameMoveAAC();
        void PrecipWindSoundBarrier(D3DXVECTOR3 relativewind, float elapsedTime);
        void LoadSounds(short instage);
        void ChangeVolume();
        float GetLength(int soundEnum);
        void LoadCockpitSound(int soundEnum, const char* path, bool force, SoundConfig* device = nullptr);
        void FrameMove(float elapsedTime);
        float GetAttenuation(bool applyDensity) const;

        static void CALLBACK AdvanceStage(HSYNC handle, DWORD channel, DWORD data, void* user);
        static void CALLBACK MetaData(HSYNC handle, DWORD channel, DWORD data, void* user);
};