~evan-nelson/armagetronad/armagetronad+pcm

« back to all changes in this revision

Viewing changes to src/thirdparty/particles/action_api.cpp

Attempting to create a timeout for PLAYER_CENTER_MESSAGE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
// action_api.cpp
2
 
//
3
 
// Copyright 1997-1998 by David K. McAllister
4
 
//
5
 
// This file implements the action API calls by creating
6
 
// action class instances, which are either executed or
7
 
// added to an action list.
8
 
 
9
 
#include "general.h"
10
 
 
11
 
extern void _pAddActionToList(ParticleAction *S, int size);
12
 
extern void _pCallActionList(ParticleAction *pa, int num_actions,
13
 
                                 ParticleGroup *pg);
14
 
 
15
 
// Do not call this function.
16
 
void _pSendAction(ParticleAction *S, PActionEnum type, int size)
17
 
{
18
 
    _ParticleState &_ps = _GetPState();
19
 
 
20
 
    S->type = type;
21
 
 
22
 
    if(_ps.in_new_list)
23
 
    {
24
 
        _pAddActionToList(S, size);
25
 
    }
26
 
    else
27
 
    {
28
 
        // Immediate mode. Execute it.
29
 
        // This is a hack to give them local access to dt.
30
 
        S->dt = _ps.dt;
31
 
        _pCallActionList(S, 1, _ps.pgrp);
32
 
    }
33
 
}
34
 
 
35
 
PARTICLEDLL_API void pAvoid(float magnitude, float epsilon, float look_ahead,
36
 
                            PDomainEnum dtype,
37
 
                            float a0, float a1, float a2,
38
 
                            float a3, float a4, float a5,
39
 
                            float a6, float a7, float a8)
40
 
{
41
 
    PAAvoid S;
42
 
 
43
 
    S.position = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
44
 
    S.magnitude = magnitude;
45
 
    S.epsilon = epsilon;
46
 
    S.look_ahead = look_ahead;
47
 
 
48
 
    _pSendAction(&S, PAAvoidID, sizeof(PAAvoid));
49
 
}
50
 
 
51
 
PARTICLEDLL_API void pBounce(float friction, float resilience, float cutoff,
52
 
                             PDomainEnum dtype,
53
 
                             float a0, float a1, float a2,
54
 
                             float a3, float a4, float a5,
55
 
                             float a6, float a7, float a8)
56
 
{
57
 
    PABounce S;
58
 
 
59
 
    S.position = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
60
 
    S.oneMinusFriction = 1.0f - friction;
61
 
    S.resilience = resilience;
62
 
    S.cutoffSqr = fsqr(cutoff);
63
 
 
64
 
    _pSendAction(&S, PABounceID, sizeof(PABounce));
65
 
}
66
 
 
67
 
PARTICLEDLL_API void pCopyVertexB(bool copy_pos, bool copy_vel)
68
 
{
69
 
    PACopyVertexB S;
70
 
 
71
 
    S.copy_pos = copy_pos;
72
 
    S.copy_vel = copy_vel;
73
 
 
74
 
    _pSendAction(&S, PACopyVertexBID, sizeof(PACopyVertexB));
75
 
}
76
 
 
77
 
PARTICLEDLL_API void pDamping(float damping_x, float damping_y, float damping_z,
78
 
                              float vlow, float vhigh)
79
 
{
80
 
    PADamping S;
81
 
 
82
 
    S.damping = pVector(damping_x, damping_y, damping_z);
83
 
    S.vlowSqr = fsqr(vlow);
84
 
    S.vhighSqr = fsqr(vhigh);
85
 
 
86
 
    _pSendAction(&S, PADampingID, sizeof(PADamping));
87
 
}
88
 
 
89
 
PARTICLEDLL_API void pExplosion(float center_x, float center_y, float center_z, float velocity,
90
 
                                float magnitude, float stdev, float epsilon, float age)
91
 
