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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llpartdata.cpp
  3.  * @brief Particle system data packing
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #include "linden_common.h"
  33. #include "llpartdata.h"
  34. #include "message.h"
  35. #include "lldatapacker.h"
  36. #include "v4coloru.h"
  37. #include "llsdutil.h"
  38. #include "llsdutil_math.h"
  39. const S32 PS_PART_DATA_BLOCK_SIZE = 4 + 2 + 4 + 4 + 2 + 2; // 18
  40. const S32 PS_DATA_BLOCK_SIZE = 68 + PS_PART_DATA_BLOCK_SIZE; // 68 + 18 = 86
  41. const F32 MAX_PART_SCALE = 4.f;
  42. BOOL LLPartData::pack(LLDataPacker &dp)
  43. {
  44. LLColor4U coloru;
  45. dp.packU32(mFlags, "pdflags");
  46. dp.packFixed(mMaxAge, "pdmaxage", FALSE, 8, 8);
  47. coloru.setVec(mStartColor);
  48. dp.packColor4U(coloru, "pdstartcolor");
  49. coloru.setVec(mEndColor);
  50. dp.packColor4U(coloru, "pdendcolor");
  51. dp.packFixed(mStartScale.mV[0], "pdstartscalex", FALSE, 3, 5);
  52. dp.packFixed(mStartScale.mV[1], "pdstartscaley", FALSE, 3, 5);
  53. dp.packFixed(mEndScale.mV[0], "pdendscalex", FALSE, 3, 5);
  54. dp.packFixed(mEndScale.mV[1], "pdendscaley", FALSE, 3, 5);
  55. return TRUE;
  56. }
  57. LLSD LLPartData::asLLSD() const
  58. {
  59. LLSD sd = LLSD();
  60. sd["pdflags"] = ll_sd_from_U32(mFlags);
  61. sd["pdmaxage"] = mMaxAge;
  62. sd["pdstartcolor"] = ll_sd_from_color4(mStartColor);
  63. sd["pdendcolor"] = ll_sd_from_color4(mEndColor);
  64. sd["pdstartscale"] = ll_sd_from_vector2(mStartScale);
  65. sd["pdendscale"] = ll_sd_from_vector2(mEndScale);
  66. return sd;
  67. }
  68. bool LLPartData::fromLLSD(LLSD& sd)
  69. {
  70. mFlags = ll_U32_from_sd(sd["pdflags"]);
  71. mMaxAge = (F32)sd["pdmaxage"].asReal();
  72. mStartColor = ll_color4_from_sd(sd["pdstartcolor"]);
  73. mEndColor = ll_color4_from_sd(sd["pdendcolor"]);
  74. mStartScale = ll_vector2_from_sd(sd["pdstartscale"]);
  75. mEndScale = ll_vector2_from_sd(sd["pdendscale"]);
  76. return true;
  77. }
  78. BOOL LLPartData::unpack(LLDataPacker &dp)
  79. {
  80. LLColor4U coloru;
  81. dp.unpackU32(mFlags, "pdflags");
  82. dp.unpackFixed(mMaxAge, "pdmaxage", FALSE, 8, 8);
  83. dp.unpackColor4U(coloru, "pdstartcolor");
  84. mStartColor.setVec(coloru);
  85. dp.unpackColor4U(coloru, "pdendcolor");
  86. mEndColor.setVec(coloru);
  87. dp.unpackFixed(mStartScale.mV[0], "pdstartscalex", FALSE, 3, 5);
  88. dp.unpackFixed(mStartScale.mV[1], "pdstartscaley", FALSE, 3, 5);
  89. dp.unpackFixed(mEndScale.mV[0], "pdendscalex", FALSE, 3, 5);
  90. dp.unpackFixed(mEndScale.mV[1], "pdendscaley", FALSE, 3, 5);
  91. return TRUE;
  92. }
  93. void LLPartData::setFlags(const U32 flags)
  94. {
  95. mFlags = flags;
  96. }
  97. void LLPartData::setMaxAge(const F32 max_age)
  98. {
  99. mMaxAge = llclamp(max_age, 0.f, 30.f);
  100. }
  101. void LLPartData::setStartScale(const F32 xs, const F32 ys)
  102. {
  103. mStartScale.mV[VX] = llmin(xs, MAX_PART_SCALE);
  104. mStartScale.mV[VY] = llmin(ys, MAX_PART_SCALE);
  105. }
  106. void LLPartData::setEndScale(const F32 xs, const F32 ys)
  107. {
  108. mEndScale.mV[VX] = llmin(xs, MAX_PART_SCALE);
  109. mEndScale.mV[VY] = llmin(ys, MAX_PART_SCALE);
  110. }
  111. void LLPartData::setStartColor(const LLVector3 &rgb)
  112. {
  113. mStartColor.setVec(rgb.mV[0], rgb.mV[1], rgb.mV[2]);
  114. }
  115. void LLPartData::setEndColor(const LLVector3 &rgb)
  116. {
  117. mEndColor.setVec(rgb.mV[0], rgb.mV[1], rgb.mV[2]);
  118. }
  119. void LLPartData::setStartAlpha(const F32 alpha)
  120. {
  121. mStartColor.mV[3] = alpha;
  122. }
  123. void LLPartData::setEndAlpha(const F32 alpha)
  124. {
  125. mEndColor.mV[3] = alpha;
  126. }
  127. LLPartSysData::LLPartSysData()
  128. {
  129. mCRC = 0;
  130. mFlags = 0;
  131. mPartData.mFlags = 0;
  132. mPartData.mStartColor = LLColor4(1.f, 1.f, 1.f, 1.f);
  133. mPartData.mEndColor = LLColor4(1.f, 1.f, 1.f, 1.f);
  134. mPartData.mStartScale = LLVector2(1.f, 1.f);
  135. mPartData.mEndScale = LLVector2(1.f, 1.f);
  136. mPartData.mMaxAge = 10.0;
  137. mMaxAge = 0.0;
  138. mStartAge = 0.0;
  139. mPattern = LL_PART_SRC_PATTERN_DROP; // Pattern for particle velocity
  140. mInnerAngle = 0.0; // Inner angle of PATTERN_ANGLE_*
  141. mOuterAngle = 0.0; // Outer angle of PATTERN_ANGLE_*
  142. mBurstRate = 0.1f; // How often to do a burst of particles
  143. mBurstPartCount = 1; // How many particles in a burst
  144. mBurstSpeedMin = 1.f; // Minimum particle velocity
  145. mBurstSpeedMax = 1.f; // Maximum particle velocity
  146. mBurstRadius = 0.f;
  147. mNumParticles = 0;
  148. }
  149. BOOL LLPartSysData::pack(LLDataPacker &dp)
  150. {
  151. dp.packU32(mCRC, "pscrc");
  152. dp.packU32(mFlags, "psflags");
  153. dp.packU8(mPattern, "pspattern");
  154. dp.packFixed(mMaxAge, "psmaxage", FALSE, 8, 8);
  155. dp.packFixed(mStartAge, "psstartage", FALSE, 8, 8);
  156. dp.packFixed(mInnerAngle, "psinnerangle", FALSE, 3, 5);
  157. dp.packFixed(mOuterAngle, "psouterangle", FALSE, 3, 5);
  158. dp.packFixed(mBurstRate, "psburstrate", FALSE, 8, 8);
  159. dp.packFixed(mBurstRadius, "psburstradius", FALSE, 8, 8);
  160. dp.packFixed(mBurstSpeedMin, "psburstspeedmin", FALSE, 8, 8);
  161. dp.packFixed(mBurstSpeedMax, "psburstspeedmax", FALSE, 8, 8);
  162. dp.packU8(mBurstPartCount, "psburstpartcount");
  163. dp.packFixed(mAngularVelocity.mV[0], "psangvelx", TRUE, 8, 7);
  164. dp.packFixed(mAngularVelocity.mV[1], "psangvely", TRUE, 8, 7);
  165. dp.packFixed(mAngularVelocity.mV[2], "psangvelz", TRUE, 8, 7);
  166. dp.packFixed(mPartAccel.mV[0], "psaccelx", TRUE, 8, 7);
  167. dp.packFixed(mPartAccel.mV[1], "psaccely", TRUE, 8, 7);
  168. dp.packFixed(mPartAccel.mV[2], "psaccelz", TRUE, 8, 7);
  169. dp.packUUID(mPartImageID, "psuuid");
  170. dp.packUUID(mTargetUUID, "pstargetuuid");
  171. mPartData.pack(dp);
  172. return TRUE;
  173. }
  174. BOOL LLPartSysData::unpack(LLDataPacker &dp)
  175. {
  176. dp.unpackU32(mCRC, "pscrc");
  177. dp.unpackU32(mFlags, "psflags");
  178. dp.unpackU8(mPattern, "pspattern");
  179. dp.unpackFixed(mMaxAge, "psmaxage", FALSE, 8, 8);
  180. dp.unpackFixed(mStartAge, "psstartage", FALSE, 8, 8);
  181. dp.unpackFixed(mInnerAngle, "psinnerangle", FALSE, 3, 5);
  182. dp.unpackFixed(mOuterAngle, "psouterangle", FALSE, 3, 5);
  183. dp.unpackFixed(mBurstRate, "psburstrate", FALSE, 8, 8);
  184. mBurstRate = llmax(0.01f, mBurstRate);
  185. dp.unpackFixed(mBurstRadius, "psburstradius", FALSE, 8, 8);
  186. dp.unpackFixed(mBurstSpeedMin, "psburstspeedmin", FALSE, 8, 8);
  187. dp.unpackFixed(mBurstSpeedMax, "psburstspeedmax", FALSE, 8, 8);
  188. dp.unpackU8(mBurstPartCount, "psburstpartcount");
  189. dp.unpackFixed(mAngularVelocity.mV[0], "psangvelx", TRUE, 8, 7);
  190. dp.unpackFixed(mAngularVelocity.mV[1], "psangvely", TRUE, 8, 7);
  191. dp.unpackFixed(mAngularVelocity.mV[2], "psangvelz", TRUE, 8, 7);
  192. dp.unpackFixed(mPartAccel.mV[0], "psaccelx", TRUE, 8, 7);
  193. dp.unpackFixed(mPartAccel.mV[1], "psaccely", TRUE, 8, 7);
  194. dp.unpackFixed(mPartAccel.mV[2], "psaccelz", TRUE, 8, 7);
  195. dp.unpackUUID(mPartImageID, "psuuid");
  196. dp.unpackUUID(mTargetUUID, "pstargetuuid");
  197. mPartData.unpack(dp);
  198. return TRUE;
  199. }
  200. std::ostream& operator<<(std::ostream& s, const LLPartSysData &data)
  201. {
  202. s << "Flags: " << std::hex << data.mFlags;
  203. s << " Pattern: " << std::hex << (U32) data.mPattern << "n";
  204. s << "Age: [" << data.mStartAge << ", " << data.mMaxAge << "]n";
  205. s << "Angle: [" << data.mInnerAngle << ", " << data.mOuterAngle << "]n";
  206. s << "Burst Rate: " << data.mBurstRate << "n";
  207. s << "Burst Radius: " << data.mBurstRadius << "n";
  208. s << "Burst Speed: [" << data.mBurstSpeedMin << ", " << data.mBurstSpeedMax << "]n";
  209. s << "Burst Part Count: " << std::hex << (U32) data.mBurstPartCount << "n";
  210. s << "Angular Velocity: " << data.mAngularVelocity << "n";
  211. s << "Accel: " << data.mPartAccel;
  212. return s;
  213. }
  214. BOOL LLPartSysData::isNullPS(const S32 block_num)
  215. {
  216. U8 ps_data_block[PS_DATA_BLOCK_SIZE];
  217. U32 crc;
  218. S32 size;
  219. // Check size of block
  220. size = gMessageSystem->getSize("ObjectData", block_num, "PSBlock");
  221. if (!size)
  222. {
  223. return TRUE;
  224. }
  225. else if (size != PS_DATA_BLOCK_SIZE)
  226. {
  227. llwarns << "PSBlock is wrong size for particle system data - got " << size << ", expecting " << PS_DATA_BLOCK_SIZE << llendl;
  228. return TRUE;
  229. }
  230. gMessageSystem->getBinaryData("ObjectData", "PSBlock", ps_data_block, PS_DATA_BLOCK_SIZE, block_num, PS_DATA_BLOCK_SIZE);
  231. LLDataPackerBinaryBuffer dp(ps_data_block, PS_DATA_BLOCK_SIZE);
  232. dp.unpackU32(crc, "crc");
  233. if (crc == 0)
  234. {
  235. return TRUE;
  236. }
  237. return FALSE;
  238. }
  239. //static
  240. BOOL LLPartSysData::packNull()
  241. {
  242. U8 ps_data_block[PS_DATA_BLOCK_SIZE];
  243. gMessageSystem->addBinaryData("PSBlock", ps_data_block, 0);
  244. return TRUE;
  245. }
  246. BOOL LLPartSysData::packBlock()
  247. {
  248. U8 ps_data_block[PS_DATA_BLOCK_SIZE];
  249. LLDataPackerBinaryBuffer dp(ps_data_block, PS_DATA_BLOCK_SIZE);
  250. pack(dp);
  251. // Add to message
  252. gMessageSystem->addBinaryData("PSBlock", ps_data_block, PS_DATA_BLOCK_SIZE);
  253. return TRUE;
  254. }                                         
  255. BOOL LLPartSysData::unpackBlock(const S32 block_num)
  256. {
  257. U8 ps_data_block[PS_DATA_BLOCK_SIZE];
  258. // Check size of block
  259. S32 size = gMessageSystem->getSize("ObjectData", block_num, "PSBlock");
  260. if (size != PS_DATA_BLOCK_SIZE)
  261. {
  262. llwarns << "PSBlock is wrong size for particle system data - got " << size << ", expecting " << PS_DATA_BLOCK_SIZE << llendl;
  263. return FALSE;
  264. }
  265. // Get from message
  266. gMessageSystem->getBinaryData("ObjectData", "PSBlock", ps_data_block, PS_DATA_BLOCK_SIZE, block_num, PS_DATA_BLOCK_SIZE);
  267. LLDataPackerBinaryBuffer dp(ps_data_block, PS_DATA_BLOCK_SIZE);
  268. unpack(dp);
  269. return TRUE;
  270. }
  271. void LLPartSysData::clampSourceParticleRate()
  272. {
  273. F32 particle_rate = 0;
  274. particle_rate = mBurstPartCount/mBurstRate;
  275. if (particle_rate > 256.f)
  276. {
  277. mBurstPartCount = llfloor(((F32)mBurstPartCount)*(256.f/particle_rate));
  278. }
  279. }
  280. void LLPartSysData::setPartAccel(const LLVector3 &accel)
  281. {
  282. mPartAccel.mV[VX] = llclamp(accel.mV[VX], -100.f, 100.f);
  283. mPartAccel.mV[VY] = llclamp(accel.mV[VY], -100.f, 100.f);
  284. mPartAccel.mV[VZ] = llclamp(accel.mV[VZ], -100.f, 100.f);
  285. }