static SCP_vector<SCP_string> opengl_get_shader_content(shader_type type_id, const char* filename, int flags, shader_stage stage) {
SCP_vector<SCP_string> parts;
parts.push_back(opengl_shader_get_header(type_id, flags, stage));
parts.push_back(opengl_load_shader(filename));
return parts;
}
static SCP_vector<SCP_string> opengl_get_shader_content(shader_type type_id, const char* filename, int flags, bool has_geo_shader) {
SCP_vector<SCP_string> parts;
parts.push_back(opengl_shader_get_header(type_id, flags, has_geo_shader));
parts.push_back(handle_includes(filename, opengl_load_shader(filename)));
return parts;
}
SCP_vector<JoystickInformation> getJoystickInformations() {
SCP_vector<JoystickInformation> joystickInfo;
if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) < 0) {
return SCP_vector<JoystickInformation>();
}
auto num_joysticks = SDL_NumJoysticks();
for (auto i = 0; i < num_joysticks; ++i) {
auto joystick = SDL_JoystickOpen(i);
JoystickInformation info{};
auto name = SDL_JoystickName(joystick);
if (name != nullptr) {
info.name = name;
}
info.guid = getJoystickGUID(joystick);
info.num_axes = static_cast<uint32_t>(SDL_JoystickNumAxes(joystick));
info.num_balls = static_cast<uint32_t>(SDL_JoystickNumBalls(joystick));
info.num_buttons = static_cast<uint32_t>(SDL_JoystickNumButtons(joystick));
info.num_hats = static_cast<uint32_t>(SDL_JoystickNumHats(joystick));
info.is_haptic = SDL_JoystickIsHaptic(joystick) == SDL_TRUE;
joystickInfo.push_back(info);
SDL_JoystickClose(joystick);
}
SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
return joystickInfo;
}
void fs2netd_add_table_validation(char *tblname)
{
uint chksum = 0;
// if the tbl name isn't valid then just assume that the tbl is too
if ( (tblname == NULL) || !strlen(tblname) ) {
return;
}
CFILE *tbl = cfopen(tblname, "rt", CFILE_NORMAL, CF_TYPE_TABLES);
if (tbl == NULL) {
return;
}
cf_chksum_long(tbl, &chksum);
cfclose(tbl);
crc_valid_status tbl_crc;
strncpy(tbl_crc.name, tblname, NAME_LENGTH);
tbl_crc.crc32 = chksum;
tbl_crc.valid = 0;
Table_valid_status.push_back( tbl_crc );
}
camid cam_create(char *n_name, vec3d *n_pos, matrix *n_ori, object *n_object, int n_object_host_submodel)
{
camera *cam = NULL;
camid cid;
//Get signature
int sig = cam_get_next_sig();
//Get name
char buf[NAME_LENGTH] = {'\0'};
if(n_name == NULL)
sprintf(buf, "Camera %d", cid.getSignature());
else
strncpy(buf, n_name, NAME_LENGTH-1);
//Find a free slot
cam = new camera(buf, sig);
cid = camid(Cameras.size(), sig);
Cameras.push_back(cam);
//Set attributes
if(n_pos != NULL)
cam->set_position(n_pos);
if(n_ori != NULL)
cam->set_rotation(n_ori);
if(n_object != NULL)
cam->set_object_host(n_object, n_object_host_submodel);
return cid;
}
void hud_sourced_print(int source, const char *msg)
{
if ( !strlen(msg) ) {
nprintf(("Warning", "HUD ==> attempt to print a 0 length string in msg window\n"));
return;
}
// add message to the scrollback log first
hud_add_msg_to_scrollback(msg, source, Missiontime);
HUD_message_data new_msg;
new_msg.text = SCP_string(msg);
new_msg.source = source;
new_msg.x = 0;
HUD_msg_buffer.push_back(new_msg);
// Invoke the scripting hook
Script_system.SetHookVar("Text", 's', const_cast<char*>(msg));
Script_system.SetHookVar("SourceType", 'i', &source);
Script_system.RunCondition(CHA_HUDMSGRECEIVED);
Script_system.RemHookVars(2, "Text", "SourceType");
}
/**
* CommanderDJ: initialise alpha colors based on colors.tbl
* Made modular and given a wider range of features by MageKing17
*/
void alpha_colors_init()
{
// Set our default colors.
int i;
for (i = 0; i < TOTAL_COLORS; i++) {
gr_init_alphacolor(COLOR_LIST[i], rgba_defaults[i][0], rgba_defaults[i][1], rgba_defaults[i][2], rgba_defaults[i][3]);
}
if (cf_exists_full("colors.tbl", CF_TYPE_TABLES)) {
mprintf(("TABLES => Starting parse of 'colors.tbl' (checking '#Start Colors' section only)...\n"));
parse_colors("colors.tbl");
}
parse_modular_table(NOX("*-clr.tbm"), parse_colors);
// Set defaults for interface colors and color tags (must be done after the above because they're generally just copies of above-defined colors).
for (i = 0; i < INTERFACE_COLORS; i++) {
memcpy(interface_colors[i], COLOR_LIST[interface_defaults[i]], sizeof(color));
}
for (i = 0; i < DEFAULT_TAGS; i++) {
Tagged_Colors[DEFAULT_TAG_LIST[i]] = DEFAULT_TAG_COLORS[i];
Color_Tags.push_back(DEFAULT_TAG_LIST[i]);
}
if (cf_exists_full("colors.tbl", CF_TYPE_TABLES)) {
mprintf(("TABLES => Starting parse of 'colors.tbl' (skipping '#Start Colors' section)...\n"));
parse_everything_else("colors.tbl");
}
parse_modular_table(NOX("*-clr.tbm"), parse_everything_else);
}
ParticleSourceWrapper ParticleManager::createSource(ParticleEffectIndex index) {
ParticleEffectPtr eff = this->getEffect(index);
ParticleSourceWrapper wrapper;
if (eff->getType() == EffectType::Composite) {
SCP_vector<ParticleSource*> sources;
auto composite = static_cast<effects::CompositeEffect*>(eff);
auto& childEffects = composite->getEffects();
// UGH, HACK! To implement the source wrapper we need constant pointers to all sources.
// To ensure this we reserve the number of sources we will need (current sources + sources being created)
m_sources.reserve(m_sources.size() + childEffects.size());
for (auto& effect : childEffects) {
ParticleSource* source = createSource();
source->setEffect(effect);
effect->initializeSource(*source);
sources.push_back(source);
}
wrapper = ParticleSourceWrapper(std::move(sources));
}
else {
ParticleSource* source = createSource();
source->setEffect(eff);
eff->initializeSource(*source);
wrapper = ParticleSourceWrapper(source);
}
wrapper.setCreationTimestamp(timestamp());
return wrapper;
}
/**
* Compiles a new shader, and creates an opengl_shader_t that will be put into the GL_shader vector
* if compilation is successful.
*
* @param sdr Identifier defined with the program we wish to compile
* @param flags Combination of SDR_* flags
* @param replacement_idx The index of the shader this replaces. If -1, the newly compiled shader will be appended to the GL_shader vector
* or inserted at the first available empty slot
*/
int opengl_compile_shader(shader_type sdr, uint flags)
{
GR_DEBUG_SCOPE("Creating new shader");
int sdr_index = -1;
int empty_idx;
opengl_shader_t new_shader;
Assert(sdr < NUM_SHADER_TYPES);
opengl_compile_shader_actual(sdr, flags, new_shader);
opengl_shader_set_current();
// add it to our list of embedded shaders
// see if we have empty shader slots
empty_idx = -1;
for (int i = 0; i < (int)GL_shader.size(); ++i) {
if (GL_shader[i].shader == NUM_SHADER_TYPES) {
empty_idx = i;
break;
}
}
// then insert it at an empty slot or at the end
if ( empty_idx >= 0 ) {
GL_shader[empty_idx] = std::move(new_shader);
sdr_index = empty_idx;
} else {
sdr_index = (int)GL_shader.size();
GL_shader.push_back(std::move(new_shader));
}
return sdr_index;
}
/**
* CommanderDJ - Parse a list of sounds. When using this function for a table entry,
* required_string and optional_string aren't needed, as this function deals with
* that as its tag parameter, just make sure that the destination sound index(es) can
* handle -1 if things don't work out.
*
* @param destination Vector where sound indexes are to be stored
* @param tag Tag
* @param object_name Name of object being parsed
* @param flags See the parse_sound_flags enum
*
*/
void parse_sound_list(const char* tag, SCP_vector<int>& destination, const char* object_name, parse_sound_flags flags)
{
if(optional_string(tag))
{
int check=0;
//if we're using the old format, parse the first entry separately
if(!(flags & PARSE_SOUND_SCP_SOUND_LIST))
{
stuff_int(&check);
}
//now read the rest of the entries on the line
for(size_t i=0; !check_for_eoln(); i++)
{
char buf[MAX_FILENAME_LEN];
stuff_string_white(buf, MAX_FILENAME_LEN);
//we do this conditionally to avoid adding needless entries when reparsing
if(destination.size() <= i)
{
destination.push_back(-1);
}
parse_sound_core(tag, &destination.at(i), object_name, buf, flags);
}
//if we're using the old format, double check the size)
if(!(flags & PARSE_SOUND_SCP_SOUND_LIST) && (destination.size() != (unsigned)check))
{
mprintf(("%s in '%s' has " SIZE_T_ARG " entries. This does not match entered size of %i.", tag, object_name, destination.size(), check));
}
}
}
void os_ignore_events() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
// Add event to buffer
buffered_events.push_back(event);
}
}
void get_post_process_effect_names(SCP_vector<SCP_string> &names)
{
size_t idx;
for (idx = 0; idx < Post_effects.size(); idx++) {
names.push_back(Post_effects[idx].name);
}
}
void outwnd_print(const char *id, const char *tmp)
{
uint i;
if ( (id == NULL) || (tmp == NULL) )
return;
if ( !outwnd_inited ) {
fputs("outwnd not initialized yet... \n", stdout);
fputs(tmp, stdout);
fflush(stdout);
return;
}
if (Outwnd_no_filter_file == 1) {
Outwnd_no_filter_file = 2;
outwnd_print( "general", "==========================================================================\n" );
outwnd_print( "general", "DEBUG SPEW: No debug_filter.cfg found, so only general, error, and warning\n" );
outwnd_print( "general", "categories can be shown and no debug_filter.cfg info will be saved.\n" );
outwnd_print( "general", "==========================================================================\n" );
}
for (i = 0; i < OutwndFilter.size(); i++) {
if ( !stricmp(id, OutwndFilter[i].name) )
break;
}
// id found that isn't in the filter list yet
if ( i == OutwndFilter.size() ) {
// Only create new filters if there was a filter file
if (Outwnd_no_filter_file)
return;
Assert( strlen(id)+1 < NAME_LENGTH );
outwnd_filter_struct new_filter;
strcpy_s(new_filter.name, id);
new_filter.enabled = true;
OutwndFilter.push_back( new_filter );
save_filter_info();
}
if ( !OutwndFilter[i].enabled )
return;
if (Log_debug_output_to_file) {
if (Log_fp != NULL) {
fputs(tmp, Log_fp);
fflush(Log_fp);
}
} else {
fputs(tmp, stdout);
fflush(stdout);
}
}
// initialization stuff for cutscenes
void cutscene_init()
{
atexit(cutscene_close);
char buf[MULTITEXT_LENGTH];
int rval;
cutscene_info cutinfo;
if ((rval = setjmp(parse_abort)) != 0) {
mprintf(("TABLES: Unable to parse '%s'! Error code = %i.\n", "cutscenes.tbl", rval));
return;
}
read_file_text("cutscenes.tbl", CF_TYPE_TABLES);
reset_parse();
// parse in all the cutscenes
Cutscenes.clear();
skip_to_string("#Cutscenes");
ignore_white_space();
bool isFirstCutscene = true;
while ( required_string_either("#End", "$Filename:") )
{
required_string("$Filename:");
stuff_string( cutinfo.filename, F_PATHNAME, MAX_FILENAME_LEN );
required_string("$Name:");
stuff_string( cutinfo.name, F_NAME, NAME_LENGTH );
required_string("$Description:");
stuff_string(buf, F_MULTITEXT, sizeof(buf));
drop_white_space(buf);
compact_multitext_string(buf);
cutinfo.description = vm_strdup(buf);
if (optional_string("$cd:"))
stuff_int( &cutinfo.cd );
else
cutinfo.cd = 0;
cutinfo.viewable = false;
if (isFirstCutscene) {
isFirstCutscene = false;
// The original code assumes the first movie is the intro, so always viewable
cutinfo.viewable = true;
}
if (optional_string("$Always Viewable:")) {
stuff_boolean(&cutinfo.viewable);
}
Cutscenes.push_back(cutinfo);
}
required_string("#End");
}
void obj_find_overlap_colliders(SCP_vector<int> *overlap_list_out, SCP_vector<int> *list, int axis, bool collide)
{
size_t i, j;
bool overlapped;
bool first_not_added = true;
SCP_vector<int> overlappers;
float min;
float max;
float overlap_min;
float overlap_max;
overlappers.clear();
for ( i = 0; i < (*list).size(); ++i ) {
overlapped = false;
min = obj_get_collider_endpoint((*list)[i], axis, true);
max = obj_get_collider_endpoint((*list)[i], axis, false);
for ( j = 0; j < overlappers.size(); ) {
overlap_min = obj_get_collider_endpoint(overlappers[j], axis, true);
overlap_max = obj_get_collider_endpoint(overlappers[j], axis, false);
if ( min <= overlap_max ) {
overlapped = true;
if ( overlappers.size() == 1 && first_not_added ) {
first_not_added = false;
overlap_list_out->push_back(overlappers[j]);
}
if ( collide ) {
obj_collide_pair(&Objects[(*list)[i]], &Objects[overlappers[j]]);
}
} else {
overlappers[j] = overlappers.back();
overlappers.pop_back();
continue;
}
++j;
}
if ( overlappers.size() == 0 ) {
first_not_added = true;
}
if ( overlapped ) {
overlap_list_out->push_back((*list)[i]);
}
overlappers.push_back((*list)[i]);
}
overlapped = true;
}
/**
* Stores profile data in in the profile history lookup. This is used internally by the profiling code and should
* not be called outside of it.
* @param name The globally unique name for this profile (see profile_begin()/profile_end())
* @param percent How much time the profiled section took to execute (as a percentage of overall frametime)
*/
void store_profile_in_history(SCP_string &name, float percent, uint64_t time)
{
float old_ratio;
float new_ratio = 0.8f * f2fl(Frametime);
if(new_ratio > 1.0f) {
new_ratio = 1.0f;
}
old_ratio = 1.0f - new_ratio;
for(int i = 0; i < (int)history.size(); i++) {
if( history[i].valid && history[i].name == name ) {
// found the sample
history[i].avg = (history[i].avg * old_ratio) + (percent * new_ratio);
history[i].avg_micro_sec = fl2i((history[i].avg_micro_sec * old_ratio) + (time * new_ratio));
if( percent < history[i].min ) {
history[i].min = percent;
} else {
history[i].min = (history[i].min*old_ratio) + (percent*new_ratio);
}
if( time < history[i].min_micro_sec ) {
history[i].min_micro_sec = time;
} else {
history[i].min_micro_sec = fl2i((history[i].min_micro_sec*old_ratio) + (time*new_ratio));
}
if( percent > history[i].max) {
history[i].max = percent;
} else {
history[i].max = (history[i].max * old_ratio) + (percent * new_ratio);
}
if( time > history[i].max_micro_sec) {
history[i].max_micro_sec = time;
} else {
history[i].max_micro_sec = fl2i((history[i].max_micro_sec * old_ratio) + (time * new_ratio));
}
return;
}
}
// add to history
profile_sample_history new_history;
new_history.name = name;
new_history.valid = true;
new_history.avg = new_history.min = new_history.max = percent;
new_history.avg_micro_sec = new_history.min_micro_sec = new_history.max_micro_sec = time;
history.push_back(new_history);
}
static int get_query_object() {
if (!free_query_objects.empty()) {
auto id = free_query_objects.front();
free_query_objects.pop();
return id;
}
auto id = gr_create_query_object();
query_objects.push_back(id);
return id;
}
/**
* Call to load a shockwave, or add it and then load it
*/
int shockwave_load(char *s_name, bool shock_3D)
{
size_t i;
int s_index = -1;
shockwave_info *si = NULL;
Assert( s_name );
// make sure that this is, or should be, valid
if ( !VALID_FNAME(s_name) )
return -1;
for (i = 0; i < Shockwave_info.size(); i++) {
if ( !stricmp(Shockwave_info[i].filename, s_name) ) {
s_index = i;
break;
}
}
if (s_index < 0) {
shockwave_info si_tmp;
strcpy_s(si_tmp.filename, s_name);
Shockwave_info.push_back( si_tmp );
s_index = (int)(Shockwave_info.size() - 1);
}
Assert( s_index >= 0 );
si = &Shockwave_info[s_index];
// make sure to only try loading the shockwave once
if ( (si->bitmap_id >= 0) || (si->model_id >= 0) )
return s_index;
if (shock_3D) {
si->model_id = model_load( si->filename, 0, NULL );
if ( si->model_id < 0 ) {
Shockwave_info.pop_back();
return -1;
}
} else {
si->bitmap_id = bm_load_animation( si->filename, &si->num_frames, &si->fps, NULL, 1 );
if ( si->bitmap_id < 0 ) {
Shockwave_info.pop_back();
return -1;
}
}
return s_index;
}
static void find_capture_device(OpenALInformation* info)
{
const char *user_device = os_config_read_string( "Sound", "CaptureDevice", NULL );
const char *default_device = info->default_capture_device.c_str();
// in case they are the same, we only want to test it once
if ( (user_device && default_device) && !strcmp(user_device, default_device) ) {
user_device = NULL;
}
for (auto& device : info->capture_devices) {
OALdevice new_device(device.c_str());
if (user_device && !strcmp(device.c_str(), user_device)) {
new_device.type = OAL_DEVICE_USER;
} else if (default_device && !strcmp(device.c_str(), default_device)) {
new_device.type = OAL_DEVICE_DEFAULT;
}
CaptureDevices.push_back( new_device );
}
if ( CaptureDevices.empty() ) {
return;
}
std::sort( CaptureDevices.begin(), CaptureDevices.end(), openal_device_sort_func );
// for each device that we have available, try and figure out which to use
for (size_t idx = 0; idx < CaptureDevices.size(); idx++) {
const ALCchar *device_name = CaptureDevices[idx].device_name.c_str();
ALCdevice *device = alcCaptureOpenDevice(device_name, 22050, AL_FORMAT_MONO8, 22050 * 2);
if (device == NULL) {
continue;
}
if (alcGetError(device) != ALC_NO_ERROR) {
alcCaptureCloseDevice(device);
continue;
}
// ok, we should be good with this one
Capture_device = CaptureDevices[idx].device_name;
alcCaptureCloseDevice(device);
break;
}
}
// Try to find a match between filename and the names inside
// of Hud_shield_filenames. This will provide us with an
// association of ship class to shield icon information.
void hud_shield_assign_info(ship_info *sip, char *filename)
{
ubyte i;
for ( i = 0; i < (ubyte)Hud_shield_filenames.size(); i++ ) {
if ( !stricmp(filename, Hud_shield_filenames.at(i).c_str()) ) {
sip->shield_icon_index = i;
return;
}
}
//No HUD icon found. Add one!
sip->shield_icon_index = (unsigned char) Hud_shield_filenames.size();
Hud_shield_filenames.push_back((SCP_string)filename);
}
int opengl_create_buffer_object(GLenum type, GLenum usage)
{
GR_DEBUG_SCOPE("Create buffer object");
opengl_buffer_object buffer_obj;
buffer_obj.usage = usage;
buffer_obj.type = type;
buffer_obj.size = 0;
glGenBuffers(1, &buffer_obj.buffer_id);
GL_buffer_objects.push_back(buffer_obj);
return (int)(GL_buffer_objects.size() - 1);
}
void cutscenes_screen_init()
{
int i;
ui_button_info *b;
Ui_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
Ui_window.set_mask_bmap(Cutscene_mask_name[gr_screen.res]);
for (i=0; i<NUM_BUTTONS; i++) {
b = &Buttons[gr_screen.res][i];
b->button.create(&Ui_window, "", b->x, b->y, 60, 30, (i < 2), 1);
// set up callback for when a mouse first goes over a button
b->button.set_highlight_action(common_play_highlight_sound);
b->button.set_bmaps(b->filename);
b->button.link_hotspot(b->hotspot);
}
// add xstrs
for(i=0; i<NUM_CUTSCENE_TEXT; i++){
Ui_window.add_XSTR(&Cutscene_text[gr_screen.res][i]);
}
Buttons[gr_screen.res][EXIT_BUTTON].button.set_hotkey(KEY_CTRLED | KEY_ENTER);
Buttons[gr_screen.res][SCROLL_UP_BUTTON].button.set_hotkey(KEY_PAGEUP);
Buttons[gr_screen.res][SCROLL_DOWN_BUTTON].button.set_hotkey(KEY_PAGEDOWN);
List_region.create(&Ui_window, "", Cutscene_list_coords[gr_screen.res][0], Cutscene_list_coords[gr_screen.res][1], Cutscene_list_coords[gr_screen.res][2], Cutscene_list_coords[gr_screen.res][3], 0, 1);
List_region.hide();
// set up hotkeys for buttons so we draw the correct animation frame when a key is pressed
Buttons[gr_screen.res][SCROLL_UP_BUTTON].button.set_hotkey(KEY_PAGEUP);
Buttons[gr_screen.res][SCROLL_DOWN_BUTTON].button.set_hotkey(KEY_PAGEDOWN);
Background_bitmap = bm_load(Cutscene_bitmap_name[gr_screen.res]);
Scroll_offset = Selected_line = 0;
Description_index = -1;
Cutscene_list.clear();
int u = 0;
for (SCP_vector<cutscene_info>::iterator cut = Cutscenes.begin(); cut != Cutscenes.end(); ++cut, u++) {
if ( (*cut).viewable ) {
Cutscene_list.push_back(u);
}
}
}
/**
* @brief Writes JSON tracing data to a file if the commandlinfe option is enabled
*/
void profile_dump_json_output() {
if (Cmdline_json_profiling) {
std::lock_guard<std::mutex> guard(json_mutex);
// FIXME: This could be improved by using only a single thread and a synchronized bounded
// queue. Boost has an implementation of that.
tracing_frame_data frame_data;
frame_data.data = current_frame_data;
frame_data.frame_num = ++json_frame_num;
pending_frame_data.push_back(std::move(frame_data));
current_frame_data.clear();
process_pending_data();
}
}
// parses the string.tbl to see which languages are supported. Doesn't read in any strings.
void parse_stringstbl_quick(const char *filename)
{
lang_info language;
int lang_idx;
int i;
read_file_text(filename, CF_TYPE_TABLES);
reset_parse();
if (optional_string("#Supported Languages")) {
while (required_string_either("#End","$Language:")) {
required_string("$Language:");
stuff_string(language.lang_name, F_RAW, LCL_LANG_NAME_LEN + 1);
required_string("+Extension:");
stuff_string(language.lang_ext, F_RAW, LCL_LANG_NAME_LEN + 1);
required_string("+Special Character Index:");
stuff_ubyte(&language.special_char_indexes[0]);
for (i = 1; i < LCL_MAX_FONTS; ++i) {
// default to "none"/0 except for font03 which defaults to 176
// NOTE: fonts.tbl may override these values
if (i == font::FONT3) {
language.special_char_indexes[i] = 176;
} else {
language.special_char_indexes[i] = 0;
}
}
lang_idx = -1;
// see if we already have this language
for (i = 0; i < (int)Lcl_languages.size(); i++) {
if (!strcmp(Lcl_languages[i].lang_name, language.lang_name)) {
strcpy_s(Lcl_languages[i].lang_ext, language.lang_ext);
Lcl_languages[i].special_char_indexes[0] = language.special_char_indexes[0];
lang_idx = i;
break;
}
}
// if we have a new language, add it.
if (lang_idx == -1) {
Lcl_languages.push_back(language);
}
}
}
}
void hud_sourced_print(int source, char *msg)
{
if ( !strlen(msg) ) {
nprintf(("Warning", "HUD ==> attempt to print a 0 length string in msg window\n"));
return;
}
// add message to the scrollback log first
hud_add_msg_to_scrollback(msg, source, Missiontime);
HUD_message_data new_msg;
new_msg.text = SCP_string(msg);
new_msg.source = source;
new_msg.x = 0;
HUD_msg_buffer.push_back(new_msg);
}
static size_t find_good_distortion_item(int texture)
{
size_t max_size = distortion_map.size();
for (size_t i = 0; i < max_size; i++) {
if (distortion_map[i].texture == texture)
return i;
}
// don't have an existing match so add a new entry
batch_item new_item;
new_item.texture = texture;
distortion_map.push_back(new_item);
return (distortion_map.size() - 1);
}
void obj_add_collider(int obj_index)
{
object *objp = &Objects[obj_index];
#ifdef OBJECT_CHECK
CheckObjects[obj_index].type = objp->type;
CheckObjects[obj_index].signature = objp->signature;
CheckObjects[obj_index].flags = objp->flags - Object::Object_Flags::Not_in_coll;
CheckObjects[obj_index].parent_sig = objp->parent_sig;
CheckObjects[obj_index].parent_type = objp->parent_type;
#endif
if(!(objp->flags[Object::Object_Flags::Not_in_coll])){
return;
}
Collision_sort_list.push_back(obj_index);
objp->flags.remove(Object::Object_Flags::Not_in_coll);
}
void obj_add_collider(int obj_index)
{
object *objp = &Objects[obj_index];
#ifdef OBJECT_CHECK
CheckObjects[obj_index].type = objp->type;
CheckObjects[obj_index].signature = objp->signature;
CheckObjects[obj_index].flags = objp->flags & ~(OF_NOT_IN_COLL);
CheckObjects[obj_index].parent_sig = objp->parent_sig;
CheckObjects[obj_index].parent_type = objp->parent_type;
#endif
if(!(objp->flags & OF_NOT_IN_COLL)){
return;
}
Collision_sort_list.push_back(obj_index);
objp->flags &= ~OF_NOT_IN_COLL;
}
/**
* Pass a GLSL shader source to OpenGL and compile it into a usable shader object.
* Prints compilation errors (if any) to the log.
* Note that this will only compile shaders into objects, linking them into executables happens later
*
* @param shader_source GLSL sourcecode for the shader
* @param shader_type OpenGL ID for the type of shader being used, like GL_FRAGMENT_SHADER_ARB, GL_VERTEX_SHADER_ARB
* @return OpenGL handle for the compiled shader object
*/
GLhandleARB opengl_shader_compile_object(const SCP_vector<SCP_string>& shader_source, GLenum shader_type)
{
GLhandleARB shader_object = 0;
GLint status = 0;
SCP_vector<const GLcharARB*> sources;
sources.reserve(shader_source.size());
for (auto it = shader_source.begin(); it != shader_source.end(); ++it) {
sources.push_back(it->c_str());
}
shader_object = vglCreateShaderObjectARB(shader_type);
vglShaderSourceARB(shader_object, sources.size(), &sources[0], NULL);
vglCompileShaderARB(shader_object);
// check if the compile was successful
vglGetObjectParameterivARB(shader_object, GL_OBJECT_COMPILE_STATUS_ARB, &status);
opengl_shader_check_info_log(shader_object);
// we failed, bail out now...
if (status == 0) {
// basic error check
mprintf(("%s shader failed to compile:\n%s\n", (shader_type == GL_VERTEX_SHADER_ARB) ? "Vertex" : ((shader_type == GL_GEOMETRY_SHADER_EXT) ? "Geometry" : "Fragment"), GLshader_info_log));
// this really shouldn't exist, but just in case
if (shader_object) {
vglDeleteObjectARB(shader_object);
}
return 0;
}
// we succeeded, maybe output warnings too
if (strlen(GLshader_info_log) > 5) {
nprintf(("SHADER-DEBUG", "%s shader compiled with warnings:\n%s\n", (shader_type == GL_VERTEX_SHADER_ARB) ? "Vertex" : ((shader_type == GL_GEOMETRY_SHADER_EXT) ? "Geometry" : "Fragment"), GLshader_info_log));
}
return shader_object;
}
// called at the start of each level from HUD_init. Use Hud_shield_init so we only init Shield_gauges[] once.
void hud_shield_level_init()
{
unsigned int i;
hud_frames temp;
hud_shield_hit_reset(Player_obj, 1); // reset for the player
if ( !Hud_shield_inited ) {
for ( i = 0; i < Hud_shield_filenames.size(); i++ ) {
Shield_gauges.push_back(temp);
Shield_gauges.at(i).first_frame = -1;
Shield_gauges.at(i).num_frames = 0;
}
Hud_shield_inited = 1;
}
Shield_mini_gauge.first_frame = bm_load_animation("targhit1", &Shield_mini_gauge.num_frames);
if ( Shield_mini_gauge.first_frame == -1 ) {
Warning(LOCATION, "Could not load in the HUD shield ani: targhit1\n");
return;
}
Shield_mini_loaded = 1;
}