{
92
 
    PAExplosion S;
93
 
 
94
 
    S.center = pVector(center_x, center_y, center_z);
95
 
    S.velocity = velocity;
96
 
    S.magnitude = magnitude;
97
 
    S.stdev = stdev;
98
 
    S.epsilon = epsilon;
99
 
    S.age = age;
100
 
 
101
 
    if(S.epsilon < 0.0f)
102
 
        S.epsilon = P_EPS;
103
 
 
104
 
    _pSendAction(&S, PAExplosionID, sizeof(PAExplosion));
105
 
}
106
 
 
107
 
PARTICLEDLL_API void pFollow(float magnitude, float epsilon, float max_radius)
108
 
{
109
 
    PAFollow S;
110
 
 
111
 
    S.magnitude = magnitude;
112
 
    S.epsilon = epsilon;
113
 
    S.max_radius = max_radius;
114
 
 
115
 
    _pSendAction(&S, PAFollowID, sizeof(PAFollow));
116
 
}
117
 
 
118
 
PARTICLEDLL_API void pGravitate(float magnitude, float epsilon, float max_radius)
119
 
{
120
 
    PAGravitate S;
121
 
 
122
 
    S.magnitude = magnitude;
123
 
    S.epsilon = epsilon;
124
 
    S.max_radius = max_radius;
125
 
 
126
 
    _pSendAction(&S, PAGravitateID, sizeof(PAGravitate));
127
 
}
128
 
 
129
 
PARTICLEDLL_API void pGravity(float dir_x, float dir_y, float dir_z)
130
 
{
131
 
    PAGravity S;
132
 
 
133
 
    S.direction = pVector(dir_x, dir_y, dir_z);
134
 
 
135
 
    _pSendAction(&S, PAGravityID, sizeof(PAGravity));
136
 
}
137
 
 
138
 
PARTICLEDLL_API void pJet(float center_x, float center_y, float center_z,
139
 
                          float magnitude, float epsilon, float max_radius)
140
 
{
141
 
    _ParticleState &_ps = _GetPState();
142
 
 
143
 
    PAJet S;
144
 
 
145
 
    S.center = pVector(center_x, center_y, center_z);
146
 
    S.acc = _ps.Vel;
147
 
    S.magnitude = magnitude;
148
 
    S.epsilon = epsilon;
149
 
    S.max_radius = max_radius;
150
 
 
151
 
    _pSendAction(&S, PAJetID, sizeof(PAJet));
152
 
}
153
 
 
154
 
PARTICLEDLL_API void pKillOld(float age_limit, bool kill_less_than)
155
 
{
156
 
    PAKillOld S;
157
 
 
158
 
    S.age_limit = age_limit;
159
 
    S.kill_less_than = kill_less_than;
160
 
 
161
 
    _pSendAction(&S, PAKillOldID, sizeof(PAKillOld));
162
 
}
163
 
 
164
 
PARTICLEDLL_API void pMatchVelocity(float magnitude, float epsilon, float max_radius)
165
 
{
166
 
    PAMatchVelocity S;
167
 
 
168
 
    S.magnitude = magnitude;
169
 
    S.epsilon = epsilon;
170
 
    S.max_radius = max_radius;
171
 
 
172
 
    _pSendAction(&S, PAMatchVelocityID, sizeof(PAMatchVelocity));
173
 
}
174
 
 
175
 
PARTICLEDLL_API void pMove()
176
 
{
177
 
    PAMove S;
178
 
 
179
 
    _pSendAction(&S, PAMoveID, sizeof(PAMove));
180
 
}
181
 
 
182
 
PARTICLEDLL_API void pOrbitLine(float p_x, float p_y, float p_z,
183
 
                                float axis_x, float axis_y, float axis_z,
184
 
                                float magnitude, float epsilon, float max_radius)
185
 
{
186
 
    PAOrbitLine S;
187
 
 
188
 
    S.p = pVector(p_x, p_y, p_z);
189
 
    S.axis = pVector(axis_x, axis_y, axis_z);
190
 
    S.axis.normalize();
191
 
    S.magnitude = magnitude;
192
 
    S.epsilon = epsilon;
193
 
    S.max_radius = max_radius;
194
 
 
195
 
    _pSendAction(&S, PAOrbitLineID, sizeof(PAOrbitLine));
196
 
}
197
 
 
198
 
