void fishtank_start()
{
int idx;
if(Fish_inited){
return;
}
// try and load the fish anim
Fish_left_anim = anim_load(FISH_LEFT_ANIM_NAME);
if(Fish_left_anim == NULL){
return;
}
Fish_right_anim = anim_load(FISH_RIGHT_ANIM_NAME);
if(Fish_right_anim == NULL){
return;
}
// no anim instances
for(idx=0; idx<MAX_FISH; idx++){
Fish[idx].a = NULL;
Fish[idx].swimming = 0;
}
Fish_inited = 1;
// generate a random # of fish
int count = (int)frand_range(1.0f, (float)(MAX_FISH - 1));
for(idx=0; idx<count; idx++){
fish_generate();
}
}
/* Runs in task threads */
void rs_threaded_load_fn(void* params, void* result, uint thread_id, uint job_id, int worker_idx)
{
struct rs_load_job_params* lparams = (struct rs_load_job_params*)params;
struct rs_load_job_result* lresult = (struct rs_load_job_result*)result;
if (worker_idx >= (int)lparams->cnt)
return;
util_sleep(100);
void* ptr = NULL;
struct rs_load_data* ldata = lparams->load_items[worker_idx];
switch (ldata->type) {
case RS_RESOURCE_TEXTURE:
ptr = gfx_texture_loaddds(ldata->filepath, ldata->params.tex.first_mipidx,
ldata->params.tex.srgb, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(texture) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_MODEL:
ptr = gfx_model_load(g_rs.alloc, ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(model) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_ANIMREEL:
ptr = anim_load(g_rs.alloc, ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(anim-reel) \"%s\" - id:%d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_PHXPREFAB:
ptr = phx_prefab_load(ldata->filepath, g_rs.alloc, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(physics) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_SCRIPT:
ptr = sct_load(ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(script) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_ANIMCTRL:
ptr = anim_ctrl_load(g_rs.alloc, ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(anim-ctrl) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
default:
ASSERT(0);
}
if (ptr == NULL) {
log_printf(LOG_WARNING, "res-mgr: loading resource '%s' failed", ldata->filepath);
err_clear();
}
lresult->ptrs[worker_idx] = ptr;
}
static void load_callback( Widget w,
XtPointer data,
XmAnyCallbackStruct *cbs)
{
char *str;
str = XmTextFieldGetString((Widget)data);
anim_load(str);
XtFree(str);
}
/**
* @brief Write the frames of a .ani file out to disk as .pcx files.
* @details Use naming convention: filename0000.pcx, filename0001.pcx etc.
*
* @return If success 0, or if failed -1
*/
int anim_write_frames_out(char *filename)
{
anim *source_anim;
anim_instance *ai;
char root_name[256], pcxname[256];
char buf[64];
int i,j;
ubyte **row_data;
strcpy_s(root_name, filename);
root_name[strlen(filename)-4] = 0;
source_anim = anim_load(filename);
if ( source_anim == NULL )
return -1;
ai = init_anim_instance(source_anim, 16);
row_data = (ubyte**)vm_malloc((source_anim->height+1) * 4);
for ( i = 0; i < source_anim->total_frames; i++ ) {
anim_get_next_raw_buffer(ai, 0, 0, 16);
strcpy_s(pcxname, root_name);
sprintf(buf,"%04d",i);
strcat_s(pcxname, buf);
for ( j = 0; j < source_anim->height; j++ ) {
row_data[j] = &ai->frame[j*source_anim->width];
}
pcx_write_bitmap( pcxname,
source_anim->width,
source_anim->height,
row_data,
source_anim->palette);
printf(".");
}
printf("\n");
vm_free(row_data);
return 0;
}
reshandle_t rs_load_animreel(const char* reel_filepath, uint flags)
{
reshandle_t res_hdl = INVALID_HANDLE;
reshandle_t override_hdl = res_hdl;
if (!g_rs.init)
return INVALID_HANDLE;
struct hashtable_item_chained* item = hashtable_chained_find(&g_rs.dict,
hash_str(reel_filepath));
if (item != NULL) {
uint idx = (uint)item->value;
struct rs_resource* res = (struct rs_resource*)g_rs.ress.buffer + idx;
res_hdl = res->hdl;
}
if (res_hdl != INVALID_HANDLE && BIT_CHECK(flags, RS_LOAD_REFRESH)) {
/* rs_resource already loaded, but refresh flag is set, so we reload it */
if (BIT_CHECK(g_rs.flags, RS_FLAG_BGLOADING)) {
res_hdl = rs_animreel_queueload(reel_filepath, res_hdl);
} else {
override_hdl = res_hdl;
res_hdl = INVALID_HANDLE;
}
} else if (res_hdl != INVALID_HANDLE) {
/* add ref count */
struct rs_resource* ress = (struct rs_resource*)g_rs.ress.buffer;
ress[GET_INDEX(res_hdl)].ref_cnt ++;
}
/* rs_resource is not loaded before, so we just have to load it for the first time */
if (res_hdl == INVALID_HANDLE) {
if(BIT_CHECK(g_rs.flags, RS_FLAG_BGLOADING)) {
res_hdl = rs_animreel_queueload(reel_filepath, INVALID_HANDLE);
} else {
/* determine file extension, then load the texture based on that */
char ext[128];
path_getfileext(ext, reel_filepath);
anim_reel reel = NULL;
/* model files should be valid extension */
if (str_isequal_nocase(ext, "h3da"))
reel = anim_load(g_rs.alloc, reel_filepath, 0);
if (reel == NULL) {
log_printf(LOG_WARNING, "res-mgr: loading rs_resource '%s' failed:"
" could not load anim-reel", reel_filepath);
err_clear();
if (override_hdl != INVALID_HANDLE)
rs_remove_fromdb(override_hdl);
return INVALID_HANDLE;
}
res_hdl = rs_add_resource(reel_filepath, reel, override_hdl, rs_animreel_unload);
/* add to hot-loading files */
if (BIT_CHECK(g_rs.flags, RS_FLAG_HOTLOADING) && !BIT_CHECK(flags, RS_LOAD_REFRESH))
fio_mon_reg(reel_filepath, rs_animreel_reload, res_hdl, 0, 0);
log_printf(LOG_LOAD, "(anim-reel) \"%s\" - id: %d", reel_filepath, GET_ID(res_hdl));
}
}
return res_hdl;
}
map_t * data_parse_map(SDL_Renderer * render,char * map_name)
{
int fd;
char * data;
int index;
map_t * map;
ssize_t ret;
fd = open(map_name,O_RDONLY);
if(fd == -1) return NULL;
map = malloc(sizeof(map_t));
map->num_start = 0;
map->start_x = NULL;
map->start_y = NULL;
map->start_a = NULL;
map->bounce = 1.0;
index=0;
data = malloc(index+1);
while( (ret=read(fd,data+index,1)) == 1) {
if(*(data+index) == '\n') {
*(data+index) = 0;
if(strncmp(data,"picture",strlen("picture")) == 0) {
map->picture = anim_load(render,data+strlen("picture")+1);
if(map->picture == NULL) {
ret = -1;
break;
}
}
if(strncmp(data,"width",strlen("width")) == 0) {
map->w = atof(data+strlen("width")+1);
map->h = (int) ((double)map->picture->h / (double)map->picture->w * map->w);
}
if(strncmp(data,"height",strlen("height")) == 0) {
map->h = atof(data+strlen("height")+1);
}
if(strncmp(data,"start_x",strlen("start_x")) == 0) {
map->num_start ++;
map->start_x = realloc(map->start_x, sizeof(int) * map->num_start);
map->start_y = realloc(map->start_y, sizeof(int) * map->num_start);
map->start_a = realloc(map->start_a, sizeof(double) * map->num_start);
map->start_x[map->num_start-1] = atoi(data+strlen("start_x")+1);
}
if(strncmp(data,"start_y",strlen("start_y")) == 0) {
map->start_y[map->num_start-1] = atoi(data+strlen("start_y")+1);
}
if(strncmp(data,"start_a",strlen("start_a")) == 0) {
map->start_a[map->num_start-1] = atoi(data+strlen("start_a")+1);
}
if(strncmp(data,"bounce",strlen("bounce")) == 0) {
map->bounce = atof(data+strlen("bounce")+1);
}
index=-1;
}
index++;
data = realloc(data,index+1);
}
free(data);
if( ret == -1) {
free(map);
return NULL;
}
return map;
}
car_t * data_parse_car(SDL_Renderer * render,char * car_name)
{
int fd;
char * data;
int index;
car_t * car;
ssize_t ret;
fd = open(car_name,O_RDONLY);
if(fd == -1) return NULL;
car = malloc(sizeof(car_t));
car->speed = 0.0;
car->a = 0.0;
index=0;
data = malloc(index+1);
while( (ret=read(fd,data+index,1)) == 1) {
if(*(data+index) == '\n') {
*(data+index) = 0;
if(strncmp(data,"picture",strlen("picture")) == 0) {
car->picture = anim_load(render,data+strlen("picture")+1);
if(car->picture == NULL) {
ret = -1;
break;
}
}
if(strncmp(data,"width",strlen("width")) == 0) {
car->w = atof(data+strlen("width")+1);
}
if(strncmp(data,"height",strlen("height")) == 0) {
car->h = atof(data+strlen("height")+1);
}
if(strncmp(data,"angle",strlen("angle")) == 0) {
car->angle = atof(data+strlen("angle")+1);
}
if(strncmp(data,"turn_speed",strlen("turn_speed")) == 0) {
car->ts = atof(data+strlen("turn_speed")+1);
}
if(strncmp(data,"accel",strlen("accel")) == 0) {
car->accel = atof(data+strlen("accel")+1);
}
if(strncmp(data,"decel",strlen("decel")) == 0) {
car->decel = atof(data+strlen("decel")+1);
}
if(strncmp(data,"max_speed",strlen("max_speed")) == 0) {
car->max_speed = atof(data+strlen("max_speed")+1);
}
if(strncmp(data,"engine_brake",strlen("engine_brake")) == 0) {
car->engine_brake = atof(data+strlen("engine_brake")+1);
}
car->angle_sign = 0.0;
car->key_u = 0;
car->key_d = 0;
car->key_l = 0;
car->key_r = 0;
car->forward = 0;
car->backward = 0;
index=-1;
}
index++;
data = realloc(data,index+1);
}
free(data);
if( ret == -1) {
free(car);
return NULL;
}
return car;
}
int generic_anim_stream(generic_anim *ga, const bool cache)
{
CFILE *img_cfp = NULL;
int anim_fps = 0;
char full_path[MAX_PATH];
int size = 0, offset = 0;
const int NUM_TYPES = 3;
const ubyte type_list[NUM_TYPES] = {BM_TYPE_EFF, BM_TYPE_ANI, BM_TYPE_PNG};
const char *ext_list[NUM_TYPES] = {".eff", ".ani", ".png"};
int rval = -1;
int bpp;
ga->type = BM_TYPE_NONE;
rval = cf_find_file_location_ext(ga->filename, NUM_TYPES, ext_list, CF_TYPE_ANY, sizeof(full_path) - 1, full_path, &size, &offset, 0);
// could not be found, or is invalid for some reason
if ( (rval < 0) || (rval >= NUM_TYPES) )
return -1;
//make sure we can open it
img_cfp = cfopen_special(full_path, "rb", size, offset, CF_TYPE_ANY);
if (img_cfp == NULL) {
return -1;
}
strcat_s(ga->filename, ext_list[rval]);
ga->type = type_list[rval];
//seek to the end
cfseek(img_cfp, 0, CF_SEEK_END);
cfclose(img_cfp);
if(ga->type == BM_TYPE_ANI) {
bpp = ANI_BPP_CHECK;
if(ga->use_hud_color)
bpp = 8;
if (ga->ani.animation == nullptr) {
ga->ani.animation = anim_load(ga->filename, CF_TYPE_ANY, 0);
}
if (ga->ani.instance == nullptr) {
ga->ani.instance = init_anim_instance(ga->ani.animation, bpp);
}
#ifndef NDEBUG
// for debug of ANI sizes
strcpy_s(ga->ani.animation->name, ga->filename);
#endif
ga->num_frames = ga->ani.animation->total_frames;
anim_fps = ga->ani.animation->fps;
ga->height = ga->ani.animation->height;
ga->width = ga->ani.animation->width;
ga->buffer = ga->ani.instance->frame;
ga->bitmap_id = bm_create(bpp, ga->width, ga->height, ga->buffer, (bpp==8)?BMP_AABITMAP:0);
ga->ani.instance->last_bitmap = -1;
ga->ani.instance->file_offset = ga->ani.animation->file_offset;
ga->ani.instance->data = ga->ani.animation->data;
ga->previous_frame = -1;
}
else if (ga->type == BM_TYPE_PNG) {
if (ga->png.anim == nullptr) {
try {
ga->png.anim = new apng::apng_ani(ga->filename, cache);
}
catch (const apng::ApngException& e) {
mprintf(("Failed to load apng: %s\n", e.what() ));
delete ga->png.anim;
ga->png.anim = nullptr;
return -1;
}
nprintf(("apng", "apng read OK (%ix%i@%i) duration (%f)\n", ga->png.anim->w, ga->png.anim->h,
ga->png.anim->bpp, ga->png.anim->anim_time));
}
ga->png.anim->goto_start();
ga->current_frame = 0;
ga->png.previous_frame_time = 0.0f;
ga->num_frames = ga->png.anim->nframes;
ga->height = ga->png.anim->h;
ga->width = ga->png.anim->w;
ga->previous_frame = -1;
ga->buffer = ga->png.anim->frame.data.data();
ga->bitmap_id = bm_create(ga->png.anim->bpp, ga->width, ga->height, ga->buffer, 0);
}
else {
bpp = 32;
if(ga->use_hud_color)
bpp = 8;
bm_load_and_parse_eff(ga->filename, CF_TYPE_ANY, &ga->num_frames, &anim_fps, &ga->keyframe, 0);
char *p = strrchr( ga->filename, '.' );
if ( p )
*p = 0;
char frame_name[MAX_FILENAME_LEN];
snprintf(frame_name, MAX_FILENAME_LEN, "%s_0000", ga->filename);
ga->bitmap_id = bm_load(frame_name);
if(ga->bitmap_id < 0) {
mprintf(("Cannot find first frame for eff streaming. eff Filename: %s", ga->filename));
return -1;
}
snprintf(frame_name, MAX_FILENAME_LEN, "%s_0001", ga->filename);
ga->eff.next_frame = bm_load(frame_name);
bm_get_info(ga->bitmap_id, &ga->width, &ga->height);
ga->previous_frame = 0;
}
// keyframe info
if (ga->type == BM_TYPE_ANI) {
//we only care if there are 2 keyframes - first frame, other frame to jump to for ship/weapons
//mainhall door anis hav every frame as keyframe, so we don't care
//other anis only have the first frame
if(ga->ani.animation->num_keys == 2) {
int key1 = ga->ani.animation->keys[0].frame_num;
int key2 = ga->ani.animation->keys[1].frame_num;
if (key1 < 0 || key1 >= ga->num_frames) key1 = -1;
if (key2 < 0 || key2 >= ga->num_frames) key2 = -1;
// some retail anis have their keyframes reversed
// and some have their keyframes out of bounds
if (key1 >= 0 && key1 >= key2) {
ga->keyframe = ga->ani.animation->keys[0].frame_num;
ga->keyoffset = ga->ani.animation->keys[0].offset;
}
else if (key2 >= 0 && key2 >= key1) {
ga->keyframe = ga->ani.animation->keys[1].frame_num;
ga->keyoffset = ga->ani.animation->keys[1].offset;
}
}
}
ga->streaming = 1;
if (ga->type == BM_TYPE_PNG) {
ga->total_time = ga->png.anim->anim_time;
}
else {
if (anim_fps == 0) {
Error(LOCATION, "animation (%s) has invalid fps of zero, fix this!", ga->filename);
}
ga->total_time = ga->num_frames / (float) anim_fps;
}
ga->done_playing = 0;
ga->anim_time = 0.0f;
return 0;
}
