自学教程：C++ vm_vec_dist函数代码示例

//	See if two lines intersect by doing recursive subdivision.//	Bails out if larger distance traveled is less than sum of radii + 1.0f.int collide_subdivide(vec3d *p0, vec3d *p1, float prad, vec3d *q0, vec3d *q1, float qrad){	float	a_dist, b_dist, ab_dist;	a_dist = vm_vec_dist(p0, p1);	b_dist = vm_vec_dist(q0, q1);	ab_dist = vm_vec_dist(p1, q1);	//	See if their spheres intersect	if (ab_dist < a_dist + b_dist + prad + qrad) {		if (ab_dist  < prad + qrad)			return 1;		else if (vm_vec_dist(p0, q0) < prad + qrad)			return 1;		else if (MAX(a_dist, b_dist) < prad + qrad + 1.0f)			return 0;		else {			int	r1, r2 = 0;			vec3d	pa, qa;			vm_vec_avg(&pa, p0, p1);			vm_vec_avg(&qa, q0, q1);			r1 = collide_subdivide(p0, &pa, prad, q0, &qa, qrad);			if (!r1)				r2 = collide_subdivide(&pa, p1, prad, &qa, q1, qrad);			return r1 | r2;		}	} else		return 0;}

//	-----------------------------------------------------------int DoTexSlideLeft(int value){	side	*sidep;	uvl	duvl03;	fix	dist;	sbyte	*vp;	int	v;	vp = Side_to_verts[Curside];	sidep = &Cursegp->sides[Curside];	dist = vm_vec_dist(&Vertices[Cursegp->verts[vp[3]]], &Vertices[Cursegp->verts[vp[0]]]);	dist *= value;	if (dist < F1_0/(64*value))		dist = F1_0/(64*value);	duvl03.u = fixdiv(sidep->uvls[3].u - sidep->uvls[0].u,dist);	duvl03.v = fixdiv(sidep->uvls[3].v - sidep->uvls[0].v,dist);	for (v=0; v<4; v++) {		sidep->uvls[v].u -= duvl03.u;		sidep->uvls[v].v -= duvl03.v;	}	Update_flags |= UF_WORLD_CHANGED;	return	1;}

void model_collide_sortnorm(ubyte * p){	int frontlist = w(p+36);	int backlist = w(p+40);	int prelist = w(p+44);	int postlist = w(p+48);	int onlist = w(p+52);	vec3d hitpos;	if ( Mc_pm->version >= 2000 )	{		if ( mc_ray_boundingbox( vp(p+56), vp(p+68), &Mc_p0, &Mc_direction, &hitpos) )	{			if ( !(Mc->flags & MC_CHECK_RAY) && (vm_vec_dist(&hitpos, &Mc_p0) > Mc_mag) ) {				return;			}		} else {			return;		}	}	if (prelist) model_collide_sub(p+prelist);	if (backlist) model_collide_sub(p+backlist);	if (onlist) model_collide_sub(p+onlist);	if (frontlist) model_collide_sub(p+frontlist);	if (postlist) model_collide_sub(p+postlist);}

//	return quadrant containing hit_pnt.//	/  1  /.//	3 / / 0//	  / /.//	/  2  /.//	Note: This is in the object's local reference frame.  Do _not_ pass a vector in the world frame.int get_quadrant(vec3d *hit_pnt, object *shipobjp){	if (shipobjp != NULL && Ship_info[Ships[shipobjp->instance].ship_info_index].flags2 & SIF2_MODEL_POINT_SHIELDS) {		int closest = -1;		float closest_dist = FLT_MAX;		for (unsigned int i=0; i<Ships[shipobjp->instance].shield_points.size(); i++) {			float dist = vm_vec_dist(hit_pnt, &Ships[shipobjp->instance].shield_points.at(i));			if (dist < closest_dist) {				closest = i;				closest_dist = dist;			}		}		return closest;	} else {		int	result = 0;		if (hit_pnt->xyz.x < hit_pnt->xyz.z)			result |= 1;		if (hit_pnt->xyz.x < -hit_pnt->xyz.z)			result |= 2;		return result;	}}

void move_object_to_vector(vms_vector *vec_through_screen, fix delta_distance){	vms_vector	result;	vm_vec_scale_add(&result, &Viewer->pos, vec_through_screen, vm_vec_dist(&Viewer->pos,&Objects[Cur_object_index].pos)+delta_distance);	move_object_to_position(Cur_object_index, &result);}

