开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llvolumemessage.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：17k
源码类别：

游戏引擎

开发平台：

C++ Builder

llvolumemessage.cpp：源码内容
  1. /** 
  2.  * @file llvolumemessage.cpp
  3.  * @brief LLVolumeMessage base class
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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.  */
  33. #include "linden_common.h"
  35. #include "message.h"
  36. #include "llvolumemessage.h"
  37. #include "lldatapacker.h"
  39. //============================================================================
  41. // LLVolumeMessage is just a wrapper class; all members are static
  43. //============================================================================
  45. bool LLVolumeMessage::packProfileParams(
  46. const LLProfileParams* params,
  47. LLMessageSystem *mesgsys)
  48. {
  49. // Default to cylinder
  50. static LLProfileParams defaultparams(LL_PCODE_PROFILE_CIRCLE, U16(0), U16(0), U16(0));
  52. if (!params)
  53. params = &defaultparams;
  55. U8 tempU8;
  56. U16 tempU16;
  58. tempU8 = params->getCurveType();
  59. mesgsys->addU8Fast(_PREHASH_ProfileCurve, tempU8);
  61. tempU16 = (U16) llround( params->getBegin() / CUT_QUANTA);
  62. mesgsys->addU16Fast(_PREHASH_ProfileBegin, tempU16);
  64. tempU16 = 50000 - (U16) llround(params->getEnd() / CUT_QUANTA);
  65. mesgsys->addU16Fast(_PREHASH_ProfileEnd, tempU16);
  67. tempU16 = (U16) llround(params->getHollow() / HOLLOW_QUANTA);
  68. mesgsys->addU16Fast(_PREHASH_ProfileHollow, tempU16);
  70. return true;
  71. }
  73. bool LLVolumeMessage::packProfileParams(
  74. const LLProfileParams* params,
  75. LLDataPacker &dp)
  76. {
  77. // Default to cylinder
  78. static LLProfileParams defaultparams(LL_PCODE_PROFILE_CIRCLE, U16(0), U16(0), U16(0));
  80. if (!params)
  81. params = &defaultparams;
  83. U8 tempU8;
  84. U16 tempU16;
  86. tempU8 = params->getCurveType();
  87. dp.packU8(tempU8, "Curve");
  89. tempU16 = (U16) llround( params->getBegin() / CUT_QUANTA);
  90. dp.packU16(tempU16, "Begin");
  92. tempU16 = 50000 - (U16) llround(params->getEnd() / CUT_QUANTA);
  93. dp.packU16(tempU16, "End");
  95. tempU16 = (U16) llround(params->getHollow() / HOLLOW_QUANTA);
  96. dp.packU16(tempU16, "Hollow");
  97. return true;
  98. }
  100. bool LLVolumeMessage::unpackProfileParams(
  101. LLProfileParams* params,
  102. LLMessageSystem* mesgsys,
  103. char* block_name,
  104. S32 block_num)
  105. {
  106. bool ok = true;
  107. U8 temp_u8;
  108. U16 temp_u16;
  109. F32 temp_f32;
  111. mesgsys->getU8Fast(block_name, _PREHASH_ProfileCurve, temp_u8, block_num);
  112. params->setCurveType(temp_u8);
  114. mesgsys->getU16Fast(block_name, _PREHASH_ProfileBegin, temp_u16, block_num);
  115. temp_f32 = temp_u16 * CUT_QUANTA;
  116. if (temp_f32 > 1.f)
  117. {
  118. llwarns << "Profile begin out of range: " << temp_f32
  119. << ". Clamping to 0.0." << llendl;
  120. temp_f32 = 0.f;
  121. ok = false;
  122. }
  123. params->setBegin(temp_f32);
  125. mesgsys->getU16Fast(block_name, _PREHASH_ProfileEnd, temp_u16, block_num);
  126. temp_f32 = temp_u16 * CUT_QUANTA;
  127. if (temp_f32 > 1.f)
  128. {
  129. llwarns << "Profile end out of range: " << 1.f - temp_f32
  130. << ". Clamping to 1.0." << llendl;
  131. temp_f32 = 1.f;
  132. ok = false;
  133. }
  134. params->setEnd(1.f - temp_f32);
  136. mesgsys->getU16Fast(block_name, _PREHASH_ProfileHollow, temp_u16, block_num);
  137. temp_f32 = temp_u16 * HOLLOW_QUANTA;
  138. if (temp_f32 > 1.f)
  139. {
  140. llwarns << "Profile hollow out of range: " << temp_f32
  141. << ". Clamping to 0.0." << llendl;
  142. temp_f32 = 0.f;
  143. ok = false;
  144. }
  145. params->setHollow(temp_f32);
  147. /*
  148. llinfos << "Unpacking Profile Block " << block_num << llendl;
  149. llinfos << "Curve:     " << (U32)getCurve() << llendl;
  150. llinfos << "Begin:     " << getBegin() << llendl;
  151. llinfos << "End:     " << getEnd() << llendl;
  152. llinfos << "Hollow:     " << getHollow() << llendl;
  153. */
  154. return ok;
  156. }
  158. bool LLVolumeMessage::unpackProfileParams(
  159. LLProfileParams* params,
  160. LLDataPacker &dp)
  161. {
  162. bool ok = true;
  163. U8 temp_u8;
  164. U16 temp_u16;
  165. F32 temp_f32;
  167. dp.unpackU8(temp_u8, "Curve");
  168. params->setCurveType(temp_u8);
  170. dp.unpackU16(temp_u16, "Begin");
  171. temp_f32 = temp_u16 * CUT_QUANTA;
  172. if (temp_f32 > 1.f)
  173. {
  174. llwarns << "Profile begin out of range: " << temp_f32 << llendl;
  175. llwarns << "Clamping to 0.0" << llendl;
  176. temp_f32 = 0.f;
  177. ok = false;
  178. }
  179. params->setBegin(temp_f32);
  181. dp.unpackU16(temp_u16, "End");
  182. temp_f32 = temp_u16 * CUT_QUANTA;
  183. if (temp_f32 > 1.f)
  184. {
  185. llwarns << "Profile end out of range: " << 1.f - temp_f32 << llendl;
  186. llwarns << "Clamping to 1.0" << llendl;
  187. temp_f32 = 1.f;
  188. ok = false;
  189. }
  190. params->setEnd(1.f - temp_f32);
  192. dp.unpackU16(temp_u16, "Hollow");
  193. temp_f32 = temp_u16 * HOLLOW_QUANTA;
  194. if (temp_f32 > 1.f)
  195. {
  196. llwarns << "Profile hollow out of range: " << temp_f32 << llendl;
  197. llwarns << "Clamping to 0.0" << llendl;
  198. temp_f32 = 0.f;
  199. ok = false;
  200. }
  201. params->setHollow(temp_f32);
  203. return ok;
  204. }
  206. //============================================================================
  208. // Quantization:
  209. // For cut begin, range is 0 to 1, quanta is 0.005, 0 maps to 0
  210. // For cut end, range is 0 to 1, quanta is 0.005, 1 maps to 0
  211. // For scale, range is 0 to 1, quanta is 0.01, 0 maps to 0, 1 maps to 100
  212. // For shear, range is -0.5 to 0.5, quanta is 0.01, 0 maps to 0
  213. // For taper, range is -1 to 1, quanta is 0.01, 0 maps to 0
  214. bool LLVolumeMessage::packPathParams(
  215. const LLPathParams* params,
  216. LLMessageSystem *mesgsys)
  217. {
  218. // Default to cylinder with no cut, top same size as bottom, no shear, no twist
  219. static LLPathParams defaultparams(LL_PCODE_PATH_LINE, U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), 0);
  220. if (!params)
  221. params = &defaultparams;
  223. U8 curve = params->getCurveType();
  224. mesgsys->addU8Fast(_PREHASH_PathCurve, curve);
  226. U16 begin = (U16) llround(params->getBegin() / CUT_QUANTA);
  227. mesgsys->addU16Fast(_PREHASH_PathBegin, begin);
  229. U16 end = 50000 - (U16) llround(params->getEnd() / CUT_QUANTA);
  230. mesgsys->addU16Fast(_PREHASH_PathEnd, end);
  232. // Avoid truncation problem with direct F32->U8 cast.
  233. // (e.g., (U8) (0.50 / 0.01) = (U8) 49.9999999 = 49 not 50.
  235. U8 pack_scale_x = 200 - (U8) llround(params->getScaleX() / SCALE_QUANTA);
  236. mesgsys->addU8Fast(_PREHASH_PathScaleX, pack_scale_x );
  238. U8 pack_scale_y = 200 - (U8) llround(params->getScaleY() / SCALE_QUANTA);
  239. mesgsys->addU8Fast(_PREHASH_PathScaleY, pack_scale_y );
  241. U8 pack_shear_x = (U8) llround(params->getShearX() / SHEAR_QUANTA);
  242. mesgsys->addU8Fast(_PREHASH_PathShearX, pack_shear_x );
  244. U8 pack_shear_y = (U8) llround(params->getShearY() / SHEAR_QUANTA);
  245. mesgsys->addU8Fast(_PREHASH_PathShearY, pack_shear_y );
  247. S8 twist = (S8) llround(params->getTwist() / SCALE_QUANTA);
  248. mesgsys->addS8Fast(_PREHASH_PathTwist, twist);
  250. S8 twist_begin = (S8) llround(params->getTwistBegin() / SCALE_QUANTA);
  251. mesgsys->addS8Fast(_PREHASH_PathTwistBegin, twist_begin);
  253. S8 radius_offset = (S8) llround(params->getRadiusOffset() / SCALE_QUANTA);
  254. mesgsys->addS8Fast(_PREHASH_PathRadiusOffset, radius_offset);
  256. S8 taper_x = (S8) llround(params->getTaperX() / TAPER_QUANTA);
  257. mesgsys->addS8Fast(_PREHASH_PathTaperX, taper_x);
  259. S8 taper_y = (S8) llround(params->getTaperY() / TAPER_QUANTA);
  260. mesgsys->addS8Fast(_PREHASH_PathTaperY, taper_y);
  262. U8 revolutions = (U8) llround( (params->getRevolutions() - 1.0f) / REV_QUANTA);
  263. mesgsys->addU8Fast(_PREHASH_PathRevolutions, revolutions);
  265. S8 skew = (S8) llround(params->getSkew() / SCALE_QUANTA);
  266. mesgsys->addS8Fast(_PREHASH_PathSkew, skew);
  268. return true;
  269. }
  271. bool LLVolumeMessage::packPathParams(
  272. const LLPathParams* params,
  273. LLDataPacker &dp)
  274. {
  275. // Default to cylinder with no cut, top same size as bottom, no shear, no twist
  276. static LLPathParams defaultparams(LL_PCODE_PATH_LINE, U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), U8(0), 0);
  277. if (!params)
  278. params = &defaultparams;
  280. U8 curve = params->getCurveType();
  281. dp.packU8(curve, "Curve");
  283. U16 begin = (U16) llround(params->getBegin() / CUT_QUANTA);
  284. dp.packU16(begin, "Begin");
  286. U16 end = 50000 - (U16) llround(params->getEnd() / CUT_QUANTA);
  287. dp.packU16(end, "End");
  289. // Avoid truncation problem with direct F32->U8 cast.
  290. // (e.g., (U8) (0.50 / 0.01) = (U8) 49.9999999 = 49 not 50.
  292. U8 pack_scale_x = 200 - (U8) llround(params->getScaleX() / SCALE_QUANTA);
  293. dp.packU8(pack_scale_x, "ScaleX");
  295. U8 pack_scale_y = 200 - (U8) llround(params->getScaleY() / SCALE_QUANTA);
  296. dp.packU8(pack_scale_y, "ScaleY");
  298. S8 pack_shear_x = (S8) llround(params->getShearX() / SHEAR_QUANTA);
  299. dp.packU8(*(U8 *)&pack_shear_x, "ShearX");
  301. S8 pack_shear_y = (S8) llround(params->getShearY() / SHEAR_QUANTA);
  302. dp.packU8(*(U8 *)&pack_shear_y, "ShearY");
  304. S8 twist = (S8) llround(params->getTwist() / SCALE_QUANTA);
  305. dp.packU8(*(U8 *)&twist, "Twist");
  307. S8 twist_begin = (S8) llround(params->getTwistBegin() / SCALE_QUANTA);
  308. dp.packU8(*(U8 *)&twist_begin, "TwistBegin");
  310. S8 radius_offset = (S8) llround(params->getRadiusOffset() / SCALE_QUANTA);
  311. dp.packU8(*(U8 *)&radius_offset, "RadiusOffset");
  313. S8 taper_x = (S8) llround(params->getTaperX() / TAPER_QUANTA);
  314. dp.packU8(*(U8 *)&taper_x, "TaperX");
  316. S8 taper_y = (S8) llround(params->getTaperY() / TAPER_QUANTA);
  317. dp.packU8(*(U8 *)&taper_y, "TaperY");
  319. U8 revolutions = (U8) llround( (params->getRevolutions() - 1.0f) / REV_QUANTA);
  320. dp.packU8(*(U8 *)&revolutions, "Revolutions");
  322. S8 skew = (S8) llround(params->getSkew() / SCALE_QUANTA);
  323. dp.packU8(*(U8 *)&skew, "Skew");
  325. return true;
  326. }
  328. bool LLVolumeMessage::unpackPathParams(
  329. LLPathParams* params,
  330. LLMessageSystem* mesgsys,
  331. char* block_name,
  332. S32 block_num)
  333. {
  334. U8 curve;
  335. mesgsys->getU8Fast(block_name, _PREHASH_PathCurve, curve, block_num);
  336. params->setCurveType(curve);
  338. U16 begin;
  339. mesgsys->getU16Fast(block_name, _PREHASH_PathBegin, begin, block_num);
  340. params->setBegin((F32)(begin * CUT_QUANTA));
  342. U16 end;
  343. mesgsys->getU16Fast(block_name, _PREHASH_PathEnd, end, block_num);
  344. params->setEnd((F32)((50000 - end) * CUT_QUANTA));
  346. U8 pack_scale_x, pack_scale_y;
  347. mesgsys->getU8Fast(block_name, _PREHASH_PathScaleX, pack_scale_x, block_num);
  348. mesgsys->getU8Fast(block_name, _PREHASH_PathScaleY, pack_scale_y, block_num);
  349. F32 x = (F32) (200 - pack_scale_x) * SCALE_QUANTA;
  350. F32 y = (F32) (200 - pack_scale_y) * SCALE_QUANTA;
  351. params->setScale( x, y );
  353. S8 shear_x_quant, shear_y_quant;
  354. mesgsys->getS8Fast(block_name, _PREHASH_PathShearX, shear_x_quant, block_num);
  355. mesgsys->getS8Fast(block_name, _PREHASH_PathShearY, shear_y_quant, block_num);
  356. F32 shear_x = (F32) shear_x_quant * SHEAR_QUANTA;
  357. F32 shear_y = (F32) shear_y_quant * SHEAR_QUANTA;
  358. params->setShear( shear_x, shear_y );
  360. S8 twist;
  361. mesgsys->getS8Fast(block_name, _PREHASH_PathTwist, twist, block_num );
  362. params->setTwist((F32)(twist * SCALE_QUANTA));
  364. S8 twist_begin;
  365. mesgsys->getS8Fast(block_name, _PREHASH_PathTwistBegin, twist_begin, block_num );
  366. params->setTwistBegin((F32)(twist_begin * SCALE_QUANTA));
  368. S8 radius_offset;
  369. mesgsys->getS8Fast(block_name, _PREHASH_PathRadiusOffset, radius_offset, block_num );
  370. params->setRadiusOffset((F32)(radius_offset * SCALE_QUANTA));
  372. S8 taper_x_quant, taper_y_quant;
  373. mesgsys->getS8Fast(block_name, _PREHASH_PathTaperX, taper_x_quant, block_num );
  374. mesgsys->getS8Fast(block_name, _PREHASH_PathTaperY, taper_y_quant, block_num );
  375. F32 taper_x = (F32)(taper_x_quant * TAPER_QUANTA);
  376. F32 taper_y = (F32)(taper_y_quant * TAPER_QUANTA);
  377. params->setTaper( taper_x, taper_y );
  379. U8 revolutions;
  380. mesgsys->getU8Fast(block_name, _PREHASH_PathRevolutions, revolutions, block_num );
  381. params->setRevolutions((F32)(revolutions * REV_QUANTA + 1.0f));
  383. S8 skew;
  384. mesgsys->getS8Fast(block_name, _PREHASH_PathSkew, skew, block_num );
  385. params->setSkew((F32)(skew * SCALE_QUANTA));
  387. /*
  388. llinfos << "Unpacking Path Block " << block_num << llendl;
  389. llinfos << "Curve:     " << (U32)params->getCurve() << llendl;
  390. llinfos << "Begin:     " << params->getBegin() << llendl;
  391. llinfos << "End:     " << params->getEnd() << llendl;
  392. llinfos << "Scale:     " << params->getScale() << llendl;
  393. llinfos << "Twist:     " << params->getTwist() << llendl;
  394. */
  396. return true;
  398. }
  400. bool LLVolumeMessage::unpackPathParams(LLPathParams* params, LLDataPacker &dp)
  401. {
  402. U8 value;
  403. S8 svalue;
  404. U16 temp_u16;
  406. dp.unpackU8(value, "Curve");
  407. params->setCurveType( value );
  409. dp.unpackU16(temp_u16, "Begin");
  410. params->setBegin((F32)(temp_u16 * CUT_QUANTA));
  412. dp.unpackU16(temp_u16, "End");
  413. params->setEnd((F32)((50000 - temp_u16) * CUT_QUANTA));
  415. dp.unpackU8(value, "ScaleX");
  416. F32 x = (F32) (200 - value) * SCALE_QUANTA;
  417. dp.unpackU8(value, "ScaleY");
  418. F32 y = (F32) (200 - value) * SCALE_QUANTA;
  419. params->setScale( x, y );
  421. dp.unpackU8(value, "ShearX");
  422. svalue = *(S8 *)&value;
  423. F32 shear_x = (F32) svalue * SHEAR_QUANTA;
  424. dp.unpackU8(value, "ShearY");
  425. svalue = *(S8 *)&value;
  426. F32 shear_y = (F32) svalue * SHEAR_QUANTA;
  427. params->setShear( shear_x, shear_y );
  429. dp.unpackU8(value, "Twist");
  430. svalue = *(S8 *)&value;
  431. params->setTwist((F32)(svalue * SCALE_QUANTA));
  433. dp.unpackU8(value, "TwistBegin");
  434. svalue = *(S8 *)&value;
  435. params->setTwistBegin((F32)(svalue * SCALE_QUANTA));
  437. dp.unpackU8(value, "RadiusOffset");
  438. svalue = *(S8 *)&value;
  439. params->setRadiusOffset((F32)(svalue * SCALE_QUANTA));
  441. dp.unpackU8(value, "TaperX");
  442. svalue = *(S8 *)&value;
  443. params->setTaperX((F32)(svalue * TAPER_QUANTA));
  445. dp.unpackU8(value, "TaperY");
  446. svalue = *(S8 *)&value;
  447. params->setTaperY((F32)(svalue * TAPER_QUANTA));
  449. dp.unpackU8(value, "Revolutions");
  450. params->setRevolutions((F32)(value * REV_QUANTA + 1.0f));
  452. dp.unpackU8(value, "Skew");
  453. svalue = *(S8 *)&value;
  454. params->setSkew((F32)(svalue * SCALE_QUANTA));
  456. return true;
  457. }
  459. //============================================================================
  461. // static
  462. bool LLVolumeMessage::constrainVolumeParams(LLVolumeParams& params)
  463. {
  464. U32 bad = 0;
  466. // This is called immediately after an unpack. feed the raw data
  467. // through the checked setters to constraint it to a valid set of
  468. // volume params.
  469. bad |= params.setType(params.getProfileParams().getCurveType(),
  470.  params.getPathParams().getCurveType()) ? 0 : 1;
  471. bad |= params.setBeginAndEndS(params.getProfileParams().getBegin(),
  472.   params.getProfileParams().getEnd()) ? 0 : 2;
  473. bad |= params.setBeginAndEndT(params.getPathParams().getBegin(),
  474.   params.getPathParams().getEnd()) ? 0 : 4;
  475. bad |= params.setHollow(params.getProfileParams().getHollow()) ? 0 : 8;
  476. bad |= params.setTwistBegin(params.getPathParams().getTwistBegin()) ? 0 : 0x10;
  477. bad |= params.setTwistEnd(params.getPathParams().getTwistEnd()) ? 0 : 0x20;
  478. bad |= params.setRatio(params.getPathParams().getScaleX(),
  479.    params.getPathParams().getScaleY()) ? 0 : 0x40;
  480. bad |= params.setShear(params.getPathParams().getShearX(),
  481.    params.getPathParams().getShearY()) ? 0 : 0x80;
  482. bad |= params.setTaper(params.getPathParams().getTaperX(),
  483.    params.getPathParams().getTaperY()) ? 0 : 0x100;
  484. bad |= params.setRevolutions(params.getPathParams().getRevolutions()) ? 0 : 0x200;
  485. bad |= params.setRadiusOffset(params.getPathParams().getRadiusOffset()) ? 0 : 0x400;
  486. bad |= params.setSkew(params.getPathParams().getSkew()) ? 0 : 0x800;
  487. if(bad)
  488. {
  489. llwarns << "LLVolumeMessage::constrainVolumeParams() - "
  490. << "forced to constrain incoming volume params: "
  491. << llformat("0x%04x",bad) << llendl;
  492. }
  493. return bad ? false : true;
  494. }
  496. bool LLVolumeMessage::packVolumeParams(const LLVolumeParams* params, LLMessageSystem *mesgsys)
  497. {
  498. // llinfos << "pack volume" << llendl;
  499. if (params)
  500. {
  501. packPathParams(&params->getPathParams(), mesgsys);
  502. packProfileParams(&params->getProfileParams(), mesgsys);
  503. }
  504. else
  505. {
  506. packPathParams(0, mesgsys);
  507. packProfileParams(0, mesgsys);
  508. }
  509. return true;
  510. }
  512. bool LLVolumeMessage::packVolumeParams(const LLVolumeParams* params, LLDataPacker &dp)
  513. {
  514. // llinfos << "pack volume" << llendl;
  515. if (params)
  516. {
  517. packPathParams(&params->getPathParams(), dp);
  518. packProfileParams(&params->getProfileParams(), dp);
  519. }
  520. else
  521. {
  522. packPathParams(0, dp);
  523. packProfileParams(0, dp);
  524. }
  525. return true;
  526. }
  528. bool LLVolumeMessage::unpackVolumeParams(
  529. LLVolumeParams* params,
  530. LLMessageSystem* mesgsys,
  531. char* block_name,
  532. S32 block_num)
  533. {
  534. bool ok = true;
  535. ok &= unpackPathParams(
  536. &params->getPathParams(),
  537. mesgsys,
  538. block_name,
  539. block_num);
  540. ok &= unpackProfileParams(
  541. &params->getProfileParams(),
  542. mesgsys,
  543. block_name,
  544. block_num);
  545. ok &= constrainVolumeParams(*params);
  547. return ok;
  548. }
  550. bool LLVolumeMessage::unpackVolumeParams(
  551. LLVolumeParams* params,
  552. LLDataPacker &dp)
  553. {
  554. bool ok = true;
  555. ok &= unpackPathParams(&params->getPathParams(), dp);
  556. ok &= unpackProfileParams(&params->getProfileParams(), dp);
  557. ok &= constrainVolumeParams(*params);
  558. return ok;
  559. }
  561. //============================================================================