mirror of
https://github.com/scp-fs2open/fs2open.github.com.git
synced 2026-11-11 04:31:35 -10:00
asarium
1001bfb760
The previous API only allowed very limited access to the audio stream system. These changes add full support for playing all types of audio streams via a dedicated API.
587 lines
6.7 KiB
C++
587 lines
6.7 KiB
C++
|
|
#include "enums.h"
|
|
|
|
#include "scripting/ade.h"
|
|
|
|
namespace scripting {
|
|
namespace api {
|
|
|
|
//**********OBJECT: constant class
|
|
//WMC NOTE -
|
|
//While you can have enumeration indexes in any order, make sure
|
|
//that any new enumerations have indexes of NEXT INDEX (see below)
|
|
//or after. Don't forget to increment NEXT INDEX after you're done.
|
|
//=====================================
|
|
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
flag_def_list Enumerations[] = {
|
|
{
|
|
"ALPHABLEND_FILTER",
|
|
LE_ALPHABLEND_FILTER,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ALPHABLEND_NONE",
|
|
LE_ALPHABLEND_NONE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"CFILE_TYPE_NORMAL",
|
|
LE_CFILE_TYPE_NORMAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"CFILE_TYPE_MEMORY_MAPPED",
|
|
LE_CFILE_TYPE_MEMORY_MAPPED,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MOUSE_LEFT_BUTTON",
|
|
LE_MOUSE_LEFT_BUTTON,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MOUSE_RIGHT_BUTTON",
|
|
LE_MOUSE_RIGHT_BUTTON,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MOUSE_MIDDLE_BUTTON",
|
|
LE_MOUSE_MIDDLE_BUTTON,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK",
|
|
LE_ORDER_ATTACK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK_ANY",
|
|
LE_ORDER_ATTACK_ANY,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DEPART",
|
|
LE_ORDER_DEPART,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DISABLE",
|
|
LE_ORDER_DISABLE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DISARM",
|
|
LE_ORDER_DISARM,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DOCK",
|
|
LE_ORDER_DOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_EVADE",
|
|
LE_ORDER_EVADE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_FLY_TO",
|
|
LE_ORDER_FLY_TO,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_FORM_ON_WING",
|
|
LE_ORDER_FORM_ON_WING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_GUARD",
|
|
LE_ORDER_GUARD,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_IGNORE_SHIP",
|
|
LE_ORDER_IGNORE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_KEEP_SAFE_DISTANCE",
|
|
LE_ORDER_KEEP_SAFE_DISTANCE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_PLAY_DEAD",
|
|
LE_ORDER_PLAY_DEAD,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_PLAY_DEAD_PERSISTENT",
|
|
LE_ORDER_PLAY_DEAD_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_REARM",
|
|
LE_ORDER_REARM,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_STAY_NEAR",
|
|
LE_ORDER_STAY_NEAR,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_STAY_STILL",
|
|
LE_ORDER_STAY_STILL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_UNDOCK",
|
|
LE_ORDER_UNDOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_WAYPOINTS",
|
|
LE_ORDER_WAYPOINTS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_WAYPOINTS_ONCE",
|
|
LE_ORDER_WAYPOINTS_ONCE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK_WING",
|
|
LE_ORDER_ATTACK_WING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_GUARD_WING",
|
|
LE_ORDER_GUARD_WING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK_SHIP_CLASS",
|
|
LE_ORDER_ATTACK_SHIP_CLASS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_DEBUG",
|
|
LE_PARTICLE_DEBUG,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_BITMAP",
|
|
LE_PARTICLE_BITMAP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_FIRE",
|
|
LE_PARTICLE_FIRE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_SMOKE",
|
|
LE_PARTICLE_SMOKE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_SMOKE2",
|
|
LE_PARTICLE_SMOKE2,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_PERSISTENT_BITMAP",
|
|
LE_PARTICLE_PERSISTENT_BITMAP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_CAMPAIGN_PERSISTENT",
|
|
LE_SEXPVAR_CAMPAIGN_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_NOT_PERSISTENT",
|
|
LE_SEXPVAR_NOT_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_PLAYER_PERSISTENT",
|
|
LE_SEXPVAR_PLAYER_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_TYPE_NUMBER",
|
|
LE_SEXPVAR_TYPE_NUMBER,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_TYPE_STRING",
|
|
LE_SEXPVAR_TYPE_STRING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"TEXTURE_STATIC",
|
|
LE_TEXTURE_STATIC,
|
|
0
|
|
},
|
|
|
|
{
|
|
"TEXTURE_DYNAMIC",
|
|
LE_TEXTURE_DYNAMIC,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LOCK",
|
|
LE_LOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"UNLOCK",
|
|
LE_UNLOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"NONE",
|
|
LE_NONE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_FRONT",
|
|
LE_SHIELD_FRONT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_LEFT",
|
|
LE_SHIELD_LEFT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_RIGHT",
|
|
LE_SHIELD_RIGHT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_BACK",
|
|
LE_SHIELD_BACK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MISSION_REPEAT",
|
|
LE_MISSION_REPEAT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"NORMAL_CONTROLS",
|
|
LE_NORMAL_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_STEERING_CONTROLS",
|
|
LE_LUA_STEERING_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_FULL_CONTROLS",
|
|
LE_LUA_FULL_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"NORMAL_BUTTON_CONTROLS",
|
|
LE_NORMAL_BUTTON_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_ADDITIVE_BUTTON_CONTROL",
|
|
LE_LUA_ADDITIVE_BUTTON_CONTROL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_OVERRIDE_BUTTON_CONTROL",
|
|
LE_LUA_OVERRIDE_BUTTON_CONTROL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_INTERNAL",
|
|
LE_VM_INTERNAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_EXTERNAL",
|
|
LE_VM_EXTERNAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_TRACK",
|
|
LE_VM_TRACK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_DEAD_VIEW",
|
|
LE_VM_DEAD_VIEW,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_CHASE",
|
|
LE_VM_CHASE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_OTHER_SHIP",
|
|
LE_VM_OTHER_SHIP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_EXTERNAL_CAMERA_LOCKED",
|
|
LE_VM_EXTERNAL_CAMERA_LOCKED,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_CAMERA_LOCKED",
|
|
LE_VM_CAMERA_LOCKED,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_WARP_CHASE",
|
|
LE_VM_WARP_CHASE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_UP",
|
|
LE_VM_PADLOCK_UP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_REAR",
|
|
LE_VM_PADLOCK_REAR,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_LEFT",
|
|
LE_VM_PADLOCK_LEFT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_RIGHT",
|
|
LE_VM_PADLOCK_RIGHT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_WARPIN_ANCHOR",
|
|
LE_VM_WARPIN_ANCHOR,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_TOPDOWN",
|
|
LE_VM_TOPDOWN,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_FREECAMERA",
|
|
LE_VM_FREECAMERA,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_CENTERING",
|
|
LE_VM_CENTERING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MESSAGE_PRIORITY_LOW",
|
|
LE_MESSAGE_PRIORITY_LOW,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MESSAGE_PRIORITY_NORMAL",
|
|
LE_MESSAGE_PRIORITY_NORMAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MESSAGE_PRIORITY_HIGH",
|
|
LE_MESSAGE_PRIORITY_HIGH,
|
|
0
|
|
},
|
|
{
|
|
"OPTION_TYPE_SELECTION",
|
|
LE_OPTION_TYPE_SELECTION,
|
|
0
|
|
},
|
|
{
|
|
"OPTION_TYPE_RANGE",
|
|
LE_OPTION_TYPE_RANGE,
|
|
0
|
|
},
|
|
{
|
|
"AUDIOSTREAM_EVENTMUSIC",
|
|
LE_ASF_EVENTMUSIC,
|
|
0
|
|
},
|
|
{
|
|
"AUDIOSTREAM_MENUMUSIC",
|
|
LE_ASF_MENUMUSIC,
|
|
0
|
|
},
|
|
{
|
|
"AUDIOSTREAM_VOICE",
|
|
LE_ASF_VOICE,
|
|
0
|
|
},
|
|
};
|
|
|
|
//DO NOT FORGET to increment NEXT INDEX: !!!!!!!!!!!!!
|
|
|
|
size_t Num_enumerations = sizeof(Enumerations) / sizeof(flag_def_list);
|
|
|
|
|
|
enum_h::enum_h() {
|
|
index = -1;
|
|
is_constant = false;
|
|
}
|
|
enum_h::enum_h(int n_index) {
|
|
index = n_index;
|
|
is_constant = false;
|
|
}
|
|
bool enum_h::IsValid() const { return (index > -1 && index < ENUM_NEXT_INDEX); }
|
|
|
|
ADE_OBJ(l_Enum, enum_h, "enumeration", "Enumeration object");
|
|
|
|
ADE_FUNC(__newindex,
|
|
l_Enum,
|
|
"enumeration",
|
|
"Sets enumeration to specified value (if it is not a global",
|
|
"enumeration",
|
|
"enumeration") {
|
|
enum_h* e1 = NULL, * e2 = NULL;
|
|
if (!ade_get_args(L, "oo", l_Enum.GetPtr(&e1), l_Enum.GetPtr(&e2))) {
|
|
return ade_set_error(L, "o", l_Enum.Set(enum_h()));
|
|
}
|
|
|
|
if (!e1->is_constant) {
|
|
e1->index = e2->index;
|
|
}
|
|
|
|
return ade_set_args(L, "o", l_Enum.Set(*e1));
|
|
}
|
|
|
|
ADE_FUNC(__tostring,
|
|
l_Enum,
|
|
NULL,
|
|
"Returns enumeration name",
|
|
"string",
|
|
"Enumeration name, or \"<INVALID>\" if invalid") {
|
|
enum_h* e = NULL;
|
|
if (!ade_get_args(L, "o", l_Enum.GetPtr(&e))) {
|
|
return ade_set_args(L, "s", "<INVALID>");
|
|
}
|
|
|
|
if (e->index < 1 || e->index >= ENUM_NEXT_INDEX) {
|
|
return ade_set_args(L, "s", "<INVALID>");
|
|
}
|
|
|
|
uint i;
|
|
for (i = 0; i < Num_enumerations; i++) {
|
|
if (Enumerations[i].def == e->index) {
|
|
return ade_set_args(L, "s", Enumerations[i].name);
|
|
}
|
|
}
|
|
|
|
return ade_set_args(L, "s", "<INVALID>");
|
|
}
|
|
|
|
ADE_FUNC(__eq,
|
|
l_Enum,
|
|
"enumeration",
|
|
"Compares the two enumerations for equality",
|
|
"boolean",
|
|
"true if equal, false otherwise") {
|
|
enum_h* e1 = NULL;
|
|
enum_h* e2 = NULL;
|
|
|
|
if (!ade_get_args(L, "oo", l_Enum.GetPtr(&e1), l_Enum.GetPtr(&e2))) {
|
|
return ade_set_error(L, "o", l_Enum.Set(enum_h()));
|
|
}
|
|
|
|
if (e1 == NULL || e2 == NULL) {
|
|
return ADE_RETURN_FALSE;
|
|
}
|
|
|
|
return ade_set_args(L, "b", e1->index == e2->index);
|
|
}
|
|
|
|
}
|
|
}
|