Mirrors/SBSPSS
1
0
Fork 0
Code Releases Activity
8e8aaaf9b8
SBSPSS/source/sound/sound.cpp
Paul ba727d8406
2001-06-18 15:59:09 +00:00

714 lines
23 KiB
C++
Raw Blame History

/*
position
adjust channels ( watery-mario64 style music changes )
*/
/*=========================================================================
sound.cpp
Author: PKG
Created:
Project: Spongebob
Purpose:
Copyright (c) 2000 Climax Development Ltd
===========================================================================*/
/*----------------------------------------------------------------------
Includes
-------- */
#include "sound.h"
#ifndef __SYSTEM_DBG_H__
#include "system\dbg.h"
#endif
#ifndef __UTILS_HEADER__
#include "utils\utils.h"
#endif
/* Std Lib
------- */
/* Data
---- */
/*----------------------------------------------------------------------
Tyepdefs && Defines
------------------- */
/*----------------------------------------------------------------------
Structure defintions
-------------------- */
typedef struct XMSONGDATA
{
FileEquate m_vh,m_vb,m_pxm;
int m_startPattern;
};
typedef struct XMSFXFILEDATA
{
FileEquate m_vh,m_vb,m_pxm;
};
typedef struct SFXDETAILS
{
int m_channelMask;
int m_pattern; // ..or instrument number for loopers
int m_looping;
};
/*----------------------------------------------------------------------
Function Prototypes
------------------- */
/*----------------------------------------------------------------------
Vars
---- */
// Static stuff for CSoundMediator
int CSoundMediator::s_initialised=false;
int CSoundMediator::s_currentVolume[CSoundMediator::NUM_VOLUMETYPES];
int CSoundMediator::s_targetVolume[CSoundMediator::NUM_VOLUMETYPES];
int CSoundMediator::s_volumeDirty[CSoundMediator::NUM_VOLUMETYPES];
xmSampleId CSoundMediator::s_songSampleId=NO_SAMPLE;
FileEquate CSoundMediator::s_songVh=(FileEquate)-1;
xmModId CSoundMediator::s_songModId=NO_SONG;
FileEquate CSoundMediator::s_songPxm=(FileEquate)-1;
xmPlayingId CSoundMediator::s_songPlayingId=NOT_PLAYING;
int CSoundMediator::s_songStartPattern=0;
xmSampleId CSoundMediator::s_sfxSampleId=NO_SAMPLE;
xmModId CSoundMediator::s_sfxModId=NO_SONG;
static CSpuSound *s_spuSound;
static CXMPlaySound *s_xmplaySound;
// Songs
static XMSONGDATA s_xmSongData[CSoundMediator::NUM_SONGIDS]=
{
// m_vh m_vb m_pxm m_startPattern;
{ MUSIC_SB_TITLE_VH, MUSIC_SB_TITLE_VB, MUSIC_SB_TITLE_PXM, 0x00 }, // SONG_TITLE
{ MUSIC_SB_TITLE_VH, MUSIC_SB_TITLE_VB, MUSIC_SB_TITLE_PXM, 0x0a }, // SONG_OPTIONS
{ MUSIC_SB_TITLE_VH, MUSIC_SB_TITLE_VB, MUSIC_SB_TITLE_PXM, 0x13 }, // SONG_MEMORYCARD
{ MUSIC_SB_TITLE_VH, MUSIC_SB_TITLE_VB, MUSIC_SB_TITLE_PXM, 0x14 }, // SONG_GAMECOMPLETE
{ MUSIC_SB_TITLE_VH, MUSIC_SB_TITLE_VB, MUSIC_SB_TITLE_PXM, 0x23 }, // SONG_GAMEOVER
{ MUSIC_CHAPTER1_VH, MUSIC_CHAPTER1_VB, MUSIC_CHAPTER1_PXM, 0x19 }, // SONG_CHAPTER1_LEVEL1,
{ MUSIC_CHAPTER1_VH, MUSIC_CHAPTER1_VB, MUSIC_CHAPTER1_PXM, 0x2d }, // SONG_CHAPTER1_LEVEL2,
{ MUSIC_CHAPTER1_VH, MUSIC_CHAPTER1_VB, MUSIC_CHAPTER1_PXM, 0x00 }, // SONG_CHAPTER1_LEVEL3,
{ MUSIC_CHAPTER1_VH, MUSIC_CHAPTER1_VB, MUSIC_CHAPTER1_PXM, 0x2c }, // SONG_CHAPTER1_LEVEL4,
{ MUSIC_CHAPTER1_VH, MUSIC_CHAPTER1_VB, MUSIC_CHAPTER1_PXM, 0x40 }, // SONG_CHAPTER1_BOSS,
{ MUSIC_CHAPTER2_VH, MUSIC_CHAPTER2_VB, MUSIC_CHAPTER2_PXM, 0x00 }, // SONG_CHAPTER2_LEVEL1,
{ MUSIC_CHAPTER2_VH, MUSIC_CHAPTER2_VB, MUSIC_CHAPTER2_PXM, 0x16 }, // SONG_CHAPTER2_LEVEL2,
{ MUSIC_CHAPTER2_VH, MUSIC_CHAPTER2_VB, MUSIC_CHAPTER2_PXM, 0x00 }, // SONG_CHAPTER2_LEVEL3,
{ MUSIC_CHAPTER2_VH, MUSIC_CHAPTER2_VB, MUSIC_CHAPTER2_PXM, 0x3e }, // SONG_CHAPTER2_LEVEL4,
{ MUSIC_CHAPTER2_VH, MUSIC_CHAPTER2_VB, MUSIC_CHAPTER2_PXM, 0x40 }, // SONG_CHAPTER2_BOSS,
{ MUSIC_CHAPTER3_VH, MUSIC_CHAPTER3_VB, MUSIC_CHAPTER3_PXM, 0x18 }, // SONG_CHAPTER3_LEVEL1,
{ MUSIC_CHAPTER3_VH, MUSIC_CHAPTER3_VB, MUSIC_CHAPTER3_PXM, 0x00 }, // SONG_CHAPTER3_LEVEL2,
{ MUSIC_CHAPTER3_VH, MUSIC_CHAPTER3_VB, MUSIC_CHAPTER3_PXM, 0x00 }, // SONG_CHAPTER3_LEVEL3,
{ MUSIC_CHAPTER3_VH, MUSIC_CHAPTER3_VB, MUSIC_CHAPTER3_PXM, 0x0b }, // SONG_CHAPTER3_LEVEL4,
{ MUSIC_CHAPTER3_VH, MUSIC_CHAPTER3_VB, MUSIC_CHAPTER3_PXM, 0x21 }, // SONG_CHAPTER3_BOSS_ASLEEP,
{ MUSIC_CHAPTER3_VH, MUSIC_CHAPTER3_VB, MUSIC_CHAPTER3_PXM, 0x22 }, // SONG_CHAPTER3_BOSS_AWAKE,
{ MUSIC_CHAPTER4_VH, MUSIC_CHAPTER4_VB, MUSIC_CHAPTER4_PXM, 0x1b }, // SONG_CHAPTER4_LEVEL1,
{ MUSIC_CHAPTER4_VH, MUSIC_CHAPTER4_VB, MUSIC_CHAPTER4_PXM, 0x00 }, // SONG_CHAPTER4_LEVEL2,
{ MUSIC_CHAPTER4_VH, MUSIC_CHAPTER4_VB, MUSIC_CHAPTER4_PXM, 0x2c }, // SONG_CHAPTER4_LEVEL3,
{ MUSIC_CHAPTER4_VH, MUSIC_CHAPTER4_VB, MUSIC_CHAPTER4_PXM, 0x00 }, // SONG_CHAPTER4_LEVEL4,
{ MUSIC_CHAPTER4_VH, MUSIC_CHAPTER4_VB, MUSIC_CHAPTER4_PXM, 0x3c }, // SONG_CHAPTER4_BOSS,
{ MUSIC_CHAPTER5_VH, MUSIC_CHAPTER5_VB, MUSIC_CHAPTER5_PXM, 0x00 }, // SONG_CHAPTER5_LEVEL1,
{ MUSIC_CHAPTER5_VH, MUSIC_CHAPTER5_VB, MUSIC_CHAPTER5_PXM, 0x14 }, // SONG_CHAPTER5_LEVEL2,
{ MUSIC_CHAPTER5_VH, MUSIC_CHAPTER5_VB, MUSIC_CHAPTER5_PXM, 0x00 }, // SONG_CHAPTER5_LEVEL3,
{ MUSIC_CHAPTER5_VH, MUSIC_CHAPTER5_VB, MUSIC_CHAPTER5_PXM, 0x2a }, // SONG_CHAPTER5_LEVEL4,
{ MUSIC_CHAPTER5_VH, MUSIC_CHAPTER5_VB, MUSIC_CHAPTER5_PXM, 0x3e }, // SONG_CHAPTER5_BOSS,
{ MUSIC_CHAPTER6_VH, MUSIC_CHAPTER6_VB, MUSIC_CHAPTER6_PXM, 0x00 }, // SONG_CHAPTER6_ROLLERCOASTER
{ MUSIC_CHAPTER6_VH, MUSIC_CHAPTER6_VB, MUSIC_CHAPTER6_PXM, 0x00 }, // SONG_CHAPTER6_SNAILRACE
{ MUSIC_CHAPTER6_VH, MUSIC_CHAPTER6_VB, MUSIC_CHAPTER6_PXM, 0x0c }, // SONG_CHAPTER6_BIGWHEEL
{ MUSIC_CHAPTER6_VH, MUSIC_CHAPTER6_VB, MUSIC_CHAPTER6_PXM, 0x0c }, // SONG_CHAPTER6_TUNNELOFLOVE
{ MUSIC_CHAPTER6_VH, MUSIC_CHAPTER6_VB, MUSIC_CHAPTER6_PXM, 0x15 }, // SONG_CHAPTER6_GHOSTTRAIN
{ MUSIC_CHAPTER6_VH, MUSIC_CHAPTER6_VB, MUSIC_CHAPTER6_PXM, 0x2b }, // SONG_CHAPTER6_BIGTOP
};
// SFX banks
static XMSFXFILEDATA s_xmSfxData[CSoundMediator::NUM_SFXBANKIDS]=
{
// m_vh m_vb m_pxm
{ SFX_INGAME_VH, SFX_INGAME_VB, SFX_INGAME_PXM }, // SFX_INGAME
};
// Individual SFX details
static SFXDETAILS s_sfxDetails[CSoundMediator::NUM_SFXIDS]=
{
// m_channelMask m_pattern m_looping
{ 1, 0, 0 }, // SFX_SPONGEBOB_WALK_1
{ 1, 1, 0 }, // SFX_SPONGEBOB_WALK_2
{ 1, 2, 0 }, // SFX_SPONGEBOB_SQUEAKY_SHOES_1
{ 1, 3, 0 }, // SFX_SPONGEBOB_SQUEAKY_SHOES_2
{ 1, 4, 0 }, // SFX_SPONGEBOB_JUMP
{ 1, 5, 0 }, // SFX_SPONGEBOB_BUTTBOUNCE
{ 1, 6, 0 }, // SFX_SPONGEBOB_BLINK
{ 3, 7, 0 }, // SFX_BUBBLE_WAND*
{ 1, 8, 0 }, // SFX_SPONGEBOB_DEFEATED_JINGLE
{ 1, 9, 0 }, // SFX_BALLOON_INFLATE
{ 1, 21, 0 }, // SFX_BALLOON_POP
{ 1, 10, 0 }, // SFX_GLASSES_ON
{ 1, 11, 0 }, // SFX_JELLY_LAUNCHER
{ 1, 12, 0 }, // SFX_SPONGEBOB_KARATE_1
{ 1, 13, 0 }, // SFX_SPONGEBOB_KARATE_2
{ 1, 14, 0 }, // SFX_SPONGEBOB_ATTACK_IMPACT_WITH_ENEMY_1
{ 1, 15, 0 }, // SFX_SPONGEBOB_ATTACK_IMPACT_WITH_ENEMY_2
{ 1, 16, 0 }, // SFX_SPONGEBOB_LAND_AFTER_FALL
{ 1, 17, 0 }, // SFX_SPONGEBOB_NET
{ 1, 18, 0 }, // SFX_ANEMONE_ATTACK_LEVEL1
{ 1, 19, 0 }, // SFX_ANEMONE_ATTACK_LEVEL2
{ 1, 20, 0 }, // SFX_ANEMONE_ATTACK_LEVEL3
{ 1, 21, 0 }, // SFX_ANEMONE_DEFEATED_LEVEL1
{ 1, 21, 0 }, // SFX_ANEMONE_DEFEATED_LEVEL2
{ 1, 22, 0 }, // SFX_ANEMONE_DEFEATED_LEVEL3
{ 1, 23, 0 }, // SFX_ANEMONE_MOVE
{ 1, 24, 0 }, // SFX_ANGLER_FISH_MOVE
{ 1, 25, 0 }, // SFX_BALL_BLOB_MOVE
{ 1, 26, 0 }, // SFX_BALL_BLOB_ATTACK
{ 1, 27, 0 }, // SFX_BEANIE_MOVE
{ 3, 28, 0 }, // SFX_BOOGER_MOVE*
{ 1, 29, 0 }, // SFX_CLAM_ATTACK
{ 1, 30, 0 }, // SFX_CLAM_DEFEATED
{ 1, 31, 0 }, // SFX_CLAM_MOVE
{ 3, 32, 0 }, // SFX_EYEBALL_SENTRY_ATTACK*
{ 3, 33, 0 }, // SFX_EYEBALL_SENTRY_MOVE*
{ 1, 34, 0 }, // SFX_FISH_HOOK_MOVE
{ 3, 35, 0 }, // SFX_FLAMING_SKULL_MOVE*
{ 1, 36, 0 }, // SFX_FLAMING_SKULL_DEFEATED
{ 3, 37, 0 }, // SFX_FLAMING_SKULL_ATTACK*
{ 1, 38, 0 }, // SFX_GARY_DE_SNAIL
{ 3, 39, 0 }, // SFX_GHOST*
{ 1, 40, 0 }, // SFX_FISH_FOLK_MOVE_1
{ 1, 41, 0 }, // SFX_FISH_FOLK_MOVE_2
{ 1, 42, 0 }, // SFX_CANNING_MACHINE
{ 3, 43, 0 }, // SFX_LAVA*
{ 1, 44, 0 }, // SFX_ROLLING_ROCK
{ 1, 45, 0 }, // SFX_SAW
{ 3, 46, 0 }, // SFX_WHIRLPOOL_DRAIN*
{ 3, 47, 0 }, // SFX_WHIRLPOOL_WHIRL*
{ 1, 48, 0 }, // SFX_HERMIT_CRAB_ATTACK
{ 1, 49, 0 }, // SFX_HERMIT_CRAB_MOVE
{ 3, 50, 0 }, // SFX_HAZARD__ACID_DROP*
{ 3, 51, 0 }, // SFX_HAZARD__ACORN_LAND*
{ 3, 52, 0 }, // SFX_HAZARD__BLADE_ATTACK*
{ 3, 53, 0 }, // SFX_HAZARD__BLADE_MOVE*
{ 1, 54, 0 }, // SFX_HAZARD__ROPE_MOVE
{ 3, 55, 0 }, // SFX_HAZARD__ROPE_SNAP*
{ 1, 56, 0 }, // SFX_ANY_OBJECT_FALLING
{ 3, 57, 0 }, // SFX_HAZARD__FIREBALL_LAND*
{ 3, 58, 0 }, // SFX_HAZARD__FIREBALL_LAUNCH*
{ 3, 59, 0 }, // SFX_HAZARD__FALLING_ROCK_FALL*
{ 3, 60, 0 }, // SFX_HAZARD__FALLING_ROCK_LAND*
{ 1, 61, 0 }, // SFX_HAZARD__MINE
{ 1, 62, 0 }, // SFX_SPONGEBOB_SPLASH_INTO_WATER
{ 1, 63, 0 }, // SFX_SPONGEBOB_DIVING_HELMET
{ 1, 64, 0 }, // SFX_HAZARD__STALACTITE_LAND
{ 1, 65, 0 }, // SFX_HAZARD__STALACTITE_RATTLE
{ 3, 66, 0 }, // SFX_HAZARD__STEAM*
{ 3, 67, 0 }, // SFX_HAZARD__SWAMP_GAS*
{ 3, 68, 0 }, // SFX_ITEM__CORAL_BLOWER*
{ 1, 69, 0 }, // SFX_ITEM__DISGUISE
{ 1, 70, 0 }, // SFX_ITEM__JAMJAR_AMMO
{ 3, 71, 0 }, // SFX_ITEM__LEVEL_ITEM*
{ 1, 72, 0 }, // SFX_ITEM__ANY_OTHER_ITEM
{ 3, 73, 0 }, // SFX_ITEM__POWER_UP_ITEM*
{ 3, 74, 0 }, // SFX_ITEM__SKILL_ITEM*
{ 1, 75, 0 }, // SFX_JELLYFISH_MOVE
{ 1, 76, 0 }, // SFX_JELLYFISH_DEFEATED
{ 3, 77, 0 }, // SFX_JELLYFISH_ATTACK*
{ 1, 78, 0 }, // SFX_NAUTILUS_ATTACK
{ 1, 79, 0 }, // SFX_NAUTILUS_MOVE
{ 1, 80, 0 }, // SFX_NINJASTARFISH_ATTACK
{ 1, 81, 0 }, // SFX_PRICKLY_BUG_ATTACK
{ 1, 82, 0 }, // SFX_PRICKLY_BUG_DEFEATED
{ 1, 83, 0 }, // SFX_PRICKLY_BUG_MOVE
{ 3, 84, 0 }, // SFX_PUFFAFISH_MOVE*
{ 3, 85, 0 }, // SFX_SKULL_ATTACK*
{ 1, 86, 0 }, // SFX_SPIDERCRAB_ATTACK
{ 1, 87, 0 }, // SFX_SPIDERCRAB_MOVE
{ 1, 88, 0 }, // SFX_SQUIDDART_ATTACK
{ 3, 89, 0 }, // SFX_SQUIDDART_DEFEATED*
{ 1, 90, 0 }, // SFX_SQUIDDART_MOVE
{ 1, 91, 0 }, // SFX_SEASNAKE_ATTACK
{ 1, 92, 0 }, // SFX_SEASNAKE_MOVE
{ 1, 93, 0 }, // SFX_TELEPHONE_BOX
{ 3, 94, 0 }, // SFX_WORLD_OBJECT__BARRIER*
{ 3, 95, 0 }, // SFX_WORLD_OBJECT__BIG_WHEEL*
{ 3, 96, 0 }, // SFX_WORLD_OBJECT__GEYSER*
{ 3, 97, 0 }, // SFX_WORLD_OBJECT__GHOST_TRAIN_DOORS*
{ 1, 98, 0 }, // SFX_WORLD_OBJECT__DISAPPEARING_PLATFORM
{ 1, 99, 0 }, // SFX_WORLD_OBJECT__RESPAWNING_PLATFORM
{ 1, 100, 0 }, // SFX_WORLD_OBJECT__ROTATING_PLATFORM
{ 1, 101, 0 }, // SFX_WORLD_OBJECT__SEESAW
{ 1, 102, 0 }, // SFX_WORLD_OBJECT__TRAIN_TRACKS
{ 1, 103, 0 }, // SFX_WORLD_OBJECT__CURRENTS
{ 1, 104, 0 }, // SFX_ZOMBIE_FISH_FOLK
{ 1, 105, 0 }, // SFX_FRONT_END__MOVE_CURSOR
{ 1, 106, 0 }, // SFX_FRONT_END__SELECT
{ 1, 107, 0 }, // SFX_FRONT_END__ERROR
{ 1, 108, 0 }, // SFX_FRONT_END__OK
{ 3, 109, 0 }, // SFX_KAPOW_V1*
{ 3, 110, 0 }, // SFX_KAPOW_V2*
{ 3, 111, 0 }, // SFX_KAPOW_V3*
{ 1, 112, 0 }, // SFX_SPLAT
{ 3, 113, 0 }, // SFX_SECRET_AREA*
{ 1, 114, 0 }, // SFX_LAND_ON_JELLYFISH
{ 3, 115, 0 }, // SFX_SPLASH*
{ 3, 116, 0 }, // SFX_BARREL_V1*
{ 3, 117, 0 }, // SFX_BARREL_V2*
{ 1, 118, 0 }, // SFX_ACORN_FALL
{ 1, 119, 0 }, // SFX_ACORN_BOUNCE
{ 1, 120, 0 }, // SFX_CLAM_SNAP
{ 1, 121, 0 }, // SFX_CAR_START
{ 1, 122, 0 }, // CAR_SLOW_DOWN
};
// Reverb details
static ReverbDetails s_reverbDetails[CSoundMediator::NUM_REVERBTYPES]=
{
// m_type m_delay m_depth m_feedback
{ SPU_REV_MODE_OFF, 0, 0, 0 }, // REV_NONE
{ SPU_REV_MODE_ECHO, 75, 0x3000, 100 }, // REV_ECHOTEST
};
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::initialise()
{
int i;
ASSERT(!s_initialised);
s_spuSound=new ("SPUSound") CSpuSound(); s_spuSound->initialise();
s_xmplaySound=new ("XMPlaySound") CXMPlaySound(); s_xmplaySound->initialise();
CXAStream::Init();
for(i=0;i<NUM_VOLUMETYPES;i++)
{
s_currentVolume[i]=MIN_VOLUME;
s_targetVolume[i]=INITIAL_VOLUME;
s_volumeDirty[i]=true;
}
ASSERT(CXAStream::MIN_VOLUME==0); // Just incase someone decides to change any of these.. things in here will break ( PKG )
ASSERT(CXAStream::MAX_VOLUME==32767);
// Initial reverb settings
setReverbType(REV_NONE);//REV_ECHOTEST);
SOUND_DBGMSG("Sound mediator initialised");
s_initialised=true;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::shutdown()
{
ASSERT(0);
ASSERT(s_initialised);
s_xmplaySound->shutdown(); delete s_xmplaySound;
s_spuSound->shutdown(); delete s_spuSound;
SOUND_DBGMSG("Sound mediator shutdown");
s_initialised=false;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::think(int _frames)
{
int i;
int diff,speed;
int *current,*target,*dirty;
ASSERT(s_initialised);
// Fade to target volume
ASSERT(_frames!=0);
if(_frames==0)_frames=1;
speed=_frames*VOLUME_CHANGE_SPEED;
current=s_currentVolume;
target=s_targetVolume;
dirty=s_volumeDirty;
for(i=0;i<NUM_VOLUMETYPES;i++)
{
diff=*target-*current;
if(diff<0)
{
*current-=speed;
if(*current<*target)*current=*target;
*dirty=true;
}
else if(diff>0)
{
*current+=speed;
if(*current>*target)*current=*target;
*dirty=true;
}
current++;
target++;
dirty++;
}
// Update of anything that needs it
CXAStream::ControlXA();
s_xmplaySound->think();
// Push through any changes in volume
if(s_volumeDirty[VOL_FADE])
{
s_volumeDirty[VOL_SONG]=true;
s_volumeDirty[VOL_SFX]=true;
s_volumeDirty[VOL_SPEECH]=true;
s_volumeDirty[VOL_FADE]=false;
}
if(s_volumeDirty[VOL_SONG])
{
s_xmplaySound->setMasterSongVolume((s_currentVolume[VOL_SONG]*s_currentVolume[VOL_FADE])>>8);
s_volumeDirty[VOL_SONG]=false;
}
if(s_volumeDirty[VOL_SFX])
{
s_xmplaySound->setMasterSfxVolume((s_currentVolume[VOL_SFX]*s_currentVolume[VOL_FADE])>>8);
s_volumeDirty[VOL_SFX]=false;
}
if(s_volumeDirty[VOL_SPEECH])
{
int vol=((s_currentVolume[VOL_SPEECH]*s_currentVolume[VOL_FADE])>>8)<<7;
CXAStream::setMasterVolume(vol,vol);
s_volumeDirty[VOL_SPEECH]=false;
}
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::setReverbType(REVERBTYPE _type)
{
s_spuSound->setReverbDetails(&s_reverbDetails[_type]);
s_spuSound->setReverbActive(true);
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::setSong(SONGID _songId)
{
XMSONGDATA *song;
song=&s_xmSongData[_songId];
if(s_songSampleId!=NO_SAMPLE&&s_songVh!=song->m_vh)
{
s_xmplaySound->dumpSampleData(s_songSampleId);
s_songSampleId=NO_SAMPLE;
}
if(s_songSampleId==NO_SAMPLE)
{
s_songSampleId=s_xmplaySound->loadSampleData(song->m_vh,song->m_vb);
}
s_songVh=song->m_vh;
if(s_songModId!=NO_SONG&&s_songPxm!=song->m_pxm)
{
s_xmplaySound->dumpModData(s_songModId);
s_songModId=NO_SONG;
}
if(s_songModId==NO_SONG)
{
s_songModId=s_xmplaySound->loadModData(song->m_pxm);
}
s_songPxm=song->m_pxm;
s_songStartPattern=song->m_startPattern;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::playSong()
{
ASSERT(s_songSampleId!=NO_SAMPLE);
ASSERT(s_songModId!=NO_SONG);
ASSERT(s_songPlayingId==NOT_PLAYING);
s_songPlayingId=s_xmplaySound->playSong(s_songSampleId,s_songModId,s_songStartPattern);
// s_volumeDirty[SONG]=true; // Force a volume update
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::stopSong()
{
ASSERT(s_songSampleId!=NO_SAMPLE);
ASSERT(s_songModId!=NO_SONG);
if(s_songPlayingId!=NOT_PLAYING)
{
s_xmplaySound->stopPlayingId(s_songPlayingId);
s_xmplaySound->unlockPlayingId(s_songPlayingId);
}
s_songPlayingId=NOT_PLAYING;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::dumpSong()
{
ASSERT(s_songSampleId!=NO_SAMPLE);
ASSERT(s_songModId!=NO_SONG);
stopSong();
s_xmplaySound->dumpSampleData(s_songSampleId);
s_songSampleId=NO_SAMPLE;
s_xmplaySound->dumpModData(s_songModId);
s_songModId=NO_SONG;
s_songVh=(FileEquate)-1;
s_songPxm=(FileEquate)-1;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::setSfxBank(SFXBANKID _bankId)
{
XMSFXFILEDATA *sfx;
ASSERT(s_sfxSampleId==NO_SAMPLE);
ASSERT(s_sfxModId==NO_SONG);
sfx=&s_xmSfxData[_bankId];
s_sfxModId=s_xmplaySound->loadModData(sfx->m_pxm);
s_sfxSampleId=s_xmplaySound->loadSampleData(sfx->m_vh,sfx->m_vb);
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params: Pass _lock as true if you wanna keep hold of one-shot sfx.
This'll be necessary if you have a *long* one-shot at the
same time as *lots* of other sfx.
Returns:
---------------------------------------------------------------------- */
xmPlayingId CSoundMediator::playSfx(SFXID _sfxId,int _lock=false)
{
int sfxChannelMask;
xmPlayingId playId;
SFXDETAILS *sfx;
ASSERT(s_sfxSampleId!=NO_SAMPLE);
ASSERT(s_sfxModId!=NO_SONG);
// Play!
sfx=&s_sfxDetails[_sfxId];
if(sfx->m_looping)
{
playId=s_xmplaySound->playLoopingSfx(s_sfxSampleId,s_sfxModId,sfx->m_pattern,10);
}
else
{
playId=s_xmplaySound->playSfx(s_sfxSampleId,s_sfxModId,sfx->m_pattern,sfx->m_channelMask,20);
if(!_lock&&playId!=NOT_PLAYING)
{
s_xmplaySound->unlockPlayingId(playId); // We really don't care about one-shot sfx..
playId=NOT_PLAYING;
}
}
// s_volumeDirty[SFX]=true; // Force a volume update
return playId;
}
/*----------------------------------------------------------------------
Function:
Purpose: Calculate volume and panning for a sound base upon its
position in space. Takes a position in space which describes
the sound position relative to the camera/microphone.
Volume comes from distance from origin and panning comes from
the position along the x axis.
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::setposition(xmPlayingId _playingId,VECTOR *pos)
{
int volume,pan;
volume=CXMPlaySound::MAX_VOLUME-(CalcLengthV(pos));
if(volume<CXMPlaySound::MIN_VOLUME)volume=CXMPlaySound::MIN_VOLUME;
pan=(pos->vx/2)+CXMPlaySound::PAN_CENTRE;
if(pan<CXMPlaySound::PAN_LEFT)pan=CXMPlaySound::PAN_LEFT;
else if(pan>CXMPlaySound::PAN_RIGHT)pan=CXMPlaySound::PAN_RIGHT;
s_xmplaySound->setVolume(_playingId,volume);
s_xmplaySound->setPanning(_playingId,pan);
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::stopAndUnlockSfx(xmPlayingId _playingId)
{
s_xmplaySound->stopPlayingId(_playingId);
s_xmplaySound->unlockPlayingId(_playingId);
}
/*----------------------------------------------------------------------
Function:
Purpose: NB: Will invalidate any locked sfx!
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::stopAllSfx()
{
s_xmplaySound->stopAndUnlockAllSfx();
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CSoundMediator::isSfxStillPlaying(xmPlayingId _playingId)
{
return s_xmplaySound->isStillPlaying(_playingId);
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::playSpeech(SpeechEquate _speech)
{
stopSpeech();
CXAStream::PlaySpeech(_speech,1);
// s_volumeDirty[SPEECH]=true; // Force a volume update
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::stopSpeech()
{
if(CXAStream::IsPlaying())
CXAStream::Stop();
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::setVolume(VOLUMETYPE _type,int _val)
{
ASSERT(_val>=MIN_VOLUME&&_val<=MAX_VOLUME);
s_targetVolume[_type]=_val;
s_volumeDirty[_type]=true; // Otherwise we could miss volume changes under rare conditions
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
int CSoundMediator::getVolume(VOLUMETYPE _type)
{
return s_targetVolume[_type];
}
/*----------------------------------------------------------------------
Function:
Purpose:
Params:
Returns:
---------------------------------------------------------------------- */
void CSoundMediator::stopAllSound()
{
s_xmplaySound->stopAndUnlockAllSound();
CXAStream::Stop();
s_songPlayingId=NOT_PLAYING;
}
/*===========================================================================
end */
View Git Blame Copy Permalink