/indra/llmessage/partsyspacket.h

/** 
 * @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