PARTICLEDLL_API void pOrbitPoint(float center_x, float center_y, float center_z,
199
 
                                 float magnitude, float epsilon, float max_radius)
200
 
{
201
 
    PAOrbitPoint S;
202
 
 
203
 
    S.center = pVector(center_x, center_y, center_z);
204
 
    S.magnitude = magnitude;
205
 
    S.epsilon = epsilon;
206
 
    S.max_radius = max_radius;
207
 
 
208
 
    _pSendAction(&S, PAOrbitPointID, sizeof(PAOrbitPoint));
209
 
}
210
 
 
211
 
PARTICLEDLL_API void pRandomAccel(PDomainEnum dtype,
212
 
                                  float a0, float a1, float a2,
213
 
                                  float a3, float a4, float a5,
214
 
                                  float a6, float a7, float a8)
215
 
{
216
 
    PARandomAccel S;
217
 
 
218
 
    S.gen_acc = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
219
 
 
220
 
    _pSendAction(&S, PARandomAccelID, sizeof(PARandomAccel));
221
 
}
222
 
 
223
 
PARTICLEDLL_API void pRandomDisplace(PDomainEnum dtype,
224
 
                                     float a0, float a1, float a2,
225
 
                                     float a3, float a4, float a5,
226
 
                                     float a6, float a7, float a8)
227
 
{
228
 
    PARandomDisplace S;
229
 
 
230
 
    S.gen_disp = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
231
 
 
232
 
    _pSendAction(&S, PARandomDisplaceID, sizeof(PARandomDisplace));
233
 
}
234
 
 
235
 
PARTICLEDLL_API void pRandomVelocity(PDomainEnum dtype,
236
 
                                     float a0, float a1, float a2,
237
 
                                     float a3, float a4, float a5,
238
 
                                     float a6, float a7, float a8)
239
 
{
240
 
    PARandomVelocity S;
241
 
 
242
 
    S.gen_vel = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
243
 
 
244
 
    _pSendAction(&S, PARandomVelocityID, sizeof(PARandomVelocity));
245
 
}
246
 
 
247
 
PARTICLEDLL_API void pRestore(float time_left)
248
 
{
249
 
    PARestore S;
250
 
 
251
 
    S.time_left = time_left;
252
 
 
253
 
    _pSendAction(&S, PARestoreID, sizeof(PARestore));
254
 
}
255
 
 
256
 
PARTICLEDLL_API void pSink(bool kill_inside, PDomainEnum dtype,
257
 
                           float a0, float a1, float a2,
258
 
                           float a3, float a4, float a5,
259
 
                           float a6, float a7, float a8)
260
 
{
261
 
    PASink S;
262
 
 
263
 
    S.kill_inside = kill_inside;
264
 
    S.position = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
265
 
 
266
 
    _pSendAction(&S, PASinkID, sizeof(PASink));
267
 
}
268
 
 
269
 
PARTICLEDLL_API void pSinkVelocity(bool kill_inside, PDomainEnum dtype,
270
 
                                   float a0, float a1, float a2,
271
 
                                   float a3, float a4, float a5,
272
 
                                   float a6, float a7, float a8)
273
 
{
274
 
    PASinkVelocity S;
275
 
 
276
 
    S.kill_inside = kill_inside;
277
 
    S.velocity = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
278
 
 
279
 
    _pSendAction(&S, PASinkVelocityID, sizeof(PASinkVelocity));
280
 
}
281
 
 
282
 
PARTICLEDLL_API void pSource(float particle_rate, PDomainEnum dtype,
283
 
                             float a0, float a1, float a2,
284
 
                             float a3, float a4, float a5,
285
 
                             float a6, float a7, float a8)
286
 
