_image *create_image (const char* file, int x, int y, int w, int h, float u_start, float v_start, float u_end, float v_end)
{
_image *img=(_image *)calloc(1,sizeof(_image));
img->x=x;
img->y=y;
img->w=w;
img->h=h;
img->u[0]=u_start;
img->u[1]=u_end;
img->v[0]=v_start;
img->v[1]=v_end;
#ifdef NEW_TEXTURES
img->texture = load_texture_cached(file, tt_image);
#else /* NEW_TEXTURES */
img->texture=load_texture_cache(file,0);
#endif /* NEW_TEXTURES */
if(!img->texture) {
free(img);
img=NULL;
}
return img;
}
void init_books()
{
#ifdef NEW_TEXTURES
paper1_text = load_texture_cached ("textures/paper1.dds", tt_image);
book1_text = load_texture_cached ("textures/book1.dds", tt_image);
#else /* NEW_TEXTURES */
paper1_text = load_texture_cache_deferred ("./textures/paper1.bmp", 0);
book1_text = load_texture_cache_deferred ("./textures/book1.bmp", 0);
#endif /* NEW_TEXTURES */
read_book("books/races/human.xml", 2, book_human);
read_book("books/races/gnome.xml", 2, book_gnome); //Adding books out of order helps slightly for our tree.
read_book("books/races/dwarf.xml", 2, book_dwarf);
read_book("books/races/elf.xml", 2, book_elf);
read_book("books/races/orchan.xml", 2, book_orchan);
read_book("books/races/draegoni.xml", 2, book_draegoni);
read_knowledge_book_index();
}
void ParseSimage(xmlAttr *a_node)
{
xmlAttr *cur_attr=NULL;
for (cur_attr = a_node; cur_attr; cur_attr = cur_attr->next) {
if (cur_attr->type==XML_ATTRIBUTE_NODE){
//name=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"name")){
#ifdef NEW_TEXTURES
id = load_texture_cached((char*)cur_attr->children->content, tt_gui);
#else /* NEW_TEXTURES */
id=load_texture_cache_deferred((char*)cur_attr->children->content,0);
#endif /* NEW_TEXTURES */
}
//isize=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"isize")){
isize=atoi((char*)cur_attr->children->content);
}
//tsize=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"tsize")){
tsize=atoi((char*)cur_attr->children->content);
}
//tid=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"tid")){
tid=atoi((char*)cur_attr->children->content);
}
//size=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"size")){
ssize=atoi((char*)cur_attr->children->content);
}
//x=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"x")){
x=atoi((char*)cur_attr->children->content);
}
//y=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"y")){
y=atoi((char*)cur_attr->children->content);
}
//mouseover=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"mouseover")){
mouseover=atoi((char*)cur_attr->children->content);
}
//xposupdate=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"xposupdate")){
xposupdate=atoi((char*)cur_attr->children->content);
}
//yposupdate=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"yposupdate")){
yposupdate=atoi((char*)cur_attr->children->content);
}
}
}
}
int load_font(int num, char *file)
{
int i;
// error checking
if(num < 0 || num >= 10)
{
return -1;
}
// allocate space if needed
if(fonts[num] == NULL)
{
fonts[num]=(font_info *)calloc(1, sizeof(font_info));
if(fonts[num] == NULL)
{
log_error(__FILE__, __LINE__, "Unable to load font");
return -1;
}
}
//watch the highest font
if(num >= max_fonts)
{
max_fonts=num+1;
}
// set default font info
strcpy(fonts[num]->name, "default");
fonts[num]->spacing=0;
for(i=0; i<9*FONT_CHARS_PER_LINE; i++) fonts[num]->widths[i]=12;
// load texture
fonts[num]->texture_id = load_texture_cached(file, tt_font);
// load font information
// TODO: write this and remove the hack!
if(num > 0){
static int widths[]={
4,2,7,11,8,12,12,2,7,7,9,10,3,8,
2,10,10,10,8,8,10,7,9,9,9,9,3,3,
10,10,10,9,12,12,9,10,10,9,9,10,9,8,
7,11,8,11,10,11,9,11,11,9,10,9,12,12,
12,12,10,6,10,6,10,12,3,11,9,9,9,9,
8,9,9,4,6,10,4,11,9,10,9,9,8,8,
8,9,10,12,10,10,9,8,2,8,10,8,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,
};
memcpy(fonts[num]->widths, widths, sizeof(widths));
fonts[num]->spacing=4;
}
//and return
return num;
}
//load only the tiles that are on the map
void load_map_tiles()
{
int i;
int cur_tile;
char str[80];
for(i=0;i<tile_map_size_x*tile_map_size_y;i++)
{
cur_tile=tile_map[i];
//check to see if we already have the current tile loaded
if(!tile_list[cur_tile] && cur_tile!=255)//if it is 255, it's a null tile, don't load it
{
//tile not loaded, so load it
if(!cur_tile && dungeon) cur_tile=231;
sprintf(str,"./3dobjects/tile%i.dds",cur_tile);
tile_list[cur_tile] = load_texture_cached(str, tt_mesh);
}
}
}
static int add_knowledge_book_image(int window_id)
{
// Book image
int isize, tsize, tid, picsperrow, xtile, ytile, id;
float ftsize, u, v, uend, vend;
isize=256;
tsize=51;
tid=21;
picsperrow=isize/tsize;
xtile=tid%picsperrow;
ytile=tid/picsperrow;
ftsize=(float)tsize/isize;
u=ftsize*xtile;
v=-ftsize*ytile;
uend=u+ftsize;
vend=v-ftsize;
id = load_texture_cached("textures/items1", tt_gui);
return image_add_extended(window_id, 0, NULL, 0, 0, 0, 0, WIDGET_DISABLED, 1.0, 1.0, 1.0, 1.0, id, u, v, uend, vend, 0.05f);
}
int weather_parse_lightning(xmlNode *node)
{
xmlAttr *attr;
int ok = 1;
int id = lightnings_defs_count++;
lightnings_defs[id].texture = -1;
lightnings_defs[id].coords[0] = 0.0;
lightnings_defs[id].coords[1] = 0.0;
lightnings_defs[id].coords[2] = 0.0;
lightnings_defs[id].coords[3] = 0.0;
for (attr = node->properties; attr; attr = attr->next)
{
if (attr->type == XML_ATTRIBUTE_NODE)
{
if (!xmlStrcasecmp (attr->name, (xmlChar*)"texture"))
#ifdef NEW_TEXTURES
lightnings_defs[id].texture = load_texture_cached((char*)attr->children->content, tt_mesh);
#else /* NEW_TEXTURES */
lightnings_defs[id].texture = load_texture_cache((char*)attr->children->content, 0);
#endif /* NEW_TEXTURES */
else if (!xmlStrcasecmp (attr->name, (xmlChar*)"x1"))
lightnings_defs[id].coords[0] = atof((char*)attr->children->content);
else if (!xmlStrcasecmp (attr->name, (xmlChar*)"y1"))
lightnings_defs[id].coords[1] = atof((char*)attr->children->content);
else if (!xmlStrcasecmp (attr->name, (xmlChar*)"x2"))
lightnings_defs[id].coords[2] = atof((char*)attr->children->content);
else if (!xmlStrcasecmp (attr->name, (xmlChar*)"y2"))
lightnings_defs[id].coords[3] = atof((char*)attr->children->content);
else {
LOG_ERROR_OLD("unknown attribute for weather effect color: %s", (char*)attr->name);
ok = 0;
}
}
}
int switch_to_game_map()
{
#ifdef NEW_TEXTURES
char buffer[1024];
#else /* NEW_TEXTURES */
int len;
texture_cache_struct tex;
#endif /* NEW_TEXTURES */
short int cur_cont;
static short int old_cont = -1;
/* check we loaded the mapinfo data */
if (continent_maps == NULL || continent_maps[0].name == NULL)
{
LOG_TO_CONSOLE(c_yellow2,err_nomap_str);
return 0;
}
#ifdef NEW_TEXTURES
if (check_image_name(map_file_name, sizeof(buffer), buffer) == 1)
{
map_text = load_texture_cached(buffer, tt_image);
}
else
{
map_text = 0;
}
#else /* NEW_TEXTURES */
my_strcp(tex.file_name,map_file_name);
len=strlen(tex.file_name);
tex.file_name[len-3]='b';
tex.file_name[len-2]='m';
tex.file_name[len-1]='p';
tex.alpha = 128;
if (!el_file_exists(tex.file_name))
map_text = 0;
else
map_text=load_bmp8_fixed_alpha(&tex, tex.alpha);
#endif /* NEW_TEXTURES */
if(!map_text)
{
LOG_TO_CONSOLE(c_yellow2,err_nomap_str);
return 0;
}
if (cur_map < 0)
{
cur_cont = -1;
}
else
{
cur_cont = continent_maps[cur_map].cont;
}
if (cur_cont != old_cont && cur_cont >= 0 && cur_cont < nr_continents)
{
#ifdef NEW_TEXTURES
cont_text = load_texture_cached (cont_map_file_names[cur_cont], tt_image);
#else /* NEW_TEXTURES */
cont_text = load_texture_cache (cont_map_file_names[cur_cont], 128);
#endif /* NEW_TEXTURES */
old_cont = cur_cont;
}
#ifdef DEBUG_MAP_SOUND
cur_tab_map = cur_map;
#endif // DEBUG_MAP_SOUND
if(current_cursor != CURSOR_ARROW)
{
change_cursor(CURSOR_ARROW);
}
return 1;
}
void init_stuff()
{
int i;
int seed;
chdir(DATA_DIR);
#ifndef WINDOWS
setlocale(LC_NUMERIC,"en_US");
#endif
init_translatables();
//create_error_mutex();
init_globals();
init_crc_tables();
init_zip_archives();
cache_system_init(MAX_CACHE_SYSTEM);
init_texture_cache();
init_vars();
read_config();
file_check_datadir();
#ifdef LOAD_XML
//Well, the current version of the map editor doesn't support having a datadir - will add that later ;-)
load_translatables();
#endif
#ifdef LINUX
#ifdef GTK2
init_filters();
#else
file_selector = create_fileselection();
#endif
#endif //LINUX
init_gl();
window_resize();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glEnable(GL_NORMALIZE);
glClearColor( 0.0, 0.0, 0.0, 0.0 );
glClearStencil(0);
seed = time (NULL);
srand (seed);
init_texture_cache();
init_particles ();
init_e3d_cache();
init_2d_obj_cache();
for(i=0; i<256; i++)
tile_list[i]=0;
for (i = 0; i < MAX_LIGHTS; i++)
lights_list[i] = NULL;
new_map(256,256);
load_all_tiles();
//lights setup
build_global_light_table();
build_sun_pos_table();
reset_material();
init_lights();
//disable_local_lights();
//clear_error_log();
// Setup the new eye candy system
#ifdef EYE_CANDY
ec_init();
#endif //EYE_CANDY
init_gl_extensions();
if(have_multitexture)
#ifdef NEW_TEXTURES
ground_detail_text = load_texture_cached("./textures/ground_detail.bmp", tt_mesh);
#else /* NEW_TEXTURES */
ground_detail_text = load_texture_cache ("./textures/ground_detail.bmp",255);
#endif /* NEW_TEXTURES */
//load the fonts texture
init_fonts();
#ifdef NEW_TEXTURES
icons_text=load_texture_cached("./textures/gamebuttons.bmp", tt_gui);
buttons_text=load_texture_cached("./textures/buttons.bmp", tt_gui);
#else /* NEW_TEXTURES */
icons_text=load_texture_cache("./textures/gamebuttons.bmp",0);
buttons_text=load_texture_cache("./textures/buttons.bmp",0);
#endif /* NEW_TEXTURES */
//get the application home dir
have_multitexture=0;//debug only
#ifndef LINUX
GetCurrentDirectory(sizeof(exec_path),exec_path);
#else
exec_path[0]='.';exec_path[1]='/';exec_path[2]=0;
#endif
init_browser();
if(SDL_InitSubSystem(SDL_INIT_TIMER)<0)
{
char str[120];
snprintf(str, sizeof(str), "Couldn't initialize the timer: %s\n", SDL_GetError());
log_error(__FILE__, __LINE__, str);
SDL_Quit();
exit(1);
}
SDL_SetTimer (1000/(18*4), my_timer);
SDL_EnableUNICODE(1);
//we might want to do this later.
// creating windows
display_browser();
toggle_window(browser_win);
display_o3dow();
toggle_window(o3dow_win);
display_replace_window();
toggle_window(replace_window_win);
display_edit_window();
toggle_window(edit_window_win);
create_particles_window ();
}
void draw_window_alphaborder(window_info *win) {
int w = win->len_x, h= win->len_y; // width, height
if (!alpha_border_tex) {
#ifdef NEW_TEXTURES
alpha_border_tex = load_texture_cached("textures/alphaborder.dds", tt_image);
#else /* NEW_TEXTURES */
alpha_border_tex= load_texture_cache_deferred("textures/alphaborder.bmp", 0);
#endif /* NEW_TEXTURES */
if (!alpha_border_tex) return;
}
glColor3fv(win->back_color);
glBegin(GL_LINE_LOOP);
glVertex3i(0, 0, 0);
glVertex3i(w, 0, 0);
glVertex3i(w, h, 0);
glVertex3i(0, h, 0);
glEnd();
// The higher the alpha value (a=r+g+b/3) in the border texture,
// the darker the shadow
glEnable(GL_BLEND);
glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
#ifdef NEW_TEXTURES
bind_texture(alpha_border_tex);
#else /* NEW_TEXTURES */
get_and_set_texture_id(alpha_border_tex);
#endif /* NEW_TEXTURES */
glBegin(GL_QUADS);
/*
*
* r===============================i
* 11| |99
* 111| |999
* 111| |999
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222| |888
* 222'-------------------------------'888
* 333444555555555555555555555555555666777
* 333444555555555555555555555555555666777
* 3344455555555555555555555555555566677
* 4455555555555555555555555555566
*/
#ifdef NEW_TEXTURES
glTexCoord2f(1.0f, 1.0f); glVertex2i( - 8, 0);
glTexCoord2f(1.0f, 0.5f); glVertex2i( 0, 0);
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, 16);
glTexCoord2f(0.5f, 1.0f); glVertex2i( - 8, 16);
glTexCoord2f(0.5f, 1.0f); glVertex2i( - 8, 16);
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, 16);
glTexCoord2f(0.1f, 0.5f); glVertex2i( 0, h );
glTexCoord2f(0.1f, 1.0f); glVertex2i( - 8, h );
glTexCoord2f(0.5f, 1.0f); glVertex2i( - 8, h );
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, h );
glTexCoord2f(1.0f, 0.5f); glVertex2i( 0, h+16);
glTexCoord2f(1.0f, 1.0f); glVertex2i( - 8, h+16);
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, h );
glTexCoord2f(0.5f, 0.0f); glVertex2i( 8, h );
glTexCoord2f(1.0f, 0.0f); glVertex2i( 8, h+16);
glTexCoord2f(1.0f, 0.5f); glVertex2i( 0, h+16);
glTexCoord2f(0.1f, 0.0f); glVertex2i( 8, h );
glTexCoord2f(0.5f, 0.0f); glVertex2i(w- 8, h );
glTexCoord2f(0.5f, 1.0f); glVertex2i(w- 8, h+16);
glTexCoord2f(0.1f, 1.0f); glVertex2i( 8, h+16);
glTexCoord2f(0.5f, 0.0f); glVertex2i(w- 8, h );
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , h );
glTexCoord2f(1.0f, 0.5f); glVertex2i(w , h+16);
glTexCoord2f(1.0f, 0.0f); glVertex2i(w- 8, h+16);
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , h );
glTexCoord2f(0.5f, 1.0f); glVertex2i(w+ 8, h );
glTexCoord2f(1.0f, 1.0f); glVertex2i(w+ 8, h+16);
glTexCoord2f(1.0f, 0.5f); glVertex2i(w , h+16);
glTexCoord2f(0.1f, 0.5f); glVertex2i(w , 16);
glTexCoord2f(0.1f, 1.0f); glVertex2i(w+ 8, 16);
glTexCoord2f(0.5f, 1.0f); glVertex2i(w+ 8, h );
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , h );
glTexCoord2f(1.0f, 0.5f); glVertex2i(w , 0);
glTexCoord2f(1.0f, 1.0f); glVertex2i(w+ 8, 0);
glTexCoord2f(0.5f, 1.0f); glVertex2i(w+ 8, 16);
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , 16);
#else /* NEW_TEXTURES */
glTexCoord2f(1.0f, 0.0f); glVertex2i( - 8, 0);
glTexCoord2f(1.0f, 0.5f); glVertex2i( 0, 0);
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, 16);
glTexCoord2f(0.5f, 0.0f); glVertex2i( - 8, 16);
glTexCoord2f(0.5f, 0.0f); glVertex2i( - 8, 16);
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, 16);
glTexCoord2f(0.1f, 0.5f); glVertex2i( 0, h );
glTexCoord2f(0.1f, 0.0f); glVertex2i( - 8, h );
glTexCoord2f(0.5f, 0.0f); glVertex2i( - 8, h );
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, h );
glTexCoord2f(1.0f, 0.5f); glVertex2i( 0, h+16);
glTexCoord2f(1.0f, 0.0f); glVertex2i( - 8, h+16);
glTexCoord2f(0.5f, 0.5f); glVertex2i( 0, h );
glTexCoord2f(0.5f, 1.0f); glVertex2i( 8, h );
glTexCoord2f(1.0f, 1.0f); glVertex2i( 8, h+16);
glTexCoord2f(1.0f, 0.5f); glVertex2i( 0, h+16);
glTexCoord2f(0.1f, 1.0f); glVertex2i( 8, h );
glTexCoord2f(0.5f, 1.0f); glVertex2i(w- 8, h );
glTexCoord2f(0.5f, 0.0f); glVertex2i(w- 8, h+16);
glTexCoord2f(0.1f, 0.0f); glVertex2i( 8, h+16);
glTexCoord2f(0.5f, 1.0f); glVertex2i(w- 8, h );
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , h );
glTexCoord2f(1.0f, 0.5f); glVertex2i(w , h+16);
glTexCoord2f(1.0f, 1.0f); glVertex2i(w- 8, h+16);
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , h );
glTexCoord2f(0.5f, 0.0f); glVertex2i(w+ 8, h );
glTexCoord2f(1.0f, 0.0f); glVertex2i(w+ 8, h+16);
glTexCoord2f(1.0f, 0.5f); glVertex2i(w , h+16);
glTexCoord2f(0.1f, 0.5f); glVertex2i(w , 16);
glTexCoord2f(0.1f, 0.0f); glVertex2i(w+ 8, 16);
glTexCoord2f(0.5f, 0.0f); glVertex2i(w+ 8, h );
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , h );
glTexCoord2f(1.0f, 0.5f); glVertex2i(w , 0);
glTexCoord2f(1.0f, 0.0f); glVertex2i(w+ 8, 0);
glTexCoord2f(0.5f, 0.0f); glVertex2i(w+ 8, 16);
glTexCoord2f(0.5f, 0.5f); glVertex2i(w , 16);
#endif /* NEW_TEXTURES */
glEnd();
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
static obj_2d_def* load_obj_2d_def(const char *file_name)
{
int f_size;
int i,k,l;
el_file_ptr file = NULL;
char cur_dir[200]={0};
obj_2d_def *cur_object;
char *obj_file_mem;
char texture_file_name[256] = {0};
float x_size,y_size;
float alpha_test;
int file_x_len;
int file_y_len;
int u_start,u_end,v_start,v_end;
cur_object=calloc(1, sizeof(obj_2d_def));
//get the current directory
l=strlen(file_name);
//parse the string backwards, until we find a /
while(l>0)
{
if(file_name[l]=='/' || file_name[l]=='\\')break;
l--;
}
i=0;
if(l)//prevent invalid dir names
{
while(l>=0)
{
cur_dir[i]=file_name[i];
i++;
l--;
}
cur_dir[i+1]=0;
}
file = el_open(file_name);
if(file == NULL){
LOG_ERROR("%s: %s \"%s\": %s\n", reg_error_str, cant_open_file, file_name, strerror(errno));
free(cur_object);
return NULL;
}
obj_file_mem = el_get_pointer(file);
if(obj_file_mem == NULL){
LOG_ERROR("%s: %s (read)\"%s\"\n", reg_error_str, cant_open_file, file_name);
el_close(file);
free(cur_object);
return NULL;
}
f_size = el_get_size(file);
//ok, the file is loaded, so parse it
file_x_len=get_integer_after_string("file_x_len:",obj_file_mem,f_size);
file_y_len=get_integer_after_string("file_y_len:",obj_file_mem,f_size);
u_start=get_integer_after_string("u_start:",obj_file_mem,f_size);
u_end=get_integer_after_string("u_end:",obj_file_mem,f_size);
v_start=get_integer_after_string("v_start:",obj_file_mem,f_size);
v_end=get_integer_after_string("v_end:",obj_file_mem,f_size);
x_size=get_float_after_string("x_size:",obj_file_mem,f_size);
y_size=get_float_after_string("y_size:",obj_file_mem,f_size);
alpha_test=get_float_after_string("alpha_test:",obj_file_mem,f_size);
if(alpha_test<0)alpha_test=0;
//get the proper u/v coordinates
cur_object->u_start=(float)u_start/file_x_len;
cur_object->u_end=(float)u_end/file_x_len;
cur_object->v_start=1.0f-(float)v_start/file_y_len;
cur_object->v_end=1.0f-(float)v_end/file_y_len;
cur_object->x_size=x_size;
cur_object->y_size=y_size;
cur_object->alpha_test=alpha_test;
//now find the texture name
i=get_string_occurance("texture:",obj_file_mem,40,0);
obj_file_mem+=i;
k=0;
//find the file name
while(k<128)
{
if(obj_file_mem[k]!=' ' && obj_file_mem[k]!=0x0a)break;
k++;
}
//we found the beginning of the file name
//now, copy the current directory string to the file_name string
i=strlen(cur_dir);
l=0;
while(l<i)
{
texture_file_name[l]=cur_dir[l];
l++;
}
while(l<128)
{
if(obj_file_mem[k]!=' ' && obj_file_mem[k]!=0x0a
&& obj_file_mem[k]!=0x0d)
{
texture_file_name[l]=obj_file_mem[k];
k++;
l++;
}
else
{
texture_file_name[l]=0;
break;
}
}
cur_object->texture_id = load_texture_cached(texture_file_name, tt_mesh);
//now get the object type
i=get_string_occurance("type:",obj_file_mem,f_size,0);
obj_file_mem+=i;
k=0;
for(k=0;k<10;k++)
{
if(obj_file_mem[k]==0x0a)
{
cur_object->object_type=INVALID;
break;
}
if(obj_file_mem[k]==' ')continue;
if(obj_file_mem[k]=='g' || obj_file_mem[k]=='G')
{
cur_object->object_type=GROUND;
break;
}
if(obj_file_mem[k]=='p' || obj_file_mem[k]=='P')
{
cur_object->object_type=PLANT;
break;
}
if(obj_file_mem[k]=='f' || obj_file_mem[k]=='F')
{
cur_object->object_type=FENCE;
break;
}
}
el_close(file);
return cur_object;
}
int weather_parse_effect(xmlNode *node)
{
xmlNode *item;
xmlAttr *attr;
int ok = 1;
int id = -1;
for (attr = node->properties; attr; attr = attr->next)
{
if (attr->type == XML_ATTRIBUTE_NODE)
{
if (!xmlStrcasecmp (attr->name, (xmlChar*)"id"))
id = atoi((char*)attr->children->content);
else {
LOG_ERROR_OLD("unknown attribute for effect: %s", (char*)attr->name);
ok = 0;
}
}
}
if (id < 1)
{
LOG_ERROR_OLD("wrong or missing id for weather effect");
return 0;
}
for(item = node->children; item; item = item->next) {
if(item->type == XML_ELEMENT_NODE) {
if (xmlStrcasecmp(item->name, (xmlChar*)"sprites") == 0) {
weather_defs[id].use_sprites = get_bool_value(item);
}
else if (xmlStrcasecmp(item->name, (xmlChar*)"density") == 0) {
weather_defs[id].density = get_float_value(item);
}
else if (xmlStrcasecmp(item->name, (xmlChar*)"color") == 0) {
weather_defs[id].color[0] = 0.0;
weather_defs[id].color[1] = 0.0;
weather_defs[id].color[2] = 0.0;
weather_defs[id].color[3] = 0.0;
for (attr = item->properties; attr; attr = attr->next)
{
if (attr->type == XML_ATTRIBUTE_NODE)
{
if (!xmlStrcasecmp (attr->name, (xmlChar*)"r"))
weather_defs[id].color[0] = atof((char*)attr->children->content);
else if (!xmlStrcasecmp (attr->name, (xmlChar*)"g"))
weather_defs[id].color[1] = atof((char*)attr->children->content);
else if (!xmlStrcasecmp (attr->name, (xmlChar*)"b"))
weather_defs[id].color[2] = atof((char*)attr->children->content);
else if (!xmlStrcasecmp (attr->name, (xmlChar*)"a"))
weather_defs[id].color[3] = atof((char*)attr->children->content);
else {
LOG_ERROR_OLD("unknown attribute for weather effect color: %s", (char*)attr->name);
ok = 0;
}
}
}
weather_defs[id].color[0] /= 255.0;
weather_defs[id].color[1] /= 255.0;
weather_defs[id].color[2] /= 255.0;
weather_defs[id].color[3] /= 255.0;
}
else if (xmlStrcasecmp(item->name, (xmlChar*)"size") == 0) {
weather_defs[id].size = get_float_value(item);
}
else if (xmlStrcasecmp(item->name, (xmlChar*)"speed") == 0) {
weather_defs[id].speed = get_float_value(item);
}
else if (xmlStrcasecmp(item->name, (xmlChar*)"wind_effect") == 0) {
weather_defs[id].wind_effect = get_float_value(item);
}
else if (xmlStrcasecmp(item->name, (xmlChar*)"texture") == 0) {
#ifdef NEW_TEXTURES
weather_defs[id].texture = load_texture_cached((char*)item->children->content, tt_mesh);
#else /* NEW_TEXTURES */
weather_defs[id].texture = load_texture_cache((char*)item->children->content, 0);
#endif /* NEW_TEXTURES */
}
else {
LOG_ERROR_OLD("unknown node for weather effect: %s", item->name);
ok = 0;
}
}
else if (item->type == XML_ENTITY_REF_NODE) {
ok &= weather_parse_effect(item->children);
}
}
return ok;
}
void ParseImage(xmlAttr *a_node)
{
xmlAttr *cur_attr=NULL;
for (cur_attr = a_node; cur_attr; cur_attr = cur_attr->next) {
if (cur_attr->type==XML_ATTRIBUTE_NODE){
//u=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"u")){
u=(float)atof((char*)cur_attr->children->content);
}
//v=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"v")){
v=(float)atof((char*)cur_attr->children->content);
}
//uend=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"uend")){
uend=(float)atof((char*)cur_attr->children->content);
}
//vend=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"vend")){
vend=(float)atof((char*)cur_attr->children->content);
}
//xend=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"xlen")){
xend=(float)atof((char*)cur_attr->children->content);
}
//yend=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"ylen")){
yend=(float)atof((char*)cur_attr->children->content);
}
//name=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"name")){
#ifdef NEW_TEXTURES
id = load_texture_cached((char*)cur_attr->children->content, tt_gui);
#else /* NEW_TEXTURES */
id=load_texture_cache_deferred((char*)cur_attr->children->content,0);
#endif /* NEW_TEXTURES */
}
//x=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"x")){
x=atoi((char*)cur_attr->children->content);
}
//y=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"y")){
y=atoi((char*)cur_attr->children->content);
}
//mouseover=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"mouseover")){
mouseover=atoi((char*)cur_attr->children->content);
}
//xposupdate=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"xposupdate")){
xposupdate=atoi((char*)cur_attr->children->content);
}
//yposupdate=""
if(!xmlStrcasecmp(cur_attr->name,(xmlChar*)"yposupdate")){
yposupdate=atoi((char*)cur_attr->children->content);
}
}
}
}
static e3d_object* do_load_e3d_detail(e3d_object* cur_object)
{
e3d_header header;
e3d_material material;
char cur_dir[1024];
int i, idx, l, mem_size, vertex_size, material_size;
int file_pos, indices_size, index_size;
char text_file_name[1024];
Uint32 tmp;
Uint16 tmp_16;
Uint8* index_pointer;
el_file_ptr file;
version_number version;
if (cur_object == 0) return 0;
memset(cur_dir, 0, sizeof(cur_dir));
//get the current directory
l = strlen(cur_object->file_name);
//parse the string backwards, until we find a /
while (l > 0)
{
if ((cur_object->file_name[l] == '/') || (cur_object->file_name[l] == '\\')) break;
l--;
}
i = 0;
if (l)//prevent invalid dir names
{
while (l >= 0)
{
cur_dir[i] = cur_object->file_name[i];
i++;
l--;
}
cur_dir[i+1] = 0;
}
LOG_DEBUG_OLD("Loading e3d file '%s'.", cur_object->file_name);
file = el_open(cur_object->file_name);
if (file == 0)
{
LOG_ERROR_OLD("Can't open file '%s'!", cur_object->file_name);
free_e3d_pointer(cur_object);
return 0;
}
if (read_and_check_elc_header(file, EL3D_FILE_MAGIC_NUMBER, &version, cur_object->file_name) != 0)
{
LOG_ERROR_OLD("File '%s' has wrong header!", cur_object->file_name);
free_e3d_pointer(cur_object);
el_close(file);
return 0;
}
el_read(file, sizeof(e3d_header), &header);
cur_object->vertex_no = SDL_SwapLE32(header.vertex_no);
cur_object->index_no = SDL_SwapLE32(header.index_no);
cur_object->material_no = SDL_SwapLE32(header.material_no);
vertex_size = SDL_SwapLE32(header.vertex_size);
material_size = SDL_SwapLE32(header.material_size);
index_size = SDL_SwapLE32(header.index_size);
LOG_DEBUG_OLD("E3d file vertex count %d and size %d.",
cur_object->vertex_no, vertex_size);
LOG_DEBUG_OLD("E3d file index count %d and size %d.",
cur_object->index_no, index_size);
LOG_DEBUG_OLD("E3d file material count %d and size %d.",
cur_object->material_no, material_size);
LOG_DEBUG_OLD("E3d file version %d.%d.%d.%d.", version[0],
version[1], version[2], version[3]);
if ((version[0] == 1) && (version[1] == 1))
{
if ((header.vertex_options & 0xF0) != 0)
{
LOG_ERROR_OLD("Unknow options (%d) for file %s.",
header.vertex_options, cur_object->file_name);
}
header.vertex_options &= 0x0F;
if ((header.vertex_format & 0xE0) != 0)
{
LOG_ERROR_OLD("Unknow format (%d) for file %s.",
header.vertex_format, cur_object->file_name);
}
header.vertex_format &= 0x1F;
}
else
{
if ((version[0] == 1) && (version[1] == 0))
{
header.vertex_format = 0;
header.vertex_options ^= 0x01;
header.vertex_options &= 0x07;
}
else
{
LOG_ERROR_OLD("File '%s' has wrong version number!",
cur_object->file_name);
free_e3d_pointer(cur_object);
el_close(file);
return 0;
}
}
idx = 0;
if (has_normal(header.vertex_options))
{
idx += 1;
}
if (has_color(header.vertex_options))
{
idx += 2;
}
cur_object->vertex_layout = &(vertex_layout_array[idx]);
// They have at least the size we expected
if (check_vertex_size(vertex_size, header.vertex_options, header.vertex_format) == 0)
{
LOG_ERROR_OLD("File '%s' has wrong vertex size!", cur_object->file_name);
free_e3d_pointer(cur_object);
el_close(file);
return 0;
}
if (material_size != get_material_size(header.vertex_options))
{
LOG_ERROR_OLD("File '%s' has wrong material size! Expected size %d, found size %d.",
cur_object->file_name, get_material_size(header.vertex_options), material_size);
free_e3d_pointer(cur_object);
el_close(file);
return 0;
}
if (short_index(header.vertex_format))
{
if (index_size != sizeof(Uint16))
{
LOG_ERROR_OLD("File '%s' has wrong index size! Expected size %d, found size %d.",
cur_object->file_name, sizeof(Uint16), index_size);
free_e3d_pointer(cur_object);
el_close(file);
return 0;
}
}
else
{
if (index_size != sizeof(Uint32))
{
LOG_ERROR_OLD("File '%s' has wrong index size! Expected size %d, found size %d.",
cur_object->file_name, sizeof(Uint32), index_size);
free_e3d_pointer(cur_object);
el_close(file);
return 0;
}
}
LOG_DEBUG_OLD("Reading vertices at %d from e3d file '%s'.",
SDL_SwapLE32(header.vertex_offset), cur_object->file_name);
// Now reading the vertices
el_seek(file, SDL_SwapLE32(header.vertex_offset), SEEK_SET);
cur_object->vertex_data = malloc(cur_object->vertex_no * cur_object->vertex_layout->size);
mem_size = cur_object->vertex_no * cur_object->vertex_layout->size;
if (!CHECK_POINTER(cur_object->vertex_data, "vertex data")) return 0;
read_vertex_buffer(file, (float*)(cur_object->vertex_data), cur_object->vertex_no,
vertex_size, header.vertex_options, header.vertex_format);
LOG_DEBUG_OLD("Reading indices at %d from e3d file '%s'.",
SDL_SwapLE32(header.index_offset), cur_object->file_name);
// Now reading the indices
el_seek(file, SDL_SwapLE32(header.index_offset), SEEK_SET);
if (cur_object->index_no < 65536)
{
indices_size = 2;
cur_object->index_type = GL_UNSIGNED_SHORT;
}
else
{
indices_size = 4;
cur_object->index_type = GL_UNSIGNED_INT;
}
cur_object->indices = malloc(cur_object->index_no * indices_size);
index_pointer = 0;
for (i = 0; i < cur_object->index_no; i++)
{
if (index_size == 2)
{
el_read(file, sizeof(Uint16), &tmp_16);
tmp = SDL_SwapLE16(tmp_16);
}
else
{
el_read(file, sizeof(Uint32), &tmp);
tmp = SDL_SwapLE32(tmp);
}
if (indices_size == 2)
{
((Uint16*)(cur_object->indices))[i] = tmp;
}
else
{
((Uint32*)(cur_object->indices))[i] = tmp;
}
}
// only allocate the materials structure if it doesn't exist (on initial load)
if (cur_object->materials == 0)
{
cur_object->materials = (e3d_draw_list*)malloc(cur_object->material_no*sizeof(e3d_draw_list));
if (!CHECK_POINTER(cur_object->materials, "materials")) return 0;
memset(cur_object->materials, 0, cur_object->material_no * sizeof(e3d_draw_list));
}
mem_size += cur_object->material_no * sizeof(e3d_draw_list);
LOG_DEBUG_OLD("Reading materials at %d from e3d file '%s'.",
SDL_SwapLE32(header.material_offset), cur_object->file_name);
// Now reading the materials
el_seek(file, SDL_SwapLE32(header.material_offset), SEEK_SET);
cur_object->min_x = 1e10f;
cur_object->min_y = 1e10f;
cur_object->min_z = 1e10f;
cur_object->max_x = -1e10f;
cur_object->max_y = -1e10f;
cur_object->max_z = -1e10f;
cur_object->max_size = -1e10f;
for (i = 0; i < cur_object->material_no; i++)
{
file_pos = el_tell(file);
el_read(file, sizeof(e3d_material), &material);
safe_snprintf(text_file_name, sizeof(text_file_name), "%s%s", cur_dir, material.material_name);
cur_object->materials[i].options = SDL_SwapLE32(material.options);
#ifdef MAP_EDITOR
#ifdef NEW_TEXTURES
cur_object->materials[i].texture = load_texture_cached(text_file_name, tt_mesh);
#else /* NEW_TEXTURES */
cur_object->materials[i].texture = load_texture_cache(text_file_name,0);
#endif /* NEW_TEXTURES */
#else //MAP_EDITOR
#ifdef NEW_TEXTURES
cur_object->materials[i].texture = load_texture_cached(text_file_name, tt_mesh);
#else /* NEW_TEXTURES */
#ifdef NEW_ALPHA
// prepare to load the textures depending on if it is transparent or not (diff alpha handling)
if (material_is_transparent(cur_object->materials[i].options))
{ // is this object transparent?
cur_object->materials[i].texture= load_texture_cache_deferred(text_file_name, -1);
}
else
{
cur_object->materials[i].texture= load_texture_cache_deferred(text_file_name, -1); //255);
}
#else //NEW_ALPHA
// cur_object->materials[i].texture = load_texture_cache_deferred(text_file_name, 255);
cur_object->materials[i].texture = load_texture_cache_deferred(text_file_name, 0);
#endif //NEW_ALPHA
#endif /* NEW_TEXTURES */
#endif //MAP_EDITOR
cur_object->materials[i].min_x = SwapLEFloat(material.min_x);
cur_object->materials[i].min_y = SwapLEFloat(material.min_y);
cur_object->materials[i].min_z = SwapLEFloat(material.min_z);
cur_object->materials[i].max_x = SwapLEFloat(material.max_x);
cur_object->materials[i].max_y = SwapLEFloat(material.max_y);
cur_object->materials[i].max_z = SwapLEFloat(material.max_z);
// calculate the max size for cruse LOD processing
cur_object->materials[i].max_size= max2f(max2f(cur_object->materials[i].max_x-cur_object->materials[i].min_x, cur_object->materials[i].max_y-cur_object->materials[i].min_y), cur_object->materials[i].max_z-cur_object->materials[i].min_z);
cur_object->min_x = min2f(cur_object->min_x, cur_object->materials[i].min_x);
cur_object->min_y = min2f(cur_object->min_y, cur_object->materials[i].min_y);
cur_object->min_z = min2f(cur_object->min_z, cur_object->materials[i].min_z);
cur_object->max_x = max2f(cur_object->max_x, cur_object->materials[i].max_x);
cur_object->max_y = max2f(cur_object->max_y, cur_object->materials[i].max_y);
cur_object->max_z = max2f(cur_object->max_z, cur_object->materials[i].max_z);
cur_object->max_size = max2f(cur_object->max_size, cur_object->materials[i].max_size);
cur_object->materials[i].triangles_indices_index = indices_size*SDL_SwapLE32(material.index) + index_pointer;
cur_object->materials[i].triangles_indices_count = SDL_SwapLE32(material.count);
cur_object->materials[i].triangles_indices_min = SDL_SwapLE32(material.triangles_min_index);
cur_object->materials[i].triangles_indices_max = SDL_SwapLE32(material.triangles_max_index);
file_pos += SDL_SwapLE32(material_size);
el_seek(file, file_pos, SEEK_SET);
}
el_close(file);
LOG_DEBUG_OLD("Building vertex buffers for e3d file '%s'.",
cur_object->file_name);
//Generate the buffers
glGenBuffersARB(1, &cur_object->vertex_vbo);
glBindBufferARB(GL_ARRAY_BUFFER_ARB,
cur_object->vertex_vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB,
cur_object->vertex_no * cur_object->vertex_layout->size,
cur_object->vertex_data, GL_STATIC_DRAW_ARB);
#ifndef MAP_EDITOR
free(cur_object->vertex_data);
cur_object->vertex_data = 0;
#endif //MAP_EDITOR
glGenBuffersARB(1, &cur_object->indices_vbo);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
cur_object->indices_vbo);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
cur_object->index_no * indices_size,
cur_object->indices, GL_STATIC_DRAW_ARB);
#ifndef MAP_EDITOR
free(cur_object->indices);
cur_object->indices = 0;
#endif //MAP_EDITOR
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
#ifndef MAP_EDITOR
LOG_DEBUG_OLD("Adding e3d file '%s' to cache.",
cur_object->file_name);
cache_adj_size(cache_e3d, mem_size, cur_object);
#endif //MAP_EDITOR
return cur_object;
}
void draw_game_map (int map, int mouse_mini)
{
int screen_x=0;
int screen_y=0;
int x=-1,y=-1;
float x_size=0,y_size=0;
GLuint map_small, map_large;
actor *me;
static int fallback_text = -1;
// if we don't have a continent texture (instance may be), fallback to blank paper
if (cont_text < 0)
{
if (fallback_text < 0)
#ifdef NEW_TEXTURES
{
fallback_text = load_texture_cached("./textures/paper1", tt_gui);
}
#else /* NEW_TEXTURES */
fallback_text = load_texture_cache ("./textures/paper1.bmp", 0);
#endif /* NEW_TEXTURES */
cont_text = fallback_text;
}
if(map){
#ifdef NEW_TEXTURES
map_small = cont_text;
#else /* NEW_TEXTURES */
map_small=get_texture_id(cont_text);
#endif /* NEW_TEXTURES */
if(inspect_map_text == 0) {
map_large=map_text;
} else {
map_large = inspect_map_text;
}
} else {
map_small=map_text;
#ifdef NEW_TEXTURES
map_large = cont_text;
#else /* NEW_TEXTURES */
map_large=get_texture_id(cont_text);
#endif /* NEW_TEXTURES */
if(cur_map!=-1){
x_size = ((float)(continent_maps[cur_map].x_end - continent_maps[cur_map].x_start)) / tile_map_size_x;
y_size = ((float)(continent_maps[cur_map].y_end - continent_maps[cur_map].y_start)) / tile_map_size_y;
} else {
x_size=y_size=0;
}
}
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glViewport(0, 0 + hud_y, window_width-hud_x, window_height-hud_y);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(300, (GLdouble)0, (GLdouble)0, 200, -250.0, 250.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glDisable(GL_TEXTURE_2D);
glColor3f(0.0f, 0.0f, 0.0f);
glBegin(GL_QUADS);
glVertex2i(0, 0);
glVertex2i(300, 0);
glVertex2i(300, 200);
glVertex2i(0, 200);
glEnd();
glEnable(GL_TEXTURE_2D);
glColor3f(1.0f,1.0f,1.0f);
#ifdef NEW_TEXTURES
bind_texture(map_large);
glBegin(GL_QUADS);
glTexCoord2f(1.0f, 1.0f); glVertex3i(50,0,0);
glTexCoord2f(1.0f, 0.0f); glVertex3i(50,200,0);
glTexCoord2f(0.0f, 0.0f); glVertex3i(250,200,0);
glTexCoord2f(0.0f, 1.0f); glVertex3i(250,0,0);
glEnd();
#else /* NEW_TEXTURES */
bind_texture_id(map_large);
glBegin(GL_QUADS);
glTexCoord2f(1.0f,0.0f); glVertex3i(50,0,0);
glTexCoord2f(1.0f,1.0f); glVertex3i(50,200,0);
glTexCoord2f(0.0f,1.0f); glVertex3i(250,200,0);
glTexCoord2f(0.0f,0.0f); glVertex3i(250,0,0);
glEnd();
#endif /* NEW_TEXTURES */
if (mouse_mini)
glColor4f (1.0f, 1.0f, 1.0f, 1.0f);
else
glColor4f (0.7f, 0.7f, 0.7f, 0.7f);
glEnable(GL_ALPHA_TEST);
#ifdef NEW_TEXTURES
bind_texture(map_small);
glBegin(GL_QUADS);
glTexCoord2f(1.0f, 1.0f); glVertex3i(250,150,0);
glTexCoord2f(1.0f, 0.0f); glVertex3i(250,200,0);
glTexCoord2f(0.0f, 0.0f); glVertex3i(300,200,0);
glTexCoord2f(0.0f, 1.0f); glVertex3i(300,150,0);
glEnd();
#else /* NEW_TEXTURES */
bind_texture_id(map_small);
glBegin(GL_QUADS);
glTexCoord2f(1.0f,0.0f); glVertex3i(250,150,0);
glTexCoord2f(1.0f,1.0f); glVertex3i(250,200,0);
glTexCoord2f(0.0f,1.0f); glVertex3i(300,200,0);
glTexCoord2f(0.0f,0.0f); glVertex3i(300,150,0);
glEnd();
#endif /* NEW_TEXTURES */
glDisable(GL_ALPHA_TEST);
glColor3f(1.0f,1.0f,1.0f);
#ifdef NEW_TEXTURES
bind_texture(legend_text);
glBegin(GL_QUADS);
glTexCoord2f(1.0f, 1.0f); glVertex3i(250,50,0);
glTexCoord2f(1.0f, 0.0f); glVertex3i(250,150,0);
glTexCoord2f(0.0f, 0.0f); glVertex3i(300,150,0);
glTexCoord2f(0.0f, 1.0f); glVertex3i(300,50,0);
glEnd();
#else /* NEW_TEXTURES */
get_and_set_texture_id(legend_text);
glBegin(GL_QUADS);
glTexCoord2f(1.0f,0.0f); glVertex3i(250,50,0);
glTexCoord2f(1.0f,1.0f); glVertex3i(250,150,0);
glTexCoord2f(0.0f,1.0f); glVertex3i(300,150,0);
glTexCoord2f(0.0f,0.0f); glVertex3i(300,50,0);
glEnd();
#endif /* NEW_TEXTURES */
// this is necessary for the text over map
// need to execute this for any map now
// because of the coordinate display - Lachesis
if(map/*&&(adding_mark||max_mark>0)*/){
glViewport(0, 0 + hud_y, window_width-hud_x, window_height-hud_y);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho((GLdouble)0, (GLdouble)300, (GLdouble)200, (GLdouble)0, -250.0, 250.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
// Draw help for toggling the mini-map
{
char buf[80];
char keybuf[20];
glEnable(GL_TEXTURE_2D);
safe_snprintf(buf, sizeof(buf), "%s %s", win_minimap, get_key_string(K_MINIMAP, keybuf, sizeof(keybuf)));
glColor3f (1.0f, 1.0f, 0.0f);
draw_string_zoomed(25 - 1.5*strlen(buf), 150 + 43, (const unsigned char *)buf, 1, 0.3);
}
// draw a temporary mark until the text is entered
if (adding_mark) {
int x = mark_x;
int y = mark_y;
screen_x=(51+200*x/(tile_map_size_x*6));
screen_y=201-200*y/(tile_map_size_y*6);
glColor3f(1.0f,1.0f,0.0f);
glDisable(GL_TEXTURE_2D);
glBegin(GL_LINES);
glVertex2i(screen_x-9*mapmark_zoom,screen_y-9*mapmark_zoom);
glVertex2i(screen_x+6*mapmark_zoom,screen_y+6*mapmark_zoom);
glVertex2i(screen_x+6*mapmark_zoom,screen_y-9*mapmark_zoom);
glVertex2i(screen_x-9*mapmark_zoom,screen_y+6*mapmark_zoom);
glEnd();
glEnable(GL_TEXTURE_2D);
glColor3f(1.0f,1.0f,0.0f);
draw_string_zoomed (screen_x, screen_y, (unsigned char*)input_text_line.data, 1, mapmark_zoom);
}
draw_mark_filter();
if(inspect_map_text == 0) {
draw_marks(marks, max_mark, tile_map_size_x, tile_map_size_y);
draw_coordinates(tile_map_size_x, tile_map_size_y);
}
else {
draw_marks(temp_marks, max_temp_mark, temp_tile_map_size_x, temp_tile_map_size_y);
draw_coordinates(temp_tile_map_size_x, temp_tile_map_size_y);
}
}
//if we're following a path, draw the destination on the map
if (pf_follow_path && inspect_map_text == 0)
{
int px = pf_dst_tile->x;
int py = pf_dst_tile->y;
if (!map)
{
if (cur_map!=-1)
{
screen_x = 300 - (50 + 200 * ( (px * x_size / 6) + continent_maps[cur_map].x_start) / 512);
screen_y = 200 * ( (py * y_size / 6) + continent_maps[cur_map].y_start) / 512;
}
else
{
screen_x = screen_y = 0;
}
}
else
{
screen_x=51 +200*px/(tile_map_size_x*6);
screen_y=201-200*py/(tile_map_size_y*6);
}
glColor3f(1.0f,0.0f,0.0f);
glDisable(GL_TEXTURE_2D);
glBegin(GL_LINES);
glVertex2i(screen_x-9*mapmark_zoom,screen_y-9*mapmark_zoom);
glVertex2i(screen_x+6*mapmark_zoom,screen_y+6*mapmark_zoom);
glVertex2i(screen_x+6*mapmark_zoom,screen_y-9*mapmark_zoom);
glVertex2i(screen_x-9*mapmark_zoom,screen_y+6*mapmark_zoom);
glEnd();
}
//ok, now let's draw our possition...
if ( (me = get_our_actor ()) != NULL && inspect_map_text == 0)
{
x = me->x_tile_pos;
y = me->y_tile_pos;
}
else
{
//We don't exist (usually happens when teleporting)
x = -1;
y = -1;
}
if (!map)
{
if (cur_map != -1)
{
screen_x = 300 - (50 + 200 * ( (x * x_size / 6) + continent_maps[cur_map].x_start) / 512);
screen_y = 200 * ( (y * y_size / 6) + continent_maps[cur_map].y_start) / 512;
}
else
{
screen_x = screen_y = 0;
}
}
else
{
screen_x=51 +200*x/(tile_map_size_x*6);
screen_y=201-200*y/(tile_map_size_y*6);
}
if ( (map || !dungeon) && x != -1 )
{
glColor3f (0.0f, 0.0f, 1.0f);
glDisable (GL_TEXTURE_2D);
glBegin (GL_LINES);
glVertex2i(screen_x-9*mapmark_zoom,screen_y-9*mapmark_zoom);
glVertex2i(screen_x+6*mapmark_zoom,screen_y+6*mapmark_zoom);
glVertex2i(screen_x+6*mapmark_zoom,screen_y-9*mapmark_zoom);
glVertex2i(screen_x-9*mapmark_zoom,screen_y+6*mapmark_zoom);
glEnd();
}
if(!map && show_continent_map_boundaries && cont_text!=fallback_text) {
int i;
/* Convert mouse coordinates to map coordinates (stolen from pf_get_mouse_position()) */
int min_mouse_x = (window_width-hud_x)/6;
int min_mouse_y = 0;
int max_mouse_x = min_mouse_x+((window_width-hud_x)/1.5);
int max_mouse_y = window_height - hud_y;
int screen_map_width = max_mouse_x - min_mouse_x;
int screen_map_height = max_mouse_y - min_mouse_y;
int m_px = ((mouse_x-min_mouse_x) * 512) / screen_map_width;
int m_py = 512 - ((mouse_y * 512) / screen_map_height);
int mouse_over = -1;
glColor3f (0.267f, 0.267f, 0.267f);
glDisable (GL_TEXTURE_2D);
glBegin(GL_LINES);
/* Draw borders for the maps except the one with the mouse over it */
glColor3f (0.267f, 0.267f, 0.267f);
for(i = 0; continent_maps[i].name != NULL; i++) {
if(continent_maps[i].cont == continent_maps[cur_map].cont) {
if(!mouse_mini && mouse_over == -1
&& m_px > continent_maps[i].x_start && m_px < continent_maps[i].x_end
&& m_py > continent_maps[i].y_start && m_py < continent_maps[i].y_end)
{
/* Mouse over this map */
mouse_over = i;
} else {
int x_start = 300-(50+200*continent_maps[i].x_start/512);
int x_end = 300-(50+200*continent_maps[i].x_end/512);
int y_start = 200*continent_maps[i].y_start / 512;
int y_end = 200*continent_maps[i].y_end / 512;
glVertex2i(x_start, y_start);
glVertex2i(x_start, y_end);
glVertex2i(x_start, y_end);
glVertex2i(x_end, y_end);
glVertex2i(x_end, y_end);
glVertex2i(x_end, y_start);
glVertex2i(x_end, y_start);
glVertex2i(x_start, y_start);
}
}
}
/* Draw border for the map with the mouse over it */
if(mouse_over >= 0) {
float flash_effect_colour = 0.90f - sin((float)SDL_GetTicks()/100.0f) / 10.0f;
int x_start = 300-(50+200*continent_maps[mouse_over].x_start/512);
int x_end = 300-(50+200*continent_maps[mouse_over].x_end/512);
int y_start = 200*continent_maps[mouse_over].y_start / 512;
int y_end = 200*continent_maps[mouse_over].y_end / 512;
glColor3f(flash_effect_colour, flash_effect_colour, flash_effect_colour);
glVertex2i(x_start, y_start);
glVertex2i(x_start, y_end);
glVertex2i(x_start, y_end);
glVertex2i(x_end, y_end);
glVertex2i(x_end, y_end);
glVertex2i(x_end, y_start);
glVertex2i(x_end, y_start);
glVertex2i(x_start, y_start);
}
glEnd();
}
#ifdef DEBUG_MAP_SOUND
// If we are in map view (not continent view) draw the sound area boundaries
if (map) {
print_sound_boundaries(cur_tab_map);
}
#endif // DEBUG_MAP_SOUND
if (map)
{
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
glEnable (GL_TEXTURE_2D);
glColor3f (1.0f, 1.0f, 1.0f);
glMatrixMode (GL_MODELVIEW);
glPopMatrix ();
glMatrixMode (GL_PROJECTION);
glPopMatrix ();
glMatrixMode (GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
static void parse_2d0(const char* desc, Uint32 len, const char* cur_dir,
obj_2d_def *def)
{
char name[256], value[256];
const char *cp, *cp_end;
Uint32 i;
int file_x_len = -1, file_y_len = -1;
int u_start = -1, u_end = -1, v_start = -1, v_end = -1;
def->x_size = def->y_size = def->alpha_test = -1;
cp = desc;
cp_end = cp + len;
while (1)
{
// skip whitespace
while (cp < cp_end && isspace(*cp))
cp++;
if (cp >= cp_end) break;
// copy the key
i = 0;
while (cp < cp_end && i < sizeof(name)-1 && !isspace(*cp) && *cp != ':' && *cp != '=')
name[i++] = *cp++;
name[i] = '\0';
if (cp >= cp_end) break;
// skip separators
while (cp < cp_end && (isspace(*cp) || *cp == ':' || *cp == '='))
{
if (*cp == '\n')
break;
cp++;
}
if (cp >= cp_end) break;
if (*cp == '\n') continue; // no value
// copy value
i = 0;
while (cp < cp_end && i < sizeof(value)-1 && !isspace(*cp))
value[i++] = *cp++;
value[i] = '\0';
if (!strcasecmp(name, "file_x_len"))
file_x_len = atoi(value);
else if (!strcasecmp(name, "file_y_len"))
file_y_len = atoi(value);
else if (!strcasecmp(name, "u_start"))
u_start = atoi(value);
else if (!strcasecmp(name, "u_end"))
u_end = atoi(value);
else if (!strcasecmp(name, "v_start"))
v_start = atoi(value);
else if (!strcasecmp(name, "v_end"))
v_end = atoi(value);
else if (!strcasecmp(name, "x_size"))
def->x_size = atof(value);
else if (!strcasecmp(name, "y_size"))
def->y_size = atof(value);
else if (!strcasecmp(name, "alpha_test"))
def->alpha_test = atof(value);
else if (!strcasecmp(name, "texture"))
{
char texture_file_name[256];
safe_snprintf(texture_file_name, sizeof(texture_file_name),
"%s/%s", cur_dir, value);
def->texture_id = load_texture_cached(texture_file_name, tt_mesh);
}
else if (!strcmp(name, "type"))
{
switch (*value)
{
case 'g':
case 'G': def->object_type = GROUND; break;
case 'p':
case 'P': def->object_type = PLANT; break;
case 'f':
case 'F': def->object_type = FENCE; break;
default: def->object_type = INVALID;
}
}
}
def->u_start = (float)u_start/file_x_len;
def->u_end = (float)u_end/file_x_len;
def->v_start = 1.0f + (float)v_start/file_y_len;
def->v_end = 1.0f + (float)v_end/file_y_len;
if (def->alpha_test < 0)
def->alpha_test = 0;
}
int load_font_textures ()
{
#ifndef NEW_TEXTURES
int poor_man_save=poor_man;
int use_mipmaps_save=use_mipmaps;
#endif /* NEW_TEXTURES */
size_t i = 0;
char *glob_pattern;
#ifdef WINDOWS
struct _finddata_t c_file;
long hFile;
#else //WINDOWS
int ret;
glob_t glob_res;
size_t j;
#endif //WINDOWS
char file[60] = "";
char str[60] = "";
if (fonts[0] == NULL || fonts[1] == NULL || fonts[2] == NULL || fonts[3]==NULL )
{
for (i = 0; i < FONTS_ARRAY_SIZE; i++) {
if (fonts[i] != NULL)
free (fonts[i]);
fonts[i] = NULL;
}
if ( !init_fonts () ) return 0;
}
#ifndef NEW_TEXTURES
poor_man=0;
use_mipmaps=0;
#endif /* NEW_TEXTURES */
#ifdef NEW_TEXTURES
fonts[0]->texture_id = load_texture_cached("textures/font.dds", tt_font);
#else /* NEW_TEXTURES */
fonts[0]->texture_id = load_texture_cache("./textures/font.bmp", 0);
#endif /* NEW_TEXTURES */
i = 1;
// Force the selection of the base font.
add_multi_option("chat_font", "Type 1");
add_multi_option("name_font", "Type 1");
// Find what font's exist and load them
glob_pattern = malloc(strlen(datadir)+sizeof(texture_dir)+10+1); //+10 = font*.bmp*
#ifdef NEW_TEXTURES
sprintf(glob_pattern, "%s%sfont*.dds", datadir, texture_dir);
#else /* NEW_TEXTURES */
sprintf(glob_pattern, "%s%sfont*.bmp*", datadir, texture_dir);
#endif /* NEW_TEXTURES */
#ifdef WINDOWS
if( (hFile = _findfirst( glob_pattern, &c_file )) == -1L ){
free(glob_pattern);
return 0;
}
do {
int len;
safe_strncpy(file, c_file.name, sizeof(file));
#else //!WINDOWS
ret = glob(glob_pattern, 0, NULL, &glob_res);
if(ret != 0) {
LOG_ERROR("Unable to find any font textures\n");
free(glob_pattern);
return 0;
}
j = 0;
while (j < glob_res.gl_pathc && i < FONTS_ARRAY_SIZE) {
int len;
safe_strncpy(file, glob_res.gl_pathv[j]+sizeof(texture_dir)-1+strlen(datadir), sizeof(file));
#endif //WINDOWS
len= strlen(file);
#ifdef NEW_TEXTURES
if (((len + sizeof(texture_dir) - 1) < sizeof(str)) && !strncasecmp(file, "font", 4)
&& has_suffix(file, len, ".dds", 4))
{
safe_snprintf(str, sizeof(str), "./textures/%s", file); //Use a relative path here, load_texture_cache_deferred() is using the path wrappers.
file[len - 4] = 0;
fonts[i]->texture_id = load_texture_cached(str, tt_font);
#else /* NEW_TEXTURES */
if (len+sizeof(texture_dir)-1 < sizeof(str) && !strncasecmp(file, "font", 4)
&& (has_suffix(file, len, ".bmp", 4) || has_suffix(file, len, ".bmp.gz", 7))
&& (!has_suffix(file, len, "_alpha.bmp", 10)) && (!has_suffix(file, len, "_alpha.bmp.gz", 13))) {
// Get the filename, remove the .bmp and add _alpha.bmp to a copy, then replace the .bmp
safe_snprintf(str, sizeof(str), "./textures/%s", file); //Use a relative path here, load_texture_cache_deferred() is using the path wrappers.
if(has_suffix(file, len, ".bmp.gz", 7)){
file[len - 7]= 0;
} else {
file[len - 4]= 0;
}
fonts[i]->texture_id = load_texture_cache_deferred(str, 0);
#endif /* NEW_TEXTURES */
safe_snprintf(font_names[i], sizeof(font_names[i]), "Type %i - %s", i + 1, file);
add_multi_option("chat_font", font_names[i]);
add_multi_option("name_font", font_names[i]);
i++;
}
#ifndef WINDOWS
j++;
#endif //WINDOWS
}
#ifdef WINDOWS
while ( _findnext( hFile, &c_file ) == 0 );
_findclose( hFile );
#else //!WINDOWS
globfree(&glob_res);
#endif //WINDOWS
free(glob_pattern);
#ifndef NEW_TEXTURES
poor_man=poor_man_save;
use_mipmaps=use_mipmaps_save;
#endif /* NEW_TEXTURES */
//set the default font
cur_font_num = 0;
font_text = fonts[0]->texture_id;
return 1;
}
int set_font_parameters (int num)
{
int i;
// error checking
if(num < 0 || num >= FONTS_ARRAY_SIZE)
{
return -1;
}
// allocate space if needed
if(fonts[num] == NULL)
{
fonts[num]=(font_info *)calloc(1, sizeof(font_info));
if(fonts[num] == NULL)
{
LOG_ERROR(cant_load_font);
return -1;
}
}
//watch the highest font
if(num >= max_fonts)
{
max_fonts=num+1;
}
// set default font info
my_strcp (fonts[num]->name, "default");
fonts[num]->spacing=0;
// load font information
// TODO: write this and remove the hack!
if(num!=1||num!=2)for(i=0; i<FONTS_ARRAY_SIZE*FONT_CHARS_PER_LINE; i++) fonts[num]->widths[i]=12;
if(num==1){
static int widths[]={
4,2,7,11,8,12,12,2,7,7,9,10,3,8,
2,10,10,10,8,8,10,7,9,9,9,9,3,3,
10,10,10,9,12,12,9,10,10,9,9,10,9,8,
7,11,8,11,10,11,9,11,11,9,10,9,12,12,
12,12,10,6,10,6,10,12,3,11,9,9,9,9,
8,9,9,4,6,10,4,11,9,10,9,9,8,8,
8,9,10,12,10,10,9,8,2,8,10,8,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,
12,12,12,12,12,12,12,12,12,12,12,12,12,12,
};
memcpy(fonts[num]->widths, widths, sizeof(widths));
fonts[num]->spacing=4;
}
if(num==2){
static int widths[]={
8, 8, 8, 10, 8, 10, 10, 8, 8, 8, 8, 10, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
10, 10, 10, 8, 12, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 8, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 8, 8, 8, 8, 8, 8, 8,
10, 8, 8, 8, 8, 8, 8, 10, 8, 8, 8, 8, 8, 8,
8, 8, 8, 10, 8, 8, 8, 10, 8, 10, 10, 8, 10, 8,
8, 8, 10, 10, 10, 8, 10, 10, 8, 8, 8, 12, 12, 12,
10, 10, 12, 10, 12, 12, 12,
};
memcpy(fonts[num]->widths, widths, sizeof(widths));
fonts[num]->spacing=2;
}
//and return
return num;
}
int set_font(int num)
{
if(num >= 0 && num < max_fonts && fonts[num] && fonts[num]->texture_id >= 0)
{
cur_font_num=num;
font_text=fonts[cur_font_num]->texture_id;
}
return cur_font_num;
}
// Read the achievements xml file and create all the achievement objects,
// the global settings and the textures.
//
Achievements_System::Achievements_System(void)
: size(32), display(32), y_win_offset(10), per_row(5), min_rows(1), max_rows(12), border(2),
prev("[<]"), next("[>]"), close("[close]"),
too_many("Too many achievement windows open already"),
xml_fail("Failed to load achievement data"),
texture_fail("Failed to load achievement texture"),
close_help("Close or +ctrl close all"),
no_next_help("No more pages"),
no_prev_help("No previous page"),
next_help("Next page"),
prev_help("Previous page"),
max_title_len(0),
max_detail_lines(2), max_windows(15), win_pos_x(100), win_pos_y(50), control_used(false), current_scale(1.0)
{
xmlDocPtr doc;
xmlNodePtr cur;
char const *error_prefix = "Reading xml: ";
std::ostringstream langpath;
langpath << "languages/" << lang << "/achievements.xml";
if ((doc = xmlReadFile(langpath.str().c_str(), NULL, 0)) == NULL)
{
const char *path = "languages/en/achievements.xml";
if ((doc = xmlReadFile(path, NULL, 0)) == NULL)
{
LOG_ERROR("%sCan't open file [%s]\n", error_prefix, path );
return;
}
}
if ((cur = xmlDocGetRootElement (doc)) == NULL)
{
LOG_ERROR("%sEmpty xml document\n", error_prefix );
xmlFreeDoc(doc);
return;
}
if (xmlStrcasecmp (cur->name, (const xmlChar *) "achievements_system"))
{
LOG_ERROR("%sNot achievements system.\n", error_prefix );
xmlFreeDoc(doc);
return;
}
for (cur = cur->xmlChildrenNode; cur; cur = cur->next)
{
if (!xmlStrcasecmp(cur->name, (const xmlChar *)"achievement"))
{
char *text = (char*)(cur->children ? cur->children->content : NULL);
char *title = (char*)xmlGetProp(cur, (xmlChar *)"title");
int achievement_id = -1, image_id = -1;
int *props_p[2] = { &achievement_id, &image_id };
const char *props_s[2] = { "achievement_id", "image_id" };
get_int_props(cur, props_p, props_s, 2);
if ((text == NULL) || (achievement_id < 0) || (image_id < 0) || (title == NULL))
{
LOG_WARNING("%sInvalid achievements node\n", error_prefix );
continue;
}
char *proc_title = 0;
char *proc_text = 0;
MY_XMLSTRCPY(&proc_title, title);
MY_XMLSTRCPY(&proc_text, text);
xmlFree(title);
if ((achievement_id < 0) || (achievement_id >= MAX_ACHIEVEMENTS))
LOG_ERROR("%sInvalid achievement id=%lu\n", error_prefix, achievement_id );
else
{
achievements.resize(achievement_id+1, 0);
if (achievements[achievement_id])
LOG_ERROR("%sDuplicate achievement id=%lu\n", error_prefix, achievement_id );
else
{
achievements[achievement_id] = new Achievement(achievement_id, image_id, proc_title, proc_text);
if (achievements[achievement_id]->get_title().size() > max_title_len)
max_title_len = achievements[achievement_id]->get_title().size();
}
}
if (proc_title) free(proc_title);
if (proc_text) free(proc_text);
}
else if (!xmlStrcasecmp(cur->name, (const xmlChar *)"image_settings"))
{
int *props_p[2] = { &size, &display };
const char * props_s[2] = { "size", "display" };
get_int_props(cur, props_p, props_s, 2);
}
else if (!xmlStrcasecmp(cur->name, (const xmlChar *)"window_settings"))
{
int *props_p[4] = { &per_row, &min_rows, &max_rows, &border };
const char *props_s[4] = { "per_row", "min_rows", "max_rows", "border" };
get_int_props(cur, props_p, props_s, 4);
std::string * ctrl_p[3] = { &prev, &next, &close };
const char* ctrl_s[3] = { "prev", "next", "close" };
get_string_props(cur, ctrl_p, ctrl_s, 3);
}
else if (!xmlStrcasecmp(cur->name, (const xmlChar *)"strings"))
{
const size_t count = 8;
std::string * strings_p[count] = { &too_many, &xml_fail, &texture_fail,
&close_help, &no_next_help, &no_prev_help, &next_help, &prev_help };
const char* strings_s[count] = { "too_many", "xml_fail", "texture_fail",
"close_help", "no_next_help", "no_prev_help", "next_help", "prev_help" };
get_string_props(cur, strings_p, strings_s, count);
}
else if (!xmlStrcasecmp(cur->name, (const xmlChar *)"texture"))
{
char *path = (char*)(cur->children ? cur->children->content : NULL);
char buffer[1024];
if (check_image_name(path, sizeof(buffer), buffer) == 1)
{
textures.push_back(load_texture_cached(buffer, tt_gui));
}
}
}
xmlFreeDoc(doc);
}
void change_minimap(){
char minimap_file_name[256];
#ifndef NEW_TEXTURES
texture_cache_struct tex;
#endif /* NEW_TEXTURES */
if(minimap_win < 0)
return;
//save_exploration_map();
#ifdef NEW_TEXTURES
//unload all textures
if(exploration_texture)
glDeleteTextures(1,&exploration_texture);
//make filename
if (check_image_name(map_file_name, sizeof(minimap_file_name), minimap_file_name) == 1)
{
minimap_texture = load_texture_cached(minimap_file_name, tt_image);
}
else
{
minimap_texture = 0;
}
compass_tex = load_texture_cached("./textures/compass", tt_gui);
#else /* NEW_TEXTURES */
//unload all textures
if(minimap_texture)
glDeleteTextures(1,&minimap_texture);
if(compass_tex)
glDeleteTextures(1,&compass_tex);
if(exploration_texture)
glDeleteTextures(1,&exploration_texture);
//make filename
my_strcp(minimap_file_name,map_file_name);
minimap_file_name[strlen(minimap_file_name)-4] = '\0';
strcat(minimap_file_name, ".bmp");
//load textures
my_strcp(tex.file_name, minimap_file_name);
if (!el_file_exists(minimap_file_name))
minimap_texture = 0;
else
minimap_texture = load_bmp8_fixed_alpha(&tex,128);
my_strcp(tex.file_name, "./textures/compass.bmp");
compass_tex = load_bmp8_fixed_alpha_with_transparent_color(&tex,255,0,0,0);
#endif /* NEW_TEXTURES */
glGenTextures(1, &exploration_texture);
bind_texture_id(exploration_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//load_exploration_map();
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
