Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mats.

Browse Source
This commit is contained in:
Shyotl
2013-11-02 01:20:05 -05:00
parent 5e8c7264da
commit af8f8bb040
121 changed files with 8416 additions and 3292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
indra/llmessage/llpartdata.cpp
View File

@@ -37,53 +37,46 @@
const S32 PS_PART_DATA_BLOCK_SIZE = 4 + 2 + 4 + 4 + 2 + 2; // 18
const S32 PS_DATA_BLOCK_SIZE = 68 + PS_PART_DATA_BLOCK_SIZE; // 68 + 18 = 86
const S32 PS_PART_DATA_GLOW_SIZE = 2;
const S32 PS_PART_DATA_BLEND_SIZE = 2;
const S32 PS_LEGACY_PART_DATA_BLOCK_SIZE = 4 + 2 + 4 + 4 + 2 + 2; //18
const S32 PS_SYS_DATA_BLOCK_SIZE = 68;
const S32 PS_MAX_DATA_BLOCK_SIZE = PS_SYS_DATA_BLOCK_SIZE+
PS_LEGACY_PART_DATA_BLOCK_SIZE +
PS_PART_DATA_BLEND_SIZE +
PS_PART_DATA_GLOW_SIZE+
8; //two S32 size fields
const S32 PS_LEGACY_DATA_BLOCK_SIZE = PS_SYS_DATA_BLOCK_SIZE + PS_LEGACY_PART_DATA_BLOCK_SIZE;
const U32 PART_DATA_MASK = LLPartData::LL_PART_DATA_GLOW | LLPartData::LL_PART_DATA_BLEND;
const F32 MAX_PART_SCALE = 4.f;
BOOL LLPartData::pack(LLDataPacker &dp)
bool LLPartData::hasGlow() const
{
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;
return mStartGlow > 0.f || mEndGlow > 0.f;
}
LLSD LLPartData::asLLSD() const
bool LLPartData::hasBlendFunc() const
{
LLSD sd = LLSD();
sd["pdflags"] = ll_sd_from_U32(mFlags);
sd["pdmaxage"] = mMaxAge;
sd["pdstartcolor"] = ll_sd_from_color4(mStartColor);
sd["pdendcolor"] = ll_sd_from_color4(mEndColor);
sd["pdstartscale"] = ll_sd_from_vector2(mStartScale);
sd["pdendscale"] = ll_sd_from_vector2(mEndScale);
return sd;
return mBlendFuncSource != LLPartData::LL_PART_BF_SOURCE_ALPHA || mBlendFuncDest != LLPartData::LL_PART_BF_ONE_MINUS_SOURCE_ALPHA;
}
bool LLPartData::fromLLSD(LLSD& sd)
S32 LLPartData::getSize() const
{
mFlags = ll_U32_from_sd(sd["pdflags"]);
mMaxAge = (F32)sd["pdmaxage"].asReal();
mStartColor = ll_color4_from_sd(sd["pdstartcolor"]);
mEndColor = ll_color4_from_sd(sd["pdendcolor"]);
mStartScale = ll_vector2_from_sd(sd["pdstartscale"]);
mEndScale = ll_vector2_from_sd(sd["pdendscale"]);
return true;
S32 size = PS_LEGACY_PART_DATA_BLOCK_SIZE;
if (hasGlow()) size += PS_PART_DATA_GLOW_SIZE;
if (hasBlendFunc()) size += PS_PART_DATA_BLEND_SIZE;
return size;
}
BOOL LLPartData::unpack(LLDataPacker &dp)
BOOL LLPartData::unpackLegacy(LLDataPacker &dp)
{
LLColor4U coloru;
@@ -98,9 +91,70 @@ BOOL LLPartData::unpack(LLDataPacker &dp)
dp.unpackFixed(mStartScale.mV[1], "pdstartscaley", FALSE, 3, 5);
dp.unpackFixed(mEndScale.mV[0], "pdendscalex", FALSE, 3, 5);
dp.unpackFixed(mEndScale.mV[1], "pdendscaley", FALSE, 3, 5);
mStartGlow = 0.f;
mEndGlow = 0.f;
mBlendFuncSource = LLPartData::LL_PART_BF_SOURCE_ALPHA;
mBlendFuncDest = LLPartData::LL_PART_BF_ONE_MINUS_SOURCE_ALPHA;
return TRUE;
}
BOOL LLPartData::unpack(LLDataPacker &dp)
{
S32 size = 0;
dp.unpackS32(size, "partsize");
unpackLegacy(dp);
size -= PS_LEGACY_PART_DATA_BLOCK_SIZE;
if (mFlags & LL_PART_DATA_GLOW)
{
if (size < PS_PART_DATA_GLOW_SIZE) return FALSE;
U8 tmp_glow = 0;
dp.unpackU8(tmp_glow,"pdstartglow");
mStartGlow = tmp_glow / 255.f;
dp.unpackU8(tmp_glow,"pdendglow");
mEndGlow = tmp_glow / 255.f;
size -= PS_PART_DATA_GLOW_SIZE;
}
else
{
mStartGlow = 0.f;
mEndGlow = 0.f;
}
if (mFlags & LL_PART_DATA_BLEND)
{
if (size < PS_PART_DATA_BLEND_SIZE) return FALSE;
dp.unpackU8(mBlendFuncSource,"pdblendsource");
dp.unpackU8(mBlendFuncDest,"pdblenddest");
size -= PS_PART_DATA_BLEND_SIZE;
}
else
{
mBlendFuncSource = LLPartData::LL_PART_BF_SOURCE_ALPHA;
mBlendFuncDest = LLPartData::LL_PART_BF_ONE_MINUS_SOURCE_ALPHA;
}
if (size > 0)
{ //leftover bytes, unrecognized parameters
U8 feh = 0;
while (size > 0)
{ //read remaining bytes in block
dp.unpackU8(feh, "whippang");
size--;
}
//this particle system won't display properly, better to not show anything
return FALSE;
}
return TRUE;
}
void LLPartData::setFlags(const U32 flags)
{
@@ -148,6 +202,18 @@ void LLPartData::setEndAlpha(const F32 alpha)
mEndColor.mV[3] = alpha;
}
// static
bool LLPartData::validBlendFunc(S32 func)
{
if (func >= 0
&& func < LL_PART_BF_COUNT
&& func != UNSUPPORTED_DEST_ALPHA
&& func != UNSUPPORTED_ONE_MINUS_DEST_ALPHA)
{
return true;
}
return false;
}
LLPartSysData::LLPartSysData()
{
@@ -160,6 +226,10 @@ LLPartSysData::LLPartSysData()
mPartData.mStartScale = LLVector2(1.f, 1.f);
mPartData.mEndScale = LLVector2(1.f, 1.f);
mPartData.mMaxAge = 10.0;
mPartData.mBlendFuncSource = LLPartData::LL_PART_BF_SOURCE_ALPHA;
mPartData.mBlendFuncDest = LLPartData::LL_PART_BF_ONE_MINUS_SOURCE_ALPHA;
mPartData.mStartGlow = 0.f;
mPartData.mEndGlow = 0.f;
mMaxAge = 0.0;
mStartAge = 0.0;
@@ -175,38 +245,7 @@ LLPartSysData::LLPartSysData()
mNumParticles = 0;
}
BOOL LLPartSysData::pack(LLDataPacker &dp)
{
dp.packU32(mCRC, "pscrc");
dp.packU32(mFlags, "psflags");
dp.packU8(mPattern, "pspattern");
dp.packFixed(mMaxAge, "psmaxage", FALSE, 8, 8);
dp.packFixed(mStartAge, "psstartage", FALSE, 8, 8);
dp.packFixed(mInnerAngle, "psinnerangle", FALSE, 3, 5);
dp.packFixed(mOuterAngle, "psouterangle", FALSE, 3, 5);
dp.packFixed(mBurstRate, "psburstrate", FALSE, 8, 8);
dp.packFixed(mBurstRadius, "psburstradius", FALSE, 8, 8);
dp.packFixed(mBurstSpeedMin, "psburstspeedmin", FALSE, 8, 8);
dp.packFixed(mBurstSpeedMax, "psburstspeedmax", FALSE, 8, 8);
dp.packU8(mBurstPartCount, "psburstpartcount");
dp.packFixed(mAngularVelocity.mV[0], "psangvelx", TRUE, 8, 7);
dp.packFixed(mAngularVelocity.mV[1], "psangvely", TRUE, 8, 7);
dp.packFixed(mAngularVelocity.mV[2], "psangvelz", TRUE, 8, 7);
dp.packFixed(mPartAccel.mV[0], "psaccelx", TRUE, 8, 7);
dp.packFixed(mPartAccel.mV[1], "psaccely", TRUE, 8, 7);
dp.packFixed(mPartAccel.mV[2], "psaccelz", TRUE, 8, 7);
dp.packUUID(mPartImageID, "psuuid");
dp.packUUID(mTargetUUID, "pstargetuuid");
mPartData.pack(dp);
return TRUE;
}
BOOL LLPartSysData::unpack(LLDataPacker &dp)
BOOL LLPartSysData::unpackSystem(LLDataPacker &dp)
{
dp.unpackU32(mCRC, "pscrc");
dp.unpackU32(mFlags, "psflags");
@@ -232,20 +271,58 @@ BOOL LLPartSysData::unpack(LLDataPacker &dp)
dp.unpackUUID(mPartImageID, "psuuid");
dp.unpackUUID(mTargetUUID, "pstargetuuid");
mPartData.unpack(dp);
return TRUE;
}
BOOL LLPartSysData::unpackLegacy(LLDataPacker &dp)
{
unpackSystem(dp);
mPartData.unpackLegacy(dp);
return TRUE;
}
BOOL LLPartSysData::unpack(LLDataPacker &dp)
{
// syssize is currently unused. Adding now when modifying the 'version to make extensible in the future
S32 size = 0;
dp.unpackS32(size, "syssize");
if (size != PS_SYS_DATA_BLOCK_SIZE)
{ //unexpected size, this viewer doesn't know how to parse this particle system
//skip to LLPartData block
U8 feh = 0;
for (U32 i = 0; i < size; ++i)
{
dp.unpackU8(feh, "whippang");
}
dp.unpackS32(size, "partsize");
//skip LLPartData block
for (U32 i = 0; i < size; ++i)
{
dp.unpackU8(feh, "whippang");
}
return FALSE;
}
unpackSystem(dp);
return mPartData.unpack(dp);
}
std::ostream& operator<<(std::ostream& s, const LLPartSysData &data)
{
s << "Flags: " << std::hex << data.mFlags << std::dec;
s << " Pattern: " << std::hex << (U32) data.mPattern << std::dec << "\n";
s << "Flags: " << std::hex << data.mFlags;
s << " Pattern: " << std::hex << (U32) data.mPattern << "\n";
s << "Age: [" << data.mStartAge << ", " << data.mMaxAge << "]\n";
s << "Angle: [" << data.mInnerAngle << ", " << data.mOuterAngle << "]\n";
s << "Burst Rate: " << data.mBurstRate << "\n";
s << "Burst Radius: " << data.mBurstRadius << "\n";
s << "Burst Speed: [" << data.mBurstSpeedMin << ", " << data.mBurstSpeedMax << "]\n";
s << "Burst Part Count: " << std::hex << (U32) data.mBurstPartCount << std::dec << "\n";
s << "Burst Part Count: " << std::hex << (U32) data.mBurstPartCount << "\n";
s << "Angular Velocity: " << data.mAngularVelocity << "\n";
s << "Accel: " << data.mPartAccel;
return s;
@@ -253,7 +330,7 @@ std::ostream& operator<<(std::ostream& s, const LLPartSysData &data)
BOOL LLPartSysData::isNullPS(const S32 block_num)
{
U8 ps_data_block[PS_DATA_BLOCK_SIZE];
U8 ps_data_block[PS_MAX_DATA_BLOCK_SIZE];
U32 crc;
S32 size;
@@ -264,14 +341,28 @@ BOOL LLPartSysData::isNullPS(const S32 block_num)
{
return TRUE;
}
else if (size != PS_DATA_BLOCK_SIZE)
if (size > PS_MAX_DATA_BLOCK_SIZE)
{
llwarns << "PSBlock is wrong size for particle system data - got " << size << ", expecting " << PS_DATA_BLOCK_SIZE << llendl;
//size is too big, newer particle version unsupported
return TRUE;
}
gMessageSystem->getBinaryData("ObjectData", "PSBlock", ps_data_block, PS_DATA_BLOCK_SIZE, block_num, PS_DATA_BLOCK_SIZE);
LLDataPackerBinaryBuffer dp(ps_data_block, PS_DATA_BLOCK_SIZE);
gMessageSystem->getBinaryData("ObjectData", "PSBlock", ps_data_block, size, block_num, PS_MAX_DATA_BLOCK_SIZE);
LLDataPackerBinaryBuffer dp(ps_data_block, size);
if (size > PS_LEGACY_DATA_BLOCK_SIZE)
{
// non legacy systems pack a size before the CRC
S32 tmp = 0;
dp.unpackS32(tmp, "syssize");
if (tmp > PS_SYS_DATA_BLOCK_SIZE)
{ //unknown system data block size, don't know how to parse it, treat as NULL
return TRUE;
}
}
dp.unpackU32(crc, "crc");
if (crc == 0)
@@ -281,50 +372,37 @@ BOOL LLPartSysData::isNullPS(const S32 block_num)
return FALSE;
}
//static
BOOL LLPartSysData::packNull()
{
U8 ps_data_block[PS_DATA_BLOCK_SIZE];
gMessageSystem->addBinaryData("PSBlock", ps_data_block, 0);
return TRUE;
}
BOOL LLPartSysData::packBlock()
{
U8 ps_data_block[PS_DATA_BLOCK_SIZE];
LLDataPackerBinaryBuffer dp(ps_data_block, PS_DATA_BLOCK_SIZE);
pack(dp);
// Add to message
gMessageSystem->addBinaryData("PSBlock", ps_data_block, PS_DATA_BLOCK_SIZE);
return TRUE;
}
BOOL LLPartSysData::unpackBlock(const S32 block_num)
{
U8 ps_data_block[PS_DATA_BLOCK_SIZE];
U8 ps_data_block[PS_MAX_DATA_BLOCK_SIZE];
// Check size of block
S32 size = gMessageSystem->getSize("ObjectData", block_num, "PSBlock");
if (size != PS_DATA_BLOCK_SIZE)
if (size > PS_MAX_DATA_BLOCK_SIZE)
{
llwarns << "PSBlock is wrong size for particle system data - got " << size << ", expecting " << PS_DATA_BLOCK_SIZE << llendl;
// Larger packets are newer and unsupported
return FALSE;
}
// Get from message
gMessageSystem->getBinaryData("ObjectData", "PSBlock", ps_data_block, PS_DATA_BLOCK_SIZE, block_num, PS_DATA_BLOCK_SIZE);
gMessageSystem->getBinaryData("ObjectData", "PSBlock", ps_data_block, size, block_num, PS_MAX_DATA_BLOCK_SIZE);
LLDataPackerBinaryBuffer dp(ps_data_block, PS_DATA_BLOCK_SIZE);
unpack(dp);
LLDataPackerBinaryBuffer dp(ps_data_block, size);
return TRUE;
if (size == PS_LEGACY_DATA_BLOCK_SIZE)
{
return unpackLegacy(dp);
}
else
{
return unpack(dp);
}
}
bool LLPartSysData::isLegacyCompatible() const
{
return !mPartData.hasGlow() && !mPartData.hasBlendFunc();
}
void LLPartSysData::clampSourceParticleRate()

61
indra/llmessage/llpartdata.h
View File

@@ -70,7 +70,12 @@ enum LLPSScriptFlags
LLPS_SRC_TARGET_UUID,
LLPS_SRC_OMEGA,
LLPS_SRC_ANGLE_BEGIN,
LLPS_SRC_ANGLE_END
LLPS_SRC_ANGLE_END,
LLPS_PART_BLEND_FUNC_SOURCE,
LLPS_PART_BLEND_FUNC_DEST,
LLPS_PART_START_GLOW,
LLPS_PART_END_GLOW
};
@@ -83,11 +88,13 @@ public:
mParameter(0.f)
{
}
BOOL unpackLegacy(LLDataPacker &dp);
BOOL unpack(LLDataPacker &dp);
BOOL pack(LLDataPacker &dp);
LLSD asLLSD() const;
operator LLSD() const {return asLLSD(); }
bool fromLLSD(LLSD& sd);
bool hasGlow() const;
bool hasBlendFunc() const;
// Masks for the different particle flags
enum
@@ -102,17 +109,39 @@ public:
LL_PART_TARGET_LINEAR_MASK = 0x80, // Particle uses a direct linear interpolation
LL_PART_EMISSIVE_MASK = 0x100, // Particle is "emissive", instead of being lit
LL_PART_BEAM_MASK = 0x200, // Particle is a "beam" connecting source and target
LL_PART_RIBBON_MASK = 0x400, // Particles are joined together into one continuous triangle strip
// Not implemented yet!
//LL_PART_RANDOM_ACCEL_MASK = 0x100, // Particles have random acceleration
//LL_PART_RANDOM_VEL_MASK = 0x200, // Particles have random velocity shifts"
//LL_PART_TRAIL_MASK = 0x400, // Particles have historical "trails"
//sYSTEM SET FLAGS
LL_PART_DATA_GLOW = 0x10000,
LL_PART_DATA_BLEND = 0x20000,
// Viewer side use only!
LL_PART_HUD = 0x40000000,
LL_PART_DEAD_MASK = 0x80000000,
};
enum
{
LL_PART_BF_ONE = 0,
LL_PART_BF_ZERO = 1,
LL_PART_BF_DEST_COLOR = 2,
LL_PART_BF_SOURCE_COLOR = 3,
LL_PART_BF_ONE_MINUS_DEST_COLOR = 4,
LL_PART_BF_ONE_MINUS_SOURCE_COLOR = 5,
UNSUPPORTED_DEST_ALPHA = 6,
LL_PART_BF_SOURCE_ALPHA = 7,
UNSUPPORTED_ONE_MINUS_DEST_ALPHA = 8,
LL_PART_BF_ONE_MINUS_SOURCE_ALPHA = 9,
LL_PART_BF_COUNT = 10
};
static bool validBlendFunc(S32 func);
void setFlags(const U32 flags);
void setMaxAge(const F32 max_age);
void setStartScale(const F32 xs, F32 ys);
@@ -126,6 +155,9 @@ public:
friend class LLPartSysData;
friend class LLViewerPartSourceScript;
private:
S32 getSize() const;
// These are public because I'm really lazy...
public:
U32 mFlags; // Particle state/interpolators in effect
@@ -137,6 +169,12 @@ public:
LLVector3 mPosOffset; // Offset from source if using FOLLOW_SOURCE
F32 mParameter; // A single floating point parameter
F32 mStartGlow;
F32 mEndGlow;
U8 mBlendFuncSource;
U8 mBlendFuncDest;
};
@@ -146,15 +184,13 @@ public:
LLPartSysData();
BOOL unpack(LLDataPacker &dp);
BOOL pack(LLDataPacker &dp);
BOOL unpackLegacy(LLDataPacker &dp);
BOOL unpackBlock(const S32 block_num);
BOOL packBlock();
static BOOL packNull();
static BOOL isNullPS(const S32 block_num); // Returns FALSE if this is a "NULL" particle system (i.e. no system)
bool isLegacyCompatible() const;
// Different masks for effects on the source
enum
{
@@ -187,7 +223,12 @@ public:
void clampSourceParticleRate();
friend std::ostream& operator<<(std::ostream& s, const LLPartSysData &data); // Stream a
S32 getdataBlockSize() const;
private:
BOOL unpackSystem(LLDataPacker &dp);
public:
// Public because I'm lazy....