qcsrc/client/hud/panel/physics.qc

   1 #include "physics.qh"
   2
   3 #include <common/mapinfo.qh>
   4 #include <lib/csqcmodel/cl_player.qh>
   5
   6 // Physics panel (#15)
   7
   8 vector acc_prevspeed;
   9 float acc_prevtime, acc_avg, top_speed, top_speed_time;
  10 float physics_update_time, discrete_speed, discrete_acceleration;
  11 void HUD_Physics()
  12 {
  13         if(!autocvar__hud_configure)
  14         {
  15                 if(!autocvar_hud_panel_physics) return;
  16                 if(spectatee_status == -1 && (autocvar_hud_panel_physics == 1 || autocvar_hud_panel_physics == 3)) return;
  17                 if(autocvar_hud_panel_physics == 3 && !(gametype == MAPINFO_TYPE_RACE || gametype == MAPINFO_TYPE_CTS)) return;
  18         }
  19
  20         HUD_Panel_UpdateCvars();
  21
  22         draw_beginBoldFont();
  23
  24         if (autocvar_hud_panel_physics_dynamichud)
  25                 HUD_Scale_Enable();
  26         else
  27                 HUD_Scale_Disable();
  28         HUD_Panel_DrawBg(1);
  29         if(panel_bg_padding)
  30         {
  31                 panel_pos += '1 1 0' * panel_bg_padding;
  32                 panel_size -= '2 2 0' * panel_bg_padding;
  33         }
  34
  35         float acceleration_progressbar_scale = 0;
  36         if(autocvar_hud_panel_physics_progressbar && autocvar_hud_panel_physics_acceleration_progressbar_scale > 1)
  37                 acceleration_progressbar_scale = autocvar_hud_panel_physics_acceleration_progressbar_scale;
  38
  39         float text_scale;
  40         if (autocvar_hud_panel_physics_text_scale <= 0)
  41                 text_scale = 1;
  42         else
  43                 text_scale = min(autocvar_hud_panel_physics_text_scale, 1);
  44
  45         //compute speed
  46         float speed, conversion_factor;
  47         string unit;
  48
  49         switch(autocvar_hud_panel_physics_speed_unit)
  50         {
  51                 default:
  52                 case 1:
  53                         unit = _(" qu/s");
  54                         conversion_factor = 1.0;
  55                         break;
  56                 case 2:
  57                         unit = _(" m/s");
  58                         conversion_factor = 0.0254;
  59                         break;
  60                 case 3:
  61                         unit = _(" km/h");
  62                         conversion_factor = 0.0254 * 3.6;
  63                         break;
  64                 case 4:
  65                         unit = _(" mph");
  66                         conversion_factor = 0.0254 * 3.6 * 0.6213711922;
  67                         break;
  68                 case 5:
  69                         unit = _(" knots");
  70                         conversion_factor = 0.0254 * 1.943844492; // 1 m/s = 1.943844492 knots, because 1 knot = 1.852 km/h
  71                         break;
  72         }
  73
  74         vector vel = (csqcplayer ? csqcplayer.velocity : pmove_vel);
  75
  76         float max_speed = floor( autocvar_hud_panel_physics_speed_max * conversion_factor + 0.5 );
  77         if (autocvar__hud_configure)
  78                 speed = floor( max_speed * 0.65 + 0.5 );
  79         else if(autocvar_hud_panel_physics_speed_vertical)
  80                 speed = floor( vlen(vel) * conversion_factor + 0.5 );
  81         else
  82                 speed = floor( vlen(vel - vel.z * '0 0 1') * conversion_factor + 0.5 );
  83
  84         //compute acceleration
  85         float acceleration, f;
  86         if (autocvar__hud_configure)
  87                 acceleration = autocvar_hud_panel_physics_acceleration_max * 0.3;
  88         else
  89         {
  90                 // 1 m/s = 0.0254 qu/s; 1 g = 9.80665 m/s^2
  91                 f = time - acc_prevtime;
  92                 if(autocvar_hud_panel_physics_acceleration_vertical)
  93                         acceleration = (vlen(vel) - vlen(acc_prevspeed));
  94                 else
  95                         acceleration = (vlen(vel - '0 0 1' * vel.z) - vlen(acc_prevspeed - '0 0 1' * acc_prevspeed.z));
  96
  97                 acceleration = acceleration * (1 / max(0.0001, f)) * (0.0254 / 9.80665);
  98
  99                 acc_prevspeed = vel;
 100                 acc_prevtime = time;
 101
 102                 if(autocvar_hud_panel_physics_acceleration_movingaverage)
 103                 {
 104                         f = bound(0, f * 10, 1);
 105                         acc_avg = acc_avg * (1 - f) + acceleration * f;
 106                         acceleration = acc_avg;
 107                 }
 108         }
 109
 110         int acc_decimals = 2;
 111         if(time > physics_update_time)
 112         {
 113                 // workaround for ftos_decimals returning a negative 0
 114                 if(discrete_acceleration > -1 / pow(10, acc_decimals) && discrete_acceleration < 0)
 115                         discrete_acceleration = 0;
 116                 discrete_acceleration = acceleration;
 117                 discrete_speed = speed;
 118                 physics_update_time += autocvar_hud_panel_physics_update_interval;
 119         }
 120
 121         //compute layout
 122         float panel_ar = panel_size.x/panel_size.y;
 123         vector speed_offset = '0 0 0', acceleration_offset = '0 0 0';
 124         if (panel_ar >= 5 && !acceleration_progressbar_scale)
 125         {
 126                 panel_size.x *= 0.5;
 127                 if (autocvar_hud_panel_physics_flip)
 128                         speed_offset.x = panel_size.x;
 129                 else
 130                         acceleration_offset.x = panel_size.x;
 131         }
 132         else
 133         {
 134                 panel_size.y *= 0.5;
 135                 if (autocvar_hud_panel_physics_flip)
 136                         speed_offset.y = panel_size.y;
 137                 else
 138                         acceleration_offset.y = panel_size.y;
 139         }
 140         int speed_baralign, acceleration_baralign;
 141         if (autocvar_hud_panel_physics_baralign == 1)
 142                 acceleration_baralign = speed_baralign = 1;
 143     else if(autocvar_hud_panel_physics_baralign == 4)
 144                 acceleration_baralign = speed_baralign = 2;
 145         else if (autocvar_hud_panel_physics_flip)
 146         {
 147                 acceleration_baralign = (autocvar_hud_panel_physics_baralign == 2);
 148                 speed_baralign = (autocvar_hud_panel_physics_baralign == 3);
 149         }
 150         else
 151         {
 152                 speed_baralign = (autocvar_hud_panel_physics_baralign == 2);
 153                 acceleration_baralign = (autocvar_hud_panel_physics_baralign == 3);
 154         }
 155         if (autocvar_hud_panel_physics_acceleration_progressbar_mode == 0)
 156                 acceleration_baralign = 3; //override hud_panel_physics_baralign value for acceleration
 157
 158         //draw speed
 159         if(speed)
 160         if(autocvar_hud_panel_physics_progressbar == 1 || autocvar_hud_panel_physics_progressbar == 2)
 161                 HUD_Panel_DrawProgressBar(panel_pos + speed_offset, panel_size, "progressbar", speed/max_speed, 0, speed_baralign, autocvar_hud_progressbar_speed_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 162         vector tmp_offset = '0 0 0', tmp_size = '0 0 0';
 163         if (autocvar_hud_panel_physics_text == 1 || autocvar_hud_panel_physics_text == 2)
 164         {
 165                 tmp_size.x = panel_size.x * 0.75;
 166                 tmp_size.y = panel_size.y * text_scale;
 167                 if (speed_baralign)
 168                         tmp_offset.x = panel_size.x - tmp_size.x;
 169                 //else
 170                         //tmp_offset_x = 0;
 171                 tmp_offset.y = (panel_size.y - tmp_size.y) / 2;
 172                 drawstring_aspect(panel_pos + speed_offset + tmp_offset, ftos(discrete_speed), tmp_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 173
 174                 //draw speed unit
 175                 if (speed_baralign)
 176                         tmp_offset.x = 0;
 177                 else
 178                         tmp_offset.x = tmp_size.x;
 179                 if (autocvar_hud_panel_physics_speed_unit_show)
 180                 {
 181                         //tmp_offset_y = 0;
 182                         tmp_size.x = panel_size.x * (1 - 0.75);
 183                         tmp_size.y = panel_size.y * 0.4 * text_scale;
 184                         tmp_offset.y = (panel_size.y * 0.4 - tmp_size.y) / 2;
 185                         drawstring_aspect(panel_pos + speed_offset + tmp_offset, unit, tmp_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 186                 }
 187         }
 188
 189         //compute and draw top speed
 190         if (autocvar_hud_panel_physics_topspeed)
 191         if (autocvar_hud_panel_physics_text == 1 || autocvar_hud_panel_physics_text == 2)
 192         {
 193                 if (autocvar__hud_configure)
 194                 {
 195                         top_speed = floor( max_speed * 0.75 + 0.5 );
 196                         f = 1;
 197                 }
 198                 else
 199                 {
 200                         if (speed >= top_speed)
 201                         {
 202                                 top_speed = speed;
 203                                 top_speed_time = time;
 204                         }
 205                         if (top_speed != 0)
 206                         {
 207                                 f = max(1, autocvar_hud_panel_physics_topspeed_time);
 208                                 // divide by f to make it start from 1
 209                                 f = cos( ((time - top_speed_time) / f) * PI/2 );
 210                         }
 211             else //hide top speed 0, it would be stupid
 212                                 f = 0;
 213                 }
 214                 if (f > 0)
 215                 {
 216                         //top speed progressbar peak
 217                         if(speed < top_speed)
 218                         if(autocvar_hud_panel_physics_progressbar == 1 || autocvar_hud_panel_physics_progressbar == 2)
 219                         {
 220                                 float peak_offsetX;
 221                                 vector peak_size = '0 0 0';
 222                                 if (speed_baralign == 0)
 223                                         peak_offsetX = min(top_speed, max_speed)/max_speed * panel_size.x;
 224                 else if (speed_baralign == 1)
 225                                         peak_offsetX = (1 - min(top_speed, max_speed)/max_speed) * panel_size.x;
 226                 else // if (speed_baralign == 2)
 227                     peak_offsetX = min(top_speed, max_speed)/max_speed * panel_size.x * 0.5;
 228                                 peak_size.x = floor(panel_size.x * 0.01 + 1.5);
 229                 peak_size.y = panel_size.y;
 230                 if (speed_baralign == 2) // draw two peaks, on both sides
 231                 {
 232                     drawfill(panel_pos + speed_offset + eX * (0.5 * panel_size.x + peak_offsetX - peak_size.x), peak_size, autocvar_hud_progressbar_speed_color, f * autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 233                     drawfill(panel_pos + speed_offset + eX * (0.5 * panel_size.x - peak_offsetX + peak_size.x), peak_size, autocvar_hud_progressbar_speed_color, f * autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 234                 }
 235                 else
 236                     drawfill(panel_pos + speed_offset + eX * (peak_offsetX - peak_size.x), peak_size, autocvar_hud_progressbar_speed_color, f * autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 237                         }
 238
 239                         //top speed
 240                         tmp_offset.y = panel_size.y * 0.4;
 241                         tmp_size.x = panel_size.x * (1 - 0.75);
 242                         tmp_size.y = (panel_size.y - tmp_offset.y) * text_scale;
 243                         tmp_offset.y += (panel_size.y - tmp_offset.y - tmp_size.y) / 2;
 244                         drawstring_aspect(panel_pos + speed_offset + tmp_offset, ftos(top_speed), tmp_size, '1 0 0', f * panel_fg_alpha, DRAWFLAG_NORMAL);
 245                 }
 246                 else
 247                         top_speed = 0;
 248         }
 249
 250         //draw acceleration
 251         if(acceleration)
 252         if(autocvar_hud_panel_physics_progressbar == 1 || autocvar_hud_panel_physics_progressbar == 3)
 253         {
 254                 vector progressbar_color;
 255                 if(acceleration < 0)
 256                         progressbar_color = autocvar_hud_progressbar_acceleration_neg_color;
 257                 else
 258                         progressbar_color = autocvar_hud_progressbar_acceleration_color;
 259
 260                 f = acceleration/autocvar_hud_panel_physics_acceleration_max;
 261                 if (autocvar_hud_panel_physics_acceleration_progressbar_nonlinear)
 262                         f = (f >= 0 ? sqrt(f) : -sqrt(-f));
 263
 264                 if (acceleration_progressbar_scale) // allow progressbar to go out of panel bounds
 265                 {
 266                         tmp_size = acceleration_progressbar_scale * panel_size.x * eX + panel_size.y * eY;
 267
 268                         if (acceleration_baralign == 1)
 269                                 tmp_offset.x = panel_size.x - tmp_size.x;
 270                         else if (acceleration_baralign == 2 || acceleration_baralign == 3)
 271                                 tmp_offset.x = (panel_size.x - tmp_size.x) / 2;
 272                         else
 273                                 tmp_offset.x = 0;
 274                         tmp_offset.y = 0;
 275                 }
 276                 else
 277                 {
 278                         tmp_size = panel_size;
 279                         tmp_offset = '0 0 0';
 280                 }
 281
 282                 HUD_Panel_DrawProgressBar(panel_pos + acceleration_offset + tmp_offset, tmp_size, "accelbar", f, 0, acceleration_baralign, progressbar_color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 283         }
 284
 285         if(autocvar_hud_panel_physics_text == 1 || autocvar_hud_panel_physics_text == 3)
 286         {
 287                 tmp_size.x = panel_size.x;
 288                 tmp_size.y = panel_size.y * text_scale;
 289                 tmp_offset.x = 0;
 290                 tmp_offset.y = (panel_size.y - tmp_size.y) / 2;
 291
 292                 drawstring_aspect(panel_pos + acceleration_offset + tmp_offset, strcat(ftos_decimals(discrete_acceleration, acc_decimals), "g"), tmp_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 293         }
 294
 295         draw_endBoldFont();
 296 }