262 lines
11 KiB
C++
262 lines
11 KiB
C++
/**
|
|
* @file partsyspacket.h
|
|
* @brief Object for packing particle system initialization parameters
|
|
* before sending them over the network
|
|
*
|
|
* $LicenseInfo:firstyear=2000&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#ifndef LL_PARTSYSPACKET_H
|
|
#define LL_PARTSYSPACKET_H
|
|
|
|
#include "lluuid.h"
|
|
|
|
// Particle system stuff
|
|
|
|
const U64 PART_SYS_MAX_TIME_IN_USEC = 1000000; // 1 second, die not quite near instantaneously
|
|
|
|
|
|
// this struct is for particle system initialization parameters
|
|
// I'm breaking some rules here, but I need a storage structure to hold initialization data
|
|
// for these things. Sorry guys, they're not simple enough (yet) to avoid this cleanly
|
|
struct LLPartInitData {
|
|
// please do not add functions to this class -- data only!
|
|
//F32 k[18]; // first 9 --> x,y,z last 9 --> scale, alpha, rot
|
|
//F32 kill_p[6]; // last one is for particles that die when they reach a spherical bounding radius
|
|
//F32 kill_plane[3];
|
|
//F32 bounce_p[5];
|
|
F32 bounce_b; // recently changed
|
|
// no need to store orientation and position here, as they're sent over seperately
|
|
//F32 pos_ranges[6];
|
|
//F32 vel_ranges[6];
|
|
F32 scale_range[4];
|
|
F32 alpha_range[4];
|
|
F32 vel_offset[3]; //new - more understandable!
|
|
|
|
F32 mDistBeginFadeout; // for fadeout LOD optimization
|
|
F32 mDistEndFadeout;
|
|
|
|
LLUUID mImageUuid;
|
|
//U8 n; // number of particles
|
|
U8 mFlags[8]; // for miscellaneous data --> its interpretation can change at my whim!
|
|
U8 createMe; // do I need to be created? or has the work allready been done?
|
|
//ActionFlag is now mFlags[PART_SYS_ACTION_BYTE]
|
|
//Spawn point is initially object creation center
|
|
|
|
F32 diffEqAlpha[3];
|
|
F32 diffEqScale[3];
|
|
|
|
U8 maxParticles;
|
|
//How many particles exist at any time within the system?
|
|
U8 initialParticles;
|
|
//How many particles exist when the system is created?
|
|
F32 killPlaneZ;
|
|
//For simplicity assume the XY plane, so this sets an altitude at which to die
|
|
F32 killPlaneNormal[3];
|
|
//Normal if not planar XY
|
|
F32 bouncePlaneZ;
|
|
//For simplicity assume the XY plane, so this sets an altitude at which to bounce
|
|
F32 bouncePlaneNormal[3];
|
|
//Normal if not planar XY
|
|
F32 spawnRange;
|
|
//Range of emission points about the mSpawnPoint
|
|
F32 spawnFrequency;
|
|
//Required if the system is to spawn new particles.
|
|
//This variable determines the time after a particle dies when it is respawned.
|
|
F32 spawnFreqencyRange;
|
|
//Determines the random range of time until a new particle is spawned.
|
|
F32 spawnDirection[3];
|
|
//Direction vector giving the mean direction in which particles are spawned
|
|
F32 spawnDirectionRange;
|
|
//Direction limiting the angular range of emissions about the mean direction. 1.0f means everywhere, 0.0f means uni-directional
|
|
F32 spawnVelocity;
|
|
//The mean speed at which particles are emitted
|
|
F32 spawnVelocityRange;
|
|
//The range of speeds about the mean at which particles are emitted.
|
|
F32 speedLimit;
|
|
//Used to constrain particle maximum velocity
|
|
F32 windWeight;
|
|
//How much of an effect does wind have
|
|
F32 currentGravity[3];
|
|
//Gravity direction used in update calculations
|
|
F32 gravityWeight;
|
|
//How much of an effect does gravity have
|
|
F32 globalLifetime;
|
|
//If particles re-spawn, a system can exist forever.
|
|
//If (ActionFlags & PART_SYS_GLOBAL_DIE) is TRUE this variable is used to determine how long the system lasts.
|
|
F32 individualLifetime;
|
|
//How long does each particle last if nothing else happens to it
|
|
F32 individualLifetimeRange;
|
|
//Range of variation in individual lifetimes
|
|
F32 alphaDecay;
|
|
//By what factor does alpha decrease as the lifetime of a particle is approached.
|
|
F32 scaleDecay;
|
|
//By what factor does scale decrease as the lifetime of a particle is approached.
|
|
F32 distanceDeath;
|
|
//With the increased functionality, particle systems can expand to indefinite size
|
|
//(e.g. wind can chaotically move particles into a wide spread).
|
|
//To avoid particles exceeding normal object size constraints,
|
|
//set the PART_SYS_DISTANCE_DEATH flag, and set a distance value here, representing a radius around the spawn point.
|
|
F32 dampMotionFactor;
|
|
//How much to damp motion
|
|
F32 windDiffusionFactor[3];
|
|
//Change the size and alpha of particles as wind speed increases (scale gets bigger, alpha smaller)
|
|
};
|
|
|
|
// constants for setting flag values
|
|
// BYTES are in range 0-8, bits are in range 2^0 - 2^8 and can only be powers of two
|
|
const int PART_SYS_NO_Z_BUFFER_BYTE = 0; // option to turn off z-buffer when rendering
|
|
const int PART_SYS_NO_Z_BUFFER_BIT = 2; // particle systems --
|
|
// I advise against using this, as it looks bad in every case I've tried
|
|
|
|
const int PART_SYS_SLOW_ANIM_BYTE = 0; // slow animation down by a factor of 10
|
|
const int PART_SYS_SLOW_ANIM_BIT = 1; // useful for tweaking anims during debugging
|
|
|
|
const int PART_SYS_FOLLOW_VEL_BYTE = 0; // indicates whether to orient sprites towards
|
|
const int PART_SYS_FOLLOW_VEL_BIT = 4; // their velocity vector -- default is FALSE
|
|
|
|
const int PART_SYS_IS_LIGHT_BYTE = 0; // indicates whether a particular particle system
|
|
const int PART_SYS_IS_LIGHT_BIT = 8; // is also a light object -- for andrew
|
|
// should deprecate this once there is a general method for setting light properties of objects
|
|
|
|
const int PART_SYS_SPAWN_COPY_BYTE = 0; // indicates whether to spawn baby particle systems on
|
|
const int PART_SYS_SPAWN_COPY_BIT = 0x10; // particle death -- intended for smoke trails
|
|
|
|
const int PART_SYS_COPY_VEL_BYTE = 0; // indicates whether baby particle systems inherit parents vel
|
|
const int PART_SYS_COPY_VEL_BIT = 0x20; // (by default they don't)
|
|
|
|
const int PART_SYS_INVISIBLE_BYTE = 0; // optional -- turn off display, just simulate
|
|
const int PART_SYS_INVISIBLE_BIT = 0x40; // useful for smoke trails
|
|
|
|
const int PART_SYS_ADAPT_TO_FRAMERATE_BYTE = 0; // drop sprites from render call proportionally
|
|
const int PART_SYS_ADAPT_TO_FRAMERATE_BIT = 0x80; // to how far we are below 60 fps
|
|
|
|
|
|
// 26 September 2001 - not even big enough to hold all changes, so should enlarge anyway
|
|
//const U16 MAX_PART_SYS_PACKET_SIZE = 180;
|
|
const U16 MAX_PART_SYS_PACKET_SIZE = 256;
|
|
|
|
//const U8 PART_SYS_K_MASK = 0x01;
|
|
const U8 PART_SYS_KILL_P_MASK = 0x02;
|
|
const U8 PART_SYS_BOUNCE_P_MASK = 0x04;
|
|
const U8 PART_SYS_BOUNCE_B_MASK = 0x08;
|
|
//const U8 PART_SYS_POS_RANGES_MASK = 0x10;
|
|
//const U8 PART_SYS_VEL_RANGES_MASK = 0x20;
|
|
const U8 PART_SYS_VEL_OFFSET_MASK = 0x10; //re-use one of the original slots now commented out
|
|
const U8 PART_SYS_ALPHA_SCALE_DIFF_MASK = 0x20; //re-use one of the original slots now commented out
|
|
const U8 PART_SYS_SCALE_RANGE_MASK = 0x40;
|
|
const U8 PART_SYS_M_IMAGE_UUID_MASK = 0x80;
|
|
const U8 PART_SYS_BYTE_3_ALPHA_MASK = 0x01; // wrapped around, didn't we?
|
|
|
|
const U8 PART_SYS_BYTE_SPAWN_MASK = 0x01;
|
|
const U8 PART_SYS_BYTE_ENVIRONMENT_MASK = 0x02;
|
|
const U8 PART_SYS_BYTE_LIFESPAN_MASK = 0x04;
|
|
const U8 PART_SYS_BYTE_DECAY_DAMP_MASK = 0x08;
|
|
const U8 PART_SYS_BYTE_WIND_DIFF_MASK = 0x10;
|
|
|
|
|
|
// 26 September 2001 - new constants for mActionFlags
|
|
const int PART_SYS_ACTION_BYTE = 1;
|
|
const U8 PART_SYS_SPAWN = 0x01;
|
|
const U8 PART_SYS_BOUNCE = 0x02;
|
|
const U8 PART_SYS_AFFECTED_BY_WIND = 0x04;
|
|
const U8 PART_SYS_AFFECTED_BY_GRAVITY = 0x08;
|
|
const U8 PART_SYS_EVALUATE_WIND_PER_PARTICLE = 0x10;
|
|
const U8 PART_SYS_DAMP_MOTION = 0x20;
|
|
const U8 PART_SYS_WIND_DIFFUSION = 0x40;
|
|
|
|
// 26 September 2001 - new constants for mKillFlags
|
|
const int PART_SYS_KILL_BYTE = 2;
|
|
const U8 PART_SYS_KILL_PLANE = 0x01;
|
|
const U8 PART_SYS_GLOBAL_DIE = 0x02;
|
|
const U8 PART_SYS_DISTANCE_DEATH = 0x04;
|
|
const U8 PART_SYS_TIME_DEATH = 0x08;
|
|
|
|
|
|
// global, because the sim-side also calls it in the LLPartInitDataFactory
|
|
|
|
|
|
void gSetInitDataDefaults(LLPartInitData *setMe);
|
|
|
|
class LLPartSysCompressedPacket
|
|
{
|
|
public:
|
|
LLPartSysCompressedPacket();
|
|
~LLPartSysCompressedPacket();
|
|
BOOL fromLLPartInitData(LLPartInitData *in, U32 &bytesUsed);
|
|
BOOL toLLPartInitData(LLPartInitData *out, U32 *bytesUsed);
|
|
BOOL fromUnsignedBytes(U8 *in, U32 bytesUsed);
|
|
BOOL toUnsignedBytes(U8 *out);
|
|
U32 bufferSize();
|
|
U8 *getBytePtr();
|
|
|
|
protected:
|
|
U8 mData[MAX_PART_SYS_PACKET_SIZE];
|
|
U32 mNumBytes;
|
|
LLPartInitData mDefaults; // this is intended to hold default LLPartInitData values
|
|
// please do not modify it
|
|
LLPartInitData mWorkingCopy; // uncompressed data I'm working with
|
|
|
|
protected:
|
|
// private functions (used only to break up code)
|
|
void writeFlagByte(LLPartInitData *in);
|
|
//U32 writeK(LLPartInitData *in, U32 startByte);
|
|
U32 writeKill_p(LLPartInitData *in, U32 startByte);
|
|
U32 writeBounce_p(LLPartInitData *in, U32 startByte);
|
|
U32 writeBounce_b(LLPartInitData *in, U32 startByte);
|
|
//U32 writePos_ranges(LLPartInitData *in, U32 startByte);
|
|
//U32 writeVel_ranges(LLPartInitData *in, U32 startByte);
|
|
U32 writeAlphaScaleDiffEqn_range(LLPartInitData *in, U32 startByte);
|
|
U32 writeScale_range(LLPartInitData *in, U32 startByte);
|
|
U32 writeAlpha_range(LLPartInitData *in, U32 startByte);
|
|
U32 writeUUID(LLPartInitData *in, U32 startByte);
|
|
|
|
U32 writeVelocityOffset(LLPartInitData *in, U32 startByte);
|
|
U32 writeSpawn(LLPartInitData *in, U32 startByte); //all spawn data
|
|
U32 writeEnvironment(LLPartInitData *in, U32 startByte); //wind and gravity
|
|
U32 writeLifespan(LLPartInitData *in, U32 startByte); //lifespan data - individual and global
|
|
U32 writeDecayDamp(LLPartInitData *in, U32 startByte); //alpha and scale, and motion damp
|
|
U32 writeWindDiffusionFactor(LLPartInitData *in, U32 startByte);
|
|
|
|
|
|
//U32 readK(LLPartInitData *in, U32 startByte);
|
|
U32 readKill_p(LLPartInitData *in, U32 startByte);
|
|
U32 readBounce_p(LLPartInitData *in, U32 startByte);
|
|
U32 readBounce_b(LLPartInitData *in, U32 startByte);
|
|
//U32 readPos_ranges(LLPartInitData *in, U32 startByte);
|
|
//U32 readVel_ranges(LLPartInitData *in, U32 startByte);
|
|
U32 readAlphaScaleDiffEqn_range(LLPartInitData *in, U32 startByte);
|
|
U32 readScale_range(LLPartInitData *in, U32 startByte);
|
|
U32 readAlpha_range(LLPartInitData *in, U32 startByte);
|
|
U32 readUUID(LLPartInitData *in, U32 startByte);
|
|
|
|
U32 readVelocityOffset(LLPartInitData *in, U32 startByte);
|
|
U32 readSpawn(LLPartInitData *in, U32 startByte); //all spawn data
|
|
U32 readEnvironment(LLPartInitData *in, U32 startByte); //wind and gravity
|
|
U32 readLifespan(LLPartInitData *in, U32 startByte); //lifespan data - individual and global
|
|
U32 readDecayDamp(LLPartInitData *in, U32 startByte); //alpha and scale, and motion damp
|
|
U32 readWindDiffusionFactor(LLPartInitData *in, U32 startByte);
|
|
};
|
|
|
|
#endif
|
|
|