partsyspacket.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:11k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file partsyspacket.h
  3.  * @brief Object for packing particle system initialization parameters
  4.  * before sending them over the network
  5.  *
  6.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2000-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  33. #ifndef LL_PARTSYSPACKET_H
  34. #define LL_PARTSYSPACKET_H
  35. #include "lluuid.h"
  36. // Particle system stuff
  37. const U64 PART_SYS_MAX_TIME_IN_USEC = 1000000;  //  1 second, die not quite near instantaneously
  38. // this struct is for particle system initialization parameters 
  39. // I'm breaking some rules here, but I need a storage structure to hold initialization data
  40. // for these things.  Sorry guys, they're not simple enough (yet) to avoid this cleanly 
  41. struct LLPartInitData {
  42. // please do not add functions to this class -- data only!
  43. //F32 k[18];     // first 9 --> x,y,z  last 9 --> scale, alpha, rot
  44. //F32 kill_p[6]; // last one is for particles that die when they reach a spherical bounding radius 
  45. //F32 kill_plane[3]; 
  46. //F32 bounce_p[5]; 
  47. F32 bounce_b; // recently changed
  48. // no need to store orientation and position here, as they're sent over seperately
  49. //F32 pos_ranges[6]; 
  50. //F32 vel_ranges[6];
  51. F32 scale_range[4];
  52. F32 alpha_range[4];
  53. F32 vel_offset[3]; //new - more understandable!
  54. F32 mDistBeginFadeout; // for fadeout LOD optimization 
  55. F32 mDistEndFadeout;
  56. LLUUID mImageUuid;
  57. //U8 n; // number of particles 
  58. U8 mFlags[8]; // for miscellaneous data --> its interpretation can change at my whim!
  59. U8 createMe; // do I need to be created? or has the work allready been done?
  60. //ActionFlag is now mFlags[PART_SYS_ACTION_BYTE]
  61. //Spawn point is initially object creation center
  62. F32 diffEqAlpha[3];
  63. F32 diffEqScale[3];
  64. U8 maxParticles;
  65. //How many particles exist at any time within the system?
  66. U8 initialParticles;
  67. //How many particles exist when the system is created?
  68. F32 killPlaneZ;
  69. //For simplicity assume the XY plane, so this sets an altitude at which to die
  70. F32 killPlaneNormal[3]; 
  71. //Normal if not planar XY
  72. F32 bouncePlaneZ;
  73. //For simplicity assume the XY plane, so this sets an altitude at which to bounce
  74. F32 bouncePlaneNormal[3]; 
  75. //Normal if not planar XY
  76. F32 spawnRange;
  77. //Range of emission points about the mSpawnPoint
  78. F32 spawnFrequency;
  79. //Required if the system is to spawn new particles.
  80. //This variable determines the time after a particle dies when it is respawned.
  81. F32 spawnFreqencyRange;
  82. //Determines the random range of time until a new particle is spawned.
  83. F32 spawnDirection[3];
  84. //Direction vector giving the mean direction in which particles are spawned
  85. F32 spawnDirectionRange;
  86. //Direction limiting the angular range of emissions about the mean direction. 1.0f means everywhere, 0.0f means uni-directional
  87. F32 spawnVelocity;
  88. //The mean speed at which particles are emitted
  89. F32 spawnVelocityRange;
  90. //The range of speeds about the mean at which particles are emitted.
  91. F32 speedLimit;
  92. //Used to constrain particle maximum velocity
  93. F32 windWeight;
  94. //How much of an effect does wind have
  95. F32 currentGravity[3];
  96. //Gravity direction used in update calculations
  97. F32 gravityWeight;
  98. //How much of an effect does gravity have
  99. F32 globalLifetime;
  100. //If particles re-spawn, a system can exist forever.
  101. //If (ActionFlags & PART_SYS_GLOBAL_DIE) is TRUE this variable is used to determine how long the system lasts.
  102. F32 individualLifetime;
  103. //How long does each particle last if nothing else happens to it
  104. F32 individualLifetimeRange;
  105. //Range of variation in individual lifetimes
  106. F32 alphaDecay;
  107. //By what factor does alpha decrease as the lifetime of a particle is approached.
  108. F32 scaleDecay;
  109. //By what factor does scale decrease as the lifetime of a particle is approached.
  110. F32 distanceDeath;
  111. //With the increased functionality, particle systems can expand to indefinite size
  112. //(e.g. wind can chaotically move particles into a wide spread).
  113. //To avoid particles exceeding normal object size constraints,
  114. //set the PART_SYS_DISTANCE_DEATH flag, and set a distance value here, representing a radius around the spawn point.
  115. F32 dampMotionFactor;
  116. //How much to damp motion
  117. F32 windDiffusionFactor[3];
  118. //Change the size and alpha of particles as wind speed increases (scale gets bigger, alpha smaller)
  119. };
  120. // constants for setting flag values
  121. // BYTES are in range 0-8, bits are in range 2^0 - 2^8 and can only be powers of two
  122. const int PART_SYS_NO_Z_BUFFER_BYTE = 0; // option to turn off z-buffer when rendering
  123. const int PART_SYS_NO_Z_BUFFER_BIT = 2;  // particle systems -- 
  124. // I advise against using this, as it looks bad in every case I've tried
  125. const int PART_SYS_SLOW_ANIM_BYTE = 0; // slow animation down by a factor of 10
  126. const int PART_SYS_SLOW_ANIM_BIT = 1;  // useful for tweaking anims during debugging
  127. const int PART_SYS_FOLLOW_VEL_BYTE = 0; // indicates whether to orient sprites towards
  128. const int PART_SYS_FOLLOW_VEL_BIT = 4;  // their velocity vector -- default is FALSE
  129. const int PART_SYS_IS_LIGHT_BYTE = 0;   // indicates whether a particular particle system
  130. const int PART_SYS_IS_LIGHT_BIT = 8;    // is also a light object -- for andrew
  131. // should deprecate this once there is a general method for setting light properties of objects
  132. const int PART_SYS_SPAWN_COPY_BYTE = 0;   // indicates whether to spawn baby particle systems on 
  133. const int PART_SYS_SPAWN_COPY_BIT = 0x10; // particle death -- intended for smoke trails
  134. const int PART_SYS_COPY_VEL_BYTE = 0; // indicates whether baby particle systems inherit parents vel
  135. const int PART_SYS_COPY_VEL_BIT = 0x20; // (by default they don't)
  136. const int PART_SYS_INVISIBLE_BYTE = 0; // optional -- turn off display, just simulate
  137. const int PART_SYS_INVISIBLE_BIT = 0x40; // useful for smoke trails
  138. const int PART_SYS_ADAPT_TO_FRAMERATE_BYTE = 0;    // drop sprites from render call proportionally
  139. const int PART_SYS_ADAPT_TO_FRAMERATE_BIT = 0x80; // to how far we are below 60 fps
  140. // 26 September 2001 - not even big enough to hold all changes, so should enlarge anyway
  141. //const U16 MAX_PART_SYS_PACKET_SIZE = 180;
  142. const U16 MAX_PART_SYS_PACKET_SIZE = 256;
  143. //const U8 PART_SYS_K_MASK = 0x01;
  144. const U8 PART_SYS_KILL_P_MASK = 0x02;
  145. const U8 PART_SYS_BOUNCE_P_MASK = 0x04;
  146. const U8 PART_SYS_BOUNCE_B_MASK = 0x08;
  147. //const U8 PART_SYS_POS_RANGES_MASK = 0x10;
  148. //const U8 PART_SYS_VEL_RANGES_MASK = 0x20;
  149. const U8 PART_SYS_VEL_OFFSET_MASK = 0x10; //re-use one of the original slots now commented out
  150. const U8 PART_SYS_ALPHA_SCALE_DIFF_MASK = 0x20; //re-use one of the original slots now commented out
  151. const U8 PART_SYS_SCALE_RANGE_MASK = 0x40;
  152. const U8 PART_SYS_M_IMAGE_UUID_MASK = 0x80;
  153. const U8 PART_SYS_BYTE_3_ALPHA_MASK = 0x01; // wrapped around, didn't we?
  154. const U8 PART_SYS_BYTE_SPAWN_MASK = 0x01;
  155. const U8 PART_SYS_BYTE_ENVIRONMENT_MASK = 0x02;
  156. const U8 PART_SYS_BYTE_LIFESPAN_MASK = 0x04;
  157. const U8 PART_SYS_BYTE_DECAY_DAMP_MASK = 0x08;
  158. const U8 PART_SYS_BYTE_WIND_DIFF_MASK = 0x10;
  159. // 26 September 2001 - new constants for  mActionFlags
  160. const int PART_SYS_ACTION_BYTE = 1;
  161. const U8 PART_SYS_SPAWN  = 0x01;
  162. const U8 PART_SYS_BOUNCE  = 0x02;
  163. const U8 PART_SYS_AFFECTED_BY_WIND  = 0x04;
  164. const U8 PART_SYS_AFFECTED_BY_GRAVITY = 0x08;
  165. const U8 PART_SYS_EVALUATE_WIND_PER_PARTICLE  = 0x10; 
  166. const U8 PART_SYS_DAMP_MOTION  = 0x20;
  167. const U8 PART_SYS_WIND_DIFFUSION  = 0x40;
  168. // 26 September 2001 - new constants for  mKillFlags
  169. const int PART_SYS_KILL_BYTE = 2;
  170. const U8 PART_SYS_KILL_PLANE = 0x01;
  171. const U8 PART_SYS_GLOBAL_DIE  = 0x02;  
  172. const U8 PART_SYS_DISTANCE_DEATH  = 0x04;
  173. const U8 PART_SYS_TIME_DEATH  = 0x08;
  174. // global, because the sim-side also calls it in the LLPartInitDataFactory
  175. void gSetInitDataDefaults(LLPartInitData *setMe);
  176. class LLPartSysCompressedPacket
  177. {
  178. public:
  179. LLPartSysCompressedPacket();
  180. ~LLPartSysCompressedPacket();
  181. BOOL fromLLPartInitData(LLPartInitData *in, U32 &bytesUsed);
  182. BOOL toLLPartInitData(LLPartInitData *out, U32 *bytesUsed);
  183. BOOL fromUnsignedBytes(U8 *in, U32 bytesUsed);
  184. BOOL toUnsignedBytes(U8 *out);
  185. U32 bufferSize();
  186. U8 *getBytePtr();
  187. protected:
  188. U8 mData[MAX_PART_SYS_PACKET_SIZE];
  189. U32 mNumBytes;
  190. LLPartInitData mDefaults; //  this is intended to hold default LLPartInitData values
  191. //                            please do not modify it
  192. LLPartInitData mWorkingCopy; // uncompressed data I'm working with
  193. protected:
  194. // private functions (used only to break up code)
  195. void writeFlagByte(LLPartInitData *in);
  196. //U32 writeK(LLPartInitData *in, U32 startByte);
  197. U32 writeKill_p(LLPartInitData *in, U32 startByte);
  198. U32 writeBounce_p(LLPartInitData *in, U32 startByte);
  199. U32 writeBounce_b(LLPartInitData *in, U32 startByte);
  200. //U32 writePos_ranges(LLPartInitData *in, U32 startByte);
  201. //U32 writeVel_ranges(LLPartInitData *in, U32 startByte);
  202. U32 writeAlphaScaleDiffEqn_range(LLPartInitData *in, U32 startByte);
  203. U32 writeScale_range(LLPartInitData *in, U32 startByte);
  204. U32 writeAlpha_range(LLPartInitData *in, U32 startByte);
  205. U32 writeUUID(LLPartInitData *in, U32 startByte);
  206. U32 writeVelocityOffset(LLPartInitData *in, U32 startByte);
  207. U32 writeSpawn(LLPartInitData *in, U32 startByte); //all spawn data
  208. U32 writeEnvironment(LLPartInitData *in, U32 startByte); //wind and gravity
  209. U32 writeLifespan(LLPartInitData *in, U32 startByte); //lifespan data - individual and global
  210. U32 writeDecayDamp(LLPartInitData *in, U32 startByte); //alpha and scale, and motion damp
  211. U32 writeWindDiffusionFactor(LLPartInitData *in, U32 startByte);
  212. //U32 readK(LLPartInitData *in, U32 startByte);
  213. U32 readKill_p(LLPartInitData *in, U32 startByte);
  214. U32 readBounce_p(LLPartInitData *in, U32 startByte);
  215. U32 readBounce_b(LLPartInitData *in, U32 startByte);
  216. //U32 readPos_ranges(LLPartInitData *in, U32 startByte);
  217. //U32 readVel_ranges(LLPartInitData *in, U32 startByte);
  218. U32 readAlphaScaleDiffEqn_range(LLPartInitData *in, U32 startByte);
  219. U32 readScale_range(LLPartInitData *in, U32 startByte);
  220. U32 readAlpha_range(LLPartInitData *in, U32 startByte);
  221. U32 readUUID(LLPartInitData *in, U32 startByte);
  222. U32 readVelocityOffset(LLPartInitData *in, U32 startByte);
  223. U32 readSpawn(LLPartInitData *in, U32 startByte); //all spawn data
  224. U32 readEnvironment(LLPartInitData *in, U32 startByte); //wind and gravity
  225. U32 readLifespan(LLPartInitData *in, U32 startByte); //lifespan data - individual and global
  226. U32 readDecayDamp(LLPartInitData *in, U32 startByte); //alpha and scale, and motion damp
  227. U32 readWindDiffusionFactor(LLPartInitData *in, U32 startByte);
  228. };
  229. #endif