summaryrefslogtreecommitdiff
path: root/apps/plugins/sdl/progs/quake/r_part.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/plugins/sdl/progs/quake/r_part.c')
-rw-r--r--apps/plugins/sdl/progs/quake/r_part.c802
1 files changed, 802 insertions, 0 deletions
diff --git a/apps/plugins/sdl/progs/quake/r_part.c b/apps/plugins/sdl/progs/quake/r_part.c
new file mode 100644
index 0000000000..8c0dcff5e8
--- /dev/null
+++ b/apps/plugins/sdl/progs/quake/r_part.c
@@ -0,0 +1,802 @@
1/*
2Copyright (C) 1996-1997 Id Software, Inc.
3
4This program is free software; you can redistribute it and/or
5modify it under the terms of the GNU General Public License
6as published by the Free Software Foundation; either version 2
7of the License, or (at your option) any later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13See the GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License
16along with this program; if not, write to the Free Software
17Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19*/
20
21#include "quakedef.h"
22#include "r_local.h"
23
24#define MAX_PARTICLES 2048 // default max # of particles at one
25 // time
26#define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's
27 // on the command line
28
29int ramp1[8] = {0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61};
30int ramp2[8] = {0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66};
31int ramp3[8] = {0x6d, 0x6b, 6, 5, 4, 3};
32
33particle_t *active_particles, *free_particles;
34
35particle_t *particles;
36int r_numparticles;
37
38vec3_t r_pright, r_pup, r_ppn;
39
40
41/*
42===============
43R_InitParticles
44===============
45*/
46void R_InitParticles (void)
47{
48 int i;
49
50 i = COM_CheckParm ("-particles");
51
52 if (i)
53 {
54 r_numparticles = (int)(Q_atoi(com_argv[i+1]));
55 if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
56 r_numparticles = ABSOLUTE_MIN_PARTICLES;
57 }
58 else
59 {
60 r_numparticles = MAX_PARTICLES;
61 }
62
63 particles = (particle_t *)
64 Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
65}
66
67#ifdef QUAKE2
68void R_DarkFieldParticles (entity_t *ent)
69{
70 int i, j, k;
71 particle_t *p;
72 float vel;
73 vec3_t dir;
74 vec3_t org;
75
76 org[0] = ent->origin[0];
77 org[1] = ent->origin[1];
78 org[2] = ent->origin[2];
79 for (i=-16 ; i<16 ; i+=8)
80 for (j=-16 ; j<16 ; j+=8)
81 for (k=0 ; k<32 ; k+=8)
82 {
83 if (!free_particles)
84 return;
85 p = free_particles;
86 free_particles = p->next;
87 p->next = active_particles;
88 active_particles = p;
89
90 p->die = cl.time + 0.2 + (rand()&7) * 0.02;
91 p->color = 150 + rand()%6;
92 p->type = pt_slowgrav;
93
94 dir[0] = j*8;
95 dir[1] = i*8;
96 dir[2] = k*8;
97
98 p->org[0] = org[0] + i + (rand()&3);
99 p->org[1] = org[1] + j + (rand()&3);
100 p->org[2] = org[2] + k + (rand()&3);
101
102 VectorNormalizeNoRet (dir);
103 vel = 50 + (rand()&63);
104 VectorScale (dir, vel, p->vel);
105 }
106}
107#endif
108
109
110/*
111===============
112R_EntityParticles
113===============
114*/
115
116#define NUMVERTEXNORMALS 162
117extern float r_avertexnormals[NUMVERTEXNORMALS][3];
118vec3_t avelocities[NUMVERTEXNORMALS];
119float beamlength = 16;
120vec3_t avelocity = {23, 7, 3};
121float partstep = 0.01;
122float timescale = 0.01;
123
124void R_EntityParticles (entity_t *ent)
125{
126 int count;
127 int i;
128 particle_t *p;
129 float angle;
130 float sr, sp, sy, cr, cp, cy;
131 vec3_t forward;
132 float dist;
133
134 dist = 64;
135 count = 50;
136
137if (!avelocities[0][0])
138{
139for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
140avelocities[0][i] = (rand()&255) * 0.01;
141}
142
143
144 for (i=0 ; i<NUMVERTEXNORMALS ; i++)
145 {
146 angle = cl.time * avelocities[i][0];
147 sy = sin(angle);
148 cy = cos(angle);
149 angle = cl.time * avelocities[i][1];
150 sp = sin(angle);
151 cp = cos(angle);
152 angle = cl.time * avelocities[i][2];
153 sr = sin(angle);
154 cr = cos(angle);
155
156 forward[0] = cp*cy;
157 forward[1] = cp*sy;
158 forward[2] = -sp;
159
160 if (!free_particles)
161 return;
162 p = free_particles;
163 free_particles = p->next;
164 p->next = active_particles;
165 active_particles = p;
166
167 p->die = cl.time + 0.01;
168 p->color = 0x6f;
169 p->type = pt_explode;
170
171 p->org[0] = ent->origin[0] + r_avertexnormals[i][0]*dist + forward[0]*beamlength;
172 p->org[1] = ent->origin[1] + r_avertexnormals[i][1]*dist + forward[1]*beamlength;
173 p->org[2] = ent->origin[2] + r_avertexnormals[i][2]*dist + forward[2]*beamlength;
174 }
175}
176
177
178/*
179===============
180R_ClearParticles
181===============
182*/
183void R_ClearParticles (void)
184{
185 int i;
186
187 free_particles = &particles[0];
188 active_particles = NULL;
189
190 for (i=0 ;i<r_numparticles ; i++)
191 particles[i].next = &particles[i+1];
192 particles[r_numparticles-1].next = NULL;
193}
194
195
196void R_ReadPointFile_f (void)
197{
198 FILE *f;
199 vec3_t org;
200 int r;
201 int c;
202 particle_t *p;
203 char name[MAX_OSPATH];
204
205 sprintf (name,"maps/%s.pts", sv.name);
206
207 COM_FOpenFile (name, &f);
208 if (!f)
209 {
210 Con_Printf ("couldn't open %s\n", name);
211 return;
212 }
213
214 Con_Printf ("Reading %s...\n", name);
215 c = 0;
216 for ( ;; )
217 {
218 r = fscanf (f,"%f ", &org[0]);
219 r += fscanf (f,"%f ", &org[1]);
220 r += fscanf (f,"%f\n", &org[2]);
221 if (r != 3)
222 break;
223 c++;
224
225 if (!free_particles)
226 {
227 Con_Printf ("Not enough free particles\n");
228 break;
229 }
230 p = free_particles;
231 free_particles = p->next;
232 p->next = active_particles;
233 active_particles = p;
234
235 p->die = 99999;
236 p->color = (-c)&15;
237 p->type = pt_static;
238 VectorCopy (vec3_origin, p->vel);
239 VectorCopy (org, p->org);
240 }
241
242 fclose (f);
243 Con_Printf ("%i points read\n", c);
244}
245
246/*
247===============
248R_ParseParticleEffect
249
250Parse an effect out of the server message
251===============
252*/
253void R_ParseParticleEffect (void)
254{
255 vec3_t org, dir;
256 int i, count, msgcount, color;
257
258 for (i=0 ; i<3 ; i++)
259 org[i] = MSG_ReadCoord ();
260 for (i=0 ; i<3 ; i++)
261 dir[i] = MSG_ReadChar () * (1.0/16);
262 msgcount = MSG_ReadByte ();
263 color = MSG_ReadByte ();
264
265if (msgcount == 255)
266 count = 1024;
267else
268 count = msgcount;
269
270 R_RunParticleEffect (org, dir, color, count);
271}
272
273/*
274===============
275R_ParticleExplosion
276
277===============
278*/
279void R_ParticleExplosion (vec3_t org)
280{
281 int i, j;
282 particle_t *p;
283
284 for (i=0 ; i<1024 ; i++)
285 {
286 if (!free_particles)
287 return;
288 p = free_particles;
289 free_particles = p->next;
290 p->next = active_particles;
291 active_particles = p;
292
293 p->die = cl.time + 5;
294 p->color = ramp1[0];
295 p->ramp = rand()&3;
296 if (i & 1)
297 {
298 p->type = pt_explode;
299 for (j=0 ; j<3 ; j++)
300 {
301 p->org[j] = org[j] + ((rand()%32)-16);
302 p->vel[j] = (rand()%512)-256;
303 }
304 }
305 else
306 {
307 p->type = pt_explode2;
308 for (j=0 ; j<3 ; j++)
309 {
310 p->org[j] = org[j] + ((rand()%32)-16);
311 p->vel[j] = (rand()%512)-256;
312 }
313 }
314 }
315}
316
317/*
318===============
319R_ParticleExplosion2
320
321===============
322*/
323void R_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
324{
325 int i, j;
326 particle_t *p;
327 int colorMod = 0;
328
329 for (i=0; i<512; i++)
330 {
331 if (!free_particles)
332 return;
333 p = free_particles;
334 free_particles = p->next;
335 p->next = active_particles;
336 active_particles = p;
337
338 p->die = cl.time + 0.3;
339 p->color = colorStart + (colorMod % colorLength);
340 colorMod++;
341
342 p->type = pt_blob;
343 for (j=0 ; j<3 ; j++)
344 {
345 p->org[j] = org[j] + ((rand()%32)-16);
346 p->vel[j] = (rand()%512)-256;
347 }
348 }
349}
350
351/*
352===============
353R_BlobExplosion
354
355===============
356*/
357void R_BlobExplosion (vec3_t org)
358{
359 int i, j;
360 particle_t *p;
361
362 for (i=0 ; i<1024 ; i++)
363 {
364 if (!free_particles)
365 return;
366 p = free_particles;
367 free_particles = p->next;
368 p->next = active_particles;
369 active_particles = p;
370
371 p->die = cl.time + 1 + (rand()&8)*0.05;
372
373 if (i & 1)
374 {
375 p->type = pt_blob;
376 p->color = 66 + rand()%6;
377 for (j=0 ; j<3 ; j++)
378 {
379 p->org[j] = org[j] + ((rand()%32)-16);
380 p->vel[j] = (rand()%512)-256;
381 }
382 }
383 else
384 {
385 p->type = pt_blob2;
386 p->color = 150 + rand()%6;
387 for (j=0 ; j<3 ; j++)
388 {
389 p->org[j] = org[j] + ((rand()%32)-16);
390 p->vel[j] = (rand()%512)-256;
391 }
392 }
393 }
394}
395
396/*
397===============
398R_RunParticleEffect
399
400===============
401*/
402void R_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
403{
404 int i, j;
405 particle_t *p;
406
407 for (i=0 ; i<count ; i++)
408 {
409 if (!free_particles)
410 return;
411 p = free_particles;
412 free_particles = p->next;
413 p->next = active_particles;
414 active_particles = p;
415
416 if (count == 1024)
417 { // rocket explosion
418 p->die = cl.time + 5;
419 p->color = ramp1[0];
420 p->ramp = rand()&3;
421 if (i & 1)
422 {
423 p->type = pt_explode;
424 for (j=0 ; j<3 ; j++)
425 {
426 p->org[j] = org[j] + ((rand()%32)-16);
427 p->vel[j] = (rand()%512)-256;
428 }
429 }
430 else
431 {
432 p->type = pt_explode2;
433 for (j=0 ; j<3 ; j++)
434 {
435 p->org[j] = org[j] + ((rand()%32)-16);
436 p->vel[j] = (rand()%512)-256;
437 }
438 }
439 }
440 else
441 {
442 p->die = cl.time + 0.1*(rand()%5);
443 p->color = (color&~7) + (rand()&7);
444 p->type = pt_slowgrav;
445 for (j=0 ; j<3 ; j++)
446 {
447 p->org[j] = org[j] + ((rand()&15)-8);
448 p->vel[j] = dir[j]*15;// + (rand()%300)-150;
449 }
450 }
451 }
452}
453
454
455/*
456===============
457R_LavaSplash
458
459===============
460*/
461void R_LavaSplash (vec3_t org)
462{
463 int i, j, k;
464 particle_t *p;
465 float vel;
466 vec3_t dir;
467
468 for (i=-16 ; i<16 ; i++)
469 for (j=-16 ; j<16 ; j++)
470 for (k=0 ; k<1 ; k++)
471 {
472 if (!free_particles)
473 return;
474 p = free_particles;
475 free_particles = p->next;
476 p->next = active_particles;
477 active_particles = p;
478
479 p->die = cl.time + 2 + (rand()&31) * 0.02;
480 p->color = 224 + (rand()&7);
481 p->type = pt_slowgrav;
482
483 dir[0] = j*8 + (rand()&7);
484 dir[1] = i*8 + (rand()&7);
485 dir[2] = 256;
486
487 p->org[0] = org[0] + dir[0];
488 p->org[1] = org[1] + dir[1];
489 p->org[2] = org[2] + (rand()&63);
490
491 VectorNormalizeNoRet (dir);
492 vel = 50 + (rand()&63);
493 VectorScale (dir, vel, p->vel);
494 }
495}
496
497/*
498===============
499R_TeleportSplash
500
501===============
502*/
503void R_TeleportSplash (vec3_t org)
504{
505 int i, j, k;
506 particle_t *p;
507 float vel;
508 vec3_t dir;
509
510 for (i=-16 ; i<16 ; i+=4)
511 for (j=-16 ; j<16 ; j+=4)
512 for (k=-24 ; k<32 ; k+=4)
513 {
514 if (!free_particles)
515 return;
516 p = free_particles;
517 free_particles = p->next;
518 p->next = active_particles;
519 active_particles = p;
520
521 p->die = cl.time + 0.2 + (rand()&7) * 0.02;
522 p->color = 7 + (rand()&7);
523 p->type = pt_slowgrav;
524
525 dir[0] = j*8;
526 dir[1] = i*8;
527 dir[2] = k*8;
528
529 p->org[0] = org[0] + i + (rand()&3);
530 p->org[1] = org[1] + j + (rand()&3);
531 p->org[2] = org[2] + k + (rand()&3);
532
533 VectorNormalizeNoRet (dir);
534 vel = 50 + (rand()&63);
535 VectorScale (dir, vel, p->vel);
536 }
537}
538
539void R_RocketTrail (vec3_t start, vec3_t end, int type)
540{
541 vec3_t vec;
542 float len;
543 int j;
544 particle_t *p;
545 int dec;
546 static int tracercount;
547
548 VectorSubtract (end, start, vec);
549 len = VectorNormalize (vec);
550 if (type < 128)
551 dec = 3;
552 else
553 {
554 dec = 1;
555 type -= 128;
556 }
557
558 while (len > 0)
559 {
560 len -= dec;
561
562 if (!free_particles)
563 return;
564 p = free_particles;
565 free_particles = p->next;
566 p->next = active_particles;
567 active_particles = p;
568
569 VectorCopy (vec3_origin, p->vel);
570 p->die = cl.time + 2;
571
572 switch (type)
573 {
574 case 0: // rocket trail
575 p->ramp = (rand()&3);
576 p->color = ramp3[(int)p->ramp];
577 p->type = pt_fire;
578 for (j=0 ; j<3 ; j++)
579 p->org[j] = start[j] + ((rand()%6)-3);
580 break;
581
582 case 1: // smoke smoke
583 p->ramp = (rand()&3) + 2;
584 p->color = ramp3[(int)p->ramp];
585 p->type = pt_fire;
586 for (j=0 ; j<3 ; j++)
587 p->org[j] = start[j] + ((rand()%6)-3);
588 break;
589
590 case 2: // blood
591 p->type = pt_grav;
592 p->color = 67 + (rand()&3);
593 for (j=0 ; j<3 ; j++)
594 p->org[j] = start[j] + ((rand()%6)-3);
595 break;
596
597 case 3:
598 case 5: // tracer
599 p->die = cl.time + 0.5;
600 p->type = pt_static;
601 if (type == 3)
602 p->color = 52 + ((tracercount&4)<<1);
603 else
604 p->color = 230 + ((tracercount&4)<<1);
605
606 tracercount++;
607
608 VectorCopy (start, p->org);
609 if (tracercount & 1)
610 {
611 p->vel[0] = 30*vec[1];
612 p->vel[1] = 30*-vec[0];
613 }
614 else
615 {
616 p->vel[0] = 30*-vec[1];
617 p->vel[1] = 30*vec[0];
618 }
619 break;
620
621 case 4: // slight blood
622 p->type = pt_grav;
623 p->color = 67 + (rand()&3);
624 for (j=0 ; j<3 ; j++)
625 p->org[j] = start[j] + ((rand()%6)-3);
626 len -= 3;
627 break;
628
629 case 6: // voor trail
630 p->color = 9*16 + 8 + (rand()&3);
631 p->type = pt_static;
632 p->die = cl.time + 0.3;
633 for (j=0 ; j<3 ; j++)
634 p->org[j] = start[j] + ((rand()&15)-8);
635 break;
636 }
637
638
639 VectorAdd (start, vec, start);
640 }
641}
642
643
644/*
645===============
646R_DrawParticles
647===============
648*/
649extern cvar_t sv_gravity;
650
651void R_DrawParticles (void)
652{
653 particle_t *p, *kill;
654 float grav;
655 int i;
656 float time2, time3;
657 float time1;
658 float dvel;
659 float frametime;
660
661#ifdef GLQUAKE
662 vec3_t up, right;
663 float scale;
664
665 GL_Bind(particletexture);
666 glEnable (GL_BLEND);
667 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
668 glBegin (GL_TRIANGLES);
669
670 VectorScale (vup, 1.5, up);
671 VectorScale (vright, 1.5, right);
672#else
673 D_StartParticles ();
674
675 VectorScale (vright, xscaleshrink, r_pright);
676 VectorScale (vup, yscaleshrink, r_pup);
677 VectorCopy (vpn, r_ppn);
678#endif
679 frametime = cl.time - cl.oldtime;
680 time3 = frametime * 15;
681 time2 = frametime * 10; // 15;
682 time1 = frametime * 5;
683 grav = frametime * sv_gravity.value * 0.05;
684 dvel = 4*frametime;
685
686 for ( ;; )
687 {
688 kill = active_particles;
689 if (kill && kill->die < cl.time)
690 {
691 active_particles = kill->next;
692 kill->next = free_particles;
693 free_particles = kill;
694 continue;
695 }
696 break;
697 }
698
699 for (p=active_particles ; p ; p=p->next)
700 {
701 for ( ;; )
702 {
703 kill = p->next;
704 if (kill && kill->die < cl.time)
705 {
706 p->next = kill->next;
707 kill->next = free_particles;
708 free_particles = kill;
709 continue;
710 }
711 break;
712 }
713
714#ifdef GLQUAKE
715 // hack a scale up to keep particles from disapearing
716 scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
717 + (p->org[2] - r_origin[2])*vpn[2];
718 if (scale < 20)
719 scale = 1;
720 else
721 scale = 1 + scale * 0.004;
722 glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
723 glTexCoord2f (0,0);
724 glVertex3fv (p->org);
725 glTexCoord2f (1,0);
726 glVertex3f (p->org[0] + up[0]*scale, p->org[1] + up[1]*scale, p->org[2] + up[2]*scale);
727 glTexCoord2f (0,1);
728 glVertex3f (p->org[0] + right[0]*scale, p->org[1] + right[1]*scale, p->org[2] + right[2]*scale);
729#else
730 D_DrawParticle (p);
731#endif
732 p->org[0] += p->vel[0]*frametime;
733 p->org[1] += p->vel[1]*frametime;
734 p->org[2] += p->vel[2]*frametime;
735
736 switch (p->type)
737 {
738 case pt_static:
739 break;
740 case pt_fire:
741 p->ramp += time1;
742 if (p->ramp >= 6)
743 p->die = -1;
744 else
745 p->color = ramp3[(int)p->ramp];
746 p->vel[2] += grav;
747 break;
748
749 case pt_explode:
750 p->ramp += time2;
751 if (p->ramp >=8)
752 p->die = -1;
753 else
754 p->color = ramp1[(int)p->ramp];
755 for (i=0 ; i<3 ; i++)
756 p->vel[i] += p->vel[i]*dvel;
757 p->vel[2] -= grav;
758 break;
759
760 case pt_explode2:
761 p->ramp += time3;
762 if (p->ramp >=8)
763 p->die = -1;
764 else
765 p->color = ramp2[(int)p->ramp];
766 for (i=0 ; i<3 ; i++)
767 p->vel[i] -= p->vel[i]*frametime;
768 p->vel[2] -= grav;
769 break;
770
771 case pt_blob:
772 for (i=0 ; i<3 ; i++)
773 p->vel[i] += p->vel[i]*dvel;
774 p->vel[2] -= grav;
775 break;
776
777 case pt_blob2:
778 for (i=0 ; i<2 ; i++)
779 p->vel[i] -= p->vel[i]*dvel;
780 p->vel[2] -= grav;
781 break;
782
783 case pt_grav:
784#ifdef QUAKE2
785 p->vel[2] -= grav * 20;
786 break;
787#endif
788 case pt_slowgrav:
789 p->vel[2] -= grav;
790 break;
791 }
792 }
793
794#ifdef GLQUAKE
795 glEnd ();
796 glDisable (GL_BLEND);
797 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
798#else
799 D_EndParticles ();
800#endif
801}
802
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-20 02:58:18 +0000