vwemirror/BT411
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f4b2a7f87fdfd49f56e541fe05540d7e4b72ae42
BT411/engine/MUNGA_L4/L4AUDRES.cpp
T
arcattackandClaude Opus 4.8 5ba541ed56 Audio: subsystem STATE sounds -- GaugeAlarm54 IS a StateIndicator; register Generator/Condenser/Reservoir state (task #50) 
The audio subsystem binds AudioStateWatchers (class 28) to per-subsystem state
attrs (GeneratorState/CondenserState/ReservoirState) BY NAME.  Recovered the
watcher TYPE per attribute via a MakeObjectImplementation ClassID trace.

Root cause of the subsystem-state crash: the binary's 0x54-byte subsystem alarm
(FUN_0041b9ec, reconstructed as GaugeAlarm54) IS a StateIndicator -- its "three
sub-indicators" @0x18/0x2c/0x40 are the audio/video/gauge watcher SChains, and
level@0x14 is currentState.  The reconstruction had modeled that tail as an opaque
`_tail`, so the sockets were never constructed -> AddAudioWatcher AV'd on 0xCDCDCDCD.

- GaugeAlarm54: give it the three REAL, constructed SChainOf<Component*> sockets +
  AddAudioWatcher/Video/Gauge; SetLevel now fires the watchers on a level CHANGE
  (empty sockets = no-op, so the ~all other alarms are unaffected).  levelB (weapon
  LevelCountB "reset source") is left untouched -- weapons unchanged.  sizeof stays
  0x54 (static_assert holds -> SChainOf<Component*> is 0x14, layout exact).
- Register the state attrs -> the subsystem's own alarm (own AttributePointers[]
  chained to the parent): Generator.GeneratorState->stateAlarm, Condenser.
  CondenserState->condenserAlarm, Reservoir.ReservoirState->reservoirAlarm.  Those
  alarms are already SetLevel'd by the sim, so the state audio fires on transition.
- AudioStateWatcher guard now validates the +0x18 SOCKET (what AddAudioWatcher
  touches), not the +0 vtable -- GaugeAlarm54 is non-polymorphic at +0 (raw header)
  but has a real socket at +0x18.

audiostate skips 85 -> 10 (only AmmoBin AmmoState/SimulationState left).  The
Logical/Scalar/Enum subsystem attrs (ReportLeak/GeneratorOn/ConfigureActivePress/
MotionState/SpeedOfTorsoHorizontal/TargetRangeExponent) stay inert (read 0, silent,
non-crashing) -- they need backing members in size-locked layouts (a polish wave).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-15 21:38:15 -05:00

1162 lines
33 KiB
C++
Raw Blame History

