/** * @file partsyspacket.cpp * @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$ */ #include "linden_common.h" #include "partsyspacket.h" #include "indra_constants.h" // this function is global void gSetInitDataDefaults(LLPartInitData *setMe) { U32 i; //for(i = 0; i < 18; i++) //{ // setMe->k[i] = 0.0f; //} //setMe->kill_p[0] = setMe->kill_p[1] = setMe->kill_p[2] = 0.0f; //setMe->kill_p[3] = -0.2f; // time parameter, die when t= 5.0f //setMe->kill_p[4] = 1.0f; //setMe->kill_p[5] = -0.5f; // or radius == 2 (contracting) //setMe->bounce_p[0] = setMe->bounce_p[1] = // setMe->bounce_p[2] = setMe->bounce_p[3] = 0.0f; //setMe->bounce_p[4] = 1.0f; setMe->bounce_b = 1.0f; // i just changed the meaning of bounce_b // its now the attenuation from revlecting your velocity across the normal // set by bounce_p //setMe->pos_ranges[0] = setMe->pos_ranges[2] = setMe->pos_ranges[4] = -1.0f; //setMe->pos_ranges[1] = setMe->pos_ranges[3] = setMe->pos_ranges[5] = 1.0f; //setMe->vel_ranges[0] = setMe->vel_ranges[2] = setMe->vel_ranges[4] = -1.0f; //setMe->vel_ranges[1] = setMe->vel_ranges[3] = setMe->vel_ranges[5] = 1.0f; for(i = 0; i < 3; i++) { setMe->diffEqAlpha[i] = 0.0f; setMe->diffEqScale[i] = 0.0f; } setMe->scale_range[0] = 1.00f; setMe->scale_range[1] = 5.00f; setMe->scale_range[2] = setMe->scale_range[3] = 0.0f; setMe->alpha_range[0] = setMe->alpha_range[1] = 1.0f; setMe->alpha_range[2] = setMe->alpha_range[3] = 0.0f; setMe->vel_offset[0] = 0.0f; setMe->vel_offset[1] = 0.0f; setMe->vel_offset[2] = 0.0f; // start dropping particles when I'm more then one sim away setMe->mDistBeginFadeout = 256.0f; setMe->mDistEndFadeout = 1.414f * 512.0f; // stop displaying particles when I'm more then two sim diagonals away setMe->mImageUuid = IMG_SHOT; for(i = 0; i < 8; i++) { setMe->mFlags[i] = 0x00; } setMe->createMe = true; setMe->maxParticles = 25; setMe->initialParticles = 25; //These defaults are for an explosion - a short lived set of debris affected by gravity. //Action flags default to PART_SYS_AFFECTED_BY_WIND + PART_SYS_AFFECTED_BY_GRAVITY + PART_SYS_DISTANCE_DEATH setMe->mFlags[PART_SYS_ACTION_BYTE] = PART_SYS_AFFECTED_BY_WIND | PART_SYS_AFFECTED_BY_GRAVITY | PART_SYS_DISTANCE_DEATH; setMe->mFlags[PART_SYS_KILL_BYTE] = PART_SYS_DISTANCE_DEATH + PART_SYS_TIME_DEATH; setMe->killPlaneNormal[0] = 0.0f;setMe->killPlaneNormal[1] = 0.0f;setMe->killPlaneNormal[2] = 1.0f; //Straight up setMe->killPlaneZ = 0.0f; //get local ground z as an approximation if turn on PART_SYS_KILL_PLANE setMe->bouncePlaneNormal[0] = 0.0f;setMe->bouncePlaneNormal[1] = 0.0f;setMe->bouncePlaneNormal[2] = 1.0f; //Straight up setMe->bouncePlaneZ = 0.0f; //get local ground z as an approximation if turn on PART_SYS_BOUNCE setMe->spawnRange = 1.0f; setMe->spawnFrequency = 0.0f; //Create the instant one dies setMe->spawnFreqencyRange = 0.0f; setMe->spawnDirection[0] = 0.0f;setMe->spawnDirection[1] = 0.0f;setMe->spawnDirection[2] = 1.0f; //Straight up setMe->spawnDirectionRange = 1.0f; //global scattering setMe->spawnVelocity = 0.75f; setMe->spawnVelocityRange = 0.25f; //velocity +/- 0.25 setMe->speedLimit = 1.0f; setMe->windWeight = 0.5f; //0.0f means looks like a heavy object (if gravity is on), 1.0f means light and fluffy setMe->currentGravity[0] = 0.0f;setMe->currentGravity[1] = 0.0f;setMe->currentGravity[2] = -9.81f; //This has to be constant to allow for compression setMe->gravityWeight = 0.5f; //0.0f means boyed by air, 1.0f means it's a lead weight setMe->globalLifetime = 0.0f; //Arbitrary, but default is no global die, so doesn't matter setMe->individualLifetime = 5.0f; setMe->individualLifetimeRange = 1.0f; //Particles last 5 secs +/- 1 setMe->alphaDecay = 1.0f; //normal alpha fadeout setMe->scaleDecay = 0.0f; //no scale decay setMe->distanceDeath = 10.0f; //die if hit unit radius setMe->dampMotionFactor = 0.0f; setMe->windDiffusionFactor[0] = 0.0f; setMe->windDiffusionFactor[1] = 0.0f; setMe->windDiffusionFactor[2] = 0.0f; } LLPartSysCompressedPacket::LLPartSysCompressedPacket() { // default constructor for mDefaults called implicitly/automatically here for(int i = 0; i < MAX_PART_SYS_PACKET_SIZE; i++) { mData[i] = '\0'; } mNumBytes = 0; gSetInitDataDefaults(&mDefaults); } LLPartSysCompressedPacket::~LLPartSysCompressedPacket() { // no dynamic data is stored by this class, do nothing. } void LLPartSysCompressedPacket::writeFlagByte(LLPartInitData *in) { mData[0] = mData[1] = mData[2] = '\0'; U32 i; //for(i = 1; i < 18; i++) { // if(in->k[i] != mDefaults.k[i]) // { // mData[0] |= PART_SYS_K_MASK; // break; // } //} if(in->killPlaneZ != mDefaults.killPlaneZ || in->killPlaneNormal[0] != mDefaults.killPlaneNormal[0] || in->killPlaneNormal[1] != mDefaults.killPlaneNormal[1] || in->killPlaneNormal[2] != mDefaults.killPlaneNormal[2] || in->distanceDeath != mDefaults.distanceDeath) { mData[0] |= PART_SYS_KILL_P_MASK; } if(in->bouncePlaneZ != mDefaults.bouncePlaneZ || in->bouncePlaneNormal[0] != mDefaults.bouncePlaneNormal[0] || in->bouncePlaneNormal[1] != mDefaults.bouncePlaneNormal[1] || in->bouncePlaneNormal[2] != mDefaults.bouncePlaneNormal[2]) { mData[0] |= PART_SYS_BOUNCE_P_MASK; } if(in->bounce_b != mDefaults.bounce_b) { mData[0] |= PART_SYS_BOUNCE_B_MASK; } //if(in->pos_ranges[0] != mDefaults.pos_ranges[0] || in->pos_ranges[1] != mDefaults.pos_ranges[1] || // in->pos_ranges[2] != mDefaults.pos_ranges[2] || in->pos_ranges[3] != mDefaults.pos_ranges[3] || // in->pos_ranges[4] != mDefaults.pos_ranges[4] || in->pos_ranges[5] != mDefaults.pos_ranges[5]) //{ // mData[0] |= PART_SYS_POS_RANGES_MASK; //} //if(in->vel_ranges[0] != mDefaults.vel_ranges[0] || in->vel_ranges[1] != mDefaults.vel_ranges[1] || // in->vel_ranges[2] != mDefaults.vel_ranges[2] || in->vel_ranges[3] != mDefaults.vel_ranges[3] || // in->vel_ranges[4] != mDefaults.vel_ranges[4] || in->vel_ranges[5] != mDefaults.vel_ranges[5]) //{ // mData[0] |= PART_SYS_VEL_RANGES_MASK; //} if(in->diffEqAlpha[0] != mDefaults.diffEqAlpha[0] || in->diffEqAlpha[1] != mDefaults.diffEqAlpha[1] || in->diffEqAlpha[2] != mDefaults.diffEqAlpha[2] || in->diffEqScale[0] != mDefaults.diffEqScale[0] || in->diffEqScale[1] != mDefaults.diffEqScale[1] || in->diffEqScale[2] != mDefaults.diffEqScale[2]) { mData[0] |= PART_SYS_ALPHA_SCALE_DIFF_MASK; } if(in->scale_range[0] != mDefaults.scale_range[0] || in->scale_range[1] != mDefaults.scale_range[1] || in->scale_range[2] != mDefaults.scale_range[2] || in->scale_range[3] != mDefaults.scale_range[3]) { mData[0] |= PART_SYS_SCALE_RANGE_MASK; } if(in->alpha_range[0] != mDefaults.alpha_range[0] || in->alpha_range[1] != mDefaults.alpha_range[1] || in->alpha_range[2] != mDefaults.alpha_range[2] || in->alpha_range[3] != mDefaults.alpha_range[3]) { mData[2] |= PART_SYS_BYTE_3_ALPHA_MASK; } if(in->vel_offset[0] != mDefaults.vel_offset[0] || in->vel_offset[1] != mDefaults.vel_offset[1] || in->vel_offset[2] != mDefaults.vel_offset[2]) { mData[0] |= PART_SYS_VEL_OFFSET_MASK; } if(in->mImageUuid != mDefaults.mImageUuid) { mData[0] |= PART_SYS_M_IMAGE_UUID_MASK; } for( i = 0; i < 8; i++) { if(in->mFlags[i]) { mData[1] |= 1<<i; // llprintline("Flag \"%x\" gets byte \"%x\"\n", i<<i, in->mFlags[i]); } } if(in->spawnRange != mDefaults.spawnRange || in->spawnFrequency != mDefaults.spawnFrequency || in->spawnFreqencyRange != mDefaults.spawnFreqencyRange || in->spawnDirection[0] != mDefaults.spawnDirection[0] || in->spawnDirection[1] != mDefaults.spawnDirection[1] || in->spawnDirection[2] != mDefaults.spawnDirection[2] || in->spawnDirectionRange != mDefaults.spawnDirectionRange || in->spawnVelocity != mDefaults.spawnVelocity || in->spawnVelocityRange != mDefaults.spawnVelocityRange) { mData[3] |= PART_SYS_BYTE_SPAWN_MASK; } if(in->windWeight != mDefaults.windWeight || in->currentGravity[0] != mDefaults.currentGravity[0] || in->currentGravity[1] != mDefaults.currentGravity[1] || in->currentGravity[2] != mDefaults.currentGravity[2] || in->gravityWeight != mDefaults.gravityWeight) { mData[3] |= PART_SYS_BYTE_ENVIRONMENT_MASK; } if(in->globalLifetime != mDefaults.globalLifetime || in->individualLifetime != mDefaults.individualLifetime || in->individualLifetimeRange != mDefaults.individualLifetimeRange) { mData[3] |= PART_SYS_BYTE_LIFESPAN_MASK; } if(in->speedLimit != mDefaults.speedLimit || in->alphaDecay != mDefaults.alphaDecay || in->scaleDecay != mDefaults.scaleDecay || in->dampMotionFactor != mDefaults.dampMotionFactor) { mData[3] |= PART_SYS_BYTE_DECAY_DAMP_MASK; } if(in->windDiffusionFactor[0] != mDefaults.windDiffusionFactor[0] || in->windDiffusionFactor[1] != mDefaults.windDiffusionFactor[1] || in->windDiffusionFactor[2] != mDefaults.windDiffusionFactor[2]) { mData[3] |= PART_SYS_BYTE_WIND_DIFF_MASK; } } F32 floatFromTwoBytes(S8 bMant, S8 bExp) { F32 result = bMant; while(bExp > 0) { result *= 2.0f; bExp--; } while(bExp < 0) { result *= 0.5f; bExp++; } return result; } void twoBytesFromFloat(F32 fIn, S8 &bMant, S8 &bExp) { bExp = 0; if(fIn > 127.0f) { fIn = 127.0f; } if(fIn < -127.0f) { fIn = -127.0f; } while(fIn < 64 && fIn > -64 && bExp > -127) { fIn *= 2.0f; bExp--; } while((fIn > 128 || fIn < -128) && bExp < 127) { fIn *= 0.5f; bExp++; } bMant = (S8)fIn; } /* U32 LLPartSysCompressedPacket::writeK(LLPartInitData *in, U32 startByte) { U32 i, kFlag, i_mod_eight; S8 bMant, bExp; kFlag = startByte; startByte += 3; // 3 bytes contain enough room for 18 flag bits mData[kFlag] = 0x00; // llprintline("In the writeK\n"); i_mod_eight = 0; for(i = 0; i < 18; i++) { if(in->k[i] != mDefaults.k[i]) { mData[kFlag] |= 1<<i_mod_eight; twoBytesFromFloat(in->k[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } i_mod_eight++; while(i_mod_eight >= 8) { kFlag++; i_mod_eight -= 8; } } return startByte; }*/ U32 LLPartSysCompressedPacket::writeKill_p(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; twoBytesFromFloat(in->killPlaneNormal[0], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->killPlaneNormal[1], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->killPlaneNormal[2], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->killPlaneZ, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->distanceDeath, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } U32 LLPartSysCompressedPacket::writeBounce_p(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; twoBytesFromFloat(in->bouncePlaneNormal[0], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->bouncePlaneNormal[1], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->bouncePlaneNormal[2], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->bouncePlaneZ, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } U32 LLPartSysCompressedPacket::writeBounce_b(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; twoBytesFromFloat(in->bounce_b, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } //U32 LLPartSysCompressedPacket::writePos_ranges(LLPartInitData *in, U32 startByte) //{ // S8 tmp; // int i; // for(i = 0; i < 6; i++) // { // tmp = (S8) in->pos_ranges[i]; // float to int conversion (keep the sign) // mData[startByte++] = (U8)tmp; // signed to unsigned typecast // } // return startByte; //} //U32 LLPartSysCompressedPacket::writeVel_ranges(LLPartInitData *in, U32 startByte) //{ // S8 tmp; // int i; // for(i = 0; i < 6; i++) // { // tmp = (S8) in->vel_ranges[i]; // float to int conversion (keep the sign) // mData[startByte++] = (U8)tmp; // signed to unsigned typecast // } // return startByte; //} U32 LLPartSysCompressedPacket::writeAlphaScaleDiffEqn_range(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; int i; for(i = 0; i < 3; i++) { twoBytesFromFloat(in->diffEqAlpha[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } for(i = 0; i < 3; i++) { twoBytesFromFloat(in->diffEqScale[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } return startByte; } U32 LLPartSysCompressedPacket::writeScale_range(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; int i; for(i = 0; i < 4; i++) { twoBytesFromFloat(in->scale_range[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } return startByte; } U32 LLPartSysCompressedPacket::writeAlpha_range(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; int i; for(i = 0; i < 4; i++) { twoBytesFromFloat(in->alpha_range[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } return startByte; } U32 LLPartSysCompressedPacket::writeVelocityOffset(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; int i; for(i = 0; i < 3; i++) { twoBytesFromFloat(in->vel_offset[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } return startByte; } U32 LLPartSysCompressedPacket::writeUUID(LLPartInitData *in, U32 startByte) { U8 * bufPtr = mData + startByte; if(in->mImageUuid == IMG_SHOT) { mData[startByte++] = 0x01; return startByte; } if(in->mImageUuid == IMG_SPARK) { mData[startByte++] = 0x02; return startByte; } if(in->mImageUuid == IMG_BIG_EXPLOSION_1) { mData[startByte++] = 0x03; return startByte; } if(in->mImageUuid == IMG_BIG_EXPLOSION_2) { mData[startByte++] = 0x04; return startByte; } if(in->mImageUuid == IMG_SMOKE_POOF) { mData[startByte++] = 0x05; return startByte; } if(in->mImageUuid == IMG_FIRE) { mData[startByte++] = 0x06; return startByte; } if(in->mImageUuid == IMG_EXPLOSION) { mData[startByte++] = 0x07; return startByte; } if(in->mImageUuid == IMG_EXPLOSION_2) { mData[startByte++] = 0x08; return startByte; } if(in->mImageUuid == IMG_EXPLOSION_3) { mData[startByte++] = 0x09; return startByte; } if(in->mImageUuid == IMG_EXPLOSION_4) { mData[startByte++] = 0x0A; return startByte; } mData[startByte++] = 0x00; // flag for "read whole UUID" memcpy(bufPtr, in->mImageUuid.mData, 16); /* Flawfinder: ignore */ return (startByte+16); } U32 LLPartSysCompressedPacket::writeSpawn(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; int i; twoBytesFromFloat(in->spawnRange, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->spawnFrequency, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->spawnFreqencyRange, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; for(i = 0; i < 3; i++) { twoBytesFromFloat(in->spawnDirection[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } twoBytesFromFloat(in->spawnDirectionRange, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->spawnVelocity, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->spawnVelocityRange, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } U32 LLPartSysCompressedPacket::writeEnvironment(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; int i; twoBytesFromFloat(in->windWeight, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; for(i = 0; i < 3; i++) { twoBytesFromFloat(in->currentGravity[i], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; } twoBytesFromFloat(in->gravityWeight, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } U32 LLPartSysCompressedPacket::writeLifespan(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; twoBytesFromFloat(in->globalLifetime, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->individualLifetime, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->individualLifetimeRange, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } U32 LLPartSysCompressedPacket::writeDecayDamp(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; twoBytesFromFloat(in->speedLimit, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->alphaDecay, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->scaleDecay, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->dampMotionFactor, bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } U32 LLPartSysCompressedPacket::writeWindDiffusionFactor(LLPartInitData *in, U32 startByte) { S8 bExp, bMant; twoBytesFromFloat(in->windDiffusionFactor[0], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->windDiffusionFactor[1], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; twoBytesFromFloat(in->windDiffusionFactor[2], bMant, bExp); mData[startByte++] = bMant; mData[startByte++] = bExp; return startByte; } /* U32 LLPartSysCompressedPacket::readK(LLPartInitData *in, U32 startByte) { U32 i, i_mod_eight, kFlag; S8 bMant, bExp; // 1 bytes mantissa and exponent for a float kFlag = startByte; startByte += 3; // 3 bytes has enough room for 18 bits i_mod_eight = 0; for(i = 0; i < 18; i++) { if(mData[kFlag]&(1<<i_mod_eight)) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->k[i] = floatFromTwoBytes(bMant, bExp); // much tighter platform-independent // way to ship floats } i_mod_eight++; if(i_mod_eight >= 8) { i_mod_eight -= 8; kFlag++; } } return startByte; } */ U32 LLPartSysCompressedPacket::readKill_p(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; bMant = mData[startByte++]; bExp = mData[startByte++]; in->killPlaneNormal[0] = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->killPlaneNormal[1] = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->killPlaneNormal[2] = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->killPlaneZ = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->distanceDeath = floatFromTwoBytes(bMant, bExp); return startByte; } U32 LLPartSysCompressedPacket::readBounce_p(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; bMant = mData[startByte++]; bExp = mData[startByte++]; in->bouncePlaneNormal[0] = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->bouncePlaneNormal[1] = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->bouncePlaneNormal[2] = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->bouncePlaneZ = floatFromTwoBytes(bMant, bExp); return startByte; } U32 LLPartSysCompressedPacket::readBounce_b(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; bMant = mData[startByte++]; bExp = mData[startByte++]; in->bounce_b = floatFromTwoBytes(bMant, bExp); return startByte; } //U32 LLPartSysCompressedPacket::readPos_ranges(LLPartInitData *in, U32 startByte) //{ // S8 tmp; // int i; // for(i = 0; i < 6; i++) // { // tmp = (S8)mData[startByte++]; // in->pos_ranges[i] = tmp; // } // return startByte; //} //U32 LLPartSysCompressedPacket::readVel_ranges(LLPartInitData *in, U32 startByte) //{ // S8 tmp; // int i; // for(i = 0; i < 6; i++) // { // tmp = (S8)mData[startByte++]; // in->vel_ranges[i] = tmp; // } // return startByte; //} U32 LLPartSysCompressedPacket::readAlphaScaleDiffEqn_range(LLPartInitData *in, U32 startByte) { int i; S8 bMant, bExp; for(i = 0; i < 3; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->diffEqAlpha[i] = floatFromTwoBytes(bMant, bExp); } for(i = 0; i < 3; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->diffEqScale[i] = floatFromTwoBytes(bMant, bExp); } return startByte; } U32 LLPartSysCompressedPacket::readAlpha_range(LLPartInitData *in, U32 startByte) { int i; S8 bMant, bExp; for(i = 0; i < 4; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->alpha_range[i] = floatFromTwoBytes(bMant, bExp); } return startByte; } U32 LLPartSysCompressedPacket::readScale_range(LLPartInitData *in, U32 startByte) { int i; S8 bMant, bExp; for(i = 0; i < 4; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->scale_range[i] = floatFromTwoBytes(bMant, bExp); } return startByte; } U32 LLPartSysCompressedPacket::readVelocityOffset(LLPartInitData *in, U32 startByte) { int i; S8 bMant, bExp; for(i = 0; i < 3; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->vel_offset[i] = floatFromTwoBytes(bMant, bExp); } return startByte; } U32 LLPartSysCompressedPacket::readUUID(LLPartInitData *in, U32 startByte) { U8 * bufPtr = mData + startByte; if(mData[startByte] == 0x01) { in->mImageUuid = IMG_SHOT; return startByte+1; } if(mData[startByte] == 0x02) { in->mImageUuid = IMG_SPARK; return startByte+1; } if(mData[startByte] == 0x03) { in->mImageUuid = IMG_BIG_EXPLOSION_1; return startByte+1; } if(mData[startByte] == 0x04) { in->mImageUuid = IMG_BIG_EXPLOSION_2; return startByte+1; } if(mData[startByte] == 0x05) { in->mImageUuid = IMG_SMOKE_POOF; return startByte+1; } if(mData[startByte] == 0x06) { in->mImageUuid = IMG_FIRE; return startByte+1; } if(mData[startByte] == 0x07) { in->mImageUuid = IMG_EXPLOSION; return startByte+1; } if(mData[startByte] == 0x08) { in->mImageUuid = IMG_EXPLOSION_2; return startByte+1; } if(mData[startByte] == 0x09) { in->mImageUuid = IMG_EXPLOSION_3; return startByte+1; } if(mData[startByte] == 0x0A) { in->mImageUuid = IMG_EXPLOSION_4; return startByte+1; } startByte++; // cause we actually have to read the UUID now. memcpy(in->mImageUuid.mData, bufPtr, 16); /* Flawfinder: ignore */ return (startByte+16); } U32 LLPartSysCompressedPacket::readSpawn(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; U32 i; bMant = mData[startByte++]; bExp = mData[startByte++]; in->spawnRange = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->spawnFrequency = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->spawnFreqencyRange = floatFromTwoBytes(bMant, bExp); for(i = 0; i < 3; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->spawnDirection[i] = floatFromTwoBytes(bMant, bExp); } bMant = mData[startByte++]; bExp = mData[startByte++]; in->spawnDirectionRange = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->spawnVelocity = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->spawnVelocityRange = floatFromTwoBytes(bMant, bExp); return startByte; } U32 LLPartSysCompressedPacket::readEnvironment(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; U32 i; bMant = mData[startByte++]; bExp = mData[startByte++]; in->windWeight = floatFromTwoBytes(bMant, bExp); for(i = 0; i < 3; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->currentGravity[i] = floatFromTwoBytes(bMant, bExp); } bMant = mData[startByte++]; bExp = mData[startByte++]; in->gravityWeight = floatFromTwoBytes(bMant, bExp); return startByte; } U32 LLPartSysCompressedPacket::readLifespan(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; bMant = mData[startByte++]; bExp = mData[startByte++]; in->globalLifetime = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->individualLifetime = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->individualLifetimeRange = floatFromTwoBytes(bMant, bExp); return startByte; } U32 LLPartSysCompressedPacket::readDecayDamp(LLPartInitData *in, U32 startByte) { S8 bMant, bExp; bMant = mData[startByte++]; bExp = mData[startByte++]; in->speedLimit = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->alphaDecay = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->scaleDecay = floatFromTwoBytes(bMant, bExp); bMant = mData[startByte++]; bExp = mData[startByte++]; in->dampMotionFactor = floatFromTwoBytes(bMant, bExp); return startByte; } U32 LLPartSysCompressedPacket::readWindDiffusionFactor(LLPartInitData *in, U32 startByte) { int i; S8 bMant, bExp; for(i = 0; i < 3; i++) { bMant = mData[startByte++]; bExp = mData[startByte++]; in->windDiffusionFactor[i] = floatFromTwoBytes(bMant, bExp); } return startByte; } bool LLPartSysCompressedPacket::fromLLPartInitData(LLPartInitData *in, U32 &bytesUsed) { writeFlagByte(in); U32 currByte = 4; // llprintline("calling \"fromLLPartInitData\"\n"); //if(mData[0] & PART_SYS_K_MASK) //{ // currByte = writeK(in, 3); // first 3 bytes are reserved for header data //} if(mData[0] & PART_SYS_KILL_P_MASK) { currByte = writeKill_p(in, currByte); } if(mData[0] & PART_SYS_BOUNCE_P_MASK) { currByte = writeBounce_p(in, currByte); } if(mData[0] & PART_SYS_BOUNCE_B_MASK) { currByte = writeBounce_b(in, currByte); } //if(mData[0] & PART_SYS_POS_RANGES_MASK) //{ // currByte = writePos_ranges(in, currByte); //} //if(mData[0] & PART_SYS_VEL_RANGES_MASK) //{ // currByte = writeVel_ranges(in, currByte); //} if(mData[0] & PART_SYS_ALPHA_SCALE_DIFF_MASK) { currByte = writeAlphaScaleDiffEqn_range(in, currByte); } if(mData[0] & PART_SYS_SCALE_RANGE_MASK) { currByte = writeScale_range(in, currByte); } if(mData[0] & PART_SYS_VEL_OFFSET_MASK) { currByte = writeVelocityOffset(in, currByte); } if(mData[0] & PART_SYS_M_IMAGE_UUID_MASK) { currByte = writeUUID(in, currByte); } if(mData[3] & PART_SYS_BYTE_SPAWN_MASK) { currByte = writeSpawn(in, currByte); } if(mData[3] & PART_SYS_BYTE_ENVIRONMENT_MASK) { currByte = writeEnvironment(in, currByte); } if(mData[3] & PART_SYS_BYTE_LIFESPAN_MASK) { currByte = writeLifespan(in, currByte); } if(mData[3] & PART_SYS_BYTE_DECAY_DAMP_MASK) { currByte = writeDecayDamp(in, currByte); } if(mData[3] & PART_SYS_BYTE_WIND_DIFF_MASK) { currByte = writeWindDiffusionFactor(in, currByte); } if(mData[2] & PART_SYS_BYTE_3_ALPHA_MASK) { currByte = writeAlpha_range(in, currByte); } mData[currByte++] = (U8)in->maxParticles; mData[currByte++] = (U8)in->initialParticles; U32 flagFlag = 1; // flag indicating which flag bytes are non-zero // yeah, I know, the name sounds funny for(U32 i = 0; i < 8; i++) { // llprintline("Flag \"%x\" gets byte \"%x\"\n", flagFlag, in->mFlags[i]); if(mData[1] & flagFlag) { mData[currByte++] = in->mFlags[i]; // llprintline("and is valid...\n"); } flagFlag <<= 1; } bytesUsed = mNumBytes = currByte; // llprintline("returning from \"fromLLPartInitData\" with %d bytes\n", bytesUsed); return true; } bool LLPartSysCompressedPacket::toLLPartInitData(LLPartInitData *out, U32 *bytesUsed) { U32 currByte = 4; gSetInitDataDefaults(out); if(mData[0] & PART_SYS_KILL_P_MASK) { currByte = readKill_p(out, currByte); } if(mData[0] & PART_SYS_BOUNCE_P_MASK) { currByte = readBounce_p(out, currByte); } if(mData[0] & PART_SYS_BOUNCE_B_MASK) { currByte = readBounce_b(out, currByte); } if(mData[0] & PART_SYS_ALPHA_SCALE_DIFF_MASK) { currByte = readAlphaScaleDiffEqn_range(out, currByte); } if(mData[0] & PART_SYS_SCALE_RANGE_MASK) { currByte = readScale_range(out, currByte); } if(mData[0] & PART_SYS_VEL_OFFSET_MASK) { currByte = readVelocityOffset(out, currByte); } if(mData[0] & PART_SYS_M_IMAGE_UUID_MASK) { currByte = readUUID(out, currByte); } if(mData[3] & PART_SYS_BYTE_SPAWN_MASK) { currByte = readSpawn(out, currByte); } if(mData[3] & PART_SYS_BYTE_ENVIRONMENT_MASK) { currByte = readEnvironment(out, currByte); } if(mData[3] & PART_SYS_BYTE_LIFESPAN_MASK) { currByte = readLifespan(out, currByte); } if(mData[3] & PART_SYS_BYTE_DECAY_DAMP_MASK) { currByte = readDecayDamp(out, currByte); } if(mData[3] & PART_SYS_BYTE_WIND_DIFF_MASK) { currByte = readWindDiffusionFactor(out, currByte); } if(mData[2] & PART_SYS_BYTE_3_ALPHA_MASK) { currByte = readAlpha_range(out, currByte); } out->maxParticles = mData[currByte++]; out->initialParticles = mData[currByte++]; U32 flagFlag = 1; // flag indicating which flag bytes are non-zero // yeah, I know, the name sounds funny for(U32 i = 0; i < 8; i++) { flagFlag = 1<<i; if((mData[1] & flagFlag)) { out->mFlags[i] = mData[currByte++]; } } *bytesUsed = currByte; return true; } bool LLPartSysCompressedPacket::fromUnsignedBytes(U8 *in, U32 bytesUsed) { if ((in != NULL) && (bytesUsed <= sizeof(mData))) { memcpy(mData, in, bytesUsed); /* Flawfinder: ignore */ mNumBytes = bytesUsed; return true; } else { LL_ERRS() << "NULL input data or number of bytes exceed mData size" << LL_ENDL; return false; } } U32 LLPartSysCompressedPacket::bufferSize() { return mNumBytes; } bool LLPartSysCompressedPacket::toUnsignedBytes(U8 *out) { memcpy(out, mData, mNumBytes); /* Flawfinder: ignore */ return true; } U8 * LLPartSysCompressedPacket::getBytePtr() { return mData; }