plServerGuid plServerGuid::FromString(const plString& str) {
plServerGuid guid;
for (size_t i=0; i<8; i++) {
char x = str[(2*i) ];
char y = str[(2*i)+1];
if (x >= '0' && x <= '9')
guid[i] = x - '0';
else if (x >= 'A' && x <= 'F')
guid[i] = (x - 'A') + 10;
else if (x >= 'a' && x <= 'f')
guid[i] = (x - 'a') + 10;
else
throw hsBadParamException(__FILE__, __LINE__, "Bad hex character");
guid[i] <<= 4;
if (y >= '0' && y <= '9')
guid[i] += y - '0';
else if (y >= 'A' && y <= 'F')
guid[i] += (y - 'A') + 10;
else if (y >= 'a' && y <= 'f')
guid[i] += (y - 'a') + 10;
else
throw hsBadParamException(__FILE__, __LINE__, "Bad hex character");
}
return guid;
}
void plVaultStore::ImportFile(const char* filename) {
hsStream* S;
if (plEncryptedStream::IsFileEncrypted(filename)) {
S = new plEncryptedStream();
((plEncryptedStream*)S)->open(filename, fmRead, plEncryptedStream::kEncAuto);
} else {
S = new hsFileStream();
((hsFileStream*)S)->open(filename, fmRead);
}
if (S->readByte() != 1) {
delete S;
throw hsBadParamException(__FILE__, __LINE__, "Incorrect Vault File Version");
}
hsBitVector fileFields;
fileFields.read(S);
if (fileFields[0]) {
if (S->readByte() != 3) {
delete S;
throw hsBadParamException(__FILE__, __LINE__, "Incorrect Vault Version");
}
hsBitVector vaultFields;
vaultFields.read(S);
if (vaultFields[0]) {
fLastNodeID = S->readInt();
}
if (vaultFields[2]) {
size_t numNodes = S->readInt();
for (size_t i=0; i<numNodes; i++) {
plVaultNode node;
node.read(S);
fNodes[node.getNodeID()] = node;
}
if (numNodes > 0)
fFirstNodeID = fNodes.begin()->first;
}
if (vaultFields[1]) {
size_t numRefs = S->readInt();
for (size_t i=0; i<numRefs; i++) {
plVaultNodeRef ref;
ref.read(S);
fNodeRefs.push_back(ref);
}
}
}
delete S;
}
pfSizedStream::pfSizedStream(hsStream* S, uint32_t len)
: fBase(S), fLength(len) {
if (S != NULL) {
ver = S->getVer();
fBegin = S->pos();
if (S->size() - fBegin < len) {
throw hsBadParamException(__FILE__, __LINE__, "Stream too small");
}
} else {
throw hsBadParamException(__FILE__, __LINE__, "Null Stream");
}
}
void plStateDataRecord::read(hsStream* S, plResManager* mgr) {
fFlags = S->readShort();
if (S->readByte() != kIOVersion || fDescriptor == NULL)
throw hsBadParamException(__FILE__, __LINE__);
for (size_t i=0; i<fDescriptor->getNumVars(); i++)
fAllVars[i]->SetFromDefault();
size_t num = plSDL::VariableLengthRead(S, fDescriptor->getNumVars());
bool all = (num == fVarsList.getSize());
for (size_t i=0; i<num; i++) {
size_t idx;
if (!all)
idx = plSDL::VariableLengthRead(S, fDescriptor->getNumVars());
else
idx = i;
fVarsList[idx]->read(S, mgr);
fVarsList[idx]->setDirty();
}
num = plSDL::VariableLengthRead(S, fDescriptor->getNumVars());
all = (num == fSDVarsList.getSize());
for (size_t i=0; i<num; i++) {
size_t idx;
if (!all)
idx = plSDL::VariableLengthRead(S, fDescriptor->getNumVars());
else
idx = i;
fSDVarsList[idx]->read(S, mgr);
fSDVarsList[idx]->setDirty();
}
}
void plPythonParameter::read(hsStream* S, plResManager* mgr) {
fID = S->readInt();
fValueType = PlasmaToMapped(S->readInt(), S->getVer());
if (fValueType > kNone || fValueType == 0)
throw hsBadParamException(__FILE__, __LINE__);
int size = 0;
switch (fValueType) {
case kInt:
fIntValue = S->readInt();
return;
case kBoolean:
fBoolValue = (S->readInt() != 0);
return;
case kFloat:
fFloatValue = S->readFloat();
return;
case kString:
case kAnimationName:
case kGlobalSDLVar:
case kSubtitle:
size = S->readInt();
if (size == 0) {
fStrValue = "";
return;
}
fStrValue = S->readStr(size);
return;
case kNone:
return;
default:
fObjKey = mgr->readKey(S);
return;
}
}
void plSimpleParticleGenerator::write(hsStream* S, plResManager* mgr) {
S->writeFloat(fGenLife);
S->writeFloat(fPartLifeMin);
S->writeFloat(fPartLifeMax);
S->writeFloat(fParticlesPerSecond);
if (fInitPos.size() != fInitPitch.size() || fInitPos.size() != fInitYaw.size()) {
throw hsBadParamException(__FILE__, __LINE__,
"Init Position, Pitch and Yaw array sizes must match");
}
uint32_t count = static_cast<uint32_t>(fInitPos.size());
S->writeInt(count);
for (uint32_t i = 0; i < count; ++i) {
fInitPos[i].write(S);
S->writeFloat(fInitPitch[i]);
S->writeFloat(fInitYaw[i]);
}
S->writeFloat(fAngleRange);
S->writeFloat(fVelMin);
S->writeFloat(fVelMax);
S->writeFloat(fXSize);
S->writeFloat(fYSize);
S->writeFloat(fScaleMin);
S->writeFloat(fScaleMax);
S->writeFloat(fPartMassRange);
S->writeFloat(fPartRadsPerSecRange);
}
void plGenericPhysical::write(hsStream* S, plResManager* mgr) {
plSynchedObject::write(S, mgr);
PhysType wtype;
if (S->getVer().isUniversal()) {
wtype = fInternalType;
S->writeInt(wtype);
} else if (S->getVer().isNewPlasma()) {
wtype = kPhysODE;
} else if (S->getVer().isLive()) {
wtype = kPhysX;
} else {
wtype = kPhysHavok;
}
switch (wtype) {
case kPhysODE:
IWriteODEPhysical(S, mgr);
break;
case kPhysX:
IWritePXPhysical(S, mgr);
break;
case kPhysHavok:
IWriteHKPhysical(S, mgr);
break;
default:
throw hsBadParamException(__FILE__, __LINE__, "Physics type");
}
}
/* plDDPixelFormat */
void plDDSurface::plDDPixelFormat::read(hsStream* S) {
if (S->readInt() != DDPF_SIZE)
throw hsBadParamException(__FILE__, __LINE__, "Invalid DDPIXELFORMAT size");
fFlags = S->readInt();
fFourCC = S->readInt();
fBitDepth = S->readInt();
fRBitMask = S->readInt();
fGBitMask = S->readInt();
fBBitMask = S->readInt();
fAlphaBitMask = S->readInt();
if (((fFlags & DDPF_FOURCC) != 0) && (fFourCC != FOURCC_DXT1
&& fFourCC != FOURCC_DXT3 && fFourCC != FOURCC_DXT5))
throw hsBadParamException(__FILE__, __LINE__, "Unsupported DXT compression type");
}
void plGenericPhysical::read(hsStream* S, plResManager* mgr) {
plSynchedObject::read(S, mgr);
if (S->getVer().isUniversal())
fInternalType = (PhysType)S->readInt();
else if (S->getVer().isNewPlasma())
fInternalType = kPhysODE;
else if (S->getVer().isLive())
fInternalType = kPhysX;
else
fInternalType = kPhysHavok;
switch (fInternalType) {
case kPhysODE:
IReadODEPhysical(S, mgr);
break;
case kPhysX:
IReadPXPhysical(S, mgr);
break;
case kPhysHavok:
IReadHKPhysical(S, mgr);
break;
default:
throw hsBadParamException(__FILE__, __LINE__, "Physics type");
}
}
void plBitmap::setConfig(ColorFormat format) {
switch (format) {
case kRGB8888:
fPixelSize = 32;
fSpace = kDirectSpace;
fFlags = kAlphaChannelFlag;
break;
case kRGB4444:
fPixelSize = 16;
fSpace = kDirectSpace;
fFlags = kAlphaChannelFlag;
break;
case kRGB1555:
fPixelSize = 16;
fSpace = kDirectSpace;
fFlags = kAlphaBitFlag;
break;
case kInten8:
fPixelSize = 8;
fSpace = kGraySpace;
fFlags = 0;
break;
case kAInten88:
fPixelSize = 16;
fSpace = kGraySpace;
fFlags = kAlphaChannelFlag;
break;
default:
throw hsBadParamException(__FILE__, __LINE__, "Invalid pixel configuration");
}
}
long pnRC4Socket::peek(void* buf, size_t size)
{
if (!fEncrypted)
return pnSocket::peek(buf, size);
throw hsBadParamException(__FILE__, __LINE__, "Cannot peek on an encrypted socket");
}
void plOneTimeParticleGenerator::IPrcWrite(pfPrcHelper* prc) {
prc->startTag("GeneratorParams");
prc->writeParam("XSize", fXSize);
prc->writeParam("YSize", fYSize);
prc->writeParam("ScaleMin", fScaleMin);
prc->writeParam("ScaleMax", fScaleMax);
prc->writeParam("RadsPerSecond", fPartRadsPerSecRange);
prc->endTag(true);
if (fPosition.size() != fDirection.size()) {
throw hsBadParamException(__FILE__, __LINE__,
"Position and Direction array sizes must match");
}
prc->writeSimpleTag("ParticleSources");
for (size_t i = 0; i < fPosition.size(); ++i) {
prc->writeSimpleTag("Source");
prc->writeSimpleTag("Position");
fPosition[i].prcWrite(prc);
prc->closeTag();
prc->writeSimpleTag("Direction");
fDirection[i].prcWrite(prc);
prc->closeTag();
prc->closeTag(); // Source
}
prc->closeTag();
}
void plMD5Hash::fromHex(const char* hex) {
HashConvert hc;
if (strlen(hex) != 32)
throw hsBadParamException(__FILE__, __LINE__, "Invalid hex string");
for (size_t i=0; i<16; i++) {
int ch1 = charToHex(hex[(2*i) ]);
int ch2 = charToHex(hex[(2*i) + 1]);
if (ch1 == -1 || ch2 == -1)
throw hsBadParamException(__FILE__, __LINE__, "Invalid hex string");
hc.hash8[i] = ((ch1 << 4) & 0xF0) | (ch2 & 0x0F);
}
fHash[0] = LESWAP32(hc.hash32[0]);
fHash[1] = LESWAP32(hc.hash32[1]);
fHash[2] = LESWAP32(hc.hash32[2]);
fHash[3] = LESWAP32(hc.hash32[3]);
}
void plLeafController::IReadUruController(hsStream* S) {
switch (ClassIndex()) {
case kEaseController:
if (S->readInt() != 0) {
AllocKeys(S->readInt(), hsKeyFrame::kScalarKeyFrame);
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->read(S, fType);
} else {
AllocKeys(0, 0);
}
break;
case kMatrix33Controller:
AllocKeys(S->readInt(), hsKeyFrame::kMatrix33KeyFrame);
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->read(S, fType);
break;
case kMatrix44Controller:
AllocKeys(S->readInt(), hsKeyFrame::kMatrix44KeyFrame);
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->read(S, fType);
break;
case kPoint3Controller:
if (S->readInt() != 0) {
AllocKeys(S->readInt(), hsKeyFrame::kPoint3KeyFrame);
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->read(S, fType);
} else {
AllocKeys(0, 0);
}
break;
case kQuatController:
AllocKeys(S->readInt(), hsKeyFrame::kQuatKeyFrame);
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->read(S, fType);
break;
case kScalarController:
if (S->readInt() != 0) {
AllocKeys(S->readInt(), hsKeyFrame::kScalarKeyFrame);
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->read(S, fType);
} else {
AllocKeys(0, 0);
}
break;
case kScaleValueController:
AllocKeys(S->readInt(), hsKeyFrame::kScaleKeyFrame);
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->read(S, fType);
break;
default:
plString err = plString::Format("Unexpected class type [%04X]", ClassIndex());
throw hsBadParamException(__FILE__, __LINE__, err);
}
if (fKeys.getSize() > 0)
fType = fKeys[0]->getType();
}
void plLeafController::IWriteUruController(hsStream* S) {
switch (ClassIndex()) {
case kEaseController:
if (fKeys.getSize() == 0) {
S->writeInt(0);
} else {
S->writeInt(1);
S->writeInt(fKeys.getSize());
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->write(S);
}
break;
case kMatrix33Controller:
S->writeInt(fKeys.getSize());
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->write(S);
break;
case kMatrix44Controller:
S->writeInt(fKeys.getSize());
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->write(S);
break;
case kPoint3Controller:
if (fKeys.getSize() == 0) {
S->writeInt(0);
} else {
S->writeInt(1);
S->writeInt(fKeys.getSize());
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->write(S);
}
break;
case kQuatController:
S->writeInt(fKeys.getSize());
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->write(S);
break;
case kScalarController:
if (fKeys.getSize() == 0) {
S->writeInt(0);
} else {
S->writeInt(1);
S->writeInt(fKeys.getSize());
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->write(S);
}
break;
case kScaleValueController:
S->writeInt(fKeys.getSize());
for (size_t i=0; i<fKeys.getSize(); i++)
fKeys[i]->write(S);
break;
default:
plString err = plString::Format("Unexpected class type [%04X]", ClassIndex());
throw hsBadParamException(__FILE__, __LINE__, err);
}
}
void plUoid::prcParse(const pfPrcTag* tag) {
if (tag->getName() != "plKey")
throw hsBadParamException(__FILE__, __LINE__, "Tag name mismatch");
objName = tag->getParam("Name", "");
classType = plFactory::ClassIndex(tag->getParam("Type", ""));
location.prcParse(tag);
loadMask.prcParse(tag);
cloneID = tag->getParam("CloneID", "0").toUint();
clonePlayerID = tag->getParam("ClonePlayerID", "0").toUint();
}
void plGenericPhysical::IWriteHKPhysical(hsStream* S, plResManager* mgr) {
unsigned int memGroup = plHKSimDefs::setMemGroup(this);
unsigned int repGroup = plHKSimDefs::setRepGroup(this);
unsigned int colGroup = plHKSimDefs::setColGroup(this);
fPos.write(S);
S->writeFloat(fRot.W);
S->writeFloat(fRot.X);
S->writeFloat(fRot.Y);
S->writeFloat(fRot.Z);
S->writeFloat(fMass);
S->writeFloat(fFriction);
S->writeFloat(fRestitution);
if (fBounds == plSimDefs::kCylinderBounds) {
throw hsBadParamException(__FILE__, __LINE__,
"Invalid Bounds type");
}
S->writeInt(fBounds);
S->writeInt(memGroup);
S->writeInt(repGroup);
S->writeInt(colGroup);
S->writeBool(fDisableReport);
S->writeBool(fDisableCollide);
if (fBounds == plSimDefs::kHullBounds) {
S->writeInt(fVerts.size());
for (size_t i=0; i<fVerts.size(); i++)
fVerts[i].write(S);
} else if (fBounds == plSimDefs::kSphereBounds) {
fOffset.write(S);
S->writeFloat(fRadius);
} else { // Box, Proxy, Explicit
S->writeInt(fVerts.size());
for (size_t i=0; i<fVerts.size(); i++)
fVerts[i].write(S);
S->writeInt(fIndices.size() / 3);
for (size_t i=0; i<fIndices.size(); i++)
S->writeShort(fIndices[i]);
}
mgr->writeKey(S, fObjectKey);
fProps.write(S);
mgr->writeKey(S, fSceneNode);
S->writeInt(fLOSDBs);
mgr->writeKey(S, fSubWorld);
mgr->writeKey(S, fSoundGroup);
}
void plDDSurface::write(hsStream* S) {
if (fDataSize != calcTotalBufferSize()) {
plDebug::Debug("Data format does not match buffer size: %d, %d",
fDataSize, calcTotalBufferSize());
}
S->write(4, "DDS ");
S->writeInt(DDSD2_SIZE);
S->writeInt(fFlags);
S->writeInt(fHeight);
S->writeInt(fWidth);
S->writeInt(fLinearSize);
S->writeInt(fBackBufferCount);
S->writeInt(fMipmapCount);
S->writeInt(fAlphaDepth);
S->writeInt(0); // Reserved
S->writeInt(0); // lpSurface
fCKDestOverlay.write(S);
fCKDestBlt.write(S);
fCKSrcOverlay.write(S);
fCKSrcBlt.write(S);
switch (fFlags & (DDSD_FVF | DDSD_PIXELFORMAT)) {
case 0:
case DDSD_PIXELFORMAT:
fPixelFormat.write(S);
break;
case DDSD_FVF:
S->writeInt(fFVF);
S->writeInt(0); // Ignored
S->writeInt(0);
S->writeInt(0);
S->writeInt(0);
S->writeInt(0);
S->writeInt(0);
S->writeInt(0);
break;
default:
throw hsBadParamException(__FILE__, __LINE__, "DDSURFACEDESC may not have both DDSD_PIXELFORMAT and DDSD_FVF");
}
S->writeInt(fCaps);
S->writeInt(fCaps2);
S->writeInt(fCaps3);
S->writeInt(fCaps4);
S->writeInt(fTextureStage);
if (fDataBuffer != NULL)
S->write(fDataSize, fDataBuffer);
}
void plDDSurface::plDDPixelFormat::write(hsStream* S) {
if (((fFlags & DDPF_FOURCC) != 0) && (fFourCC != FOURCC_DXT1
&& fFourCC != FOURCC_DXT3 && fFourCC != FOURCC_DXT5))
throw hsBadParamException(__FILE__, __LINE__, "Unsupported DXT compression type");
S->writeInt(DDPF_SIZE);
S->writeInt(fFlags);
S->writeInt(fFourCC);
S->writeInt(fBitDepth);
S->writeInt(fRBitMask);
S->writeInt(fGBitMask);
S->writeInt(fBBitMask);
S->writeInt(fAlphaBitMask);
}
void plStateDescriptor::read(hsStream* S) {
if (S->readByte() != 1)
throw hsBadParamException(__FILE__, __LINE__, "Bad plStateDescriptor IO Version");
fName = S->readSafeStr();
fVersion = S->readShort();
clearVariables();
fVariables.resize(S->readShort());
for (size_t i=0; i<fVariables.size(); i++) {
fVariables[i] = new plVarDescriptor();
S->readBool(); // Redundant - tells us whether this is an SDVar or a SimpleVar
fVariables[i]->read(S);
}
}
void plKeyData::setObj(class hsKeyedObject* obj) {
if (obj == fObjPtr)
return;
if (fObjPtr != NULL && !fObjPtr->isStub())
throw hsBadParamException(__FILE__, __LINE__, "Trying to change already loaded object");
fObjPtr = obj;
if (obj && !obj->isStub()) {
for (auto it = fCallbacks.begin(); it != fCallbacks.end(); it++)
(*it)(obj);
fCallbacks.clear();
}
}
void plMipmap::Create(unsigned int width, unsigned int height, unsigned char numLevels,
unsigned char compType, ColorFormat format, unsigned char dxtLevel) {
delete[] fImageData;
delete[] fJPEGData;
delete[] fJAlphaData;
if (compType == kDirectXCompression && dxtLevel == kDXTError)
throw hsBadParamException(__FILE__, __LINE__, "DXT Type must be set for DirectX textures");
fCompressionType = compType;
if (compType == kUncompressed || compType == kJPEGCompression) {
setConfig(format);
fUncompressedInfo.fType = format;
} else {
fPixelSize = 32;
fSpace = kDirectSpace;
fDXInfo.fCompressionType = dxtLevel;
if (dxtLevel == kDXT1) {
fDXInfo.fBlockSize = 8;
fFlags = kAlphaBitFlag;
} else {
fDXInfo.fBlockSize = 16;
fFlags = kAlphaChannelFlag;
}
}
fWidth = width;
fHeight = height;
fStride = (fPixelSize * fWidth) / 8;
if (fWidth == 0 || fHeight == 0) {
fLevelData.clear();
fTotalSize = 0;
fImageData = NULL;
fJPEGData = NULL;
fJAlphaData = NULL;
return;
}
if (numLevels == 0) {
numLevels = 1;
while (width > 1 || height > 1) {
width = (width > 1) ? width >> 1 : 1;
height = (height > 1) ? height >> 1 : 1;
numLevels++;
}
}
void hsThread::start() {
hsThread_WIN32* _this = (hsThread_WIN32*)fThreadData;
_this->fMutex.lock();
if ((_this->fState & kStateRunning) != 0) {
_this->fMutex.unlock();
throw hsBadParamException(__FILE__, __LINE__, "Thread already running!");
}
_this->fState |= kStateRunning;
_this->fThreadHandle = CreateThread(NULL, 0, &s_threadstart, this, 0, NULL);
if (_this->fThreadHandle == NULL) {
_this->fState = (_this->fState & ~kStateRunning) | kStateFinished;
fFinishCondition.signal();
}
_this->fMutex.unlock();
}
size_t plDDSurface::calcBufferSize(unsigned int width, unsigned int height) const {
if ((fFlags & DDSD_HEIGHT) == 0 || (fFlags & DDSD_WIDTH) == 0)
return 0;
if ((fFlags & DDSD_PIXELFORMAT) == 0)
throw hsBadParamException(__FILE__, __LINE__, "Surface has no pixel format descriptor");
size_t stride, blocks;
if ((fPixelFormat.fFlags & DDPF_FOURCC) != 0) {
stride = (fPixelFormat.fFourCC == FOURCC_DXT1) ? 8 : 16;
blocks = ((width+3)/4) * ((height+3)/4);
} else {
stride = ((fPixelFormat.fBitCount * width) + 7) / 8;
blocks = height;
}
return stride * blocks;
}
void plParticleSystem::read(hsStream* S, plResManager* mgr) {
plModifier::read(S, mgr);
fMaterial = mgr->readKey(S);
setAmbientCtl(plController::Convert(mgr->ReadCreatable(S)));
setDiffuseCtl(plController::Convert(mgr->ReadCreatable(S)));
setOpacityCtl(plController::Convert(mgr->ReadCreatable(S)));
setWidthCtl(plController::Convert(mgr->ReadCreatable(S)));
setHeightCtl(plController::Convert(mgr->ReadCreatable(S)));
fXTiles = S->readInt();
fYTiles = S->readInt();
fMaxTotalParticles = S->readInt();
fMaxEmitters = S->readInt();
fPreSim = S->readFloat();
fAccel.read(S);
fDrag = S->readFloat();
fWindMult = S->readFloat();
fNumValidEmitters = S->readInt();
for (auto emi = fEmitters.begin(); emi != fEmitters.end(); ++emi)
delete *emi;
fEmitters.resize(fMaxEmitters);
if (fNumValidEmitters > fMaxEmitters)
throw hsBadParamException(__FILE__, __LINE__);
for (size_t i=0; i<fNumValidEmitters; i++)
fEmitters[i] = plParticleEmitter::Convert(mgr->ReadCreatable(S));
for (size_t i=fNumValidEmitters; i<fMaxEmitters; i++)
fEmitters[i] = NULL;
fForces.resize(S->readInt());
for (size_t i=0; i<fForces.size(); i++)
fForces[i] = mgr->readKey(S);
fEffects.resize(S->readInt());
for (size_t i=0; i<fEffects.size(); i++)
fEffects[i] = mgr->readKey(S);
fConstraints.resize(S->readInt());
for (size_t i=0; i<fConstraints.size(); i++)
fConstraints[i] = mgr->readKey(S);
fPermaLights.resize(S->readInt());
for (size_t i=0; i<fPermaLights.size(); i++)
fPermaLights[i] = mgr->readKey(S);
}
void plOneTimeParticleGenerator::write(hsStream* S, plResManager* mgr) {
uint32_t count = static_cast<uint32_t>(fPosition.size());
S->writeInt(count);
S->writeFloat(fXSize);
S->writeFloat(fYSize);
S->writeFloat(fScaleMin);
S->writeFloat(fScaleMax);
S->writeFloat(fPartRadsPerSecRange);
if (fPosition.size() != fDirection.size()) {
throw hsBadParamException(__FILE__, __LINE__,
"Position and Direction array sizes must match");
}
for (uint32_t i = 0; i < count; ++i) {
fPosition[i].write(S);
fDirection[i].write(S);
}
}
/* plVarDescriptor */
void plVarDescriptor::read(hsStream* S) {
if (S->readByte() != 3)
throw hsBadParamException(__FILE__, __LINE__, "Bad plVarDescriptor IO Version");
fName = S->readSafeStr();
size_t len = S->readShort();
fDisplay = S->readStr(len);
fCount = S->readInt();
fType = (plVarDescriptor::Type)S->readByte();
fDefault = S->readSafeStr();
fFlags = S->readInt();
if (fType == kStateDescriptor) {
fStateDescType = S->readSafeStr();
fStateDescVer = S->readShort();
} else {
S->readShort(); // Atomic count
S->readByte(); // Atomic type
}
}
void plSimpleParticleGenerator::IPrcWrite(pfPrcHelper* prc) {
prc->startTag("ParticleParams");
prc->writeParam("GenLife", fGenLife);
prc->writeParam("PartLifeMin", fPartLifeMin);
prc->writeParam("PartLifeMax", fPartLifeMax);
prc->writeParam("ParticlesPerSecond", fParticlesPerSecond);
prc->writeParam("ParticleMass", fPartMassRange);
prc->writeParam("RadsPerSecond", fPartRadsPerSecRange);
prc->endTag(true);
prc->startTag("GeneratorParams");
prc->writeParam("AngleRange", fAngleRange);
prc->writeParam("VelMin", fVelMin);
prc->writeParam("VelMax", fVelMax);
prc->writeParam("XSize", fXSize);
prc->writeParam("YSize", fYSize);
prc->writeParam("ScaleMin", fScaleMin);
prc->writeParam("ScaleMax", fScaleMax);
prc->endTag(true);
if (fInitPos.size() != fInitPitch.size() || fInitPos.size() != fInitYaw.size()) {
throw hsBadParamException(__FILE__, __LINE__,
"Init Position, Pitch and Yaw array sizes must match");
}
prc->writeSimpleTag("ParticleSources");
for (size_t i = 0; i < fInitPos.size(); ++i) {
prc->startTag("Source");
prc->writeParam("Pitch", fInitPitch[i]);
prc->writeParam("Yaw", fInitYaw[i]);
prc->endTag();
fInitPos[i].prcWrite(prc);
prc->closeTag();
}
prc->closeTag();
}
void plDrawableSpans::read(hsStream* S, plResManager* mgr) {
hsKeyedObject::read(S, mgr);
fProps = S->readInt();
fCriteria = S->readInt();
fRenderLevel = S->readInt();
fMaterials.setSize(S->readInt());
for (size_t i=0; i<fMaterials.getSize(); i++)
fMaterials[i] = mgr->readKey(S);
for (size_t i=0; i<fSpans.getSize(); i++)
delete fSpans[i];
fIcicles.setSize(S->readInt());
for (size_t i=0; i<fIcicles.getSize(); i++) {
fIcicles[i] = new plIcicle();
fIcicles[i]->read(S);
}
if (!S->getVer().isHexIsle()) {
if (S->readInt() != 0)
throw hsBadParamException(__FILE__, __LINE__, "Unsupported field count > 0");
}
fSpans.setSizeNull(S->readInt());
fSpanSourceIndices.setSizeNull(fSpans.getSize());
for (size_t i=0; i<fSpanSourceIndices.getSize(); i++) {
fSpanSourceIndices[i] = S->readInt();
if ((fSpanSourceIndices[i] & kSpanTypeMask) == kSpanTypeIcicle)
fSpans[i] = fIcicles[fSpanSourceIndices[i] & kSpanIDMask];
else if ((fSpanSourceIndices[i] & kSpanTypeMask) == kSpanTypeParticleSpan)
fSpans[i] = fParticleSpans[fSpanSourceIndices[i] & kSpanIDMask];
}
for (size_t i=0; i<fSpans.getSize(); i++)
fSpans[i]->setFogEnvironment(mgr->readKey(S));
if (fSpans.getSize() > 0) {
fLocalBounds.read(S);
fWorldBounds.read(S);
fMaxWorldBounds.read(S);
} else {
fLocalBounds.setType(hsBounds3::kIsSphere);
fWorldBounds.setType(hsBounds3::kIsSphere);
fMaxWorldBounds.setType(hsBounds3::kIsSphere);
}
for (size_t i=0; i<fSpans.getSize(); i++) {
if (fSpans[i]->getProps() & plSpan::kPropHasPermaLights) {
size_t count = S->readInt();
for (size_t j=0; j<count; j++)
fSpans[i]->addPermaLight(mgr->readKey(S));
}
if (fSpans[i]->getProps() & plSpan::kPropHasPermaProjs) {
size_t count = S->readInt();
for (size_t j=0; j<count; j++)
fSpans[i]->addPermaProj(mgr->readKey(S));
}
}
fSourceSpans.setSizeNull(S->readInt());
if (fSourceSpans.getSize() > 0 && !S->getVer().isUniversal())
plDebug::Debug("Reading deprecated SourceSpans");
for (size_t i=0; i<fSourceSpans.getSize(); i++) {
fSourceSpans[i].reset(new plGeometrySpan());
fSourceSpans[i]->read(S);
if (fSpans[i]->getMaterialIdx() == 0xFFFFFFFF)
fSourceSpans[i]->setMaterial(NULL);
else
fSourceSpans[i]->setMaterial(fMaterials[fSpans[i]->getMaterialIdx()]);
fSourceSpans[i]->setFogEnvironment(fSpans[i]->getFogEnvironment());
}
size_t xformCount = S->readInt();
fLocalToWorlds.setSize(xformCount);
fWorldToLocals.setSize(xformCount);
fLocalToBones.setSize(xformCount);
fBoneToLocals.setSize(xformCount);
for (size_t i=0; i<xformCount; i++) {
fLocalToWorlds[i].read(S);
fWorldToLocals[i].read(S);
fLocalToBones[i].read(S);
fBoneToLocals[i].read(S);
}
fDIIndices.setSize(S->readInt());
for (size_t i=0; i<fDIIndices.getSize(); i++) {
fDIIndices[i].fFlags = S->readInt();
fDIIndices[i].fIndices.setSize(S->readInt());
for (size_t j=0; j<(fDIIndices[i].fIndices.getSize()); j++)
fDIIndices[i].fIndices[j] = S->readInt();
}
for (size_t i=0; i<fGroups.getSize(); i++)
delete fGroups[i];
fGroups.setSizeNull(S->readInt());
for (size_t i=0; i<fGroups.getSize(); i++) {
fGroups[i] = new plGBufferGroup(0);
fGroups[i]->read(S);
}
setSpaceTree(plSpaceTree::Convert(mgr->ReadCreatable(S)));
fSceneNode = mgr->readKey(S);
}
void plClothingItem::IPrcParse(const pfPrcTag* tag, plResManager* mgr) {
if (tag->getName() == "ClothingName") {
fItemName = tag->getParam("value", "");
} else if (tag->getName() == "ClosetOptions") {
fGroup = tag->getParam("Group", "0").to_uint();
fType = tag->getParam("Type", "0").to_uint();
fTileset = tag->getParam("Tileset", "0").to_uint();
fSortOrder = tag->getParam("SortOrder", "0").to_uint();
} else if (tag->getName() == "Description") {
fDescription = "";
std::list<ST::string> descTokens = tag->getContents();
for (auto tok = descTokens.begin(); tok != descTokens.end(); ++tok)
fDescription += *tok + " ";
} else if (tag->getName() == "CustomText") {
fCustomText = tag->getParam("value", "");
} else if (tag->getName() == "Icon") {
if (tag->hasChildren())
fIcon = mgr->prcParseKey(tag->getFirstChild());
} else if (tag->getName() == "Elements") {
clearElements();
fElementNames.resize(tag->countChildren());
fTextures.resize(fElementNames.size());
const pfPrcTag* child = tag->getFirstChild();
for (size_t i=0; i<fElementNames.size(); i++) {
if (child->getName() != "Element")
throw pfPrcTagException(__FILE__, __LINE__, child->getName());
fElementNames[i] = child->getParam("Name", "");
fTextures[i] = new plKey[10];
size_t nSubChildren = child->countChildren();
const pfPrcTag* subChild = child->getFirstChild();
for (size_t j=0; j<nSubChildren; j++) {
plKey k = mgr->prcParseKey(subChild);
if (j < kLayerMax)
fTextures[i][j] = k;
else
plDebug::Warning("Throwing away key {}", k.toString());
subChild = subChild->getNextSibling();
}
child = child->getNextSibling();
}
} else if (tag->getName() == "Meshes") {
size_t nMeshes = tag->countChildren();
if (nMeshes != kNumLODLevels)
throw hsBadParamException(__FILE__, __LINE__);
const pfPrcTag* child = tag->getFirstChild();
for (size_t i=0; i<kNumLODLevels; i++) {
fMeshes[i] = mgr->prcParseKey(child);
child = child->getNextSibling();
}
} else if (tag->getName() == "Accessory") {
if (tag->hasChildren())
fAccessory = mgr->prcParseKey(tag->getFirstChild());
} else if (tag->getName() == "DefaultTints") {
const pfPrcTag* child = tag->getFirstChild();
while (child != NULL) {
if (child->getName() == "Tint1") {
fDefaultTint1[0] = child->getParam("red", "0").to_uint();
fDefaultTint1[1] = child->getParam("green", "0").to_uint();
fDefaultTint1[2] = child->getParam("blue", "0").to_uint();
} else if (child->getName() == "Tint2") {
fDefaultTint2[0] = child->getParam("red", "0").to_uint();
fDefaultTint2[1] = child->getParam("green", "0").to_uint();
fDefaultTint2[2] = child->getParam("blue", "0").to_uint();
} else {
throw pfPrcTagException(__FILE__, __LINE__, child->getName());
}
child = child->getNextSibling();
}
} else {
hsKeyedObject::IPrcParse(tag, mgr);
}
}