//	Project the viewer's position onto the grid plane.  If more than threshold distance//	from grid center, move grid center.void maybe_create_new_grid(grid* gridp, vector *pos, matrix *orient, int force){	int roundoff;	plane	tplane;	vector	gpos, tmp, c;	float	dist_to_plane;	float	square_size, ux, uy, uz;	ux = tplane.A = gridp->gmatrix.v.uvec.xyz.x;	uy = tplane.B = gridp->gmatrix.v.uvec.xyz.y;	uz = tplane.C = gridp->gmatrix.v.uvec.xyz.z;	tplane.D = gridp->planeD;	compute_point_on_plane(&c, &tplane, pos);	dist_to_plane = fl_abs(vm_dist_to_plane(pos, &gridp->gmatrix.v.uvec, &c));	square_size = 1.0f;	while (dist_to_plane >= 25.0f)	{		square_size *= 10.0f;		dist_to_plane /= 10.0f;	}		if (fvi_ray_plane(&gpos, &gridp->center, &gridp->gmatrix.v.uvec, pos, &orient->v.fvec, 0.0f)<0.0f)	{		vector p;		vm_vec_scale_add(&p,pos,&orient->v.fvec, 100.0f );		compute_point_on_plane(&gpos, &tplane, &p );	}	if (vm_vec_dist(&gpos, &c) > 50.0f * square_size)	{		vm_vec_sub(&tmp, &gpos, &c);		vm_vec_normalize(&tmp);		vm_vec_scale_add(&gpos, &c, &tmp, 50.0f * square_size);	}	roundoff = (int) square_size * 10;	if (!ux)		gpos.xyz.x = fl_roundoff(gpos.xyz.x, roundoff);	if (!uy)		gpos.xyz.y = fl_roundoff(gpos.xyz.y, roundoff);	if (!uz)		gpos.xyz.z = fl_roundoff(gpos.xyz.z, roundoff);	if ((square_size != gridp->square_size) ||		(gpos.xyz.x != gridp->center.xyz.x) ||		(gpos.xyz.y != gridp->center.xyz.y) ||		(gpos.xyz.z != gridp->center.xyz.z) || force)	{		gridp->square_size = square_size;		gridp->center = gpos;		modify_grid(gridp);	}}

