Merge remote-tracking branch 'origin/divVerent/allow-override-item-model'
[xonotic/xonotic-data.pk3dir.git] / 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                                 self.origin = 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         self.origin = 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 entity zcurve;
229 void zcurveparticles(float effectnum, vector start, vector end, float end_dz, float speed, float depth)
230 {
231         // end_dz:
232         //   IF IT WERE A STRAIGHT LINE, it'd end end_dz above end
233
234         vector mid;
235         mid = (start + end) * 0.5;
236
237         end_dz *= 0.25;
238         mid_z += end_dz;
239
240         --depth;
241         if(depth < 0 || normalize(mid - start) * normalize(end - start) > 0.999999)
242         // TODO make this a variable threshold
243         // currently: 0.081 degrees
244         // 0.99999 would be 0.256 degrees and is visible
245         {
246                 zcurve.velocity = speed * normalize(end - start);
247                 trailparticles(zcurve, effectnum, start, end);
248         }
249         else
250         {
251                 zcurveparticles(effectnum, start, mid, end_dz, speed, depth);
252                 zcurveparticles(effectnum, mid, end, end_dz, speed, depth);
253         }
254 }
255
256 void Net_ReadZCurveParticles()
257 {
258         vector start, end;
259         float end_dz;
260         float effectnum, speed;
261
262         if(!zcurve)
263         {
264                 zcurve = spawn();
265                 zcurve.classname = "zcurve";
266         }
267
268         effectnum = ReadShort();
269
270         start_x = ReadCoord();
271         start_y = ReadCoord();
272         start_z = ReadCoord();
273
274         do
275         {
276                 end_x = ReadCoord();
277                 end_y = ReadCoord();
278                 end_z = ReadCoord();
279                 end_dz = ReadCoord();
280                 speed = ReadShort();
281                 zcurveparticles(effectnum, start, end, end_dz, 16 * (speed & 0x7FFF), 5); // at most 32 segments
282         }
283         while(!(speed & 0x8000));
284 }
285
286 void Net_ReadNexgunBeamParticle()
287 {
288         vector shotorg, endpos;
289         float charge;
290         shotorg_x = ReadCoord(); shotorg_y = ReadCoord(); shotorg_z = ReadCoord();
291         endpos_x = ReadCoord(); endpos_y = ReadCoord(); endpos_z = ReadCoord();
292         charge = ReadByte() / 255.0;
293         
294         pointparticles(particleeffectnum("nex_muzzleflash"), shotorg, normalize(endpos - shotorg) * 1000, 1);
295         
296         //draw either the old v2.3 beam or the new beam
297         charge = sqrt(charge); // divide evenly among trail spacing and alpha
298         particles_alphamin = particles_alphamax = charge;
299         if (autocvar_cl_particles_oldnexbeam && (getstati(STAT_ALLOW_OLDNEXBEAM) || isdemo()))
300                 WarpZone_TrailParticles_WithMultiplier(world, particleeffectnum("TE_TEI_G3"), shotorg, endpos, charge, 1);
301         else
302                 WarpZone_TrailParticles_WithMultiplier(world, particleeffectnum("nex_beam"), shotorg, endpos, charge, 1);
303 }