double * xyz_to_llh( ellipsoid *el, double xyz[3], double llh[3] )
{
double bsac,p,slt,clt,lt0,ln,lt,hgt;
int it;
ln = atan2( xyz[1], xyz[0] );
p = _hypot( xyz[0], xyz[1] );
lt = atan2( el->a2*xyz[2], el->b2*p );
it = 0;
do
{
lt0 = lt;
slt = sin(lt);
clt = cos(lt);
bsac = _hypot( el->b*slt, el->a*clt );
lt = atan2( xyz[2]+slt*el->a2b2/bsac, p );
if ( fabs(lt-lt0) < 1.0e-10 ) break;
}
while( it++ < 10);
hgt = p*clt+xyz[2]*slt - bsac;
llh[CRD_LAT] = lt;
llh[CRD_LON] = ln;
llh[CRD_HGT] = hgt;
return &llh[0];
}
void Hrtf::get_kemar_data(kemar_ptr & kemar_data, int & elev_n, const v3f &pos) {
kemar_data = 0;
elev_n = 0;
if (pos.is0())
return;
#ifdef _WINDOWS
float len = (float)_hypot(pos.x, pos.y);
#else
float len = (float)hypot(pos.x, pos.y);
#endif
int elev_gr = (int)(180 * atan2f(pos.z, len) / (float)M_PI);
//LOG_DEBUG(("elev = %d (%g %g %g)", elev_gr, pos.x, pos.y, pos.z));
for(size_t i = 0; i < KemarElevationCount; ++i)
{
const kemar_elevation_data &elev = ::kemar_data[i];
if (elev_gr < elev.elevation + KemarElevationStep / 2)
{
//LOG_DEBUG(("used elevation %d", elev.elevation));
kemar_data = elev.data;
elev_n = elev.samples;
break;
}
}
}
// hud_calculate_lock_start_pos() will determine where to draw the starting location of the lock
// indicator. It does this by picking a location that is Lock_start_dist pixels away from the current
// target (in 2D). This is accomplished by finding the endpoint of a line that passes through the
// origin, and connects the target and lock indicator postion (and has a magnitude of Lock_start_dist)
void hud_calculate_lock_start_pos()
{
double hypotenuse;
double delta_y;
double delta_x;
double target_mag, target_x, target_y;
delta_x = Player->current_target_sx - gr_screen.clip_center_x;
delta_y = Player->current_target_sy - gr_screen.clip_center_y;
if ( (delta_x == 0.0) && (delta_y == 0.0) ) {
Players[Player_num].lock_indicator_start_x = fl2i(gr_screen.clip_center_x + Lock_start_dist);
Players[Player_num].lock_indicator_start_y = fl2i(gr_screen.clip_center_y);
return;
}
hypotenuse = _hypot(delta_y, delta_x);
if (hypotenuse >= Lock_start_dist) {
Players[Player_num].lock_indicator_start_x = fl2i(gr_screen.clip_center_x);
Players[Player_num].lock_indicator_start_y = fl2i(gr_screen.clip_center_y);
return;
}
target_mag = Lock_start_dist - hypotenuse;
target_x = target_mag * (delta_x / hypotenuse);
target_y = target_mag * (delta_y / hypotenuse);
Players[Player_num].lock_indicator_start_x = fl2i(gr_screen.clip_center_x - target_x);
Players[Player_num].lock_indicator_start_y = fl2i(gr_screen.clip_center_y - target_y);
CLAMP(Players[Player_num].lock_indicator_start_x, gr_screen.clip_left, gr_screen.clip_right);
CLAMP(Players[Player_num].lock_indicator_start_y, gr_screen.clip_top, gr_screen.clip_bottom);
}
void gnomic_geod( GnomicProjection *gp, double ce, double cn, double *lon, double *lat)
{
double psi, u, a1, a2, a3, a4, root, dlam, csth, snth;
ce -= gp->fe;
cn -= gp->fn;
if( ce == 0.0 && cn == 0.0 )
{
*lat = gp->orglat;
*lon = gp->orglon;
return;
}
csth=_hypot(cn,ce);
snth=cn/csth;
csth=ce/csth;
if( ce == 0.0 )
{
psi=atan(cn/(gp->a*snth));
}
else
{
psi=atan(ce/(gp->a*csth));
}
u=sin(psi);
a4=cos(psi);
a1 = a4*a4;
a2=gp->csolt*gp->csolt * (csth*csth * u*u - 1.0);
a3 = gp->snolt*gp->snolt*a1;
a4 *= gp->snolt;
u *= csth;
root=sqrt(a3-a2-a1);
if( cn > 0.0 )
{
*lat = asin( a4 + root );
}
else
{
*lat = asin( a4 - root );
}
dlam = asin(u/cos(*lat));
dlam += gp->orglon;
while( dlam > PI ) dlam -= TWOPI;
while( dlam < -PI ) dlam += TWOPI;
*lon = dlam;
}
void main(void)
{
double fResult;
double a1, a2;
a1 = 1.7e+308;
a2 = 1.7e+308;
fResult = _hypot(a1, a2);
printf("_hypot(%e, %e) = %.4e\n", a1, a2, fResult);
//A floating point reset causes the next calculation to pass.
//_fpreset();
a1 = -9.6412221495223150e+002;
a2 = -9.5463338659229547e+007;
fResult = _hypot(a1, a2);
printf("_hypot(%e, %e) = %.4e\n", a1, a2, fResult);
}
double hypot (double x, double y)
{
int x_class = fpclassify (x);
int y_class = fpclassify (y);
if (x_class == FP_INFINITE || y_class == FP_INFINITE)
return __FLT_HUGE_VAL;
else if (x_class == FP_NAN || y_class == FP_NAN)
return __FLT_NAN;
return _hypot (x, y);
}
int
main(void)
{
printf("hypot(3, 4) =\t\t\t %25.17e\n", _hypot(3., 4.));
printf("hypot(3*10^150, 4*10^150) =\t %25.17g\n", _hypot(3.e+150, 4.e+150));
printf("hypot(3*10^306, 4*10^306) =\t %25.17g\n", _hypot(3.e+306, 4.e+306));
printf("hypot(3*10^-320, 4*10^-320) =\t %25.17g\n",_hypot(3.e-320, 4.e-320));
printf("hypot(0.7*DBL_MAX, 0.7*DBL_MAX) =%25.17g\n",_hypot(0.7*DBL_MAX, 0.7*DBL_MAX));
printf("hypot(DBL_MAX, 1.0) =\t\t %25.17g\n", _hypot(DBL_MAX, 1.0));
printf("hypot(1.0, DBL_MAX) =\t\t %25.17g\n", _hypot(1.0, DBL_MAX));
printf("hypot(0.0, DBL_MAX) =\t\t %25.17g\n", _hypot(0.0, DBL_MAX));
return 0;
}
bool INSTHYPOT::execute(void)
{
bool result= false;
VMREGTYPE val1,val2,sum= 0;
if(machine.pop(val1)
&& machine.pop(val2))
{
VMFLOAT f1= ffromi(val1);
VMFLOAT f2= ffromi(val2);
f1=(VMFLOAT) _hypot(f1,f2);
sum= ifromf(f1);
result= machine.push(sum);
}
return result;
}
void HudGaugeRadarStd::plotBlip(blip *b, int *x, int *y)
{
float zdist, rscale;
vec3d *pos = &b->position;
if (b->dist < pos->xyz.z) {
rscale = 0.0f;
} else {
rscale = (float) acos(pos->xyz.z / b->dist) / PI; //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 * (Radar_radius[0]/2.0f);
new_y_dist = (pos->xyz.y / zdist) * rscale * (Radar_radius[1]/2.0f);
// force new_x_dist and new_y_dist to be inside the radar
float hypotenuse;
float max_radius;
hypotenuse = (float) _hypot(new_x_dist, new_y_dist);
max_radius = i2fl(Radar_radius[0] - 5);
if (hypotenuse >= max_radius)
{
clipped_x_dist = max_radius * (new_x_dist / hypotenuse);
clipped_y_dist = max_radius * (new_y_dist / hypotenuse);
new_x_dist = clipped_x_dist;
new_y_dist = clipped_y_dist;
}
}
*x = fl2i(position[0] + Radar_center_offsets[0] + new_x_dist);
*y = fl2i(position[1] + Radar_center_offsets[1] - new_y_dist);
}
float complex CLANG_PORT_DECL(csqrtf) (float complex Z)
{
float complex Res;
float r;
float x = __real__ Z;
float y = __imag__ Z;
if (y == 0.0f)
{
if (x < 0.0f)
{
__real__ Res = 0.0f;
__imag__ Res = sqrtf (-x);
}
else
{
__real__ Res = sqrtf (x);
__imag__ Res = 0.0f;
}
}
else if (x == 0.0f)
{
r = sqrtf(0.5f * fabsf (y));
__real__ Res = r;
__imag__ Res = y > 0 ? r : -r;
}
else
{
float t = sqrtf (2 * (_hypot (__real__ Z, __imag__ Z) + fabsf (x)));
float u = t / 2.0f;
if ( x > 0.0f)
{
__real__ Res = u;
__imag__ Res = y / t;
}
else
{
__real__ Res = fabsf (y / t);
__imag__ Res = y < 0 ? -u : u;
}
}
return Res;
}
void PaintClover(HWND hwnd,HRGN hRgnClip, int cxClient, int cyClient)
{
double fAngle, fRadius ;
PAINTSTRUCT ps;
HDC hdc = BeginPaint (hwnd, &ps) ;
SetViewportOrgEx (hdc, cxClient / 2, cyClient / 2, NULL) ;
SelectClipRgn (hdc, hRgnClip) ;
fRadius = _hypot (cxClient / 2.0, cyClient / 2.0) ;
for (fAngle = 0.0 ; fAngle < TWOPI ; fAngle += TWOPI / 360)
{
MoveToEx (hdc, 0, 0, NULL) ;
LineTo (hdc, (int) ( fRadius * cos (fAngle) + 0.5),
(int) (-fRadius * sin (fAngle) + 0.5)) ;
}
EndPaint (hwnd, &ps) ;
}
// hud_calculate_lock_start_pos() will determine where to draw the starting location of the lock
// indicator. It does this by picking a location that is Lock_start_dist pixels away from the current
// target (in 2D). This is accomplished by finding the endpoint of a line that passes through the
// origin, and connects the target and lock indicator postion (and has a magnitude of Lock_start_dist)
void hud_calculate_lock_start_pos()
{
double hypotenuse;
double delta_y;
double delta_x;
double target_mag, target_x, target_y;
delta_x = Player->current_target_sx - SCREEN_CENTER_X;
delta_y = Player->current_target_sy - SCREEN_CENTER_Y;
if (!delta_x && !delta_y) {
Players[Player_num].lock_indicator_start_x = fl2i(SCREEN_CENTER_X + Lock_start_dist);
Players[Player_num].lock_indicator_start_y = fl2i(SCREEN_CENTER_Y);
return;
}
hypotenuse = _hypot(delta_y, delta_x);
if (hypotenuse >= Lock_start_dist) {
Players[Player_num].lock_indicator_start_x = fl2i(SCREEN_CENTER_X);
Players[Player_num].lock_indicator_start_y = fl2i(SCREEN_CENTER_Y);
return;
}
target_mag = Lock_start_dist - hypotenuse;
target_x = target_mag * (delta_x / hypotenuse);
target_y = target_mag * (delta_y / hypotenuse);
Players[Player_num].lock_indicator_start_x = fl2i(SCREEN_CENTER_X - target_x);
Players[Player_num].lock_indicator_start_y = fl2i(SCREEN_CENTER_Y - target_y);
if (Players[Player_num].lock_indicator_start_x > gr_screen.clip_right)
Players[Player_num].lock_indicator_start_x = gr_screen.clip_right;
if (Players[Player_num].lock_indicator_start_y > gr_screen.clip_bottom)
Players[Player_num].lock_indicator_start_y = gr_screen.clip_bottom;
if (Players[Player_num].lock_indicator_start_x < gr_screen.clip_left)
Players[Player_num].lock_indicator_start_x = gr_screen.clip_left;
if (Players[Player_num].lock_indicator_start_y < gr_screen.clip_top)
Players[Player_num].lock_indicator_start_y = gr_screen.clip_top;
}
void xXY_Brg_Rng(double X_1, double Y_1, double X_2, double Y_2, double *Bearing, double *Range)
{
double Rad_Bearing;
double Rad_360 = (2 * PI);
double y = (X_2 - X_1);
double x = (Y_2 - Y_1);
if (fabs(x)>0.00000001 && fabs(y)>0.00000001){
Rad_Bearing = atan2(y, x);
} else {
Rad_Bearing = 0;
}
if (Rad_Bearing < 0) {
Rad_Bearing += Rad_360;
}
*Bearing = (double)(RAD_TO_DEG * Rad_Bearing);
*Range = (double) (_hypot((double) (X_2 - X_1), (double) (Y_2 - Y_1)));
}
// Convert an orientation matrix to a pitch/yaw/roll vector. Based on what
// Freelancer does for the save game.
void Matrix_to_Vector( const Matrix& mat, Vector& vec )
{
Vector x = { mat.data[0][0], mat.data[1][0], mat.data[2][0] };
Vector y = { mat.data[0][1], mat.data[1][1], mat.data[2][1] };
Vector z = { mat.data[0][2], mat.data[1][2], mat.data[2][2] };
float h = (float)_hypot( x.x, x.y );
if (h > 1/524288.0f)
{
vec.x = degrees( atan2f( y.z, z.z ) );
vec.y = degrees( atan2f( -x.z, h ) );
vec.z = degrees( atan2f( x.y, x.x ) );
}
else
{
vec.x = degrees( atan2f( -z.y, y.y ) );
vec.y = degrees( atan2f( -x.z, h ) );
vec.z = 0;
}
}
double * llh_to_xyz( ellipsoid *el, double llh[3], double xyz[3],
double *dEdLn, double *dNdLt )
{
double bsac,p,clt,slt,cln,sln,hgt;
clt = cos(llh[CRD_LAT]);
slt = sin(llh[CRD_LAT]);
cln = cos(llh[CRD_LON]);
sln = sin(llh[CRD_LON]);
hgt = llh[CRD_HGT];
bsac = _hypot( el->b*slt, el->a*clt );
p = el->a2*clt/bsac + hgt*clt;
xyz[0] = p*cln;
xyz[1] = p*sln;
xyz[2] = el->b2*slt/bsac + llh[CRD_HGT]*slt;
if( dEdLn ) *dEdLn = p;
if( dNdLt ) *dNdLt = (el->a2 * el->b2)/(bsac*bsac*bsac) + hgt;
return &xyz[0];
}
// Convert an orientation matrix to a pitch/yaw/roll vector. Based on what
// Freelancer does for the save game.
Vector MatrixToEuler(const Matrix& mat)
{
Vector x = { mat.data[0][0], mat.data[1][0], mat.data[2][0] };
Vector y = { mat.data[0][1], mat.data[1][1], mat.data[2][1] };
Vector z = { mat.data[0][2], mat.data[1][2], mat.data[2][2] };
Vector vec;
float h = (float)_hypot( x.x, x.y );
if (h > 1/524288.0f)
{
vec.x = degrees( atan2f( y.z, z.z ) );
vec.y = degrees( atan2f( -x.z, h ) );
vec.z = degrees( atan2f( x.y, x.x ) );
}
else
{
vec.x = degrees( atan2f( -z.y, y.y ) );
vec.y = degrees( atan2f( -x.z, h ) );
vec.z = 0;
}
return vec;
}
inline float Distance(const POINT& p1, const POINT& p2)
{
return float(_hypot(float(p1.x-p2.x), float(p1.y-p2.y)));
}
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;
// force new_x_dist and new_y_dist to be inside the radar
float hypotenuse;
float max_radius;
hypotenuse = (float)_hypot(new_x_dist, new_y_dist);
max_radius = i2fl(Radar_radius[gr_screen.res][0] - 5);
if (hypotenuse >= (max_radius) ) {
clipped_x_dist = max_radius * (new_x_dist / hypotenuse);
clipped_y_dist = max_radius * (new_y_dist / hypotenuse);
new_x_dist = clipped_x_dist;
new_y_dist = clipped_y_dist;
}
}
xpos = fl2i( Radar_center[gr_screen.res][0] + new_x_dist );
ypos = fl2i( Radar_center[gr_screen.res][1] - new_y_dist );
color = radar_blip_color(objp);
// Determine the distance at which we will dim the radar blip
if ( timestamp_elapsed(Radar_calc_dim_dist_timer) ) {
Radar_calc_dim_dist_timer=timestamp(1000);
Radar_dim_range = player_farthest_weapon_range();
if ( Radar_dim_range <= 0 ) {
Radar_dim_range=1500.0f;
}
}
blip *b;
int blip_dim=0;
if ( dist > Radar_dim_range ) {
blip_dim=1;
}
if ( N_blips >= MAX_BLIPS ) {
// out of blips, don't plot
Int3();
return;
}
b = &Blips[N_blips];
b->flags=0;
// flag the blip as a current target if it is
if (OBJ_INDEX(objp) == Player_ai->target_objnum) {
b->flags |= BLIP_CURRENT_TARGET;
blip_dim = 0;
}
if ( blip_dim ) {
list_append( &Blip_dim_list[color], b );
} else {
list_append( &Blip_bright_list[color], b );
}
b->x = xpos;
b->y = ypos;
// see if blip should be drawn distorted
if (objp->type == OBJ_SHIP) {
// ships specifically hidden from sensors
if ( Ships[objp->instance].flags & SF_HIDDEN_FROM_SENSORS ) {
b->flags |= BLIP_DRAW_DISTORTED;
}
// determine if its AWACS distorted
if ( awacs_level < 1.0f ){
b->flags |= BLIP_DRAW_DISTORTED;
}
}
N_blips++;
}
static inline double hypot(double x, double y) throw()
{ return _hypot(x, y); }
double hypot(double x, double y)
{
return _hypot(x, y);
}
//_____________________________________________________________________________
CPolarCoordinate::CPolarCoordinate(const CPoint2d& rectangularCoordinate)
{
m_r = _hypot(rectangularCoordinate.x,rectangularCoordinate.y);
m_theta = atan2(rectangularCoordinate.y,rectangularCoordinate.x);
}
// hud_calculate_lock_position() will determine where on the screen to draw the lock
// indicator, and will determine when a lock has occurred. If the lock indicator is not
// on the screen yet, hud_calculate_lock_start_pos() is called to pick a starting location
void hud_calculate_lock_position(float frametime)
{
ship_weapon *swp;
weapon_info *wip;
static float pixels_moved_while_locking;
static float pixels_moved_while_degrading;
static int Need_new_start_pos = 0;
static double accumulated_x_pixels, accumulated_y_pixels;
double int_portion;
static float last_dist_to_target;
static int catching_up;
static int maintain_lock_count = 0;
static float catch_up_distance = 0.0f;
double hypotenuse, delta_x, delta_y;
swp = &Player_ship->weapons;
wip = &Weapon_info[swp->secondary_bank_weapons[swp->current_secondary_bank]];
if (Player->target_in_lock_cone) {
if (!Players[Player_num].lock_indicator_visible) {
hud_calculate_lock_start_pos();
last_dist_to_target = 0.0f;
Players[Player_num].lock_indicator_x = Players[Player_num].lock_indicator_start_x;
Players[Player_num].lock_indicator_y = Players[Player_num].lock_indicator_start_y;
Players[Player_num].lock_indicator_visible = 1;
Players[Player_num].lock_time_to_target = i2fl(wip->min_lock_time);
catching_up = 0;
}
Need_new_start_pos = 1;
if (Player_ai->current_target_is_locked) {
Players[Player_num].lock_indicator_x = Player->current_target_sx;
Players[Player_num].lock_indicator_y = Player->current_target_sy;
return;
}
delta_x = Players[Player_num].lock_indicator_x - Player->current_target_sx;
delta_y = Players[Player_num].lock_indicator_y - Player->current_target_sy;
if (!delta_y && !delta_x) {
hypotenuse = 0.0f;
}
else {
hypotenuse = _hypot(delta_y, delta_x);
}
Players[Player_num].lock_dist_to_target = (float)hypotenuse;
if (last_dist_to_target == 0) {
last_dist_to_target = Players[Player_num].lock_dist_to_target;
}
//nprintf(("Alan","dist to target: %.2f\n",Players[Player_num].lock_dist_to_target));
//nprintf(("Alan","last to target: %.2f\n\n",last_dist_to_target));
if (catching_up) {
//nprintf(("Alan","IN CATCH UP MODE catch_up_dist is %.2f\n",catch_up_distance));
if ( Players[Player_num].lock_dist_to_target < catch_up_distance )
catching_up = 0;
}
else {
//nprintf(("Alan","IN NORMAL MODE\n"));
if ( (Players[Player_num].lock_dist_to_target - last_dist_to_target) > 2.0f ) {
catching_up = 1;
catch_up_distance = last_dist_to_target + wip->catchup_pixel_penalty;
}
}
last_dist_to_target = Players[Player_num].lock_dist_to_target;
if (!catching_up) {
Players[Player_num].lock_time_to_target -= frametime;
if (Players[Player_num].lock_time_to_target < 0.0f)
Players[Player_num].lock_time_to_target = 0.0f;
}
float lock_pixels_per_sec;
if (Players[Player_num].lock_time_to_target > 0) {
lock_pixels_per_sec = Players[Player_num].lock_dist_to_target / Players[Player_num].lock_time_to_target;
} else {
lock_pixels_per_sec = i2fl(wip->lock_pixels_per_sec);
}
if (lock_pixels_per_sec > wip->lock_pixels_per_sec) {
lock_pixels_per_sec = i2fl(wip->lock_pixels_per_sec);
}
if (catching_up) {
pixels_moved_while_locking = wip->catchup_pixels_per_sec * frametime;
} else {
pixels_moved_while_locking = lock_pixels_per_sec * frametime;
}
if (delta_x != 0) {
accumulated_x_pixels += pixels_moved_while_locking * delta_x/hypotenuse;
}
if (delta_y != 0) {
accumulated_y_pixels += pixels_moved_while_locking * delta_y/hypotenuse;
}
if (fl_abs(accumulated_x_pixels) > 1.0f) {
modf(accumulated_x_pixels, &int_portion);
Players[Player_num].lock_indicator_x -= (int)int_portion;
if ( fl_abs(Players[Player_num].lock_indicator_x - Player->current_target_sx) < fl_abs(int_portion) )
Players[Player_num].lock_indicator_x = Player->current_target_sx;
accumulated_x_pixels -= int_portion;
}
if (fl_abs(accumulated_y_pixels) > 1.0f) {
modf(accumulated_y_pixels, &int_portion);
Players[Player_num].lock_indicator_y -= (int)int_portion;
if ( fl_abs(Players[Player_num].lock_indicator_y - Player->current_target_sy) < fl_abs(int_portion) )
Players[Player_num].lock_indicator_y = Player->current_target_sy;
accumulated_y_pixels -= int_portion;
}
if ( Missile_track_loop == -1 ) {
Missile_track_loop = snd_play_looping( &Snds[SND_MISSILE_TRACKING], 0.0f , -1, -1);
}
if (!Players[Player_num].lock_time_to_target) {
if ( (Players[Player_num].lock_indicator_x == Player->current_target_sx) && (Players[Player_num].lock_indicator_y == Player->current_target_sy) ) {
if (maintain_lock_count++ > 1) {
Player_ai->current_target_is_locked = 1;
}
} else {
maintain_lock_count = 0;
}
}
} else {
if ( Missile_track_loop > -1 ) {
snd_chg_loop_status(Missile_track_loop, 0);
Missile_track_loop = -1;
}
Player_ai->current_target_is_locked = 0;
if (!Players[Player_num].lock_indicator_visible) {
return;
}
catching_up = 0;
last_dist_to_target = 0.0f;
if (Need_new_start_pos) {
hud_calculate_lock_start_pos();
Need_new_start_pos = 0;
accumulated_x_pixels = 0.0f;
accumulated_y_pixels = 0.0f;
}
delta_x = Players[Player_num].lock_indicator_x - Players[Player_num].lock_indicator_start_x;
delta_y = Players[Player_num].lock_indicator_y - Players[Player_num].lock_indicator_start_y;
if (!delta_y && !delta_x) {
hypotenuse = 0.0f;
}
else {
hypotenuse = _hypot(delta_y, delta_x);
}
Players[Player_num].lock_time_to_target += frametime;
if (Players[Player_num].lock_time_to_target > wip->min_lock_time)
Players[Player_num].lock_time_to_target = i2fl(wip->min_lock_time);
pixels_moved_while_degrading = 2.0f * wip->lock_pixels_per_sec * frametime;
if (delta_x != 0)
accumulated_x_pixels += pixels_moved_while_degrading * delta_x/hypotenuse;
if (delta_y != 0)
accumulated_y_pixels += pixels_moved_while_degrading * delta_y/hypotenuse;
if (fl_abs(accumulated_x_pixels) > 1.0f) {
modf(accumulated_x_pixels, &int_portion);
Players[Player_num].lock_indicator_x -= (int)int_portion;
if ( fl_abs(Players[Player_num].lock_indicator_x - Players[Player_num].lock_indicator_start_x) < fl_abs(int_portion) )
Players[Player_num].lock_indicator_x = Players[Player_num].lock_indicator_start_x;
accumulated_x_pixels -= int_portion;
}
if (fl_abs(accumulated_y_pixels) > 1.0f) {
modf(accumulated_y_pixels, &int_portion);
Players[Player_num].lock_indicator_y -= (int)int_portion;
if ( fl_abs(Players[Player_num].lock_indicator_y - Players[Player_num].lock_indicator_start_y) < fl_abs(int_portion) )
Players[Player_num].lock_indicator_y = Players[Player_num].lock_indicator_start_y;
accumulated_y_pixels -= int_portion;
}
if ( (Players[Player_num].lock_indicator_x == Players[Player_num].lock_indicator_start_x) && (Players[Player_num].lock_indicator_y == Players[Player_num].lock_indicator_start_y) ) {
Players[Player_num].lock_indicator_visible = 0;
}
}
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
static HRGN hRgnClip ;
static int cxClient, cyClient ;
double fAngle, fRadius ;
HCURSOR hCursor ;
HDC hdc ;
HRGN hRgnTemp[6] ; // HRGN just like RECT is a self-defined area.
int i ;
PAINTSTRUCT ps ;
switch (iMsg)
{
// The task of WM_SIZE case is used to create a self-defined region as valid client area.
case WM_SIZE:
cxClient = LOWORD (lParam) ;
cyClient = HIWORD (lParam) ;
hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
ShowCursor (TRUE) ;
if (hRgnClip)
DeleteObject (hRgnClip) ; // delete old region before create a new one.
// The apis below are used to create RGN just like RECT
// other apis including CreateRoundRectRgn & CreatePolygonRgn etc..
// These apis will create region and be ready to be selected, after that the valid client area
// will be changed to the region created instead of tranditional rect area.
hRgnTemp[0] = CreateEllipticRgn (0, cyClient / 3,
cxClient / 2, 2 * cyClient / 3) ;
hRgnTemp[1] = CreateEllipticRgn (cxClient / 2, cyClient / 3,
cxClient, 2 * cyClient / 3) ;
hRgnTemp[2] = CreateEllipticRgn (cxClient / 3, 0,
2 * cxClient / 3, cyClient / 2) ;
hRgnTemp[3] = CreateEllipticRgn (cxClient / 3, cyClient / 2,
2 * cxClient / 3, cyClient) ;
hRgnTemp[4] = CreateRectRgn (0, 0, 1, 1) ;
hRgnTemp[5] = CreateRectRgn (0, 0, 1, 1) ;
hRgnClip = CreateRectRgn (0, 0, 1, 1) ;
// combie region from the second and the third regions to the first region with the fourth style.
// and the first region should be initialized with a small region.
// RGN_AND: inter sect
// RGN_OR: srcRgn1 || srcRgn2
// RGN_XOR: !RGN_AND
// RGN_DIFF: the part belong to srcRgn1 but not belong to srcRgn2
// RGN_COPY: srcRgn1 and ignore srcRgn2 totally.
// Return value: NULLREGION; SIMPLEREGION; COMPLEXREGION; ERROR
CombineRgn (hRgnTemp[4], hRgnTemp[0], hRgnTemp[1], RGN_OR) ;
CombineRgn (hRgnTemp[5], hRgnTemp[2], hRgnTemp[3], RGN_OR) ;
CombineRgn (hRgnClip, hRgnTemp[4], hRgnTemp[5], RGN_XOR) ;
for (i = 0 ; i < 6 ; i++)
DeleteObject (hRgnTemp[i]) ;
SetCursor (hCursor) ;
ShowCursor (FALSE) ;
return 0 ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
// draw on region api
// FillRgn, FrameRgn, InvertRgn, PaintRgn like FillRect, FrameRect ... etc.
HBRUSH hBrush = CreateSolidBrush(RGB(255, 0, 0));
FillRgn(hdc, hRgnClip, hBrush);
DeleteObject(hBrush);
// set the center position as the origin.
SetViewportOrgEx (hdc, cxClient / 2, cyClient / 2, NULL) ;
// select self-defined region as valid client area.
// so the painting will only happen in self-defined region.
SelectClipRgn (hdc, hRgnClip) ; // equals to SelectObject(hdc, hRgnClip);
// Use InvalidateRgn and ValidRgn instead of InvalidRect and ValidRect.
fRadius = _hypot (cxClient / 2.0, cyClient / 2.0) ;
for (fAngle = 0.0 ; fAngle < TWO_PI ; fAngle += TWO_PI / 360)
{
MoveToEx (hdc, 0, 0, NULL) ;
LineTo (hdc, (int) ( fRadius * cos (fAngle) + 0.5),
(int) (-fRadius * sin (fAngle) + 0.5)) ;
}
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_DESTROY:
DeleteObject (hRgnClip) ; // destroy region
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
}
void radar_plot_object_std( object *objp )
{
vec3d pos, tempv;
float dist, rscale, zdist, max_radar_dist;
int xpos, ypos;
vec3d *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, Player_ship)) {
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:
{
// don't plot hidden jump nodes
if ( objp->jnp->is_hidden() )
return;
// 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 we don't attack the bomb, return
if ( !iff_x_attacks_y(Player_ship->team, obj_team(objp)) )
return;
// if a local ssm is in subspace, return
if (Weapons[objp->instance].lssm_stage == 3)
return;
break;
}
// if any other kind of object, don't show it on radar
default:
return;
}
// 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;
// force new_x_dist and new_y_dist to be inside the radar
float hypotenuse;
float max_radius;
hypotenuse = (float) _hypot(new_x_dist, new_y_dist);
max_radius = i2fl(Current_radar_global->Radar_radius[gr_screen.res][0] - 5);
if (hypotenuse >= max_radius)
{
clipped_x_dist = max_radius * (new_x_dist / hypotenuse);
clipped_y_dist = max_radius * (new_y_dist / hypotenuse);
new_x_dist = clipped_x_dist;
new_y_dist = clipped_y_dist;
}
}
xpos = fl2i(Current_radar_global->Radar_center[gr_screen.res][0] + new_x_dist);
ypos = fl2i(Current_radar_global->Radar_center[gr_screen.res][1] - new_y_dist);
// determine the range within which the radar blip is bright
if (timestamp_elapsed(Radar_calc_bright_dist_timer))
{
Radar_calc_bright_dist_timer = timestamp(1000);
Radar_bright_range = player_farthest_weapon_range();
if (Radar_bright_range <= 0)
Radar_bright_range = 1500.0f;
}
blip *b;
int blip_bright = 0;
int blip_type = 0;
if (N_blips >= MAX_BLIPS)
{
// out of blips, don't plot
//Gahhh, this is bloody annoying -WMC
//Int3();
return;
}
b = &Blips[N_blips];
b->flags = 0;
// bright if within range
blip_bright = (dist <= Radar_bright_range);
// flag the blip as a current target if it is
if (OBJ_INDEX(objp) == Player_ai->target_objnum)
{
b->flags |= BLIP_CURRENT_TARGET;
blip_bright = 1;
}
radar_stuff_blip_info_std(objp, blip_bright, &b->blip_color, &blip_type);
if (blip_bright)
list_append(&Blip_bright_list[blip_type], b);
else
list_append(&Blip_dim_list[blip_type], b);
b->x = xpos;
b->y = ypos;
// see if blip should be drawn distorted
if (objp->type == OBJ_SHIP)
{
// ships specifically hidden from sensors
if (Ships[objp->instance].flags & SF_HIDDEN_FROM_SENSORS)
b->flags |= BLIP_DRAW_DISTORTED;
// determine if its AWACS distorted
if (awacs_level < 1.0f)
b->flags |= BLIP_DRAW_DISTORTED;
}
// don't distort the sensor blips if the player has primitive sensors and the nebula effect
// is not active
if (Player_ship->flags2 & SF2_PRIMITIVE_SENSORS)
{
if (!(The_mission.flags & MISSION_FLAG_FULLNEB))
b->flags &= ~BLIP_DRAW_DISTORTED;
}
N_blips++;
}
