BOOL LLGestureStepSound::deserialize(LLDataPacker& dp)
{
dp.unpackString(mSoundName, "sound_name");
dp.unpackUUID(mSoundAssetID, "asset_id");
dp.unpackU32(mFlags, "flags");
return TRUE;
}
void LLTransferSourceParamsEstate::packParams(LLDataPacker &dp) const
{
dp.packUUID(mAgentID, "AgentID");
// *NOTE: We do not want to pass the session id from the server to
// the client, but I am not sure if anyone expects this value to
// be set on the client.
dp.packUUID(mSessionID, "SessionID");
dp.packS32(mEstateAssetType, "EstateAssetType");
}
BOOL LLTransferSourceParamsFile::unpackParams(LLDataPacker &dp)
{
dp.unpackString(mFilename, "Filename");
U8 delete_flag;
dp.unpackU8(delete_flag, "Delete");
mDeleteOnCompletion = delete_flag;
llinfos << "Unpacked filename: " << mFilename << llendl;
return TRUE;
}
BOOL LLTransferSourceParamsAsset::unpackParams(LLDataPacker &dp)
{
S32 tmp_at;
dp.unpackUUID(mAssetID, "AssetID");
dp.unpackS32(tmp_at, "AssetType");
mAssetType = (LLAssetType::EType)tmp_at;
return TRUE;
}
BOOL LLTransferSourceParamsEstate::unpackParams(LLDataPacker &dp)
{
S32 tmp_et;
dp.unpackUUID(mAgentID, "AgentID");
dp.unpackUUID(mSessionID, "SessionID");
dp.unpackS32(tmp_et, "EstateAssetType");
mEstateAssetType = (EstateAssetType)tmp_et;
return TRUE;
}
BOOL LLGestureStepAnimation::deserialize(LLDataPacker& dp)
{
dp.unpackString(mAnimName, "anim_name");
// Apparently an earlier version of the gesture code added \r to the end
// of the animation names. Get rid of it. JC
if (!mAnimName.empty() && mAnimName[mAnimName.length() - 1] == '\r')
{
// chop the last character
mAnimName.resize(mAnimName.length() - 1);
}
dp.unpackUUID(mAnimAssetID, "asset_id");
dp.unpackU32(mFlags, "flags");
return TRUE;
}
bool LLVolumeMessage::unpackProfileParams(
LLProfileParams* params,
LLDataPacker &dp)
{
bool ok = true;
U8 temp_u8;
U16 temp_u16;
F32 temp_f32;
dp.unpackU8(temp_u8, "Curve");
params->setCurveType(temp_u8);
dp.unpackU16(temp_u16, "Begin");
temp_f32 = temp_u16 * CUT_QUANTA;
if (temp_f32 > 1.f)
{
LL_WARNS() << "Profile begin out of range: " << temp_f32 << LL_ENDL;
LL_WARNS() << "Clamping to 0.0" << LL_ENDL;
temp_f32 = 0.f;
ok = false;
}
params->setBegin(temp_f32);
dp.unpackU16(temp_u16, "End");
temp_f32 = temp_u16 * CUT_QUANTA;
if (temp_f32 > 1.f)
{
LL_WARNS() << "Profile end out of range: " << 1.f - temp_f32 << LL_ENDL;
LL_WARNS() << "Clamping to 1.0" << LL_ENDL;
temp_f32 = 1.f;
ok = false;
}
params->setEnd(1.f - temp_f32);
dp.unpackU16(temp_u16, "Hollow");
temp_f32 = temp_u16 * HOLLOW_QUANTA;
if (temp_f32 > 1.f)
{
LL_WARNS() << "Profile hollow out of range: " << temp_f32 << LL_ENDL;
LL_WARNS() << "Clamping to 0.0" << LL_ENDL;
temp_f32 = 0.f;
ok = false;
}
params->setHollow(temp_f32);
return ok;
}
void LLThrottleGroup::packThrottle(LLDataPacker &dp) const
{
S32 i;
for (i = 0; i < TC_EOF; i++)
{
dp.packF32(mThrottleTotal[i], "Throttle");
}
}
void LLTextureAnim::packTAMessage(LLDataPacker &dp) const
{
U8 data[TA_BLOCK_SIZE];
data[0] = mMode;
data[1] = mFace;
data[2] = mSizeX;
data[3] = mSizeY;
htonmemcpy(data + 4, &mStart, MVT_F32, sizeof(F32));
htonmemcpy(data + 8, &mLength, MVT_F32, sizeof(F32));
htonmemcpy(data + 12, &mRate, MVT_F32, sizeof(F32));
dp.packBinaryData(data, TA_BLOCK_SIZE, "TextureAnimation");
}
void LLThrottleGroup::unpackThrottle(LLDataPacker &dp)
{
S32 i;
for (i = 0; i < TC_EOF; i++)
{
F32 temp_throttle;
dp.unpackF32(temp_throttle, "Throttle");
temp_throttle = llclamp(temp_throttle, 0.f, 2250000.f);
mThrottleTotal[i] = temp_throttle;
if(mThrottleTotal[i] > gThrottleMaximumBPS[i])
{
mThrottleTotal[i] = gThrottleMaximumBPS[i];
}
}
}
void LLTransferSourceParamsInvItem::packParams(LLDataPacker &dp) const
{
lldebugs << "LLTransferSourceParamsInvItem::packParams()" << llendl;
dp.packUUID(mAgentID, "AgentID");
dp.packUUID(mSessionID, "SessionID");
dp.packUUID(mOwnerID, "OwnerID");
dp.packUUID(mTaskID, "TaskID");
dp.packUUID(mItemID, "ItemID");
dp.packUUID(mAssetID, "AssetID");
dp.packS32(mAssetType, "AssetType");
}
BOOL LLPartData::pack(LLDataPacker &dp)
{
LLColor4U coloru;
dp.packU32(mFlags, "pdflags");
dp.packFixed(mMaxAge, "pdmaxage", FALSE, 8, 8);
coloru.setVec(mStartColor);
dp.packColor4U(coloru, "pdstartcolor");
coloru.setVec(mEndColor);
dp.packColor4U(coloru, "pdendcolor");
dp.packFixed(mStartScale.mV[0], "pdstartscalex", FALSE, 3, 5);
dp.packFixed(mStartScale.mV[1], "pdstartscaley", FALSE, 3, 5);
dp.packFixed(mEndScale.mV[0], "pdendscalex", FALSE, 3, 5);
dp.packFixed(mEndScale.mV[1], "pdendscaley", FALSE, 3, 5);
return TRUE;
}
BOOL LLTransferSourceParamsInvItem::unpackParams(LLDataPacker &dp)
{
S32 tmp_at;
dp.unpackUUID(mAgentID, "AgentID");
dp.unpackUUID(mSessionID, "SessionID");
dp.unpackUUID(mOwnerID, "OwnerID");
dp.unpackUUID(mTaskID, "TaskID");
dp.unpackUUID(mItemID, "ItemID");
dp.unpackUUID(mAssetID, "AssetID");
dp.unpackS32(tmp_at, "AssetType");
mAssetType = (LLAssetType::EType)tmp_at;
return TRUE;
}
void LLTextureAnim::unpackTAMessage(LLDataPacker &dp)
{
S32 size;
U8 data[TA_BLOCK_SIZE];
dp.unpackBinaryData(data, size, "TextureAnimation");
if (size != TA_BLOCK_SIZE)
{
if (size)
{
LL_WARNS() << "Bad size " << size << " for TA block, ignoring." << LL_ENDL;
}
mMode = 0;
return;
}
mMode = data[0];
mFace = data[1];
mSizeX = data[2];
mSizeY = data[3];
htonmemcpy(&mStart, data + 4, MVT_F32, sizeof(F32));
htonmemcpy(&mLength, data + 8, MVT_F32, sizeof(F32));
htonmemcpy(&mRate, data + 12, MVT_F32, sizeof(F32));
}
bool LLTransferTargetParamsVFile::unpackParams(LLDataPacker& dp)
{
// if the source provided a new key, assign that to the asset id.
if(dp.hasNext())
{
LLUUID dummy_id;
dp.unpackUUID(dummy_id, "AgentID");
dp.unpackUUID(dummy_id, "SessionID");
dp.unpackUUID(dummy_id, "OwnerID");
dp.unpackUUID(dummy_id, "TaskID");
dp.unpackUUID(dummy_id, "ItemID");
dp.unpackUUID(mAssetID, "AssetID");
S32 dummy_type;
dp.unpackS32(dummy_type, "AssetType");
}
// if we never got an asset id, this will always fail.
if(mAssetID.isNull())
{
return false;
}
return true;
}
BOOL LLMultiGesture::serialize(LLDataPacker& dp) const
{
dp.packS32(GESTURE_VERSION, "version");
dp.packU8(mKey, "key");
dp.packU32(mMask, "mask");
dp.packString(mTrigger, "trigger");
dp.packString(mReplaceText, "replace");
S32 count = (S32)mSteps.size();
dp.packS32(count, "step_count");
S32 i;
for (i = 0; i < count; ++i)
{
LLGestureStep* step = mSteps[i];
dp.packS32(step->getType(), "step_type");
BOOL ok = step->serialize(dp);
if (!ok)
{
return FALSE;
}
}
return TRUE;
}
BOOL LLGestureStepWait::deserialize(LLDataPacker& dp)
{
dp.unpackF32(mWaitSeconds, "wait_seconds");
dp.unpackU32(mFlags, "flags");
return TRUE;
}
BOOL LLGestureStepChat::serialize(LLDataPacker& dp) const
{
dp.packString(mChatText, "chat_text");
dp.packU32(mFlags, "flags");
return TRUE;
}
void LLTransferSourceParamsAsset::packParams(LLDataPacker &dp) const
{
dp.packUUID(mAssetID, "AssetID");
dp.packS32(mAssetType, "AssetType");
}
BOOL LLMultiGesture::deserialize(LLDataPacker& dp)
{
S32 version;
dp.unpackS32(version, "version");
if (version != GESTURE_VERSION)
{
llwarns << "Bad LLMultiGesture version " << version
<< " should be " << GESTURE_VERSION
<< llendl;
return FALSE;
}
dp.unpackU8(mKey, "key");
dp.unpackU32(mMask, "mask");
dp.unpackString(mTrigger, "trigger");
dp.unpackString(mReplaceText, "replace");
S32 count;
dp.unpackS32(count, "step_count");
if (count < 0)
{
llwarns << "Bad LLMultiGesture step count " << count << llendl;
return FALSE;
}
S32 i;
for (i = 0; i < count; ++i)
{
S32 type;
dp.unpackS32(type, "step_type");
EStepType step_type = (EStepType)type;
switch(step_type)
{
case STEP_ANIMATION:
{
LLGestureStepAnimation* step = new LLGestureStepAnimation();
BOOL ok = step->deserialize(dp);
if (!ok) return FALSE;
mSteps.push_back(step);
break;
}
case STEP_SOUND:
{
LLGestureStepSound* step = new LLGestureStepSound();
BOOL ok = step->deserialize(dp);
if (!ok) return FALSE;
mSteps.push_back(step);
break;
}
case STEP_CHAT:
{
LLGestureStepChat* step = new LLGestureStepChat();
BOOL ok = step->deserialize(dp);
if (!ok) return FALSE;
mSteps.push_back(step);
break;
}
case STEP_WAIT:
{
LLGestureStepWait* step = new LLGestureStepWait();
BOOL ok = step->deserialize(dp);
if (!ok) return FALSE;
mSteps.push_back(step);
break;
}
default:
{
llwarns << "Bad LLMultiGesture step type " << type << llendl;
return FALSE;
}
}
}
return TRUE;
}
bool LLVolumeMessage::unpackPathParams(LLPathParams* params, LLDataPacker &dp)
{
U8 value;
S8 svalue;
U16 temp_u16;
dp.unpackU8(value, "Curve");
params->setCurveType( value );
dp.unpackU16(temp_u16, "Begin");
params->setBegin((F32)(temp_u16 * CUT_QUANTA));
dp.unpackU16(temp_u16, "End");
params->setEnd((F32)((50000 - temp_u16) * CUT_QUANTA));
dp.unpackU8(value, "ScaleX");
F32 x = (F32) (200 - value) * SCALE_QUANTA;
dp.unpackU8(value, "ScaleY");
F32 y = (F32) (200 - value) * SCALE_QUANTA;
params->setScale( x, y );
dp.unpackU8(value, "ShearX");
svalue = *(S8 *)&value;
F32 shear_x = (F32) svalue * SHEAR_QUANTA;
dp.unpackU8(value, "ShearY");
svalue = *(S8 *)&value;
F32 shear_y = (F32) svalue * SHEAR_QUANTA;
params->setShear( shear_x, shear_y );
dp.unpackU8(value, "Twist");
svalue = *(S8 *)&value;
params->setTwist((F32)(svalue * SCALE_QUANTA));
dp.unpackU8(value, "TwistBegin");
svalue = *(S8 *)&value;
params->setTwistBegin((F32)(svalue * SCALE_QUANTA));
dp.unpackU8(value, "RadiusOffset");
svalue = *(S8 *)&value;
params->setRadiusOffset((F32)(svalue * SCALE_QUANTA));
dp.unpackU8(value, "TaperX");
svalue = *(S8 *)&value;
params->setTaperX((F32)(svalue * TAPER_QUANTA));
dp.unpackU8(value, "TaperY");
svalue = *(S8 *)&value;
params->setTaperY((F32)(svalue * TAPER_QUANTA));
dp.unpackU8(value, "Revolutions");
params->setRevolutions((F32)(value * REV_QUANTA + 1.0f));
dp.unpackU8(value, "Skew");
svalue = *(S8 *)&value;
params->setSkew((F32)(svalue * SCALE_QUANTA));
return true;
}
bool LLVolumeMessage::packPathParams(
const LLPathParams* params,
LLDataPacker &dp)
{
// Default to cylinder with no cut, top same size as bottom, no shear, no twist
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);
if (!params)
params = &defaultparams;
U8 curve = params->getCurveType();
dp.packU8(curve, "Curve");
U16 begin = (U16) ll_round(params->getBegin() / CUT_QUANTA);
dp.packU16(begin, "Begin");
U16 end = 50000 - (U16) ll_round(params->getEnd() / CUT_QUANTA);
dp.packU16(end, "End");
// Avoid truncation problem with direct F32->U8 cast.
// (e.g., (U8) (0.50 / 0.01) = (U8) 49.9999999 = 49 not 50.
U8 pack_scale_x = 200 - (U8) ll_round(params->getScaleX() / SCALE_QUANTA);
dp.packU8(pack_scale_x, "ScaleX");
U8 pack_scale_y = 200 - (U8) ll_round(params->getScaleY() / SCALE_QUANTA);
dp.packU8(pack_scale_y, "ScaleY");
S8 pack_shear_x = (S8) ll_round(params->getShearX() / SHEAR_QUANTA);
dp.packU8(*(U8 *)&pack_shear_x, "ShearX");
S8 pack_shear_y = (S8) ll_round(params->getShearY() / SHEAR_QUANTA);
dp.packU8(*(U8 *)&pack_shear_y, "ShearY");
S8 twist = (S8) ll_round(params->getTwist() / SCALE_QUANTA);
dp.packU8(*(U8 *)&twist, "Twist");
S8 twist_begin = (S8) ll_round(params->getTwistBegin() / SCALE_QUANTA);
dp.packU8(*(U8 *)&twist_begin, "TwistBegin");
S8 radius_offset = (S8) ll_round(params->getRadiusOffset() / SCALE_QUANTA);
dp.packU8(*(U8 *)&radius_offset, "RadiusOffset");
S8 taper_x = (S8) ll_round(params->getTaperX() / TAPER_QUANTA);
dp.packU8(*(U8 *)&taper_x, "TaperX");
S8 taper_y = (S8) ll_round(params->getTaperY() / TAPER_QUANTA);
dp.packU8(*(U8 *)&taper_y, "TaperY");
U8 revolutions = (U8) ll_round( (params->getRevolutions() - 1.0f) / REV_QUANTA);
dp.packU8(*(U8 *)&revolutions, "Revolutions");
S8 skew = (S8) ll_round(params->getSkew() / SCALE_QUANTA);
dp.packU8(*(U8 *)&skew, "Skew");
return true;
}
void LLTransferSourceParamsFile::packParams(LLDataPacker &dp) const
{
dp.packString(mFilename, "Filename");
dp.packU8((U8)mDeleteOnCompletion, "Delete");
}
// writes contents to datapacker
BOOL LLBVHLoader::serialize(LLDataPacker& dp)
{
JointVector::iterator ji;
KeyVector::iterator ki;
F32 time;
// count number of non-ignored joints
S32 numJoints = 0;
for (ji=mJoints.begin(); ji!=mJoints.end(); ++ji)
{
Joint *joint = *ji;
if ( ! joint->mIgnore )
numJoints++;
}
// print header
dp.packU16(KEYFRAME_MOTION_VERSION, "version");
dp.packU16(KEYFRAME_MOTION_SUBVERSION, "sub_version");
dp.packS32(mPriority, "base_priority");
dp.packF32(mDuration, "duration");
dp.packString(mEmoteName, "emote_name");
dp.packF32(mLoopInPoint, "loop_in_point");
dp.packF32(mLoopOutPoint, "loop_out_point");
dp.packS32(mLoop, "loop");
dp.packF32(mEaseIn, "ease_in_duration");
dp.packF32(mEaseOut, "ease_out_duration");
dp.packU32(mHand, "hand_pose");
dp.packU32(numJoints, "num_joints");
for ( ji = mJoints.begin();
ji != mJoints.end();
++ji )
{
Joint *joint = *ji;
// if ignored, skip it
if ( joint->mIgnore )
continue;
LLQuaternion first_frame_rot;
LLQuaternion fixup_rot;
dp.packString(joint->mOutName, "joint_name");
dp.packS32(joint->mPriority, "joint_priority");
// compute coordinate frame rotation
LLQuaternion frameRot( joint->mFrameMatrix );
LLQuaternion frameRotInv = ~frameRot;
LLQuaternion offsetRot( joint->mOffsetMatrix );
// find mergechild and mergeparent joints, if specified
LLQuaternion mergeParentRot;
LLQuaternion mergeChildRot;
Joint *mergeParent = NULL;
Joint *mergeChild = NULL;
JointVector::iterator mji;
for (mji=mJoints.begin(); mji!=mJoints.end(); ++mji)
{
Joint *mjoint = *mji;
if ( !joint->mMergeParentName.empty() && (mjoint->mName == joint->mMergeParentName) )
{
mergeParent = *mji;
}
if ( !joint->mMergeChildName.empty() && (mjoint->mName == joint->mMergeChildName) )
{
mergeChild = *mji;
}
}
dp.packS32(joint->mNumRotKeys, "num_rot_keys");
LLQuaternion::Order order = bvhStringToOrder( joint->mOrder );
S32 outcount = 0;
S32 frame = 1;
for ( ki = joint->mKeys.begin();
ki != joint->mKeys.end();
++ki )
{
if ((frame == 1) && joint->mRelativeRotationKey)
{
first_frame_rot = mayaQ( ki->mRot[0], ki->mRot[1], ki->mRot[2], order);
fixup_rot.shortestArc(LLVector3::z_axis * first_frame_rot * frameRot, LLVector3::z_axis);
}
if (ki->mIgnoreRot)
{
frame++;
continue;
}
time = (F32)frame * mFrameTime;
if (mergeParent)
{
mergeParentRot = mayaQ( mergeParent->mKeys[frame-1].mRot[0],
mergeParent->mKeys[frame-1].mRot[1],
mergeParent->mKeys[frame-1].mRot[2],
bvhStringToOrder(mergeParent->mOrder) );
LLQuaternion parentFrameRot( mergeParent->mFrameMatrix );
LLQuaternion parentOffsetRot( mergeParent->mOffsetMatrix );
mergeParentRot = ~parentFrameRot * mergeParentRot * parentFrameRot * parentOffsetRot;
}
else
{
mergeParentRot.loadIdentity();
}
if (mergeChild)
{
mergeChildRot = mayaQ( mergeChild->mKeys[frame-1].mRot[0],
mergeChild->mKeys[frame-1].mRot[1],
mergeChild->mKeys[frame-1].mRot[2],
bvhStringToOrder(mergeChild->mOrder) );
LLQuaternion childFrameRot( mergeChild->mFrameMatrix );
LLQuaternion childOffsetRot( mergeChild->mOffsetMatrix );
mergeChildRot = ~childFrameRot * mergeChildRot * childFrameRot * childOffsetRot;
}
else
{
mergeChildRot.loadIdentity();
}
LLQuaternion inRot = mayaQ( ki->mRot[0], ki->mRot[1], ki->mRot[2], order);
LLQuaternion outRot = frameRotInv* mergeChildRot * inRot * mergeParentRot * ~first_frame_rot * frameRot * offsetRot;
U16 time_short = F32_to_U16(time, 0.f, mDuration);
dp.packU16(time_short, "time");
U16 x, y, z;
LLVector3 rot_vec = outRot.packToVector3();
rot_vec.quantize16(-1.f, 1.f, -1.f, 1.f);
x = F32_to_U16(rot_vec.mV[VX], -1.f, 1.f);
y = F32_to_U16(rot_vec.mV[VY], -1.f, 1.f);
z = F32_to_U16(rot_vec.mV[VZ], -1.f, 1.f);
dp.packU16(x, "rot_angle_x");
dp.packU16(y, "rot_angle_y");
dp.packU16(z, "rot_angle_z");
outcount++;
frame++;
}
// output position keys (only for 1st joint)
if ( ji == mJoints.begin() && !joint->mIgnorePositions )
{
dp.packS32(joint->mNumPosKeys, "num_pos_keys");
LLVector3 relPos = joint->mRelativePosition;
LLVector3 relKey;
frame = 1;
for ( ki = joint->mKeys.begin();
ki != joint->mKeys.end();
++ki )
{
if ((frame == 1) && joint->mRelativePositionKey)
{
relKey.setVec(ki->mPos);
}
if (ki->mIgnorePos)
{
frame++;
continue;
}
time = (F32)frame * mFrameTime;
LLVector3 inPos = (LLVector3(ki->mPos) - relKey) * ~first_frame_rot;// * fixup_rot;
LLVector3 outPos = inPos * frameRot * offsetRot;
outPos *= INCHES_TO_METERS;
outPos -= relPos;
outPos.clamp(-LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
U16 time_short = F32_to_U16(time, 0.f, mDuration);
dp.packU16(time_short, "time");
U16 x, y, z;
outPos.quantize16(-LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
x = F32_to_U16(outPos.mV[VX], -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
y = F32_to_U16(outPos.mV[VY], -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
z = F32_to_U16(outPos.mV[VZ], -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
dp.packU16(x, "pos_x");
dp.packU16(y, "pos_y");
dp.packU16(z, "pos_z");
frame++;
}
}
else
{
dp.packS32(0, "num_pos_keys");
}
}
S32 num_constraints = (S32)mConstraints.size();
dp.packS32(num_constraints, "num_constraints");
for (ConstraintVector::iterator constraint_it = mConstraints.begin();
constraint_it != mConstraints.end();
constraint_it++)
{
U8 byte = constraint_it->mChainLength;
dp.packU8(byte, "chain_lenght");
byte = constraint_it->mConstraintType;
dp.packU8(byte, "constraint_type");
dp.packBinaryDataFixed((U8*)constraint_it->mSourceJointName, 16, "source_volume");
dp.packVector3(constraint_it->mSourceOffset, "source_offset");
dp.packBinaryDataFixed((U8*)constraint_it->mTargetJointName, 16, "target_volume");
dp.packVector3(constraint_it->mTargetOffset, "target_offset");
dp.packVector3(constraint_it->mTargetDir, "target_dir");
dp.packF32(constraint_it->mEaseInStart, "ease_in_start");
dp.packF32(constraint_it->mEaseInStop, "ease_in_stop");
dp.packF32(constraint_it->mEaseOutStart, "ease_out_start");
dp.packF32(constraint_it->mEaseOutStop, "ease_out_stop");
}
return TRUE;
}
BOOL LLPartSysData::unpack(LLDataPacker &dp)
{
dp.unpackU32(mCRC, "pscrc");
dp.unpackU32(mFlags, "psflags");
dp.unpackU8(mPattern, "pspattern");
dp.unpackFixed(mMaxAge, "psmaxage", FALSE, 8, 8);
dp.unpackFixed(mStartAge, "psstartage", FALSE, 8, 8);
dp.unpackFixed(mInnerAngle, "psinnerangle", FALSE, 3, 5);
dp.unpackFixed(mOuterAngle, "psouterangle", FALSE, 3, 5);
dp.unpackFixed(mBurstRate, "psburstrate", FALSE, 8, 8);
mBurstRate = llmax(0.01f, mBurstRate);
dp.unpackFixed(mBurstRadius, "psburstradius", FALSE, 8, 8);
dp.unpackFixed(mBurstSpeedMin, "psburstspeedmin", FALSE, 8, 8);
dp.unpackFixed(mBurstSpeedMax, "psburstspeedmax", FALSE, 8, 8);
dp.unpackU8(mBurstPartCount, "psburstpartcount");
dp.unpackFixed(mAngularVelocity.mV[0], "psangvelx", TRUE, 8, 7);
dp.unpackFixed(mAngularVelocity.mV[1], "psangvely", TRUE, 8, 7);
dp.unpackFixed(mAngularVelocity.mV[2], "psangvelz", TRUE, 8, 7);
dp.unpackFixed(mPartAccel.mV[0], "psaccelx", TRUE, 8, 7);
dp.unpackFixed(mPartAccel.mV[1], "psaccely", TRUE, 8, 7);
dp.unpackFixed(mPartAccel.mV[2], "psaccelz", TRUE, 8, 7);
dp.unpackUUID(mPartImageID, "psuuid");
dp.unpackUUID(mTargetUUID, "pstargetuuid");
mPartData.unpack(dp);
return TRUE;
}
