ParticleEffectIndex ParticleManager::getEffectByName(const SCP_string& name) {
if (name.empty()) {
// Don't allow empty names, it's a special case for effects that should not be referenced.
return -1;
}
auto foundIterator = find_if(m_effects.begin(), m_effects.end(),
[&name](const std::shared_ptr<ParticleEffect>& ptr) {
return !stricmp(ptr->getName().c_str(), name.c_str());
});
if (foundIterator == m_effects.end()) {
return -1;
}
return distance(m_effects.begin(), foundIterator);
}
ParticleEffectIndex parseEffect(const SCP_string& objectName) {
SCP_string name;
stuff_string(name, F_NAME);
auto idx = ParticleManager::get()->getEffectByName(name);
if (idx < 0) {
if (objectName.empty()) {
error_display(0, "Unknown particle effect name '%s' encountered!", name.c_str());
} else {
error_display(0, "Unknown particle effect name '%s' encountered while parsing '%s'!", name.c_str(),
objectName.c_str());
}
}
return idx;
}
// init the capture system
// exit: 0 -> success
// !0 -> failure
int dscap_init()
{
if (dscap_inited) {
return 0;
}
bool rval = openal_init_device(NULL, &capture_dev_name);
if ( !rval || capture_dev_name.empty() ) {
dscap_inited = 0;
return -1;
}
dscap_inited = 1;
return 0;
}
void credits_parse_table(const char* filename)
{
try
{
read_file_text(filename, CF_TYPE_TABLES);
reset_parse();
// any metadata?
if (optional_string("$Music:"))
{
stuff_string(Credits_music_name, F_NAME, NAME_LENGTH);
}
if (optional_string("$Number of Images:"))
{
int temp;
stuff_int(&temp);
if (temp > 0)
Credits_num_images = temp;
}
if (optional_string("$Start Image Index:"))
{
stuff_int(&Credits_artwork_index);
// bounds check
if (Credits_artwork_index < 0)
{
Credits_artwork_index = 0;
}
else if (Credits_artwork_index >= Credits_num_images)
{
Credits_artwork_index = Credits_num_images - 1;
}
}
if (optional_string("$Text scroll rate:"))
{
stuff_float(&Credits_scroll_rate);
if (Credits_scroll_rate < 0.01f)
Credits_scroll_rate = 0.01f;
}
if (optional_string("$Artworks display time:"))
{
stuff_float(&Credits_artwork_display_time);
if (Credits_artwork_display_time < 0.01f)
Credits_artwork_display_time = 0.01f;
}
if (optional_string("$Artworks fade time:"))
{
stuff_float(&Credits_artwork_fade_time);
if (Credits_artwork_fade_time < 0.01f)
Credits_artwork_fade_time = 0.01f;
}
if (optional_string("$SCP Credits position:"))
{
char mode[NAME_LENGTH];
stuff_string(mode, F_NAME, NAME_LENGTH);
if (!stricmp(mode, "Start"))
SCP_credits_position = START;
else if (!stricmp(mode, "End"))
SCP_credits_position = END;
else
Warning(LOCATION, "Unknown credits position mode \"%s\".", mode);
}
ignore_white_space();
SCP_string credits_text;
SCP_string line;
SCP_vector<int> charNum;
SCP_vector<const char*> lines;
int numLines = -1;
bool first_run = true;
while (!check_for_string_raw("#end"))
{
// Read in a line of text
stuff_string_line(line);
// This is a bit odd but it means if a total conversion uses different credits the
// Volition credit won't happen
// Also don't append the default credits anymore when there was already a parsed table
if (first_run && !Credits_parsed && !line.compare(mod_check))
{
credits_text.append(unmodified_credits);
}
first_run = false;
if (line.empty())
{
// If the line is empty then just append a newline, don't bother with splitting it first
credits_text.append("\n");
}
else
{
// split_str doesn't take care of this.
charNum.clear();
// Split the string into multiple lines if it's too long
numLines = split_str(line.c_str(), Credits_text_coords[gr_screen.res][2], charNum, lines, -1);
// Make sure that we have valid data
Assertion(lines.size() == (size_t)numLines, "split_str reported %d lines but vector contains " SIZE_T_ARG " entries!", numLines, lines.size());
Assertion(lines.size() <= charNum.size(),
"Something has gone wrong while splitting strings. Got " SIZE_T_ARG " lines but only " SIZE_T_ARG " chacter lengths.",
lines.size(), charNum.size());
// Now add all splitted lines to the credit text and append a newline to the end
for (int i = 0; i < numLines; i++)
{
credits_text.append(SCP_string(lines[i], charNum[i]));
credits_text.append("\n");
}
}
}
Credit_text_parts.push_back(credits_text);
Credits_parsed = true;
}
catch (const parse::ParseException& e)
{
mprintf(("TABLES: Unable to parse '%s'! Error message = %s.\n", filename, e.what()));
return;
}
}
void debug_console(void (*_func)(void))
{
int done = 0;
while( key_inkey() ) {
os_poll();
}
if ( !debug_inited ) {
dc_init();
}
dc_draw(TRUE);
while (!done) {
// poll the os
os_poll();
int k = key_inkey();
switch( k ) {
case KEY_SHIFTED+KEY_ENTER:
case KEY_ESC:
done = TRUE;
break;
case KEY_BACKSP:
if (!dc_command_buf.empty()) {
dc_command_buf.erase(dc_command_buf.size() - 1);
}
break;
case KEY_F3:
case KEY_UP:
if (last_oldcommand < (dc_history.end() - 1)) {
++last_oldcommand;
}
dc_command_buf = *last_oldcommand;
break;
case KEY_DOWN:
if (last_oldcommand > dc_history.begin()) {
--last_oldcommand;
}
dc_command_buf = *last_oldcommand;
break;
case KEY_PAGEUP:
if (dc_scroll_y > 1) {
dc_scroll_y--;
}
break;
case KEY_PAGEDOWN:
if (dc_scroll_y < (DBROWS - DROWS)) {
dc_scroll_y++;
} else {
dc_scroll_y = (DBROWS - DROWS);
}
break;
case KEY_ENTER:
dc_scroll_y = (DBROWS - DROWS); // Set the scroll to look at the bottom
last_oldcommand = dc_history.begin(); // Reset the last oldcommand
lastline = 0; // Reset the line counter
// Clear the command line on the window, but don't print the prompt until the command has processed
// Stuff a copy of the command line onto the history
// Search for the command
// If not found:
// abort,
// dc_printf("Error: Invalid or Missing command %s", cmd.c_str()), and
// dc_printf(dc_prompt) when ready for input
// Call the function for that command, and strip the cmd token from the command line string
if (dc_command_buf.empty()) {
dc_printf("No command given.\n");
break;
} // Else, continue to process the cmd_line
// z64: Thread Note: Maybe lock a mutex here to allow a previous DCF to finish/abort before starting a new one
// z64: We'll just assume we won't be here unless a command has finished...
dc_history.push_front(dc_command_buf); // Push the command onto the history queue
last_oldcommand = dc_history.begin(); // Reset oldcommand
while (dc_history.size() > DCMDS) {
dc_history.pop_back(); // Keep the commands less than or equal to DCMDS
}
dc_command_str = dc_command_buf; // Xfer to the command string for processing
dc_command_buf.resize(0); // Nullify the buffer
dc_printf("%s%s\n", dc_prompt, dc_command_str.c_str()); // Print the command w/ prompt.
dc_draw(FALSE); // Redraw the console without the command line.
dc_do_command(&dc_command_str); // Try to do the command
break;
default:
// Not any of the control key codes, so it's probably a letter or number.
ubyte c = (ubyte)key_to_ascii(k);
if ((c != 255) && (dc_command_buf.size() < MAX_CLI_LEN)) {
dc_command_buf.push_back(c);
}
}
// Do the passed function
if ( _func ) {
_func();
}
// All done, and ready for new entry
dc_draw(TRUE);
}
while( key_inkey() ) {
os_poll();
}
}
// initializes hardware device from perferred/default/enumerated list
bool openal_init_device(SCP_string *playback, SCP_string *capture)
{
if ( !Playback_device.empty() ) {
if (playback) {
*playback = Playback_device;
}
if (capture) {
*capture = Capture_device;
}
return true;
}
if (playback) {
playback->erase();
}
if (capture) {
capture->erase();
}
// initialize default setup first, for version check...
ALCdevice *device = alcOpenDevice(NULL);
if (device == NULL) {
return false;
}
ALCcontext *context = alcCreateContext(device, NULL);
if (context == NULL) {
alcCloseDevice(device);
return false;
}
alcMakeContextCurrent(context);
// version check (for 1.0 or 1.1)
ALCint AL_minor_version = 0;
alcGetIntegerv(NULL, ALC_MINOR_VERSION, sizeof(ALCint), &AL_minor_version);
if (AL_minor_version < 1) {
#ifdef _WIN32
MessageBox(NULL, "OpenAL 1.1 or newer is required for proper operation. Please upgrade your OpenAL drivers, which\nare available at http://www.openal.org/downloads.html, and try running the game again.", NULL, MB_OK);
#else
printf("OpenAL 1.1 or newer is required for proper operation.\n");
printf("Please upgrade to a newer version if on OS X or switch\n");
printf("to OpenAL-Soft on Linux.\n");
#endif
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
alcCloseDevice(device);
return false;
}
alcGetError(device);
// close default device
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
alcCloseDevice(device);
// go through and find out what devices we actually want to use ...
find_playback_device();
find_capture_device();
if ( Playback_device.empty() ) {
return false;
}
#ifndef NDEBUG
if ( !PlaybackDevices.empty() ) {
nprintf(("OpenAL", " Available Playback Devices:\n"));
for (size_t idx = 0; idx < PlaybackDevices.size(); idx++) {
nprintf(("OpenAL", " %s", PlaybackDevices[idx].device_name.c_str()));
if (PlaybackDevices[idx].type == OAL_DEVICE_USER) {
nprintf(("OpenAL", " *preferred*\n"));
} else if (PlaybackDevices[idx].type == OAL_DEVICE_DEFAULT) {
nprintf(("OpenAL", " *default*\n"));
} else {
nprintf(("OpenAL", "\n"));
}
}
}
if ( !CaptureDevices.empty() ) {
if ( !PlaybackDevices.empty() ) {
nprintf(("OpenAL", "\n"));
}
nprintf(("OpenAL", " Available Capture Devices:\n"));
for (size_t idx = 0; idx < CaptureDevices.size(); idx++) {
nprintf(("OpenAL", " %s", CaptureDevices[idx].device_name.c_str()));
if (CaptureDevices[idx].type == OAL_DEVICE_USER) {
nprintf(("OpenAL", " *preferred*\n"));
} else if (CaptureDevices[idx].type == OAL_DEVICE_DEFAULT) {
nprintf(("OpenAL", " *default*\n"));
} else {
nprintf(("OpenAL", "\n"));
}
}
nprintf(("OpenAL", "\n"));
}
#endif
// cleanup
PlaybackDevices.clear();
CaptureDevices.clear();
if (playback) {
*playback = Playback_device;
}
if (capture) {
*capture = Capture_device;
}
return true;
}
// initializes hardware device from perferred/default/enumerated list
bool openal_init_device(SCP_string *playback, SCP_string *capture)
{
if ( !Playback_device.empty() ) {
if (playback) {
*playback = Playback_device;
}
if (capture) {
*capture = Capture_device;
}
return true;
}
if (playback) {
playback->erase();
}
if (capture) {
capture->erase();
}
// This reuses the code for the launcher to make sure everything is consistent
auto platform_info = openal_get_platform_information();
if (platform_info.version_major <= 1 && platform_info.version_minor < 1) {
os::dialogs::Message(os::dialogs::MESSAGEBOX_ERROR,
"OpenAL 1.1 or newer is required for proper operation. On Linux and Windows OpenAL Soft is recommended. If you are on Mac OS X you need to upgrade your OS.");
return false;
}
// go through and find out what devices we actually want to use ...
find_playback_device(&platform_info);
find_capture_device(&platform_info);
if ( Playback_device.empty() ) {
return false;
}
#ifndef NDEBUG
if ( !PlaybackDevices.empty() ) {
nprintf(("OpenAL", " Available Playback Devices:\n"));
for (size_t idx = 0; idx < PlaybackDevices.size(); idx++) {
nprintf(("OpenAL", " %s", PlaybackDevices[idx].device_name.c_str()));
if (PlaybackDevices[idx].type == OAL_DEVICE_USER) {
nprintf(("OpenAL", " *preferred*\n"));
} else if (PlaybackDevices[idx].type == OAL_DEVICE_DEFAULT) {
nprintf(("OpenAL", " *default*\n"));
} else {
nprintf(("OpenAL", "\n"));
}
}
}
if ( !CaptureDevices.empty() ) {
if ( !PlaybackDevices.empty() ) {
nprintf(("OpenAL", "\n"));
}
nprintf(("OpenAL", " Available Capture Devices:\n"));
for (size_t idx = 0; idx < CaptureDevices.size(); idx++) {
nprintf(("OpenAL", " %s", CaptureDevices[idx].device_name.c_str()));
if (CaptureDevices[idx].type == OAL_DEVICE_USER) {
nprintf(("OpenAL", " *preferred*\n"));
} else if (CaptureDevices[idx].type == OAL_DEVICE_DEFAULT) {
nprintf(("OpenAL", " *default*\n"));
} else {
nprintf(("OpenAL", "\n"));
}
}
nprintf(("OpenAL", "\n"));
}
#endif
// cleanup
PlaybackDevices.clear();
CaptureDevices.clear();
if (playback) {
*playback = Playback_device;
}
if (capture) {
*capture = Capture_device;
}
return true;
}
// initializes hardware device from perferred/default/enumerated list
bool openal_init_device(SCP_string *playback, SCP_string *capture)
{
if ( !Playback_device.empty() ) {
if (playback) {
*playback = Playback_device;
}
if (capture) {
*capture = Capture_device;
}
return true;
}
if (playback) {
playback->erase();
}
if (capture) {
capture->erase();
}
// initialize default setup first, for version check...
ALCdevice *device = alcOpenDevice(NULL);
if (device == NULL) {
return false;
}
ALCcontext *context = alcCreateContext(device, NULL);
if (context == NULL) {
alcCloseDevice(device);
return false;
}
alcMakeContextCurrent(context);
// version check (for 1.0 or 1.1)
ALCint AL_minor_version = 0;
alcGetIntegerv(NULL, ALC_MINOR_VERSION, sizeof(ALCint), &AL_minor_version);
if (AL_minor_version < 1) {
os::dialogs::Message(os::dialogs::MESSAGEBOX_ERROR,
"OpenAL 1.1 or newer is required for proper operation. On Linux and Windows OpenAL Soft is recommended. If you are on Mac OS X you need to upgrade your OS.");
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
alcCloseDevice(device);
return false;
}
alcGetError(device);
// close default device
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
alcCloseDevice(device);
// go through and find out what devices we actually want to use ...
find_playback_device();
find_capture_device();
if ( Playback_device.empty() ) {
return false;
}
#ifndef NDEBUG
if ( !PlaybackDevices.empty() ) {
nprintf(("OpenAL", " Available Playback Devices:\n"));
for (size_t idx = 0; idx < PlaybackDevices.size(); idx++) {
nprintf(("OpenAL", " %s", PlaybackDevices[idx].device_name.c_str()));
if (PlaybackDevices[idx].type == OAL_DEVICE_USER) {
nprintf(("OpenAL", " *preferred*\n"));
} else if (PlaybackDevices[idx].type == OAL_DEVICE_DEFAULT) {
nprintf(("OpenAL", " *default*\n"));
} else {
nprintf(("OpenAL", "\n"));
}
}
}
if ( !CaptureDevices.empty() ) {
if ( !PlaybackDevices.empty() ) {
nprintf(("OpenAL", "\n"));
}
nprintf(("OpenAL", " Available Capture Devices:\n"));
for (size_t idx = 0; idx < CaptureDevices.size(); idx++) {
nprintf(("OpenAL", " %s", CaptureDevices[idx].device_name.c_str()));
if (CaptureDevices[idx].type == OAL_DEVICE_USER) {
nprintf(("OpenAL", " *preferred*\n"));
} else if (CaptureDevices[idx].type == OAL_DEVICE_DEFAULT) {
nprintf(("OpenAL", " *default*\n"));
} else {
nprintf(("OpenAL", "\n"));
}
}
nprintf(("OpenAL", "\n"));
}
#endif
// cleanup
PlaybackDevices.clear();
CaptureDevices.clear();
if (playback) {
*playback = Playback_device;
}
if (capture) {
*capture = Capture_device;
}
return true;
}
