int rotate_object(short objnum, int p, int b, int h)
{
object *obj = &Objects[objnum];
vms_angvec ang;
vms_matrix rotmat,tempm;
// vm_extract_angles_matrix( &ang,&obj->orient);
// ang.p += p;
// ang.b += b;
// ang.h += h;
ang.p = p;
ang.b = b;
ang.h = h;
vm_angles_2_matrix(&rotmat, &ang);
vm_matrix_x_matrix(&tempm, &obj->orient, &rotmat);
obj->orient = tempm;
// vm_angles_2_matrix(&obj->orient, &ang);
Update_flags |= UF_WORLD_CHANGED;
return 1;
}
//draws the given model in the current canvas. The distance is set to
//more-or-less fill the canvas. Note that this routine actually renders
//into an off-screen canvas that it creates, then copies to the current
//canvas.
void draw_model_picture(int mn,vms_angvec *orient_angles)
{
vms_vector temp_pos=ZERO_VECTOR;
vms_matrix temp_orient = IDENTITY_MATRIX;
grs_canvas *save_canv = grd_curcanv,*temp_canv;
Assert(mn>=0 && mn<N_polygon_models);
temp_canv = gr_create_canvas(save_canv->cv_bitmap.bm_w,save_canv->cv_bitmap.bm_h);
gr_set_current_canvas(temp_canv);
gr_clear_canvas( BM_XRGB(0,0,0) );
g3_start_frame();
g3_set_view_matrix(&temp_pos,&temp_orient,0x9000);
if (Polygon_models[mn].rad != 0)
temp_pos.z = fixmuldiv(DEFAULT_VIEW_DIST,Polygon_models[mn].rad,BASE_MODEL_SIZE);
else
temp_pos.z = DEFAULT_VIEW_DIST;
vm_angles_2_matrix(&temp_orient, orient_angles);
PA_DFX(save_light = Lighting_on);
PA_DFX(Lighting_on = 0);
draw_polygon_model(&temp_pos,&temp_orient,NULL,mn,0,f1_0,NULL,NULL);
PA_DFX (Lighting_on = save_light);
gr_set_current_canvas(save_canv);
gr_bitmap(0,0,&temp_canv->cv_bitmap);
gr_free_canvas(temp_canv);
}
/**
* Set view from x,y,z & p,b,h, zoom. Must call one of g3_set_view_*()
*/
void g3_set_view_angles(const vec3d *view_pos, const angles *view_orient, float zoom)
{
matrix tmp;
Assert( G3_count == 1 );
vm_angles_2_matrix(&tmp,view_orient);
g3_set_view_matrix(view_pos,&tmp,zoom);
}
//set view from x,y,z & p,b,h, zoom. Must call one of g3_set_view_*()
void g3_set_view_angles(const vms_vector *view_pos,const vms_angvec *view_orient,fix zoom)
{
View_zoom = zoom;
View_position = *view_pos;
vm_angles_2_matrix(&View_matrix,view_orient);
scale_matrix();
}
void gr_start_angles_instance_matrix(const vec3d *pos, const angles *rotation)
{
Assert(htl_view_matrix_set);
matrix m;
vm_angles_2_matrix(&m, rotation);
gr_start_instance_matrix(pos, &m);
}
void gr_opengl_start_instance_angles(const vec3d *pos, const angles *rotation)
{
Assert(GL_htl_projection_matrix_set);
Assert(GL_htl_view_matrix_set);
matrix m;
vm_angles_2_matrix(&m, rotation);
gr_opengl_start_instance_matrix(pos, &m);
}
void do_object_flythrough(object * obj ) //set true if init
{
if ( obj->fly_info.ft_mode == FP_FIRST_TIME ) {
obj->fly_info.ft_mode = FP_FORWARD;
objfly_move_to_new_segment( obj, obj->segnum, 1 );
} else {
//move the object for this frame
angvec_add2_scale(&obj->phys_info.rotvel,&obj->fly_info.angle_step,FrameTime);
vm_angles_2_matrix(&obj->orient,&obj->phys_info.rotvel);
}
}
int medlisp_rotate_segment(void)
{
vms_matrix rotmat;
Seg_orientation.p = func_get_param(0);
Seg_orientation.b = func_get_param(1);
Seg_orientation.h = func_get_param(2);
med_rotate_segment(Cursegp,vm_angles_2_matrix(&rotmat,&Seg_orientation));
Update_flags |= UF_WORLD_CHANGED | UF_VIEWPOINT_MOVED;
mine_changed = 1;
return 1;
}
//instance at specified point with specified orientation
//if angles==NULL, don't modify matrix. This will be like doing an offset
void g3_start_instance_angles(vms_vector *pos, vms_angvec *angles) {
vms_matrix tm;
if (angles == NULL) {
g3_start_instance_matrix(pos, NULL);
return;
}
vm_angles_2_matrix(&tm, angles);
g3_start_instance_matrix(pos, &tm);
}
void physics_sim_rot_editor(matrix * orient, physics_info * pi, float sim_time)
{
angles tangles;
vec3d new_vel;
matrix tmp;
angles t1, t2;
apply_physics( pi->rotdamp, pi->desired_rotvel.xyz.x, pi->rotvel.xyz.x, sim_time,
&new_vel.xyz.x, NULL );
apply_physics( pi->rotdamp, pi->desired_rotvel.xyz.y, pi->rotvel.xyz.y, sim_time,
&new_vel.xyz.y, NULL );
apply_physics( pi->rotdamp, pi->desired_rotvel.xyz.z, pi->rotvel.xyz.z, sim_time,
&new_vel.xyz.z, NULL );
pi->rotvel = new_vel;
tangles.p = pi->rotvel.xyz.x*sim_time;
tangles.h = pi->rotvel.xyz.y*sim_time;
tangles.b = pi->rotvel.xyz.z*sim_time;
t1 = t2 = tangles;
t1.h = 0.0f; t1.b = 0.0f;
t2.p = 0.0f; t2.b = 0.0f;
// put in p & b like normal
vm_angles_2_matrix(&pi->last_rotmat, &t1 );
vm_matrix_x_matrix( &tmp, orient, &pi->last_rotmat );
// Put in heading separately
vm_angles_2_matrix(&pi->last_rotmat, &t2 );
vm_matrix_x_matrix( orient, &pi->last_rotmat, &tmp );
vm_orthogonalize_matrix(orient);
}
int medlisp_scale_segment(void)
{
vms_matrix rotmat;
vms_vector scale;
scale.x = fl2f((float) func_get_param(0));
scale.y = fl2f((float) func_get_param(1));
scale.z = fl2f((float) func_get_param(2));
med_create_new_segment(&scale);
med_rotate_segment(Cursegp,vm_angles_2_matrix(&rotmat,&Seg_orientation));
Update_flags |= UF_WORLD_CHANGED;
mine_changed = 1;
return 1;
}
//given an object and a gun number, return position in 3-space of gun
//fills in gun_point
void calc_gun_point(vms_vector *gun_point,object *obj,int gun_num)
{
polymodel *pm;
robot_info *r;
vms_vector pnt;
vms_matrix m;
int mn; //submodel number
Assert(obj->render_type==RT_POLYOBJ || obj->render_type==RT_MORPH);
Assert(obj->id < N_robot_types);
r = &Robot_info[obj->id];
pm =&Polygon_models[r->model_num];
if (gun_num >= r->n_guns)
{
mprintf((1, "Bashing gun num %d to 0.\n", gun_num));
//Int3();
gun_num = 0;
}
// Assert(gun_num < r->n_guns);
pnt = r->gun_points[gun_num];
mn = r->gun_submodels[gun_num];
//instance up the tree for this gun
while (mn != 0) {
vms_vector tpnt;
vm_angles_2_matrix(&m,&obj->rtype.pobj_info.anim_angles[mn]);
vm_transpose_matrix(&m);
vm_vec_rotate(&tpnt,&pnt,&m);
vm_vec_add(&pnt,&tpnt,&pm->submodel_offsets[mn]);
mn = pm->submodel_parents[mn];
}
//now instance for the entire object
vm_copy_transpose_matrix(&m,&obj->orient);
vm_vec_rotate(gun_point,&pnt,&m);
vm_vec_add2(gun_point,&obj->pos);
}
//instance at specified point with specified orientation
//if angles==NULL, don't modify matrix. This will be like doing an offset
void g3_start_instance_angles(vector *pos,angles *orient)
{
matrix tm;
Assert( G3_count == 1 );
if (orient==NULL) {
g3_start_instance_matrix(pos,NULL);
return;
}
vm_angles_2_matrix(&tm,orient);
g3_start_instance_matrix(pos,&tm, false);
if(!Cmdline_nohtl)gr_start_angles_instance_matrix(pos, orient);
}
//draws the given model in the current canvas. The distance is set to
//more-or-less fill the canvas. Note that this routine actually renders
//into an off-screen canvas that it creates, then copies to the current
//canvas.
void draw_model_picture(int mn,vms_angvec *orient_angles)
{
vms_vector temp_pos=ZERO_VECTOR;
vms_matrix temp_orient = IDENTITY_MATRIX;
Assert(mn>=0 && mn<N_polygon_models);
gr_clear_canvas( BM_XRGB(0,0,0) );
g3_start_frame();
g3_set_view_matrix(&temp_pos,&temp_orient,0x9000);
if (Polygon_models[mn].rad != 0)
temp_pos.z = fixmuldiv(DEFAULT_VIEW_DIST,Polygon_models[mn].rad,BASE_MODEL_SIZE);
else
temp_pos.z = DEFAULT_VIEW_DIST;
vm_angles_2_matrix(&temp_orient, orient_angles);
draw_polygon_model(&temp_pos,&temp_orient,NULL,mn,0,f1_0,NULL,NULL);
g3_end_frame();
}
endlevel_render_mine(fix eye_offset)
{
int start_seg_num;
Viewer_eye = Viewer->pos;
if (Viewer->type == OBJ_PLAYER )
vm_vec_scale_add2(&Viewer_eye,&Viewer->orient.fvec,(Viewer->size*3)/4);
if (eye_offset)
vm_vec_scale_add2(&Viewer_eye,&Viewer->orient.rvec,eye_offset);
#ifdef EDITOR
if (Function_mode==FMODE_EDITOR)
Viewer_eye = Viewer->pos;
#endif
if (Endlevel_sequence >= EL_OUTSIDE) {
start_seg_num = exit_segnum;
}
else {
start_seg_num = find_point_seg(&Viewer_eye,Viewer->segnum);
if (start_seg_num==-1)
start_seg_num = Viewer->segnum;
}
if (Endlevel_sequence == EL_LOOKBACK) {
vms_matrix headm,viewm;
vms_angvec angles = {0,0,0x7fff};
vm_angles_2_matrix(&headm,&angles);
vm_matrix_x_matrix(&viewm,&Viewer->orient,&headm);
g3_set_view_matrix(&Viewer_eye,&viewm,Render_zoom);
}
else
g3_set_view_matrix(&Viewer_eye,&Viewer->orient,Render_zoom);
render_mine(start_seg_num,eye_offset);
}
static int rotate_object(const vobjptridx_t obj, int p, int b, int h)
{
vms_angvec ang;
// vm_extract_angles_matrix( &ang,&obj->orient);
// ang.p += p;
// ang.b += b;
// ang.h += h;
ang.p = p;
ang.b = b;
ang.h = h;
const auto rotmat = vm_angles_2_matrix(ang);
obj->orient = vm_matrix_x_matrix(obj->orient, rotmat);
// vm_angles_2_matrix(&obj->orient, &ang);
Update_flags |= UF_WORLD_CHANGED;
return 1;
}
void record_demo_frame(void)
{
vms_angvec pbh;
//mprintf(0, "Record start...");
mprintf(0, "Curtime = %6i, Last time = %6i\n", Player_stats.time_total, Demo_last_time);
if (GameTime - Demo_last_time >= 65536) {
Demo_last_time = GameTime;
if (Demo_record_index < MAX_DEMO_RECS) {
demorec *demo_ptr = &Demo_records[Demo_record_index];
vms_matrix tempmat;
demo_ptr->time = GameTime - Demo_start_time;
demo_ptr->x = Player->pos.x;
demo_ptr->y = Player->pos.y;
demo_ptr->z = Player->pos.z;
vm_extract_angles_matrix(&pbh, &Player->orient);
vm_angles_2_matrix(&tempmat, &pbh);
matrix_compare(&tempmat, &Player->orient);
demo_ptr->p = pbh.p;
demo_ptr->b = pbh.b;
demo_ptr->h = pbh.h;
demo_ptr->segnum = Player->segnum;
Demo_record_index++;
Num_demo_recs = Demo_record_index;
// if (firing)
// demo_ptr->specials = 1;
// else
// demo_ptr->specials = 0;
}
}
//mprintf(0, "Record end\n");
}
void model_collide_preprocess_subobj(vec3d *pos, matrix *orient, polymodel *pm, polymodel_instance *pmi, int subobj_num)
{
submodel_instance *smi = &pmi->submodel[subobj_num];
smi->mc_base = *pos;
smi->mc_orient = *orient;
int i = pm->submodel[subobj_num].first_child;
while ( i >= 0 ) {
angles angs = pmi->submodel[i].angs;
bsp_info * csm = &pm->submodel[i];
matrix tm = IDENTITY_MATRIX;
vm_vec_unrotate(pos, &csm->offset, &smi->mc_orient );
vm_vec_add2(pos, &smi->mc_base);
if( vm_matrix_same(&tm, &csm->orientation)) {
// if submodel orientation matrix is identity matrix then don't bother with matrix ops
vm_angles_2_matrix(&tm, &angs);
} else {
matrix rotation_matrix = csm->orientation;
vm_rotate_matrix_by_angles(&rotation_matrix, &angs);
matrix inv_orientation;
vm_copy_transpose(&inv_orientation, &csm->orientation);
vm_matrix_x_matrix(&tm, &rotation_matrix, &inv_orientation);
}
vm_matrix_x_matrix(orient, &smi->mc_orient, &tm);
model_collide_preprocess_subobj(pos, orient, pm, pmi, i);
i = csm->next_sibling;
}
}
do_endlevel_flythrough(int n)
{
object *obj;
segment *pseg;
int old_player_seg;
flydata = &fly_objects[n];
obj = flydata->obj;
old_player_seg = obj->segnum;
//move the player for this frame
if (!flydata->first_time) {
vm_vec_scale_add2(&obj->pos,&flydata->step,FrameTime);
angvec_add2_scale(&flydata->angles,&flydata->angstep,FrameTime);
vm_angles_2_matrix(&obj->orient,&flydata->angles);
}
//check new player seg
update_object_seg(obj);
pseg = &Segments[obj->segnum];
if (flydata->first_time || obj->segnum != old_player_seg) { //moved into new seg
vms_vector curcenter,nextcenter;
fix step_size,seg_time;
short entry_side,exit_side; //what sides we entry and leave through
vms_vector dest_point; //where we are heading (center of exit_side)
vms_angvec dest_angles; //where we want to be pointing
vms_matrix dest_orient;
int up_side;
//find new exit side
if (!flydata->first_time) {
entry_side = matt_find_connect_side(obj->segnum,old_player_seg);
exit_side = Side_opposite[entry_side];
}
if (flydata->first_time || entry_side==-1 || pseg->children[exit_side]==-1)
exit_side = find_exit_side(obj);
{ //find closest side to align to
fix d,largest_d=-f1_0;
int i;
for (i=0;i<6;i++) {
#ifdef COMPACT_SEGS
vms_vector v1;
get_side_normal(pseg, i, 0, &v1 );
d = vm_vec_dot(&v1,&flydata->obj->orient.uvec);
#else
d = vm_vec_dot(&pseg->sides[i].normals[0],&flydata->obj->orient.uvec);
#endif
if (d > largest_d) {largest_d = d; up_side=i;}
}
}
//update target point & angles
compute_center_point_on_side(&dest_point,pseg,exit_side);
//update target point and movement points
//offset object sideways
if (flydata->offset_frac) {
int s0=-1,s1,i;
vms_vector s0p,s1p;
fix dist;
for (i=0;i<6;i++)
if (i!=entry_side && i!=exit_side && i!=up_side && i!=Side_opposite[up_side])
if (s0==-1)
s0 = i;
else
s1 = i;
compute_center_point_on_side(&s0p,pseg,s0);
compute_center_point_on_side(&s1p,pseg,s1);
dist = fixmul(vm_vec_dist(&s0p,&s1p),flydata->offset_frac);
if (dist-flydata->offset_dist > MAX_SLIDE_PER_SEGMENT)
dist = flydata->offset_dist + MAX_SLIDE_PER_SEGMENT;
flydata->offset_dist = dist;
vm_vec_scale_add2(&dest_point,&obj->orient.rvec,dist);
}
vm_vec_sub(&flydata->step,&dest_point,&obj->pos);
step_size = vm_vec_normalize_quick(&flydata->step);
vm_vec_scale(&flydata->step,flydata->speed);
compute_segment_center(&curcenter,pseg);
compute_segment_center(&nextcenter,&Segments[pseg->children[exit_side]]);
vm_vec_sub(&flydata->headvec,&nextcenter,&curcenter);
#ifdef COMPACT_SEGS
{
vms_vector _v1;
get_side_normal(pseg, up_side, 0, &_v1 );
vm_vector_2_matrix(&dest_orient,&flydata->headvec,&_v1,NULL);
}
#else
vm_vector_2_matrix(&dest_orient,&flydata->headvec,&pseg->sides[up_side].normals[0],NULL);
#endif
vm_extract_angles_matrix(&dest_angles,&dest_orient);
if (flydata->first_time)
vm_extract_angles_matrix(&flydata->angles,&obj->orient);
seg_time = fixdiv(step_size,flydata->speed); //how long through seg
if (seg_time) {
flydata->angstep.x = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.p,dest_angles.p),seg_time)));
flydata->angstep.z = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.b,dest_angles.b),seg_time)));
flydata->angstep.y = max(-MAX_ANGSTEP,min(MAX_ANGSTEP,fixdiv(delta_ang(flydata->angles.h,dest_angles.h),seg_time)));
}
else {
flydata->angles = dest_angles;
flydata->angstep.x = flydata->angstep.y = flydata->angstep.z = 0;
}
}
flydata->first_time=0;
}
void techroom_ships_render(float frametime)
{
// render all the common stuff
tech_common_render();
if(Cur_entry_index == -1)
return;
// now render the trackball ship, which is unique to the ships tab
float rev_rate = REVOLUTION_RATE;
angles rot_angles, view_angles;
int z, i, j;
ship_info *sip = &Ship_info[Cur_entry_index];
model_render_params render_info;
if (sip->uses_team_colors) {
render_info.set_team_color(sip->default_team_name, "none", 0, 0);
}
// get correct revolution rate
z = sip->flags;
if (z & SIF_BIG_SHIP) {
rev_rate *= 1.7f;
}
if (z & SIF_HUGE_SHIP) {
rev_rate *= 3.0f;
}
// rotate the ship as much as required for this frame
Techroom_ship_rot += PI2 * frametime / rev_rate;
while (Techroom_ship_rot > PI2){
Techroom_ship_rot -= PI2;
}
// reorient ship
if (Trackball_active) {
int dx, dy;
matrix mat1, mat2;
if (Trackball_active) {
mouse_get_delta(&dx, &dy);
if (dx || dy) {
vm_trackball(-dx, -dy, &mat1);
vm_matrix_x_matrix(&mat2, &mat1, &Techroom_ship_orient);
Techroom_ship_orient = mat2;
}
}
} else {
// setup stuff needed to render the ship
view_angles.p = -0.6f;
view_angles.b = 0.0f;
view_angles.h = 0.0f;
vm_angles_2_matrix(&Techroom_ship_orient, &view_angles);
rot_angles.p = 0.0f;
rot_angles.b = 0.0f;
rot_angles.h = Techroom_ship_rot;
vm_rotate_matrix_by_angles(&Techroom_ship_orient, &rot_angles);
}
gr_set_clip(Tech_ship_display_coords[gr_screen.res][SHIP_X_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_Y_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_W_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_H_COORD], GR_RESIZE_MENU);
// render the ship
g3_start_frame(1);
g3_set_view_matrix(&sip->closeup_pos, &vmd_identity_matrix, sip->closeup_zoom * 1.3f);
// lighting for techroom
light_reset();
vec3d light_dir = vmd_zero_vector;
light_dir.xyz.y = 1.0f;
light_dir.xyz.x = 0.0000001f;
light_add_directional(&light_dir, 0.85f, 1.0f, 1.0f, 1.0f);
light_rotate_all();
// lighting for techroom
Glowpoint_use_depth_buffer = false;
model_clear_instance(Techroom_ship_modelnum);
render_info.set_detail_level_lock(0);
polymodel *pm = model_get(Techroom_ship_modelnum);
for (i = 0; i < sip->n_subsystems; i++) {
model_subsystem *msp = &sip->subsystems[i];
if (msp->type == SUBSYSTEM_TURRET) {
float p = 0.0f;
float h = 0.0f;
for (j = 0; j < msp->n_triggers; j++) {
// special case for turrets
p = msp->triggers[j].angle.xyz.x;
h = msp->triggers[j].angle.xyz.y;
}
if ( msp->subobj_num >= 0 ) {
model_set_instance_techroom(Techroom_ship_modelnum, msp->subobj_num, 0.0f, h );
}
if ( (msp->subobj_num != msp->turret_gun_sobj) && (msp->turret_gun_sobj >= 0) ) {
model_set_instance_techroom(Techroom_ship_modelnum, msp->turret_gun_sobj, p, 0.0f );
}
}
}
if(Cmdline_shadow_quality)
{
gr_reset_clip();
shadows_start_render(&Eye_matrix, &Eye_position, Proj_fov, gr_screen.clip_aspect, -sip->closeup_pos.xyz.z + pm->rad, -sip->closeup_pos.xyz.z + pm->rad + 200.0f, -sip->closeup_pos.xyz.z + pm->rad + 2000.0f, -sip->closeup_pos.xyz.z + pm->rad + 10000.0f);
render_info.set_flags(MR_NO_TEXTURING | MR_NO_LIGHTING | MR_AUTOCENTER);
model_render_immediate(&render_info, Techroom_ship_modelnum, &Techroom_ship_orient, &vmd_zero_vector);
shadows_end_render();
gr_set_clip(Tech_ship_display_coords[gr_screen.res][SHIP_X_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_Y_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_W_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_H_COORD], GR_RESIZE_MENU);
}
if (!Cmdline_nohtl) {
gr_set_proj_matrix(Proj_fov, gr_screen.clip_aspect, Min_draw_distance, Max_draw_distance);
gr_set_view_matrix(&Eye_position, &Eye_matrix);
}
uint render_flags = MR_AUTOCENTER;
if(sip->flags2 & SIF2_NO_LIGHTING)
render_flags |= MR_NO_LIGHTING;
render_info.set_flags(render_flags);
model_render_immediate(&render_info, Techroom_ship_modelnum, &Techroom_ship_orient, &vmd_zero_vector);
Glowpoint_use_depth_buffer = true;
batch_render_all();
if (!Cmdline_nohtl)
{
gr_end_view_matrix();
gr_end_proj_matrix();
}
g3_end_frame();
gr_reset_clip();
}
int automap_process_input(window *wind, d_event *event, automap *am)
{
vms_matrix tempm;
Controls = am->controls;
kconfig_read_controls(event, 1);
am->controls = Controls;
memset(&Controls, 0, sizeof(control_info));
if ( !am->controls.automap_state && (am->leave_mode==1) )
{
window_close(wind);
return 1;
}
if ( am->controls.automap_count > 0)
{
am->controls.automap_count = 0;
if (am->leave_mode==0)
{
window_close(wind);
return 1;
}
}
if (PlayerCfg.AutomapFreeFlight)
{
if ( am->controls.fire_primary_count > 0)
{
// Reset orientation
am->viewMatrix = Objects[Players[Player_num].objnum].orient;
vm_vec_scale_add(&am->view_position, &Objects[Players[Player_num].objnum].pos, &am->viewMatrix.fvec, -ZOOM_DEFAULT );
am->controls.fire_primary_count = 0;
}
if (am->controls.pitch_time || am->controls.heading_time || am->controls.bank_time)
{
vms_angvec tangles;
vms_matrix new_m;
tangles.p = fixdiv( am->controls.pitch_time, ROT_SPEED_DIVISOR );
tangles.h = fixdiv( am->controls.heading_time, ROT_SPEED_DIVISOR );
tangles.b = fixdiv( am->controls.bank_time, ROT_SPEED_DIVISOR*2 );
vm_angles_2_matrix(&tempm, &tangles);
vm_matrix_x_matrix(&new_m,&am->viewMatrix,&tempm);
am->viewMatrix = new_m;
check_and_fix_matrix(&am->viewMatrix);
}
if ( am->controls.forward_thrust_time || am->controls.vertical_thrust_time || am->controls.sideways_thrust_time )
{
vm_vec_scale_add2( &am->view_position, &am->viewMatrix.fvec, am->controls.forward_thrust_time*ZOOM_SPEED_FACTOR );
vm_vec_scale_add2( &am->view_position, &am->viewMatrix.uvec, am->controls.vertical_thrust_time*SLIDE_SPEED );
vm_vec_scale_add2( &am->view_position, &am->viewMatrix.rvec, am->controls.sideways_thrust_time*SLIDE_SPEED );
// Crude wrapping check
if (am->view_position.x > F1_0*32000) am->view_position.x = F1_0*32000;
if (am->view_position.x < -F1_0*32000) am->view_position.x = -F1_0*32000;
if (am->view_position.y > F1_0*32000) am->view_position.y = F1_0*32000;
if (am->view_position.y < -F1_0*32000) am->view_position.y = -F1_0*32000;
if (am->view_position.z > F1_0*32000) am->view_position.z = F1_0*32000;
if (am->view_position.z < -F1_0*32000) am->view_position.z = -F1_0*32000;
}
}
else
{
if ( am->controls.fire_primary_count > 0)
{
// Reset orientation
am->viewDist = ZOOM_DEFAULT;
am->tangles.p = PITCH_DEFAULT;
am->tangles.h = 0;
am->tangles.b = 0;
am->view_target = Objects[Players[Player_num].objnum].pos;
am->controls.fire_primary_count = 0;
}
am->viewDist -= am->controls.forward_thrust_time*ZOOM_SPEED_FACTOR;
am->tangles.p += fixdiv( am->controls.pitch_time, ROT_SPEED_DIVISOR );
am->tangles.h += fixdiv( am->controls.heading_time, ROT_SPEED_DIVISOR );
am->tangles.b += fixdiv( am->controls.bank_time, ROT_SPEED_DIVISOR*2 );
if ( am->controls.vertical_thrust_time || am->controls.sideways_thrust_time )
{
vms_angvec tangles1;
vms_vector old_vt;
old_vt = am->view_target;
tangles1 = am->tangles;
vm_angles_2_matrix(&tempm,&tangles1);
vm_matrix_x_matrix(&am->viewMatrix,&Objects[Players[Player_num].objnum].orient,&tempm);
vm_vec_scale_add2( &am->view_target, &am->viewMatrix.uvec, am->controls.vertical_thrust_time*SLIDE_SPEED );
vm_vec_scale_add2( &am->view_target, &am->viewMatrix.rvec, am->controls.sideways_thrust_time*SLIDE_SPEED );
if ( vm_vec_dist_quick( &am->view_target, &Objects[Players[Player_num].objnum].pos) > i2f(1000) )
am->view_target = old_vt;
}
vm_angles_2_matrix(&tempm,&am->tangles);
vm_matrix_x_matrix(&am->viewMatrix,&Objects[Players[Player_num].objnum].orient,&tempm);
if ( am->viewDist < ZOOM_MIN_VALUE ) am->viewDist = ZOOM_MIN_VALUE;
if ( am->viewDist > ZOOM_MAX_VALUE ) am->viewDist = ZOOM_MAX_VALUE;
}
return 0;
}
do_endlevel_frame()
{
static fix timer;
vms_vector save_last_pos;
static fix explosion_wait1=0;
static fix explosion_wait2=0;
static fix bank_rate;
static fix ext_expl_halflife;
save_last_pos = ConsoleObject->last_pos; //don't let move code change this
object_move_all();
ConsoleObject->last_pos = save_last_pos;
if (ext_expl_playing) {
external_explosion.lifeleft -= FrameTime;
do_explosion_sequence(&external_explosion);
if (external_explosion.lifeleft < ext_expl_halflife)
mine_destroyed = 1;
if (external_explosion.flags & OF_SHOULD_BE_DEAD)
ext_expl_playing = 0;
}
if (cur_fly_speed != desired_fly_speed) {
fix delta = desired_fly_speed - cur_fly_speed;
fix frame_accel = fixmul(FrameTime,FLY_ACCEL);
if (abs(delta) < frame_accel)
cur_fly_speed = desired_fly_speed;
else
if (delta > 0)
cur_fly_speed += frame_accel;
else
cur_fly_speed -= frame_accel;
}
//do big explosions
if (!outside_mine) {
if (Endlevel_sequence==EL_OUTSIDE) {
vms_vector tvec;
vm_vec_sub(&tvec,&ConsoleObject->pos,&mine_side_exit_point);
if (vm_vec_dot(&tvec,&mine_exit_orient.fvec) > 0) {
object *tobj;
outside_mine = 1;
tobj = object_create_explosion(exit_segnum,&mine_side_exit_point,i2f(50),VCLIP_BIG_PLAYER_EXPLOSION);
if (tobj) {
external_explosion = *tobj;
tobj->flags |= OF_SHOULD_BE_DEAD;
flash_scale = 0; //kill lights in mine
ext_expl_halflife = tobj->lifeleft;
ext_expl_playing = 1;
}
digi_link_sound_to_pos( SOUND_BIG_ENDLEVEL_EXPLOSION, exit_segnum, 0, &mine_side_exit_point, 0, i2f(3)/4 );
}
}
//do explosions chasing player
if ((explosion_wait1-=FrameTime) < 0) {
vms_vector tpnt;
int segnum;
object *expl;
static int sound_count;
vm_vec_scale_add(&tpnt,&ConsoleObject->pos,&ConsoleObject->orient.fvec,-ConsoleObject->size*5);
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.rvec,(rand()-RAND_MAX/2)*15);
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.uvec,(rand()-RAND_MAX/2)*15);
segnum = find_point_seg(&tpnt,ConsoleObject->segnum);
if (segnum != -1) {
expl = object_create_explosion(segnum,&tpnt,i2f(20),VCLIP_BIG_PLAYER_EXPLOSION);
if (rand()<10000 || ++sound_count==7) { //pseudo-random
digi_link_sound_to_pos( SOUND_TUNNEL_EXPLOSION, segnum, 0, &tpnt, 0, F1_0 );
sound_count=0;
}
}
explosion_wait1 = 0x2000 + rand()/4;
}
}
//do little explosions on walls
if (Endlevel_sequence >= EL_FLYTHROUGH && Endlevel_sequence < EL_OUTSIDE)
if ((explosion_wait2-=FrameTime) < 0) {
vms_vector tpnt;
fvi_query fq;
fvi_info hit_data;
//create little explosion on wall
vm_vec_copy_scale(&tpnt,&ConsoleObject->orient.rvec,(rand()-RAND_MAX/2)*100);
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.uvec,(rand()-RAND_MAX/2)*100);
vm_vec_add2(&tpnt,&ConsoleObject->pos);
if (Endlevel_sequence == EL_FLYTHROUGH)
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.fvec,rand()*200);
else
vm_vec_scale_add2(&tpnt,&ConsoleObject->orient.fvec,rand()*60);
//find hit point on wall
fq.p0 = &ConsoleObject->pos;
fq.p1 = &tpnt;
fq.startseg = ConsoleObject->segnum;
fq.rad = 0;
fq.thisobjnum = 0;
fq.ignore_obj_list = NULL;
fq.flags = 0;
find_vector_intersection(&fq,&hit_data);
if (hit_data.hit_type==HIT_WALL && hit_data.hit_seg!=-1)
object_create_explosion(hit_data.hit_seg,&hit_data.hit_pnt,i2f(3)+rand()*6,VCLIP_SMALL_EXPLOSION);
explosion_wait2 = (0xa00 + rand()/8)/2;
}
switch (Endlevel_sequence) {
case EL_OFF: return;
case EL_FLYTHROUGH: {
do_endlevel_flythrough(0);
if (ConsoleObject->segnum == transition_segnum) {
int objnum;
Endlevel_sequence = EL_LOOKBACK;
objnum = obj_create(OBJ_CAMERA, 0,
ConsoleObject->segnum,&ConsoleObject->pos,&ConsoleObject->orient,0,
CT_NONE,MT_NONE,RT_NONE);
if (objnum == -1) { //can't get object, so abort
mprintf((1, "Can't get object for endlevel sequence. Aborting endlevel sequence.\n"));
stop_endlevel_sequence();
return;
}
Viewer = endlevel_camera = &Objects[objnum];
select_cockpit(CM_LETTERBOX);
fly_objects[1] = fly_objects[0];
fly_objects[1].obj = endlevel_camera;
fly_objects[1].speed = (5*cur_fly_speed)/4;
fly_objects[1].offset_frac = 0x4000;
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.fvec,i2f(7));
timer=0x20000;
}
break;
}
case EL_LOOKBACK: {
do_endlevel_flythrough(0);
do_endlevel_flythrough(1);
if (timer>0) {
timer -= FrameTime;
if (timer < 0) //reduce speed
fly_objects[1].speed = fly_objects[0].speed;
}
if (endlevel_camera->segnum == exit_segnum) {
vms_angvec cam_angles,exit_seg_angles;
Endlevel_sequence = EL_OUTSIDE;
timer = i2f(2);
vm_vec_negate(&endlevel_camera->orient.fvec);
vm_vec_negate(&endlevel_camera->orient.rvec);
vm_extract_angles_matrix(&cam_angles,&endlevel_camera->orient);
vm_extract_angles_matrix(&exit_seg_angles,&mine_exit_orient);
bank_rate = (-exit_seg_angles.b - cam_angles.b)/2;
ConsoleObject->control_type = endlevel_camera->control_type = CT_NONE;
//_MARK_("Starting outside");//Commented out by KRB
#ifdef SLEW_ON
slew_obj = endlevel_camera;
#endif
}
break;
}
case EL_OUTSIDE: {
#ifndef SLEW_ON
vms_angvec cam_angles;
#endif
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
#ifndef SLEW_ON
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.fvec,fixmul(FrameTime,-2*cur_fly_speed));
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.uvec,fixmul(FrameTime,-cur_fly_speed/10));
vm_extract_angles_matrix(&cam_angles,&endlevel_camera->orient);
cam_angles.b += fixmul(bank_rate,FrameTime);
vm_angles_2_matrix(&endlevel_camera->orient,&cam_angles);
#endif
timer -= FrameTime;
if (timer < 0) {
Endlevel_sequence = EL_STOPPED;
vm_extract_angles_matrix(&player_angles,&ConsoleObject->orient);
timer = i2f(3);
}
break;
}
case EL_STOPPED: {
get_angs_to_object(&player_dest_angles,&station_pos,&ConsoleObject->pos);
chase_angles(&player_angles,&player_dest_angles);
vm_angles_2_matrix(&ConsoleObject->orient,&player_angles);
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
timer -= FrameTime;
if (timer < 0) {
#ifdef SLEW_ON
slew_obj = endlevel_camera;
_do_slew_movement(endlevel_camera,1,1);
timer += FrameTime; //make time stop
break;
#else
#ifdef SHORT_SEQUENCE
stop_endlevel_sequence();
#else
Endlevel_sequence = EL_PANNING;
vm_extract_angles_matrix(&camera_cur_angles,&endlevel_camera->orient);
timer = i2f(3);
if (Game_mode & GM_MULTI) { // try to skip part of the seq if multiplayer
stop_endlevel_sequence();
return;
}
//mprintf((0,"Switching to pan...\n"));
#endif //SHORT_SEQUENCE
#endif //SLEW_ON
}
break;
}
#ifndef SHORT_SEQUENCE
case EL_PANNING: {
#ifndef SLEW_ON
int mask;
#endif
get_angs_to_object(&player_dest_angles,&station_pos,&ConsoleObject->pos);
chase_angles(&player_angles,&player_dest_angles);
vm_angles_2_matrix(&ConsoleObject->orient,&player_angles);
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
#ifdef SLEW_ON
_do_slew_movement(endlevel_camera,1,1);
#else
get_angs_to_object(&camera_desired_angles,&ConsoleObject->pos,&endlevel_camera->pos);
mask = chase_angles(&camera_cur_angles,&camera_desired_angles);
vm_angles_2_matrix(&endlevel_camera->orient,&camera_cur_angles);
if ((mask&5) == 5) {
vms_vector tvec;
Endlevel_sequence = EL_CHASING;
//_MARK_("Done outside");//Commented out -KRB
vm_vec_normalized_dir_quick(&tvec,&station_pos,&ConsoleObject->pos);
vm_vector_2_matrix(&ConsoleObject->orient,&tvec,&surface_orient.uvec,NULL);
desired_fly_speed *= 2;
//mprintf((0,"Switching to chase...\n"));
}
#endif
break;
}
case EL_CHASING: {
fix d,speed_scale;
#ifdef SLEW_ON
_do_slew_movement(endlevel_camera,1,1);
#endif
get_angs_to_object(&camera_desired_angles,&ConsoleObject->pos,&endlevel_camera->pos);
chase_angles(&camera_cur_angles,&camera_desired_angles);
#ifndef SLEW_ON
vm_angles_2_matrix(&endlevel_camera->orient,&camera_cur_angles);
#endif
d = vm_vec_dist_quick(&ConsoleObject->pos,&endlevel_camera->pos);
speed_scale = fixdiv(d,i2f(0x20));
if (d<f1_0) d=f1_0;
get_angs_to_object(&player_dest_angles,&station_pos,&ConsoleObject->pos);
chase_angles(&player_angles,&player_dest_angles);
vm_angles_2_matrix(&ConsoleObject->orient,&player_angles);
vm_vec_scale_add2(&ConsoleObject->pos,&ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));
#ifndef SLEW_ON
vm_vec_scale_add2(&endlevel_camera->pos,&endlevel_camera->orient.fvec,fixmul(FrameTime,fixmul(speed_scale,cur_fly_speed)));
if (vm_vec_dist(&ConsoleObject->pos,&station_pos) < i2f(10))
stop_endlevel_sequence();
#endif
break;
}
#endif //ifdef SHORT_SEQUENCE
}
}
int _do_slew_movement(object *obj, int check_keys, int check_joy )
{
int moved = 0;
vms_vector svel, movement; //scaled velocity (per this frame)
vms_matrix rotmat,new_pm;
int joy_x,joy_y,btns;
int joyx_moved,joyy_moved;
vms_angvec rotang;
if (keyd_pressed[KEY_PAD5])
vm_vec_zero(&obj->phys_info.velocity);
if (check_keys) {
obj->phys_info.velocity.x += VEL_SPEED * (key_down_time(KEY_PAD9) - key_down_time(KEY_PAD7));
obj->phys_info.velocity.y += VEL_SPEED * (key_down_time(KEY_PADMINUS) - key_down_time(KEY_PADPLUS));
obj->phys_info.velocity.z += VEL_SPEED * (key_down_time(KEY_PAD8) - key_down_time(KEY_PAD2));
rotang.pitch = (key_down_time(KEY_LBRACKET) - key_down_time(KEY_RBRACKET))/ROT_SPEED;
rotang.bank = (key_down_time(KEY_PAD1) - key_down_time(KEY_PAD3))/ROT_SPEED;
rotang.head = (key_down_time(KEY_PAD6) - key_down_time(KEY_PAD4))/ROT_SPEED;
}
else
rotang.pitch = rotang.bank = rotang.head = 0;
//check for joystick movement
if (check_joy && joy_present) {
joy_get_pos(&joy_x,&joy_y);
btns=joy_get_btns();
joyx_moved = (abs(joy_x - old_joy_x)>JOY_NULL);
joyy_moved = (abs(joy_y - old_joy_y)>JOY_NULL);
if (abs(joy_x) < JOY_NULL) joy_x = 0;
if (abs(joy_y) < JOY_NULL) joy_y = 0;
if (btns)
if (!rotang.pitch) rotang.pitch = fixmul(-joy_y * 512,FrameTime); else;
else
if (joyy_moved) obj->phys_info.velocity.z = -joy_y * 8192;
if (!rotang.head) rotang.head = fixmul(joy_x * 512,FrameTime);
if (joyx_moved) old_joy_x = joy_x;
if (joyy_moved) old_joy_y = joy_y;
}
moved = rotang.pitch | rotang.bank | rotang.head;
vm_angles_2_matrix(&rotmat,&rotang);
vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
obj->orient = new_pm;
vm_transpose_matrix(&new_pm); //make those columns rows
moved |= obj->phys_info.velocity.x | obj->phys_info.velocity.y | obj->phys_info.velocity.z;
svel = obj->phys_info.velocity;
vm_vec_scale(&svel,FrameTime); //movement in this frame
vm_vec_rotate(&movement,&svel,&new_pm);
vm_vec_add2(&obj->pos,&movement);
moved |= (movement.x || movement.y || movement.z);
return moved;
}
void do_object_physics( object * obj )
{
vms_angvec rotang;
vms_vector frame_vec; //movement in this frame
vms_vector new_pos,ipos; //position after this frame
int iseg;
int hit;
vms_matrix rotmat,new_pm;
int count=0;
short joy_x,joy_y,btns;
int joyx_moved,joyy_moved;
fix speed;
vms_vector *desired_upvec;
fixang delta_ang,roll_ang;
vms_vector forvec = {0,0,f1_0};
vms_matrix temp_matrix;
//check keys
rotang.pitch = ROT_SPEED * (key_down_time(KEY_UP) - key_down_time(KEY_DOWN));
rotang.head = ROT_SPEED * (key_down_time(KEY_RIGHT) - key_down_time(KEY_LEFT));
rotang.bank = 0;
//check for joystick movement
joy_get_pos(&joy_x,&joy_y);
btns=joy_get_btns();
joyx_moved = (abs(joy_x - _old_joy_x)>JOY_NULL);
joyy_moved = (abs(joy_y - _old_joy_y)>JOY_NULL);
if (abs(joy_x) < JOY_NULL) joy_x = 0;
if (abs(joy_y) < JOY_NULL) joy_y = 0;
if (!rotang.pitch) rotang.pitch = fixmul(-joy_y * 128,FrameTime);
if (!rotang.head) rotang.head = fixmul(joy_x * 128,FrameTime);
if (joyx_moved) _old_joy_x = joy_x;
if (joyy_moved) _old_joy_y = joy_y;
speed = ((btns&2) || keyd_pressed[KEY_A])?SLOW_SPEED*3:(keyd_pressed[KEY_Z]?SLOW_SPEED/2:SLOW_SPEED);
//now build matrices, do rotations, etc., etc.
vm_angles_2_matrix(&rotmat,&rotang);
vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
obj->orient = new_pm;
//move player
vm_vec_copy_scale(&obj->velocity,&obj->orient.fvec,speed);
vm_vec_copy_scale(&frame_vec,&obj->velocity,FrameTime);
do {
fix wall_part;
vms_vector tvec;
count++;
vm_vec_add(&new_pos,&obj->pos,&frame_vec);
hit = find_vector_intersection(&ipos,&iseg,&obj->pos,obj->seg_id,&new_pos,obj->size,-1);
obj->seg_id = iseg;
obj->pos = ipos;
//-FIXJOHN-if (hit==HIT_OBJECT) ExplodeObject(hit_objnum);
if (hit==HIT_WALL) {
vm_vec_sub(&frame_vec,&new_pos,&obj->pos); //part through wall
wall_part = vm_vec_dot(wall_norm,&frame_vec);
vm_vec_copy_scale(&tvec,wall_norm,wall_part);
if ((wall_part == 0) || (vm_vec_mag(&tvec) < 5)) Int3();
vm_vec_sub2(&frame_vec,&tvec);
}
} while (hit == HIT_WALL);
Assert(check_point_in_seg(&obj->pos,obj->seg_id,0).centermask==0);
//now bank player according to segment orientation
desired_upvec = &Segments[obj->seg_id].sides[3].faces[0].normal;
if (labs(vm_vec_dot(desired_upvec,&obj->orient.fvec)) < f1_0/2) {
vm_vector_2_matrix(&temp_matrix,&obj->orient.fvec,desired_upvec,NULL);
delta_ang = vm_vec_delta_ang(&obj->orient.uvec,&temp_matrix.uvec,&obj->orient.fvec);
if (rotang.head) delta_ang += (rotang.head<0)?TURNROLL_ANG:-TURNROLL_ANG;
if (abs(delta_ang) > DAMP_ANG) {
roll_ang = fixmul(FrameTime,ROLL_RATE);
if (abs(delta_ang) < roll_ang) roll_ang = delta_ang;
else if (delta_ang<0) roll_ang = -roll_ang;
vm_vec_ang_2_matrix(&rotmat,&forvec,roll_ang);
vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
obj->orient = new_pm;
}
}
}
void do_physics_align_object( object * obj )
{
vms_vector desired_upvec;
fixang delta_ang,roll_ang;
//vms_vector forvec = {0,0,f1_0};
vms_matrix temp_matrix;
fix d,largest_d=-f1_0;
int i,best_side;
best_side=0;
// bank player according to segment orientation
//find side of segment that player is most alligned with
for (i=0;i<6;i++) {
#ifdef COMPACT_SEGS
vms_vector _tv1;
get_side_normal( &Segments[obj->segnum], i, 0, &_tv1 );
d = vm_vec_dot(&_tv1,&obj->orient.uvec);
#else
d = vm_vec_dot(&Segments[obj->segnum].sides[i].normals[0],&obj->orient.uvec);
#endif
if (d > largest_d) {largest_d = d; best_side=i;}
}
if (floor_levelling) {
// old way: used floor's normal as upvec
#ifdef COMPACT_SEGS
get_side_normal(&Segments[obj->segnum], 3, 0, &desired_upvec );
#else
desired_upvec = Segments[obj->segnum].sides[3].normals[0];
#endif
}
else // new player leveling code: use normal of side closest to our up vec
if (get_num_faces(&Segments[obj->segnum].sides[best_side])==2) {
#ifdef COMPACT_SEGS
vms_vector normals[2];
get_side_normals(&Segments[obj->segnum], best_side, &normals[0], &normals[1] );
desired_upvec.x = (normals[0].x + normals[1].x) / 2;
desired_upvec.y = (normals[0].y + normals[1].y) / 2;
desired_upvec.z = (normals[0].z + normals[1].z) / 2;
vm_vec_normalize(&desired_upvec);
#else
side *s = &Segments[obj->segnum].sides[best_side];
desired_upvec.x = (s->normals[0].x + s->normals[1].x) / 2;
desired_upvec.y = (s->normals[0].y + s->normals[1].y) / 2;
desired_upvec.z = (s->normals[0].z + s->normals[1].z) / 2;
vm_vec_normalize(&desired_upvec);
#endif
}
else
#ifdef COMPACT_SEGS
get_side_normal(&Segments[obj->segnum], best_side, 0, &desired_upvec );
#else
desired_upvec = Segments[obj->segnum].sides[best_side].normals[0];
#endif
if (labs(vm_vec_dot(&desired_upvec,&obj->orient.fvec)) < f1_0/2) {
vms_angvec tangles;
vm_vector_2_matrix(&temp_matrix,&obj->orient.fvec,&desired_upvec,NULL);
delta_ang = vm_vec_delta_ang(&obj->orient.uvec,&temp_matrix.uvec,&obj->orient.fvec);
delta_ang += obj->mtype.phys_info.turnroll;
if (abs(delta_ang) > DAMP_ANG) {
vms_matrix rotmat, new_pm;
roll_ang = fixmul(FrameTime,ROLL_RATE);
if (abs(delta_ang) < roll_ang) roll_ang = delta_ang;
else if (delta_ang<0) roll_ang = -roll_ang;
tangles.p = tangles.h = 0; tangles.b = roll_ang;
vm_angles_2_matrix(&rotmat,&tangles);
vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
obj->orient = new_pm;
}
else floor_levelling=0;
}
}
// -----------------------------------------------------------------------------------------------------------
// add rotational velocity & acceleration
void do_physics_sim_rot(object *obj)
{
vms_angvec tangles;
vms_matrix rotmat,new_orient;
//fix rotdrag_scale;
physics_info *pi;
Assert(FrameTime > 0); //Get MATT if hit this!
pi = &obj->mtype.phys_info;
if (!(pi->rotvel.x || pi->rotvel.y || pi->rotvel.z || pi->rotthrust.x || pi->rotthrust.y || pi->rotthrust.z))
return;
if (obj->mtype.phys_info.drag) {
int count;
vms_vector accel;
fix drag,r,k;
count = FrameTime / FT;
r = FrameTime % FT;
k = fixdiv(r,FT);
drag = (obj->mtype.phys_info.drag*5)/2;
if (obj->mtype.phys_info.flags & PF_USES_THRUST) {
vm_vec_copy_scale(&accel,&obj->mtype.phys_info.rotthrust,fixdiv(f1_0,obj->mtype.phys_info.mass));
while (count--) {
vm_vec_add2(&obj->mtype.phys_info.rotvel,&accel);
vm_vec_scale(&obj->mtype.phys_info.rotvel,f1_0-drag);
}
//do linear scale on remaining bit of time
vm_vec_scale_add2(&obj->mtype.phys_info.rotvel,&accel,k);
vm_vec_scale(&obj->mtype.phys_info.rotvel,f1_0-fixmul(k,drag));
}
else {
fix total_drag=f1_0;
while (count--)
total_drag = fixmul(total_drag,f1_0-drag);
//do linear scale on remaining bit of time
total_drag = fixmul(total_drag,f1_0-fixmul(k,drag));
vm_vec_scale(&obj->mtype.phys_info.rotvel,total_drag);
}
}
//now rotate object
//unrotate object for bank caused by turn
if (obj->mtype.phys_info.turnroll) {
vms_matrix new_pm;
tangles.p = tangles.h = 0;
tangles.b = -obj->mtype.phys_info.turnroll;
vm_angles_2_matrix(&rotmat,&tangles);
vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
obj->orient = new_pm;
}
tangles.p = fixmul(obj->mtype.phys_info.rotvel.x,FrameTime);
tangles.h = fixmul(obj->mtype.phys_info.rotvel.y,FrameTime);
tangles.b = fixmul(obj->mtype.phys_info.rotvel.z,FrameTime);
vm_angles_2_matrix(&rotmat,&tangles);
vm_matrix_x_matrix(&new_orient,&obj->orient,&rotmat);
obj->orient = new_orient;
if (obj->mtype.phys_info.flags & PF_TURNROLL)
set_object_turnroll(obj);
//re-rotate object for bank caused by turn
if (obj->mtype.phys_info.turnroll) {
vms_matrix new_pm;
tangles.p = tangles.h = 0;
tangles.b = obj->mtype.phys_info.turnroll;
vm_angles_2_matrix(&rotmat,&tangles);
vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
obj->orient = new_pm;
}
check_and_fix_matrix(&obj->orient);
}
//called for each level to load & setup the exit sequence
load_endlevel_data(int level_num)
{
char filename[13];
char line[LINE_LEN],*p;
CFILE *ifile;
int var,segnum,sidenum;
int exit_side, i;
int have_binary = 0;
endlevel_data_loaded = 0; //not loaded yet
try_again:
;
if (level_num<0) //secret level
strcpy(filename,Secret_level_names[-level_num-1]);
else //normal level
strcpy(filename,Level_names[level_num-1]);
if (!convert_ext(filename,"END"))
return;
ifile = cfopen(filename,"rb");
if (!ifile) {
convert_ext(filename,"TXB");
ifile = cfopen(filename,"rb");
if (!ifile)
if (level_num==1) {
return; //abort
//Error("Cannot load file text of binary version of <%s>",filename);
}
else {
level_num = 1;
goto try_again;
}
have_binary = 1;
}
//ok...this parser is pretty simple. It ignores comments, but
//everything else must be in the right place
var = 0;
while (cfgets(line,LINE_LEN,ifile)) {
if (have_binary) {
for (i = 0; i < strlen(line) - 1; i++) {
encode_rotate_left(&(line[i]));
line[i] = line[i] ^ BITMAP_TBL_XOR;
encode_rotate_left(&(line[i]));
}
p = line;
}
if ((p=strchr(line,';'))!=NULL)
*p = 0; //cut off comment
for (p=line+strlen(line)-1;p>line && isspace(*p);*p--=0);
for (p=line;isspace(*p);p++);
if (!*p) //empty line
continue;
switch (var) {
case 0: { //ground terrain
int iff_error;
ubyte pal[768];
if (terrain_bm_instance.bm_data)
free(terrain_bm_instance.bm_data);
iff_error = iff_read_bitmap(p,&terrain_bm_instance,BM_LINEAR,pal);
if (iff_error != IFF_NO_ERROR) {
mprintf((1, "File %s - IFF error: %s",p,iff_errormsg(iff_error)));
Error("File %s - IFF error: %s",p,iff_errormsg(iff_error));
}
terrain_bitmap = &terrain_bm_instance;
gr_remap_bitmap_good( terrain_bitmap, pal, iff_transparent_color, -1);
break;
}
case 1: //height map
load_terrain(p);
break;
case 2:
sscanf(p,"%d,%d",&exit_point_bmx,&exit_point_bmy);
break;
case 3: //exit heading
exit_angles.h = i2f(atoi(p))/360;
break;
case 4: { //planet bitmap
int iff_error;
ubyte pal[768];
if (satellite_bm_instance.bm_data)
free(satellite_bm_instance.bm_data);
iff_error = iff_read_bitmap(p,&satellite_bm_instance,BM_LINEAR,pal);
if (iff_error != IFF_NO_ERROR) {
mprintf((1, "File %s - IFF error: %s",p,iff_errormsg(iff_error)));
Error("File %s - IFF error: %s",p,iff_errormsg(iff_error));
}
satellite_bitmap = &satellite_bm_instance;
gr_remap_bitmap_good( satellite_bitmap, pal, iff_transparent_color, -1);
break;
}
case 5: //earth pos
case 7: { //station pos
vms_matrix tm;
vms_angvec ta;
int pitch,head;
sscanf(p,"%d,%d",&head,&pitch);
ta.h = i2f(head)/360;
ta.p = -i2f(pitch)/360;
ta.b = 0;
vm_angles_2_matrix(&tm,&ta);
if (var==5)
satellite_pos = tm.fvec;
//vm_vec_copy_scale(&satellite_pos,&tm.fvec,SATELLITE_DIST);
else
station_pos = tm.fvec;
break;
}
case 6: //planet size
satellite_size = i2f(atoi(p));
break;
}
var++;
}
Assert(var == NUM_VARS);
// OK, now the data is loaded. Initialize everything
//find the exit sequence by searching all segments for a side with
//children == -2
for (segnum=0,exit_segnum=-1;exit_segnum==-1 && segnum<=Highest_segment_index;segnum++)
for (sidenum=0;sidenum<6;sidenum++)
if (Segments[segnum].children[sidenum] == -2) {
exit_segnum = segnum;
exit_side = sidenum;
break;
}
Assert(exit_segnum!=-1);
compute_segment_center(&mine_exit_point,&Segments[exit_segnum]);
extract_orient_from_segment(&mine_exit_orient,&Segments[exit_segnum]);
compute_center_point_on_side(&mine_side_exit_point,&Segments[exit_segnum],exit_side);
vm_vec_scale_add(&mine_ground_exit_point,&mine_exit_point,&mine_exit_orient.uvec,-i2f(20));
//compute orientation of surface
{
vms_vector tv;
vms_matrix exit_orient,tm;
vm_angles_2_matrix(&exit_orient,&exit_angles);
vm_transpose_matrix(&exit_orient);
vm_matrix_x_matrix(&surface_orient,&mine_exit_orient,&exit_orient);
vm_copy_transpose_matrix(&tm,&surface_orient);
vm_vec_rotate(&tv,&station_pos,&tm);
vm_vec_scale_add(&station_pos,&mine_exit_point,&tv,STATION_DIST);
vm_vec_rotate(&tv,&satellite_pos,&tm);
vm_vec_scale_add(&satellite_pos,&mine_exit_point,&tv,SATELLITE_DIST);
vm_vector_2_matrix(&tm,&tv,&surface_orient.uvec,NULL);
vm_vec_copy_scale(&satellite_upvec,&tm.uvec,SATELLITE_HEIGHT);
}
cfclose(ifile);
endlevel_data_loaded = 1;
}
void physics_sim_rot(matrix * orient, physics_info * pi, float sim_time )
{
angles tangles;
vec3d new_vel;
matrix tmp;
float shock_amplitude;
float rotdamp;
float shock_fraction_time_left;
Assert(is_valid_matrix(orient));
Assert(is_valid_vec(&pi->rotvel));
Assert(is_valid_vec(&pi->desired_rotvel));
// Handle special case of shockwave
shock_amplitude = 0.0f;
if ( pi->flags & PF_IN_SHOCKWAVE ) {
if ( timestamp_elapsed(pi->shockwave_decay) ) {
pi->flags &= ~PF_IN_SHOCKWAVE;
rotdamp = pi->rotdamp;
} else {
shock_fraction_time_left = timestamp_until( pi->shockwave_decay ) / (float) SW_BLAST_DURATION;
rotdamp = pi->rotdamp + pi->rotdamp * (SW_ROT_FACTOR - 1) * shock_fraction_time_left;
shock_amplitude = pi->shockwave_shake_amp * shock_fraction_time_left;
}
} else {
rotdamp = pi->rotdamp;
}
// Do rotational physics with given damping
apply_physics( rotdamp, pi->desired_rotvel.xyz.x, pi->rotvel.xyz.x, sim_time, &new_vel.xyz.x, NULL );
apply_physics( rotdamp, pi->desired_rotvel.xyz.y, pi->rotvel.xyz.y, sim_time, &new_vel.xyz.y, NULL );
apply_physics( rotdamp, pi->desired_rotvel.xyz.z, pi->rotvel.xyz.z, sim_time, &new_vel.xyz.z, NULL );
Assert(is_valid_vec(&new_vel));
pi->rotvel = new_vel;
tangles.p = pi->rotvel.xyz.x*sim_time;
tangles.h = pi->rotvel.xyz.y*sim_time;
tangles.b = pi->rotvel.xyz.z*sim_time;
/* // Make ship shake due to afterburner.
if (pi->flags & PF_AFTERBURNER_ON || !timestamp_elapsed(pi->afterburner_decay) ) {
float max_speed;
max_speed = vm_vec_mag_quick(&pi->max_vel);
tangles.p += (float) (rand()-RAND_MAX_2) * RAND_MAX_1f * pi->speed/max_speed/64.0f;
tangles.h += (float) (rand()-RAND_MAX_2) * RAND_MAX_1f * pi->speed/max_speed/64.0f;
if ( pi->flags & PF_AFTERBURNER_ON ) {
pi->afterburner_decay = timestamp(ABURN_DECAY_TIME);
}
}
*/
// Make ship shake due to shockwave, decreasing in amplitude at the end of the shockwave
if ( pi->flags & PF_IN_SHOCKWAVE ) {
tangles.p += (float) (myrand()-RAND_MAX_2) * RAND_MAX_1f * shock_amplitude;
tangles.h += (float) (myrand()-RAND_MAX_2) * RAND_MAX_1f * shock_amplitude;
}
vm_angles_2_matrix(&pi->last_rotmat, &tangles );
vm_matrix_x_matrix( &tmp, orient, &pi->last_rotmat );
*orient = tmp;
vm_orthogonalize_matrix(orient);
}
// ------------------------------------------------------------------------------------
// shockwave_create()
//
// Call to create a shockwave
//
// input: parent_objnum => object number of object spawning the shockwave
// pos => vector specifing global position of shockwave center
// speed => speed at which shockwave expands (m/s)
// inner_radius => radius at which damage applied is at maximum
// outer_radius => damage decreases linearly to zero from inner_radius to
// outer_radius. Outside outer_radius, damage is 0.
// damage => the maximum damage (ie within inner_radius)
// blast => the maximux blast (within inner_radius)
// sw_flag => indicates whether shockwave is from weapon or ship explosion
// delay => delay in ms before the shockwave actually starts
//
// return: success => object number of shockwave
// failure => -1
//
// Goober5000 - now parent_objnum can be allowed to be -1
int shockwave_create(int parent_objnum, vec3d *pos, shockwave_create_info *sci, int flag, int delay)
{
int i, objnum, real_parent;
int info_index = -1, model_id = -1;
shockwave *sw;
// shockwave_info *si;
matrix orient;
for (i = 0; i < MAX_SHOCKWAVES; i++) {
if ( !(Shockwaves[i].flags & SW_USED) )
break;
}
if (i == MAX_SHOCKWAVES)
return -1;
// try 2D shockwave first, then fall back to 3D, then fall back to default of either
// this should be pretty fool-proof and allow quick change between 2D and 3D effects
if ( strlen(sci->name) )
info_index = shockwave_load(sci->name, false);
if ( (info_index < 0) && strlen(sci->pof_name) )
info_index = shockwave_load(sci->pof_name, true);
if (info_index < 0) {
if ( (Shockwave_info[0].bitmap_id >= 0) || (Shockwave_info[0].model_id >= 0) ) {
info_index = 0;
model_id = Shockwave_info[0].model_id;
} else {
// crap, just bail
return -1;
}
} else {
model_id = Shockwave_info[info_index].model_id;
}
// real_parent is the guy who caused this shockwave to happen
if (parent_objnum == -1) { // Goober5000
real_parent = -1;
} else if ( Objects[parent_objnum].type == OBJ_WEAPON ){
real_parent = Objects[parent_objnum].parent;
} else {
real_parent = parent_objnum;
}
sw = &Shockwaves[i];
sw->model_id = model_id;
sw->flags = (SW_USED | flag);
sw->speed = sci->speed;
sw->inner_radius = sci->inner_rad;
sw->outer_radius = sci->outer_rad;
sw->damage = sci->damage;
sw->blast = sci->blast;
sw->radius = 1.0f;
sw->pos = *pos;
sw->num_objs_hit = 0;
sw->shockwave_info_index = info_index; // only one type for now... type could be passed is as a parameter
sw->current_bitmap = -1;
sw->time_elapsed=0.0f;
sw->delay_stamp = delay;
sw->rot_angles = sci->rot_angles;
sw->damage_type_idx = sci->damage_type_idx;
// si = &Shockwave_info[sw->shockwave_info_index];
// sw->total_time = i2fl(si->num_frames) / si->fps; // in seconds
sw->total_time = sw->outer_radius / sw->speed;
if ( (parent_objnum != -1) && Objects[parent_objnum].type == OBJ_WEAPON ) { // Goober5000: allow -1
sw->weapon_info_index = Weapons[Objects[parent_objnum].instance].weapon_info_index;
}
else {
sw->weapon_info_index = -1;
}
orient = vmd_identity_matrix;
vm_angles_2_matrix(&orient, &sw->rot_angles);
// angles a;
// a.p = sw->rot_angle*(PI/180);
// a.b = frand_range(0.0f, PI2);
// a.h = frand_range(0.0f, PI2);
// vm_angles_2_matrix(&orient, &a);
objnum = obj_create( OBJ_SHOCKWAVE, real_parent, i, &orient, &sw->pos, sw->outer_radius, OF_RENDERS );
if ( objnum == -1 ){
Int3();
}
sw->objnum = objnum;
list_append(&Shockwave_list, sw);
return objnum;
}
int do_slew_movement(object *obj, int check_keys, int check_joy )
{
int moved = 0;
vms_vector svel, movement; //scaled velocity (per this frame)
vms_matrix rotmat,new_pm;
int joy_x,joy_y,btns;
int joyx_moved,joyy_moved;
vms_angvec rotang;
if (!slew_obj || slew_obj->control_type!=CT_SLEW) return 0;
if (check_keys) {
if (Function_mode == FMODE_EDITOR) {
obj->mtype.phys_info.velocity.x += VEL_SPEED * (key_down_time(KEY_PAD9) - key_down_time(KEY_PAD7));
obj->mtype.phys_info.velocity.y += VEL_SPEED * (key_down_time(KEY_PADMINUS) - key_down_time(KEY_PADPLUS));
obj->mtype.phys_info.velocity.z += VEL_SPEED * (key_down_time(KEY_PAD8) - key_down_time(KEY_PAD2));
rotang.p = (key_down_time(KEY_LBRACKET) - key_down_time(KEY_RBRACKET))/ROT_SPEED ;
rotang.b = (key_down_time(KEY_PAD1) - key_down_time(KEY_PAD3))/ROT_SPEED;
rotang.h = (key_down_time(KEY_PAD6) - key_down_time(KEY_PAD4))/ROT_SPEED;
}
else {
obj->mtype.phys_info.velocity.x += VEL_SPEED * Controls.sideways_thrust_time;
obj->mtype.phys_info.velocity.y += VEL_SPEED * Controls.vertical_thrust_time;
obj->mtype.phys_info.velocity.z += VEL_SPEED * Controls.forward_thrust_time;
rotang.p = Controls.pitch_time/ROT_SPEED ;
rotang.b = Controls.bank_time/ROT_SPEED;
rotang.h = Controls.heading_time/ROT_SPEED;
}
}
else
rotang.p = rotang.b = rotang.h = 0;
//check for joystick movement
if (check_joy && joy_present && (Function_mode == FMODE_EDITOR) ) {
joy_get_pos(&joy_x,&joy_y);
btns=joy_get_btns();
joyx_moved = (abs(joy_x - old_joy_x)>JOY_NULL);
joyy_moved = (abs(joy_y - old_joy_y)>JOY_NULL);
if (abs(joy_x) < JOY_NULL) joy_x = 0;
if (abs(joy_y) < JOY_NULL) joy_y = 0;
if (btns)
if (!rotang.p) rotang.p = fixmul(-joy_y * 512,FrameTime); else;
else
if (joyy_moved) obj->mtype.phys_info.velocity.z = -joy_y * 8192;
if (!rotang.h) rotang.h = fixmul(joy_x * 512,FrameTime);
if (joyx_moved) old_joy_x = joy_x;
if (joyy_moved) old_joy_y = joy_y;
}
moved = rotang.p | rotang.b | rotang.h;
vm_angles_2_matrix(&rotmat,&rotang);
vm_matrix_x_matrix(&new_pm,&obj->orient,&rotmat);
obj->orient = new_pm;
vm_transpose_matrix(&new_pm); //make those columns rows
moved |= obj->mtype.phys_info.velocity.x | obj->mtype.phys_info.velocity.y | obj->mtype.phys_info.velocity.z;
svel = obj->mtype.phys_info.velocity;
vm_vec_scale(&svel,FrameTime); //movement in this frame
vm_vec_rotate(&movement,&svel,&new_pm);
// obj->last_pos = obj->pos;
vm_vec_add2(&obj->pos,&movement);
moved |= (movement.x || movement.y || movement.z);
if (moved)
update_object_seg(obj); //update segment id
return moved;
}
