657 lines
17 KiB
C
657 lines
17 KiB
C
/*
|
|
Raydium - CQFD Corp.
|
|
http://raydium.org/
|
|
License: GPL - GNU General Public License, see "gpl.txt" file.
|
|
*/
|
|
|
|
#ifndef DONT_INCLUDE_HEADERS
|
|
#include "index.h"
|
|
#else
|
|
#include "headers/object.h"
|
|
#endif
|
|
|
|
GLint raydium_object_find(char *name)
|
|
{
|
|
GLint i;
|
|
for(i=0;i<raydium_object_index;i++)
|
|
if(!strcmp(raydium_object_name[i],name)) return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
signed char raydium_object_isvalid(int obj)
|
|
{
|
|
if(obj>=0 && obj<raydium_object_index)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
void raydium_object_reset(GLuint o)
|
|
{
|
|
raydium_object_name[o][0]=0;
|
|
raydium_object_start[o]=0;
|
|
raydium_object_end[o]=0;
|
|
raydium_object_anims[o]=0;
|
|
}
|
|
|
|
|
|
int raydium_object_load(char *filename)
|
|
{
|
|
if(raydium_object_find(filename)>=0)
|
|
{
|
|
raydium_log("ERROR: object: %s already loaded",filename);
|
|
return -1;
|
|
}
|
|
raydium_object_start[raydium_object_index]=raydium_vertex_index;
|
|
read_vertex_from(filename);
|
|
raydium_object_end[raydium_object_index]=raydium_vertex_index;
|
|
strcpy(raydium_object_name[raydium_object_index],filename);
|
|
return(raydium_object_index++);
|
|
}
|
|
|
|
GLint raydium_object_find_load(char *name)
|
|
{
|
|
int ret;
|
|
|
|
ret=raydium_object_find(name);
|
|
if(ret<0) return raydium_object_load(name);
|
|
return ret;
|
|
}
|
|
|
|
|
|
void raydium_object_draw(GLuint o)
|
|
{
|
|
#ifndef DEBUG_RENDER_DISABLE_DISPLAYLISTS
|
|
static GLuint dl[RAYDIUM_MAX_OBJECTS];
|
|
static char dl_state[RAYDIUM_MAX_OBJECTS];
|
|
static int first=0;
|
|
int i;
|
|
#endif
|
|
|
|
if(!raydium_object_isvalid(o))
|
|
{
|
|
raydium_log("object: draw: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
|
|
// if animated : draw "only" first (generated) frame
|
|
if(raydium_object_anims[o]>0)
|
|
{
|
|
raydium_object_anim_generate_internal(o,raydium_object_anim_instance_current[o]);
|
|
raydium_rendering_from_to(raydium_object_start[o],raydium_object_start[o]+raydium_object_anim_len[o]);
|
|
return;
|
|
}
|
|
// ...
|
|
|
|
|
|
#ifndef DEBUG_RENDER_DISABLE_DISPLAYLISTS
|
|
if(first)
|
|
for(i=0;i<RAYDIUM_MAX_OBJECTS;i++)
|
|
dl_state[i]=-1;
|
|
|
|
|
|
if(raydium_render_displaylists_tag && !raydium_shadow_rendering)
|
|
{
|
|
if(!dl_state[o])
|
|
{
|
|
// build DL
|
|
dl_state[o]=1;
|
|
dl[o]=glGenLists(1);
|
|
raydium_log("Object: creating display list for object %s",raydium_object_name[o]);
|
|
glNewList(dl[o],GL_COMPILE);
|
|
raydium_rendering_from_to(raydium_object_start[o],raydium_object_end[o]);
|
|
glEndList();
|
|
}
|
|
glCallList(dl[o]);
|
|
}
|
|
else raydium_rendering_from_to(raydium_object_start[o],raydium_object_end[o]);
|
|
|
|
#else
|
|
// No display lists, draw
|
|
raydium_rendering_from_to(raydium_object_start[o],raydium_object_end[o]);
|
|
#endif
|
|
}
|
|
|
|
void raydium_object_draw_name(char *name)
|
|
{
|
|
GLint i;
|
|
|
|
i=raydium_object_find(name);
|
|
|
|
if(i>=0) raydium_object_draw(i);
|
|
else
|
|
raydium_object_draw(raydium_object_load(name));
|
|
}
|
|
|
|
|
|
void raydium_object_deform(GLuint obj,GLfloat ampl)
|
|
{
|
|
GLuint i;
|
|
|
|
if(!raydium_object_isvalid(obj))
|
|
{
|
|
raydium_log("object: deform: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
for(i=raydium_object_start[obj];i<raydium_object_end[obj];i++)
|
|
{
|
|
raydium_vertex_x[i]+=raydium_random_neg_pos_1()*ampl;
|
|
raydium_vertex_y[i]+=raydium_random_neg_pos_1()*ampl;
|
|
raydium_vertex_z[i]+=raydium_random_neg_pos_1()*ampl;
|
|
}
|
|
|
|
/*
|
|
GLfloat ox,oy,oz;
|
|
GLfloat nx,ny,nz;
|
|
GLint j;
|
|
|
|
for(i=raydium_object_start[obj];i<raydium_object_end[obj];i++)
|
|
{
|
|
ox=raydium_vertex_x[i];
|
|
oy=raydium_vertex_y[i];
|
|
oz=raydium_vertex_z[i];
|
|
|
|
nx=ox+raydium_random_neg_pos_1()*ampl;
|
|
ny=oy+raydium_random_neg_pos_1()*ampl;
|
|
nz=oz+raydium_random_neg_pos_1()*ampl;
|
|
|
|
for(j=i;j<raydium_object_end[obj];j++)
|
|
if(raydium_vertex_x[j]==ox &&
|
|
raydium_vertex_y[j]==oy &&
|
|
raydium_vertex_z[j]==oz)
|
|
{
|
|
raydium_vertex_x[j]=nx;
|
|
raydium_vertex_y[j]=ny;
|
|
raydium_vertex_z[j]=nz;
|
|
}
|
|
}*/
|
|
}
|
|
|
|
|
|
void raydium_object_deform_name(char *name,GLfloat ampl)
|
|
{
|
|
raydium_object_deform(raydium_object_find(name),ampl);
|
|
}
|
|
|
|
|
|
GLfloat raydium_object_find_dist_max(GLuint obj)
|
|
{
|
|
GLfloat max=0,val;
|
|
int i;
|
|
int start,end;
|
|
|
|
if(!raydium_object_isvalid(obj))
|
|
{
|
|
raydium_log("object: find_dist_max: ERROR: id or name is invalid");
|
|
return -1;
|
|
}
|
|
|
|
if(raydium_object_anims[obj]>0)
|
|
{
|
|
raydium_object_anim_generate_internal(obj,raydium_object_anim_instance_current[obj]);
|
|
start=raydium_object_start[obj];
|
|
end=raydium_object_start[obj]+raydium_object_anim_len[obj];
|
|
}
|
|
else
|
|
{
|
|
start=raydium_object_start[obj];
|
|
end=raydium_object_end[obj];
|
|
}
|
|
|
|
for(i=start;i<end;i++)
|
|
{
|
|
val=sqrt((raydium_vertex_x[i]*raydium_vertex_x[i])+
|
|
(raydium_vertex_y[i]*raydium_vertex_y[i])+
|
|
(raydium_vertex_z[i]*raydium_vertex_z[i]) );
|
|
if(val>max) max=val;
|
|
}
|
|
return max;
|
|
}
|
|
|
|
void raydium_object_find_axes_max(GLuint obj, GLfloat *tx, GLfloat *ty, GLfloat *tz)
|
|
{
|
|
int i;
|
|
int start,end;
|
|
|
|
if(!raydium_object_isvalid(obj))
|
|
{
|
|
raydium_log("object: find_axes_max: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
if(raydium_object_anims[obj]>0)
|
|
{
|
|
raydium_object_anim_generate_internal(obj,raydium_object_anim_instance_current[obj]);
|
|
start=raydium_object_start[obj];
|
|
end=raydium_object_start[obj]+raydium_object_anim_len[obj];
|
|
}
|
|
else
|
|
{
|
|
start=raydium_object_start[obj];
|
|
end=raydium_object_end[obj];
|
|
}
|
|
|
|
|
|
*tx=*ty=*tz=0;
|
|
|
|
for(i=start;i<end;i++)
|
|
{
|
|
if(raydium_trigo_abs(raydium_vertex_x[i])>*tx) *tx=raydium_trigo_abs(raydium_vertex_x[i]);
|
|
if(raydium_trigo_abs(raydium_vertex_y[i])>*ty) *ty=raydium_trigo_abs(raydium_vertex_y[i]);
|
|
if(raydium_trigo_abs(raydium_vertex_z[i])>*tz) *tz=raydium_trigo_abs(raydium_vertex_z[i]);
|
|
}
|
|
*tx*=2;
|
|
*ty*=2;
|
|
*tz*=2;
|
|
}
|
|
|
|
|
|
void raydium_object_find_minmax(GLuint obj, GLfloat *min, GLfloat *max)
|
|
{
|
|
int i;
|
|
int start,end;
|
|
//GLfloat min[3];
|
|
//GLfloat max[3];
|
|
|
|
if(!raydium_object_isvalid(obj))
|
|
{
|
|
raydium_log("object: find_size: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
if(raydium_object_anims[obj]>0)
|
|
{
|
|
raydium_object_anim_generate_internal(obj,raydium_object_anim_instance_current[obj]);
|
|
start=raydium_object_start[obj];
|
|
end=raydium_object_start[obj]+raydium_object_anim_len[obj];
|
|
}
|
|
else
|
|
{
|
|
start=raydium_object_start[obj];
|
|
end=raydium_object_end[obj];
|
|
}
|
|
|
|
min[0]=max[0]=raydium_vertex_x[start];
|
|
min[1]=max[1]=raydium_vertex_y[start];
|
|
min[2]=max[2]=raydium_vertex_z[start];
|
|
|
|
for(i=start+1;i<end;i++)
|
|
{
|
|
if(raydium_vertex_x[i]<min[0])
|
|
min[0]=raydium_vertex_x[i];
|
|
if(raydium_vertex_y[i]<min[1])
|
|
min[1]=raydium_vertex_y[i];
|
|
if(raydium_vertex_z[i]<min[2])
|
|
min[2]=raydium_vertex_z[i];
|
|
|
|
if(raydium_vertex_x[i]>max[0])
|
|
max[0]=raydium_vertex_x[i];
|
|
if(raydium_vertex_y[i]>max[1])
|
|
max[1]=raydium_vertex_y[i];
|
|
if(raydium_vertex_z[i]>max[2])
|
|
max[2]=raydium_vertex_z[i];
|
|
}
|
|
/*tx=(max[0]-min[0]);
|
|
*ty=(max[1]-min[1]);
|
|
*tz=(max[2]-min[2]);*/
|
|
}
|
|
|
|
|
|
void raydium_object_find_center_factors(GLuint obj, GLfloat *tx, GLfloat *ty, GLfloat *tz)
|
|
{
|
|
GLfloat min[3];
|
|
GLfloat max[3];
|
|
|
|
raydium_object_find_minmax(obj,min,max);
|
|
*tx=(max[0]-((max[0]-min[0])/2));
|
|
*ty=(max[1]-((max[1]-min[1])/2));
|
|
*tz=(max[2]-((max[2]-min[2])/2));
|
|
|
|
(*tx)/=(max[0]-min[0]);
|
|
(*ty)/=(max[1]-min[1]);
|
|
(*tz)/=(max[2]-min[2]);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////
|
|
// Animation support starts here
|
|
|
|
|
|
GLint raydium_object_anim_find(int object, char *name)
|
|
{
|
|
int i;
|
|
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim_find: ERROR: id or name is invalid");
|
|
return -1;
|
|
}
|
|
|
|
for(i=0;i<raydium_object_anims[object];i++)
|
|
if(!strcmp(raydium_object_anim_names[object][i],name))
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
#define _pondavg(a,b,f) ( (a)+(((b)-(a))*(f)) )
|
|
|
|
// There's always a bug here, causing jitters when switching animation:
|
|
// frame_b jumps from "destination frame" to "destination frame"+1, as
|
|
// during normal operation
|
|
void raydium_object_anim_generate_internal(int object, int instance)
|
|
{
|
|
int i;
|
|
GLfloat factor;
|
|
int anim_frames;
|
|
int frame_a,frame_b;
|
|
int anim_current;
|
|
GLfloat anim_frame_current;
|
|
char flag;
|
|
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: generate_internal: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
// here starts the big job ! :)
|
|
anim_current=raydium_object_anim_current[object][instance];
|
|
anim_frame_current=raydium_object_anim_frame_current[object][instance];
|
|
|
|
|
|
// How many frames for the current anim ?
|
|
anim_frames=
|
|
raydium_object_anim_end[object][anim_current] -
|
|
raydium_object_anim_start[object][anim_current];
|
|
|
|
flag=0;
|
|
// slow ... :( (any good idea to make a modulo on a float ?)
|
|
while(anim_frame_current>(anim_frames+1))
|
|
{
|
|
anim_frame_current-=(anim_frames+1);
|
|
flag=1;
|
|
}
|
|
|
|
// end of ponctually anim ?
|
|
if(flag && raydium_object_anim_punctually_flag[object][instance]>=0)
|
|
{
|
|
raydium_object_anim_punctually_flag[object][instance]=-1;
|
|
raydium_object_anim(object,instance,raydium_object_anim_default_anim[object]);
|
|
raydium_object_anim_frame(object,instance,0);
|
|
// recursive call with regular situation
|
|
raydium_object_anim_generate_internal(object,instance);
|
|
return;
|
|
}
|
|
|
|
//printf("frame (int): %i\n",(int)raydium_object_anim_frame_current[object][instance]);
|
|
//printf("%f %i\n",raydium_object_anim_frame_current[object],anim_frames);
|
|
|
|
factor=anim_frame_current-(int)anim_frame_current;
|
|
|
|
frame_a=raydium_object_start[object]+
|
|
(raydium_object_anim_start[object][anim_current] *
|
|
raydium_object_anim_len[object]) +
|
|
(((int)anim_frame_current) *
|
|
raydium_object_anim_len[object]) +
|
|
raydium_object_anim_len[object];
|
|
|
|
|
|
if( ((int)anim_frame_current) >= anim_frames)
|
|
{
|
|
frame_b=raydium_object_start[object] +
|
|
(raydium_object_anim_start[object][anim_current] *
|
|
raydium_object_anim_len[object]) +
|
|
raydium_object_anim_len[object];
|
|
}
|
|
else
|
|
frame_b=frame_a+raydium_object_anim_len[object];
|
|
|
|
|
|
// if we come from another anim, let's erase frame_a
|
|
if(raydium_object_anim_previous[object][instance]>=0)
|
|
{
|
|
|
|
// is it the first pass right after anim change ?
|
|
if(raydium_object_anim_frame_previous_timeout[object][instance]==-1)
|
|
{
|
|
// save current frame
|
|
raydium_object_anim_frame_previous_timeout[object][instance]=raydium_object_anim_frame_current[object][instance];
|
|
//printf("*** start\n");
|
|
}
|
|
|
|
// We're now in current anim, cancel previous one
|
|
if(raydium_object_anim_frame_current[object][instance]-raydium_object_anim_frame_previous_timeout[object][instance]>=1)
|
|
{
|
|
raydium_object_anim_previous[object][instance]=-1;
|
|
//printf("*** end\n");
|
|
}
|
|
else
|
|
{
|
|
// ... erase frame_a
|
|
//printf("%f| erasing %i (%f)",anim_frame_current,anim_current,anim_frame_current);
|
|
anim_current=raydium_object_anim_previous[object][instance];
|
|
anim_frame_current=raydium_object_anim_frame_previous[object][instance];
|
|
|
|
anim_frames=
|
|
raydium_object_anim_end[object][anim_current] -
|
|
raydium_object_anim_start[object][anim_current];
|
|
|
|
// slow ... :( (any good idea to make a modulo on a float ?)
|
|
while(anim_frame_current>(anim_frames+1))
|
|
anim_frame_current-=(anim_frames+1);
|
|
|
|
//printf(" with %i (%f)\n",anim_current,anim_frame_current);
|
|
|
|
factor=(raydium_object_anim_frame_current[object][instance]-raydium_object_anim_frame_previous_timeout[object][instance]);
|
|
|
|
frame_a=raydium_object_start[object]+
|
|
(raydium_object_anim_start[object][anim_current] *
|
|
raydium_object_anim_len[object]) +
|
|
(((int)anim_frame_current) *
|
|
raydium_object_anim_len[object]) +
|
|
raydium_object_anim_len[object];
|
|
}
|
|
|
|
//printf("refresh from %i/%i (a) and %i/%i (b), factor = %.2f (%i af)\n",frame_a,frame_a/raydium_object_anim_len[object],frame_b,frame_b/raydium_object_anim_len[object],factor,anim_frames);
|
|
}
|
|
|
|
//printf("refresh from %i/%i (a) and %i/%i (b), factor = %.2f (%i af)\n",frame_a,frame_a/raydium_object_anim_len[object],frame_b,frame_b/raydium_object_anim_len[object],factor,anim_frames);
|
|
|
|
|
|
for(i=0;i<raydium_object_anim_len[object];i++)
|
|
{
|
|
raydium_vertex_x[raydium_object_start[object]+i]=_pondavg(raydium_vertex_x[frame_a+i],raydium_vertex_x[frame_b+i],factor);
|
|
raydium_vertex_y[raydium_object_start[object]+i]=_pondavg(raydium_vertex_y[frame_a+i],raydium_vertex_y[frame_b+i],factor);
|
|
raydium_vertex_z[raydium_object_start[object]+i]=_pondavg(raydium_vertex_z[frame_a+i],raydium_vertex_z[frame_b+i],factor);
|
|
|
|
raydium_vertex_normal_visu_x[raydium_object_start[object]+i]=_pondavg(raydium_vertex_normal_visu_x[frame_a+i],raydium_vertex_normal_visu_x[frame_b+i],factor);
|
|
raydium_vertex_normal_visu_y[raydium_object_start[object]+i]=_pondavg(raydium_vertex_normal_visu_y[frame_a+i],raydium_vertex_normal_visu_y[frame_b+i],factor);
|
|
raydium_vertex_normal_visu_z[raydium_object_start[object]+i]=_pondavg(raydium_vertex_normal_visu_z[frame_a+i],raydium_vertex_normal_visu_z[frame_b+i],factor);
|
|
|
|
raydium_vertex_texture_u[raydium_object_start[object]+i]=_pondavg(raydium_vertex_texture_u[frame_a+i],raydium_vertex_texture_u[frame_b+i],factor);
|
|
raydium_vertex_texture_v[raydium_object_start[object]+i]=_pondavg(raydium_vertex_texture_v[frame_a+i],raydium_vertex_texture_v[frame_b+i],factor);
|
|
|
|
raydium_vertex_texture[raydium_object_start[object]+i]=raydium_vertex_texture[frame_a+i];
|
|
}
|
|
}
|
|
|
|
void raydium_object_anim_frame(int object, int instance, GLfloat frame)
|
|
{
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim_frame: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
raydium_object_anim_frame_current[object][instance]=frame;
|
|
}
|
|
|
|
void raydium_object_anim_frame_name(char *object, int instance, GLfloat frame)
|
|
{
|
|
raydium_object_anim_frame(raydium_object_find_load(object),instance,frame);
|
|
}
|
|
|
|
|
|
void raydium_object_anim(int object, int instance, int anim)
|
|
{
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
if(anim<0 || anim>=raydium_object_anims[object])
|
|
{
|
|
raydium_log("object: anim: ERROR: id or name is invalid for animation");
|
|
return;
|
|
}
|
|
|
|
if(raydium_object_anim_current[object][instance]==anim)
|
|
return;
|
|
|
|
//printf("%i asked %i\n",raydium_object_anim_current[object][instance],anim);
|
|
// warning, change anim BEFORE anim's frame
|
|
raydium_object_anim_previous[object][instance]=raydium_object_anim_current[object][instance];
|
|
raydium_object_anim_frame_previous[object][instance]=raydium_object_anim_frame_current[object][instance];
|
|
raydium_object_anim_frame_previous_timeout[object][instance]=-1;
|
|
|
|
raydium_object_anim_current[object][instance]=anim;
|
|
}
|
|
|
|
void raydium_object_anim_name(char *object, int instance, char *anim)
|
|
{
|
|
int o;
|
|
o=raydium_object_find_load(object);
|
|
raydium_object_anim(o,instance,raydium_object_anim_find(o,anim));
|
|
}
|
|
|
|
|
|
void raydium_object_anim_instance(int object, int instance)
|
|
{
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim_instance: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
raydium_object_anim_instance_current[object]=instance;
|
|
}
|
|
|
|
void raydium_object_anim_instance_name(char *object, int instance)
|
|
{
|
|
raydium_object_anim_instance(raydium_object_find_load(object),instance);
|
|
}
|
|
|
|
void raydium_object_anim_automatic(int object, int anim, GLfloat factor)
|
|
{
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim_automatic: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
if(anim<0 || anim>=raydium_object_anims[object])
|
|
{
|
|
raydium_log("object: anim_automatic: ERROR: id or name is invalid for animation");
|
|
return;
|
|
}
|
|
|
|
//printf("%i %i %f\n",object,anim,factor);
|
|
raydium_object_anim_automatic_factor[object][anim]=factor;
|
|
}
|
|
|
|
|
|
void raydium_object_anim_automatic_name(char *object, char *anim, GLfloat factor)
|
|
{
|
|
int o;
|
|
|
|
o=raydium_object_find_load(object);
|
|
|
|
raydium_object_anim_automatic(o,raydium_object_anim_find(o,anim),factor);
|
|
}
|
|
|
|
void raydium_object_callback(void)
|
|
{
|
|
GLfloat f;
|
|
int o,i;
|
|
|
|
for(o=0;o<raydium_object_index;o++)
|
|
if(raydium_object_anims[o]>0)
|
|
for(i=0;i<RAYDIUM_MAX_OBJECT_ANIM_INSTANCES;i++)
|
|
{
|
|
f=raydium_frame_time * raydium_object_anim_time_factor *
|
|
raydium_object_anim_automatic_factor[o][raydium_object_anim_current[o][i]];
|
|
raydium_object_anim_frame_current[o][i]+=f;
|
|
}
|
|
}
|
|
|
|
|
|
void raydium_object_anim_default(int object, int anim)
|
|
{
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim_default: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
if(anim<0 || anim>=raydium_object_anims[object])
|
|
{
|
|
raydium_log("object: anim_default: ERROR: id or name is invalid for animation");
|
|
return;
|
|
}
|
|
|
|
raydium_object_anim_default_anim[object]=anim;
|
|
}
|
|
|
|
|
|
signed char raydium_object_anim_ispunctually(int object, int instance)
|
|
{
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim_isdefault: ERROR: id or name is invalid");
|
|
return 0;
|
|
}
|
|
|
|
return (raydium_object_anim_punctually_flag[object][instance]>=0?1:0);
|
|
}
|
|
|
|
signed char raydium_object_anim_ispunctually_name(char *object, int instance)
|
|
{
|
|
return raydium_object_anim_ispunctually(raydium_object_find_load(object),instance);
|
|
}
|
|
|
|
// punctually (change current and set flag. set frame to 0 [in,out])
|
|
void raydium_object_anim_punctually(int object, int anim, int instance)
|
|
{
|
|
if(!raydium_object_isvalid(object))
|
|
{
|
|
raydium_log("object: anim_punctually: ERROR: id or name is invalid");
|
|
return;
|
|
}
|
|
|
|
if(anim<0 || anim>=raydium_object_anims[object])
|
|
{
|
|
raydium_log("object: anim_punctually: ERROR: id or name is invalid for animation");
|
|
return;
|
|
}
|
|
|
|
raydium_object_anim(object,instance,anim);
|
|
raydium_object_anim_frame(object,instance,0);
|
|
raydium_object_anim_punctually_flag[object][instance]=anim;
|
|
}
|
|
|
|
|
|
void raydium_object_anim_punctually_name(char *object, char *anim, int instance)
|
|
{
|
|
int o;
|
|
|
|
o=raydium_object_find_load(object);
|
|
raydium_object_anim_punctually(o,raydium_object_anim_find(o,anim),instance);
|
|
}
|
|
|
|
// no loops for some animation (death)
|