{
287
 
    _ParticleState &_ps = _GetPState();
288
 
 
289
 
    PASource S;
290
 
 
291
 
    S.particle_rate = particle_rate;
292
 
    S.position = pDomain(dtype, a0, a1, a2, a3, a4, a5, a6, a7, a8);
293
 
    S.positionB = _ps.VertexB;
294
 
    S.size = _ps.Size;
295
 
    S.velocity = _ps.Vel;
296
 
    S.color = _ps.Color;
297
 
    S.alpha = _ps.Alpha;
298
 
    S.age = _ps.Age;
299
 
    S.age_sigma = _ps.AgeSigma;
300
 
    S.vertexB_tracks = _ps.vertexB_tracks;
301
 
 
302
 
    _pSendAction(&S, PASourceID, sizeof(PASource));
303
 
}
304
 
 
305
 
PARTICLEDLL_API void pSpeedLimit(float min_speed, float max_speed)
306
 
{
307
 
    PASpeedLimit S;
308
 
 
309
 
    S.min_speed = min_speed;
310
 
    S.max_speed = max_speed;
311
 
 
312
 
    _pSendAction(&S, PASpeedLimitID, sizeof(PASpeedLimit));
313
 
}
314
 
 
315
 
PARTICLEDLL_API void pTargetColor(float color_x, float color_y, float color_z,
316
 
                                  float alpha, float scale)
317
 
{
318
 
    PATargetColor S;
319
 
 
320
 
    S.color = pVector(color_x, color_y, color_z);
321
 
    S.alpha = alpha;
322
 
    S.scale = scale;
323
 
 
324
 
    _pSendAction(&S, PATargetColorID, sizeof(PATargetColor));
325
 
}
326
 
 
327
 
PARTICLEDLL_API void pTargetSize(float size_x, float size_y, float size_z,
328
 
                                 float scale_x, float scale_y, float scale_z)
329
 
{
330
 
    PATargetSize S;
331
 
 
332
 
    S.size = pVector(size_x, size_y, size_z);
333
 
    S.scale = pVector(scale_x, scale_y, scale_z);
334
 
 
335
 
    _pSendAction(&S, PATargetSizeID, sizeof(PATargetSize));
336
 
}
337
 
 
338
 
PARTICLEDLL_API void pTargetVelocity(float vel_x, float vel_y, float vel_z, float scale)
339
 
{
340
 
    PATargetVelocity S;
341
 
 
342
 
    S.velocity = pVector(vel_x, vel_y, vel_z);
343
 
    S.scale = scale;
344
 
 
345
 
    _pSendAction(&S, PATargetVelocityID, sizeof(PATargetVelocity));
346
 
}
347
 
 
348
 
// If in immediate mode, quickly add a vertex.
349
 
// If building an action list, call pSource.
350
 
PARTICLEDLL_API void pVertex(float x, float y, float z)
351
 
{
352
 
    _ParticleState &_ps = _GetPState();
353
 
 
354
 
    if(_ps.in_new_list)
355
 
    {
356
 
        pSource(1, PDPoint, x, y, z);
357
 
        return;
358
 
    }
359
 
 
360
 
    // Immediate mode. Quickly add the vertex.
361
 
    if(_ps.pgrp == NULL)
362
 
        return;
363
 
 
364
 
    pVector pos(x, y, z);
365
 
    pVector siz, vel, col, posB;
366
 
    if(_ps.vertexB_tracks)
367
 
        posB = pos;
368
 
    else
369
 
        _ps.VertexB.Generate(posB);
370
 
    _ps.Size.Generate(siz);
371
 
    _ps.Vel.Generate(vel);
372
 
    _ps.Color.Generate(col);
373
 
    _ps.pgrp->Add(pos, posB, siz, vel, col, _ps.Alpha, _ps.Age);
374
 
}
375
 
 
376
 
PARTICLEDLL_API void pVortex(float center_x, float center_y, float center_z,
377
 
                             float axis_x, float axis_y, float axis_z,
378
 
                             float magnitude, float epsilon, float max_radius)
379
 
{
380
 
    PAVortex S;
381
 
 
382
 
    S.center = pVector(center_x, center_y, center_z);
383
 
    S.axis = pVector(axis_x, axis_y, axis_z);
384
 
    S.axis.normalize();
385
 
    S.magnitude = magnitude;
386
 
    S.epsilon = epsilon;
387
 
    S.max_radius = max_radius;
388
 
 
389
 
    _pSendAction(&S, PAVortexID, sizeof(PAVortex));
390
 
}