void gr_use_palette_table( char * filename )
{
CFILE *fp;
int i,fsize;
fp = cfopen( filename, "rb" );
if ( fp==NULL)
Error("Can't open palette file <%s>",filename);
fsize = cfilelength( fp );
Assert( fsize == 9472 );
cfread( gr_palette, 256*3, 1, fp );
cfread( gr_fade_table, 256*34, 1, fp );
cfclose(fp);
// This is the TRANSPARENCY COLOR
for (i=0; i<GR_FADE_LEVELS; i++ ) {
gr_fade_table[i*256+255] = 255;
}
Num_computed_colors = 0; // Flush palette cache.
#if defined(POLY_ACC)
pa_update_clut(gr_palette, 0, 256, 0);
#endif
}
void palette_load_table( char * filename )
{
int i;
int w, h;
int pcx_error;
strcpy( palette_base_filename, filename );
char * p = strchr(palette_base_filename,'.');
if ( p ) {
*p = 0;
}
pcx_error = pcx_read_header(palette_base_filename, NULL, &w, &h, NULL, palette_org );
if ( pcx_error != PCX_ERROR_NONE ) {
// Read the old .256 file
CFILE *fp;
int fsize;
fp = cfopen( palette_base_filename, "rb" );
if ( fp==NULL)
Error( LOCATION, "Can't open palette file <%s>",palette_base_filename);
fsize = cfilelength( fp );
Assert( fsize == 9472 );
cfread( palette_org, 256*3, 1, fp );
cfclose(fp);
for (i=0; i<768; i++ ) {
palette_org[i] = ubyte((palette_org[i]*255)/63);
}
}
palette_base_loaded = 1;
gr_set_palette(palette_base_filename, palette_org);
}
void fiction_viewer_load(const char *filename, const char *font_filename, const char *voice_filename)
{
int file_length;
Assertion(filename, "Invalid fictionviewer filename pointer given!");
Assertion(font_filename, "Invalid fictionviewer font filename pointer given!");
Assertion(voice_filename, "Invalid fictionviewer voice filename pointer given!");
// just to be sure
if (Fiction_viewer_text != NULL)
{
Int3();
fiction_viewer_reset();
}
// save our filenames
strcpy_s(Fiction_viewer_filename, filename);
strcpy_s(Fiction_viewer_font_filename, font_filename);
strcpy_s(Fiction_viewer_voice_filename, voice_filename);
// see if we have a matching font
Fiction_viewer_fontnum = gr_get_fontnum(Fiction_viewer_font_filename);
if (Fiction_viewer_fontnum < 0 && !Fred_running)
strcpy_s(Fiction_viewer_font_filename, "");
Fiction_viewer_voice = audiostream_open(Fiction_viewer_voice_filename, ASF_VOICE);
if (Fiction_viewer_voice < 0 && !Fred_running)
strcpy_s(Fiction_viewer_voice_filename, "");
if (!strlen(filename))
return;
// load up the text
CFILE *fp = cfopen(filename, "rb", CFILE_NORMAL, CF_TYPE_FICTION);
if (fp == NULL)
{
Warning(LOCATION, "Unable to load fiction file '%s'.", filename);
return;
}
// we don't need to copy the text in Fred
if (!Fred_running)
{
// allocate space
file_length = cfilelength(fp);
Fiction_viewer_text = (char *) vm_malloc(file_length + 1);
Fiction_viewer_text[file_length] = '\0';
// copy all the text
cfread(Fiction_viewer_text, file_length, 1, fp);
}
// we're done, close it out
cfclose(fp);
}
void gr_use_palette_table( char * filename )
{
CFILE *fp;
int i,fsize;
#ifdef SWAP_0_255
ubyte c;
#endif
fp = cfopen( filename, "rb" );
// the following is a hack to enable the loading of d2 levels
// even if only the d2 mac shareware datafiles are present.
// However, if the pig file is present but the palette file isn't,
// the textures in the level will look wierd...
if ( fp==NULL)
fp = cfopen( DEFAULT_LEVEL_PALETTE, "rb" );
if ( fp==NULL)
Error("Can open neither palette file <%s> "
"nor default palette file <"
DEFAULT_LEVEL_PALETTE
">.\n",
filename);
fsize = cfilelength( fp );
Assert( fsize == 9472 );
cfread( gr_palette, 256*3, 1, fp );
cfread( gr_fade_table, 256*34, 1, fp );
cfclose(fp);
// This is the TRANSPARENCY COLOR
for (i=0; i<GR_FADE_LEVELS; i++ ) {
gr_fade_table[i*256+255] = 255;
}
Num_computed_colors = 0; // Flush palette cache.
// swap colors 0 and 255 of the palette along with fade table entries
#ifdef SWAP_0_255
for (i = 0; i < 3; i++) {
c = gr_palette[i];
gr_palette[i] = gr_palette[765+i];
gr_palette[765+i] = c;
}
for (i = 0; i < GR_FADE_LEVELS * 256; i++) {
if (gr_fade_table[i] == 0)
gr_fade_table[i] = 255;
}
for (i=0; i<GR_FADE_LEVELS; i++)
gr_fade_table[i*256] = TRANSPARENCY_COLOR;
#endif
}
int do_ipc(int qid, struct msgbuf *buf, int flags)
{
int ipc_read;
CFILE *fptr;
int l=0;
ipc_read = msgrcv(qid,buf,16,0,flags | MSG_NOERROR);
switch (ipc_read)
{
case -1:
if (errno == ENOMSG)
break;
perror("IPC trouble");
break;
case 0:
break;
default:
printf ("do_ipc %s\n", buf->mtext);//##########3
switch (buf->mtext[0])
{
case 'v':
volume=(double) ((double) buf->mtext[0]/127.0);
break;
case 'p':
fptr=cfopen((buf->mtext+1),"rb");
if(fptr != NULL)
{
l = cfilelength(fptr);
data=realloc(data,(size_t) l);
cfread(data, l, 1, fptr);
cfclose(fptr);
printf ("good. fpr=%p l=%i data=%p\n", fptr, l, data);//##########3
}
stop = 0;
break;
case 's':
stop = 2;
break;
case 'q':
// SDL_KillThread(player_thread);
break;
}
}
return ipc_read;
}
const char *loadfile(const char *url, int *size) {
CFILE *f;
char *buf;
long fsize;
if (!(f = cfopen((char *)url, "rb")))
return NULL;
fsize = cfilelength(f);
if (fsize != (int)fsize)
return NULL;
if (!(buf = (char *)malloc(fsize)))
return NULL;
cfread(buf, fsize, 1, f);
cfclose(f);
*size = fsize;
return buf;
}
void gr_use_palette_table( char * filename )
{
CFILE *fp;
int i,fsize;
fp = cfopen( filename, "rb" );
if ( fp==NULL)
Error("Can't open palette file <%s>",filename);
fsize = cfilelength( fp );
Assert( fsize == 9472 );
cfread( gr_palette, 256*3, 1, fp );
cfread( gr_fade_table, 256*34, 1, fp );
cfclose(fp);
// This is the TRANSPARENCY COLOR
for (i=0; i<GR_FADE_LEVELS; i++ ) {
gr_fade_table[i*256+255] = 255;
}
}
/**
* Load a shader file from disc or from the builtin defaults in def_files.cpp if none can be found.
* This function will also create a list of preprocessor defines for the GLSL compiler based on the shader flags
* and the supported GLSL version as reported by the GPU driver.
*
* @param shader shader_type enum defined with which shader we're loading
* @param filename C-string holding the filename (with extension) of the shader file
* @param flags integer variable holding a combination of SDR_* flags
* @return C-string holding the complete shader source code
*/
static SCP_string opengl_load_shader(const char* filename) {
SCP_string content;
if (Enable_external_shaders) {
CFILE* cf_shader = cfopen(filename, "rt", CFILE_NORMAL, CF_TYPE_EFFECTS);
if (cf_shader != NULL) {
int len = cfilelength(cf_shader);
content.resize(len);
cfread(&content[0], len + 1, 1, cf_shader);
cfclose(cf_shader);
return content;
}
}
//If we're still here, proceed with internals
mprintf((" Loading built-in default shader for: %s\n", filename));
auto def_shader = defaults_get_file(filename);
content.assign(reinterpret_cast<const char*>(def_shader.data), def_shader.size);
return content;
}
// -----------------------------------------------------------------------------
// Load Descent briefing text.
void load_screen_text(char *filename, char **buf)
{
CFILE *tfile;
CFILE *ifile;
int len, i;
int have_binary = 0;
if ((tfile = cfopen(filename,"rb")) == NULL) {
char nfilename[30], *ptr;
strcpy(nfilename, filename);
if ((ptr = strrchr(nfilename, '.')))
*ptr = '\0';
strcat(nfilename, ".txb");
if ((ifile = cfopen(nfilename, "rb")) == NULL)
Error("Cannot open file %s or %s", filename, nfilename);
have_binary = 1;
len = cfilelength(ifile);
MALLOC(*buf,char, len);
cfread(*buf, 1, len, ifile);
cfclose(ifile);
} else {
static bool load_cached_shader_binary(opengl::ShaderProgram* program, const SCP_string& hash) {
if (!do_shader_caching()) {
return false;
}
auto base_filename = SCP_string("ogl_shader-") + hash;
auto metadata = base_filename + ".json";
auto binary = base_filename + ".bin";
auto metadata_fp = cfopen(metadata.c_str(), "rb", CFILE_NORMAL, CF_TYPE_CACHE, false,
CF_LOCATION_ROOT_USER | CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT);
if (!metadata_fp) {
nprintf(("ShaderCache", "Metadata file does not exist.\n"));
return false;
}
auto size = cfilelength(metadata_fp);
SCP_string metadata_content;
metadata_content.resize((size_t) size);
cfread(&metadata_content[0], 1, size, metadata_fp);
cfclose(metadata_fp);
auto metadata_root = json_loads(metadata_content.c_str(), 0, nullptr);
if (!metadata_root) {
mprintf(("Loading of cache metadata failed! Falling back to GLSL shader...\n"));
return false;
}
json_int_t format;
if (json_unpack(metadata_root, "{sI}", "format", &format) != 0) {
mprintf(("Failed to unpack values from metadata JSON! Falling back to GLSL shader...\n"));
return false;
}
auto binary_format = (GLenum) format;
json_decref(metadata_root);
bool supported = false;
for (auto supported_fmt : GL_binary_formats) {
if ((GLenum)supported_fmt == binary_format) {
supported = true;
break;
}
}
if (!supported) {
// This can happen in case an implementation stops supporting a particular binary format
nprintf(("ShaderCache", "Unsupported binary format %d encountered in shader cache.\n", binary_format));
return false;
}
auto binary_fp = cfopen(binary.c_str(), "rb", CFILE_NORMAL, CF_TYPE_CACHE, false,
CF_LOCATION_ROOT_USER | CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT);
if (!binary_fp) {
nprintf(("ShaderCache", "Binary file does not exist.\n"));
return false;
}
GR_DEBUG_SCOPE("Loading cached shader");
SCP_vector<uint8_t> buffer;
int length = cfilelength(binary_fp);
buffer.resize((size_t) length);
cfread(&buffer[0], 1, length, binary_fp);
cfclose(binary_fp);
// Load the data!
glProgramBinary(program->getShaderHandle(), binary_format, buffer.data(), (GLsizei) buffer.size());
// Check the status...
GLint status;
glGetProgramiv(program->getShaderHandle(), GL_LINK_STATUS, &status);
return status == GL_TRUE;
}
// plays the voice file associated with a training message. Automatically streams the file
// from disk if it's over 100k, otherwise plays it as a normal file in memory. Returns -1
// if it didn't play, otherwise index of voice
int message_play_training_voice(int index)
{
int len;
CFILE *fp;
if (index < 0) {
if (Training_voice >= 0) {
if (Training_voice_type) {
audiostream_close_file(Training_voice_handle, 0);
} else {
snd_stop(Training_voice_handle);
}
}
Training_voice = -1;
return -1;
}
if (Message_waves[index].num < 0) {
fp = cfopen(Message_waves[index].name, "rb");
if (!fp)
return -1;
len = cfilelength(fp);
cfclose(fp);
if (len > 100000) {
if ((Training_voice < 0) || !Training_voice_type || (Training_voice != index)) {
if (Training_voice >= 0) {
if (Training_voice_type) {
if (Training_voice == index)
audiostream_stop(Training_voice_handle, 1, 0);
else
audiostream_close_file(Training_voice_handle, 0);
} else {
snd_stop(Training_voice_handle);
}
}
if (stricmp(Message_waves[index].name, NOX("none.wav"))) {
Training_voice_handle = audiostream_open(Message_waves[index].name, ASF_VOICE);
if (Training_voice_handle < 0) {
nprintf(("Warning", "Unable to load voice file %s\n", Message_waves[index].name));
// Warning(LOCATION, "Unable to load voice file %s\n", Message_waves[index].name);
}
}
} // Training_voice should be valid and loaded now
Training_voice_type = 1;
if (Training_voice_handle >= 0)
audiostream_play(Training_voice_handle, Master_voice_volume, 0);
Training_voice = index;
return Training_voice;
} else {
game_snd tmp_gs;
memset(&tmp_gs, 0, sizeof(game_snd));
strcpy(tmp_gs.filename, Message_waves[index].name);
Message_waves[index].num = snd_load(&tmp_gs, 0);
if (Message_waves[index].num < 0) {
nprintf(("Warning", "Cannot load message wave: %s. Will not play\n", Message_waves[index].name));
return -1;
}
}
}
if (Training_voice >= 0) {
if (Training_voice_type) {
audiostream_close_file(Training_voice_handle, 0);
} else {
snd_stop(Training_voice_handle);
}
}
Training_voice = index;
if (Message_waves[index].num >= 0)
Training_voice_handle = snd_play_raw(Message_waves[index].num, 0.0f);
else
Training_voice_handle = -1;
Training_voice_type = 0;
return Training_voice;
}
int piggy_init()
{
int sbytes = 0;
char temp_name_read[16];
char temp_name[16];
grs_bitmap temp_bitmap;
digi_sound temp_sound;
DiskBitmapHeader bmh;
DiskSoundHeader sndh;
int header_size, N_bitmaps, N_sounds;
int i,size, length, x, y;
char * filename;
int read_sounds = 1;
int Pigdata_start;
hashtable_init( &AllBitmapsNames, MAX_BITMAP_FILES );
hashtable_init( &AllDigiSndNames, MAX_SOUND_FILES );
if ( FindArg( "-nosound" ) || (digi_driver_board<1) ) {
read_sounds = 0;
mprintf(( 0, "Not loading sound data!!!!!\n" ));
}
for (i=0; i<MAX_SOUND_FILES; i++ ) {
GameSounds[i].length = 0;
GameSounds[i].data = NULL;
SoundOffset[i] = 0;
}
for (i=0; i<MAX_BITMAP_FILES; i++ ) {
GameBitmapXlat[i] = i;
GameBitmaps[i].bm_flags = BM_FLAG_PAGED_OUT;
}
if ( !bogus_bitmap_initialized ) {
int i;
ubyte c;
bogus_bitmap_initialized = 1;
memset( &bogus_bitmap, 0, sizeof(grs_bitmap) );
bogus_bitmap.bm_w = bogus_bitmap.bm_h = bogus_bitmap.bm_rowsize = 64;
bogus_bitmap.bm_data = bogus_data;
c = gr_find_closest_color( 0, 0, 63 );
for (i=0; i<4096; i++ ) bogus_data[i] = c;
c = gr_find_closest_color( 63, 0, 0 );
// Make a big red X !
for (i=0; i<64; i++ ) {
bogus_data[i*64+i] = c;
bogus_data[i*64+(63-i)] = c;
}
piggy_register_bitmap( &bogus_bitmap, "bogus", 1 );
bogus_sound.length = 64*64;
bogus_sound.data = bogus_data;
GameBitmapOffset[0] = 0;
}
filename = "DESCENT.PIG";
if ( FindArg( "-bigpig" ))
BigPig = 1;
if ( FindArg( "-lowmem" ))
piggy_low_memory = 1;
if ( FindArg( "-nolowmem" ))
piggy_low_memory = 0;
if (piggy_low_memory)
digi_lomem = 1;
if ( (i=FindArg( "-piggy" )) ) {
filename = Args[i+1];
mprintf( (0, "Using alternate pigfile, '%s'\n", filename ));
}
Piggy_fp = cfopen( filename, "rb" );
if (Piggy_fp==NULL) return 0;
cfread( &Pigdata_start, sizeof(int), 1, Piggy_fp );
#ifdef EDITOR
if ( FindArg("-nobm") )
#endif
{
bm_read_all( Piggy_fp ); // Note connection to above if!!!
cfread( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, Piggy_fp );
}
cfseek( Piggy_fp, Pigdata_start, SEEK_SET );
size = cfilelength(Piggy_fp) - Pigdata_start;
length = size;
mprintf( (0, "\nReading data (%d KB) ", size/1024 ));
cfread( &N_bitmaps, sizeof(int), 1, Piggy_fp );
size -= sizeof(int);
cfread( &N_sounds, sizeof(int), 1, Piggy_fp );
size -= sizeof(int);
header_size = (N_bitmaps*sizeof(DiskBitmapHeader)) + (N_sounds*sizeof(DiskSoundHeader));
x = 60; y = 189 * f2fl(Scale_y);
gr_set_curfont( Gamefonts[GFONT_SMALL] );
gr_set_fontcolor(gr_find_closest_color_current( 20, 20, 20 ),-1 );
gr_scale_printf( 0x8000, y-10*f2fl(Scale_y), Scale_factor, Scale_factor, "%s...", TXT_LOADING_DATA );
#ifdef OGLES
showRenderBuffer();
#endif
for (i=0; i<N_bitmaps; i++ ) {
cfread( &bmh, sizeof(DiskBitmapHeader), 1, Piggy_fp );
//size -= sizeof(DiskBitmapHeader);
memcpy( temp_name_read, bmh.name, 8 );
temp_name_read[8] = 0;
if ( bmh.dflags & DBM_FLAG_ABM )
sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
else
strcpy( temp_name, temp_name_read );
memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
if ( bmh.dflags & DBM_FLAG_LARGE )
temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width+256;
else
temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width;
temp_bitmap.bm_h = bmh.height;
temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
temp_bitmap.avg_color = bmh.avg_color;
temp_bitmap.bm_data = Piggy_bitmap_cache_data;
#ifdef OGLES
temp_bitmap.bm_ogles_tex_id = 0;
#endif
GameBitmapFlags[i+1] = 0;
if ( bmh.flags & BM_FLAG_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_TRANSPARENT;
if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_SUPER_TRANSPARENT;
if ( bmh.flags & BM_FLAG_NO_LIGHTING ) GameBitmapFlags[i+1] |= BM_FLAG_NO_LIGHTING;
if ( bmh.flags & BM_FLAG_RLE ) GameBitmapFlags[i+1] |= BM_FLAG_RLE;
GameBitmapOffset[i+1] = bmh.offset + header_size + (sizeof(int)*2) + Pigdata_start;
Assert( (i+1) == Num_bitmap_files );
piggy_register_bitmap( &temp_bitmap, temp_name, 1 );
}
for (i=0; i<N_sounds; i++ ) {
cfread( &sndh, sizeof(DiskSoundHeader), 1, Piggy_fp );
//size -= sizeof(DiskSoundHeader);
temp_sound.length = sndh.length;
temp_sound.data = (ubyte *)(sndh.offset + header_size + (sizeof(int)*2)+Pigdata_start);
SoundOffset[Num_sound_files] = sndh.offset + header_size + (sizeof(int)*2)+Pigdata_start;
memcpy( temp_name_read, sndh.name, 8 );
temp_name_read[8] = 0;
piggy_register_sound( &temp_sound, temp_name_read, 1 );
sbytes += sndh.length;
//mprintf(( 0, "%d bytes of sound\n", sbytes ));
}
SoundBits = malloc( sbytes + 16 );
if ( SoundBits == NULL )
Error( "Not enough memory to load DESCENT.PIG sounds\n" );
#ifdef EDITOR
Piggy_bitmap_cache_size = size - header_size - sbytes + 16;
Assert( Piggy_bitmap_cache_size > 0 );
#else
Piggy_bitmap_cache_size = PIGGY_BUFFER_SIZE;
#endif
BitmapBits = malloc( Piggy_bitmap_cache_size );
if ( BitmapBits == NULL )
Error( "Not enough memory to load DESCENT.PIG bitmaps\n" );
Piggy_bitmap_cache_data = BitmapBits;
Piggy_bitmap_cache_next = 0;
mprintf(( 0, "\nBitmaps: %d KB Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
atexit(piggy_close_file);
// mprintf( (0, "<<<<Paging in all piggy bitmaps...>>>>>" ));
// for (i=0; i < Num_bitmap_files; i++ ) {
// bitmap_index bi;
// bi.index = i;
// PIGGY_PAGE_IN( bi );
// }
// mprintf( (0, "\n (USed %d / %d KB)\n", Piggy_bitmap_cache_next/1024, (size - header_size - sbytes + 16)/1024 ));
// key_getch();
return 0;
}
void credits_init()
{
int i, w, h;
credits_screen_buttons *b;
char line[512] = "";
char *linep1, *linep2;
int credits_spooled_music_index = event_music_get_spooled_music_index("Cinema");
if(credits_spooled_music_index != -1){
char *credits_wavfile_name = Spooled_music[credits_spooled_music_index].filename;
if(credits_wavfile_name != NULL){
credits_load_music(credits_wavfile_name);
}
}
// Use this id to trigger the start of music playing on the briefing screen
Credits_music_begin_timestamp = timestamp(CREDITS_MUSIC_DELAY);
Credits_frametime = 0;
Credits_last_time = timer_get_milliseconds();
Credit_text = NULL;
Credit_text_malloced = 0;
// allocate enough space for credits text
CFILE *fp = cfopen( NOX("credits.tbl"), "rb" );
if(fp != NULL){
int rval, size;
size = cfilelength(fp);
Credit_text = (char *) vm_malloc(size + 200 + strlen(fs2_open_credit_text) + strlen(unmodified_credits));
if (Credit_text == NULL) {
return;
} else {
Credit_text_malloced = 1;
}
cfclose(fp);
// open localization
lcl_ext_open();
if ((rval = setjmp(parse_abort)) != 0) {
mprintf(("TABLES: Unable to parse '%s'! Error code = %i.\n", "credits.tbl", rval));
lcl_ext_close();
return;
}
read_file_text("credits.tbl");
reset_parse();
// keep reading everything in
strcpy(Credit_text, fs2_open_credit_text);
bool first_run = true;
while(!check_for_string_raw("#end")){
stuff_string_line(line, sizeof(line));
// This is a bit odd but it means if a total conversion uses different credits the
// Volition credit won't happen
if(first_run == true)
{
if(strcmp(line, mod_check) == 0)
{
strcat(Credit_text, unmodified_credits);
}
first_run = false;
}
linep1 = line;
do {
linep2 = split_str_once(linep1, Credits_text_coords[gr_screen.res][2]);
Assert( linep2 != linep1 );
strcat(Credit_text, linep1);
strcat(Credit_text, "\n");
linep1 = linep2;
} while (linep2 != NULL);
}
// close localization
lcl_ext_close();
} else {
Credit_text = NOX("No credits available.\n");
}
int ch;
for ( i = 0; Credit_text[i]; i++ ) {
ch = Credit_text[i];
switch (ch) {
case -4:
ch = 129;
break;
case -28:
ch = 132;
break;
case -10:
ch = 148;
break;
case -23:
ch = 130;
break;
case -30:
ch = 131;
break;
case -25:
ch = 135;
break;
case -21:
ch = 137;
break;
case -24:
ch = 138;
break;
case -17:
ch = 139;
break;
case -18:
ch = 140;
break;
case -60:
ch = 142;
break;
case -55:
ch = 144;
break;
case -12:
ch = 147;
break;
case -14:
ch = 149;
break;
case -5:
ch = 150;
break;
case -7:
ch = 151;
break;
case -42:
ch = 153;
break;
case -36:
ch = 154;
break;
case -31:
ch = 160;
break;
case -19:
ch = 161;
break;
case -13:
ch = 162;
break;
case -6:
ch = 163;
break;
case -32:
ch = 133;
break;
case -22:
ch = 136;
break;
case -20:
ch = 141;
break;
}
Credit_text[i] = (char)ch;
}
gr_get_string_size(&w, &h, Credit_text);
Credit_start_pos = i2fl(Credits_text_coords[gr_screen.res][CREDITS_H_COORD]);
Credit_stop_pos = -i2fl(h);
Credit_position = Credit_start_pos;
Ui_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
Ui_window.set_mask_bmap(Credits_bitmap_mask_fname[gr_screen.res]);
common_set_interface_palette("InterfacePalette"); // set the interface palette
for (i=0; i<NUM_BUTTONS; i++) {
b = &Buttons[i][gr_screen.res];
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 some text
Ui_window.add_XSTR("Technical Database", 1055, Buttons[TECH_DATABASE_BUTTON][gr_screen.res].xt, Buttons[TECH_DATABASE_BUTTON][gr_screen.res].yt, &Buttons[TECH_DATABASE_BUTTON][gr_screen.res].button, UI_XSTR_COLOR_GREEN);
Ui_window.add_XSTR("Mission Simulator", 1056, Buttons[SIMULATOR_BUTTON][gr_screen.res].xt, Buttons[SIMULATOR_BUTTON][gr_screen.res].yt, &Buttons[SIMULATOR_BUTTON][gr_screen.res].button, UI_XSTR_COLOR_GREEN);
Ui_window.add_XSTR("Cutscenes", 1057, Buttons[CUTSCENES_BUTTON][gr_screen.res].xt, Buttons[CUTSCENES_BUTTON][gr_screen.res].yt, &Buttons[CUTSCENES_BUTTON][gr_screen.res].button, UI_XSTR_COLOR_GREEN);
Ui_window.add_XSTR("Credits", 1058, Buttons[CREDITS_BUTTON][gr_screen.res].xt, Buttons[CREDITS_BUTTON][gr_screen.res].yt, &Buttons[CREDITS_BUTTON][gr_screen.res].button, UI_XSTR_COLOR_GREEN);
Ui_window.add_XSTR("Exit", 1420, Buttons[EXIT_BUTTON][gr_screen.res].xt, Buttons[EXIT_BUTTON][gr_screen.res].yt, &Buttons[EXIT_BUTTON][gr_screen.res].button, UI_XSTR_COLOR_PINK);
if (Player->flags & PLAYER_FLAGS_IS_MULTI) {
Buttons[SIMULATOR_BUTTON][gr_screen.res].button.disable();
Buttons[CUTSCENES_BUTTON][gr_screen.res].button.disable();
}
Buttons[EXIT_BUTTON][gr_screen.res].button.set_hotkey(KEY_CTRLED | KEY_ENTER);
Background_bitmap = bm_load(Credits_bitmap_fname[gr_screen.res]);
Credits_artwork_index = rand() % NUM_IMAGES;
for (i=0; i<NUM_IMAGES; i++){
Credits_bmps[i] = -1;
}
// CreditsWin01 = bm_load(NOX("CreditsWin01"));
// CreditsWin02 = bm_load(NOX("CreditsWin02"));
// CreditsWin03 = bm_load(NOX("CreditsWin03"));
// CreditsWin04 = bm_load(NOX("CreditsWin04"));
}
//reads a binary file containing a 3d model
polymodel *read_model_file(polymodel *pm,char *filename,robot_info *r)
{
CFILE *ifile;
short version;
int id,len, next_chunk;
ubyte model_buf[MODEL_BUF_SIZE];
if ((ifile=cfopen(filename,"rb"))==NULL)
Error("Can't open file <%s>",filename);
Assert(cfilelength(ifile) <= MODEL_BUF_SIZE);
Pof_addr = 0;
Pof_file_end = cfread(model_buf, 1, cfilelength(ifile), ifile);
cfclose(ifile);
id = pof_read_int(model_buf);
if (id!=0x4f505350) /* 'OPSP' */
Error("Bad ID in model file <%s>",filename);
version = pof_read_short(model_buf);
if (version < PM_COMPATIBLE_VERSION || version > PM_OBJFILE_VERSION)
Error("Bad version (%d) in model file <%s>",version,filename);
while (new_pof_read_int(id,model_buf) == 1) {
id = INTEL_INT(id);
//id = pof_read_int(model_buf);
len = pof_read_int(model_buf);
next_chunk = Pof_addr + len;
switch (id) {
case ID_OHDR: { //Object header
vms_vector pmmin,pmmax;
pm->n_models = pof_read_int(model_buf);
pm->rad = pof_read_int(model_buf);
Assert(pm->n_models <= MAX_SUBMODELS);
pof_read_vecs(&pmmin,1,model_buf);
pof_read_vecs(&pmmax,1,model_buf);
break;
}
case ID_SOBJ: { //Subobject header
int n;
n = pof_read_short(model_buf);
Assert(n < MAX_SUBMODELS);
pm->submodel_parents[n] = pof_read_short(model_buf);
pof_read_vecs(&pm->submodel_norms[n],1,model_buf);
pof_read_vecs(&pm->submodel_pnts[n],1,model_buf);
pof_read_vecs(&pm->submodel_offsets[n],1,model_buf);
pm->submodel_rads[n] = pof_read_int(model_buf); //radius
pm->submodel_ptrs[n] = pof_read_int(model_buf); //offset
break;
}
#ifndef DRIVE
case ID_GUNS: { //List of guns on this object
if (r) {
int i;
vms_vector gun_dir;
r->n_guns = pof_read_int(model_buf);
Assert(r->n_guns <= MAX_GUNS);
for (i=0;i<r->n_guns;i++) {
int id;
id = pof_read_short(model_buf);
r->gun_submodels[id] = pof_read_short(model_buf);
Assert(r->gun_submodels[id] != 0xff);
pof_read_vecs(&r->gun_points[id],1,model_buf);
if (version >= 7)
pof_read_vecs(&gun_dir,1,model_buf);
}
}
else
pof_cfseek(model_buf,len,SEEK_CUR);
break;
}
case ID_ANIM: //Animation data
if (r) {
int n_frames,f,m;
n_frames = pof_read_short(model_buf);
Assert(n_frames == N_ANIM_STATES);
for (m=0;m<pm->n_models;m++)
for (f=0;f<n_frames;f++)
pof_read_angvecs(&anim_angs[f][m], 1, model_buf);
robot_set_angles(r,pm,anim_angs);
}
else
pof_cfseek(model_buf,len,SEEK_CUR);
break;
#endif
case ID_TXTR: { //Texture filename list
int n;
char name_buf[128];
n = pof_read_short(model_buf);
while (n--) {
pof_read_string(name_buf,128,model_buf);
}
break;
}
case ID_IDTA: //Interpreter data
pm->model_data = d_malloc(len);
pm->model_data_size = len;
pof_cfread(pm->model_data,1,len,model_buf);
break;
default:
pof_cfseek(model_buf,len,SEEK_CUR);
break;
}
if ( version >= 8 ) // Version 8 needs 4-byte alignment!!!
pof_cfseek(model_buf,next_chunk,SEEK_SET);
}
#ifdef WORDS_NEED_ALIGNMENT
align_polygon_model_data(pm);
#endif
#ifdef WORDS_BIGENDIAN
swap_polygon_model_data(pm->model_data);
#endif
return pm;
}
int piggy_init()
{
int sbytes = 0;
char temp_name_read[16];
char temp_name[16];
grs_bitmap temp_bitmap;
digi_sound temp_sound;
DiskBitmapHeader bmh;
DiskSoundHeader sndh;
int header_size, N_bitmaps, N_sounds;
int i,size, length;
char * filename;
int read_sounds = 1;
int Pigdata_start;
hashtable_init( &AllBitmapsNames, MAX_BITMAP_FILES );
// hashtable_init( &AllDigiSndNames, MAX_SOUND_FILES );
if (GameBitmaps == NULL) {
GameBitmaps = (grs_bitmap *)mymalloc(sizeof(grs_bitmap) * MAX_BITMAP_FILES);
if (GameBitmaps == NULL)
Error("Cannot allocate space for game bitmaps in piggy.c");
}
if (AllBitmaps == NULL) {
AllBitmaps = (BitmapFile *)mymalloc(sizeof(BitmapFile) * MAX_BITMAP_FILES);
if (AllBitmaps == NULL)
Error("Cannot allocate space for bitmap filenames in piggy.c");
}
#if 0
if (AllSounds == NULL) {
AllSounds = (SoundFile *)mymalloc(sizeof(SoundFile) * MAX_SOUND_FILES);
if (AllSounds == NULL)
Error("Cannot allocate space for sound filenames in piggy.c");
}
if ( FindArg( "-nosound" ) || (digi_driver_board<1) ) {
read_sounds = 0;
mprintf(( 0, "Not loading sound data!!!!!\n" ));
}
for (i=0; i<MAX_SOUND_FILES; i++ ) {
GameSounds[i].length = 0;
GameSounds[i].data = NULL;
SoundOffset[i] = 0;
}
#endif
for (i=0; i<MAX_BITMAP_FILES; i++ )
GameBitmapXlat[i] = i;
if ( !bogus_bitmap_initialized ) {
int i;
ubyte c;
bogus_bitmap_initialized = 1;
memset( &bogus_bitmap, 0, sizeof(grs_bitmap) );
bogus_bitmap.bm_w = bogus_bitmap.bm_h = bogus_bitmap.bm_rowsize = 64;
bogus_bitmap.bm_data = bogus_data;
c = gr_find_closest_color( 0, 0, 63 );
for (i=0; i<4096; i++ ) bogus_data[i] = c;
c = gr_find_closest_color( 63, 0, 0 );
// Make a big red X !
for (i=0; i<64; i++ ) {
bogus_data[i*64+i] = c;
bogus_data[i*64+(63-i)] = c;
}
piggy_register_bitmap( &bogus_bitmap, "bogus", 1 );
bogus_sound.length = 64*64;
bogus_sound.data = bogus_data;
GameBitmapOffset[0] = 0;
}
filename = ":Data:DESCENT.PIG";
if ( FindArg( "-bigpig" ))
BigPig = 1;
if ( FindArg( "-lowmem" ))
piggy_low_memory = 1;
if ( FindArg( "-nolowmem" ))
piggy_low_memory = 0;
if (use_alt_textures)
piggy_low_memory = 1;
//MWA if (piggy_low_memory)
//MWA digi_lomem = 1;
if ( (i=FindArg( "-piggy" )) ) {
filename = Args[i+1];
mprintf( (0, "Using alternate pigfile, '%s'\n", filename ));
}
Piggy_fp = cfopen( filename, "rb" );
if (Piggy_fp==NULL) return 0;
Pigdata_start = read_int_swap(Piggy_fp);
#ifdef EDITOR
if ( FindArg("-nobm") )
#endif
{
bm_read_all( Piggy_fp ); // Note connection to above if!!!
for (i = 0; i < MAX_BITMAP_FILES; i++)
GameBitmapXlat[i] = read_short_swap(Piggy_fp);
digi_load_sounds();
}
cfseek( Piggy_fp, Pigdata_start, SEEK_SET );
size = cfilelength(Piggy_fp) - Pigdata_start;
length = size;
mprintf( (0, "\nReading data (%d KB) ", size/1024 ));
N_bitmaps = read_int_swap(Piggy_fp);
size -= sizeof(int);
N_sounds = read_int_swap(Piggy_fp);
size -= sizeof(int);
// header_size = (N_bitmaps*sizeof(DiskBitmapHeader)) + (N_sounds*sizeof(DiskSoundHeader));
header_size = ((N_bitmaps*17) + (N_sounds*20));
gr_set_curfont( Gamefonts[GFONT_SMALL] );
gr_set_fontcolor(gr_find_closest_color_current( 20, 20, 20 ),-1 );
gr_printf( 0x8000, grd_curcanv->cv_bitmap.bm_h - 25, "%s...", TXT_LOADING_DATA );
bitblt_to_screen();
// put a couple of event loop calls here. This should take care of TM driver!!!
process_one_event();
process_one_event();
process_one_event();
process_one_event();
for (i=0; i<N_bitmaps; i++ ) {
cfread(bmh.name, 8, 1, Piggy_fp);
bmh.dflags = read_byte(Piggy_fp);
bmh.width = read_byte(Piggy_fp);
bmh.height = read_byte(Piggy_fp);
bmh.flags = read_byte(Piggy_fp);
bmh.avg_color = read_byte(Piggy_fp);
bmh.offset = read_int_swap(Piggy_fp);
//size -= sizeof(DiskBitmapHeader);
memcpy( temp_name_read, bmh.name, 8 );
temp_name_read[8] = 0;
if ( bmh.dflags & DBM_FLAG_ABM )
sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
else
strcpy( temp_name, temp_name_read );
memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
if ( bmh.dflags & DBM_FLAG_LARGE )
temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width+256;
else
temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width;
temp_bitmap.bm_h = bmh.height;
temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
temp_bitmap.avg_color = bmh.avg_color;
temp_bitmap.bm_data = Piggy_bitmap_cache_data;
// HACK HACK HACK!!!!!
if (!strnicmp(bmh.name, "cockpit", 7) || !strnicmp(bmh.name, "status", 6) || !strnicmp(bmh.name, "rearview", 8)) {
temp_bitmap.bm_w = temp_bitmap.bm_rowsize = 640;
}
if (!strnicmp(bmh.name, "cockpit", 7) || !strnicmp(bmh.name, "rearview", 8))
temp_bitmap.bm_h = 480;
GameBitmapFlags[i+1] = 0;
if ( bmh.flags & BM_FLAG_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_TRANSPARENT;
if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_SUPER_TRANSPARENT;
if ( bmh.flags & BM_FLAG_NO_LIGHTING ) GameBitmapFlags[i+1] |= BM_FLAG_NO_LIGHTING;
if ( bmh.flags & BM_FLAG_RLE ) GameBitmapFlags[i+1] |= BM_FLAG_RLE;
GameBitmapOffset[i+1] = bmh.offset + header_size + (sizeof(int)*2) + Pigdata_start;
Assert( (i+1) == Num_bitmap_files );
piggy_register_bitmap( &temp_bitmap, temp_name, 1 );
}
#if 0
for (i=0; i<N_sounds; i++ ) {
cfread(sndh.name, 8, 1, Piggy_fp);
sndh.length = read_int_swap(Piggy_fp);
sndh.data_length = read_int_swap(Piggy_fp);
sndh.offset = read_int_swap(Piggy_fp);
//size -= sizeof(DiskSoundHeader);
temp_sound.length = sndh.length;
temp_sound.data = (ubyte *)(sndh.offset + header_size + (sizeof(int)*2)+Pigdata_start);
SoundOffset[Num_sound_files] = sndh.offset + header_size + (sizeof(int)*2)+Pigdata_start;
memcpy( temp_name_read, sndh.name, 8 );
temp_name_read[8] = 0;
piggy_register_sound( &temp_sound, temp_name_read, 1 );
sbytes += sndh.length;
//mprintf(( 0, "%d bytes of sound\n", sbytes ));
}
SoundBits = mymalloc( sbytes + 16 );
if ( SoundBits == NULL )
Error( "Not enough memory to load DESCENT.PIG sounds\n" );
#endif
#ifdef EDITOR
Piggy_bitmap_cache_size = size - header_size - sbytes + 16;
Assert( Piggy_bitmap_cache_size > 0 );
#else
if (!piggy_low_memory)
Piggy_bitmap_cache_size = PIGGY_BUFFER_SIZE;
else
Piggy_bitmap_cache_size = LOW_PIGGY_BUFFER_SIZE;
#endif
BitmapBits = mymalloc( Piggy_bitmap_cache_size );
if ( BitmapBits == NULL )
Error( "Not enough memory to load DESCENT.PIG bitmaps\n" );
Piggy_bitmap_cache_data = BitmapBits;
Piggy_bitmap_cache_next = 0;
mprintf(( 0, "\nBitmaps: %d KB Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
atexit(piggy_close_file);
// mprintf( (0, "<<<<Paging in all piggy bitmaps...>>>>>" ));
// for (i=0; i < Num_bitmap_files; i++ ) {
// bitmap_index bi;
// bi.index = i;
// PIGGY_PAGE_IN( bi );
// }
// mprintf( (0, "\n (USed %d / %d KB)\n", Piggy_bitmap_cache_next/1024, (size - header_size - sbytes + 16)/1024 ));
// key_getch();
return 0;
}
static bool load_cached_shader_binary(opengl::ShaderProgram* program, SCP_string hash) {
if (!do_shader_caching()) {
return false;
}
auto base_filename = SCP_string("ogl_shader-") + hash;
auto metadata = base_filename + ".json";
auto binary = base_filename + ".bin";
auto metadata_fp = cfopen(metadata.c_str(), "rb", CFILE_NORMAL, CF_TYPE_CACHE);
if (!metadata_fp) {
nprintf(("ShaderCache", "Metadata file does not exist.\n"));
return false;
}
auto size = cfilelength(metadata_fp);
SCP_string metadata_content;
metadata_content.resize((size_t) size);
cfread(&metadata_content[0], 1, size, metadata_fp);
cfclose(metadata_fp);
auto metadata_root = json_loads(metadata_content.c_str(), 0, nullptr);
if (!metadata_root) {
mprintf(("Loading of cache metadata failed! Falling back to GLSL shader...\n"));
return false;
}
json_int_t format;
if (json_unpack(metadata_root, "{sI}", "format", &format) != 0) {
mprintf(("Failed to unpack values from metadata JSON! Falling back to GLSL shader...\n"));
return false;
}
auto binary_format = (GLenum) format;
json_decref(metadata_root);
auto binary_fp = cfopen(binary.c_str(), "rb", CFILE_NORMAL, CF_TYPE_CACHE);
if (!binary_fp) {
nprintf(("ShaderCache", "Binary file does not exist.\n"));
return false;
}
GR_DEBUG_SCOPE("Loading cached shader");
SCP_vector<uint8_t> buffer;
int length = cfilelength(binary_fp);
buffer.resize((size_t) length);
cfread(&buffer[0], 1, length, binary_fp);
cfclose(binary_fp);
// Load the data!
glProgramBinary(program->getShaderHandle(), binary_format, buffer.data(), (GLsizei) buffer.size());
// Check the status...
GLint status;
glGetProgramiv(program->getShaderHandle(), GL_LINK_STATUS, &status);
return status == GL_TRUE;
}
int do_ipc(int qid, struct msgbuf *buf, int flags)
{
int ipc_read;
CFILE *fptr=NULL;
float last_volume = volume;
int l=0;
ipc_read = msgrcv(qid,buf,16,0,flags | MSG_NOERROR);
switch (ipc_read)
{
case -1:
if (errno == ENOMSG)
break;
perror("IPC trouble");
break;
case 0:
break;
default:
printf ("do_ipc %s\n", buf->mtext);//##########3
switch (buf->mtext[0])
{
case 'v':
volume=(double) (atof(buf->mtext+1)/128.0);
printf("vol %f->%f\n",last_volume,volume);
if (last_volume<=0 && volume>0) {
buf->mtext[0]='p';//start playing again if volume raised above 0
strcpy(buf->mtext+1, digi_last_midi_song);
//fall through to case 'p'
}else if (last_volume>0 && volume<=0) {
strcpy(buf->mtext, "s"); //stop playing if volume reduced to 0
stop = 2;
break;
}else
break;
case 'p':
if (buf->mtext[1]) {
strcpy(digi_last_midi_song, buf->mtext+1);
if (volume>0)
fptr=cfopen((buf->mtext+1),"rb");
}
if(fptr != NULL)
{
l = cfilelength(fptr);
data=realloc(data,(size_t) l);
cfread(data, l, 1, fptr);
cfclose(fptr);
printf ("good. fpr=%p l=%i data=%p\n", fptr, l, data);//##########3
stop = 0;
} else {
strcpy(buf->mtext, "s"); //not playing, thus "stop".
stop = 2;
}
break;
case 's':
stop = 2;
break;
case 'q':
// SDL_KillThread(player_thread);
break;
}
// printf ("do_ipc %s ret %i\n", buf->mtext, ipc_read);//##########3
}
return ipc_read;
}
//reads the gun information for a model
//fills in arrays gun_points & gun_dirs, returns the number of guns read
int read_model_guns(char *filename,vms_vector *gun_points, vms_vector *gun_dirs, int *gun_submodels)
{
CFILE *ifile;
short version;
int id,len;
int n_guns=0;
ubyte model_buf[MODEL_BUF_SIZE];
if ((ifile=cfopen(filename,"rb"))==NULL)
Error("Can't open file <%s>",filename);
Assert(cfilelength(ifile) <= MODEL_BUF_SIZE);
Pof_addr = 0;
Pof_file_end = cfread(model_buf, 1, cfilelength(ifile), ifile);
cfclose(ifile);
id = pof_read_int(model_buf);
if (id!=0x4f505350) /* 'OPSP' */
Error("Bad ID in model file <%s>",filename);
version = pof_read_short(model_buf);
Assert(version >= 7); //must be 7 or higher for this data
if (version < PM_COMPATIBLE_VERSION || version > PM_OBJFILE_VERSION)
Error("Bad version (%d) in model file <%s>",version,filename);
while (new_pof_read_int(id,model_buf) == 1) {
id = INTEL_INT(id);
//id = pof_read_int(model_buf);
len = pof_read_int(model_buf);
if (id == ID_GUNS) { //List of guns on this object
int i;
n_guns = pof_read_int(model_buf);
for (i=0;i<n_guns;i++) {
int id,sm;
id = pof_read_short(model_buf);
sm = pof_read_short(model_buf);
if (gun_submodels)
gun_submodels[id] = sm;
else if (sm!=0)
Error("Invalid gun submodel in file <%s>",filename);
pof_read_vecs(&gun_points[id],1,model_buf);
pof_read_vecs(&gun_dirs[id],1,model_buf);
}
}
else
pof_cfseek(model_buf,len,SEEK_CUR);
}
return n_guns;
}
//load all the text strings for Descent
void load_text()
{
CFILE *tfile;
CFILE *ifile;
int len,i, have_binary = 0;
char *tptr;
char *filename="descent.tex";
if ((i=FindArg("-text"))!=0)
filename = Args[i+1];
if ((tfile = cfopen(filename,"rb")) == NULL) {
filename="descent.txb";
if ((ifile = cfopen(filename, "rb")) == NULL)
Error("Cannot open file DESCENT.TEX or DESCENT.TXB");
have_binary = 1;
len = cfilelength(ifile);
//MALLOC(text,char,len);//Won't compile... working on it..-KRB
text=malloc(len*sizeof(char));//my hack -KRB
atexit(free_text);
cfread(text,1,len,ifile);
cfclose(ifile);
} else {
int c;
char * p;
len = cfilelength(tfile);
//MALLOC(text,char,len);//Won't compile... working on it..-KRB
text=malloc(len*sizeof(char));//my hack -KRB
atexit(free_text);
//fread(text,1,len,tfile);
p = text;
do {
c = cfgetc( tfile );
if ( c != 13 )
*p++ = c;
} while ( c!=EOF );
cfclose(tfile);
}
for (i=0,tptr=text;i<N_TEXT_STRINGS;i++) {
char *p;
Text_string[i] = tptr;
tptr = strchr(tptr,'\n');
if (!tptr)
Error("Not enough strings in text file - expecting %d, found %d",N_TEXT_STRINGS,i);
if ( tptr ) *tptr++ = 0;
if (have_binary) {
for (p=Text_string[i]; p < tptr - 1; p++) {
encode_rotate_left(p);
*p = *p ^ BITMAP_TBL_XOR;
encode_rotate_left(p);
}
}
//scan for special chars (like \n)
for (p=Text_string[i];p=strchr(p,'\\');) {
char newchar;
if (p[1] == 'n') newchar = '\n';
else if (p[1] == 't') newchar = '\t';
else if (p[1] == '\\') newchar = '\\';
else
Error("Unsupported key sequence <\\%c> on line %d of file <%s>",p[1],i+1,filename);
p[0] = newchar;
sprintf(p+1, "%s", p+2);
p++;
}
}
// Assert(tptr==text+len || tptr==text+len-2);
}
/**
* Load a shader file from disc or from the builtin defaults in def_files.cpp if none can be found.
* This function will also create a list of preprocessor defines for the GLSL compiler based on the shader flags
* and the supported GLSL version as reported by the GPU driver.
*
* @param filename C-string holding the filename (with extension) of the shader file
* @param flags integer variable holding a combination of SDR_* flags
* @return C-string holding the complete shader source code
*/
static char *opengl_load_shader(char *filename, int flags)
{
SCP_string sflags;
if (Use_GLSL >= 4) {
sflags += "#define SHADER_MODEL 4\n";
} else if (Use_GLSL == 3) {
sflags += "#define SHADER_MODEL 3\n";
} else {
sflags += "#define SHADER_MODEL 2\n";
}
if (flags & SDR_FLAG_DIFFUSE_MAP) {
sflags += "#define FLAG_DIFFUSE_MAP\n";
}
if (flags & SDR_FLAG_ENV_MAP) {
sflags += "#define FLAG_ENV_MAP\n";
}
if (flags & SDR_FLAG_FOG) {
sflags += "#define FLAG_FOG\n";
}
if (flags & SDR_FLAG_GLOW_MAP) {
sflags += "#define FLAG_GLOW_MAP\n";
}
if (flags & SDR_FLAG_HEIGHT_MAP) {
sflags += "#define FLAG_HEIGHT_MAP\n";
}
if (flags & SDR_FLAG_LIGHT) {
sflags += "#define FLAG_LIGHT\n";
}
if (flags & SDR_FLAG_NORMAL_MAP) {
sflags += "#define FLAG_NORMAL_MAP\n";
}
if (flags & SDR_FLAG_SPEC_MAP) {
sflags += "#define FLAG_SPEC_MAP\n";
}
if (flags & SDR_FLAG_ANIMATED) {
sflags += "#define FLAG_ANIMATED\n";
}
if (flags & SDR_FLAG_DISTORTION) {
sflags += "#define FLAG_DISTORTION\n";
}
if (flags & SDR_FLAG_MISC_MAP) {
sflags += "#define FLAG_MISC_MAP\n";
}
if (flags & SDR_FLAG_TEAMCOLOR) {
sflags += "#define FLAG_TEAMCOLOR\n";
}
if (flags & SDR_FLAG_THRUSTER) {
sflags += "#define FLAG_THRUSTER\n";
}
const char *shader_flags = sflags.c_str();
int flags_len = strlen(shader_flags);
if (Enable_external_shaders) {
CFILE *cf_shader = cfopen(filename, "rt", CFILE_NORMAL, CF_TYPE_EFFECTS);
if (cf_shader != NULL) {
int len = cfilelength(cf_shader);
char *shader = (char*) vm_malloc(len + flags_len + 1);
strcpy(shader, shader_flags);
memset(shader + flags_len, 0, len + 1);
cfread(shader + flags_len, len + 1, 1, cf_shader);
cfclose(cf_shader);
return shader;
}
}
//If we're still here, proceed with internals
mprintf((" Loading built-in default shader for: %s\n", filename));
char* def_shader = defaults_get_file(filename);
size_t len = strlen(def_shader);
char *shader = (char*) vm_malloc(len + flags_len + 1);
strcpy(shader, shader_flags);
strcat(shader, def_shader);
return shader;
}
//reads a binary file containing a 3d model
polymodel *read_model_file(polymodel *pm,char *filename,robot_info *r)
{
CFILE *ifile;
short version;
int id,len, next_chunk;
int anim_flag = 0;
ubyte *model_buf;
model_buf = (ubyte *)d_malloc( MODEL_BUF_SIZE * sizeof(ubyte) );
if (!model_buf)
Error("Can't allocate space to read model %s\n", filename);
if ((ifile=cfopen(filename,"rb"))==NULL)
Error("Can't open file <%s>",filename);
Assert(ifile->size <= MODEL_BUF_SIZE);
Pof_addr = 0;
Pof_file_end = cfread(model_buf, 1, cfilelength(ifile), ifile);
cfclose(ifile);
id = pof_read_int(model_buf);
if (id!=0x4f505350) /* 'OPSP' */
Error("Bad ID in model file <%s>",filename);
version = pof_read_short(model_buf);
if (version < PM_COMPATIBLE_VERSION || version > PM_OBJFILE_VERSION)
Error("Bad version (%d) in model file <%s>",version,filename);
if ( FindArg( "-bspgen" ))
printf( "bspgen -c1" );
while (new_pof_read_int(id,model_buf) == 1) {
id = INTEL_INT(id);
//id = pof_read_int(model_buf);
len = pof_read_int(model_buf);
next_chunk = Pof_addr + len;
switch (id) {
case ID_OHDR: { //Object header
vms_vector pmmin,pmmax;
//con_printf(DEBUG_LEVEL, "Got chunk OHDR, len=%d\n",len);
pm->n_models = pof_read_int(model_buf);
pm->rad = pof_read_int(model_buf);
Assert(pm->n_models <= MAX_SUBMODELS);
pof_read_vecs(&pmmin,1,model_buf);
pof_read_vecs(&pmmax,1,model_buf);
if ( FindArg( "-bspgen" )) {
vms_vector v;
fix l;
vm_vec_sub(&v, &pmmax, &pmmin );
l = v.x;
if ( v.y > l ) l = v.y;
if ( v.z > l ) l = v.z;
printf( " -l%.3f", f2fl(l) );
}
break;
}
case ID_SOBJ: { //Subobject header
int n;
anim_flag++;
//con_printf(DEBUG_LEVEL, "Got chunk SOBJ, len=%d\n",len);
n = pof_read_short(model_buf);
Assert(n < MAX_SUBMODELS);
pm->submodel_parents[n] = pof_read_short(model_buf);
pof_read_vecs(&pm->submodel_norms[n],1,model_buf);
pof_read_vecs(&pm->submodel_pnts[n],1,model_buf);
pof_read_vecs(&pm->submodel_offsets[n],1,model_buf);
pm->submodel_rads[n] = pof_read_int(model_buf); //radius
pm->submodel_ptrs[n] = pof_read_int(model_buf); //offset
break;
}
#ifndef DRIVE
case ID_GUNS: { //List of guns on this object
//con_printf(DEBUG_LEVEL, "Got chunk GUNS, len=%d\n",len);
if (r) {
int i;
vms_vector gun_dir;
ubyte gun_used[MAX_GUNS];
r->n_guns = pof_read_int(model_buf);
if ( r->n_guns )
anim_flag++;
Assert(r->n_guns <= MAX_GUNS);
for (i=0;i<r->n_guns;i++)
gun_used[i] = 0;
for (i=0;i<r->n_guns;i++) {
int id;
id = pof_read_short(model_buf);
Assert(id < r->n_guns);
Assert(gun_used[id] == 0);
gun_used[id] = 1;
r->gun_submodels[id] = pof_read_short(model_buf);
Assert(r->gun_submodels[id] != 0xff);
pof_read_vecs(&r->gun_points[id],1,model_buf);
if (version >= 7)
pof_read_vecs(&gun_dir,1,model_buf);
}
}
else
pof_cfseek(model_buf,len,SEEK_CUR);
break;
}
case ID_ANIM: //Animation data
//con_printf(DEBUG_LEVEL, "Got chunk ANIM, len=%d\n",len);
anim_flag++;
if (r) {
int n_frames,f,m;
n_frames = pof_read_short(model_buf);
Assert(n_frames == N_ANIM_STATES);
for (m=0;m<pm->n_models;m++)
for (f=0;f<n_frames;f++)
pof_read_angs(&anim_angs[f][m], 1, model_buf);
robot_set_angles(r,pm,anim_angs);
}
else
pof_cfseek(model_buf,len,SEEK_CUR);
break;
#endif
case ID_TXTR: { //Texture filename list
int n;
char name_buf[128];
//con_printf(DEBUG_LEVEL, "Got chunk TXTR, len=%d\n",len);
n = pof_read_short(model_buf);
//con_printf(DEBUG_LEVEL, " num textures = %d\n",n);
while (n--) {
pof_read_string(name_buf,128,model_buf);
//con_printf(DEBUG_LEVEL, "<%s>\n",name_buf);
}
break;
}
case ID_IDTA: //Interpreter data
//con_printf(DEBUG_LEVEL, "Got chunk IDTA, len=%d\n",len);
pm->model_data = d_malloc(len);
pm->model_data_size = len;
pof_cfread(pm->model_data,1,len,model_buf);
break;
default:
//con_printf(DEBUG_LEVEL, "Unknown chunk <%c%c%c%c>, len = %d\n",id,id>>8,id>>16,id>>24,len);
pof_cfseek(model_buf,len,SEEK_CUR);
break;
}
if ( version >= 8 ) // Version 8 needs 4-byte alignment!!!
pof_cfseek(model_buf,next_chunk,SEEK_SET);
}
// for (i=0;i<pm->n_models;i++)
// pm->submodel_ptrs[i] += (int) pm->model_data;
if ( FindArg( "-bspgen" )) {
char *p = strchr( filename, '.' );
*p = 0;
if ( anim_flag > 1 )
printf( " -a" );
printf( " %s.3ds\n", filename );
*p = '.';
}
d_free(model_buf);
#ifdef WORDS_NEED_ALIGNMENT
align_polygon_model_data(pm);
#endif
#ifdef WORDS_BIGENDIAN
swap_polygon_model_data(pm->model_data);
#endif
//verify(pm->model_data);
return pm;
}
