qcsrc/client/particles.qc

   1 .float dphitcontentsmask;
   2
   3 .float cnt; // effect number
   4 .vector velocity; // particle velocity
   5 .float waterlevel; // direction jitter
   6 .float count; // count multiplier
   7 .float impulse; // density
   8 .string noise; // sound
   9 .float atten;
  10 .float volume;
  11 .float absolute; // 1 = count per second is absolute, 2 = only spawn at toggle
  12 .vector movedir; // trace direction
  13
  14 void Draw_PointParticles()
  15 {
  16         float n, i, fail;
  17         vector p;
  18         vector sz;
  19         vector o;
  20         o = self.origin;
  21         sz = self.maxs - self.mins;
  22         n = BGMScript(self);
  23         if(self.absolute == 2)
  24         {
  25                 if(n >= 0)
  26                         n = self.just_toggled ? self.impulse : 0;
  27                 else
  28                         n = self.impulse * drawframetime;
  29         }
  30         else
  31         {
  32                 n *= self.impulse * drawframetime;
  33                 if(self.just_toggled)
  34                         if(n < 1)
  35                                 n = 1;
  36         }
  37         if(n == 0)
  38                 return;
  39         fail = 0;
  40         for(i = random(); i <= n && fail <= 64*n; ++i)
  41         {
  42                 p = o + self.mins;
  43                 p_x += random() * sz_x;
  44                 p_y += random() * sz_y;
  45                 p_z += random() * sz_z;
  46                 if(WarpZoneLib_BoxTouchesBrush(p, p, self, world))
  47                 {
  48                         if(self.movedir != '0 0 0')
  49                         {
  50                                 traceline(p, p + normalize(self.movedir) * 4096, 0, world);
  51                                 p = trace_endpos;
  52                                 pointparticles(self.cnt, p, trace_plane_normal * vlen(self.movedir) + self.velocity + randomvec() * self.waterlevel, self.count);
  53                         }
  54                         else
  55                         {
  56                                 pointparticles(self.cnt, p, self.velocity + randomvec() * self.waterlevel, self.count);
  57                         }
  58                         if(self.noise != "")
  59                         {
  60                                 setorigin(self, p);
  61                                 sound(self, CH_AMBIENT, self.noise, VOL_BASE * self.volume, self.atten);
  62                         }
  63                         self.just_toggled = 0;
  64                 }
  65                 else if(self.absolute)
  66                 {
  67                         ++fail;
  68                         --i;
  69                 }
  70         }
  71         setorigin(self, o);
  72 }
  73
  74 void Ent_PointParticles_Remove()
  75 {
  76         if(self.noise)
  77                 strunzone(self.noise);
  78         self.noise = string_null;
  79         if(self.bgmscript)
  80                 strunzone(self.bgmscript);
  81         self.bgmscript = string_null;
  82 }
  83
  84 void Ent_PointParticles()
  85 {
  86         float f, i;
  87         vector v;
  88         f = ReadByte();
  89         if(f & 2)
  90         {
  91                 i = ReadCoord(); // density (<0: point, >0: volume)
  92                 if(i && !self.impulse && self.cnt) // self.cnt check is so it only happens if the ent already existed
  93                         self.just_toggled = 1;
  94                 self.impulse = i;
  95         }
  96         if(f & 4)
  97         {
  98                 self.origin_x = ReadCoord();
  99                 self.origin_y = ReadCoord();
 100                 self.origin_z = ReadCoord();
 101         }
 102         if(f & 1)
 103         {
 104                 self.modelindex = ReadShort();
 105                 if(f & 0x80)
 106                 {
 107                         if(self.modelindex)
 108                         {
 109                                 self.mins_x = ReadCoord();
 110                                 self.mins_y = ReadCoord();
 111                                 self.mins_z = ReadCoord();
 112                                 self.maxs_x = ReadCoord();
 113                                 self.maxs_y = ReadCoord();
 114                                 self.maxs_z = ReadCoord();
 115                         }
 116                         else
 117                         {
 118                                 self.mins    = '0 0 0';
 119                                 self.maxs_x = ReadCoord();
 120                                 self.maxs_y = ReadCoord();
 121                                 self.maxs_z = ReadCoord();
 122                         }
 123                 }
 124                 else
 125                 {
 126                         self.mins = self.maxs = '0 0 0';
 127                 }
 128
 129                 self.cnt = ReadShort(); // effect number
 130
 131                 if(f & 0x20)
 132                 {
 133                         self.velocity = decompressShortVector(ReadShort());
 134                         self.movedir = decompressShortVector(ReadShort());
 135                 }
 136                 else
 137                 {
 138                         self.velocity = self.movedir = '0 0 0';
 139                 }
 140                 if(f & 0x40)
 141                 {
 142                         self.waterlevel = ReadShort() / 16.0;
 143                         self.count = ReadByte() / 16.0;
 144                 }
 145                 else
 146                 {
 147                         self.waterlevel = 0;
 148                         self.count = 1;
 149                 }
 150                 if(self.noise)
 151                         strunzone(self.noise);
 152                 if(self.bgmscript)
 153                         strunzone(self.bgmscript);
 154                 self.noise = strzone(ReadString());
 155                 if(self.noise != "")
 156                 {
 157                         self.atten = ReadByte() / 64.0;
 158                         self.volume = ReadByte() / 255.0;
 159                 }
 160                 self.bgmscript = strzone(ReadString());
 161                 if(self.bgmscript != "")
 162                 {
 163                         self.bgmscriptattack = ReadByte() / 64.0;
 164                         self.bgmscriptdecay = ReadByte() / 64.0;
 165                         self.bgmscriptsustain = ReadByte() / 255.0;
 166                         self.bgmscriptrelease = ReadByte() / 64.0;
 167                 }
 168                 BGMScript_InitEntity(self);
 169         }
 170
 171         if(f & 2)
 172         {
 173                 self.absolute = (self.impulse >= 0);
 174                 if(!self.absolute)
 175                 {
 176                         v = self.maxs - self.mins;
 177                         self.impulse *= -v_x * v_y * v_z / 262144; // relative: particles per 64^3 cube
 178                 }
 179         }
 180
 181         if(f & 0x10)
 182                 self.absolute = 2;
 183
 184         setorigin(self, self.origin);
 185         setsize(self, self.mins, self.maxs);
 186         self.solid = SOLID_NOT;
 187         self.draw = Draw_PointParticles;
 188         self.entremove = Ent_PointParticles_Remove;
 189 }
 190
 191 .float glow_color; // palette index
 192 void Draw_Rain()
 193 {
 194     te_particlerain(self.origin + self.mins, self.origin + self.maxs, self.velocity, floor(self.count * drawframetime + random()), self.glow_color);
 195 }
 196
 197 void Draw_Snow()
 198 {
 199     te_particlesnow(self.origin + self.mins, self.origin + self.maxs, self.velocity, floor(self.count * drawframetime + random()), self.glow_color);
 200 }
 201
 202 void Ent_RainOrSnow()
 203 {
 204         self.impulse = ReadByte(); // Rain, Snow, or Whatever
 205         self.origin_x = ReadCoord();
 206         self.origin_y = ReadCoord();
 207         self.origin_z = ReadCoord();
 208         self.maxs_x = ReadCoord();
 209         self.maxs_y = ReadCoord();
 210         self.maxs_z = ReadCoord();
 211         self.velocity = decompressShortVector(ReadShort());
 212         self.count = ReadShort() * 10;
 213         self.glow_color = ReadByte(); // color
 214
 215         self.mins    = -0.5 * self.maxs;
 216         self.maxs    =  0.5 * self.maxs;
 217         self.origin  = self.origin - self.mins;
 218
 219         setorigin(self, self.origin);
 220         setsize(self, self.mins, self.maxs);
 221         self.solid = SOLID_NOT;
 222         if(self.impulse)
 223                 self.draw = Draw_Rain;
 224         else
 225                 self.draw = Draw_Snow;
 226 }
 227
 228 void Net_ReadVortexBeamParticle()
 229 {
 230         vector shotorg, endpos;
 231         float charge;
 232         shotorg_x = ReadCoord(); shotorg_y = ReadCoord(); shotorg_z = ReadCoord();
 233         endpos_x = ReadCoord(); endpos_y = ReadCoord(); endpos_z = ReadCoord();
 234         charge = ReadByte() / 255.0;
 235
 236         pointparticles(particleeffectnum("nex_muzzleflash"), shotorg, normalize(endpos - shotorg) * 1000, 1);
 237
 238         //draw either the old v2.3 beam or the new beam
 239         charge = sqrt(charge); // divide evenly among trail spacing and alpha
 240         particles_alphamin = particles_alphamax = particles_fade = charge;
 241
 242         if (autocvar_cl_particles_oldnexbeam && (getstati(STAT_ALLOW_OLDNEXBEAM) || isdemo()))
 243                 WarpZone_TrailParticles_WithMultiplier(world, particleeffectnum("TE_TEI_G3"), shotorg, endpos, 1, PARTICLES_USEALPHA | PARTICLES_USEFADE);
 244         else
 245                 WarpZone_TrailParticles_WithMultiplier(world, particleeffectnum("nex_beam"), shotorg, endpos, 1, PARTICLES_USEALPHA | PARTICLES_USEFADE);
 246 }
 247
 248 .vector sw_shotorg;
 249 .vector sw_endpos;
 250 .float sw_spread_max;
 251 .float sw_spread_min;
 252 .float sw_time;
 253
 254 void Draw_Shockwave()
 255 {
 256         float a = bound(0, (0.5 - ((time - self.sw_time) / 0.4)), 0.5);
 257
 258         if(!a) { remove(self); }
 259
 260         vector deviation, angle;
 261
 262         vector sw_color = getcsqcplayercolor(self.sv_entnum); // GetTeamRGB(GetPlayerColor(self.sv_entnum));
 263
 264         vector first_min_end = '0 0 0', prev_min_end = '0 0 0', new_min_end = '0 0 0';
 265         vector first_max_end = '0 0 0', prev_max_end = '0 0 0', new_max_end = '0 0 0';
 266
 267         float new_max_dist, new_min_dist;
 268
 269         vector shotdir = normalize(self.sw_endpos - self.sw_shotorg);
 270         vectorvectors(shotdir);
 271         vector right = v_right;
 272         vector up = v_up;
 273
 274         float counter, dist_before_normal = 200, shots = 20;
 275
 276         vector min_end = ((self.sw_shotorg + (shotdir * dist_before_normal)) + (up * self.sw_spread_min));
 277         vector max_end = (self.sw_endpos + (up * self.sw_spread_max));
 278
 279         float spread_to_min = vlen(normalize(min_end - self.sw_shotorg) - shotdir);
 280         float spread_to_max = vlen(normalize(max_end - min_end) - shotdir);
 281
 282         for(counter = 0; counter < shots; ++counter)
 283         {
 284                 // perfect circle effect lines
 285                 angle = '0 0 0';
 286                 makevectors('0 360 0' * (0.75 + (counter - 0.5) / shots));
 287                 angle_y = v_forward_x;
 288                 angle_z = v_forward_y;
 289
 290                 // first do the spread_to_min effect
 291                 deviation = angle * spread_to_min;
 292                 deviation = ((shotdir + (right * deviation_y) + (up * deviation_z)));
 293                 new_min_dist = dist_before_normal;
 294                 new_min_end = (self.sw_shotorg + (deviation * new_min_dist));
 295                 //te_lightning2(world, new_min_end, self.sw_shotorg);
 296
 297                 // then calculate spread_to_max effect
 298                 deviation = angle * spread_to_max;
 299                 deviation = ((shotdir + (right * deviation_y) + (up * deviation_z)));
 300                 new_max_dist = vlen(new_min_end - self.sw_endpos);
 301                 new_max_end = (new_min_end + (deviation * new_max_dist));
 302                 //te_lightning2(world, new_end, prev_min_end);
 303
 304
 305                 if(counter == 0)
 306                 {
 307                         first_min_end = new_min_end;
 308                         first_max_end = new_max_end;
 309                 }
 310
 311                 if(counter >= 1)
 312                 {
 313                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 314                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 315                         R_PolygonVertex(new_min_end, '0 0 0', sw_color, a);
 316                         R_PolygonVertex(self.sw_shotorg, '0 0 0', sw_color, a);
 317                         R_EndPolygon();
 318
 319                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 320                         R_PolygonVertex(new_min_end, '0 0 0', sw_color, a);
 321                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 322                         R_PolygonVertex(prev_max_end, '0 0 0', sw_color, a);
 323                         R_PolygonVertex(new_max_end, '0 0 0', sw_color, a);
 324                         R_EndPolygon();
 325                 }
 326
 327                 prev_min_end = new_min_end;
 328                 prev_max_end = new_max_end;
 329
 330                 if((counter + 1) == shots)
 331                 {
 332                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 333                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 334                         R_PolygonVertex(first_min_end, '0 0 0', sw_color, a);
 335                         R_PolygonVertex(self.sw_shotorg, '0 0 0', sw_color, a);
 336                         R_EndPolygon();
 337
 338                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 339                         R_PolygonVertex(first_min_end, '0 0 0', sw_color, a);
 340                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 341                         R_PolygonVertex(prev_max_end, '0 0 0', sw_color, a);
 342                         R_PolygonVertex(first_max_end, '0 0 0', sw_color, a);
 343                         R_EndPolygon();
 344                 }
 345         }
 346 }
 347
 348 void Net_ReadShockwaveParticle()
 349 {
 350         entity shockwave;
 351         shockwave = spawn();
 352         shockwave.draw = Draw_Shockwave;
 353
 354         shockwave.sw_shotorg_x = ReadCoord(); shockwave.sw_shotorg_y = ReadCoord(); shockwave.sw_shotorg_z = ReadCoord();
 355         shockwave.sw_endpos_x  = ReadCoord(); shockwave.sw_endpos_y  = ReadCoord(); shockwave.sw_endpos_z  = ReadCoord();
 356
 357         shockwave.sw_spread_max = ReadByte();
 358         shockwave.sw_spread_min = ReadByte();
 359
 360         shockwave.sv_entnum = ReadByte();
 361
 362         shockwave.sw_time = time;
 363 }
 364
 365 .vector beam_color;
 366 .float beam_alpha;
 367 .float beam_thickness;
 368 .float beam_traileffect;
 369 .float beam_hiteffect;
 370 .float beam_hitlight[4]; // 0: radius, 123: rgb
 371 .float beam_muzzleeffect;
 372 .float beam_muzzlelight[4]; // 0: radius, 123: rgb
 373 .string beam_image;
 374
 375 .entity beam_muzzleentity;
 376
 377 .float beam_degreespersegment;
 378 .float beam_distancepersegment;
 379 .float beam_usevieworigin;
 380 .float beam_initialized;
 381 .float beam_maxangle;
 382 .float beam_range;
 383 .float beam_returnspeed;
 384 .float beam_tightness;
 385 .vector beam_shotorigin;
 386 .vector beam_dir;
 387
 388 entity Draw_ArcBeam_callback_entity;
 389 vector Draw_ArcBeam_callback_new_dir;
 390 float Draw_ArcBeam_callback_segmentdist;
 391 float Draw_ArcBeam_callback_last_thickness;
 392 vector Draw_ArcBeam_callback_last_top;
 393 vector Draw_ArcBeam_callback_last_bottom;
 394
 395 void Draw_ArcBeam_callback(vector start, vector hit, vector end)
 396 {
 397         entity beam = Draw_ArcBeam_callback_entity;
 398         vector transformed_view_org;
 399         transformed_view_org = WarpZone_TransformOrigin(WarpZone_trace_transform, view_origin);
 400
 401         vector thickdir = normalize(cross(normalize(start - hit), transformed_view_org - start));
 402
 403         vector hitorigin;
 404
 405         // draw segment
 406         #if 0
 407         if(trace_fraction != 1)
 408         {
 409                 // calculate our own hit origin as trace_endpos tends to jump around annoyingly (to player origin?)
 410                 hitorigin = start + (Draw_ArcBeam_callback_new_dir * Draw_ArcBeam_callback_segmentdist * trace_fraction);
 411                 hitorigin = WarpZone_TransformOrigin(WarpZone_trace_transform, hitorigin);
 412         }
 413         else
 414         {
 415                 hitorigin = hit;
 416         }
 417         #else
 418         hitorigin = hit;
 419         #endif
 420
 421         // decide upon thickness
 422         float thickness = beam.beam_thickness;
 423
 424         // draw primary beam render
 425         vector top    = hitorigin + (thickdir * thickness);
 426         vector bottom = hitorigin - (thickdir * thickness);
 427         //vector last_top    = start + (thickdir * Draw_ArcBeam_callback_last_thickness);
 428         //vector last_bottom = start - (thickdir * Draw_ArcBeam_callback_last_thickness);
 429
 430         R_BeginPolygon(beam.beam_image, DRAWFLAG_NORMAL); // DRAWFLAG_ADDITIVE
 431         R_PolygonVertex(
 432                 top,
 433                 '0 0.5 0' + ('0 0.5 0' * (thickness / beam.beam_thickness)),
 434                 beam.beam_color,
 435                 beam.beam_alpha
 436         );
 437         R_PolygonVertex(
 438                 Draw_ArcBeam_callback_last_top,
 439                 '0 0.5 0' + ('0 0.5 0' * (Draw_ArcBeam_callback_last_thickness / beam.beam_thickness)),
 440                 beam.beam_color,
 441                 beam.beam_alpha
 442         );
 443         R_PolygonVertex(
 444                 Draw_ArcBeam_callback_last_bottom,
 445                 '0 0.5 0' * (1 - (Draw_ArcBeam_callback_last_thickness / beam.beam_thickness)),
 446                 beam.beam_color,
 447                 beam.beam_alpha
 448         );
 449         R_PolygonVertex(
 450                 bottom,
 451                 '0 0.5 0' * (1 - (thickness / beam.beam_thickness)),
 452                 beam.beam_color,
 453                 beam.beam_alpha
 454         );
 455         R_EndPolygon();
 456
 457         // draw trailing particles
 458         // NOTES:
 459         //  - Don't use spammy particle counts here, use a FEW small particles around the beam
 460         //  - We're not using WarpZone_TrailParticles here because we will handle warpzones ourselves.
 461         if(beam.beam_traileffect)
 462         {
 463                 trailparticles(beam, beam.beam_traileffect, start, hitorigin);
 464         }
 465
 466         // set up for the next
 467         Draw_ArcBeam_callback_last_thickness = thickness;
 468         Draw_ArcBeam_callback_last_top = top;
 469         Draw_ArcBeam_callback_last_bottom = bottom;
 470 }
 471
 472 void Draw_ArcBeam()
 473 {
 474         if(!self.beam_usevieworigin)
 475         {
 476                 InterpolateOrigin_Do();
 477         }
 478
 479         // origin = beam starting origin
 480         // v_angle = wanted/aim direction
 481         // angles = current direction of beam
 482
 483         vector start_pos;
 484         vector wantdir; //= view_forward;
 485         vector beamdir; //= self.beam_dir;
 486
 487         float segments;
 488         if(self.beam_usevieworigin)
 489         {
 490                 // WEAPONTODO:
 491                 // Currently we have to replicate nearly the same method of figuring
 492                 // out the shotdir that the server does... Ideally in the future we
 493                 // should be able to acquire this from a generalized function built
 494                 // into a weapon system for client code.
 495
 496                 // find where we are aiming
 497                 makevectors(view_angles);
 498
 499                 // decide upon start position
 500                 if(self.beam_usevieworigin == 2)
 501                         { start_pos = view_origin; }
 502                 else
 503                         { start_pos = self.origin; }
 504
 505                 // trace forward with an estimation
 506                 WarpZone_TraceLine(
 507                         start_pos,
 508                         start_pos + view_forward * self.beam_range,
 509                         MOVE_NOMONSTERS,
 510                         self
 511                 );
 512
 513                 // untransform in case our trace went through a warpzone
 514                 vector vf, vr, vu;
 515                 vf = view_forward;
 516                 vr = view_right;
 517                 vu = view_up;
 518                 vector shothitpos = WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos); // warpzone support
 519                 view_forward = vf;
 520                 view_right = vr;
 521                 view_up = vu;
 522
 523                 // un-adjust trueaim if shotend is too close
 524                 if(vlen(shothitpos - view_origin) < g_trueaim_minrange)
 525                         shothitpos = view_origin + (view_forward * g_trueaim_minrange);
 526
 527                 // move shot origin to the actual gun muzzle origin
 528                 vector origin_offset =
 529                         view_forward * self.beam_shotorigin_x
 530                         + view_right * -self.beam_shotorigin_y
 531                         + view_up * self.beam_shotorigin_z;
 532
 533                 start_pos = start_pos + origin_offset;
 534
 535                 // calculate the aim direction now
 536                 wantdir = normalize(shothitpos - start_pos);
 537
 538                 if(!self.beam_initialized)
 539                 {
 540                         self.beam_dir = wantdir;
 541                         self.beam_initialized = TRUE;
 542                 }
 543
 544                 if(self.beam_dir != wantdir)
 545                 {
 546                         // calculate how much we're going to move the end of the beam to the want position
 547                         // WEAPONTODO (server and client):
 548                         // blendfactor never actually becomes 0 in this situation, which is a problem
 549                         // regarding precision... this means that self.beam_dir and w_shotdir approach
 550                         // eachother, however they never actually become the same value with this method.
 551                         // Perhaps we should do some form of rounding/snapping?
 552                         float angle = vlen(wantdir - self.beam_dir) * RAD2DEG;
 553                         if(angle && (angle > self.beam_maxangle))
 554                         {
 555                                 // if the angle is greater than maxangle, force the blendfactor to make this the maximum factor
 556                                 float blendfactor = bound(
 557                                         0,
 558                                         (1 - (self.beam_returnspeed * frametime)),
 559                                         min(self.beam_maxangle / angle, 1)
 560                                 );
 561                                 self.beam_dir = normalize((wantdir * (1 - blendfactor)) + (self.beam_dir * blendfactor));
 562                         }
 563                         else
 564                         {
 565                                 // the radius is not too far yet, no worries :D
 566                                 float blendfactor = bound(
 567                                         0,
 568                                         (1 - (self.beam_returnspeed * frametime)),
 569                                         1
 570                                 );
 571                                 self.beam_dir = normalize((wantdir * (1 - blendfactor)) + (self.beam_dir * blendfactor));
 572                         }
 573
 574                         // calculate how many segments are needed
 575                         float max_allowed_segments;
 576
 577                         if(self.beam_distancepersegment)
 578                         {
 579                                 max_allowed_segments = min(
 580                                         ARC_MAX_SEGMENTS,
 581                                         1 + (vlen(wantdir / self.beam_distancepersegment))
 582                                 );
 583                         }
 584                         else { max_allowed_segments = ARC_MAX_SEGMENTS; }
 585
 586                         if(self.beam_degreespersegment)
 587                         {
 588                                 segments = bound(
 589                                         1,
 590                                         (
 591                                                 min(
 592                                                         angle,
 593                                                         self.beam_maxangle
 594                                                 )
 595                                                 /
 596                                                 self.beam_degreespersegment
 597                                         ),
 598                                         max_allowed_segments
 599                                 );
 600                         }
 601                         else { segments = 1; }
 602                 }
 603                 else { segments = 1; }
 604
 605                 // set the beam direction which the rest of the code will refer to
 606                 beamdir = self.beam_dir;
 607
 608                 // finally, set self.angles to the proper direction so that muzzle attachment points in proper direction
 609                 self.angles = fixedvectoangles2(view_forward, view_up);
 610         }
 611         else
 612         {
 613                 // set the values from the provided info from the networked entity
 614                 start_pos = self.origin;
 615                 wantdir = self.v_angle;
 616                 beamdir = self.angles;
 617
 618                 if(beamdir != wantdir)
 619                 {
 620                         float angle = vlen(wantdir - beamdir) * RAD2DEG;
 621
 622                         // calculate how many segments are needed
 623                         float max_allowed_segments;
 624
 625                         if(self.beam_distancepersegment)
 626                         {
 627                                 max_allowed_segments = min(
 628                                         ARC_MAX_SEGMENTS,
 629                                         1 + (vlen(wantdir / self.beam_distancepersegment))
 630                                 );
 631                         }
 632                         else { max_allowed_segments = ARC_MAX_SEGMENTS; }
 633
 634                         if(self.beam_degreespersegment)
 635                         {
 636                                 segments = bound(
 637                                         1,
 638                                         (
 639                                                 min(
 640                                                         angle,
 641                                                         self.beam_maxangle
 642                                                 )
 643                                                 /
 644                                                 self.beam_degreespersegment
 645                                         ),
 646                                         max_allowed_segments
 647                                 );
 648                         }
 649                         else { segments = 1; }
 650                 }
 651                 else { segments = 1; }
 652         }
 653
 654         setorigin(self, start_pos);
 655         self.beam_muzzleentity.angles_z = random() * 360; // WEAPONTODO: use avelocity instead?
 656
 657         vector beam_endpos_estimate = (start_pos + (beamdir * self.beam_range));
 658
 659         Draw_ArcBeam_callback_entity = self;
 660         Draw_ArcBeam_callback_last_thickness = 0;
 661         Draw_ArcBeam_callback_last_top = start_pos;
 662         Draw_ArcBeam_callback_last_bottom = start_pos;
 663
 664         vector last_origin = start_pos;
 665
 666         float i;
 667         for(i = 1; i <= segments; ++i)
 668         {
 669                 // WEAPONTODO (server and client):
 670                 // Segment blend and distance should probably really be calculated in a better way,
 671                 // however I am not sure how to do it properly. There are a few things I have tried,
 672                 // but most of them do not work properly due to my lack of understanding regarding
 673                 // the mathematics behind them.
 674
 675                 // Ideally, we should calculate the positions along a perfect curve
 676                 // between wantdir and self.beam_dir with an option for depth of arc
 677
 678                 // Another issue is that (on the client code) we must separate the
 679                 // curve into multiple rendered curves when handling warpzones.
 680
 681                 // I can handle this by detecting it for each segment, however that
 682                 // is a fairly inefficient method in comparison to having a curved line
 683                 // drawing function similar to Draw_CylindricLine that accepts
 684                 // top and bottom origins as input, this way there would be no
 685                 // overlapping edges when connecting the curved pieces.
 686
 687                 // WEAPONTODO (client):
 688                 // In order to do nice fading and pointing on the starting segment, we must always
 689                 // have that drawn as a separate triangle... However, that is difficult to do when
 690                 // keeping in mind the above problems and also optimizing the amount of segments
 691                 // drawn on screen at any given time. (Automatic beam quality scaling, essentially)
 692
 693                 // calculate this on every segment to ensure that we always reach the full length of the attack
 694                 float segmentblend = bound(0, (i/segments) + self.beam_tightness, 1);
 695                 float segmentdist = vlen(beam_endpos_estimate - last_origin) * (i/segments);
 696
 697                 // WEAPONTODO: Apparently, normalize is not the correct function to use here...
 698                 // Figure out how this actually should work.
 699                 vector new_dir = normalize(
 700                         (wantdir * (1 - segmentblend))
 701                         +
 702                         (normalize(beam_endpos_estimate - last_origin) * segmentblend)
 703                 );
 704                 vector new_origin = last_origin + (new_dir * segmentdist);
 705
 706                 Draw_ArcBeam_callback_segmentdist = segmentdist;
 707                 Draw_ArcBeam_callback_new_dir = new_dir;
 708
 709                 WarpZone_TraceBox_ThroughZone(
 710                         last_origin,
 711                         '0 0 0',
 712                         '0 0 0',
 713                         new_origin,
 714                         MOVE_NORMAL,
 715                         world,
 716                         world,
 717                         Draw_ArcBeam_callback
 718                 );
 719
 720                 //printf("segment: %d, warpzone transform: %d\n", i, (WarpZone_trace_transform != world));
 721
 722                 // WEAPONTODO:
 723                 // Figure out some way to detect a collision with geometry with callback...
 724                 // That way we can know when we are done drawing the beam and skip
 725                 // the rest of the segments without breaking warpzone support.
 726
 727                 last_origin = WarpZone_TransformOrigin(WarpZone_trace_transform, new_origin);
 728                 beam_endpos_estimate = WarpZone_TransformOrigin(WarpZone_trace_transform, beam_endpos_estimate);
 729         }
 730
 731         // startpoint and endpoint drawn visual effects
 732         if(self.beam_hiteffect)
 733         {
 734                 pointparticles(
 735                         self.beam_hiteffect,
 736                         last_origin,
 737                         beamdir * -1,
 738                         frametime * 2
 739                 );
 740         }
 741         if(self.beam_hitlight[0])
 742         {
 743                 adddynamiclight(
 744                         last_origin,
 745                         self.beam_hitlight[0],
 746                         vec3(
 747                                 self.beam_hitlight[1],
 748                                 self.beam_hitlight[2],
 749                                 self.beam_hitlight[3]
 750                         )
 751                 );
 752         }
 753         if(self.beam_muzzleeffect)
 754         {
 755                 pointparticles(
 756                         self.beam_muzzleeffect,
 757                         start_pos + wantdir * 20,
 758                         wantdir * 1000,
 759                         frametime * 0.1
 760                 );
 761         }
 762         if(self.beam_muzzlelight[0])
 763         {
 764                 adddynamiclight(
 765                         start_pos + wantdir * 20,
 766                         self.beam_muzzlelight[0],
 767                         vec3(
 768                                 self.beam_muzzlelight[1],
 769                                 self.beam_muzzlelight[2],
 770                                 self.beam_muzzlelight[3]
 771                         )
 772                 );
 773         }
 774
 775         // cleanup
 776         Draw_ArcBeam_callback_entity = world;
 777         Draw_ArcBeam_callback_new_dir = '0 0 0';
 778         Draw_ArcBeam_callback_segmentdist = 0;
 779         Draw_ArcBeam_callback_last_thickness = 0;
 780         Draw_ArcBeam_callback_last_top = '0 0 0';
 781         Draw_ArcBeam_callback_last_bottom = '0 0 0';
 782 }
 783
 784 void Remove_ArcBeam(void)
 785 {
 786         remove(self.beam_muzzleentity);
 787         sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, ATTEN_NORM);
 788 }
 789
 790 void Ent_ReadArcBeam(float isnew)
 791 {
 792         float sf = ReadByte();
 793         entity flash;
 794
 795         if(isnew)
 796         {
 797                 // calculate shot origin offset from gun alignment
 798                 float gunalign = autocvar_cl_gunalign;
 799                 if(gunalign != 1 && gunalign != 2 && gunalign != 4)
 800                         gunalign = 3; // default value
 801                 --gunalign;
 802
 803                 self.beam_shotorigin = arc_shotorigin[gunalign];
 804
 805                 // set other main attributes of the beam
 806                 self.draw = Draw_ArcBeam;
 807                 self.entremove = Remove_ArcBeam;
 808                 sound(self, CH_SHOTS_SINGLE, "weapons/lgbeam_fly.wav", VOL_BASE, ATTEN_NORM);
 809
 810                 flash = spawn();
 811                 flash.owner = self;
 812                 flash.effects = EF_ADDITIVE | EF_FULLBRIGHT;
 813                 flash.drawmask = MASK_NORMAL;
 814                 flash.solid = SOLID_NOT;
 815                 setattachment(flash, self, "");
 816                 setorigin(flash, '0 0 0');
 817
 818                 self.beam_muzzleentity = flash;
 819         }
 820         else
 821         {
 822                 flash = self.beam_muzzleentity;
 823         }
 824
 825         if(sf & 1) // settings information
 826         {
 827                 self.beam_degreespersegment = ReadShort();
 828                 self.beam_distancepersegment = ReadShort();
 829                 self.beam_maxangle = ReadShort();
 830                 self.beam_range = ReadCoord();
 831                 self.beam_returnspeed = ReadShort();
 832                 self.beam_tightness = (ReadByte() / 10);
 833
 834                 if(ReadByte())
 835                 {
 836                         if(autocvar_chase_active)
 837                                 { self.beam_usevieworigin = 1; }
 838                         else // use view origin
 839                                 { self.beam_usevieworigin = 2; }
 840                 }
 841                 else
 842                 {
 843                         self.beam_usevieworigin = 0;
 844                 }
 845         }
 846
 847         if(!self.beam_usevieworigin)
 848         {
 849                 // self.iflags = IFLAG_ORIGIN | IFLAG_ANGLES | IFLAG_V_ANGLE; // why doesn't this work?
 850                 self.iflags = IFLAG_ORIGIN;
 851
 852                 InterpolateOrigin_Undo();
 853         }
 854
 855         if(sf & 2) // starting location
 856         {
 857                 self.origin_x = ReadCoord();
 858                 self.origin_y = ReadCoord();
 859                 self.origin_z = ReadCoord();
 860         }
 861         else if(self.beam_usevieworigin) // infer the location from player location
 862         {
 863                 if(self.beam_usevieworigin == 2)
 864                 {
 865                         // use view origin
 866                         self.origin = view_origin;
 867                 }
 868                 else
 869                 {
 870                         // use player origin so that third person display still works
 871                         self.origin = getplayerorigin(player_localnum) + ('0 0 1' * getstati(STAT_VIEWHEIGHT));
 872                 }
 873         }
 874
 875         setorigin(self, self.origin);
 876
 877         if(sf & 4) // want/aim direction
 878         {
 879                 self.v_angle_x = ReadCoord();
 880                 self.v_angle_y = ReadCoord();
 881                 self.v_angle_z = ReadCoord();
 882         }
 883
 884         if(sf & 8) // beam direction
 885         {
 886                 self.angles_x = ReadCoord();
 887                 self.angles_y = ReadCoord();
 888                 self.angles_z = ReadCoord();
 889         }
 890
 891         if(sf & 16) // beam type
 892         {
 893                 self.beam_type = ReadByte();
 894                 switch(self.beam_type)
 895                 {
 896                         case ARC_BT_MISS:
 897                         {
 898                                 self.beam_color = '-1 -1 1';
 899                                 self.beam_alpha = 0.5;
 900                                 self.beam_thickness = 8;
 901                                 self.beam_traileffect = FALSE;
 902                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 903                                 self.beam_hitlight[0] = 0;
 904                                 self.beam_hitlight[1] = 1;
 905                                 self.beam_hitlight[2] = 1;
 906                                 self.beam_hitlight[3] = 1;
 907                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
 908                                 self.beam_muzzlelight[0] = 0;
 909                                 self.beam_muzzlelight[1] = 1;
 910                                 self.beam_muzzlelight[2] = 1;
 911                                 self.beam_muzzlelight[3] = 1;
 912                                 self.beam_image = "particles/lgbeam";
 913                                 setmodel(flash, "models/flash.md3");
 914                                 flash.alpha = self.beam_alpha;
 915                                 flash.colormod = self.beam_color;
 916                                 flash.scale = 0.5;
 917                                 break;
 918                         }
 919                         case ARC_BT_WALL: // grenadelauncher_muzzleflash healray_muzzleflash
 920                         {
 921                                 self.beam_color = '0.5 0.5 1';
 922                                 self.beam_alpha = 0.5;
 923                                 self.beam_thickness = 8;
 924                                 self.beam_traileffect = FALSE;
 925                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 926                                 self.beam_hitlight[0] = 0;
 927                                 self.beam_hitlight[1] = 1;
 928                                 self.beam_hitlight[2] = 1;
 929                                 self.beam_hitlight[3] = 1;
 930                                 self.beam_muzzleeffect = FALSE; // particleeffectnum("grenadelauncher_muzzleflash");
 931                                 self.beam_muzzlelight[0] = 0;
 932                                 self.beam_muzzlelight[1] = 1;
 933                                 self.beam_muzzlelight[2] = 1;
 934                                 self.beam_muzzlelight[3] = 1;
 935                                 self.beam_image = "particles/lgbeam";
 936                                 setmodel(flash, "models/flash.md3");
 937                                 flash.alpha = self.beam_alpha;
 938                                 flash.colormod = self.beam_color;
 939                                 flash.scale = 0.5;
 940                                 break;
 941                         }
 942                         case ARC_BT_HEAL:
 943                         {
 944                                 self.beam_color = '0 1 0';
 945                                 self.beam_alpha = 0.5;
 946                                 self.beam_thickness = 8;
 947                                 self.beam_traileffect = FALSE;
 948                                 self.beam_hiteffect = particleeffectnum("healray_impact");
 949                                 self.beam_hitlight[0] = 0;
 950                                 self.beam_hitlight[1] = 1;
 951                                 self.beam_hitlight[2] = 1;
 952                                 self.beam_hitlight[3] = 1;
 953                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
 954                                 self.beam_muzzlelight[0] = 0;
 955                                 self.beam_muzzlelight[1] = 1;
 956                                 self.beam_muzzlelight[2] = 1;
 957                                 self.beam_muzzlelight[3] = 1;
 958                                 self.beam_image = "particles/lgbeam";
 959                                 setmodel(flash, "models/flash.md3");
 960                                 flash.alpha = self.beam_alpha;
 961                                 flash.colormod = self.beam_color;
 962                                 flash.scale = 0.5;
 963                                 break;
 964                         }
 965                         case ARC_BT_HIT:
 966                         {
 967                                 self.beam_color = '1 0 1';
 968                                 self.beam_alpha = 0.5;
 969                                 self.beam_thickness = 8;
 970                                 self.beam_traileffect = particleeffectnum("nex_beam");
 971                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 972                                 self.beam_hitlight[0] = 20;
 973                                 self.beam_hitlight[1] = 1;
 974                                 self.beam_hitlight[2] = 0;
 975                                 self.beam_hitlight[3] = 0;
 976                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
 977                                 self.beam_muzzlelight[0] = 50;
 978                                 self.beam_muzzlelight[1] = 1;
 979                                 self.beam_muzzlelight[2] = 0;
 980                                 self.beam_muzzlelight[3] = 0;
 981                                 self.beam_image = "particles/lgbeam";
 982                                 setmodel(flash, "models/flash.md3");
 983                                 flash.alpha = self.beam_alpha;
 984                                 flash.colormod = self.beam_color;
 985                                 flash.scale = 0.5;
 986                                 break;
 987                         }
 988                         case ARC_BT_BURST_MISS:
 989                         {
 990                                 self.beam_color = '-1 -1 1';
 991                                 self.beam_alpha = 0.5;
 992                                 self.beam_thickness = 14;
 993                                 self.beam_traileffect = FALSE;
 994                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 995                                 self.beam_hitlight[0] = 0;
 996                                 self.beam_hitlight[1] = 1;
 997                                 self.beam_hitlight[2] = 1;
 998                                 self.beam_hitlight[3] = 1;
 999                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
1000                                 self.beam_muzzlelight[0] = 0;
1001                                 self.beam_muzzlelight[1] = 1;
1002                                 self.beam_muzzlelight[2] = 1;
1003                                 self.beam_muzzlelight[3] = 1;
1004                                 self.beam_image = "particles/lgbeam";
1005                                 setmodel(flash, "models/flash.md3");
1006                                 flash.alpha = self.beam_alpha;
1007                                 flash.colormod = self.beam_color;
1008                                 flash.scale = 0.5;
1009                                 break;
1010                         }
1011                         case ARC_BT_BURST_WALL:
1012                         {
1013                                 self.beam_color = '0.5 0.5 1';
1014                                 self.beam_alpha = 0.5;
1015                                 self.beam_thickness = 14;
1016                                 self.beam_traileffect = FALSE;
1017                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
1018                                 self.beam_hitlight[0] = 0;
1019                                 self.beam_hitlight[1] = 1;
1020                                 self.beam_hitlight[2] = 1;
1021                                 self.beam_hitlight[3] = 1;
1022                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
1023                                 self.beam_muzzlelight[0] = 0;
1024                                 self.beam_muzzlelight[1] = 1;
1025                                 self.beam_muzzlelight[2] = 1;
1026                                 self.beam_muzzlelight[3] = 1;
1027                                 self.beam_image = "particles/lgbeam";
1028                                 setmodel(flash, "models/flash.md3");
1029                                 flash.alpha = self.beam_alpha;
1030                                 flash.colormod = self.beam_color;
1031                                 flash.scale = 0.5;
1032                                 break;
1033                         }
1034                         case ARC_BT_BURST_HEAL:
1035                         {
1036                                 self.beam_color = '0 1 0';
1037                                 self.beam_alpha = 0.5;
1038                                 self.beam_thickness = 14;
1039                                 self.beam_traileffect = FALSE;
1040                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
1041                                 self.beam_hitlight[0] = 0;
1042                                 self.beam_hitlight[1] = 1;
1043                                 self.beam_hitlight[2] = 1;
1044                                 self.beam_hitlight[3] = 1;
1045                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
1046                                 self.beam_muzzlelight[0] = 0;
1047                                 self.beam_muzzlelight[1] = 1;
1048                                 self.beam_muzzlelight[2] = 1;
1049                                 self.beam_muzzlelight[3] = 1;
1050                                 self.beam_image = "particles/lgbeam";
1051                                 setmodel(flash, "models/flash.md3");
1052                                 flash.alpha = self.beam_alpha;
1053                                 flash.colormod = self.beam_color;
1054                                 flash.scale = 0.5;
1055                                 break;
1056                         }
1057                         case ARC_BT_BURST_HIT:
1058                         {
1059                                 self.beam_color = '1 0 1';
1060                                 self.beam_alpha = 0.5;
1061                                 self.beam_thickness = 14;
1062                                 self.beam_traileffect = FALSE;
1063                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
1064                                 self.beam_hitlight[0] = 0;
1065                                 self.beam_hitlight[1] = 1;
1066                                 self.beam_hitlight[2] = 1;
1067                                 self.beam_hitlight[3] = 1;
1068                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
1069                                 self.beam_muzzlelight[0] = 0;
1070                                 self.beam_muzzlelight[1] = 1;
1071                                 self.beam_muzzlelight[2] = 1;
1072                                 self.beam_muzzlelight[3] = 1;
1073                                 self.beam_image = "particles/lgbeam";
1074                                 setmodel(flash, "models/flash.md3");
1075                                 flash.alpha = self.beam_alpha;
1076                                 flash.colormod = self.beam_color;
1077                                 flash.scale = 0.5;
1078                                 break;
1079                         }
1080
1081                         // shouldn't be possible, but lets make it colorful if it does :D
1082                         default:
1083                         {
1084                                 self.beam_color = randomvec();
1085                                 self.beam_alpha = 1;
1086                                 self.beam_thickness = 8;
1087                                 self.beam_traileffect = FALSE;
1088                                 self.beam_hiteffect = FALSE;
1089                                 self.beam_hitlight[0] = 0;
1090                                 self.beam_hitlight[1] = 1;
1091                                 self.beam_hitlight[2] = 1;
1092                                 self.beam_hitlight[3] = 1;
1093                                 self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
1094                                 self.beam_muzzlelight[0] = 0;
1095                                 self.beam_muzzlelight[1] = 1;
1096                                 self.beam_muzzlelight[2] = 1;
1097                                 self.beam_muzzlelight[3] = 1;
1098                                 self.beam_image = "particles/lgbeam";
1099                                 setmodel(flash, "models/flash.md3");
1100                                 flash.alpha = self.beam_alpha;
1101                                 flash.colormod = self.beam_color;
1102                                 flash.scale = 0.5;
1103                                 break;
1104                         }
1105                 }
1106         }
1107
1108         if(!self.beam_usevieworigin)
1109         {
1110                 InterpolateOrigin_Note();
1111         }
1112 }
1113