#include <stdio.h>
#include <direct.h>
#include <string.h>
#include <cstdlib>
#include "mungal4.h"
#pragma hdrstop
#include "l4audres.h"
#include "l4audhdw.h"
#include "l4audio.h"
#include "l4audlvl.h"
#include "l4audwtr.h"
#include "..\munga\audcmp.h"
#include "..\munga\audseq.h"
#include "..\munga\audrend.h"
#include "..\munga\namelist.h"
#include "..\munga\app.h"
#include "..\munga\notation.h"
#include "openal\al.h"
#include "openal\alc.h"
ALuint *g_buffers;
int g_numBuffers;
int g_curAudioWatcherClass = 0;
//
// Minimal canonical-PCM WAV reader. The repo's libsndfile-1.dll is a STUB
// (exports 15 funcs by ordinal only, no names -- sf_open always returns NULL
// and sf_strerror(NULL) faults), so the original sf_open path loaded nothing.
// Our soundbank samples (AUDIO1/2.RES, cracked by scratchpad/sf2extract.py)
// are written as plain 16-bit mono PCM WAVs, so a tiny RIFF/WAVE fmt+data
// parser loads the real sample data directly into the AL buffer -- no
// external dependency, no stub. Handles 8/16-bit mono/stereo PCM.
//
static bool LoadWavPCM(const char *path, char **outData, int *outBytes,
int *outChannels, int *outBits, int *outRate)
{
FILE *fp = fopen(path, "rb");
if (!fp) return false;
fseek(fp, 0, SEEK_END); long flen = ftell(fp); fseek(fp, 0, SEEK_SET);
if (flen < 44) { fclose(fp); return false; }
unsigned char *buf = new unsigned char[flen];
size_t got = fread(buf, 1, flen, fp);
fclose(fp);
if ((long)got != flen) { delete [] buf; return false; }
if (memcmp(buf, "RIFF", 4) != 0 || memcmp(buf + 8, "WAVE", 4) != 0) { delete [] buf; return false; }
int channels = 0, bits = 0, rate = 0;
char *pcm = 0; int pcmBytes = 0;
bool haveFmt = false;
long p = 12;
while (p + 8 <= flen)
{
const unsigned char *id = buf + p;
unsigned int csz = buf[p+4] | (buf[p+5]<<8) | (buf[p+6]<<16) | ((unsigned)buf[p+7]<<24);
long body = p + 8;
if (memcmp(id, "fmt ", 4) == 0 && csz >= 16)
{
channels = buf[body+2] | (buf[body+3]<<8);
rate = buf[body+4] | (buf[body+5]<<8) | (buf[body+6]<<16) | ((unsigned)buf[body+7]<<24);
bits = buf[body+14] | (buf[body+15]<<8);
haveFmt = true;
}
else if (memcmp(id, "data", 4) == 0)
{
long avail = flen - body;
pcmBytes = ((long)csz <= avail) ? (int)csz : (int)avail;
if (pcmBytes < 0) pcmBytes = 0;
pcm = new char[pcmBytes > 0 ? pcmBytes : 1];
memcpy(pcm, buf + body, pcmBytes);
}
p = body + csz + (csz & 1); // RIFF chunks are word-aligned
}
delete [] buf;
if (!haveFmt || pcm == 0) { delete [] pcm; return false; }
*outData = pcm; *outBytes = pcmBytes;
*outChannels = channels; *outBits = bits; *outRate = rate;
return true;
}
//#############################################################################
//####################### AudioObjectStream #############################
//#############################################################################
//
//#############################################################################
// AudioObjectStream
//#############################################################################
//
AudioObjectStream::AudioObjectStream(
ResourceDescription *resource_description,
Entity *the_entity
):
PlugStream(resource_description)
{
entity = the_entity;
}
//
//#############################################################################
// AudioObjectStream
//#############################################################################
//
AudioObjectStream::AudioObjectStream()
{
entity = NULL;
}
//
//#############################################################################
// ~AudioObjectStream
//#############################################################################
//
AudioObjectStream::~AudioObjectStream()
{
}
//
//#############################################################################
// TestInstance
//#############################################################################
//
Logical
AudioObjectStream::TestInstance() const
{
PlugStream::TestInstance();
if (entity != NULL)
{
Check(entity);
}
return True;
}
//
//#############################################################################
// MakeObjectImplementation
//#############################################################################
//
RegisteredClass*
AudioObjectStream::MakeObjectImplementation(Enumeration class_ID)
{
Check(this);
Verify(class_ID != RegisteredClass::NullClassID);
// DIAG (BT_ATTRBIND_LOG): record which audio-object ClassID is being built so the
// AttributeWatcher trace can print the watcher TYPE alongside the bound attribute.
extern int g_curAudioWatcherClass;
g_curAudioWatcherClass = (int)class_ID;
//
//-----------------------------------------------------------------------
// HACK - Constructors should be referenced through registration, for
// now just use a switch statement
//-----------------------------------------------------------------------
//
RegisteredClass *object;
switch (class_ID)
{
//
// Static resources ...
//
case RegisteredClass::PatchLevelOfDetailClassID:
object = new PatchLevelOfDetail(this);
break;
case RegisteredClass::PatchResourceClassID:
object = new PatchResource(this);
break;
case RegisteredClass::AudioResourceIndexClassID:
object = new AudioResourceIndex(this);
break;
//
// Location and sources ...
//
case RegisteredClass::L4AudioLocationClassID:
object = new L4AudioLocation(this, entity);
break;
case RegisteredClass::DirectPatchSourceClassID:
object = new DirectPatchSource(this, entity);
break;
case RegisteredClass::Dynamic3DPatchSourceClassID:
object = new Dynamic3DPatchSource(this, entity);
break;
case RegisteredClass::Static3DPatchSourceClassID:
object = new Static3DPatchSource(this, entity);
break;
//
// Audio components ...
//
case RegisteredClass::AudioControlMixerClassID:
object = new AudioControlMixer(this, entity);
break;
case RegisteredClass::AudioControlMultiplierClassID:
object = new AudioControlMultiplier(this, entity);
break;
case RegisteredClass::AudioResourceSelectorClassID:
object = new AudioResourceSelector(this, entity);
break;
case RegisteredClass::AudioControlSmootherClassID:
object = new AudioControlSmoother(this, entity);
break;
case RegisteredClass::AudioSampleAndHoldClassID:
object = new AudioSampleAndHold(this, entity);
break;
case RegisteredClass::AudioControlSendClassID:
object = new AudioControlSend(this, entity);
break;
case RegisteredClass::AudioControlSequenceClassID:
object = new AudioControlSequence(this, entity);
break;
case RegisteredClass::AudioControlSplitterClassID:
object = new AudioControlSplitter(this, entity);
break;
case RegisteredClass::AudioLFOClassID:
object = new AudioLFO(this, entity);
break;
//
// Audio watchers ...
//
case RegisteredClass::AudioMotionTriggerClassID:
object = new AudioMotionTrigger(this, entity);
break;
case RegisteredClass::AudioMotionScaleClassID:
object = new AudioMotionScale(this, entity);
break;
case RegisteredClass::AudioHingeScaleClassID:
object = new AudioHingeScale(this, entity);
break;
case RegisteredClass::AudioScalarTriggerClassID:
object = new AudioScalarTrigger(this, entity);
break;
case RegisteredClass::AudioScalarScaleClassID:
object = new AudioScalarScale(this, entity);
break;
case RegisteredClass::AudioLogicalTriggerClassID:
object = new AudioLogicalTrigger(this, entity);
break;
case RegisteredClass::AudioEnumerationTriggerClassID:
object = new AudioEnumerationTrigger(this, entity);
break;
case RegisteredClass::AudioIntegerTriggerClassID:
object = new AudioIntegerTrigger(this, entity);
break;
case RegisteredClass::AudioControlsButtonTriggerClassID:
object = new AudioControlsButtonTrigger(this, entity);
break;
case RegisteredClass::AudioStateTriggerClassID:
object = new AudioStateTrigger(this, entity);
break;
case RegisteredClass::AudioIdleWatcherClassID:
object = new AudioIdleWatcher(this, entity);
break;
case RegisteredClass::AudioEnumerationDeltaTriggerClassID:
object = new AudioEnumerationDeltaTrigger(this, entity);
break;
case RegisteredClass::AudioScalarDeltaTriggerClassID:
object = new AudioScalarDeltaTrigger(this, entity);
break;
case RegisteredClass::L4AudioCollisionTriggerClassID:
object = new L4AudioCollisionTrigger(this, entity);
break;
case RegisteredClass::AudioMessageWatcherClassID:
object = new AudioMessageWatcher(this, entity);
break;
case RegisteredClass::AudioControlsButtonMessageWatcherClassID:
object = new AudioControlsButtonMessageWatcher(this, entity);
break;
//
// Inherited behavior
//
default:
object = PlugStream::MakeObjectImplementation(class_ID);
break;
}
return object;
}
//
//#############################################################################
// CreatedObjectImplementation
//#############################################################################
//
void
AudioObjectStream::CreatedObjectImplementation(
RegisteredClass *object,
ObjectID object_ID
)
{
Check(this);
Check(object);
Verify(object_ID != NullObjectID);
//
// std::Decide which index to add object to
//
switch (object->GetClassID())
{
case RegisteredClass::PatchLevelOfDetailClassID:
case RegisteredClass::PatchResourceClassID:
case RegisteredClass::AudioResourceIndexClassID:
AddGlobalPlug(Cast_Object(Plug*, object), object_ID);
break;
default:
AddLocalPlug(Cast_Object(Plug*, object), object_ID);
break;
}
}
//
//#############################################################################
// BuildFromPageImplementation
//#############################################################################
//
void
AudioObjectStream::BuildFromPageImplementation(
NameList *name_list,
Enumeration class_ID_enumeration,
ObjectID object_ID
)
{
Check(this);
Verify(class_ID_enumeration != RegisteredClass::NullClassID);
Verify(object_ID != NullObjectID);
//
//-----------------------------------------------------------------------
// HACK - Page interpreters should be referenced through registration,
// for now just use a switch statement
//-----------------------------------------------------------------------
//
RegisteredClass::ClassID
class_ID = (RegisteredClass::ClassID)class_ID_enumeration;
switch (class_ID)
{
//
// Static resources ...
//
case RegisteredClass::PatchLevelOfDetailClassID:
PatchLevelOfDetail::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::PatchResourceClassID:
PatchResource::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioResourceIndexClassID:
AudioResourceIndex::BuildFromPage(this, name_list, class_ID, object_ID);
break;
//
// Location and sources ...
//
case RegisteredClass::L4AudioLocationClassID:
L4AudioLocation::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::DirectPatchSourceClassID:
DirectPatchSource::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::Dynamic3DPatchSourceClassID:
Dynamic3DPatchSource::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::Static3DPatchSourceClassID:
Static3DPatchSource::BuildFromPage(this, name_list, class_ID, object_ID);
break;
//
// Audio components ...
//
case RegisteredClass::AudioControlMixerClassID:
AudioControlMixer::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioControlMultiplierClassID:
AudioControlMultiplier::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioResourceSelectorClassID:
AudioResourceSelector::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioControlSmootherClassID:
AudioControlSmoother::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioSampleAndHoldClassID:
AudioSampleAndHold::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioControlSendClassID:
AudioControlSend::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioControlSequenceClassID:
AudioControlSequence::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioControlSplitterClassID:
AudioControlSplitter::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioLFOClassID:
AudioLFO::BuildFromPage(this, name_list, class_ID, object_ID);
break;
//
// Audio watchers ...
//
case RegisteredClass::AudioMotionTriggerClassID:
AudioMotionTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioMotionScaleClassID:
AudioMotionScale::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioHingeScaleClassID:
AudioHingeScale::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioScalarTriggerClassID:
AudioScalarTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioScalarScaleClassID:
AudioScalarScale::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioLogicalTriggerClassID:
AudioLogicalTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioEnumerationTriggerClassID:
AudioEnumerationTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioIntegerTriggerClassID:
AudioIntegerTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioControlsButtonTriggerClassID:
AudioControlsButtonTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioStateTriggerClassID:
AudioStateTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioIdleWatcherClassID:
AudioIdleWatcher::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioEnumerationDeltaTriggerClassID:
AudioEnumerationDeltaTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioScalarDeltaTriggerClassID:
AudioScalarDeltaTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::L4AudioCollisionTriggerClassID:
L4AudioCollisionTrigger::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioMessageWatcherClassID:
AudioMessageWatcher::BuildFromPage(this, name_list, class_ID, object_ID);
break;
case RegisteredClass::AudioControlsButtonMessageWatcherClassID:
AudioControlsButtonMessageWatcher::BuildFromPage(this, name_list, class_ID, object_ID);
break;
//
// Inherited behavior
//
default:
PlugStream::BuildFromPageImplementation(name_list, class_ID, object_ID);
break;
}
}
//
//#############################################################################
// BuiltFromPageImplementation
//#############################################################################
//
void
AudioObjectStream::BuiltFromPageImplementation(
Enumeration class_ID,
ObjectID object_ID,
const CString &object_name
)
{
Check(this);
Verify(class_ID != RegisteredClass::NullClassID);
Verify(object_ID != NullObjectID);
Check(&object_name);
//
// std::Decide which index to add object to
//
if (object_name.Length() == 0)
return;
switch (class_ID)
{
case RegisteredClass::PatchLevelOfDetailClassID:
case RegisteredClass::PatchResourceClassID:
case RegisteredClass::AudioResourceIndexClassID:
AddGlobalObjectID(object_ID, object_name);
break;
default:
AddLocalObjectID(object_ID, object_name);
break;
}
}
//#############################################################################
//###################### L4AudioResourceManager #########################
//#############################################################################
//
//#############################################################################
// L4AudioResourceManager
//#############################################################################
//
L4AudioResourceManager::L4AudioResourceManager()
{
g_buffers = NULL;
g_numBuffers = 0;
}
//
//#############################################################################
// ~L4AudioResourceManager
//#############################################################################
//
L4AudioResourceManager::~L4AudioResourceManager()
{
}
//
//#############################################################################
// TestInstance
//#############################################################################
//
Logical
L4AudioResourceManager::TestInstance() const
{
Node::TestInstance();
return True;
}
//
//#############################################################################
// PreloadResources
//#############################################################################
//
void
L4AudioResourceManager::PreloadResources(
NotationFile *notation_file
)
{
Check(this);
Check(notation_file);
//Check(audio_hardware);
//Determine how many loadable samples exist
g_numBuffers=0;
for(int i=1; i <= 2; i++)
{
for (int j=0; j < 128; j++)
{
if (PRESET_isImplemented(i,j))
{
g_numBuffers += PRESET_getNumSamples(i,j);
}
}
}
//Generate the buffers
if (g_numBuffers > 0)
{
//Generate buffers
alGetError();
g_buffers = new ALuint[g_numBuffers];
alGenBuffers(g_numBuffers,g_buffers);
if (getenv("BT_AUDIO_LOG")) DEBUG_STREAM << "[audio] alGenBuffers count=" << g_numBuffers << "\n" << std::flush;
ALenum error;
if ((error = alGetError()) != AL_NO_ERROR)
{
DEBUG_STREAM << "OpenAL has encountered an error while initializing the buffers." << std::endl;
delete [] g_buffers;
g_buffers = NULL;
g_numBuffers = 0;
}
}
int bufferInd = 0;
//Load buffers
for(int i=1; i<=2 && bufferInd < g_numBuffers; i++)
{
for(int j=0; j<128 && bufferInd < g_numBuffers; j++)
{
if (PRESET_isImplemented(i,j))
{
for (int k=0; k < PRESET_getNumSamples(i,j) && bufferInd < g_numBuffers; k++)
{
SAMPLEINFO info = PRESET_getSampleInfo(i,j,k);
//Open WAV
char fullname[50];
strcpy_s(fullname,50,"AUDIO/");
strcat_s(fullname,50,info.file);
char *data = 0; int size = 0;
int wavCh = 0, wavBits = 0, wavRate = 0;
if (!LoadWavPCM(fullname, &data, &size, &wavCh, &wavBits, &wavRate))
{
if (getenv("BT_AUDIO_LOG") && bufferInd == 0) {
char cwd[512]; cwd[0]=0; _getcwd(cwd, sizeof(cwd));
DEBUG_STREAM << "[audio] DIAG cwd=[" << cwd << "] path=[" << fullname << "] WAV load FAILED\n" << std::flush;
}
DEBUG_STREAM << "[audio] Failed to open AUDIO/" << info.file << " -- skipping\n" << std::flush;
PRESET_setBufferIndex(i,j,k,bufferInd);
bufferInd++;
continue;
}
ALenum format;
if (wavBits == 8)
format = (wavCh == 1) ? AL_FORMAT_MONO8 : AL_FORMAT_STEREO8;
else
format = (wavCh == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
//Feed the buffer with the real PCM sample data
alBufferData(g_buffers[bufferInd], format, data, size, wavRate);
if (getenv("BT_AUDIO_LOG") && bufferInd < 3)
DEBUG_STREAM << "[audio] loaded buf" << bufferInd << " " << info.file
<< " ch=" << wavCh << " bits=" << wavBits << " rate=" << wavRate
<< " bytes=" << size << " alErr=" << alGetError() << "\n" << std::flush;
PRESET_setBufferIndex(i,j,k,bufferInd);
bufferInd++;
delete [] data;
}
}
}
}
if (getenv("BT_AUDIO_TEST") && g_numBuffers > 0)
{
// PROOF OF LIFE: play the first loaded sample so we can confirm the
// SF2 -> WAV -> OpenAL buffer -> speakers path works end to end.
ALCcontext *ctx = alcGetCurrentContext();
alGetError();
ALuint testsrc = 0; alGenSources(1, &testsrc);
ALenum genErr = alGetError();
alSourcei(testsrc, AL_BUFFER, g_buffers[0]);
ALenum bufErr = alGetError();
alSourcei(testsrc, AL_LOOPING, AL_TRUE);
alSourcef(testsrc, AL_GAIN, 1.0f);
alSourcePlay(testsrc);
ALenum playErr = alGetError();
ALint st = 0; alGetSourcei(testsrc, AL_SOURCE_STATE, &st);
DEBUG_STREAM << "[audio] TEST-PLAY buffer0 src=" << testsrc
<< " ctx=" << (void*)ctx
<< " genErr=" << genErr << " bufErr=" << bufErr << " playErr=" << playErr
<< " state=" << st << " playing=" << (int)(st==AL_PLAYING) << "\n" << std::flush;
}
//
//----------------------------------------------------------------------
// Load the sound banks
//----------------------------------------------------------------------
//
/*NameList *name_list;
NameList::Entry *entry;
Verify(notation_file->EntryCount("AudioResources") >= 2);
name_list = notation_file->MakeEntryList("AudioResources");
Register_Object(name_list);
entry = name_list->GetFirstEntry();
Check(entry);
while (entry != NULL)
{
Check(entry);
if (entry->IsName("front_audio_resource"))
{
Check_Pointer(entry->GetChar());
Check(audio_hardware->GetFrontCard());
audio_hardware->GetFrontCard()->LoadSBK(entry->GetChar());
}
else
{
Verify(entry->IsName("rear_audio_resource"));
Check_Pointer(entry->GetChar());
Check(audio_hardware->GetRearCard());
audio_hardware->GetRearCard()->LoadSBK(entry->GetChar());
}
entry = entry->GetNextEntry();
}
Unregister_Object(name_list);
delete name_list;*/
//
//----------------------------------------------------------------------
// Create static audio objects
//----------------------------------------------------------------------
//
//
// Get static audio stream resource
//
ResourceDescription *resource_description;
Check(application);
Check(application->GetResourceFile());
resource_description =
application->GetResourceFile()->FindResourceDescription(
"StaticAudioStream",
ResourceDescription::StaticAudioStreamResourceType
);
Check(resource_description);
resource_description->Lock();
//
// Parse the audio object stream
//
AudioObjectStream audio_object_stream(resource_description, NULL);
Check(&audio_object_stream);
audio_object_stream.CreateObjects();
resource_description->Unlock();
}
ALuint AL_getBuffer(int index)
{
return g_buffers[index];
}
//
//#############################################################################
// UnloadResources
//#############################################################################
//
void
L4AudioResourceManager::UnloadResources(
)
{
Check(this);
// Check(audio_hardware);
//Unload wav data
if (g_numBuffers > 0)
{
alGetError();
alDeleteBuffers(g_numBuffers,g_buffers);
ALenum error = alGetError();
if (error != AL_NO_ERROR)
{
DEBUG_STREAM << "OpenAL reached an error when attempting to delete its buffers." << std::endl;
}
}
//
//----------------------------------------------------------------------
// Release banks
//----------------------------------------------------------------------
//
// Check(audio_hardware->GetFrontCard());
// audio_hardware->GetFrontCard()->ReleaseAllBanks();
// Check(audio_hardware->GetRearCard());
// audio_hardware->GetRearCard()->ReleaseAllBanks();
}
//
//#############################################################################
// CreateStaticAudioStreamResource
//#############################################################################
//
ResourceDescription::ResourceID
L4AudioResourceManager::CreateStaticAudioStreamResource(
ResourceFile *resource_file
)
{
Check(resource_file);
//
//----------------------------------------------------------------------
// Open the notation file for the static stream resource
//----------------------------------------------------------------------
//
Tell("Opening Audio Script audio\\static.scp\n");
NotationFile notation_file("audio\\static.scp");
Check(&notation_file);
//
//----------------------------------------------------------------------
// Build the static audio object stream
//----------------------------------------------------------------------
//
AudioObjectStream audio_object_stream;
Check(&audio_object_stream);
audio_object_stream.BuildFromNotationFile(&notation_file, resource_file);
Tell("Closed Audio Script\n");
//
//----------------------------------------------------------------------
// Add the resource
//----------------------------------------------------------------------
//
ResourceDescription *res_description;
res_description =
resource_file->AddResourceMemoryStream(
"StaticAudioStream",
ResourceDescription::StaticAudioStreamResourceType,
1,
ResourceDescription::Preload,
&audio_object_stream
);
Check(res_description);
return res_description->resourceID;
}
//
//#############################################################################
// CreateEntityAudioObjects
//#############################################################################
//
void
L4AudioResourceManager::CreateEntityAudioObjects(
Entity *entity,
AudioRepresentation audio_representation
)
{
Check(this);
Check(entity);
Verify(
audio_representation == InternalAudioRepresentation ||
audio_representation == ExternalAudioRepresentation
);
//
//------------------------------------------------------------------------
// Read the audio resource for this entity
//------------------------------------------------------------------------
//
ResourceDescription *audio_resource_description;
Check(application);
Check(application->GetResourceFile());
audio_resource_description =
application->GetResourceFile()->SearchList(
entity->GetResourceID(),
ResourceDescription::AudioStreamListResourceType
);
if (audio_resource_description == NULL)
return;
//
//------------------------------------------------------------------------
// Read the appropriate resource for an internal or external
// representation
//------------------------------------------------------------------------
//
ResourceDescription *stream_resource_description;
Check(application);
Check(application->GetResourceFile());
Check(audio_resource_description);
stream_resource_description =
application->GetResourceFile()->SearchList(
audio_resource_description->resourceID,
(audio_representation == InternalAudioRepresentation) ?
ResourceDescription::InternalAudioStreamResourceType :
ResourceDescription::ExternalAudioStreamResourceType
);
if (stream_resource_description == NULL)
return;
Check(stream_resource_description);
stream_resource_description->Lock();
audio_resource_description->Lock();
//
//------------------------------------------------------------------------
// Make the audio object stream
//------------------------------------------------------------------------
//
AudioObjectStream
audio_object_stream(
stream_resource_description,
entity
);
Check(&audio_object_stream);
audio_object_stream.CreateObjects();
stream_resource_description->Unlock();
audio_resource_description->Unlock();
}
//
//#############################################################################
// DestroyEntityAudioObjects
//#############################################################################
//
void
L4AudioResourceManager::DestroyEntityAudioObjects(Entity *entity)
{
Check(this);
Check(entity);
//
//--------------------------------------------------------------------------
// Stop and delete all audio objects
//--------------------------------------------------------------------------
//
Entity::AudioSocketIterator
iterator(entity);
Component
*component;
AudioComponent
*audio_component;
Check(&iterator);
while ((component = iterator.ReadAndNext()) != NULL)
{
audio_component = Cast_Object(AudioComponent*, component);
Check(audio_component);
audio_component->ReceiveControl(StopAudioControlID, 0.0f);
audio_component->ReceiveControl(FlushMessagesAudioControlID, 0.0f);
}
iterator.DeletePlugs();
}
//
//#############################################################################
// CreateModelAudioResource
//#############################################################################
//
ResourceDescription::ResourceID
L4AudioResourceManager::CreateModelAudioStreamResource(
ResourceFile *resource_file,
const char *model_name,
NotationFile *model_file,
const ResourceDirectories*
)
{
Check(resource_file);
Check_Pointer(model_name);
Check(model_file);
const char *script_name = NULL;
ResourceDescription::ResourceID resource_id_list[3];
size_t list_length = 0;
resource_id_list[0] = ResourceDescription::NullResourceID;
resource_id_list[1] = ResourceDescription::NullResourceID;
resource_id_list[2] = ResourceDescription::NullResourceID;
//
//--------------------------------------------------------------------------
// Check for the external audio script
//--------------------------------------------------------------------------
//
if (model_file->GetEntry("audio", "external", &script_name))
{
//
// See if the resource already exists
//
ResourceDescription *res_description =
resource_file->FindResourceDescription(
script_name,
ResourceDescription::ExternalAudioStreamResourceType
);
//
//-----------------------------------------------------------------------
// If not, create it
//-----------------------------------------------------------------------
//
if (res_description == NULL)
{
//
// Make the file name
//
CString file_name(script_name);
CString prefix("audio\\");
file_name = prefix + file_name;
//
// Build the memory stream
//
Tell("Opening Audio Script " << file_name << "\n");
NotationFile script_file(file_name);
AudioObjectStream audio_object_stream;
Check(&script_file);
Check(&audio_object_stream);
audio_object_stream.BuildFromNotationFile(&script_file, resource_file);
Tell("Closed Audio Script\n");
//
// Add the resource
//
res_description =
resource_file->AddResourceMemoryStream(
script_name,
ResourceDescription::ExternalAudioStreamResourceType,
1,
ResourceDescription::Preload,
&audio_object_stream
);
}
Check(res_description);
resource_id_list[list_length++] = res_description->resourceID;
}
//
//--------------------------------------------------------------------------
// Check for the internal audio script
//--------------------------------------------------------------------------
//
if (model_file->GetEntry("audio", "internal", &script_name))
{
//
// See if the resource already exists
//
ResourceDescription *res_description =
resource_file->FindResourceDescription(
script_name,
ResourceDescription::InternalAudioStreamResourceType
);
//
// If not, create it
//
if (res_description == NULL)
{
//
// Make the file name
//
CString file_name(script_name);
CString prefix("audio\\");
file_name = prefix + file_name;
//
// Build the memory stream
//
Tell("Opening Audio Script " << file_name << "\n");
NotationFile script_file(file_name);
AudioObjectStream audio_object_stream;
Check(&script_file);
Check(&audio_object_stream);
audio_object_stream.BuildFromNotationFile(&script_file, resource_file);
Tell("Closed Audio Script\n");
//
// Add the resource
//
res_description =
resource_file->AddResourceMemoryStream(
script_name,
ResourceDescription::InternalAudioStreamResourceType,
1,
ResourceDescription::Preload,
&audio_object_stream
);
}
Check(res_description);
resource_id_list[list_length++] = res_description->resourceID;
}
//
//--------------------------------------------------------------------------
// Check for the audio entity model
//--------------------------------------------------------------------------
//
const char *audio_entity_model = NULL;
if (model_file->GetEntry("audio", "model", &audio_entity_model))
{
//
// The resource should already exist
//
ResourceDescription *res_description =
resource_file->FindResourceDescription(
audio_entity_model,
ResourceDescription::ModelListResourceType
);
if (res_description == NULL)
{
std::cout << "audio_entity_model == " << audio_entity_model;
Fail("L4AudioResourceManager::CreateModelAudioStreamResource - model not found");
}
Check(res_description);
resource_id_list[list_length++] = res_description->resourceID;
}
//
//--------------------------------------------------------------------------
// If either script has been created, then create the resource list
//--------------------------------------------------------------------------
//
if (list_length > 0)
{
ResourceDescription *res_description =
resource_file->AddResourceList(
model_name,
ResourceDescription::AudioStreamListResourceType,
1,
ResourceDescription::Preload,
resource_id_list,
list_length
);
Check(res_description);
return res_description->resourceID;
}
return ResourceDescription::NullResourceID;
}
Reference in New Issue View Git Blame Copy Permalink