/* return true if digest calculated */ int get_file_digest(const char * filename, Uint8 digest[16]) { MD5 md5; el_file_ptr file = NULL; file = el_open(filename); memset (digest, 0, 16); if (file == NULL) { LOG_ERROR("MD5Digest: Unable to open %s (%d)", filename, errno); return 0; } if (el_get_pointer(file) == NULL) { el_close(file); return 0; } MD5Open(&md5); MD5Digest(&md5, el_get_pointer(file), el_get_size(file)); MD5Close(&md5, digest); el_close(file); return 1; }
static obj_2d_def* load_obj_2d_def(const char *file_name) { int f_size; el_file_ptr file = NULL; char cur_dir[200]={0}; obj_2d_def *cur_object; const char *obj_file_mem; const char* sep; sep = strrchr(file_name, '/'); if (!sep || sep == file_name) *cur_dir = '\0'; else my_strncp(cur_dir, file_name, sep-file_name+1); file = el_open(file_name); if (!file) { LOG_ERROR("%s: %s \"%s\": %s\n", reg_error_str, cant_open_file, file_name, strerror(errno)); return NULL; } obj_file_mem = el_get_pointer(file); if (!obj_file_mem) { LOG_ERROR("%s: %s (read)\"%s\"\n", reg_error_str, cant_open_file, file_name); el_close(file); return NULL; } f_size = el_get_size(file); //ok, the file is loaded, so parse it cur_object=calloc(1, sizeof(obj_2d_def)); my_strncp(cur_object->file_name, file_name, sizeof(cur_object->file_name)); parse_2d0(obj_file_mem, f_size, cur_dir, cur_object); el_close(file); return cur_object; }
int get_tile_map_sizes(const char *file_name, int *x, int *y) { map_header cur_map_header; char* file_mem; el_file_ptr file; file = el_open(file_name); if (!file) { return 0; } file_mem = el_get_pointer(file); memcpy(&cur_map_header, file_mem, sizeof(cur_map_header)); *x = SDL_SwapLE32(cur_map_header.tile_map_x_len); *y = SDL_SwapLE32(cur_map_header.tile_map_y_len); el_close(file); return 1; }
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; }
void load_cursors() { int cursors_colors_no, x, y, i; Uint8 * cursors_mem_bmp; Uint8 cur_color; el_file_ptr file; file = el_open("textures/cursors.bmp"); if (file == NULL) { LOG_ERROR("%s: %s [%s]\n", reg_error_str, cursors_file_str, "textures/cursors.bmp"); return; } if ((cursors_mem_bmp = el_get_pointer(file)) == NULL) { el_close(file); LOG_ERROR("%s: %s (read) [%s]\n", reg_error_str, cursors_file_str, "textures/cursors.bmp"); return; } cursors_mem_bmp += 18; //x length is at offset+18 cursors_x_length = SDL_SwapLE32(*((int *) cursors_mem_bmp)); cursors_mem_bmp += 4; //y length is at offset+22 cursors_y_length = SDL_SwapLE32(*((int *) cursors_mem_bmp)); cursors_mem_bmp += 46 - 22; cursors_colors_no = SDL_SwapLE32(*((int *) cursors_mem_bmp)); cursors_mem_bmp += 54 - 46 + cursors_colors_no * 4; //ok, now transform the bitmap in cursors info if(cursors_mem) free(cursors_mem); cursors_mem = (Uint8 *)calloc ( cursors_x_length*cursors_y_length*2, sizeof(char)); for(y=cursors_y_length-1;y>=0;y--) { i=(cursors_y_length-y-1)*cursors_x_length; for(x=0;x<cursors_x_length;x++) { cur_color=*(cursors_mem_bmp+y*cursors_x_length+x); switch(cur_color) { case 0: //transparent *(cursors_mem+(i+x)*2)=0; *(cursors_mem+(i+x)*2+1)=0; break; case 1: //white *(cursors_mem+(i+x)*2)=0; *(cursors_mem+(i+x)*2+1)=1; break; case 2: //black *(cursors_mem+(i+x)*2)=1; *(cursors_mem+(i+x)*2+1)=1; break; case 3: //reverse *(cursors_mem+(i+x)*2)=1; *(cursors_mem+(i+x)*2+1)=0; break; } } } el_close(file); }
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; }
static int do_load_map(const char *file_name, update_func *update_function) { int i; int cur_tile, j; AABBOX bbox; map_header cur_map_header; char* file_mem; #ifdef CLUSTER_INSIDES char* occupied = 0; int have_clusters; #endif object3d_io* objs_3d; obj_2d_io* objs_2d; light_io* lights; particles_io* particles; #ifndef FASTER_MAP_LOAD float progress; #endif el_file_ptr file; file = el_open(file_name); if (!file) { return 0; } #ifdef EXTRA_DEBUG ERR(); #endif file_mem = el_get_pointer(file); my_strcp(map_file_name, file_name); LOG_DEBUG("Loading map '%s'.", file_name); main_bbox_tree_items = create_bbox_items(1024); memcpy(&cur_map_header, file_mem, sizeof(cur_map_header)); cur_map_header.tile_map_x_len = SDL_SwapLE32(cur_map_header.tile_map_x_len); cur_map_header.tile_map_y_len = SDL_SwapLE32(cur_map_header.tile_map_y_len); cur_map_header.tile_map_offset = SDL_SwapLE32(cur_map_header.tile_map_offset); cur_map_header.height_map_offset = SDL_SwapLE32(cur_map_header.height_map_offset); cur_map_header.obj_3d_struct_len = SDL_SwapLE32(cur_map_header.obj_3d_struct_len); cur_map_header.obj_3d_no = SDL_SwapLE32(cur_map_header.obj_3d_no); cur_map_header.obj_3d_offset = SDL_SwapLE32(cur_map_header.obj_3d_offset); cur_map_header.obj_2d_struct_len = SDL_SwapLE32(cur_map_header.obj_2d_struct_len); cur_map_header.obj_2d_no = SDL_SwapLE32(cur_map_header.obj_2d_no); cur_map_header.obj_2d_offset = SDL_SwapLE32(cur_map_header.obj_2d_offset); cur_map_header.lights_struct_len = SDL_SwapLE32(cur_map_header.lights_struct_len); cur_map_header.lights_no = SDL_SwapLE32(cur_map_header.lights_no); cur_map_header.lights_offset = SDL_SwapLE32(cur_map_header.lights_offset); cur_map_header.ambient_r = SwapLEFloat(cur_map_header.ambient_r); cur_map_header.ambient_g = SwapLEFloat(cur_map_header.ambient_g); cur_map_header.ambient_b = SwapLEFloat(cur_map_header.ambient_b); cur_map_header.particles_struct_len = SDL_SwapLE32(cur_map_header.particles_struct_len); cur_map_header.particles_no = SDL_SwapLE32(cur_map_header.particles_no); cur_map_header.particles_offset = SDL_SwapLE32(cur_map_header.particles_offset); #ifdef CLUSTER_INSIDES cur_map_header.clusters_offset = SDL_SwapLE32(cur_map_header.clusters_offset); #endif LOG_DEBUG("Checking map '%s' file signature.", file_name); //verify if we have a valid file if(cur_map_header.file_sig[0]!='e'|| cur_map_header.file_sig[1]!='l'|| cur_map_header.file_sig[2]!='m'|| cur_map_header.file_sig[3]!='f') { LOG_ERROR(invalid_map, map_file_name); exit_now = 1; // We might as well quit... el_close(file); return 0; } LOG_DEBUG("Checking map '%s' sizes.", file_name); // Check the sizes of structures. If they don't match, we have a // major problem, since these structures are supposed to be // written flat out to disk. if (cur_map_header.obj_3d_struct_len != sizeof (object3d_io) || cur_map_header.obj_2d_struct_len != sizeof (obj_2d_io) || cur_map_header.lights_struct_len != sizeof (light_io) || (cur_map_header.particles_struct_len != sizeof (particles_io) && cur_map_header.particles_no > 0) ) { LOG_ERROR ("Invalid object size on map %s", map_file_name); exit_now = 1; // We might as well quit... el_close(file); return 0; } update_function(load_map_str, 0); //get the map size tile_map_size_x = cur_map_header.tile_map_x_len; tile_map_size_y = cur_map_header.tile_map_y_len; LOG_DEBUG("Map '%s' size <%d, %d>.", file_name, tile_map_size_x, tile_map_size_y); // allocate the tile map (it was destroyed), and fill it tile_map = calloc (tile_map_size_x*tile_map_size_y, 1); memcpy(tile_map, file_mem + cur_map_header.tile_map_offset, tile_map_size_x*tile_map_size_y); begin_managing_memchunk(tile_map); // allocate the height map, and fill it height_map = calloc (tile_map_size_x*tile_map_size_y*6*6, 1); memcpy(height_map, file_mem + cur_map_header.height_map_offset, tile_map_size_x*tile_map_size_y*6*6); begin_managing_memchunk(height_map); #ifdef CLUSTER_INSIDES // check if we need to compute the clusters, or if they're stored // in the map have_clusters = (cur_map_header.clusters_offset > 0) && ((cur_map_header.clusters_offset + tile_map_size_x * tile_map_size_y * 6 * 6 * sizeof(short)) <= el_get_size(file)); LOG_DEBUG("Map '%s' has clusters: %d.", file_name, have_clusters); if (have_clusters) { // clusters are stored in the map, set them set_clusters (file_mem + cur_map_header.clusters_offset); } else { // We need to compute the clusters, allocate memory for // the occupation array, and initialize it with the // tile and height maps occupied = calloc (tile_map_size_x*tile_map_size_y*6*6, 1); update_occupied_with_tile_map (occupied, tile_map); update_occupied_with_height_map (occupied, height_map); } #endif LOG_DEBUG("Map '%s' is dungeon %d and ambient <%f, %f, %f>.", file_name, cur_map_header.dungeon, cur_map_header.ambient_r, cur_map_header.ambient_g, cur_map_header.ambient_b); //get the type of map, and the ambient light dungeon = cur_map_header.dungeon; ambient_r = cur_map_header.ambient_r; ambient_g = cur_map_header.ambient_g; ambient_b = cur_map_header.ambient_b; /* water_tiles_extension = (tile_map_size_x > tile_map_size_y ? */ /* tile_map_size_x : tile_map_size_y * 1.5); */ /* if (water_tiles_extension < 500.0) */ /* water_tiles_extension = 500.0 - water_tiles_extension; */ /* else */ /* water_tiles_extension = 0.0; */ LOG_DEBUG("Loading tiles"); //load the tiles in this map, if not already loaded load_map_tiles(); LOG_DEBUG("Initializing buffers"); init_buffers(); #ifndef CLUSTER_INSIDES for(i = 0; i < tile_map_size_y; i++) { bbox.bbmin[Y] = i*3.0f; bbox.bbmax[Y] = (i+1)*3.0f; if (i == 0) bbox.bbmin[Y] -= water_tiles_extension; else if (i == tile_map_size_y-1) bbox.bbmax[Y] += water_tiles_extension; for(j = 0; j < tile_map_size_x; j++) { cur_tile = tile_map[i*tile_map_size_x+j]; if (cur_tile != 255) { bbox.bbmin[X] = j*3.0f; bbox.bbmax[X] = (j+1)*3.0f; if (j == 0) bbox.bbmin[X] -= water_tiles_extension; else if (j == tile_map_size_x-1) bbox.bbmax[X] += water_tiles_extension; if (IS_WATER_TILE(cur_tile)) { bbox.bbmin[Z] = -0.25f; bbox.bbmax[Z] = -0.25f; if (IS_REFLECTING(cur_tile)) add_water_to_list(main_bbox_tree_items, get_terrain_id(j, i), bbox, cur_tile, 1); else add_water_to_list(main_bbox_tree_items, get_terrain_id(j, i), bbox, cur_tile, 0); } else { bbox.bbmin[Z] = 0.0f; bbox.bbmax[Z] = 0.0f; add_terrain_to_list(main_bbox_tree_items, get_terrain_id(j, i), bbox, cur_tile); } } } } #endif // CLUSTER_INSIDES #ifdef FASTER_MAP_LOAD update_function(load_3d_object_str, 20.0f); #else // FASTER_MAP_LOAD progress = (cur_map_header.obj_3d_no + 249) / 250; if (progress > 0.0f) { update_function(load_3d_object_str, 0.0f); progress = 20.0f / progress; } else { update_function(load_3d_object_str, 20.0f); progress = 0.0f; } #endif // FASTER_MAP_LOAD LOG_DEBUG("Loading %d 3d objects.", cur_map_header.obj_3d_no); //read the 3d objects #ifndef FASTER_MAP_LOAD clear_objects_list_placeholders(); #endif objs_3d = (object3d_io*) (file_mem + cur_map_header.obj_3d_offset); ENTER_DEBUG_MARK("load 3d objects"); for (i = 0; i < cur_map_header.obj_3d_no; i++) { object3d_io cur_3d_obj_io = objs_3d[i]; cur_3d_obj_io.x_pos = SwapLEFloat (cur_3d_obj_io.x_pos); cur_3d_obj_io.y_pos = SwapLEFloat (cur_3d_obj_io.y_pos); cur_3d_obj_io.z_pos = SwapLEFloat (cur_3d_obj_io.z_pos); cur_3d_obj_io.x_rot = SwapLEFloat (cur_3d_obj_io.x_rot); cur_3d_obj_io.y_rot = SwapLEFloat (cur_3d_obj_io.y_rot); cur_3d_obj_io.z_rot = SwapLEFloat (cur_3d_obj_io.z_rot); cur_3d_obj_io.r = SwapLEFloat (cur_3d_obj_io.r); cur_3d_obj_io.g = SwapLEFloat (cur_3d_obj_io.g); cur_3d_obj_io.b = SwapLEFloat (cur_3d_obj_io.b); LOG_DEBUG("Adding 3d object (%d) '%s' at <%d, %f, %f> with " "rotation <%f, %f, %f>, left lit %d, blended %d and " "color <%f, %f, %f>.", i, cur_3d_obj_io.file_name, cur_3d_obj_io.x_pos, cur_3d_obj_io.y_pos, cur_3d_obj_io.z_pos, cur_3d_obj_io.x_rot, cur_3d_obj_io.y_rot, cur_3d_obj_io.z_rot, cur_3d_obj_io.self_lit, cur_3d_obj_io.blended, cur_3d_obj_io.r, cur_3d_obj_io.g, cur_3d_obj_io.b); if (cur_3d_obj_io.blended != 20) { #ifdef CLUSTER_INSIDES int id; if (cur_3d_obj_io.blended != 1) cur_3d_obj_io.blended = 0; id = add_e3d (cur_3d_obj_io.file_name, cur_3d_obj_io.x_pos, cur_3d_obj_io.y_pos, cur_3d_obj_io.z_pos, cur_3d_obj_io.x_rot, cur_3d_obj_io.y_rot, cur_3d_obj_io.z_rot, cur_3d_obj_io.self_lit, cur_3d_obj_io.blended, cur_3d_obj_io.r, cur_3d_obj_io.g, cur_3d_obj_io.b, 0); if (!have_clusters) update_occupied_with_3d (occupied, id); #else if (cur_3d_obj_io.blended != 1) cur_3d_obj_io.blended = 0; add_e3d (cur_3d_obj_io.file_name, cur_3d_obj_io.x_pos, cur_3d_obj_io.y_pos, cur_3d_obj_io.z_pos, cur_3d_obj_io.x_rot, cur_3d_obj_io.y_rot, cur_3d_obj_io.z_rot, cur_3d_obj_io.self_lit, cur_3d_obj_io.blended, cur_3d_obj_io.r, cur_3d_obj_io.g, cur_3d_obj_io.b, 0); #endif } else { inc_objects_list_placeholders(); } #ifndef FASTER_MAP_LOAD if (i % 250 == 0) { update_function(load_3d_object_str, progress); } #endif } LEAVE_DEBUG_MARK("load 3d objects"); #ifdef FASTER_MAP_LOAD update_function(load_2d_object_str, 20.0f); #else // FASTER_MAP_LOAD progress = (cur_map_header.obj_2d_no + 249) / 250; if (progress > 0) { update_function(load_2d_object_str, 0.0f); progress = 20.0f / progress; } else { update_function(load_2d_object_str, 20.0f); progress = 0.0f; } #endif // FASTER_MAP_LOAD LOG_DEBUG("Loading %d 2d objects.", cur_map_header.obj_2d_no); //read the 2d objects objs_2d = (obj_2d_io*) (file_mem + cur_map_header.obj_2d_offset); ENTER_DEBUG_MARK("load 2d objects"); for (i = 0; i < cur_map_header.obj_2d_no; i++) { obj_2d_io cur_2d_obj_io = objs_2d[i]; #ifdef CLUSTER_INSIDES int id; #endif cur_2d_obj_io.x_pos = SwapLEFloat(cur_2d_obj_io.x_pos); cur_2d_obj_io.y_pos = SwapLEFloat(cur_2d_obj_io.y_pos); cur_2d_obj_io.z_pos = SwapLEFloat(cur_2d_obj_io.z_pos); cur_2d_obj_io.x_rot = SwapLEFloat(cur_2d_obj_io.x_rot); cur_2d_obj_io.y_rot = SwapLEFloat(cur_2d_obj_io.y_rot); cur_2d_obj_io.z_rot = SwapLEFloat(cur_2d_obj_io.z_rot); LOG_DEBUG("Adding 2d object (%d) '%s' at <%d, %f, %f> with " "rotation <%f, %f, %f>.", i, cur_2d_obj_io.file_name, cur_2d_obj_io.x_pos, cur_2d_obj_io.y_pos, cur_2d_obj_io.z_pos, cur_2d_obj_io.x_rot, cur_2d_obj_io.y_rot, cur_2d_obj_io.z_rot); #ifndef SHOW_FLICKERING // Add in low-order bits to prevent flicker. cur_2d_obj_io.z_pos += offset_2d; offset_2d += offset_2d_increment; if (offset_2d >= offset_2d_max) offset_2d = offset_2d_increment; #endif #ifdef FASTER_MAP_LOAD #ifdef CLUSTER_INSIDES id = add_2d_obj(i, cur_2d_obj_io.file_name, cur_2d_obj_io.x_pos, cur_2d_obj_io.y_pos, cur_2d_obj_io.z_pos, cur_2d_obj_io.x_rot, cur_2d_obj_io.y_rot, cur_2d_obj_io.z_rot, 0); if (!have_clusters) update_occupied_with_2d (occupied, id); #else // CLUSTER_INSIDES add_2d_obj(i, cur_2d_obj_io.file_name, cur_2d_obj_io.x_pos, cur_2d_obj_io.y_pos, cur_2d_obj_io.z_pos, cur_2d_obj_io.x_rot, cur_2d_obj_io.y_rot, cur_2d_obj_io.z_rot, 0); #endif // CLUSTER_INSIDES #else // FASTER_MAP_LOAD #ifdef CLUSTER_INSIDES id = add_2d_obj (cur_2d_obj_io.file_name, cur_2d_obj_io.x_pos, cur_2d_obj_io.y_pos, cur_2d_obj_io.z_pos, cur_2d_obj_io.x_rot, cur_2d_obj_io.y_rot, cur_2d_obj_io.z_rot, 0); if (!have_clusters) update_occupied_with_2d (occupied, id); #else // CLUSTER_INSIDES add_2d_obj(cur_2d_obj_io.file_name, cur_2d_obj_io.x_pos, cur_2d_obj_io.y_pos, cur_2d_obj_io.z_pos, cur_2d_obj_io.x_rot, cur_2d_obj_io.y_rot, cur_2d_obj_io.z_rot, 0); #endif // CLUSTER_INSIDES if (i % 250 == 0) { update_function(load_2d_object_str, progress); } #endif // FASTER_MAP_LOAD } LEAVE_DEBUG_MARK("load 2d objects"); #ifdef CLUSTER_INSIDES // If we need to compute the clusters, do it here, so that the // newly added lights and particle systems get the right cluster // number automagically. We don't update the occupation map with // lights or particle systems since I don't expect them to bridge // any clusters, and if they do happen to hang in the void, // they'll be shown anyway. if (!have_clusters) { compute_clusters (occupied); free (occupied); // Ok, we have the clusters, now assign new IDs to each // object that we added. for (i = 0; i < MAX_OBJ_3D; i++) { if (objects_list[i]) { int x = (int) (objects_list[i]->x_pos / 0.5f); int y = (int) (objects_list[i]->y_pos / 0.5f); objects_list[i]->cluster = get_cluster (x, y); } } for (i = 0; i < MAX_OBJ_2D; i++) { if (obj_2d_list[i]) { int x = (int) (obj_2d_list[i]->x_pos / 0.5f); int y = (int) (obj_2d_list[i]->y_pos / 0.5f); obj_2d_list[i]->cluster = get_cluster (x, y); } } } // we finally add the tiles to the abt for(i = 0; i < tile_map_size_y; i++) { bbox.bbmin[Y] = i*3.0f; bbox.bbmax[Y] = (i+1)*3.0f; if (i == 0) bbox.bbmin[Y] -= water_tiles_extension; else if (i == tile_map_size_y-1) bbox.bbmax[Y] += water_tiles_extension; for(j = 0; j < tile_map_size_x; j++) { current_cluster = get_cluster(j*6, i*6); cur_tile = tile_map[i*tile_map_size_x+j]; if (cur_tile != 255) { bbox.bbmin[X] = j*3.0f; bbox.bbmax[X] = (j+1)*3.0f; if (j == 0) bbox.bbmin[X] -= water_tiles_extension; else if (j == tile_map_size_x-1) bbox.bbmax[X] += water_tiles_extension; if (IS_WATER_TILE(cur_tile)) { bbox.bbmin[Z] = -0.25f; bbox.bbmax[Z] = -0.25f; if (IS_REFLECTING(cur_tile)) add_water_to_list(main_bbox_tree_items, get_terrain_id(j, i), bbox, cur_tile, 1); else add_water_to_list(main_bbox_tree_items, get_terrain_id(j, i), bbox, cur_tile, 0); } else { bbox.bbmin[Z] = 0.0f; bbox.bbmax[Z] = 0.0f; add_terrain_to_list(main_bbox_tree_items, get_terrain_id(j, i), bbox, cur_tile); } } } } #endif #ifdef FASTER_MAP_LOAD update_function(load_lights_str, 20.0f); #else // FASTER_MAP_LOAD progress = (cur_map_header.lights_no + 99) / 100; if (progress > 0) { update_function(load_lights_str, 0.0f); progress = 20.0f / progress; } else { update_function(load_lights_str, 20.0f); progress = 0.0f; } #endif // FASTER_MAP_LOAD LOG_DEBUG("Loading %d lights.", cur_map_header.lights_no); //read the lights lights = (light_io *) (file_mem + cur_map_header.lights_offset); ENTER_DEBUG_MARK("load lights"); for (i = 0; i < cur_map_header.lights_no; i++) { light_io cur_light_io = lights[i]; cur_light_io.pos_x = SwapLEFloat (cur_light_io.pos_x); cur_light_io.pos_y = SwapLEFloat (cur_light_io.pos_y); cur_light_io.pos_z = SwapLEFloat (cur_light_io.pos_z); cur_light_io.r = SwapLEFloat (cur_light_io.r); cur_light_io.g = SwapLEFloat (cur_light_io.g); cur_light_io.b = SwapLEFloat (cur_light_io.b); LOG_DEBUG("Adding light(%d) at <%d, %f, %f> with color " "<%f, %f, %f>.", i, cur_light_io.pos_x, cur_light_io.pos_y, cur_light_io.pos_z, cur_light_io.r, cur_light_io.g, cur_light_io.b); if (cur_light_io.pos_x < 0.0f || cur_light_io.pos_x > tile_map_size_x * 60 || cur_light_io.pos_y < 0.0f || cur_light_io.pos_y > tile_map_size_y * 60 || cur_light_io.pos_z < -1000.0f || cur_light_io.pos_z > 1000.0f || cur_light_io.r < -1.0f || cur_light_io.r > 1000.0f || cur_light_io.g < -1.0f || cur_light_io.g > 1000.0f || cur_light_io.b < -1.0f || cur_light_io.b > 1000.0f) { LOG_ERROR("Bad light (number %d) when loading '%s'; co-ords [%f %f %f] " "colour [%f %f %f]", i, file_name, cur_light_io.pos_x, cur_light_io.pos_y, cur_light_io.pos_z, cur_light_io.r, cur_light_io.g, cur_light_io.b); cur_light_io.pos_x = cur_light_io.pos_y = 1.0f; cur_light_io.pos_z = 2.0f; cur_light_io.r = cur_light_io.g = cur_light_io.b = 1.0f; continue; } add_light (cur_light_io.pos_x, cur_light_io.pos_y, cur_light_io.pos_z, cur_light_io.r, cur_light_io.g, cur_light_io.b, 1.0f, 0); #ifndef FASTER_MAP_LOAD if (i % 100 == 0) { update_function(load_lights_str, progress); } #endif } LEAVE_DEBUG_MARK("load lights"); #ifdef FASTER_MAP_LOAD update_function(load_particles_str, 20.0f); #else // FASTER_MAP_LOAD progress = (cur_map_header.particles_no + 99) / 100; if (progress > 0.0f) { update_function(load_particles_str, 0.0f); progress = 20.0f / progress; } else { update_function(load_particles_str, 20.0f); progress = 0.0f; } #endif // FASTER_MAP_LOAD LOG_DEBUG("Loading %d particles.", cur_map_header.particles_no); //read particle systems particles = (particles_io *) (file_mem + cur_map_header.particles_offset); ENTER_DEBUG_MARK("load particles"); for (i = 0; i < cur_map_header.particles_no; i++) { particles_io cur_particles_io = particles[i]; cur_particles_io.x_pos = SwapLEFloat (cur_particles_io.x_pos); cur_particles_io.y_pos = SwapLEFloat (cur_particles_io.y_pos); cur_particles_io.z_pos = SwapLEFloat (cur_particles_io.z_pos); LOG_DEBUG("Adding particle(%d) '%s' at <%d, %f, %f>.", i, cur_particles_io.file_name, cur_particles_io.x_pos, cur_particles_io.y_pos, cur_particles_io.z_pos); if (!strncmp(cur_particles_io.file_name, "ec://", 5)) { ec_create_effect_from_map_code(cur_particles_io.file_name + 5, cur_particles_io.x_pos, cur_particles_io.y_pos, cur_particles_io.z_pos, (poor_man ? 6 : 10)); } else { #ifdef NEW_SOUND add_map_particle_sys (cur_particles_io.file_name, cur_particles_io.x_pos, cur_particles_io.y_pos, cur_particles_io.z_pos, 0); #else add_particle_sys (cur_particles_io.file_name, cur_particles_io.x_pos, cur_particles_io.y_pos, cur_particles_io.z_pos, 0); #endif // NEW_SOUND } #ifndef FASTER_MAP_LOAD if (i % 100 == 0) { update_function(load_particles_str, progress); } #endif } LEAVE_DEBUG_MARK("load particles"); // Everything copied, get rid of the file data el_close(file); update_function(bld_sectors_str, 0.0f); LOG_DEBUG("Building bbox tree for map '%s'.", file_name); init_bbox_tree(main_bbox_tree, main_bbox_tree_items); free_bbox_items(main_bbox_tree_items); main_bbox_tree_items = 0; update_function(init_done_str, 20.0f); #ifdef EXTRA_DEBUG ERR();//We finished loading the new map apparently... #endif return 1; }
int main(int argc, char **argv) { int listenfd, connfd, n; EL *el; CF *conf; char *opName[] = { "Listen", "ServerPath", "ClusterManagerName", "ClusterManagerPort"}; char *ptr; socklen_t addrlen; char BUFF[MAXLINE]; struct sockaddr_storage cliaddr; if (argc > 2) err_quit("usage: node [path to config file] <--help>\n"); if (argc == 2 && strcmp(argv[1],"--help") != 0) conf = cfileInit(argv[1],opName); else if (argc == 1) conf = cfileInit(DB_CONF,opName); connfd = tcpConnect( getOption(conf,"ClusterManagerName"), getOption(conf,"ClusterManagerPort")); if (connfd < 0) err_quit("error for connecting cluster manager.\n"); strcpy(BUFF,"REG "); getExternalIp(BUFF + 4); strcat(BUFF,"\r\n"); write(connfd,BUFF,strlen(BUFF)); if ((n = read(connfd,BUFF,MAXLINE)) > 0) { BUFF[n] = '\0'; if (strcmp(BUFF,"REG ERR\r\n") == 0) err_quit("error for registering node in cluster"); } else err_quit("error for registering node in cluster"); close(connfd); if ((ptr = getOption(conf,"Listen")) != NULL) listenfd = tcpListen(getOption(conf,"ServerName"),ptr,&addrlen); else err_quit("error for opening listen port.\n"); if ((el = el_open()) == NULL) err_quit("node error for creating epoll.\n"); el_addFileEvent(el,listenfd,AE_READABLE,sendRequesData,(void *)conf); el_start(el,AE_BLOCK); el_close(el); }