void camera_static_get_position(d3pnt *pnt,d3ang *ang)
{
obj_type *obj;
// get position
memmove(pnt,&camera_static_pnt,sizeof(d3pnt));
if (ang==NULL) return;
// if following an object, point camera at object
if (camera.static_follow) {
obj=object_find_uid(camera.obj_uid);
ang->y=angle_find(camera_static_pnt.x,camera_static_pnt.z,obj->pnt.x,obj->pnt.z);
ang->x=-(180.0f-angle_find(camera_static_pnt.y,camera_static_pnt.z,obj->pnt.y,obj->pnt.z));
ang->z=camera.ang.z;
return;
}
// if in walk and not following
// then point way specified in node
if (camera.auto_walk.on) {
ang->x=angle_add(camera_static_walk_ang.x,camera.ang.x);
ang->y=angle_add(camera_static_walk_ang.y,camera.ang.y);
ang->z=angle_add(camera_static_walk_ang.z,camera.ang.z);
return;
}
// else just use camera offset
memmove(ang,&camera.ang,sizeof(d3ang));
}
void select_model_get_drag_direction(d3pnt *pnt)
{
float fx,fy,fz;
matrix_type mat;
fx=(float)pnt->x;
fy=(float)pnt->y;
fz=(float)pnt->z;
if (state.model.ang.x!=0) {
matrix_rotate_x(&mat,state.model.ang.x);
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
}
if (state.model.ang.y!=0) {
matrix_rotate_y(&mat,angle_add(state.model.ang.y,180.0f));
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
}
if (state.model.ang.z!=0) {
matrix_rotate_z(&mat,state.model.ang.z);
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
}
pnt->x=(int)fx;
pnt->y=(int)fy;
pnt->z=(int)fz;
}
void camera_chase_static_get_position(d3pnt *pnt,d3ang *ang)
{
int cx,cz,cy;
float fx,fy,fz;
matrix_type mat;
obj_type *obj;
obj=object_find_uid(camera.obj_uid);
// get static chase position
fx=0;
fy=0;
fz=(float)camera.chase_distance;
matrix_rotate_zyx(&mat,camera.cur_chase_ang.x,camera.cur_chase_ang.y,camera.cur_chase_ang.z);
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
cx=(int)fx+obj->pnt.x;
cy=(int)fy+obj->pnt.y-obj->size.y;
cz=(int)fz+obj->pnt.z;
// new camera position
pnt->x=camera.pnt.x=cx+camera.chase_offset.x;
pnt->y=camera.pnt.y=cy+camera.chase_offset.y;
pnt->z=camera.pnt.z=cz+camera.chase_offset.z;
// looking angles
ang->x=(camera.cur_chase_ang.x+camera.ang.x);
ang->y=angle_add(camera.cur_chase_ang.y,camera.ang.y);
ang->z=camera.ang.z;
}
void weapon_kickback(int tick,obj_type *obj,weapon_type *weap)
{
d3ang ang;
ang.x=0;
ang.y=angle_add(obj->ang.y,180.0f);
ang.z=0;
object_shove(obj,&ang,(float)weap->kickback.size);
}
void camera_chase_run(void)
{
float goal_y;
obj_type *obj;
obj=server.obj_list.objs[camera.obj_idx];
goal_y=angle_add(obj->ang.y,map.camera.chase.track_ang.y);
camera.cur_pos.chase_ang.y=camera_chase_run_slop(camera.cur_pos.chase_ang.y,goal_y,map.camera.chase.slop.y,map.camera.chase.track_speed);
}
void camera_chase_run(void)
{
float goal_y;
obj_type *obj;
obj=object_find_uid(camera.obj_uid);
goal_y=angle_add(obj->ang.y,camera.chase_ang.y);
camera.cur_chase_ang.y=camera_chase_run_slop(camera.cur_chase_ang.y,goal_y,camera.chase_slop.y,camera.chase_track_speed);
}
bool weapon_get_projectile_position_angle_object_model(int tick,obj_type *obj,weapon_type *weap,d3pnt *fire_pnt,d3ang *fire_ang,char *err_str)
{
int pose_idx,bone_idx;
model_type *mdl;
model_draw_setup *setup;
// get model
mdl=model_find_uid(obj->draw.uid);
if (mdl==NULL) {
if (err_str!=NULL) strcpy(err_str,"Object has no model");
return(FALSE);
}
// get current pose
pose_idx=model_find_pose(mdl,weap->proj.object_fire_pose_name);
if (pose_idx==-1) {
if (err_str!=NULL) strcpy(err_str,"Object has missing or no fire pose");
return(FALSE);
}
// get bone offset and calc
bone_idx=model_find_bone(mdl,weap->proj.object_fire_bone_tag);
if (bone_idx==-1) {
if (err_str!=NULL) strcpy(err_str,"Object has missing or no fire bone");
return(FALSE);
}
model_draw_setup_object(tick,obj);
setup=&obj->draw.setup;
setup->move.x=setup->move.y=setup->move.z=0;
setup->sway.x=setup->sway.y=setup->sway.z=0.0f;
model_calc_draw_bone_position(mdl,setup,pose_idx,bone_idx,&fire_pnt->x,&fire_pnt->y,&fire_pnt->z);
// move fire point in front of obj
fire_pnt->x+=obj->draw.pnt.x;
fire_pnt->y+=obj->draw.pnt.y;
fire_pnt->z+=obj->draw.pnt.z;
if (weap->draw.no_rot.on) gl_project_fix_rotation(&fire_pnt->x,&fire_pnt->y,&fire_pnt->z);
// angle from object
fire_ang->x=angle_add(setup->ang.x,obj->view_ang.x);
fire_ang->y=setup->ang.y;
fire_ang->z=setup->ang.z;
return(TRUE);
}
JSValueRef js_map_object_get_angle_func(JSContextRef cx,JSObjectRef func,JSObjectRef j_obj,size_t argc,const JSValueRef argv[],JSValueRef *exception)
{
d3ang ang;
obj_type *obj;
if (!script_check_param_count(cx,func,argc,1,exception)) return(script_null_to_value(cx));
// uid
obj=script_find_obj_from_uid_arg(cx,argv[0],exception);
if (obj==NULL) return(script_null_to_value(cx));
// get angle
ang.x=angle_add(obj->ang.x,obj->face.ang.x);
ang.y=angle_add(obj->ang.y,obj->face.ang.y);
ang.z=angle_add(obj->ang.z,obj->face.ang.z);
return(script_angle_to_value(cx,&ang));
}
void camera_chase_connect(void)
{
obj_type *obj;
obj=server.obj_list.objs[camera.obj_idx];
memmove(&camera.cur_pos.pnt,&obj->pnt,sizeof(d3pnt));
camera.cur_pos.chase_ang.x=map.camera.chase.track_ang.x;
camera.cur_pos.chase_ang.y=angle_add(obj->ang.y,map.camera.chase.track_ang.y);
camera.cur_pos.chase_ang.z=map.camera.chase.track_ang.z;
}
void object_player_turn(obj_type *obj)
{
float turn_add,turn_restrict;
weapon_type *weap;
// can it turn?
if ((obj->turn.only_when_moving) && (!obj->forward_move.moving)) {
obj->turn.ang_add.y=0;
return;
}
// get turn speed
obj->turn.fix_ang_add.y=0;
turn_add=obj->turn.ang_add.y;
if (turn_add==0) return;
// zoom factors
if (camera.mode==cv_fpp) {
weap=weapon_find_current(obj);
if (weap!=NULL) {
if ((weap->zoom.on) && (weap->zoom.mode!=zoom_mode_off)) {
if (obj->duck.mode!=dm_duck) {
turn_add*=weap->zoom.turn_factor;
}
else {
turn_add*=weap->zoom.crawl_turn_factor;
}
}
}
}
// restriction
if (obj->turn.restrict_player_turning) {
turn_restrict=object_get_turn_speed(obj);
if (turn_add<-turn_restrict) turn_add=-turn_restrict;
if (turn_add>turn_restrict) turn_add=turn_restrict;
}
// turning
obj->ang.y=angle_add(obj->ang.y,turn_add);
obj->turn.fix_ang_add.y=turn_add;
// turn any standing objects
object_rotate_with_standing_object(obj,turn_add);
}
void camera_chase_connect(void)
{
obj_type *obj;
obj=object_find_uid(camera.obj_uid);
memmove(&camera.pnt,&obj->pnt,sizeof(d3pnt));
// current chasing angle
camera.cur_chase_ang.x=camera.chase_ang.x;
camera.cur_chase_ang.y=angle_add(obj->ang.y,camera.chase_ang.y);
camera.cur_chase_ang.z=camera.chase_ang.z;
}
void player_movement_top_down_input(obj_type *obj)
{
bool left,right,up,down;
left=input_action_get_state(nc_turn_left);
right=input_action_get_state(nc_turn_right);
up=input_action_get_state(nc_move_forward);
down=input_action_get_state(nc_move_backward);
// all the movements
if (left) {
if (up) {
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,315.0f));
return;
}
if (down) {
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,225.0f));
return;
}
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,270.0f));
return;
}
if (right) {
if (up) {
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,45.0f));
return;
}
if (down) {
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,135.0f));
return;
}
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,90.0f));
return;
}
if (up) {
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,0.0f));
return;
}
if (down) {
object_player_turn_direct(obj,angle_add(obj->turn.top_down_ang_offset,180.0f));
return;
}
}
void al_set_listener(d3pnt *pnt,float ang_y)
{
SDL_LockAudio();
// position
audio_listener_pnt.x=pnt->x;
audio_listener_pnt.y=pnt->y;
audio_listener_pnt.z=pnt->z;
// add 90 degrees to put ears on side of head
audio_listener_ang_y=angle_add(ang_y,-90.0f);
SDL_UnlockAudio();
}
float camera_chase_run_slop(float ang,float goal,float slop,float chase_track_speed)
{
float dif;
bool cwise;
if ((ang==goal) || (slop==0)) return(goal);
// force angle to within min/max slop
dif=angle_dif(ang,goal,&cwise);
if (dif>slop) {
ang=angle_add(goal,(cwise?(-slop):(slop)));
}
// now turn towards goal
return(angle_turn_toward(ang,goal,chase_track_speed));
}
void object_turn(obj_type *obj)
{
float ang,rang,turn_add,subway,addway;
turn_add=obj->turn.ang_add.y;
if (turn_add==0) return;
ang=obj->ang.y;
if (obj->turn.ang_to.y==ang) return;
rang=obj->turn.ang_to.y;
if (ang>rang) {
subway=ang-rang;
addway=360-(ang-rang);
}
else {
subway=360-(rang-ang);
addway=rang-ang;
}
if (turn_add<0) {
if (fabs(turn_add)>=subway) {
obj->ang.y=rang;
return;
}
}
else {
if (turn_add>=addway) {
obj->ang.y=rang;
return;
}
}
// turn object
obj->ang.y=angle_add(ang,turn_add);
// turn any standing objects
object_rotate_with_standing_object(obj,turn_add);
}
JSValueRef js_map_object_is_facing_id_func(JSContextRef cx,JSObjectRef func,JSObjectRef j_obj,size_t argc,const JSValueRef argv[],JSValueRef *exception)
{
float ang_y,ang_dif;
bool cwise;
obj_type *obj,*obj2;
if (!script_check_param_count(cx,func,argc,3,exception)) return(script_null_to_value(cx));
// uids
obj=script_find_obj_from_uid_arg(cx,argv[0],exception);
if (obj==NULL) return(script_null_to_value(cx));
obj2=script_find_obj_from_uid_arg(cx,argv[1],exception);
if (obj2==NULL) return(script_null_to_value(cx));
// get angles to
ang_y=angle_find(obj->pnt.x,obj->pnt.z,obj2->pnt.x,obj2->pnt.z);
ang_dif=angle_dif(ang_y,angle_add(obj->ang.y,obj->face.ang.y),&cwise);
return(script_bool_to_value(cx,ang_dif<script_value_to_float(cx,argv[2])));
}
bool object_watch_restrict(obj_type *obj,obj_type *watch_obj)
{
float ang_y,ang_dif;
bool cwise;
d3pnt spt,ept;
ray_trace_contact_type contact;
// within angle
ang_y=angle_find(obj->pnt.x,obj->pnt.z,watch_obj->pnt.x,watch_obj->pnt.z);
ang_dif=angle_dif(ang_y,angle_add(obj->ang.y,obj->face.ang.y),&cwise);
if (ang_dif>(obj->watch.watch_restrict.ang*0.5f)) return(FALSE);
// is ray tracing on?
if (!obj->watch.watch_restrict.ray_trace) return(TRUE);
// can ray trace from eye to middle
contact.obj.on=FALSE;
contact.proj.on=FALSE;
contact.obj.ignore_idx=-1;
contact.proj.ignore_idx=-1;
contact.origin=poly_ray_trace_origin_object;
spt.x=obj->pnt.x;
spt.y=obj->pnt.y+obj->size.eye_offset;
spt.z=obj->pnt.z;
ept.x=watch_obj->pnt.x;
ept.y=watch_obj->pnt.y-(watch_obj->size.y>>1);
ept.z=watch_obj->pnt.z;
return(!ray_trace_map_by_point(&spt,&ept,&contact));
}
void camera_chase_calc_position(void)
{
int radius;
float fang,fx,fy,fz;
d3pnt spt,ept;
ray_trace_contact_type contact;
matrix_type mat;
obj_type *obj;
obj=server.obj_list.objs[camera.obj_idx];
// get camera starting position
radius=object_get_radius(obj);
fx=0;
fy=0;
fz=(float)(radius>>2); // always move camera back to protect against hitting walls in front of player
fang=angle_add(camera.cur_pos.chase_ang.x,(obj->view_ang.x*2));
matrix_rotate_zyx(&mat,fang,camera.cur_pos.chase_ang.y,camera.cur_pos.chase_ang.z);
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
spt.x=((int)fx)+obj->pnt.x;
spt.y=((int)fy)+(obj->pnt.y+obj->size.eye_offset);
spt.z=((int)fz)+obj->pnt.z;
// get camera ending position
fx=0;
fy=0;
fz=(float)map.camera.chase.distance;
fang=angle_add(camera.cur_pos.chase_ang.x,-obj->view_ang.x);
matrix_rotate_zyx(&mat,fang,camera.cur_pos.chase_ang.y,camera.cur_pos.chase_ang.z);
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
ept.x=((int)fx)+obj->pnt.x;
ept.y=((int)fy)+(obj->pnt.y+obj->size.eye_offset);
ept.z=((int)fz)+obj->pnt.z;
// setup contacts
contact.obj.on=TRUE;
contact.obj.ignore_idx=obj->idx;
contact.proj.on=FALSE;
contact.origin=poly_ray_trace_origin_unknown;
ray_trace_map_by_point(&spt,&ept,&contact);
// the position
camera.cur_pos.pnt.x=contact.hpt.x+map.camera.pnt_offset.x;
camera.cur_pos.pnt.y=contact.hpt.y+map.camera.pnt_offset.y;
camera.cur_pos.pnt.z=contact.hpt.z+map.camera.pnt_offset.z;
if (obj->bump.on) camera.cur_pos.pnt.y+=obj->bump.smooth_offset;
// looking angles
// need to reverse X looking angle so it
// behaves opposite track X angle
camera.cur_pos.ang.x=(camera.cur_pos.chase_ang.x-map.camera.ang_offset.x)-obj->view_ang.x;
camera.cur_pos.ang.y=angle_add(camera.cur_pos.chase_ang.y,map.camera.ang_offset.y);
camera.cur_pos.ang.z=camera.cur_pos.chase_ang.z+map.camera.ang_offset.z;
}
bool weapon_get_projectile_position_angle_weapon_model(int tick,obj_type *obj,weapon_type *weap,d3pnt *fire_pnt,d3ang *fire_ang,char *err_str)
{
int pose_idx,bone_idx;
model_type *mdl;
model_draw *draw;
model_draw_setup *setup;
// get model
mdl=model_find_uid(weap->draw.uid);
if (mdl==NULL) {
if (err_str!=NULL) strcpy(err_str,"Weapon has no model");
return(FALSE);
}
// get current pose
pose_idx=model_find_pose(mdl,weap->proj.fire_pose_name);
if (pose_idx==-1) {
if (err_str!=NULL) strcpy(err_str,"Weapon has missing or no fire pose");
return(FALSE);
}
// get 'fire' bone offset and calc
bone_idx=model_find_bone(mdl,weap->proj.fire_bone_tag);
if (bone_idx==-1) {
if (err_str!=NULL) strcpy(err_str,"Weapon has missing or no fire bone");
return(FALSE);
}
model_draw_setup_weapon(tick,obj,weap,TRUE,weap->dual.in_dual);
if (weap->dual.in_dual) {
draw=&weap->draw_dual;
}
else {
draw=&weap->draw;
}
setup=&draw->setup;
setup->move.x=setup->move.y=setup->move.z=0;
setup->sway.x=setup->sway.y=setup->sway.z=0.0f;
model_calc_draw_bone_position(mdl,setup,pose_idx,bone_idx,&fire_pnt->x,&fire_pnt->y,&fire_pnt->z);
if (draw->flip_x) fire_pnt->x=-fire_pnt->x;
fire_pnt->x+=draw->pnt.x;
fire_pnt->y+=draw->pnt.y;
fire_pnt->z+=draw->pnt.z;
if (draw->no_rot.on) gl_project_fix_rotation(&fire_pnt->x,&fire_pnt->y,&fire_pnt->z);
// fire angle
fire_ang->x=angle_add(setup->ang.x,obj->draw.setup.ang.x);
fire_ang->y=angle_add(setup->ang.y,angle_add(obj->draw.setup.ang.y,180.0f));
fire_ang->z=angle_add(setup->ang.z,obj->draw.setup.ang.z);
if (draw->flip_x) fire_ang->y=angle_add(fire_ang->y,180.0f);
return(TRUE);
}
void weapon_recoil_add(obj_type *obj,weapon_type *weap,d3ang *ang)
{
ang->x=object_player_look_constrain(obj,weap,(ang->x+weap->recoil.ang.x));
ang->y=angle_add(ang->y,weap->recoil.ang.y);
ang->z+=weap->recoil.ang.z;
}
void camera_chase_get_position(d3pnt *pnt,d3ang *ang)
{
int n,xadd,yadd,zadd,radius,div,
cx,cz,cy;
float fang,fx,fy,fz;
d3pnt spt,ept,hpt;
ray_trace_contact_type contact;
matrix_type mat;
obj_type *obj;
weapon_type *weap;
obj=object_find_uid(camera.obj_uid);
// get maximum camera offset
fx=0;
fy=0;
fz=(float)camera.chase_distance;
fang=angle_add(camera.cur_chase_ang.x,-obj->view_ang.x);
matrix_rotate_zyx(&mat,fang,camera.cur_chase_ang.y,camera.cur_chase_ang.z);
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
cx=(int)fx+obj->pnt.x;
cy=(int)fy+obj->pnt.y;
cz=(int)fz+obj->pnt.z;
// get camera movement
div=camera_chase_get_division(abs(cx-obj->pnt.x),abs(cz-obj->pnt.z),abs(cy-obj->pnt.y));
if (div==0) div=1;
xadd=(cx-obj->pnt.x)/div;
yadd=(cy-obj->pnt.y)/div;
zadd=(cz-obj->pnt.z)/div;
// get camera starting position
radius=camera.chase_size;
fx=0;
fy=0;
fz=(float)(radius>>2); // always move camera back to protect against hitting walls in front of player
fang=angle_add(camera.cur_chase_ang.x,(obj->view_ang.x*2));
matrix_rotate_zyx(&mat,fang,camera.cur_chase_ang.y,camera.cur_chase_ang.z);
matrix_vertex_multiply(&mat,&fx,&fy,&fz);
cx=(int)fx+obj->pnt.x;
cz=(int)fz+obj->pnt.z;
cy=(int)fy+(obj->pnt.y-obj->size.y);
// setup contacts
contact.obj.on=TRUE;
contact.obj.ignore_uid=obj->uid;
contact.proj.on=FALSE;
contact.origin=poly_ray_trace_origin_unknown;
// move camera
for (n=0;n!=div;n++) {
// xz movement
spt.x=cx;
spt.y=cy;
spt.z=cz;
ept.x=cx+xadd;
ept.y=cy;
ept.z=cz+zadd;
contact.hit_mode=poly_ray_trace_hit_mode_wall_only;
if (!ray_trace_map_by_point(&spt,&ept,&hpt,&contact)) {
cx+=xadd;
cz+=zadd;
}
// y movement
spt.x=cx;
spt.y=cy;
spt.z=cz;
ept.x=cx;
ept.y=cy+yadd;
ept.z=cz;
contact.hit_mode=poly_ray_trace_hit_mode_floor_only;
if (!ray_trace_map_by_point(&spt,&ept,&hpt,&contact)) cy+=yadd;
}
// new camera position
camera.pnt.x=cx;
camera.pnt.y=cy;
camera.pnt.z=cz;
// return values
memmove(pnt,&camera.pnt,sizeof(d3pnt));
// looking angles
ang->x=(camera.cur_chase_ang.x+camera.ang.x)-obj->view_ang.x;
weap=weapon_find_current(obj);
if (weap!=NULL) ang->x=object_player_look_constrain(obj,weap,ang->x);
ang->y=angle_add(camera.cur_chase_ang.y,camera.ang.y);
ang->z=camera.ang.z;
}
void view_dim3rtl_effect_mesh_particle_update(effect_type *effect,int count,int image_offset)
{
int n,k,idx,particle_count,quad_count,
ntrail,pixel_dif,material_id;
short *polys,*vk;
float gravity,gx,gy,g_size,pixel_sz,f,trail_step,
alpha_dif,color_dif,f_count,f_tick;
float *vp,*uv;
d3pnt pnt;
d3ang *rot_ang,rang;
rtlColor col;
iface_particle_type *particle;
particle_effect_data *eff_particle;
matrix_type pixel_x_mat,pixel_y_mat;
// have a mesh?
if (effect->rtl_mesh_id==-1) return;
// get particle
eff_particle=&effect->data.particle;
particle=&iface.particle_list.particles[eff_particle->particle_idx];
f_count=(float)count;
// position
particle_draw_position(effect,count,&pnt);
// particle move rotation
// we can have rotations from being attached to a bone of a model
// or the timed rotations from the particle setup
// we only want to set these up if the rotation is necessary as it
// saves time over thousands of particles
rot_ang=NULL;
if (eff_particle->rot.on) {
rang.x=eff_particle->rot.ang.x;
rang.y=eff_particle->rot.ang.y;
rang.z=eff_particle->rot.ang.z;
rot_ang=⟩
}
if ((particle->rot.x!=0.0f) || (particle->rot.y!=0.0f) || (particle->rot.z!=0.0f)) {
if (rot_ang==NULL) {
rang.x=rang.y=rang.z=0.0f;
rot_ang=⟩
}
f=f_count*particle->rot.x;
f+=(f*particle->rot_accel.x);
rot_ang->x=angle_add(rot_ang->x,f);
f=f_count*particle->rot.y;
f+=(f*particle->rot_accel.y);
rot_ang->y=angle_add(rot_ang->y,f);
f=f_count*particle->rot.z;
f+=(f*particle->rot_accel.z);
rot_ang->z=angle_add(rot_ang->z,f);
}
// particle billboard rotation
matrix_rotate_x(&pixel_x_mat,view.render->camera.ang.x);
matrix_rotate_y(&pixel_y_mat,view.render->camera.ang.y);
// reverse
if (particle->reverse) count=(effect->life_tick-count);
// setup size
f_tick=(float)effect->life_tick;
pixel_dif=particle->end_pixel_size-particle->start_pixel_size;
pixel_sz=(float)(particle->start_pixel_size+((pixel_dif*count)/effect->life_tick));
// setup images
effect_image_animate_get_uv(count,image_offset,&particle->animate,&gx,&gy,&g_size);
// reduce x/z/y movement and add in offset
count=count/10;
// construct meshes
// each particle is a quad
quad_count=particle->count*(particle->trail_count+1);
rtlSceneMeshMapVertexPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id,(void**)&vp);
rtlSceneMeshMapUVPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id,(void**)&uv);
// setup the vertexes
particle_count=particle->count;
ntrail=particle->trail_count+1;
trail_step=particle->trail_step;
f_count=(float)count;
for (n=0;n!=ntrail;n++) {
// get gravity
gravity=particle_get_gravity(particle,count);
// create mesh quads
view_dim3rtl_effect_mesh_particle_quad(vp,uv,&pnt,rot_ang,pixel_sz,&pixel_x_mat,&pixel_y_mat,gravity,f_count,particle_count,particle->pieces[eff_particle->variation_idx],gx,gy,g_size);
vp+=((particle->count*3)*4);
uv+=((particle->count*2)*4);
// reduce pixel sizes and counts for trails
pixel_sz=pixel_sz*particle->reduce_pixel_fact;
f_count-=trail_step;
}
rtlSceneMeshUnMapVertexPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id);
rtlSceneMeshUnMapUVPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id);
// build the polygons
material_id=particle->rtl_material_id;
polys=(short*)malloc(sizeof(short)*(quad_count*10));
vk=polys;
idx=0;
for (n=0;n!=quad_count;n++) {
*vk++=4;
*vk++=material_id;
for (k=0;k!=4;k++) {
*vk++=idx;
*vk++=idx;
idx++;
}
}
rtlSceneMeshSetPoly(view_rtl_draw_scene_id,effect->rtl_mesh_id,RL_MESH_FORMAT_POLY_SHORT_VERTEX_UV,quad_count,polys);
free(polys);
// setup color and alpha
color_dif=particle->end_color.r-particle->start_color.r;
col.r=particle->start_color.r+((color_dif*f_count)/f_tick);
color_dif=particle->end_color.g-particle->start_color.g;
col.g=particle->start_color.g+((color_dif*f_count)/f_tick);
color_dif=particle->end_color.b-particle->start_color.b;
col.b=particle->start_color.b+((color_dif*f_count)/f_tick);
alpha_dif=particle->end_alpha-particle->start_alpha;
col.a=particle->start_alpha+((alpha_dif*f_count)/f_tick);
rtlSceneMeshSetPolyColorAll(view_rtl_draw_scene_id,effect->rtl_mesh_id,&col);
}
bool object_move_xz_slide_line(obj_type *obj,int *xadd,int *yadd,int *zadd,int lx,int rx,int lz,int rz)
{
int n,xadd2,yadd2,zadd2,mx,mz;
float f,ang,rang;
bool hit,cwise;
d3vct line_vct,obj_vct;
// special check for horizontal/vertical walls
if (lx==rx) {
xadd2=0;
yadd2=0;
zadd2=*zadd;
if (collide_object_to_map(obj,&xadd2,&yadd2,&zadd2)) return(FALSE);
obj->pnt.z+=zadd2;
xadd2=*xadd;
yadd2=0;
zadd2=0;
if (collide_object_to_map(obj,&xadd2,&yadd2,&zadd2)) return(FALSE);
obj->pnt.x+=xadd2;
return(FALSE);
}
if (lz==rz) {
xadd2=*xadd;
yadd2=0;
zadd2=0;
if (collide_object_to_map(obj,&xadd2,&yadd2,&zadd2)) return(FALSE);
obj->pnt.x+=xadd2;
xadd2=0;
yadd2=0;
zadd2=*zadd;
if (collide_object_to_map(obj,&xadd2,&yadd2,&zadd2)) return(FALSE);
obj->pnt.z+=zadd2;
return(FALSE);
}
// get angle between the line and the object movement
obj_vct.x=(float)*xadd;
obj_vct.y=0.0f;
obj_vct.z=(float)*zadd;
vector_normalize(&obj_vct);
vector_create(&line_vct,lx,0,lz,rx,0,rz); // perpendicular vector (swap x/z)
// get the angle between them
f=vector_dot_product(&obj_vct,&line_vct);
f=((float)acos(f))*RAD_to_ANG;
// get angle of wall. If the angle between the
// collision lines is less than 90, then head down
// the line the opposite way
ang=angle_find(lx,lz,rx,rz);
if (f<90.0f) ang=angle_add(ang,180.0f);
// change the motion to reflect the angle of the wall
// uses facing instead of motion to check so we
// don't get motion build up from sliding against a wall
rang=obj->ang.y;
if (obj->forward_move.reverse) rang=angle_add(rang,180.0f);
if (angle_dif(rang,ang,&cwise)<90.0f) {
if (!obj->forward_move.reverse) {
obj->motion.ang.y=ang;
}
else {
obj->motion.ang.y=angle_add(ang,180.0f);
}
}
// reduce movement to slide against the walls
mz=*zadd/ws_step_factor;
mx=*xadd/ws_step_factor;
for (n=0;n!=ws_step_factor;n++) {
// try z then x movement first
xadd2=0;
yadd2=0;
zadd2=mz;
hit=collide_object_to_map(obj,&xadd2,&yadd2,&zadd2);
if (!hit) {
obj->pnt.z+=zadd2;
xadd2=mx;
yadd2=0;
zadd2=0;
if (!collide_object_to_map(obj,&xadd2,&yadd2,&zadd2)) {
obj->pnt.x+=xadd2;
}
continue;
}
// try x then z movement next
xadd2=mx;
yadd2=0;
zadd2=0;
hit=collide_object_to_map(obj,&xadd2,&yadd2,&zadd2);
if (!hit) {
obj->pnt.x+=xadd2;
xadd2=0;
yadd2=0;
zadd2=mz;
if (!collide_object_to_map(obj,&xadd2,&yadd2,&zadd2)) {
obj->pnt.z+=zadd2;
}
}
}
return(FALSE);
}
void object_motion_setup(obj_type *obj,float *xmove,float *ymove,float *zmove)
{
float ang,xadd,zadd;
// if thrust input type, then use thrust
if (obj->input_mode==im_thrust) {
*xmove=obj->thrust.vct.x+obj->force.vct.x;
*ymove=obj->thrust.vct.y+obj->force.vct.y;
*zmove=obj->thrust.vct.z+obj->force.vct.z;
return;
}
// forward motion
ang=obj->motion.ang.y;
get_motion_movement(ang,&obj->forward_move,xmove,zmove);
// side motion
if (obj->side_step) {
get_motion_movement(angle_add(ang,270),&obj->side_move,&xadd,&zadd);
*xmove=(*xmove)+xadd;
*zmove=(*zmove)+zadd;
}
// vertical motion
*ymove=0;
// flying or swiming
if ((obj->fly) || (obj->liquid_mode==lm_under)) {
// in auto-walk?
if (obj->auto_walk.mode!=aw_none) {
if (obj->forward_move.moving) {
angle_get_movement_float(obj->vert_move.seek_ang,obj->vert_move.max_walk_speed,&xadd,&zadd);
*ymove=xadd;
}
}
// regular seeking
else {
*ymove=obj->vert_move.speed;
if (obj->vert_move.reverse) *ymove=-(*ymove);
}
}
// climbing ladders
else {
if (obj->on_ladder) {
*ymove=obj->vert_move.speed;
if (obj->vert_move.reverse) *ymove=-(*ymove);
}
}
// add in outside forces
*xmove=(*xmove)+obj->force.vct.x;
*ymove=(*ymove)+obj->force.vct.y;
*zmove=(*zmove)+obj->force.vct.z;
}
void view_dim3rtl_effect_mesh_ring_update(effect_type *effect,int count,int image_offset)
{
int n,k,life_tick,idx,
material_id;
short *polys,*vk;
float mx,my,mz,fx,fy,fz,
outer_sz,inner_sz,rd,
color_dif,alpha,gx,gy,g_size,
f_count,f_tick;
float *vp,*uv;
d3pnt pnt;
rtlColor col;
iface_ring_type *ring;
ring_effect_data *eff_ring;
matrix_type mat_x,mat_y,mat_z;
eff_ring=&effect->data.ring;
ring=&iface.ring_list.rings[eff_ring->ring_idx];
// get size
life_tick=effect->life_tick;
f_tick=(float)life_tick;
f_count=(float)count;
outer_sz=(float)(ring->end_outer_size-ring->start_outer_size);
outer_sz=((outer_sz*f_count)/f_tick)+(float)ring->start_outer_size;
inner_sz=(float)(ring->end_inner_size-ring->start_inner_size);
inner_sz=((inner_sz*f_count)/f_tick)+(float)ring->start_inner_size;
// setup images
effect_image_animate_get_uv(count,image_offset,&ring->animate,&gx,&gy,&g_size);
// position and ring rotation
ring_draw_position(effect,count,&pnt);
mx=(float)pnt.x;
my=(float)pnt.y;
mz=(float)pnt.z;
fx=f_count*ring->rot.x;
fx+=(fx*ring->rot_accel.x);
fx=angle_add(eff_ring->ang.x,fx);
fy=f_count*ring->rot.y;
fy+=(fy*ring->rot_accel.y);
fy=angle_add(eff_ring->ang.y,fy);
fz=f_count*ring->rot.z;
fz+=(fz*ring->rot_accel.z);
fz=angle_add(eff_ring->ang.z,fz);
matrix_rotate_x(&mat_x,-fx);
matrix_rotate_z(&mat_z,fz);
matrix_rotate_y(&mat_y,fy);
// create the ring vertexes
rtlSceneMeshMapVertexPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id,(void**)&vp);
rtlSceneMeshMapUVPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id,(void**)&uv);
for (n=0;n!=360;n+=10) {
rd=((float)n)*ANG_to_RAD;
// outer
fx=cosf(rd)*outer_sz;
fy=-(sinf(rd)*outer_sz);
fz=0.0f;
matrix_vertex_multiply(&mat_x,&fx,&fy,&fz);
matrix_vertex_multiply(&mat_z,&fx,&fy,&fz);
matrix_vertex_multiply(&mat_y,&fx,&fy,&fz);
*vp++=mx+fx;
*vp++=my+fy;
*vp++=mz+fz;
*uv++=gx+(g_size*((fx+outer_sz)/(outer_sz*2.0f)));
*uv++=gy+(g_size*((fy+outer_sz)/(outer_sz*2.0f)));
// inner
fx=cosf(rd)*inner_sz;
fy=-(sinf(rd)*inner_sz);
fz=0.0f;
matrix_vertex_multiply(&mat_x,&fx,&fy,&fz);
matrix_vertex_multiply(&mat_z,&fx,&fy,&fz);
matrix_vertex_multiply(&mat_y,&fx,&fy,&fz);
*vp++=mx+fx;
*vp++=my+fy;
*vp++=mz+fz;
*uv++=gx+(g_size*((fx+outer_sz)/(outer_sz*2.0f)));
*uv++=gy+(g_size*((fy+outer_sz)/(outer_sz*2.0f)));
}
rtlSceneMeshUnMapVertexPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id);
rtlSceneMeshUnMapUVPointer(view_rtl_draw_scene_id,effect->rtl_mesh_id);
// create the polys
// last one needs to wrap around to beginning
material_id=ring->rtl_material_id;
polys=(short*)malloc(sizeof(short)*(36*10));
vk=polys;
idx=0;
for (n=0;n!=36;n++) {
*vk++=4;
*vk++=material_id;
*vk++=idx;
*vk++=idx;
*vk++=idx+1;
*vk++=idx+1;
if (n!=35) {
k=idx+2;
}
else {
k=0;
}
*vk++=k+1;
*vk++=k+1;
*vk++=k;
*vk++=k;
idx+=2;
}
rtlSceneMeshSetPoly(view_rtl_draw_scene_id,effect->rtl_mesh_id,RL_MESH_FORMAT_POLY_SHORT_VERTEX_UV,36,polys);
free(polys);
// set color and alpha
color_dif=ring->end_color.r-ring->start_color.r;
col.r=ring->start_color.r+((color_dif*f_count)/f_tick);
color_dif=ring->end_color.g-ring->start_color.g;
col.g=ring->start_color.g+((color_dif*f_count)/f_tick);
color_dif=ring->end_color.b-ring->start_color.b;
col.b=ring->start_color.b+((color_dif*f_count)/f_tick);
alpha=ring->end_alpha-ring->start_alpha;
col.a=((alpha*f_count)/f_tick)+ring->start_alpha;
rtlSceneMeshSetPolyColorAll(view_rtl_draw_scene_id,effect->rtl_mesh_id,&col);
}
