![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cl_newfx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / client|
Return to cl_newfx.c CVS log | Up to [Quake II] / quake2 / client |
1.1 root 1: // cl_newfx.c -- MORE entity effects parsing and management
2:
3: #include "client.h"
4:
5: extern cparticle_t *active_particles, *free_particles;
6: extern cparticle_t particles[MAX_PARTICLES];
7: extern int cl_numparticles;
8: extern cvar_t *vid_ref;
9:
10: extern void MakeNormalVectors (vec3_t forward, vec3_t right, vec3_t up);
11:
12:
13: /*
14: ======
15: vectoangles2 - this is duplicated in the game DLL, but I need it here.
16: ======
17: */
18: void vectoangles2 (vec3_t value1, vec3_t angles)
19: {
20: float forward;
21: float yaw, pitch;
22:
23: if (value1[1] == 0 && value1[0] == 0)
24: {
25: yaw = 0;
26: if (value1[2] > 0)
27: pitch = 90;
28: else
29: pitch = 270;
30: }
31: else
32: {
33: // PMM - fixed to correct for pitch of 0
34: if (value1[0])
35: yaw = (atan2(value1[1], value1[0]) * 180 / M_PI);
36: else if (value1[1] > 0)
37: yaw = 90;
38: else
39: yaw = 270;
40:
41: if (yaw < 0)
42: yaw += 360;
43:
44: forward = sqrt (value1[0]*value1[0] + value1[1]*value1[1]);
45: pitch = (atan2(value1[2], forward) * 180 / M_PI);
46: if (pitch < 0)
47: pitch += 360;
48: }
49:
50: angles[PITCH] = -pitch;
51: angles[YAW] = yaw;
52: angles[ROLL] = 0;
53: }
54:
55: //=============
56: //=============
57: void CL_Flashlight (int ent, vec3_t pos)
58: {
59: cdlight_t *dl;
60:
61: dl = CL_AllocDlight (ent);
62: VectorCopy (pos, dl->origin);
63: dl->radius = 400;
64: dl->minlight = 250;
65: dl->die = cl.time + 100;
66: dl->color[0] = 1;
67: dl->color[1] = 1;
68: dl->color[2] = 1;
69: }
70:
71: /*
72: ======
73: CL_ColorFlash - flash of light
74: ======
75: */
76: void CL_ColorFlash (vec3_t pos, int ent, int intensity, float r, float g, float b)
77: {
78: cdlight_t *dl;
79:
80: if((vidref_val == VIDREF_SOFT) && ((r < 0) || (g<0) || (b<0)))
81: {
82: intensity = -intensity;
83: r = -r;
84: g = -g;
85: b = -b;
86: }
87:
88: dl = CL_AllocDlight (ent);
89: VectorCopy (pos, dl->origin);
90: dl->radius = intensity;
91: dl->minlight = 250;
92: dl->die = cl.time + 100;
93: dl->color[0] = r;
94: dl->color[1] = g;
95: dl->color[2] = b;
96: }
97:
98:
99: /*
100: ======
101: CL_DebugTrail
102: ======
103: */
104: void CL_DebugTrail (vec3_t start, vec3_t end)
105: {
106: vec3_t move;
107: vec3_t vec;
108: float len;
109: // int j;
110: cparticle_t *p;
111: float dec;
112: vec3_t right, up;
113: // int i;
114: // float d, c, s;
115: // vec3_t dir;
116:
117: VectorCopy (start, move);
118: VectorSubtract (end, start, vec);
119: len = VectorNormalize (vec);
120:
121: MakeNormalVectors (vec, right, up);
122:
123: // VectorScale(vec, RT2_SKIP, vec);
124:
125: // dec = 1.0;
126: // dec = 0.75;
127: dec = 3;
128: VectorScale (vec, dec, vec);
129: VectorCopy (start, move);
130:
131: while (len > 0)
132: {
133: len -= dec;
134:
135: if (!free_particles)
136: return;
137: p = free_particles;
138: free_particles = p->next;
139: p->next = active_particles;
140: active_particles = p;
141:
142: p->time = cl.time;
143: VectorClear (p->accel);
144: VectorClear (p->vel);
145: p->alpha = 1.0;
146: p->alphavel = -0.1;
147: // p->alphavel = 0;
148: p->color = 0x74 + (rand()&7);
149: VectorCopy (move, p->org);
150: /*
151: for (j=0 ; j<3 ; j++)
152: {
153: p->org[j] = move[j] + crand()*2;
154: p->vel[j] = crand()*3;
155: p->accel[j] = 0;
156: }
157: */
158: VectorAdd (move, vec, move);
159: }
160:
161: }
162:
163: /*
164: ===============
165: CL_SmokeTrail
166: ===============
167: */
168: void CL_SmokeTrail (vec3_t start, vec3_t end, int colorStart, int colorRun, int spacing)
169: {
170: vec3_t move;
171: vec3_t vec;
172: float len;
173: int j;
174: cparticle_t *p;
175:
176: VectorCopy (start, move);
177: VectorSubtract (end, start, vec);
178: len = VectorNormalize (vec);
179:
180: VectorScale (vec, spacing, vec);
181:
182: // FIXME: this is a really silly way to have a loop
183: while (len > 0)
184: {
185: len -= spacing;
186:
187: if (!free_particles)
188: return;
189: p = free_particles;
190: free_particles = p->next;
191: p->next = active_particles;
192: active_particles = p;
193: VectorClear (p->accel);
194:
195: p->time = cl.time;
196:
197: p->alpha = 1.0;
198: p->alphavel = -1.0 / (1+frand()*0.5);
199: p->color = colorStart + (rand() % colorRun);
200: for (j=0 ; j<3 ; j++)
201: {
202: p->org[j] = move[j] + crand()*3;
203: p->accel[j] = 0;
204: }
205: p->vel[2] = 20 + crand()*5;
206:
207: VectorAdd (move, vec, move);
208: }
209: }
210:
211: void CL_ForceWall (vec3_t start, vec3_t end, int color)
212: {
213: vec3_t move;
214: vec3_t vec;
215: float len;
216: int j;
217: cparticle_t *p;
218:
219: VectorCopy (start, move);
220: VectorSubtract (end, start, vec);
221: len = VectorNormalize (vec);
222:
223: VectorScale (vec, 4, vec);
224:
225: // FIXME: this is a really silly way to have a loop
226: while (len > 0)
227: {
228: len -= 4;
229:
230: if (!free_particles)
231: return;
232:
233: if (frand() > 0.3)
234: {
235: p = free_particles;
236: free_particles = p->next;
237: p->next = active_particles;
238: active_particles = p;
239: VectorClear (p->accel);
240:
241: p->time = cl.time;
242:
243: p->alpha = 1.0;
244: p->alphavel = -1.0 / (3.0+frand()*0.5);
245: p->color = color;
246: for (j=0 ; j<3 ; j++)
247: {
248: p->org[j] = move[j] + crand()*3;
249: p->accel[j] = 0;
250: }
251: p->vel[0] = 0;
252: p->vel[1] = 0;
253: p->vel[2] = -40 - (crand()*10);
254: }
255:
256: VectorAdd (move, vec, move);
257: }
258: }
259:
260: void CL_FlameEffects (centity_t *ent, vec3_t origin)
261: {
262: int n, count;
263: int j;
264: cparticle_t *p;
265:
266: count = rand() & 0xF;
267:
268: for(n=0;n<count;n++)
269: {
270: if (!free_particles)
271: return;
272:
273: p = free_particles;
274: free_particles = p->next;
275: p->next = active_particles;
276: active_particles = p;
277:
278: VectorClear (p->accel);
279: p->time = cl.time;
280:
281: p->alpha = 1.0;
282: p->alphavel = -1.0 / (1+frand()*0.2);
283: p->color = 226 + (rand() % 4);
284: for (j=0 ; j<3 ; j++)
285: {
286: p->org[j] = origin[j] + crand()*5;
287: p->vel[j] = crand()*5;
288: }
289: p->vel[2] = crand() * -10;
290: p->accel[2] = -PARTICLE_GRAVITY;
291: }
292:
293: count = rand() & 0x7;
294:
295: for(n=0;n<count;n++)
296: {
297: if (!free_particles)
298: return;
299: p = free_particles;
300: free_particles = p->next;
301: p->next = active_particles;
302: active_particles = p;
303: VectorClear (p->accel);
304:
305: p->time = cl.time;
306:
307: p->alpha = 1.0;
308: p->alphavel = -1.0 / (1+frand()*0.5);
309: p->color = 0 + (rand() % 4);
310: for (j=0 ; j<3 ; j++)
311: {
312: p->org[j] = origin[j] + crand()*3;
313: }
314: p->vel[2] = 20 + crand()*5;
315: }
316:
317: }
318:
319:
320: /*
321: ===============
322: CL_GenericParticleEffect
323: ===============
324: */
325: void CL_GenericParticleEffect (vec3_t org, vec3_t dir, int color, int count, int numcolors, int dirspread, float alphavel)
326: {
327: int i, j;
328: cparticle_t *p;
329: float d;
330:
331: for (i=0 ; i<count ; i++)
332: {
333: if (!free_particles)
334: return;
335: p = free_particles;
336: free_particles = p->next;
337: p->next = active_particles;
338: active_particles = p;
339:
340: p->time = cl.time;
341: if (numcolors > 1)
342: p->color = color + (rand() & numcolors);
343: else
344: p->color = color;
345:
346: d = rand() & dirspread;
347: for (j=0 ; j<3 ; j++)
348: {
349: p->org[j] = org[j] + ((rand()&7)-4) + d*dir[j];
350: p->vel[j] = crand()*20;
351: }
352:
353: p->accel[0] = p->accel[1] = 0;
354: p->accel[2] = -PARTICLE_GRAVITY;
355: // VectorCopy (accel, p->accel);
356: p->alpha = 1.0;
357:
358: p->alphavel = -1.0 / (0.5 + frand()*alphavel);
359: // p->alphavel = alphavel;
360: }
361: }
362:
363: /*
364: ===============
365: CL_BubbleTrail2 (lets you control the # of bubbles by setting the distance between the spawns)
366:
367: ===============
368: */
369: void CL_BubbleTrail2 (vec3_t start, vec3_t end, int dist)
370: {
371: vec3_t move;
372: vec3_t vec;
373: float len;
374: int i, j;
375: cparticle_t *p;
376: float dec;
377:
378: VectorCopy (start, move);
379: VectorSubtract (end, start, vec);
380: len = VectorNormalize (vec);
381:
382: dec = dist;
383: VectorScale (vec, dec, vec);
384:
385: for (i=0 ; i<len ; i+=dec)
386: {
387: if (!free_particles)
388: return;
389:
390: p = free_particles;
391: free_particles = p->next;
392: p->next = active_particles;
393: active_particles = p;
394:
395: VectorClear (p->accel);
396: p->time = cl.time;
397:
398: p->alpha = 1.0;
399: p->alphavel = -1.0 / (1+frand()*0.1);
400: p->color = 4 + (rand()&7);
401: for (j=0 ; j<3 ; j++)
402: {
403: p->org[j] = move[j] + crand()*2;
404: p->vel[j] = crand()*10;
405: }
406: p->org[2] -= 4;
407: // p->vel[2] += 6;
408: p->vel[2] += 20;
409:
410: VectorAdd (move, vec, move);
411: }
412: }
413:
414: //#define CORKSCREW 1
415: //#define DOUBLE_SCREW 1
416: #define RINGS 1
417: //#define SPRAY 1
418:
419: #ifdef CORKSCREW
420: void CL_Heatbeam (vec3_t start, vec3_t end)
421: {
422: vec3_t move;
423: vec3_t vec;
424: float len;
425: int j,k;
426: cparticle_t *p;
427: vec3_t right, up;
428: int i;
429: float d, c, s;
430: vec3_t dir;
431: float ltime;
432: float step = 5.0;
433:
434: VectorCopy (start, move);
435: VectorSubtract (end, start, vec);
436: len = VectorNormalize (vec);
437:
438: // MakeNormalVectors (vec, right, up);
439: VectorCopy (cl.v_right, right);
440: VectorCopy (cl.v_up, up);
441: VectorMA (move, -1, right, move);
442: VectorMA (move, -1, up, move);
443:
444: VectorScale (vec, step, vec);
445: ltime = (float) cl.time/1000.0;
446:
447: // for (i=0 ; i<len ; i++)
448: for (i=0 ; i<len ; i+=step)
449: {
450: d = i * 0.1 - fmod(ltime,16.0)*M_PI;
451: c = cos(d)/1.75;
452: s = sin(d)/1.75;
453: #ifdef DOUBLE_SCREW
454: for (k=-1; k<2; k+=2)
455: {
456: #else
457: k=1;
458: #endif
459: if (!free_particles)
460: return;
461:
462: p = free_particles;
463: free_particles = p->next;
464: p->next = active_particles;
465: active_particles = p;
466:
467: p->time = cl.time;
468: VectorClear (p->accel);
469:
470: p->alpha = 0.5;
471: // p->alphavel = -1.0 / (1+frand()*0.2);
472: // only last one frame!
473: p->alphavel = INSTANT_PARTICLE;
474: // p->color = 0x74 + (rand()&7);
475: // p->color = 223 - (rand()&7);
476: p->color = 223;
477: // p->color = 240;
478:
479: // trim it so it looks like it's starting at the origin
480: if (i < 10)
481: {
482: VectorScale (right, c*(i/10.0)*k, dir);
483: VectorMA (dir, s*(i/10.0)*k, up, dir);
484: }
485: else
486: {
487: VectorScale (right, c*k, dir);
488: VectorMA (dir, s*k, up, dir);
489: }
490:
491: for (j=0 ; j<3 ; j++)
492: {
493: p->org[j] = move[j] + dir[j]*3;
494: // p->vel[j] = dir[j]*6;
495: p->vel[j] = 0;
496: }
497: #ifdef DOUBLE_SCREW
498: }
499: #endif
500: VectorAdd (move, vec, move);
501: }
502: }
503: #endif
504: #ifdef RINGS
505: //void CL_Heatbeam (vec3_t start, vec3_t end)
506: void CL_Heatbeam (vec3_t start, vec3_t forward)
507: {
508: vec3_t move;
509: vec3_t vec;
510: float len;
511: int j;
512: cparticle_t *p;
513: vec3_t right, up;
514: int i;
515: float c, s;
516: vec3_t dir;
517: float ltime;
518: float step = 32.0, rstep;
519: float start_pt;
520: float rot;
521: float variance;
522: vec3_t end;
523:
524: VectorMA (start, 4096, forward, end);
525:
526: VectorCopy (start, move);
527: VectorSubtract (end, start, vec);
528: len = VectorNormalize (vec);
529:
530: // FIXME - pmm - these might end up using old values?
531: // MakeNormalVectors (vec, right, up);
532: VectorCopy (cl.v_right, right);
533: VectorCopy (cl.v_up, up);
534: if (vidref_val == VIDREF_GL)
535: { // GL mode
536: VectorMA (move, -0.5, right, move);
537: VectorMA (move, -0.5, up, move);
538: }
539: // otherwise assume SOFT
540:
541: ltime = (float) cl.time/1000.0;
542: start_pt = fmod(ltime*96.0,step);
543: VectorMA (move, start_pt, vec, move);
544:
545: VectorScale (vec, step, vec);
546:
547: // Com_Printf ("%f\n", ltime);
548: rstep = M_PI/10.0;
549: for (i=start_pt ; i<len ; i+=step)
550: {
551: if (i>step*5) // don't bother after the 5th ring
552: break;
553:
554: for (rot = 0; rot < M_PI*2; rot += rstep)
555: {
556:
557: if (!free_particles)
558: return;
559:
560: p = free_particles;
561: free_particles = p->next;
562: p->next = active_particles;
563: active_particles = p;
564:
565: p->time = cl.time;
566: VectorClear (p->accel);
567: // rot+= fmod(ltime, 12.0)*M_PI;
568: // c = cos(rot)/2.0;
569: // s = sin(rot)/2.0;
570: // variance = 0.4 + ((float)rand()/(float)RAND_MAX) *0.2;
571: variance = 0.5;
572: c = cos(rot)*variance;
573: s = sin(rot)*variance;
574:
575: // trim it so it looks like it's starting at the origin
576: if (i < 10)
577: {
578: VectorScale (right, c*(i/10.0), dir);
579: VectorMA (dir, s*(i/10.0), up, dir);
580: }
581: else
582: {
583: VectorScale (right, c, dir);
584: VectorMA (dir, s, up, dir);
585: }
586:
587: p->alpha = 0.5;
588: // p->alphavel = -1.0 / (1+frand()*0.2);
589: p->alphavel = -1000.0;
590: // p->color = 0x74 + (rand()&7);
591: p->color = 223 - (rand()&7);
592: for (j=0 ; j<3 ; j++)
593: {
594: p->org[j] = move[j] + dir[j]*3;
595: // p->vel[j] = dir[j]*6;
596: p->vel[j] = 0;
597: }
598: }
599: VectorAdd (move, vec, move);
600: }
601: }
602: #endif
603: #ifdef SPRAY
604: void CL_Heatbeam (vec3_t start, vec3_t end)
605: {
606: vec3_t move;
607: vec3_t vec;
608: float len;
609: int j;
610: cparticle_t *p;
611: vec3_t forward, right, up;
612: int i;
613: float d, c, s;
614: vec3_t dir;
615: float ltime;
616: float step = 32.0, rstep;
617: float start_pt;
618: float rot;
619:
620: VectorCopy (start, move);
621: VectorSubtract (end, start, vec);
622: len = VectorNormalize (vec);
623:
624: // MakeNormalVectors (vec, right, up);
625: VectorCopy (cl.v_forward, forward);
626: VectorCopy (cl.v_right, right);
627: VectorCopy (cl.v_up, up);
628: VectorMA (move, -0.5, right, move);
629: VectorMA (move, -0.5, up, move);
630:
631: for (i=0; i<8; i++)
632: {
633: if (!free_particles)
634: return;
635:
636: p = free_particles;
637: free_particles = p->next;
638: p->next = active_particles;
639: active_particles = p;
640:
641: p->time = cl.time;
642: VectorClear (p->accel);
643:
644: d = crand()*M_PI;
645: c = cos(d)*30;
646: s = sin(d)*30;
647:
648: p->alpha = 1.0;
649: p->alphavel = -5.0 / (1+frand());
650: p->color = 223 - (rand()&7);
651:
652: for (j=0 ; j<3 ; j++)
653: {
654: p->org[j] = move[j];
655: }
656: VectorScale (vec, 450, p->vel);
657: VectorMA (p->vel, c, right, p->vel);
658: VectorMA (p->vel, s, up, p->vel);
659: }
660: /*
661:
662: ltime = (float) cl.time/1000.0;
663: start_pt = fmod(ltime*16.0,step);
664: VectorMA (move, start_pt, vec, move);
665:
666: VectorScale (vec, step, vec);
667:
668: // Com_Printf ("%f\n", ltime);
669: rstep = M_PI/12.0;
670: for (i=start_pt ; i<len ; i+=step)
671: {
672: if (i>step*5) // don't bother after the 5th ring
673: break;
674:
675: for (rot = 0; rot < M_PI*2; rot += rstep)
676: {
677: if (!free_particles)
678: return;
679:
680: p = free_particles;
681: free_particles = p->next;
682: p->next = active_particles;
683: active_particles = p;
684:
685: p->time = cl.time;
686: VectorClear (p->accel);
687: // rot+= fmod(ltime, 12.0)*M_PI;
688: // c = cos(rot)/2.0;
689: // s = sin(rot)/2.0;
690: c = cos(rot)/1.5;
691: s = sin(rot)/1.5;
692:
693: // trim it so it looks like it's starting at the origin
694: if (i < 10)
695: {
696: VectorScale (right, c*(i/10.0), dir);
697: VectorMA (dir, s*(i/10.0), up, dir);
698: }
699: else
700: {
701: VectorScale (right, c, dir);
702: VectorMA (dir, s, up, dir);
703: }
704:
705: p->alpha = 0.5;
706: // p->alphavel = -1.0 / (1+frand()*0.2);
707: p->alphavel = -1000.0;
708: // p->color = 0x74 + (rand()&7);
709: p->color = 223 - (rand()&7);
710: for (j=0 ; j<3 ; j++)
711: {
712: p->org[j] = move[j] + dir[j]*3;
713: // p->vel[j] = dir[j]*6;
714: p->vel[j] = 0;
715: }
716: }
717: VectorAdd (move, vec, move);
718: }
719: */
720: }
721: #endif
722:
723: /*
724: ===============
725: CL_ParticleSteamEffect
726:
727: Puffs with velocity along direction, with some randomness thrown in
728: ===============
729: */
730: void CL_ParticleSteamEffect (vec3_t org, vec3_t dir, int color, int count, int magnitude)
731: {
732: int i, j;
733: cparticle_t *p;
734: float d;
735: vec3_t r, u;
736:
737: // vectoangles2 (dir, angle_dir);
738: // AngleVectors (angle_dir, f, r, u);
739:
740: MakeNormalVectors (dir, r, u);
741:
742: for (i=0 ; i<count ; i++)
743: {
744: if (!free_particles)
745: return;
746: p = free_particles;
747: free_particles = p->next;
748: p->next = active_particles;
749: active_particles = p;
750:
751: p->time = cl.time;
752: p->color = color + (rand()&7);
753:
754: for (j=0 ; j<3 ; j++)
755: {
756: p->org[j] = org[j] + magnitude*0.1*crand();
757: // p->vel[j] = dir[j]*magnitude;
758: }
759: VectorScale (dir, magnitude, p->vel);
760: d = crand()*magnitude/3;
761: VectorMA (p->vel, d, r, p->vel);
762: d = crand()*magnitude/3;
763: VectorMA (p->vel, d, u, p->vel);
764:
765: p->accel[0] = p->accel[1] = 0;
766: p->accel[2] = -PARTICLE_GRAVITY/2;
767: p->alpha = 1.0;
768:
769: p->alphavel = -1.0 / (0.5 + frand()*0.3);
770: }
771: }
772:
773: void CL_ParticleSteamEffect2 (cl_sustain_t *self)
774: //vec3_t org, vec3_t dir, int color, int count, int magnitude)
775: {
776: int i, j;
777: cparticle_t *p;
778: float d;
779: vec3_t r, u;
780: vec3_t dir;
781:
782: // vectoangles2 (dir, angle_dir);
783: // AngleVectors (angle_dir, f, r, u);
784:
785: VectorCopy (self->dir, dir);
786: MakeNormalVectors (dir, r, u);
787:
788: for (i=0 ; i<self->count ; i++)
789: {
790: if (!free_particles)
791: return;
792: p = free_particles;
793: free_particles = p->next;
794: p->next = active_particles;
795: active_particles = p;
796:
797: p->time = cl.time;
798: p->color = self->color + (rand()&7);
799:
800: for (j=0 ; j<3 ; j++)
801: {
802: p->org[j] = self->org[j] + self->magnitude*0.1*crand();
803: // p->vel[j] = dir[j]*magnitude;
804: }
805: VectorScale (dir, self->magnitude, p->vel);
806: d = crand()*self->magnitude/3;
807: VectorMA (p->vel, d, r, p->vel);
808: d = crand()*self->magnitude/3;
809: VectorMA (p->vel, d, u, p->vel);
810:
811: p->accel[0] = p->accel[1] = 0;
812: p->accel[2] = -PARTICLE_GRAVITY/2;
813: p->alpha = 1.0;
814:
815: p->alphavel = -1.0 / (0.5 + frand()*0.3);
816: }
817: self->nextthink += self->thinkinterval;
818: }
819:
820: /*
821: ===============
822: CL_TrackerTrail
823: ===============
824: */
825: void CL_TrackerTrail (vec3_t start, vec3_t end, int particleColor)
826: {
827: vec3_t move;
828: vec3_t vec;
829: vec3_t forward,right,up,angle_dir;
830: float len;
831: int j;
832: cparticle_t *p;
833: int dec;
834: float dist;
835:
836: VectorCopy (start, move);
837: VectorSubtract (end, start, vec);
838: len = VectorNormalize (vec);
839:
840: VectorCopy(vec, forward);
841: vectoangles2 (forward, angle_dir);
842: AngleVectors (angle_dir, forward, right, up);
843:
844: dec = 3;
845: VectorScale (vec, 3, vec);
846:
847: // FIXME: this is a really silly way to have a loop
848: while (len > 0)
849: {
850: len -= dec;
851:
852: if (!free_particles)
853: return;
854: p = free_particles;
855: free_particles = p->next;
856: p->next = active_particles;
857: active_particles = p;
858: VectorClear (p->accel);
859:
860: p->time = cl.time;
861:
862: p->alpha = 1.0;
863: p->alphavel = -2.0;
864: p->color = particleColor;
865: dist = DotProduct(move, forward);
866: VectorMA(move, 8 * cos(dist), up, p->org);
867: for (j=0 ; j<3 ; j++)
868: {
869: // p->org[j] = move[j] + crand();
870: p->vel[j] = 0;
871: p->accel[j] = 0;
872: }
873: p->vel[2] = 5;
874:
875: VectorAdd (move, vec, move);
876: }
877: }
878:
879: void CL_Tracker_Shell(vec3_t origin)
880: {
881: vec3_t dir;
882: int i;
883: cparticle_t *p;
884:
885: for(i=0;i<300;i++)
886: {
887: if (!free_particles)
888: return;
889: p = free_particles;
890: free_particles = p->next;
891: p->next = active_particles;
892: active_particles = p;
893: VectorClear (p->accel);
894:
895: p->time = cl.time;
896:
897: p->alpha = 1.0;
898: p->alphavel = INSTANT_PARTICLE;
899: p->color = 0;
900:
901: dir[0] = crand();
902: dir[1] = crand();
903: dir[2] = crand();
904: VectorNormalize(dir);
905:
906: VectorMA(origin, 40, dir, p->org);
907: }
908: }
909:
910: void CL_MonsterPlasma_Shell(vec3_t origin)
911: {
912: vec3_t dir;
913: int i;
914: cparticle_t *p;
915:
916: for(i=0;i<40;i++)
917: {
918: if (!free_particles)
919: return;
920: p = free_particles;
921: free_particles = p->next;
922: p->next = active_particles;
923: active_particles = p;
924: VectorClear (p->accel);
925:
926: p->time = cl.time;
927:
928: p->alpha = 1.0;
929: p->alphavel = INSTANT_PARTICLE;
930: p->color = 0xe0;
931:
932: dir[0] = crand();
933: dir[1] = crand();
934: dir[2] = crand();
935: VectorNormalize(dir);
936:
937: VectorMA(origin, 10, dir, p->org);
938: // VectorMA(origin, 10*(((rand () & 0x7fff) / ((float)0x7fff))), dir, p->org);
939: }
940: }
941:
942: void CL_Widowbeamout (cl_sustain_t *self)
943: {
944: vec3_t dir;
945: int i;
946: cparticle_t *p;
947: static int colortable[4] = {2*8,13*8,21*8,18*8};
948: float ratio;
949:
950: ratio = 1.0 - (((float)self->endtime - (float)cl.time)/2100.0);
951:
952: for(i=0;i<300;i++)
953: {
954: if (!free_particles)
955: return;
956: p = free_particles;
957: free_particles = p->next;
958: p->next = active_particles;
959: active_particles = p;
960: VectorClear (p->accel);
961:
962: p->time = cl.time;
963:
964: p->alpha = 1.0;
965: p->alphavel = INSTANT_PARTICLE;
966: p->color = colortable[rand()&3];
967:
968: dir[0] = crand();
969: dir[1] = crand();
970: dir[2] = crand();
971: VectorNormalize(dir);
972:
973: VectorMA(self->org, (45.0 * ratio), dir, p->org);
974: // VectorMA(origin, 10*(((rand () & 0x7fff) / ((float)0x7fff))), dir, p->org);
975: }
976: }
977:
978: void CL_Nukeblast (cl_sustain_t *self)
979: {
980: vec3_t dir;
981: int i;
982: cparticle_t *p;
983: static int colortable[4] = {110, 112, 114, 116};
984: float ratio;
985:
986: ratio = 1.0 - (((float)self->endtime - (float)cl.time)/1000.0);
987:
988: for(i=0;i<700;i++)
989: {
990: if (!free_particles)
991: return;
992: p = free_particles;
993: free_particles = p->next;
994: p->next = active_particles;
995: active_particles = p;
996: VectorClear (p->accel);
997:
998: p->time = cl.time;
999:
1000: p->alpha = 1.0;
1001: p->alphavel = INSTANT_PARTICLE;
1002: p->color = colortable[rand()&3];
1003:
1004: dir[0] = crand();
1005: dir[1] = crand();
1006: dir[2] = crand();
1007: VectorNormalize(dir);
1008:
1009: VectorMA(self->org, (200.0 * ratio), dir, p->org);
1010: // VectorMA(origin, 10*(((rand () & 0x7fff) / ((float)0x7fff))), dir, p->org);
1011: }
1012: }
1013:
1014: void CL_WidowSplash (vec3_t org)
1015: {
1016: static int colortable[4] = {2*8,13*8,21*8,18*8};
1017: int i;
1018: cparticle_t *p;
1019: vec3_t dir;
1020:
1021: for (i=0 ; i<256 ; i++)
1022: {
1023: if (!free_particles)
1024: return;
1025: p = free_particles;
1026: free_particles = p->next;
1027: p->next = active_particles;
1028: active_particles = p;
1029:
1030: p->time = cl.time;
1031: p->color = colortable[rand()&3];
1032:
1033: dir[0] = crand();
1034: dir[1] = crand();
1035: dir[2] = crand();
1036: VectorNormalize(dir);
1037: VectorMA(org, 45.0, dir, p->org);
1038: VectorMA(vec3_origin, 40.0, dir, p->vel);
1039:
1040: p->accel[0] = p->accel[1] = 0;
1041: p->alpha = 1.0;
1042:
1043: p->alphavel = -0.8 / (0.5 + frand()*0.3);
1044: }
1045:
1046: }
1047:
1048: void CL_Tracker_Explode(vec3_t origin)
1049: {
1050: vec3_t dir, backdir;
1051: int i;
1052: cparticle_t *p;
1053:
1054: for(i=0;i<300;i++)
1055: {
1056: if (!free_particles)
1057: return;
1058: p = free_particles;
1059: free_particles = p->next;
1060: p->next = active_particles;
1061: active_particles = p;
1062: VectorClear (p->accel);
1063:
1064: p->time = cl.time;
1065:
1066: p->alpha = 1.0;
1067: p->alphavel = -1.0;
1068: p->color = 0;
1069:
1070: dir[0] = crand();
1071: dir[1] = crand();
1072: dir[2] = crand();
1073: VectorNormalize(dir);
1074: VectorScale(dir, -1, backdir);
1075:
1076: VectorMA(origin, 64, dir, p->org);
1077: VectorScale(backdir, 64, p->vel);
1078: }
1079:
1080: }
1081:
1082: /*
1083: ===============
1084: CL_TagTrail
1085:
1086: ===============
1087: */
1088: void CL_TagTrail (vec3_t start, vec3_t end, float color)
1089: {
1090: vec3_t move;
1091: vec3_t vec;
1092: float len;
1093: int j;
1094: cparticle_t *p;
1095: int dec;
1096:
1097: VectorCopy (start, move);
1098: VectorSubtract (end, start, vec);
1099: len = VectorNormalize (vec);
1100:
1101: dec = 5;
1102: VectorScale (vec, 5, vec);
1103:
1104: while (len >= 0)
1105: {
1106: len -= dec;
1107:
1108: if (!free_particles)
1109: return;
1110: p = free_particles;
1111: free_particles = p->next;
1112: p->next = active_particles;
1113: active_particles = p;
1114: VectorClear (p->accel);
1115:
1116: p->time = cl.time;
1117:
1118: p->alpha = 1.0;
1119: p->alphavel = -1.0 / (0.8+frand()*0.2);
1120: p->color = color;
1121: for (j=0 ; j<3 ; j++)
1122: {
1123: p->org[j] = move[j] + crand()*16;
1124: p->vel[j] = crand()*5;
1125: p->accel[j] = 0;
1126: }
1127:
1128: VectorAdd (move, vec, move);
1129: }
1130: }
1131:
1132: /*
1133: ===============
1134: CL_ColorExplosionParticles
1135: ===============
1136: */
1137: void CL_ColorExplosionParticles (vec3_t org, int color, int run)
1138: {
1139: int i, j;
1140: cparticle_t *p;
1141:
1142: for (i=0 ; i<128 ; i++)
1143: {
1144: if (!free_particles)
1145: return;
1146: p = free_particles;
1147: free_particles = p->next;
1148: p->next = active_particles;
1149: active_particles = p;
1150:
1151: p->time = cl.time;
1152: p->color = color + (rand() % run);
1153:
1154: for (j=0 ; j<3 ; j++)
1155: {
1156: p->org[j] = org[j] + ((rand()%32)-16);
1157: p->vel[j] = (rand()%256)-128;
1158: }
1159:
1160: p->accel[0] = p->accel[1] = 0;
1161: p->accel[2] = -PARTICLE_GRAVITY;
1162: p->alpha = 1.0;
1163:
1164: p->alphavel = -0.4 / (0.6 + frand()*0.2);
1165: }
1166: }
1167:
1168: /*
1169: ===============
1170: CL_ParticleSmokeEffect - like the steam effect, but unaffected by gravity
1171: ===============
1172: */
1173: void CL_ParticleSmokeEffect (vec3_t org, vec3_t dir, int color, int count, int magnitude)
1174: {
1175: int i, j;
1176: cparticle_t *p;
1177: float d;
1178: vec3_t r, u;
1179:
1180: MakeNormalVectors (dir, r, u);
1181:
1182: for (i=0 ; i<count ; i++)
1183: {
1184: if (!free_particles)
1185: return;
1186: p = free_particles;
1187: free_particles = p->next;
1188: p->next = active_particles;
1189: active_particles = p;
1190:
1191: p->time = cl.time;
1192: p->color = color + (rand()&7);
1193:
1194: for (j=0 ; j<3 ; j++)
1195: {
1196: p->org[j] = org[j] + magnitude*0.1*crand();
1197: // p->vel[j] = dir[j]*magnitude;
1198: }
1199: VectorScale (dir, magnitude, p->vel);
1200: d = crand()*magnitude/3;
1201: VectorMA (p->vel, d, r, p->vel);
1202: d = crand()*magnitude/3;
1203: VectorMA (p->vel, d, u, p->vel);
1204:
1205: p->accel[0] = p->accel[1] = p->accel[2] = 0;
1206: p->alpha = 1.0;
1207:
1208: p->alphavel = -1.0 / (0.5 + frand()*0.3);
1209: }
1210: }
1211:
1212: /*
1213: ===============
1214: CL_BlasterParticles2
1215:
1216: Wall impact puffs (Green)
1217: ===============
1218: */
1219: void CL_BlasterParticles2 (vec3_t org, vec3_t dir, unsigned int color)
1220: {
1221: int i, j;
1222: cparticle_t *p;
1223: float d;
1224: int count;
1225:
1226: count = 40;
1227: for (i=0 ; i<count ; i++)
1228: {
1229: if (!free_particles)
1230: return;
1231: p = free_particles;
1232: free_particles = p->next;
1233: p->next = active_particles;
1234: active_particles = p;
1235:
1236: p->time = cl.time;
1237: p->color = color + (rand()&7);
1238:
1239: d = rand()&15;
1240: for (j=0 ; j<3 ; j++)
1241: {
1242: p->org[j] = org[j] + ((rand()&7)-4) + d*dir[j];
1243: p->vel[j] = dir[j] * 30 + crand()*40;
1244: }
1245:
1246: p->accel[0] = p->accel[1] = 0;
1247: p->accel[2] = -PARTICLE_GRAVITY;
1248: p->alpha = 1.0;
1249:
1250: p->alphavel = -1.0 / (0.5 + frand()*0.3);
1251: }
1252: }
1253:
1254: /*
1255: ===============
1256: CL_BlasterTrail2
1257:
1258: Green!
1259: ===============
1260: */
1261: void CL_BlasterTrail2 (vec3_t start, vec3_t end)
1262: {
1263: vec3_t move;
1264: vec3_t vec;
1265: float len;
1266: int j;
1267: cparticle_t *p;
1268: int dec;
1269:
1270: VectorCopy (start, move);
1271: VectorSubtract (end, start, vec);
1272: len = VectorNormalize (vec);
1273:
1274: dec = 5;
1275: VectorScale (vec, 5, vec);
1276:
1277: // FIXME: this is a really silly way to have a loop
1278: while (len > 0)
1279: {
1280: len -= dec;
1281:
1282: if (!free_particles)
1283: return;
1284: p = free_particles;
1285: free_particles = p->next;
1286: p->next = active_particles;
1287: active_particles = p;
1288: VectorClear (p->accel);
1289:
1290: p->time = cl.time;
1291:
1292: p->alpha = 1.0;
1293: p->alphavel = -1.0 / (0.3+frand()*0.2);
1294: p->color = 0xd0;
1295: for (j=0 ; j<3 ; j++)
1296: {
1297: p->org[j] = move[j] + crand();
1298: p->vel[j] = crand()*5;
1299: p->accel[j] = 0;
1300: }
1301:
1302: VectorAdd (move, vec, move);
1303: }
1304: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.