void HudGaugeRadarDradis::drawContact(vec3d *pnt, int idx, int clr_idx, float  /*dist*/, float alpha, float scale_factor){	vec3d  p;	int h, w;	vertex vert;	float aspect_mp;	if ((sub_y_clip && (pnt->xyz.y > 0)) || ((!sub_y_clip) && (pnt->xyz.y <= 0)))		return;    memset(&vert, 0, sizeof(vert));    	vm_vec_rotate(&p, pnt,  &vmd_identity_matrix); 	g3_transfer_vertex(&vert, &p);		float sizef = fl_sqrt(vm_vec_dist(&Orb_eye_position, pnt) * 8.0f) * scale_factor;    if ( clr_idx >= 0 ) {        bm_get_info(clr_idx, &w, &h);                if (h == w) {            aspect_mp = 1.0f;        } else {            aspect_mp = (((float) h) / ((float) w));        }                //gr_set_bitmap(clr_idx, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha);        //g3_draw_polygon(&p, &vmd_identity_matrix, sizef/35.0f, aspect_mp*sizef/35.0f, TMAP_FLAG_TEXTURED | TMAP_HTL_3D_UNLIT);		material mat_params;		material_set_unlit_color(&mat_params, clr_idx, &Color_bright_white, alpha, true, false);		g3_render_rect_oriented(&mat_params, &p, &vmd_identity_matrix, sizef/35.0f, aspect_mp*sizef/35.0f);    }        if ( idx >= 0 ) {        bm_get_info(idx, &w, &h);                if (h == w) {            aspect_mp = 1.0f;        } else {            aspect_mp = (((float) h) / ((float) w));        }                //gr_set_bitmap(idx, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha);        //g3_draw_polygon(&p, &vmd_identity_matrix, sizef/35.0f, aspect_mp*sizef/35.0f, TMAP_FLAG_TEXTURED | TMAP_FLAG_BW_TEXTURE | TMAP_HTL_3D_UNLIT);		material mat_params;		material_set_unlit_color(&mat_params, idx, &gr_screen.current_color, alpha, true, false);		g3_render_rect_oriented(&mat_params, &p, &vmd_identity_matrix, sizef/35.0f, aspect_mp*sizef/35.0f);    }}

fix curve_dist(vms_equation *coeffs, int degree, fix t0, vms_vector *p0, fix dist) {	 vms_vector coord;    fix t, diff;    if (degree!=3) printf("ERROR: for Hermite Curves degree must be 3/n");    for (t=t0;t<1*F1_0;t+=0.001*F1_0) {        coord = evaluate_curve(coeffs, 3, t);        diff = dist - vm_vec_dist(&coord, p0);        if (diff<ACCURACY)   //&&(diff>-ACCURACY))            return t;    }    return -1*F1_0;}

//calls the object interpreter to render an object.  The object renderer//is really a seperate pipeline. returns true if drewint model_collide_sub(void *model_ptr ){    ubyte *p = (ubyte *)model_ptr;    int chunk_type, chunk_size;    vec3d hitpos;    chunk_type = w(p);    chunk_size = w(p+4);    while (chunk_type != OP_EOF)	{//		mprintf(( "Processing chunk type %d, len=%d/n", chunk_type, chunk_size ));        switch (chunk_type) {        case OP_DEFPOINTS:            model_collide_defpoints(p);            break;        case OP_FLATPOLY:            model_collide_flatpoly(p);            break;        case OP_TMAPPOLY:            model_collide_tmappoly(p);            break;        case OP_SORTNORM:            model_collide_sortnorm(p);            break;        case OP_BOUNDBOX:            if ( mc_ray_boundingbox( vp(p+8), vp(p+20), &Mc_p0, &Mc_direction, &hitpos ) )	{                if ( !(Mc->flags & MC_CHECK_RAY) && (vm_vec_dist(&hitpos, &Mc_p0) > Mc_mag) ) {                    // The ray isn't long enough to intersect the bounding box                    return 1;                }            } else {                return 1;            }            break;        default:            mprintf(( "Bad chunk type %d, len=%d in model_collide_sub/n", chunk_type, chunk_size ));            Int3();		// Bad chunk type!            return 0;        }        p += chunk_size;        chunk_type = w(p);        chunk_size = w(p+4);    }    return 1;}

//	-----------------------------------------------------------------------------------------------------------------//	Return true if side is planar, else return false.int side_is_planar_p(segment *sp, int side){	sbyte			*vp;	vms_vector	*v0,*v1,*v2,*v3;	vms_vector	va,vb;	vp = Side_to_verts[side];	v0 = &Vertices[sp->verts[vp[0]]];	v1 = &Vertices[sp->verts[vp[1]]];	v2 = &Vertices[sp->verts[vp[2]]];	v3 = &Vertices[sp->verts[vp[3]]];	vm_vec_normalize(vm_vec_normal(&va,v0,v1,v2));	vm_vec_normalize(vm_vec_normal(&vb,v0,v2,v3));		// If the two vectors are very close to being the same, then generate one quad, else generate two triangles.	return (vm_vec_dist(&va,&vb) < F1_0/1000);}

/** * Given an object, returns which jump node it's inside (if any) * * @param objp Object * @return Jump node object or NULL if not in one */CJumpNode *jumpnode_get_which_in(object *objp){	Assert(objp != NULL);	SCP_list<CJumpNode>::iterator jnp;	float radius, dist;	for (jnp = Jump_nodes.begin(); jnp != Jump_nodes.end(); ++jnp) {		if(jnp->GetModelNumber() < 0)			continue;		radius = model_get_radius( jnp->GetModelNumber() );		dist = vm_vec_dist( &objp->pos, &jnp->GetSCPObject()->pos );		if ( dist <= radius ) {			return &(*jnp);		}	}	return NULL;}

void HudGaugeRadarDradis::drawContact(vec3d *pnt, int idx, int clr_idx, float dist, float alpha, float scale_factor){	vec3d  p;	int h, w;	vertex vert;	float aspect_mp;	if ((sub_y_clip && (pnt->xyz.y > 0)) || ((!sub_y_clip) && (pnt->xyz.y <= 0)))		return;    memset(&vert, 0, sizeof(vert));    	vm_vec_rotate(&p, pnt,  &vmd_identity_matrix); 	g3_transfer_vertex(&vert, &p);		float sizef = fl_sqrt(vm_vec_dist(&Orb_eye_position, pnt) * 8.0f) * scale_factor;    if ( clr_idx >= 0 ) {        bm_get_info(clr_idx, &w, &h);                if (h == w) {            aspect_mp = 1.0f;        } else {            aspect_mp = (((float) h) / ((float) w));        }                gr_set_bitmap(clr_idx, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha);        g3_draw_polygon(&p, &vmd_identity_matrix, sizef/35.0f, aspect_mp*sizef/35.0f, TMAP_FLAG_TEXTURED | TMAP_HTL_3D_UNLIT);    }        if ( idx >= 0 ) {        bm_get_info(idx, &w, &h);                if (h == w) {            aspect_mp = 1.0f;        } else {            aspect_mp = (((float) h) / ((float) w));        }                gr_set_bitmap(idx, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha);        g3_draw_polygon(&p, &vmd_identity_matrix, sizef/35.0f, aspect_mp*sizef/35.0f, TMAP_FLAG_TEXTURED | TMAP_FLAG_BW_TEXTURE | TMAP_HTL_3D_UNLIT);    }}

void grid_render_elevation_line(vector *pos, grid* gridp){	vector	gpos;	//	Location of point on grid.	vector	tpos;	float		dxz;	plane		tplane;	vector	*gv;		tplane.A = gridp->gmatrix.v.uvec.xyz.x;	tplane.B = gridp->gmatrix.v.uvec.xyz.y;	tplane.C = gridp->gmatrix.v.uvec.xyz.z;	tplane.D = gridp->planeD;	compute_point_on_plane(&gpos, &tplane, pos);	dxz = vm_vec_dist(pos, &gpos)/8.0f;	gv = &gridp->gmatrix.v.uvec;	if (gv->xyz.x * pos->xyz.x + gv->xyz.y * pos->xyz.y + gv->xyz.z * pos->xyz.z < -gridp->planeD)		gr_set_color(127, 127, 127);	else		gr_set_color(255, 255, 255);   // white	rpd_line(&gpos, pos);	//	Line from grid to object center.	tpos = gpos;	vm_vec_scale_add2(&gpos, &gridp->gmatrix.v.rvec, -dxz/2);	vm_vec_scale_add2(&gpos, &gridp->gmatrix.v.fvec, -dxz/2);		vm_vec_scale_add2(&tpos, &gridp->gmatrix.v.rvec, dxz/2);	vm_vec_scale_add2(&tpos, &gridp->gmatrix.v.fvec, dxz/2);		rpd_line(&gpos, &tpos);	vm_vec_scale_add2(&gpos, &gridp->gmatrix.v.rvec, dxz);	vm_vec_scale_add2(&tpos, &gridp->gmatrix.v.rvec, -dxz);	rpd_line(&gpos, &tpos);}

void model_collide_bsp(bsp_collision_tree *tree, int node_index){	if ( tree->node_list == NULL || tree->n_verts <= 0) {		return;	}	bsp_collision_node *node = &tree->node_list[node_index];	vec3d hitpos;	// check the bounding box of this node. if it passes, check left and right children	if ( mc_ray_boundingbox( &node->min, &node->max, &Mc_p0, &Mc_direction, &hitpos ) ) {		if ( !(Mc->flags & MC_CHECK_RAY) && (vm_vec_dist(&hitpos, &Mc_p0) > Mc_mag) ) {			// The ray isn't long enough to intersect the bounding box			return;		}		if ( node->leaf >= 0 ) {			model_collide_bsp_poly(tree, node->leaf);		} else {			if ( node->back >= 0 ) model_collide_bsp(tree, node->back);			if ( node->front >= 0 ) model_collide_bsp(tree, node->front);		}	}}

//.........这里部分代码省略.........			}			vm_vec_sub( &delta_x, &obj_weapon->pos, &other->pos );			laser_vel = obj_weapon->phys_info.vel;			// vm_vec_copy_scale( &laser_vel, &weapon->orient.vec.fvec, max_vel_weapon );			delta_t = (other->radius + 10.0f) / max_vel_other;		// time to get from center to radius of other obj			delta_x_dot_vl = vm_vec_dotprod( &delta_x, &laser_vel );			a = max_vel_weapon*max_vel_weapon - max_vel_other*max_vel_other;			b = 2.0f * (delta_x_dot_vl - max_vel_other*max_vel_other*delta_t);			c = vm_vec_mag_squared( &delta_x ) - max_vel_other*max_vel_other*delta_t*delta_t;			float discriminant = b*b - 4.0f*a*c;			if ( discriminant < 0) {				// never hit				return 1;			} else {				root = fl_sqrt( discriminant );				root1 = (-b + root) / (2.0f * a) * 1000.0f;	// get time in ms				root2 = (-b - root) / (2.0f * a) * 1000.0f;	// get time in ms			}			// standard algorithm			if (max_vel_weapon > max_vel_other) {				// find earliest positive time				if ( root1 > root2 ) {					float temp = root1;					root1 = root2;					root2 = temp;				}				if (root1 > 0) {					earliest_time = root1;				} else if (root2 > 0) {					// root1 < 0 and root2 > 0, so we're inside sphere and next check should be next frame					current_pair->next_check_time = timestamp(0);	// check next time					return 0;				} else {					// both times negative, so never collides					return 1;				}			}			// need to modify it for weapons that are slower than ships			else {				if (root2 > 0) {					earliest_time = root2;				} else {					current_pair->next_check_time = timestamp(0);					return 0;				}			}			// check if possible collision occurs after weapon expires			if ( earliest_time > 1000*wp->lifeleft )				return 1;			// Allow one worst case frametime to elapse (~5 fps)			earliest_time -= 200.0f;			if (earliest_time > 100) {				current_pair->next_check_time = timestamp( fl2i(earliest_time) );				return 0;			} else {				current_pair->next_check_time = timestamp(0);	// check next time				return 0;			}		} else {			float dist, max_vel, time;			max_vel = max_vel_weapon + max_vel_other;			// suggest that fudge factor for other radius be changed to other_radius + const (~10)			dist = vm_vec_dist( &other->pos, &obj_weapon->pos ) - (other->radius + 10.0f);			if ( dist > 0.0f )	{				time = (dist*1000.0f) / max_vel;				int time_ms = fl2i(time);				// check if possible collision occurs after weapon expires				if ( time_ms > 1000*wp->lifeleft )					return 1;				time_ms -= 200;	// Allow at least one worst case frametime to elapse (~5 fps)										if ( time_ms > 100 )	{		// If it takes longer than 1/10th of a second, then delay it					current_pair->next_check_time = timestamp(time_ms);					//mprintf(( "Delaying %d ms/n", time_ms ));					return 0;				}			}			current_pair->next_check_time = timestamp(0);	// check next time		}	}	return 0;}

//.........这里部分代码省略.........	//	}	//}		// only check debris:weapon collisions for player	if (check_collision == collide_debris_weapon) {		// weapon is B		if ( !(Weapon_info[Weapons[B->instance].weapon_info_index].wi_flags & WIF_TURNS) ) {		// check for dumbfire weapon			// check if debris is behind laser			float vdot;			if (Weapon_info[Weapons[B->instance].weapon_info_index].subtype == WP_LASER) {				vec3d velocity_rel_weapon;				vm_vec_sub(&velocity_rel_weapon, &B->phys_info.vel, &A->phys_info.vel);				vdot = -vm_vec_dot(&velocity_rel_weapon, &B->orient.vec.fvec);			} else {				vdot = vm_vec_dot( &A->phys_info.vel, &B->phys_info.vel);			}			if ( vdot <= 0.0f )	{				// They're heading in opposite directions...				// check their positions				vec3d weapon2other;				vm_vec_sub( &weapon2other, &A->pos, &B->pos );				float pdot = vm_vec_dot( &B->orient.vec.fvec, &weapon2other );				if ( pdot <= -A->radius )	{					// The other object is behind the weapon by more than					// its radius, so it will never hit...					return;				}			}			// check dist vs. dist moved during weapon lifetime			vec3d delta_v;			vm_vec_sub(&delta_v, &B->phys_info.vel, &A->phys_info.vel);			if (vm_vec_dist_squared(&A->pos, &B->pos) > (vm_vec_mag_squared(&delta_v)*Weapons[B->instance].lifeleft*Weapons[B->instance].lifeleft)) {				return;			}			// for nonplayer ships, only create collision pair if close enough			if ( (B->parent >= 0) && !(Objects[B->parent].flags & OF_PLAYER_SHIP) && (vm_vec_dist(&B->pos, &A->pos) < (4.0f*A->radius + 200.0f)) )				return;		}	}	// don't check same team laser:ship collisions on small ships if not player	if (check_collision == collide_ship_weapon) {		// weapon is B		if ( (B->parent >= 0)			&& !(Objects[B->parent].flags & OF_PLAYER_SHIP)			&& (Ships[Objects[B->parent].instance].team == Ships[A->instance].team) 			&& (Ship_info[Ships[A->instance].ship_info_index].flags & SIF_SMALL_SHIP) 			&& (Weapon_info[Weapons[B->instance].weapon_info_index].subtype == WP_LASER) ) {			pairs_not_created++;			return;		}	}	if ( !check_collision ) return;	Pairs_created++;	// At this point, we have determined that collisions between	// these two should be checked, so add the pair to the	// collision pair list.	if ( pair_free_list.next == NULL )	{		nprintf(( "collision", "Out of object pairs!! Not all collisions will work!/n" ));		return;

//.........这里部分代码省略.........			collision_info->next_check_time = timestamp(0);		}	} else {		collision_info->a = A;		collision_info->b = B;		collision_info->signature_a = A->signature;		collision_info->signature_b = B->signature;		collision_info->initialized = true;		collision_info->next_check_time = timestamp(0);	}	if ( valid &&  A->type != OBJ_BEAM ) {		// if this signature is valid, make the necessary checks to see if we need to collide check		if ( collision_info->next_check_time == -1 ) {			return;		} else {			if ( !timestamp_elapsed(collision_info->next_check_time) ) {				return;			}		}	} else {		//if ( A->type == OBJ_BEAM ) {			//if(beam_collide_early_out(A, B)){				//collision_info->next_check_time = -1;				//return;			//}		//}		// only check debris:weapon collisions for player		if (check_collision == collide_debris_weapon) {			// weapon is B			if ( !(Weapon_info[Weapons[B->instance].weapon_info_index].wi_flags & WIF_TURNS) ) {				// check for dumbfire weapon				// check if debris is behind laser				float vdot;				if (Weapon_info[Weapons[B->instance].weapon_info_index].subtype == WP_LASER) {					vec3d velocity_rel_weapon;					vm_vec_sub(&velocity_rel_weapon, &B->phys_info.vel, &A->phys_info.vel);					vdot = -vm_vec_dot(&velocity_rel_weapon, &B->orient.vec.fvec);				} else {					vdot = vm_vec_dot( &A->phys_info.vel, &B->phys_info.vel);				}				if ( vdot <= 0.0f )	{					// They're heading in opposite directions...					// check their positions					vec3d weapon2other;					vm_vec_sub( &weapon2other, &A->pos, &B->pos );					float pdot = vm_vec_dot( &B->orient.vec.fvec, &weapon2other );					if ( pdot <= -A->radius )	{						// The other object is behind the weapon by more than						// its radius, so it will never hit...						collision_info->next_check_time = -1;						return;					}				}				// check dist vs. dist moved during weapon lifetime				vec3d delta_v;				vm_vec_sub(&delta_v, &B->phys_info.vel, &A->phys_info.vel);				if (vm_vec_dist_squared(&A->pos, &B->pos) > (vm_vec_mag_squared(&delta_v)*Weapons[B->instance].lifeleft*Weapons[B->instance].lifeleft)) {					collision_info->next_check_time = -1;					return;				}				// for nonplayer ships, only create collision pair if close enough				if ( (B->parent >= 0) && !(Objects[B->parent].flags & OF_PLAYER_SHIP) && (vm_vec_dist(&B->pos, &A->pos) < (4.0f*A->radius + 200.0f)) ) {					collision_info->next_check_time = -1;					return;				}			}		}		// don't check same team laser:ship collisions on small ships if not player		if (check_collision == collide_ship_weapon) {			// weapon is B			if ( (B->parent >= 0)				&& !(Objects[B->parent].flags & OF_PLAYER_SHIP)				&& (Ships[Objects[B->parent].instance].team == Ships[A->instance].team) 				&& (Ship_info[Ships[A->instance].ship_info_index].flags & SIF_SMALL_SHIP) 				&& (Weapon_info[Weapons[B->instance].weapon_info_index].subtype == WP_LASER) ) {				collision_info->next_check_time = -1;				return;			}		}	}	obj_pair new_pair;		new_pair.a = A;	new_pair.b = B;	new_pair.check_collision = check_collision;	new_pair.next_check_time = collision_info->next_check_time;	if ( check_collision(&new_pair) ) {		// don't have to check ever again		collision_info->next_check_time = -1;	} else {		collision_info->next_check_time = new_pair.next_check_time;	}}

void radar_plot_object( object *objp )	{	vector	pos, tempv;	float		dist, rscale, zdist, max_radar_dist;	int		xpos, ypos, color=0;	vector	*world_pos = &objp->pos;		float		awacs_level;	// don't process anything here.  Somehow, a jumpnode object caused this function	// to get entered on server side.	if( Game_mode & GM_STANDALONE_SERVER ){		return;	}	// multiplayer clients ingame joining should skip this function	if ( MULTIPLAYER_CLIENT && (Net_player->flags & NETINFO_FLAG_INGAME_JOIN) ){		return;	}	// get team-wide awacs level for the object if not ship	int ship_is_visible = 0;	if (objp->type == OBJ_SHIP) {		if (Player_ship != NULL) {			if (ship_is_visible_by_team(objp->instance, Player_ship->team)) {				ship_is_visible = 1;			}		}	}	// only check awacs level if ship is not visible by team	awacs_level = 1.5f;	if (Player_ship != NULL && !ship_is_visible) {		awacs_level = awacs_get_level(objp, Player_ship);	}	// if the awacs level is unviewable - bail	if(awacs_level < 0.0f && !See_all){		return;	}	// Apply object type filters		switch ( objp->type ) {	case OBJ_SHIP:		// Place to cull ships, such as NavBuoys				break;			case OBJ_JUMP_NODE:		// filter jump nodes here if required		break;	case OBJ_WEAPON: {		// if not a bomb, return		if ( !(Weapon_info[Weapons[objp->instance].weapon_info_index].wi_flags & WIF_BOMB) ) {			return;		}		// if bomb is on same team as player, return		if ( (obj_team(objp) == Player_ship->team) && (Player_ship->team != TEAM_TRAITOR) ) {			return;		}		break;	}	default:		return;			// if any other kind of object, don't want to show on radar		break;	} // end switch		// JAS -- new way of getting the rotated point that doesn't require this to be	// in a g3_start_frame/end_frame block.	vm_vec_sub(&tempv,world_pos,&Player_obj->pos);	vm_vec_rotate( &pos, &tempv, &Player_obj->orient );	// Apply range filter	dist = vm_vec_dist(world_pos, &Player_obj->pos);	max_radar_dist = Radar_ranges[HUD_config.rp_dist];	if ( dist > max_radar_dist ){		return;	}	if ( dist < pos.xyz.z ) {		rscale = 0.0f;	} else {		rscale = (float) acos( pos.xyz.z/dist ) / 3.14159f;		//2.0f;	}	zdist = fl_sqrt( (pos.xyz.x*pos.xyz.x)+(pos.xyz.y*pos.xyz.y) );	float new_x_dist, clipped_x_dist;	float new_y_dist, clipped_y_dist;	if (zdist < 0.01f ) {		new_x_dist = 0.0f;		new_y_dist = 0.0f;	}	else {		new_x_dist = (pos.xyz.x/zdist) * rscale * radx;		new_y_dist = (pos.xyz.y/zdist) * rscale * rady;//.........这里部分代码省略.........

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);//.........这里部分代码省略.........

/** * Checks asteroid-ship collisions.   * @param pair obj_pair pointer to the two objects. pair->a is asteroid and pair->b is ship. * @return 1 if all future collisions between these can be ignored */int collide_asteroid_ship( obj_pair * pair ){	if (!Asteroids_enabled)		return 0;	float		dist;	object	*pasteroid = pair->a;	object	*pship = pair->b;	// Don't check collisions for warping out player	if ( Player->control_mode != PCM_NORMAL )	{		if ( pship == Player_obj ) return 0;	}	if (pasteroid->hull_strength < 0.0f)		return 0;	Assert( pasteroid->type == OBJ_ASTEROID );	Assert( pship->type == OBJ_SHIP );	dist = vm_vec_dist( &pasteroid->pos, &pship->pos );	if ( dist < pasteroid->radius + pship->radius )	{		int hit;		vec3d	hitpos;		// create and initialize ship_ship_hit_info struct		collision_info_struct asteroid_hit_info;		init_collision_info_struct(&asteroid_hit_info);		if ( pasteroid->phys_info.mass > pship->phys_info.mass ) {			asteroid_hit_info.heavy = pasteroid;			asteroid_hit_info.light = pship;		} else {			asteroid_hit_info.heavy = pship;			asteroid_hit_info.light = pasteroid;		}		hit = asteroid_check_collision(pasteroid, pship, &hitpos, &asteroid_hit_info );		if ( hit )		{			//Scripting support (WMC)			Script_system.SetHookObjects(4, "Ship", pship, "Asteroid", pasteroid, "Self",pship, "Object", pasteroid);			bool ship_override = Script_system.IsConditionOverride(CHA_COLLIDEASTEROID, pship);			Script_system.SetHookObjects(2, "Self",pasteroid, "Object", pship);			bool asteroid_override = Script_system.IsConditionOverride(CHA_COLLIDESHIP, pasteroid);			if(!ship_override && !asteroid_override)			{				float		ship_damage;					float		asteroid_damage;				vec3d asteroid_vel = pasteroid->phys_info.vel;				// do collision physics				calculate_ship_ship_collision_physics( &asteroid_hit_info );				if ( asteroid_hit_info.impulse < 0.5f )					return 0;				// limit damage from impulse by making max impulse (for damage) 2*m*v_max_relative				float max_ship_impulse = (2.0f*pship->phys_info.max_vel.xyz.z+vm_vec_mag_quick(&asteroid_vel)) * 					(pship->phys_info.mass*pasteroid->phys_info.mass) / (pship->phys_info.mass + pasteroid->phys_info.mass);				if (asteroid_hit_info.impulse > max_ship_impulse) {					ship_damage = 0.001f * max_ship_impulse;				} else {					ship_damage = 0.001f * asteroid_hit_info.impulse;	//	Cut collision-based damage in half.				}				//	Decrease heavy damage by 2x.				if (ship_damage > 5.0f)					ship_damage = 5.0f + (ship_damage - 5.0f)/2.0f;				if ((ship_damage > 500.0f) && (ship_damage > Ships[pship->instance].ship_max_hull_strength/8.0f)) {					ship_damage = Ships[pship->instance].ship_max_hull_strength/8.0f;					nprintf(("AI", "Pinning damage to %s from asteroid at %7.3f (%7.3f percent)/n", Ships[pship->instance].ship_name, ship_damage, 100.0f * ship_damage/Ships[pship->instance].ship_max_hull_strength));				}				//	Decrease damage during warp out because it's annoying when your escoree dies during warp out.				if (Ai_info[Ships[pship->instance].ai_index].mode == AIM_WARP_OUT)					ship_damage /= 3.0f;				// calculate asteroid damage and set asteroid damage to greater or asteroid and ship				// asteroid damage is needed since we can really whack some small asteroid with afterburner and not do				// significant damage to ship but the asteroid goes off faster than afterburner speed.				asteroid_damage = asteroid_hit_info.impulse/pasteroid->phys_info.mass;	// ie, delta velocity of asteroid				asteroid_damage = (asteroid_damage > ship_damage) ? asteroid_damage : ship_damage;				// apply damage to asteroid				asteroid_hit( pasteroid, pship, &hitpos, asteroid_damage);		// speed => damage				//extern fix Missiontime;				int quadrant_num;//.........这里部分代码省略.........

//.........这里部分代码省略.........				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	}}

/** * Checks debris-ship collisions.   * @param pair obj_pair pointer to the two objects. pair->a is debris and pair->b is ship. * @return 1 if all future collisions between these can be ignored */int collide_debris_ship( obj_pair * pair ){	float dist;	object *pdebris = pair->a;	object *pship = pair->b;	// Don't check collisions for warping out player	if ( Player->control_mode != PCM_NORMAL )	{		if ( pship == Player_obj )			return 0;	}	Assert( pdebris->type == OBJ_DEBRIS );	Assert( pship->type == OBJ_SHIP );	// don't check collision if it's our own debris and we are dying	if ( (pdebris->parent == OBJ_INDEX(pship)) && (Ships[pship->instance].flags[Ship::Ship_Flags::Dying]) )		return 0;	dist = vm_vec_dist( &pdebris->pos, &pship->pos );	if ( dist < pdebris->radius + pship->radius )	{		int hit;		vec3d	hitpos;		// create and initialize ship_ship_hit_info struct		collision_info_struct debris_hit_info;		init_collision_info_struct(&debris_hit_info);		if ( pdebris->phys_info.mass > pship->phys_info.mass ) {			debris_hit_info.heavy = pdebris;			debris_hit_info.light = pship;		} else {			debris_hit_info.heavy = pship;			debris_hit_info.light = pdebris;		}		hit = debris_check_collision(pdebris, pship, &hitpos, &debris_hit_info );		if ( hit )		{			Script_system.SetHookObjects(4, "Ship", pship, "Debris", pdebris, "Self", pship, "Object", pdebris);			bool ship_override = Script_system.IsConditionOverride(CHA_COLLIDEDEBRIS, pship);			Script_system.SetHookObjects(2, "Self",pdebris, "Object", pship);			bool debris_override = Script_system.IsConditionOverride(CHA_COLLIDESHIP, pdebris);			if(!ship_override && !debris_override)			{				float		ship_damage;					float		debris_damage;				// do collision physics				calculate_ship_ship_collision_physics( &debris_hit_info );				if ( debris_hit_info.impulse < 0.5f )					return 0;				// calculate ship damage				ship_damage = 0.005f * debris_hit_info.impulse;	//	Cut collision-based damage in half.				//	Decrease heavy damage by 2x.				if (ship_damage > 5.0f)					ship_damage = 5.0f + (ship_damage - 5.0f)/2.0f;				// calculate debris damage and set debris damage to greater or debris and ship				// debris damage is needed since we can really whack some small debris with afterburner and not do				// significant damage to ship but the debris goes off faster than afterburner speed.				debris_damage = debris_hit_info.impulse/pdebris->phys_info.mass;	// ie, delta velocity of debris				debris_damage = (debris_damage > ship_damage) ? debris_damage : ship_damage;				// modify ship damage by debris damage multiplier				ship_damage *= Debris[pdebris->instance].damage_mult;				// supercaps cap damage at 10-20% max hull ship damage				if (Ship_info[Ships[pship->instance].ship_info_index].flags[Ship::Info_Flags::Supercap]) {					float cap_percent_damage = frand_range(0.1f, 0.2f);					ship_damage = MIN(ship_damage, cap_percent_damage * Ships[pship->instance].ship_max_hull_strength);				}				// apply damage to debris				debris_hit( pdebris, pship, &hitpos, debris_damage);		// speed => damage				int quadrant_num, apply_ship_damage;				// apply damage to ship unless 1) debris is from ship				apply_ship_damage = !(pship->signature == pdebris->parent_sig);				if ( debris_hit_info.heavy == pship ) {					quadrant_num = get_ship_quadrant_from_global(&hitpos, pship);					if ((pship->flags[Object::Object_Flags::No_shields]) || !ship_is_shield_up(pship, quadrant_num) ) {						quadrant_num = -1;					}					if (apply_ship_damage) {						ship_apply_local_damage(debris_hit_info.heavy, debris_hit_info.light, &hitpos, ship_damage, quadrant_num, CREATE_SPARKS, debris_hit_info.submodel_num);					}				} else {					// don't draw sparks using sphere hit position					if (apply_ship_damage) {						ship_apply_local_damage(debris_hit_info.light, debris_hit_info.heavy, &hitpos, ship_damage, MISS_SHIELDS, NO_SPARKS);					}//.........这里部分代码省略.........