Files
CydandClaude Fable 5 fdd9ac9d97 Initial import: Tesla Release 4.10 (Tesla:BattleTech & Tesla:Red Planet)
Archival snapshot of the Virtual World Entertainment Tesla cockpit
software, 1994-1996: MUNGA engine and L4 pod layer source (Borland
C++ 5.0), BT/RP game code, and game content (models, audio, maps,
gauges, Division renderer data). Includes third-party libraries:
Division dVS/DPL graphics, HMI SOS audio, WATTCP networking.

Files are preserved byte-for-byte (.gitattributes disables all
line-ending conversion). README.md documents the layout, target
hardware, and toolchain.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 13:21:58 -05:00

1594 lines
43 KiB
C++

//===========================================================================//
// File: audwthr.hh //
// Project: MUNGA Brick: Audio Renderer //
// Contents: //
//---------------------------------------------------------------------------//
// Date Who Modification //
// -------- --- -----------------------------------------------------------//
// 01/31/95 ECH Initial coding. //
//---------------------------------------------------------------------------//
// Copyright (C) 1995, Virtual World Entertainment, Inc. //
// All Rights reserved worldwide //
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL //
//===========================================================================//
#if !defined(AUDWTHR_HPP)
# define AUDWTHR_HPP
# if !defined(WATCHER_HPP)
# include <watcher.hpp>
# endif
# if !defined(AUDIO_HPP)
# include <audio.hpp>
# endif
# if !defined(SIMULATE_HPP)
# include <simulate.hpp>
# endif
# if !defined(SIMULATE_HPP)
# include <objstrm.hpp>
# endif
# if !defined(CONTROLS_HPP)
# include <controls.hpp>
# endif
# if !defined(MOTION_HPP)
# include <motion.hpp>
# endif
//##########################################################################
//######################## AudioIdleWatcher ##########################
//##########################################################################
class AudioIdleWatcher:
public Component
{
public:
//
//-----------------------------------------------------------------------
// Constructor, Destructor, Testing
//-----------------------------------------------------------------------
//
AudioIdleWatcher(
PlugStream *stream,
Entity *entity
);
void
AudioIdleWatcherX(
AudioComponent *audio_component,
Entity *entity
);
~AudioIdleWatcher();
Logical
TestInstance() const;
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
//
//-----------------------------------------------------------------------
// ReleaseLinkHandler
//-----------------------------------------------------------------------
//
void
ReleaseLinkHandler(
Socket *socket,
Plug *plug
);
//
//-----------------------------------------------------------------------
// Execute
//-----------------------------------------------------------------------
//
void
Execute();
protected:
//
//-----------------------------------------------------------------------
// Protected data
//-----------------------------------------------------------------------
//
SlotOf<AudioComponent*>
audioComponentSocket;
};
//##########################################################################
//########################### AudioWatcherOf #########################
//##########################################################################
template <class T> class AudioWatcherOf:
public AttributeWatcherOf<T>
{
public:
//
//--------------------------------------------------------------------
// Constructor, Destructor, Testing
//--------------------------------------------------------------------
//
AudioWatcherOf(
PlugStream *stream,
Entity *entity
);
~AudioWatcherOf();
Logical
TestInstance() const;
//
//--------------------------------------------------------------------
// BuildFromPage
//--------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
//
//--------------------------------------------------------------------
// ReleaseLinkHandler
//--------------------------------------------------------------------
//
void
ReleaseLinkHandler(
Socket *socket,
Plug *plug
);
protected:
//
//--------------------------------------------------------------------
// Protected data
//--------------------------------------------------------------------
//
SlotOf<AudioComponent*>
audioComponentSocket;
};
//~~~~~~~~~~~~~~~~~~~~~~~~ AudioWatcherOf templates ~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioWatcherOf<T>::AudioWatcherOf(
PlugStream *stream,
Entity *entity
):
AttributeWatcherOf<T>(stream, entity),
audioComponentSocket(this)
{
//
// Get audio component
//
AudioComponent *audio_component;
PlugStream_ReadObjectIDAndFindPlug(stream, &audio_component);
Check(audio_component);
audioComponentSocket.Add(audio_component);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioWatcherOf<T>::~AudioWatcherOf()
{
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioWatcherOf<T>::BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
)
{
AttributeWatcherOf<T>::BuildFromPage(
stream, name_list, class_ID, object_ID
);
//
// Store audio_component object ID
//
CString audio_component_name("audio_component");
PlugStream_FindEntryAndWriteObjectID(
stream, name_list, audio_component_name
);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> Logical
AudioWatcherOf<T>::TestInstance() const
{
AttributeWatcherOf<T>::TestInstance();
Check(&audioComponentSocket);
return True;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioWatcherOf<T>::ReleaseLinkHandler(
Socket *socket,
Plug *plug
)
{
if (socket == &audioComponentSocket)
{
Check(&audioComponentSocket);
Check(socket);
Unregister_Object(this);
delete this;
}
else
{
AttributeWatcherOf<T>::ReleaseLinkHandler(socket, plug);
}
}
//##########################################################################
//########################### AudioTriggerOf #########################
//##########################################################################
template <class T> class AudioTriggerOf:
public AudioWatcherOf<T>
{
public:
//
//--------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------
//
AudioTriggerOf(
PlugStream *stream,
Entity *entity
);
~AudioTriggerOf();
//
//--------------------------------------------------------------------
// BuildFromPage
//--------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//--------------------------------------------------------------------
// SendNotificationOfChange
//--------------------------------------------------------------------
//
void
SendNotificationOfChange();
//
//--------------------------------------------------------------------
// ExtractInterestingValue
//--------------------------------------------------------------------
//
virtual AudioControlValue
ExtractInterestingValue(const T *attribute_ptr);
private:
//
//--------------------------------------------------------------------
// Private data
//--------------------------------------------------------------------
//
Scalar
attributeValueThreshold;
Logical
inverseTrigger;
AudioControlID
controlIDOn,
controlIDOff;
AudioControlValue
controlValueOn,
controlValueOff;
Logical
triggerOn;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~ AudioTriggerOf templates ~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioTriggerOf<T>::AudioTriggerOf(
PlugStream *stream,
Entity *entity
):
AudioWatcherOf<T>(stream, entity)
{
Check(simulation);
simulation->AddAudioWatcher(this);
//
// Get other fields
//
MemoryStream_Read(stream, &attributeValueThreshold);
MemoryStream_Read(stream, &inverseTrigger);
MemoryStream_Read(stream, &controlIDOn);
MemoryStream_Read(stream, &controlIDOff);
MemoryStream_Read(stream, &controlValueOn);
MemoryStream_Read(stream, &controlValueOff);
triggerOn = False;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioTriggerOf<T>::~AudioTriggerOf()
{
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioTriggerOf<T>::BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
)
{
AudioWatcherOf<T>::BuildFromPage(stream, name_list, class_ID, object_ID);
//
// Store other fields
//
MEM_STRM_WRITE_ENTRY(
*stream, name_list, AudioControlValue, attribute_value_threshold
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Logical, inverse_trigger
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Enumeration, control_ID_on
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Enumeration, control_ID_off
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, AudioControlValue, control_value_on
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, AudioControlValue, control_value_off
);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioTriggerOf<T>::SendNotificationOfChange()
{
//
// Get current value
//
T *attribute_ptr = GetCurrentPointer();
Check_Pointer(attribute_ptr);
Scalar current_value = ExtractInterestingValue(attribute_ptr);
if (triggerOn)
{
if (
(!inverseTrigger && current_value <= attributeValueThreshold) ||
(inverseTrigger && current_value >= attributeValueThreshold)
)
{
Check(&audioComponentSocket);
Check(audioComponentSocket.GetCurrent());
#if 1
audioComponentSocket.GetCurrent()->ReceiveControl(
controlIDOff,
controlValueOff
);
#else
audioComponentSocket.GetCurrent()->PostReceiveControl(
controlIDOff,
controlValueOff
);
#endif
triggerOn = False;
}
}
else
{
if (
(!inverseTrigger && current_value > attributeValueThreshold) ||
(inverseTrigger && current_value < attributeValueThreshold)
)
{
Check(&audioComponentSocket);
Check(audioComponentSocket.GetCurrent());
#if 1
audioComponentSocket.GetCurrent()->ReceiveControl(
controlIDOn,
controlValueOn
);
#else
audioComponentSocket.GetCurrent()->PostReceiveControl(
controlIDOn,
controlValueOn
);
#endif
triggerOn = True;
}
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> AudioControlValue
AudioTriggerOf<T>::ExtractInterestingValue(const T*)
{
Fail("AudioTriggerOf<T>::ExtractInterestingValue - Should never reach here");
return 0;
}
//##########################################################################
//########################### AudioScaleOf ###########################
//##########################################################################
template <class T> class AudioScaleOf:
public AudioWatcherOf<T>
{
public:
//
//--------------------------------------------------------------------
// Constructor, Destructor
//--------------------------------------------------------------------
//
AudioScaleOf(
PlugStream *stream,
Entity *entity
);
~AudioScaleOf();
//
//--------------------------------------------------------------------
// BuildFromPage
//--------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//--------------------------------------------------------------------
// SendNotificationOfChange
//--------------------------------------------------------------------
//
void
SendNotificationOfChange();
//
//--------------------------------------------------------------------
// ExtractInterestingValue
//--------------------------------------------------------------------
//
virtual AudioControlValue
ExtractInterestingValue(const T *attribute_ptr);
private:
//
//--------------------------------------------------------------------
// Private data
//--------------------------------------------------------------------
//
Scalar
attributeValueBoundary1,
attributeValueBoundary2;
AudioControlID
controlID;
AudioControlValue
controlValueBoundary1,
controlValueBoundary2;
Scalar
exponent;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~ AudioScaleOf templates ~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioScaleOf<T>::AudioScaleOf(
PlugStream *stream,
Entity *entity
):
AudioWatcherOf<T>(stream, entity)
{
//
// Get audio component
//
AudioComponent *audio_component = audioComponentSocket.GetCurrent();
Check(audio_component);
audio_component->AddWatcher(this);
//
// Get other fields
//
MemoryStream_Read(stream, &attributeValueBoundary1);
MemoryStream_Read(stream, &attributeValueBoundary2);
MemoryStream_Read(stream, &controlID);
MemoryStream_Read(stream, &controlValueBoundary1);
MemoryStream_Read(stream, &controlValueBoundary2);
MemoryStream_Read(stream, &exponent);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioScaleOf<T>::~AudioScaleOf()
{
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioScaleOf<T>::BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
)
{
AudioWatcherOf<T>::BuildFromPage(stream, name_list, class_ID, object_ID);
//
// Store other fields
//
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Scalar, attribute_value_boundary1
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Scalar, attribute_value_boundary2
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Enumeration, control_ID
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, AudioControlValue, control_value_boundary1
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, AudioControlValue, control_value_boundary2
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Scalar, exponent
);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioScaleOf<T>::SendNotificationOfChange()
{
//
// Get current value
//
T *attribute_ptr = GetCurrentPointer();
Check_Pointer(attribute_ptr);
Scalar current_value = ExtractInterestingValue(attribute_ptr);
//
// Clamp value within range
//
Scalar min_attribute_boundary =
Min(attributeValueBoundary1, attributeValueBoundary2);
Scalar max_attribute_boundary =
Max(attributeValueBoundary1, attributeValueBoundary2);
Clamp(current_value, min_attribute_boundary, max_attribute_boundary);
Verify(
current_value >= min_attribute_boundary &&
current_value <= max_attribute_boundary
);
//
// Calculate scale
//
Verify(!Small_Enough(attributeValueBoundary2 - attributeValueBoundary1));
Scalar current_scale =
(current_value - attributeValueBoundary1) /
(attributeValueBoundary2 - attributeValueBoundary1);
Verify(current_scale >= -1.0f && current_scale <= 1.0f);
//
// Apply exponent
//
if (exponent != 1.0f)
{
Scalar old_scale = current_scale; // HACK - for debugging
current_scale = pow(old_scale, exponent);
#if DEBUG_LEVEL>0
if (!(current_scale >= -1.0f && current_scale <= 1.0f))
{
Dump(old_scale);
Dump(exponent);
Dump(current_scale);
}
#endif
}
Verify(current_scale >= -1.0f && current_scale <= 1.0f);
//
// Calculate control value
//
AudioControlValue control_value =
current_scale * (controlValueBoundary2 - controlValueBoundary1) +
controlValueBoundary1;
#if DEBUG_LEVEL>0
AudioControlValue min_control_boundary =
Min(controlValueBoundary1, controlValueBoundary2);
AudioControlValue max_control_boundary =
Max(controlValueBoundary1, controlValueBoundary2);
Verify(
control_value >= min_control_boundary &&
control_value <= max_control_boundary
);
#endif
Check(&audioComponentSocket);
Check(audioComponentSocket.GetCurrent());
audioComponentSocket.GetCurrent()->ReceiveControl(
controlID,
control_value
);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> AudioControlValue
AudioScaleOf<T>::ExtractInterestingValue(const T*)
{
Fail("AudioScaleOf<T>::ExtractInterestingValue - Should never reach here");
return 0;
}
//##########################################################################
//########################## AudioMatchOf ############################
//##########################################################################
template <class T> class AudioMatchOf:
public AudioWatcherOf<T>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioMatchOf(
PlugStream *stream,
Entity *entity
);
~AudioMatchOf();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// SendNotificationOfChange
//-----------------------------------------------------------------------
//
void
SendNotificationOfChange();
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
virtual int
ExtractInterestingValue(const T *attribute_ptr);
private:
//
//-----------------------------------------------------------------------
// Private data
//-----------------------------------------------------------------------
//
int
attributeMatchValue;
AudioControlID
controlID;
AudioControlValue
controlValue;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~ AudioMatchOf templates ~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioMatchOf<T>::AudioMatchOf(
PlugStream *stream,
Entity *entity
):
AudioWatcherOf<T>(stream, entity)
{
Check(simulation);
simulation->AddAudioWatcher(this);
//
// Get other fields
//
MemoryStream_Read(stream, &attributeMatchValue);
MemoryStream_Read(stream, &controlID);
MemoryStream_Read(stream, &controlValue);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioMatchOf<T>::~AudioMatchOf()
{
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioMatchOf<T>::BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
)
{
AudioWatcherOf<T>::BuildFromPage(stream, name_list, class_ID, object_ID);
//
// Store other fields
//
MEM_STRM_WRITE_ENTRY(
*stream, name_list, int, attribute_match_value
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Enumeration, control_ID
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, AudioControlValue, control_value
);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioMatchOf<T>::SendNotificationOfChange()
{
//
// Get current value
//
T *attribute_ptr = GetCurrentPointer();
Check_Pointer(attribute_ptr);
int current_value = ExtractInterestingValue(attribute_ptr);
if (current_value == attributeMatchValue)
{
Check(&audioComponentSocket);
Check(audioComponentSocket.GetCurrent());
#if 1
audioComponentSocket.GetCurrent()->ReceiveControl(
controlID,
controlValue
);
#else
audioComponentSocket.GetCurrent()->PostReceiveControl(
controlID,
controlValue
);
#endif
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> int
AudioMatchOf<T>::ExtractInterestingValue(const T*)
{
Fail("AudioMatchOf<T>::ExtractInterestingValue - Should never reach here");
return 0;
}
//##########################################################################
//########################## AudioDeltaOf ############################
//##########################################################################
template <class T> class AudioDeltaOf:
public AudioWatcherOf<T>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioDeltaOf(
PlugStream *stream,
Entity *entity
);
~AudioDeltaOf();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// SendNotificationOfChange
//-----------------------------------------------------------------------
//
void
SendNotificationOfChange();
private:
//
//-----------------------------------------------------------------------
// Private data
//-----------------------------------------------------------------------
//
T
lastValue;
T
deltaTrigger;
AudioControlID
controlID;
AudioControlValue
controlValue;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~ AudioDeltaOf templates ~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioDeltaOf<T>::AudioDeltaOf(
PlugStream *stream,
Entity *entity
):
AudioWatcherOf<T>(stream, entity)
{
Check(simulation);
simulation->AddAudioWatcher(this);
MemoryStream_Read(stream, &controlID);
MemoryStream_Read(stream, &controlValue);
MemoryStream_Read(stream, &deltaTrigger);
lastValue = GetCurrentValue();
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T>
AudioDeltaOf<T>::~AudioDeltaOf()
{
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioDeltaOf<T>::BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
)
{
AudioWatcherOf<T>::BuildFromPage(stream, name_list, class_ID, object_ID);
//
// control_ID, control_value
//
MEM_STRM_WRITE_ENTRY(
*stream, name_list, Enumeration, control_ID
);
MEM_STRM_WRITE_ENTRY(
*stream, name_list, AudioControlValue, control_value
);
//
// delta_value
//
T delta_trigger = SMALL;
if (name_list->FindData("delta_trigger") != NULL)
{
Convert_From_Ascii(
(const char *)name_list->FindData("delta_trigger"),
&delta_trigger
);
}
MemoryStream_Write(stream, &delta_trigger);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
template <class T> void
AudioDeltaOf<T>::SendNotificationOfChange()
{
T *attribute_ptr;
T delta_change;
attribute_ptr = GetCurrentPointer();
Check_Pointer(attribute_ptr);
delta_change = *attribute_ptr - lastValue;
if (Abs(delta_change) >= deltaTrigger)
{
lastValue = *attribute_ptr;
Check(&audioComponentSocket);
Check(audioComponentSocket.GetCurrent());
#if 1
audioComponentSocket.GetCurrent()->ReceiveControl(
controlID,
controlValue
);
#else
audioComponentSocket.GetCurrent()->PostReceiveControl(
controlID,
controlValue
);
#endif
}
}
//##########################################################################
//########################### AudioMotionTrigger #####################
//##########################################################################
enum MotionType
{
LinearMotionType = 0,
AngularMotionType = 1
};
inline MemoryStream&
MemoryStream_Read(
MemoryStream *stream,
MotionType *ptr
)
{return stream->ReadBytes(ptr, sizeof(*ptr));}
inline MemoryStream&
MemoryStream_Write(
MemoryStream *stream,
const MotionType *ptr
)
{return stream->WriteBytes(ptr, sizeof(*ptr));}
enum MotionValue
{
XMotionValue = 0,
YMotionValue = 1,
ZMotionValue = 2,
LengthMotionValue = 3
};
inline MemoryStream&
MemoryStream_Read(
MemoryStream *stream,
MotionValue *ptr
)
{return stream->ReadBytes(ptr, sizeof(*ptr));}
inline MemoryStream&
MemoryStream_Write(
MemoryStream *stream,
const MotionValue *ptr
)
{return stream->WriteBytes(ptr, sizeof(*ptr));}
class AudioMotionTrigger:
public AudioTriggerOf<Motion>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioMotionTrigger(
PlugStream *stream,
Entity *entity
);
~AudioMotionTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
AudioControlValue
ExtractInterestingValue(const Motion *attribute_ptr);
private:
//
//-----------------------------------------------------------------------
// DumpValue
//-----------------------------------------------------------------------
//
void
DumpValue(const Motion *attribute_ptr);
//
//-----------------------------------------------------------------------
// Private data
//-----------------------------------------------------------------------
//
MotionType
motionType;
MotionValue
motionValue;
};
//##########################################################################
//########################### AudioMotionScale #######################
//##########################################################################
class AudioMotionScale:
public AudioScaleOf<Motion>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioMotionScale(
PlugStream *stream,
Entity *entity
);
~AudioMotionScale();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
AudioControlValue
ExtractInterestingValue(const Motion *attribute_ptr);
private:
//
//-----------------------------------------------------------------------
// DumpValue
//-----------------------------------------------------------------------
//
void
DumpValue(const Motion *attribute_ptr);
//
//-----------------------------------------------------------------------
// Private data
//-----------------------------------------------------------------------
//
MotionType
motionType;
MotionValue
motionValue;
};
//##########################################################################
//########################### AudioHingeScale #########################
//##########################################################################
class AudioHingeScale:
public AudioScaleOf<Hinge>
{
public:
//
//--------------------------------------------------------------------
// Constructor, Destructor, Testing
//--------------------------------------------------------------------
//
AudioHingeScale(
PlugStream *stream,
Entity *entity
);
~AudioHingeScale();
protected:
//
//--------------------------------------------------------------------
// ExtractInterestingValue
//--------------------------------------------------------------------
//
AudioControlValue
ExtractInterestingValue(const Hinge *attribute_ptr);
private:
//
//-----------------------------------------------------------------------
// DumpValue
//-----------------------------------------------------------------------
//
void
DumpValue(const Hinge *attribute_ptr);
};
//##########################################################################
//########################### AudioScalarTrigger #####################
//##########################################################################
class AudioScalarTrigger:
public AudioTriggerOf<Scalar>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioScalarTrigger(
PlugStream *stream,
Entity *entity
);
~AudioScalarTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
AudioControlValue
ExtractInterestingValue(const Scalar *attribute_ptr);
};
//##########################################################################
//###################### AudioScalarDeltaTrigger #####################
//##########################################################################
class AudioScalarDeltaTrigger:
public AudioDeltaOf<Scalar>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioScalarDeltaTrigger(
PlugStream *stream,
Entity *entity
);
~AudioScalarDeltaTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
};
//##########################################################################
//########################### AudioScalarScale ########################
//##########################################################################
class AudioScalarScale:
public AudioScaleOf<Scalar>
{
public:
//
//--------------------------------------------------------------------
// Constructor, Destructor, Testing
//--------------------------------------------------------------------
//
AudioScalarScale(
PlugStream *stream,
Entity *entity
);
~AudioScalarScale();
protected:
//
//--------------------------------------------------------------------
// ExtractInterestingValue
//--------------------------------------------------------------------
//
AudioControlValue
ExtractInterestingValue(const Scalar *attribute_ptr);
};
//##########################################################################
//######################## AudioLogicalTrigger #######################
//##########################################################################
class AudioLogicalTrigger:
public AudioMatchOf<Logical>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioLogicalTrigger(
PlugStream *stream,
Entity *entity
);
~AudioLogicalTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
int
ExtractInterestingValue(const Logical *attribute_ptr);
};
//##########################################################################
//###################### AudioEnumerationTrigger #####################
//##########################################################################
class AudioEnumerationTrigger:
public AudioMatchOf<Enumeration>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioEnumerationTrigger(
PlugStream *stream,
Entity *entity
);
~AudioEnumerationTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
int
ExtractInterestingValue(const Enumeration *attribute_ptr);
};
//##########################################################################
//################### AudioEnumerationDeltaTrigger ###################
//##########################################################################
class AudioEnumerationDeltaTrigger:
public AudioDeltaOf<Enumeration>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioEnumerationDeltaTrigger(
PlugStream *stream,
Entity *entity
);
~AudioEnumerationDeltaTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
};
//##########################################################################
//####################### AudioIntegerTrigger ########################
//##########################################################################
class AudioIntegerTrigger:
public AudioTriggerOf<int>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioIntegerTrigger(
PlugStream *stream,
Entity *entity
);
~AudioIntegerTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
AudioControlValue
ExtractInterestingValue(const int *attribute_ptr);
};
//##########################################################################
//################### AudioControlsButtonTrigger #####################
//##########################################################################
class AudioControlsButtonTrigger:
public AudioTriggerOf<ControlsButton>
{
public:
//
//-----------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------
//
AudioControlsButtonTrigger(
PlugStream *stream,
Entity *entity
);
~AudioControlsButtonTrigger();
//
//-----------------------------------------------------------------------
// BuildFromPage
//-----------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//-----------------------------------------------------------------------
// ExtractInterestingValue
//-----------------------------------------------------------------------
//
AudioControlValue
ExtractInterestingValue(const ControlsButton *attribute_ptr);
};
//##########################################################################
//######################## AudioStateWatcher #########################
//##########################################################################
class AudioStateWatcher:
public AudioWatcherOf<StateIndicator>
{
public:
//
//--------------------------------------------------------------------
// Destructor
//--------------------------------------------------------------------
//
~AudioStateWatcher();
protected:
//
//--------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------
//
AudioStateWatcher(
PlugStream *stream,
Entity *entity
);
//
//--------------------------------------------------------------------
// SendNotificationOfChange
//--------------------------------------------------------------------
//
void
SendNotificationOfChange();
//
//--------------------------------------------------------------------
// StateChanged
//--------------------------------------------------------------------
//
virtual void
StateChanged(
Enumeration old_state,
Enumeration new_state
);
};
//##########################################################################
//########################### AudioStateTrigger ######################
//##########################################################################
class AudioStateTrigger:
public AudioStateWatcher
{
public:
//
//--------------------------------------------------------------------
// Constructor, Destructor
//--------------------------------------------------------------------
//
AudioStateTrigger(
PlugStream *stream,
Entity *entity
);
~AudioStateTrigger();
//
//--------------------------------------------------------------------
// BuildFromPage
//--------------------------------------------------------------------
//
static void
BuildFromPage(
PlugStream *stream,
NameList *name_list,
ClassID class_ID,
ObjectID object_ID
);
protected:
//
//--------------------------------------------------------------------
// StateChanged
//--------------------------------------------------------------------
//
void
StateChanged(
Enumeration old_state,
Enumeration new_state
);
private:
//
//--------------------------------------------------------------------
// Private data
//--------------------------------------------------------------------
//
Enumeration
triggerState;
Logical
inverseTrigger;
AudioControlID
controlID;
AudioControlValue
controlValue;
Logical
excludeTransition;
Enumeration
excludeState;
};
#endif