1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
/**
* @file llpartdata.h
* @brief Particle system data packing
*
* $LicenseInfo:firstyear=2003&license=viewergpl$
*
* Copyright (c) 2003-2007, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlife.com/developers/opensource/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at http://secondlife.com/developers/opensource/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLPARTDATA_H
#define LL_LLPARTDATA_H
#include "lluuid.h"
#include "v3math.h"
#include "v3dmath.h"
#include "v2math.h"
#include "v4color.h"
class LLMessageSystem;
class LLDataPacker;
const S32 PS_CUR_VERSION = 18;
//
// These constants are used by the script code, not by the particle system itself
//
enum LLPSScriptFlags
{
// Flags for the different parameters of individual particles
LLPS_PART_FLAGS,
LLPS_PART_START_COLOR,
LLPS_PART_START_ALPHA,
LLPS_PART_END_COLOR,
LLPS_PART_END_ALPHA,
LLPS_PART_START_SCALE,
LLPS_PART_END_SCALE,
LLPS_PART_MAX_AGE,
// Flags for the different parameters of the particle source
LLPS_SRC_ACCEL,
LLPS_SRC_PATTERN,
LLPS_SRC_INNERANGLE,
LLPS_SRC_OUTERANGLE,
LLPS_SRC_TEXTURE,
LLPS_SRC_BURST_RATE,
LLPS_SRC_BURST_DURATION,
LLPS_SRC_BURST_PART_COUNT,
LLPS_SRC_BURST_RADIUS,
LLPS_SRC_BURST_SPEED_MIN,
LLPS_SRC_BURST_SPEED_MAX,
LLPS_SRC_MAX_AGE,
LLPS_SRC_TARGET_UUID,
LLPS_SRC_OMEGA,
LLPS_SRC_ANGLE_BEGIN,
LLPS_SRC_ANGLE_END
};
class LLPartData
{
public:
LLPartData() :
mFlags(0),
mMaxAge(0.f),
mParameter(0.f)
{
}
BOOL unpack(LLDataPacker &dp);
BOOL pack(LLDataPacker &dp);
LLSD asLLSD() const;
operator LLSD() const {return asLLSD(); }
bool fromLLSD(LLSD& sd);
// Masks for the different particle flags
enum
{
LL_PART_INTERP_COLOR_MASK = 0x01,
LL_PART_INTERP_SCALE_MASK = 0x02,
LL_PART_BOUNCE_MASK = 0x04,
LL_PART_WIND_MASK = 0x08,
LL_PART_FOLLOW_SRC_MASK = 0x10, // Follows source, no rotation following (expensive!)
LL_PART_FOLLOW_VELOCITY_MASK = 0x20, // Particles orient themselves with velocity
LL_PART_TARGET_POS_MASK = 0x40,
LL_PART_TARGET_LINEAR_MASK = 0x80, // Particle uses a direct linear interpolation
LL_PART_EMISSIVE_MASK = 0x100, // Particle is "emissive", instead of being lit
LL_PART_BEAM_MASK = 0x200, // Particle is a "beam" connecting source and target
// Not implemented yet!
//LL_PART_RANDOM_ACCEL_MASK = 0x100, // Particles have random acceleration
//LL_PART_RANDOM_VEL_MASK = 0x200, // Particles have random velocity shifts"
//LL_PART_TRAIL_MASK = 0x400, // Particles have historical "trails"
// Viewer side use only!
LL_PART_DEAD_MASK = 0x80000000,
};
void setFlags(const U32 flags);
void setMaxAge(const F32 max_age);
void setStartScale(const F32 xs, F32 ys);
void setEndScale(const F32 xs, F32 ys);
void setStartColor(const LLVector3 &rgb);
void setEndColor(const LLVector3 &rgb);
void setStartAlpha(const F32 alpha);
void setEndAlpha(const F32 alpha);
friend class LLPartSysData;
friend class LLViewerPartSourceScript;
// These are public because I'm really lazy...
public:
U32 mFlags; // Particle state/interpolators in effect
F32 mMaxAge; // Maximum age of the particle
LLColor4 mStartColor; // Start color
LLColor4 mEndColor; // End color
LLVector2 mStartScale; // Start scale
LLVector2 mEndScale; // End scale
LLVector3 mPosOffset; // Offset from source if using FOLLOW_SOURCE
F32 mParameter; // A single floating point parameter
};
class LLPartSysData
{
public:
LLPartSysData();
BOOL unpack(LLDataPacker &dp);
BOOL pack(LLDataPacker &dp);
BOOL unpackBlock(const S32 block_num);
BOOL packBlock();
static BOOL packNull();
static BOOL isNullPS(const S32 block_num); // Returns FALSE if this is a "NULL" particle system (i.e. no system)
// Different masks for effects on the source
enum
{
LL_PART_SRC_OBJ_REL_MASK = 0x01, // Accel and velocity for particles relative object rotation
LL_PART_USE_NEW_ANGLE = 0x02, // Particles uses new 'correct' angle parameters.
};
// The different patterns for how particles are created
enum
{
LL_PART_SRC_PATTERN_DROP = 0x01,
LL_PART_SRC_PATTERN_EXPLODE = 0x02,
// Not implemented fully yet
LL_PART_SRC_PATTERN_ANGLE = 0x04,
LL_PART_SRC_PATTERN_ANGLE_CONE = 0x08,
LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY = 0x10,
};
void setBurstSpeedMin(const F32 spd) { mBurstSpeedMin = llclamp(spd, -100.f, 100.f); }
void setBurstSpeedMax(const F32 spd) { mBurstSpeedMax = llclamp(spd, -100.f, 100.f); }
void setBurstRadius(const F32 rad) { mBurstRadius = llclamp(rad, 0.f, 50.f); }
void setPartAccel(const LLVector3 &accel);
void setUseNewAngle() { mFlags |= LL_PART_USE_NEW_ANGLE; }
void unsetUseNewAngle() { mFlags &= ~LL_PART_USE_NEW_ANGLE; }
// Since the actual particle creation rate is
// a combination of multiple parameters, we
// need to clamp it using a separate method instead of an accessor.
void clampSourceParticleRate();
friend std::ostream& operator<<(std::ostream& s, const LLPartSysData &data); // Stream a
public:
// Public because I'm lazy....
//
// There are two kinds of data for the particle system
// 1. Parameters which specify parameters of the source (mSource*)
// 2. Parameters which specify parameters of the particles generated by the source (mPart*)
//
U32 mCRC;
U32 mFlags;
U8 mPattern; // Pattern for particle velocity/output
F32 mInnerAngle; // Inner angle for PATTERN_ANGLE
F32 mOuterAngle; // Outer angle for PATTERN_ANGLE
LLVector3 mAngularVelocity; // Angular velocity for emission axis (for PATTERN_ANGLE)
F32 mBurstRate; // How often to do a burst of particles
U8 mBurstPartCount; // How many particles in a burst
F32 mBurstRadius;
F32 mBurstSpeedMin; // Minimum particle velocity
F32 mBurstSpeedMax; // Maximum particle velocity
F32 mMaxAge; // Maximum lifetime of this particle source
LLUUID mTargetUUID; // Target UUID for the particle system
F32 mStartAge; // Age at which to start the particle system (for an update after the
// particle system has started)
//
// These are actually particle properties, but can be mutated by the source,
// so are stored here instead
//
LLVector3 mPartAccel;
LLUUID mPartImageID;
//
// The "template" partdata where we actually store the non-mutable particle parameters
//
LLPartData mPartData;
protected:
S32 mNumParticles; // Number of particles generated
};
#endif // LL_LLPARTDATA_H
|
