OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
363 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 3ead2ccda5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3ead2ccda5'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plSDL/plStateVariable.cpp

2778 lines
77 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include <float.h>
#include "hsStream.h"
#include "hsTimer.h"
#include "hsStlUtils.h"
#include "plSDL.h"
#include "pnProduct/pnProduct.h"
#include "pnFactory/plCreatable.h"
#include "pnKeyedObject/plUoid.h"
#include "pnKeyedObject/plKey.h"
#include "pnKeyedObject/plKeyImp.h"
#include "pnNetCommon/plNetApp.h"
#include "pnNetCommon/pnNetCommon.h"
#include "plResMgr/plResManager.h"
#include "plResMgr/plKeyFinder.h"
#include "plUnifiedTime/plClientUnifiedTime.h"
#include "plResMgr/plResManager.h"
#include "plUnifiedTime/plClientUnifiedTime.h"
/*****************************************************************************
*
* VALIDATE_WITH_FALSE_RETURN
* Used in var getters and setters to validate incoming parameters and
* bail in a non-fatal way on error.
*
***/
#define VALIDATE_WITH_FALSE_RETURN(cond) \
if (!(cond)) { \
plSDLMgr::GetInstance()->GetNetApp()->DebugMsg("SDL var. Validation failed: "#cond); \
ASSERT(!(cond)); \
return false; \
} //
//
// generic creatable which holds any kind of creatable blob
//
class plSDLCreatableStub : public plCreatable
{
private:
UInt16 fClassIndex;
public:
void* fData;
int fDataLen;
plSDLCreatableStub(UInt16 classIndex, int len) : fClassIndex(classIndex),fData(nil),fDataLen(len) {}
~plSDLCreatableStub() { delete [] fData; }
const char* ClassName() const { return "SDLCreatable"; }
UInt16 ClassIndex() const { return fClassIndex; }
void Read(hsStream* s, hsResMgr* mgr) { delete [] fData; fData = TRACKED_NEW char[fDataLen]; s->Read(fDataLen, fData); }
void Write(hsStream* s, hsResMgr* mgr) { s->Write(fDataLen, fData); }
};
/////////////////////////////////////////////////////
// plStateVarNotificationInfo
/////////////////////////////////////////////////////
void plStateVarNotificationInfo::Read(hsStream* s, UInt32 readOptions)
{
UInt8 saveFlags=s->ReadByte(); // unused
char* hint=s->ReadSafeString();
if (hint && !(readOptions & plSDL::kSkipNotificationInfo))
fHintString = (const char*)hint;
// we're done with it...
delete [] hint;
}
void plStateVarNotificationInfo::Write(hsStream* s, UInt32 writeOptions) const
{
UInt8 saveFlags=0; // unused
s->WriteSwap(saveFlags);
s->WriteSafeString(fHintString.c_str());
}
/////////////////////////////////////////////////////
// plStateVariable
/////////////////////////////////////////////////////
bool plStateVariable::ReadData(hsStream* s, float timeConvert, UInt32 readOptions)
{
UInt8 saveFlags;
s->ReadSwap(&saveFlags);
if (saveFlags & plSDL::kHasNotificationInfo)
{
GetNotificationInfo().Read(s, readOptions);
}
return true;
}
bool plStateVariable::WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const
{
bool writeNotificationInfo = ((writeOptions & plSDL::kSkipNotificationInfo)==0);
UInt8 saveFlags=0;
if (writeNotificationInfo)
saveFlags |= plSDL::kHasNotificationInfo;
s->WriteSwap(saveFlags);
if (writeNotificationInfo)
{
GetNotificationInfo().Write(s, writeOptions);
}
return true;
}
/////////////////////////////////////////////////////
// plSimpleStateVariable
/////////////////////////////////////////////////////
void plSimpleStateVariable::IInit()
{
SetDirty(false);
SetUsed(false);
fBy=nil;
fS=nil;
fI=nil;
fF=nil;
fD=nil;
fB=nil;
fU=nil;
fS32=nil;
fC=nil;
fT=nil;
fTimeStamp.ToEpoch();
}
//
// delete memory
//
#define DEALLOC(type, var) \
case type: \
delete [] var; \
break;
void plSimpleStateVariable::IDeAlloc()
{
int cnt = fVar.GetAtomicCount()*fVar.GetCount();
int type = fVar.GetAtomicType();
switch (type)
{
DEALLOC (plVarDescriptor::kInt, fI)
DEALLOC (plVarDescriptor::kAgeTimeOfDay, fF)
DEALLOC (plVarDescriptor::kShort, fS)
DEALLOC (plVarDescriptor::kByte, fBy)
DEALLOC (plVarDescriptor::kFloat, fF)
DEALLOC (plVarDescriptor::kTime, fT)
DEALLOC (plVarDescriptor::kDouble, fD)
DEALLOC (plVarDescriptor::kBool, fB)
DEALLOC (plVarDescriptor::kKey, fU)
DEALLOC (plVarDescriptor::kString32, fS32)
case plVarDescriptor::kCreatable:
{
if(fC)
{
int i;
// delete each creatable
for(i=0;i<cnt; i++)
delete fC[i];
// delete creatable array
delete [] fC;
}
}
break;
default:
hsAssert(false, xtl::format("undefined atomic type:%d var:%s cnt:%d",
type, GetName() ? GetName() : "?", GetCount()).c_str());
break;
};
}
//
// alloc memory
//
#define SDLALLOC(typeName, type, var) \
case typeName: \
var = TRACKED_NEW type[cnt]; \
break;
void plSimpleStateVariable::Alloc(int listSize)
{
if (listSize != -1)
fVar.SetCount(listSize);
IDeAlloc();
IInit();
int cnt = fVar.GetAtomicCount()*fVar.GetCount();
if (cnt)
{
switch (fVar.GetAtomicType())
{
SDLALLOC(plVarDescriptor::kInt, int, fI)
SDLALLOC(plVarDescriptor::kAgeTimeOfDay, float, fF)
SDLALLOC(plVarDescriptor::kByte, byte, fBy)
SDLALLOC(plVarDescriptor::kShort, short, fS)
SDLALLOC(plVarDescriptor::kFloat, float, fF)
SDLALLOC(plVarDescriptor::kDouble, double, fD)
SDLALLOC(plVarDescriptor::kBool, bool, fB)
SDLALLOC(plVarDescriptor::kCreatable, plCreatable*, fC)
case plVarDescriptor::kTime:
fT = TRACKED_NEW plClientUnifiedTime[cnt];
break;
case plVarDescriptor::kKey:
fU = TRACKED_NEW plUoid[cnt];
break;
case plVarDescriptor::kString32:
fS32 = TRACKED_NEW plVarDescriptor::String32[cnt];
break;
default:
hsAssert(false, "undefined atomic type");
break;
};
}
Reset();
}
#define RESET(typeName, type, var) \
case typeName: \
for(i=0;i<cnt;i++) \
var[i]=0; \
break;
void plSimpleStateVariable::Reset()
{
int i, cnt = fVar.GetAtomicCount()*fVar.GetCount();
if (cnt)
{
switch (fVar.GetAtomicType())
{
RESET(plVarDescriptor::kInt, int, fI)
RESET(plVarDescriptor::kAgeTimeOfDay, float, fF)
RESET(plVarDescriptor::kByte, byte, fBy)
RESET(plVarDescriptor::kShort, short, fS)
RESET(plVarDescriptor::kFloat, float, fF)
RESET(plVarDescriptor::kDouble, double, fD)
RESET(plVarDescriptor::kBool, bool, fB)
RESET(plVarDescriptor::kCreatable, plCreatable*, fC)
case plVarDescriptor::kTime:
break;
case plVarDescriptor::kKey:
break;
case plVarDescriptor::kString32:
for(i=0;i<cnt;i++)
*fS32[i]=0;
break;
default:
hsAssert(false, "undefined atomic type");
break;
};
}
}
//
// Copy the descriptor settings and allocate list
//
void plSimpleStateVariable::CopyFrom(plVarDescriptor* v)
{
if (v)
{
plSimpleVarDescriptor* simV=(plSimpleVarDescriptor*)v;
if (simV)
fVar.CopyFrom(simV);
else
fVar.CopyFrom(v); // copy base class
Alloc();
}
}
void plSimpleStateVariable::TimeStamp( const plUnifiedTime & ut/*=plUnifiedTime::GetCurrentTime()*/ )
{
fTimeStamp = ut;
}
//
// Set value from string. Used to set default values which are specified as strings.
//
bool plSimpleStateVariable::SetFromString(const char* valueConst, int idx, bool timeStampNow)
{
if (!valueConst)
return false;
std::string value = valueConst;
plVarDescriptor::Type type=fVar.GetAtomicType();
switch(type)
{
case plVarDescriptor::kAgeTimeOfDay:
case plVarDescriptor::kTime:
case plVarDescriptor::kDouble:
case plVarDescriptor::kFloat:
case plVarDescriptor::kInt:
case plVarDescriptor::kShort:
case plVarDescriptor::kByte:
{
// handles value in the form "(i,j,k)" for vectors
static char seps[] = "( ,)";
char* ptr = strtok( (char*)value.c_str(), seps );
int i=idx*fVar.GetAtomicCount();
while (ptr)
{
if ((type==plVarDescriptor::kInt) && fI)
fI[i++] = atoi(ptr);
else if (type==plVarDescriptor::kShort && fS)
fS[i++] = (short)atoi(ptr);
else if (type==plVarDescriptor::kByte && fBy)
fBy[i++] = (byte)atoi(ptr);
else if ( (type==plVarDescriptor::kFloat || type==plVarDescriptor::kAgeTimeOfDay) && fF)
fF[i++] = (float)atof(ptr);
else if ( (type==plVarDescriptor::kDouble || type==plVarDescriptor::kTime) && fD)
fD[i++] = atof(ptr);
ptr = strtok(nil, seps);
}
}
break;
case plVarDescriptor::kBool:
{
// handles value in the form "(i,j,k)" for things like vectors
static char seps[] = "( ,)";
char* ptr = strtok( (char*)value.c_str(), seps );
int i=idx*fVar.GetAtomicCount();
while (ptr)
{
if (!stricmp(ptr, "true"))
fB[i++]=true;
else
if (!stricmp(ptr, "false"))
fB[i++]=false;
else
fB[i++] = (atoi(ptr) != 0);
ptr = strtok(nil, seps);
}
}
break;
case plVarDescriptor::kString32:
{
// handles value in the form "(i,j,k)" for things like vectors
static char seps[] = "( ,)";
char* ptr = strtok( (char*)value.c_str(), seps );
int i=idx*fVar.GetAtomicCount();
while (ptr)
{
hsStrncpy(fS32[i++], ptr, 32);
ptr = strtok(nil, seps);
}
}
break;
default:
return false; // err
}
IVarSet(timeStampNow);
return true; // ok
}
//
// Called when a var has been set with a value
//
void plSimpleStateVariable::IVarSet(bool timeStampNow/*=true*/)
{
if (timeStampNow)
TimeStamp();
SetDirty(true);
SetUsed(true);
}
//
// Get value as string.
//
char* plSimpleStateVariable::GetAsString(int idx) const
{
int j;
std::string str;
if (fVar.GetAtomicCount()>1)
str = str + "(";
plVarDescriptor::Type type=fVar.GetAtomicType();
switch(type)
{
case plVarDescriptor::kAgeTimeOfDay:
case plVarDescriptor::kTime:
case plVarDescriptor::kDouble:
case plVarDescriptor::kFloat:
case plVarDescriptor::kInt:
case plVarDescriptor::kByte:
case plVarDescriptor::kShort:
{
// handles value in the form "(i,j,k)" for vectors
int i=idx*fVar.GetAtomicCount();
for(j=0;j<fVar.GetAtomicCount();j++)
{
if (type==plVarDescriptor::kInt)
str.append( xtl::format( "%d", fI[i++]) );
else if (type==plVarDescriptor::kShort)
str.append( xtl::format( "%d", fS[i++]) );
else if (type==plVarDescriptor::kByte)
str.append( xtl::format( "%d", fBy[i++]) );
else if (type==plVarDescriptor::kFloat || type==plVarDescriptor::kAgeTimeOfDay)
str.append( xtl::format( "%.3f", fF[i++]) );
else if (type==plVarDescriptor::kDouble)
str.append( xtl::format( "%.3f", fD[i++]) );
else if (type==plVarDescriptor::kTime)
{
double tmp;
Get(&tmp, i++);
str.append( xtl::format( "%.3f", tmp) );
}
if (j==fVar.GetAtomicCount()-1)
{
if (j)
str += ")";
}
else
str += ",";
}
}
break;
case plVarDescriptor::kBool:
{
// handles value in the form "(i,j,k)" for things like vectors
int i=idx*fVar.GetAtomicCount();
for(j=0;j<fVar.GetAtomicCount();j++)
{
str.append( xtl::format( "%s", fB[i++] ? "true" : "false") );
if (j==fVar.GetAtomicCount()-1)
{
if (j)
str += ")";
}
else
str += ",";
}
}
break;
case plVarDescriptor::kString32:
{
// handles value in the form "(i,j,k)" for things like vectors
int i=idx*fVar.GetAtomicCount();
for(j=0;j<fVar.GetAtomicCount();j++)
{
str.append( xtl::format( "%s", fS32[i++]) );
if (j==fVar.GetAtomicCount()-1)
{
if (j)
str += ")";
}
else
str += ",";
}
}
break;
default:
{
// handles value in the form "(i,j,k)" for things like vectors
int i=idx*fVar.GetAtomicCount();
for(j=0;j<fVar.GetAtomicCount();j++)
{
str.append( xtl::format( "%s", "other") );
if (j==fVar.GetAtomicCount()-1)
{
if (j)
str += ")";
}
else
str += ",";
}
}
break;
}
return hsStrcpy(str.c_str());
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromRGB(plVarDescriptor::Type newType)
{
switch(newType)
{
case plVarDescriptor::kRGBA:
{
// rgb to rgba
int i,j;
float* newF = TRACKED_NEW float[fVar.GetCount()*4]; // make more space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy with alpha=0 by default
for(i=0;i<3;i++)
newF[j*4+i] = fF[j*fVar.GetAtomicCount()+i];
newF[j*4+3] = 0;
}
delete [] fF; // delete old
fF = newF; // use new
}
break;
case plVarDescriptor::kRGBA8:
{
// rgb to rgba8
int i,j;
byte * newB = TRACKED_NEW byte [fVar.GetCount()*4]; // make more space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy with alpha=0 by default
for(i=0;i<3;i++)
newB[j*4+i] = byte(fF[j*fVar.GetAtomicCount()+i]*255+.5);
newB[j*4+3] = 0;
}
delete [] fF; // delete old
fBy = newB; // use new
}
break;
case plVarDescriptor::kRGB8:
{
// rgb to rgb8
int i,j;
byte * newB = TRACKED_NEW byte [fVar.GetCount()*3]; // make space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy with alpha=0 by default
for(i=0;i<3;i++)
newB[j*3+i] = byte(fF[j*fVar.GetAtomicCount()+i]*255+.5);
}
delete [] fF; // delete old
fBy = newB; // use new
}
break;
default:
return false; // err
}
return true;
}
bool plSimpleStateVariable::IConvertFromRGB8(plVarDescriptor::Type newType)
{
switch(newType)
{
case plVarDescriptor::kRGBA:
{
// rgb8 to rgba
int i,j;
float* newF = TRACKED_NEW float[fVar.GetCount()*4]; // make more space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy with alpha=0 by default
for(i=0;i<3;i++)
newF[j*4+i] = fBy[j*fVar.GetAtomicCount()+i]/255.f;
newF[j*4+3] = 0;
}
delete [] fBy; // delete old
fF = newF; // use new
}
break;
case plVarDescriptor::kRGB:
{
// rgb8 to rgb
int i,j;
float* newF = TRACKED_NEW float[fVar.GetCount()*3]; // make more space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy with alpha=0 by default
for(i=0;i<3;i++)
newF[j*3+i] = fBy[j*fVar.GetAtomicCount()+i]/255.f;
}
delete [] fBy; // delete old
fF = newF; // use new
}
break;
case plVarDescriptor::kRGBA8:
{
// rgb8 to rgba8
int i,j;
byte * newB = TRACKED_NEW byte [fVar.GetCount()*4]; // make more space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy with alpha=0 by default
for(i=0;i<3;i++)
newB[j*4+i] = fBy[j*fVar.GetAtomicCount()+i];
newB[j*4+3] = 0;
}
delete [] fBy; // delete old
fBy = newB; // use new
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromRGBA(plVarDescriptor::Type newType)
{
switch(newType)
{
case plVarDescriptor::kRGB:
{
// rgba to rgb
int i,j;
float* newF = TRACKED_NEW float[fVar.GetCount()*3]; // make less space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy and ignore alpha
for(i=0;i<3;i++)
newF[j*3+i] = fF[j*fVar.GetAtomicCount()+i];
}
delete [] fF; // delete old
fF = newF; // use new
}
break;
case plVarDescriptor::kRGB8:
{
// rgba to rgb8
int i,j;
byte* newB = TRACKED_NEW byte[fVar.GetCount()*3]; // make less space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy and ignore alpha
for(i=0;i<3;i++)
newB[j*3+i] = byte(fF[j*fVar.GetAtomicCount()+i]*255+.5);
}
delete [] fF; // delete old
fBy = newB; // use new
}
break;
case plVarDescriptor::kRGBA8:
{
// rgba to rgba8
int i,j;
byte* newBy = TRACKED_NEW byte [fVar.GetCount()*4]; // make less space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy and ignore alpha
for(i=0;i<4;i++)
newBy[j*4+i] = byte(fF[j*fVar.GetAtomicCount()+i]*255+.5);
}
delete [] fF; // delete old
fBy = newBy; // use new
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromRGBA8(plVarDescriptor::Type newType)
{
switch(newType)
{
case plVarDescriptor::kRGB:
{
// rgba8 to rgb
int i,j;
float* newF = TRACKED_NEW float[fVar.GetCount()*3]; // make less space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy and ignore alpha
for(i=0;i<3;i++)
newF[j*3+i] = fBy[j*fVar.GetAtomicCount()+i]/255.f;
}
delete [] fBy; // delete old
fF = newF; // use new
}
break;
case plVarDescriptor::kRGB8:
{
// rgba8 to rgb8
int i,j;
byte* newB = TRACKED_NEW byte[fVar.GetCount()*3]; // make less space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy and ignore alpha
for(i=0;i<3;i++)
newB[j*3+i] = fBy[j*fVar.GetAtomicCount()+i];
}
delete [] fBy; // delete old
fBy = newB; // use new
}
break;
case plVarDescriptor::kRGBA:
{
// rgba8 to rgba
int i,j;
float* newF = TRACKED_NEW float[fVar.GetCount()*4]; // make less space
for(j=0;j<fVar.GetCount(); j++)
{
// recopy and ignore alpha
for(i=0;i<4;i++)
newF[j*4+i] = fBy[j*fVar.GetAtomicCount()+i]/255.f;
}
delete [] fBy; // delete old
fF = newF; // use new
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromInt(plVarDescriptor::Type newType)
{
int j;
switch(newType)
{
case plVarDescriptor::kFloat:
{
// int to float
float* newF = TRACKED_NEW float[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newF[j] = (float)(fI[j]);
delete [] fI;
fF = newF;
}
break;
case plVarDescriptor::kShort:
{
// int to short
short* newS = TRACKED_NEW short[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newS[j] = short(fI[j]);
delete [] fI;
fS = newS;
}
break;
case plVarDescriptor::kByte:
{
// int to byte
byte* newBy = TRACKED_NEW byte[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newBy[j] = byte(fI[j]);
delete [] fI;
fBy = newBy;
}
break;
case plVarDescriptor::kDouble:
{
// int to double
double * newD = TRACKED_NEW double[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newD[j] = fI[j];
delete [] fI;
fD = newD;
}
break;
case plVarDescriptor::kBool:
{
// int to bool
bool * newB = TRACKED_NEW bool[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newB[j] = (fI[j]!=0);
delete [] fI;
fB = newB;
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromShort(plVarDescriptor::Type newType)
{
int j;
switch(newType)
{
case plVarDescriptor::kFloat:
{
float* newF = TRACKED_NEW float[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newF[j] = fS[j];
delete [] fS;
fF = newF;
}
break;
case plVarDescriptor::kInt:
{
int* newI = TRACKED_NEW int[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newI[j] = short(fS[j]);
delete [] fS;
fI = newI;
}
case plVarDescriptor::kByte:
{
byte* newBy = TRACKED_NEW byte[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newBy[j] = byte(fS[j]);
delete [] fS;
fBy = newBy;
}
break;
case plVarDescriptor::kDouble:
{
double * newD = TRACKED_NEW double[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newD[j] = fS[j];
delete [] fS;
fD = newD;
}
break;
case plVarDescriptor::kBool:
{
bool * newB = TRACKED_NEW bool[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newB[j] = (fS[j]!=0);
delete [] fS;
fB = newB;
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromByte(plVarDescriptor::Type newType)
{
int j;
switch(newType)
{
case plVarDescriptor::kFloat:
{
float* newF = TRACKED_NEW float[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newF[j] = fBy[j];
delete [] fBy;
fF = newF;
}
break;
case plVarDescriptor::kInt:
{
int* newI = TRACKED_NEW int[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newI[j] = short(fBy[j]);
delete [] fBy;
fI = newI;
}
case plVarDescriptor::kShort:
{
short* newS = TRACKED_NEW short[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newS[j] = fBy[j];
delete [] fBy;
fS = newS;
}
break;
case plVarDescriptor::kDouble:
{
double * newD = TRACKED_NEW double[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newD[j] = fBy[j];
delete [] fBy;
fD = newD;
}
break;
case plVarDescriptor::kBool:
{
bool * newB = TRACKED_NEW bool[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newB[j] = (fBy[j]!=0);
delete [] fBy;
fB = newB;
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromFloat(plVarDescriptor::Type newType)
{
int j;
switch(newType)
{
case plVarDescriptor::kInt:
{
int* newI = TRACKED_NEW int[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newI[j] = (int)(fF[j]+.5f); // round to nearest int
delete [] fF;
fI = newI;
}
break;
case plVarDescriptor::kShort:
{
short* newS = TRACKED_NEW short[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newS[j] = (short)(fF[j]+.5f); // round to nearest int
delete [] fF;
fS = newS;
}
break;
case plVarDescriptor::kByte:
{
byte* newBy = TRACKED_NEW byte[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newBy[j] = (byte)(fF[j]+.5f); // round to nearest int
delete [] fF;
fBy = newBy;
}
break;
case plVarDescriptor::kDouble:
{
double* newD = TRACKED_NEW double[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newD[j] = fF[j];
delete [] fF;
fD = newD;
}
break;
case plVarDescriptor::kBool:
{
bool* newB = TRACKED_NEW bool[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newB[j] = (fF[j]!=0);
delete [] fF;
fB = newB;
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromDouble(plVarDescriptor::Type newType)
{
int j;
switch(newType)
{
case plVarDescriptor::kInt:
{
int* newI = TRACKED_NEW int[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newI[j] = (int)(fD[j]+.5f); // round to nearest int
delete [] fD;
fI = newI;
}
break;
case plVarDescriptor::kShort:
{
short* newS = TRACKED_NEW short[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newS[j] = (short)(fD[j]+.5f); // round to nearest int
delete [] fD;
fS = newS;
}
break;
case plVarDescriptor::kByte:
{
byte* newBy = TRACKED_NEW byte[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newBy[j] = (byte)(fD[j]+.5f); // round to nearest int
delete [] fD;
fBy = newBy;
}
break;
case plVarDescriptor::kFloat:
{
float* newF = TRACKED_NEW float[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newF[j] = (float)(fD[j]);
delete [] fD;
fF = newF;
}
break;
case plVarDescriptor::kBool:
{
bool* newB = TRACKED_NEW bool[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newB[j] = (fD[j]!=0);
delete [] fD;
fB = newB;
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromBool(plVarDescriptor::Type newType)
{
int j;
switch(newType)
{
case plVarDescriptor::kInt:
{
int* newI = TRACKED_NEW int[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newI[j] = (fB[j] == true ? 1 : 0);
delete [] fB;
fI = newI;
}
break;
case plVarDescriptor::kShort:
{
short* newS = TRACKED_NEW short[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newS[j] = (fB[j] == true ? 1 : 0);
delete [] fB;
fS = newS;
}
break;
case plVarDescriptor::kByte:
{
byte* newBy = TRACKED_NEW byte[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newBy[j] = (fB[j] == true ? 1 : 0);
delete [] fB;
fBy = newBy;
}
break;
case plVarDescriptor::kFloat:
{
float* newF = TRACKED_NEW float[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newF[j] = (fB[j] == true ? 1.f : 0.f);
delete [] fB;
fF = newF;
}
break;
case plVarDescriptor::kDouble:
{
double* newD= TRACKED_NEW double[fVar.GetCount()];
for(j=0;j<fVar.GetCount(); j++)
newD[j] = (fB[j] == true ? 1.f : 0.f);
delete [] fB;
fD = newD;
}
break;
default:
return false; // err
}
return true;
}
//
// return false on err
//
bool plSimpleStateVariable::IConvertFromString(plVarDescriptor::Type newType)
{
int j;
switch(newType)
{
case plVarDescriptor::kBool:
// string to bool
for(j=0;j<fVar.GetCount(); j++)
{
if (!stricmp(fS32[j], "true") || !stricmp(fS32[j], "1"))
fB[j]=true;
else
if (!stricmp(fS32[j], "false") || !stricmp(fS32[j], "0"))
fB[j]=false;
else
return false; // err
}
break;
case plVarDescriptor::kInt:
// string to int
for(j=0;j<fVar.GetCount(); j++)
{
fI[j] = atoi(fS32[j]);
}
break;
case plVarDescriptor::kFloat:
// string to float
for(j=0;j<fVar.GetCount(); j++)
{
fF[j] = (float) atof(fS32[j]);
}
break;
default:
return false; // err
}
return true;
}
//
// Try to convert my value to another type.
// return false on err.
// called when a data record is read in
//
bool plSimpleStateVariable::ConvertTo(plSimpleVarDescriptor* toVar, bool force )
{
// NOTE: 'force' has no meaning here really, so it is not inforced.
plVarDescriptor::Type newType = toVar->GetType();
int cnt = toVar->GetCount() ? toVar->GetCount() : fVar.GetCount();
if (cnt > fVar.GetCount()) {
#ifndef PLASMA_EXTERNAL_RELEASE
FATAL("SDL Convert: array size increased, conversion loses data");
#endif
// Reallocate new memory (destroys existing variable state)
Alloc(cnt);
// match types now
fVar.SetCount(cnt);
fVar.SetType(toVar->GetType());
fVar.SetAtomicType(toVar->GetAtomicType());
return true;
}
fVar.SetCount(cnt); // convert count
// types are already the same, done.
if (fVar.GetType()==newType )
return true;
hsLogEntry( plNetApp::StaticDebugMsg( "SSV(%p) converting %s from %s to %s",
this, fVar.GetName(), fVar.GetTypeString(), toVar->GetTypeString() ) );
switch(fVar.GetType()) // original type
{
// FROM RGB
case plVarDescriptor::kRGB:
if (!IConvertFromRGB(newType))
return false;
break;
// FROM RGBA
case plVarDescriptor::kRGBA:
if (!IConvertFromRGBA(newType))
return false;
break;
// FROM RGB8
case plVarDescriptor::kRGB8:
if (!IConvertFromRGB8(newType))
return false;
break;
// FROM RGBA8
case plVarDescriptor::kRGBA8:
if (!IConvertFromRGBA8(newType))
return false;
break;
// FROM INT
case plVarDescriptor::kInt:
if (!IConvertFromInt(newType))
return false;
break;
// FROM SHORT
case plVarDescriptor::kShort:
if (!IConvertFromShort(newType))
return false;
break;
// FROM Byte
case plVarDescriptor::kByte:
if (!IConvertFromByte(newType))
return false;
break;
// FROM FLOAT
case plVarDescriptor::kFloat:
if (!IConvertFromFloat(newType))
return false;
break;
// FROM DOUBLE
case plVarDescriptor::kDouble:
if (!IConvertFromDouble(newType))
return false;
break;
// FROM BOOL
case plVarDescriptor::kBool:
if (!IConvertFromBool(newType))
return false;
break;
// FROM STRING32
case plVarDescriptor::kString32:
if (!IConvertFromString(newType))
return false;
break;
default:
return false; // err
}
// match types now
fVar.SetType(toVar->GetType());
fVar.SetAtomicType(toVar->GetAtomicType());
return true; // ok
}
/////////////////////////////////////////////////////////////
// SETTERS
/////////////////////////////////////////////////////////////
bool plSimpleStateVariable::Set(float v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kAgeTimeOfDay)
{
hsAssert(false, "AgeTime variables are read-only, can't set");
}
else
if (fVar.GetType()==plVarDescriptor::kFloat)
{
fF[idx]=v;
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Set(double v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kDouble)
{
fD[idx]=v;
IVarSet();
return true;
}
if (fVar.GetType()==plVarDescriptor::kTime)
{ // convert from,
fT[idx].SetFromGameTime(v, hsTimer::GetSysSeconds());
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
// floatvector
bool plSimpleStateVariable::Set(float* v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kAgeTimeOfDay)
{
hsAssert(false, "AgeTime variables are read-only, can't set");
}
else
if (fVar.GetAtomicType()==plVarDescriptor::kFloat)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
fF[cnt+i]=v[i];
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
// bytevector
bool plSimpleStateVariable::Set(byte* v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kByte)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
fBy[cnt+i]=v[i];
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
//
bool plSimpleStateVariable::Set(double* v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kDouble)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
fD[cnt+i]=v[i];
IVarSet();
return true;
}
if (fVar.GetAtomicType()==plVarDescriptor::kTime)
{
double secs=hsTimer::GetSysSeconds();
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
fT[cnt+i].SetFromGameTime(v[i], secs);
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Set(int v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kInt)
{
fI[idx]=v;
IVarSet();
return true;
}
else
if (fVar.GetType()==plVarDescriptor::kBool)
return Set((bool)(v?true:false), idx); // since 'true' is coming in as an int not bool
else
if (fVar.GetType()==plVarDescriptor::kShort)
return Set((short)v, idx);
else
if (fVar.GetType()==plVarDescriptor::kByte)
return Set((byte)v, idx);
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Set(short v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kShort)
{
fS[idx]=v;
IVarSet();
return true;
}
else
if (fVar.GetType()==plVarDescriptor::kInt)
return Set((int)v, idx);
else
if (fVar.GetType()==plVarDescriptor::kByte)
return Set((byte)v, idx);
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Set(byte v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kByte)
{
fBy[idx]=v;
IVarSet();
return true;
}
else
if (fVar.GetType()==plVarDescriptor::kBool)
return Set((bool)(v?true:false), idx);
else
if (fVar.GetType()==plVarDescriptor::kInt)
return Set((int)v, idx);
else
if (fVar.GetType()==plVarDescriptor::kShort)
return Set((short)v, idx);
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Set(const char* v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (v && fVar.GetType()==plVarDescriptor::kString32)
{
hsAssert(hsStrlen(v)<32, "string length overflow");
hsStrncpy(fS32[idx], v, 32);
IVarSet();
return true;
}
hsAssert(false, v ? "passing wrong value type to SDL variable" : "trying to set nil string");
return false;
}
bool plSimpleStateVariable::Set(bool v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kBool)
{
fB[idx]=v;
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Set(const plKey& v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kKey)
{
if(v)
{
fU[idx] = v->GetUoid();
}
else
{
fU[idx] = plUoid();
}
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Set(plCreatable* v, int idx)
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kCreatable)
{
// copy creatable via stream
hsRAMStream stream;
if(v)
{
hsgResMgr::ResMgr()->WriteCreatable(&stream, v);
stream.Rewind();
}
plCreatable* copy = v ? hsgResMgr::ResMgr()->ReadCreatable(&stream): nil;
hsAssert(!v || copy, "failed to create creatable copy");
fC[idx]=copy;
IVarSet();
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
/////////////////////////////////////////////////////////////
// GETTERS
/////////////////////////////////////////////////////////////
bool plSimpleStateVariable::Get(int* value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kInt)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fI[cnt+i];
return true;
}
if (fVar.GetAtomicType()==plVarDescriptor::kShort)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fS[cnt+i];
return true;
}
if (fVar.GetAtomicType()==plVarDescriptor::kByte)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fBy[cnt+i];
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Get(short* value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kShort)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fS[cnt+i];
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Get(byte* value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kByte)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fBy[cnt+i];
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
// float or floatVector
bool plSimpleStateVariable::Get(float* value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kAgeTimeOfDay)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
{
if (plNetClientApp::GetInstance())
fF[cnt+i] = plNetClientApp::GetInstance()->GetCurrentAgeTimeOfDayPercent();
value[i]=fF[cnt+i];
}
return true;
}
if (fVar.GetAtomicType()==plVarDescriptor::kFloat)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fF[cnt+i];
return true;
}
if (fVar.GetAtomicType()==plVarDescriptor::kDouble)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=(float)fD[cnt+i];
return true;
}
if (fVar.GetAtomicType()==plVarDescriptor::kTime) // && fIsUsed)
{
double secs=hsTimer::GetSysSeconds();
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
{
double tmp;
fT[cnt+i].ConvertToGameTime(&tmp, secs);
value[i] = (float)tmp;
}
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
// double
bool plSimpleStateVariable::Get(double* value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kDouble)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fD[cnt+i];
return true;
}
if (fVar.GetAtomicType()==plVarDescriptor::kTime)
{
double secs=hsTimer::GetSysSeconds();
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
fT[cnt+i].ConvertToGameTime(&value[i], secs);
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Get(bool* value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kBool)
{
int i;
int cnt=fVar.GetAtomicCount()*idx;
for(i=0;i<fVar.GetAtomicCount();i++)
value[i]=fB[cnt+i];
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Get(plKey* value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kKey)
{
if(!(fU[idx] == plUoid())) // compare to default "nil uoid"
{
*value = hsgResMgr::ResMgr()->FindKey(fU[idx]);
if (*value)
{
const plUoid& newUoid = (*value)->GetUoid();
if (stricmp(newUoid.GetObjectName(), fU[idx].GetObjectName()) != 0)
{
// uoid names don't match... chances are the key changed in the local data after the key was written to the sdl
// do a search by name, which takes longer, to get the correct key
std::vector<plKey> foundKeys;
plKeyFinder::Instance().ReallyStupidSubstringSearch(fU[idx].GetObjectName(), fU[idx].GetClassType(), foundKeys, fU[idx].GetLocation());
// not really sure what we can do if it finds MORE then one (they are supposed to be unique names), so just grab the
// first one and return it
if (foundKeys.size() >= 1)
*value = foundKeys[0];
else
*value = nil;
}
}
} else {
*value = nil;
}
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Get(char value[], int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetType()==plVarDescriptor::kString32)
{
hsStrcpy(value, fS32[idx]);
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
bool plSimpleStateVariable::Get(plCreatable** value, int idx) const
{
VALIDATE_WITH_FALSE_RETURN(idx < fVar.GetCount());
if (fVar.GetAtomicType()==plVarDescriptor::kCreatable)
{
*value = nil;
plCreatable* v = fC[idx];
if (v)
{
*value = plFactory::Create(v->ClassIndex());
hsAssert(*value, "failed to create creatable copy");
hsRAMStream stream;
v->Write(&stream, hsgResMgr::ResMgr());
stream.Rewind();
(*value)->Read(&stream, hsgResMgr::ResMgr());
}
return true;
}
hsAssert(false, "passing wrong value type to SDL variable");
return false;
}
/////////////////////////////////////////////////////////////
const char* plSimpleStateVariable::GetKeyName(int idx) const
{
if (fVar.GetAtomicType()==plVarDescriptor::kKey)
{
if(!(fU[idx] == plUoid())) // compare to default "nil uoid"
{
return fU[idx].GetObjectName();
}
}
hsAssert(false, "passing wrong value type to SDL variable");
return "(nil)";
}
#pragma optimize( "g", off ) // disable float optimizations
bool plSimpleStateVariable::IWriteData(hsStream* s, float timeConvert, int idx, UInt32 writeOptions) const
{
#ifdef HS_DEBUGGING
if (!IsUsed())
{
// hsAssert(false, "plSimpleStateVariable::WriteData doesn't contain data?");
plNetApp::StaticWarningMsg("plSimpleStateVariable::WriteData Var %s doesn't contain data?",
GetName());
}
#endif
int j=idx*fVar.GetAtomicCount();
int i;
switch(fVar.GetAtomicType())
{
case plVarDescriptor::kAgeTimeOfDay:
// don't need to write out ageTime, since it's computed on the fly when Get is called
break;
case plVarDescriptor::kInt:
for(i=0;i<fVar.GetAtomicCount();i++)
s->WriteSwap32(fI[j+i]);
break;
case plVarDescriptor::kShort:
for(i=0;i<fVar.GetAtomicCount();i++)
s->WriteSwap16(fS[j+i]);
break;
case plVarDescriptor::kByte:
for(i=0;i<fVar.GetAtomicCount();i++)
s->WriteByte(fBy[j+i]);
break;
case plVarDescriptor::kFloat:
for(i=0;i<fVar.GetAtomicCount();i++)
s->WriteSwapScalar(fF[j+i]);
break;
case plVarDescriptor::kTime:
for(i=0;i<fVar.GetAtomicCount();i++)
{
if (timeConvert != 0.0)
{
double utDouble=fT[j+i].GetSecsDouble();
hsDoublePrecBegin
utDouble += timeConvert;
hsDoublePrecEnd
plUnifiedTime ut(utDouble);
ut.Write(s);
}
else
fT[j+i].Write(s);
}
break;
case plVarDescriptor::kDouble:
for(i=0;i<fVar.GetAtomicCount();i++)
s->WriteSwapDouble(fD[j+i]);
break;
case plVarDescriptor::kBool:
for(i=0;i<fVar.GetAtomicCount();i++)
s->Writebool(fB[j+i]);
break;
case plVarDescriptor::kKey:
for(i=0;i<fVar.GetAtomicCount();i++)
fU[j+i].Write(s);
break;
case plVarDescriptor::kString32:
for(i=0;i<fVar.GetAtomicCount();i++)
s->Write(32, fS32[j+i]);
break;
case plVarDescriptor::kCreatable:
{
hsAssert(fVar.GetAtomicCount()==1, "invalid atomic count");
plCreatable* cre = fC[j];
s->WriteSwap16(cre ? cre->ClassIndex() : 0x8000); // creatable class index
if (cre)
{
hsRAMStream ramStream;
cre->Write(&ramStream, hsgResMgr::ResMgr());
s->WriteSwap32(ramStream.GetEOF()); // write length
cre->Write(s, hsgResMgr::ResMgr()); // write data
}
}
break;
}
return true;
}
bool plSimpleStateVariable::IReadData(hsStream* s, float timeConvert, int idx, UInt32 readOptions)
{
int j=idx*fVar.GetAtomicCount();
int i;
switch(fVar.GetAtomicType())
{
case plVarDescriptor::kAgeTimeOfDay:
// don't need to read in ageTime, since it's computed on the fly when Get is called
break;
case plVarDescriptor::kInt:
for(i=0;i<fVar.GetAtomicCount();i++)
fI[j+i]=s->ReadSwap32();
break;
case plVarDescriptor::kShort:
for(i=0;i<fVar.GetAtomicCount();i++)
fS[j+i]=s->ReadSwap16();
break;
case plVarDescriptor::kByte:
for(i=0;i<fVar.GetAtomicCount();i++)
fBy[j+i]=s->ReadByte();
break;
case plVarDescriptor::kFloat:
for(i=0;i<fVar.GetAtomicCount();i++)
fF[j+i]=s->ReadSwapScalar();
break;
case plVarDescriptor::kTime:
for(i=0;i<fVar.GetAtomicCount();i++)
{
fT[j+i].Read(s);
if (timeConvert != 0.0)
{
hsDoublePrecBegin
double newUt = (fT[j+i].GetSecsDouble() + timeConvert);
hsDoublePrecEnd
hsAssert(newUt>=0, "negative unified time");
fT[j+i].SetSecsDouble(newUt);
}
}
break;
case plVarDescriptor::kDouble:
for(i=0;i<fVar.GetAtomicCount();i++)
fD[j+i]=s->ReadSwapDouble();
break;
case plVarDescriptor::kBool:
for(i=0;i<fVar.GetAtomicCount();i++)
fB[j+i]=s->Readbool();
break;
case plVarDescriptor::kKey:
for(i=0;i<fVar.GetAtomicCount();i++)
{
fU[j+i].Invalidate();
fU[j+i].Read(s);
}
break;
case plVarDescriptor::kString32:
for(i=0;i<fVar.GetAtomicCount();i++)
s->Read(32, fS32[j+i]);
break;
case plVarDescriptor::kCreatable:
{
hsAssert(fVar.GetAtomicCount()==1, "invalid atomic count");
UInt16 hClass = s->ReadSwap16(); // class index
if (hClass != 0x8000)
{
UInt32 len = s->ReadSwap32(); // length
if (plFactory::CanCreate(hClass))
{
delete fC[j];
fC[j] = plFactory::Create(hClass);
}
else
{
plSDLCreatableStub* stub = TRACKED_NEW plSDLCreatableStub(hClass, len);
fC[j] = stub;
}
fC[j]->Read(s, hsgResMgr::ResMgr()); // data
}
}
break;
default:
hsAssert(false, "invalid atomic type");
return false;
}
return true;
}
#pragma optimize( "", on ) // restore optimizations to their defaults
bool plSimpleStateVariable::WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const
{
#ifdef HS_DEBUGGING
if (!IsUsed())
{
// hsAssert(false, "plSimpleStateVariable::WriteData Var doesn't contain data?");
plNetApp::StaticWarningMsg("plSimpleStateVariable::WriteData Var %s doesn't contain data?",
GetName());
}
#endif
// write base class data
plStateVariable::WriteData(s, timeConvert, writeOptions);
// check if the same as default
bool sameAsDefaults=false;
if (!GetVarDescriptor()->IsVariableLength())
{
plSimpleStateVariable def;
def.fVar.CopyFrom(&fVar); // copy descriptor
def.Alloc(); // and rest
def.SetFromDefaults(false /* timeStamp */); // may do nothing if nor default
sameAsDefaults = (def == *this);
}
bool writeTimeStamps = (writeOptions & plSDL::kWriteTimeStamps)!=0;
bool writeDirtyFlags = (writeOptions & plSDL::kDontWriteDirtyFlag)==0;
bool forceDirtyFlags = (writeOptions & plSDL::kMakeDirty)!=0;
bool wantTimeStamp = (writeOptions & plSDL::kTimeStampOnRead)!=0;
bool needTimeStamp = (writeOptions & plSDL::kTimeStampOnWrite)!=0;
forceDirtyFlags = forceDirtyFlags || (!sameAsDefaults && (writeOptions & plSDL::kDirtyNonDefaults)!=0);
// write save flags
UInt8 saveFlags = 0;
saveFlags |= writeTimeStamps ? plSDL::kHasTimeStamp : 0;
saveFlags |= forceDirtyFlags || (writeDirtyFlags && IsDirty()) ? plSDL::kHasDirtyFlag : 0;
saveFlags |= wantTimeStamp ? plSDL::kWantTimeStamp : 0;
saveFlags |= needTimeStamp ? plSDL::kHasTimeStamp : 0;
if (sameAsDefaults)
saveFlags |= plSDL::kSameAsDefault;
s->WriteSwap(saveFlags);
if (needTimeStamp) {
// timestamp on write
fTimeStamp.ToCurrentTime();
fTimeStamp.Write(s);
}
else if (writeTimeStamps) {
// write time stamps
fTimeStamp.Write(s);
}
// write var data
if (!sameAsDefaults)
{
// list size
if (GetVarDescriptor()->IsVariableLength())
s->WriteSwap32(GetVarDescriptor()->GetCount()); // have to write out as long since we don't know how big the list is
// list
int i;
for(i=0;i<fVar.GetCount();i++)
if (!IWriteData(s, timeConvert, i, writeOptions))
return false;
}
return true;
}
// assumes var is created from the right type of descriptor (count, type, etc.)
bool plSimpleStateVariable::ReadData(hsStream* s, float timeConvert, UInt32 readOptions)
{
// read base class data
plStateVariable::ReadData(s, timeConvert, readOptions);
plUnifiedTime ut;
ut.ToEpoch();
UInt8 saveFlags;
s->ReadSwap(&saveFlags);
bool isDirty = ( saveFlags & plSDL::kHasDirtyFlag )!=0;
bool setDirty = ( isDirty && ( readOptions & plSDL::kKeepDirty ) ) || ( readOptions & plSDL::kMakeDirty );
bool wantTimestamp = isDirty &&
plSDLMgr::GetInstance()->AllowTimeStamping() &&
( ( saveFlags & plSDL::kWantTimeStamp ) ||
( readOptions & plSDL::kTimeStampOnRead ) );
if (saveFlags & plSDL::kHasTimeStamp)
ut.Read(s);
else if ( wantTimestamp )
ut.ToCurrentTime();
if (!(saveFlags & plSDL::kSameAsDefault))
{
setDirty = setDirty || ( readOptions & plSDL::kDirtyNonDefaults )!=0;
// read list size
if (GetVarDescriptor()->IsVariableLength())
{
UInt32 cnt;
s->ReadSwap(&cnt); // have to read as long since we don't know how big the list is
if (cnt>=0 && cnt<plSDL::kMaxListSize)
fVar.SetCount(cnt);
else
return false;
Alloc(); // alloc after setting count
}
else
{
hsAssert(fVar.GetCount(), "empty var?");
}
}
// compare timestamps
if (fTimeStamp > ut)
return true;
if ( (saveFlags & plSDL::kHasTimeStamp) || (readOptions & plSDL::kTimeStampOnRead) )
TimeStamp(ut);
// read list
if (!(saveFlags & plSDL::kSameAsDefault))
{
int i;
for(i=0;i<fVar.GetCount();i++)
if (!IReadData(s, timeConvert, i, readOptions))
return false;
}
else
{
Reset();
SetFromDefaults(false);
}
SetUsed( true );
SetDirty( setDirty );
return true;
}
void plSimpleStateVariable::CopyData(const plSimpleStateVariable* other, UInt32 writeOptions/*=0*/)
{
// use stream as a medium
hsRAMStream stream;
other->WriteData(&stream, 0, writeOptions);
stream.Rewind();
ReadData(&stream, 0, writeOptions);
}
//
// send notification msg if necessary, called internally
//
#define NOTIFY_CHECK(type, var) \
case type: \
for(i=0;i<cnt;i++) \
if (hsABS(var[i] - other->var[i])>d) \
{ \
notify=true; \
break; \
} \
break;
void plSimpleStateVariable::NotifyStateChange(const plSimpleStateVariable* other, const char* sdlName)
{
if (fChangeNotifiers.size()==0)
return;
bool different=!(*this == *other);
bool notify=false;
int numNotifiers=0;
if (different)
{
StateChangeNotifiers::iterator it=fChangeNotifiers.begin();
for( ; it!=fChangeNotifiers.end(); it++)
{
float d=(*it).fDelta;
if (d==0 && different) // delta of 0 means notify on any change
{
notify=true;
}
else
{
int i;
int cnt = fVar.GetAtomicCount()*fVar.GetCount();
switch(fVar.GetAtomicType())
{
NOTIFY_CHECK(plVarDescriptor::kInt, fI)
NOTIFY_CHECK(plVarDescriptor::kShort, fS)
NOTIFY_CHECK(plVarDescriptor::kByte, fBy)
NOTIFY_CHECK(plVarDescriptor::kFloat, fF)
NOTIFY_CHECK(plVarDescriptor::kDouble, fD)
}
}
if (notify)
{
numNotifiers += (*it).fKeys.size();
(*it).SendNotificationMsg(other /* src */, this /* dst */, sdlName);
}
}
}
if (plNetObjectDebuggerBase::GetInstance() && plNetObjectDebuggerBase::GetInstance()->GetDebugging())
{
plNetObjectDebuggerBase::GetInstance()->LogMsg(
xtl::format("Var %s did %s send notification difference. Has %d notifiers with %d recipients.",
GetName(), !notify ? "NOT" : "", fChangeNotifiers.size(), numNotifiers).c_str());
}
}
//
// Checks to see if data contents are the same on two matching vars.
//
#define EQ_CHECK(type, var) \
case type: \
for(i=0;i<cnt;i++) \
if (var[i]!=other.var[i]) \
return false; \
break;
bool plSimpleStateVariable::operator==(const plSimpleStateVariable &other) const
{
hsAssert(fVar.GetType() == other.GetVarDescriptor()->GetType(), "type mismatch in equality check");
hsAssert(fVar.GetAtomicCount() == other.GetVarDescriptor()->GetAsSimpleVarDescriptor()->GetAtomicCount(),
"atomic cnt mismatch in equality check");
if (GetCount() != other.GetCount())
return false;
int i;
int cnt = fVar.GetAtomicCount()*fVar.GetCount();
switch(fVar.GetAtomicType())
{
EQ_CHECK(plVarDescriptor::kAgeTimeOfDay, fF)
EQ_CHECK(plVarDescriptor::kInt, fI)
EQ_CHECK(plVarDescriptor::kFloat, fF)
EQ_CHECK(plVarDescriptor::kTime, fT)
EQ_CHECK(plVarDescriptor::kDouble, fD)
EQ_CHECK(plVarDescriptor::kBool, fB)
EQ_CHECK(plVarDescriptor::kKey, fU)
EQ_CHECK(plVarDescriptor::kCreatable, fC)
EQ_CHECK(plVarDescriptor::kShort, fS)
EQ_CHECK(plVarDescriptor::kByte, fBy)
case plVarDescriptor::kString32:
for(i=0;i<cnt;i++)
if (stricmp(fS32[i],other.fS32[i]))
return false;
break;
default:
hsAssert(false, "invalid atomic type");
return false;
break;
}
return true;
}
//
// Add and coalate
//
void plSimpleStateVariable::AddStateChangeNotification(plStateChangeNotifier& n)
{
StateChangeNotifiers::iterator it=fChangeNotifiers.begin();
for( ; it != fChangeNotifiers.end(); it++)
{
if ((*it).fDelta==n.fDelta)
{
// merged into an existing entry
(*it).AddNotificationKeys(n.fKeys);
return;
}
}
// add new entry
fChangeNotifiers.push_back(n);
}
//
// remove entries with this key
//
void plSimpleStateVariable::RemoveStateChangeNotification(plKey notificationObj)
{
StateChangeNotifiers::iterator it=fChangeNotifiers.end();
for(; it != fChangeNotifiers.begin();)
{
it--;
int size=(*it).RemoveNotificationKey(notificationObj);
if (size==0)
it=fChangeNotifiers.erase(it); // iterator is moved to item after this one
}
}
//
// remove entries which match
//
void plSimpleStateVariable::RemoveStateChangeNotification(plStateChangeNotifier n)
{
StateChangeNotifiers::iterator it=fChangeNotifiers.end();
for(; it != fChangeNotifiers.begin();)
{
it--;
if ( (*it).fDelta==n.fDelta)
{
int size=(*it).RemoveNotificationKeys(n.fKeys);
if (size==0)
it=fChangeNotifiers.erase(it); // iterator is moved to item after this one
}
}
}
//
//
//
void plSimpleStateVariable::DumpToObjectDebugger(bool dirtyOnly, int level) const
{
plNetObjectDebuggerBase* dbg = plNetObjectDebuggerBase::GetInstance();
if (!dbg)
return;
std::string pad;
int i;
for(i=0;i<level; i++)
pad += " ";
std::string logMsg = xtl::format( "%sSimpleVar, name:%s[%d]", pad.c_str(), GetName(), GetCount());
if (GetCount()>1)
{
dbg->LogMsg(logMsg.c_str()); // it's going to be a long msg, so print it on its own line
logMsg = "";
}
pad += "\t";
for(i=0;i<GetCount(); i++)
{
char* s=GetAsString(i);
if (fVar.GetAtomicType() == plVarDescriptor::kTime)
{
const char* p=fT[i].PrintWMillis();
logMsg += xtl::format( "%sVar:%d gameTime:%s pst:%s ts:%s",
pad.c_str(), i, s ? s : "?", p, fTimeStamp.Format("%c").c_str() );
}
else
{
logMsg +=xtl::format( "%sVar:%d value:%s ts:%s",
pad.c_str(), i, s ? s : "?", fTimeStamp.AtEpoch() ? "0" : fTimeStamp.Format("%c").c_str() );
}
delete [] s;
if ( !dirtyOnly )
logMsg += xtl::format( " dirty:%d", IsDirty() );
dbg->LogMsg(logMsg.c_str());
logMsg = "";
}
}
void plSimpleStateVariable::DumpToStream(hsStream* stream, bool dirtyOnly, int level) const
{
std::string pad;
int i;
for(i=0;i<level; i++)
pad += " ";
std::string logMsg = xtl::format( "%sSimpleVar, name:%s[%d]", pad.c_str(), GetName(), GetCount());
if (GetCount()>1)
{
stream->WriteString(logMsg.c_str()); // it's going to be a long msg, so print it on its own line
logMsg = "";
}
pad += "\t";
for(i=0;i<GetCount(); i++)
{
char* s=GetAsString(i);
if (fVar.GetAtomicType() == plVarDescriptor::kTime)
{
const char* p=fT[i].PrintWMillis();
logMsg += xtl::format( "%sVar:%d gameTime:%s pst:%s ts:%s",
pad.c_str(), i, s ? s : "?", p, fTimeStamp.Format("%c").c_str() );
}
else
{
logMsg +=xtl::format( "%sVar:%d value:%s ts:%s",
pad.c_str(), i, s ? s : "?", fTimeStamp.AtEpoch() ? "0" : fTimeStamp.Format("%c").c_str() );
}
delete [] s;
if ( !dirtyOnly )
logMsg += xtl::format( " dirty:%d", IsDirty() );
stream->WriteString(logMsg.c_str());
logMsg = "";
}
}
//
// set var to its defalt value
//
void plSimpleStateVariable::SetFromDefaults(bool timeStampNow)
{
int i;
for(i=0;i<GetCount();i++)
SetFromString(GetVarDescriptor()->GetDefault(), i, timeStampNow);
}
///////////////////////////////////////////////////////////////////////////////
// plSDStateVariable
///////////////////////////////////////////////////////////////////////////////
plSDStateVariable::plSDStateVariable(plSDVarDescriptor* sdvd) : fVarDescriptor(nil)
{
Alloc(sdvd);
}
plSDStateVariable::~plSDStateVariable()
{
IDeInit();
}
//
// resize the array of state data records
//
void plSDStateVariable::Resize(int cnt)
{
int origCnt=GetCount();
// when sending, this is always freshly allocated. if you then set it to zero,
// the change won't be sent, even though the version on the server might not be zero
// for now, we're just not going to do this optimization
// we could, however, change it to (origCnt==cnt==0), because for sizes other
// than zero the bug won't happen
// if (origCnt==cnt)
// return; // no work to do
// shrinking
if (cnt<origCnt)
{
int i;
for(i=cnt;i<origCnt;i++)
delete fDataRecList[i];
}
fDataRecList.resize(cnt);
// growing
if (cnt>origCnt)
{
int i;
for(i=origCnt;i<cnt;i++)
fDataRecList[i] = TRACKED_NEW plStateDataRecord(fVarDescriptor->GetStateDescriptor());
}
SetDirty(true);
SetUsed(true);
}
//
// create/allocate data records based on the given SDVarDesc
//
void plSDStateVariable::Alloc(plSDVarDescriptor* sdvd, int listSize)
{
if (sdvd==fVarDescriptor)
{
// trick to not have to delete and recreate fVarDescriptor
fVarDescriptor=nil;
IDeInit();
fVarDescriptor=sdvd;
}
else
IDeInit(); // will delete fVarDescriptor
if (sdvd)
{
if (fVarDescriptor==nil)
{
fVarDescriptor = TRACKED_NEW plSDVarDescriptor;
fVarDescriptor->CopyFrom(sdvd);
}
int cnt = listSize==-1 ? sdvd->GetCount() : listSize;
fDataRecList.resize(cnt);
int j;
for (j=0;j<cnt; j++)
InsertStateDataRecord(TRACKED_NEW plStateDataRecord(sdvd->GetStateDescriptor()), j);
}
}
//
// help alloc fxn
//
void plSDStateVariable::Alloc(int listSize)
{
Alloc(fVarDescriptor, listSize);
}
//
// delete all records
//
void plSDStateVariable::IDeInit()
{
DataRecList::iterator it;
for (it=fDataRecList.begin(); it != fDataRecList.end(); it++)
delete *it;
fDataRecList.clear();
delete fVarDescriptor;
fVarDescriptor=nil;
}
//
// Make 'this' into a copy of 'other'.
//
void plSDStateVariable::CopyFrom(plSDStateVariable* other, UInt32 writeOptions/*=0*/)
{
// IDeInit();
Alloc(other->GetSDVarDescriptor(), other->GetCount());
int i;
for(i=0; i<other->GetCount(); i++)
fDataRecList[i]->CopyFrom(*other->GetStateDataRecord(i),writeOptions);
}
//
// Find the data items which are dirty in 'other' and
// copy them to my corresponding item.
// Requires that records have the same descriptor.
//
void plSDStateVariable::UpdateFrom(plSDStateVariable* other, UInt32 writeOptions/*=0*/)
{
hsAssert(!stricmp(other->GetSDVarDescriptor()->GetName(), fVarDescriptor->GetName()),
xtl::format("var descriptor mismatch in UpdateFrom, name %s,%s ver %d,%d",
GetName(), other->GetName()).c_str());
Resize(other->GetCount()); // make sure sizes match
bool dirtyOnly = (writeOptions & plSDL::kDirtyOnly);
int i;
for(i=0; i<other->GetCount(); i++)
{
if ( (dirtyOnly && other->GetStateDataRecord(i)->IsDirty()) ||
(!dirtyOnly &&other->GetStateDataRecord(i)->IsUsed()) )
fDataRecList[i]->UpdateFrom(*other->GetStateDataRecord(i), writeOptions);
}
}
//
// Convert all my stateDataRecords to the type defined by the 'other var'
//
void plSDStateVariable::ConvertTo(plSDStateVariable* otherSDVar, bool force )
{
plStateDescriptor* otherSD=otherSDVar->GetSDVarDescriptor()->GetStateDescriptor();
hsLogEntry( plNetApp::StaticDebugMsg( "SDSV(%p) converting %s from %s to %s (force:%d)",
this, fVarDescriptor->GetName(), fVarDescriptor->GetTypeString(),
otherSDVar->GetSDVarDescriptor()->GetTypeString(), force ) );
int j;
for(j=0;j<GetCount(); j++)
{
GetStateDataRecord(j)->ConvertTo( otherSD, force );
}
}
bool plSDStateVariable::IsDirty() const
{
if (plStateVariable::IsDirty())
return true;
int j;
for(j=0;j<GetCount(); j++)
if (GetStateDataRecord(j)->IsDirty())
return true;
return false;
}
int plSDStateVariable::GetDirtyCount() const
{
int cnt=0;
int j;
for(j=0;j<GetCount(); j++)
if (GetStateDataRecord(j)->IsDirty())
cnt++;
return cnt;
}
bool plSDStateVariable::IsUsed() const
{
if (plStateVariable::IsUsed())
return true;
int j;
for(j=0;j<GetCount(); j++)
if (GetStateDataRecord(j)->IsUsed())
return true;
return false;
}
int plSDStateVariable::GetUsedCount() const
{
int cnt=0;
int j;
for(j=0;j<GetCount(); j++)
if (GetStateDataRecord(j)->IsUsed())
cnt++;
return cnt;
}
void plSDStateVariable::GetUsedDataRecords(ConstDataRecList* recList) const
{
recList->clear();
int j;
for(j=0;j<GetCount(); j++)
if (GetStateDataRecord(j)->IsUsed())
recList->push_back(GetStateDataRecord(j));
}
void plSDStateVariable::GetDirtyDataRecords(ConstDataRecList* recList) const
{
recList->clear();
int j;
for(j=0;j<GetCount(); j++)
if (GetStateDataRecord(j)->IsDirty())
recList->push_back(GetStateDataRecord(j));
}
//
// read all SDVars
//
bool plSDStateVariable::ReadData(hsStream* s, float timeConvert, UInt32 readOptions)
{
plStateVariable::ReadData(s, timeConvert, readOptions);
UInt8 saveFlags;
s->ReadSwap(&saveFlags); // unused
// read total list size
if (GetVarDescriptor()->IsVariableLength())
{
UInt32 total;
s->ReadSwap(&total);
Resize(total);
}
// read dirty list size
int cnt;
plSDL::VariableLengthRead(s,
GetVarDescriptor()->IsVariableLength() ? 0xffffffff : GetVarDescriptor()->GetCount(), &cnt);
// if we are reading the entire list in, then we don't need to read each index
bool all = (cnt==fDataRecList.size());
// read list
int i;
for(i=0;i<cnt; i++)
{
int idx;
if (!all)
plSDL::VariableLengthRead(s,
GetVarDescriptor()->IsVariableLength() ? 0xffffffff : GetVarDescriptor()->GetCount(), &idx);
else
idx=i;
if (idx<fDataRecList.size())
fDataRecList[idx]->Read(s, timeConvert, readOptions);
else
return false;
}
return true;
}
//
// write all SDVars
//
bool plSDStateVariable::WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const
{
plStateVariable::WriteData(s, timeConvert, writeOptions);
UInt8 saveFlags=0; // unused
s->WriteSwap(saveFlags);
// write total list size
UInt32 total=GetCount();
if (GetVarDescriptor()->IsVariableLength())
s->WriteSwap(total);
// write dirty list size
bool dirtyOnly = (writeOptions & plSDL::kDirtyOnly) != 0;
int writeCnt = dirtyOnly ? GetDirtyCount() : GetUsedCount();
plSDL::VariableLengthWrite(s,
GetVarDescriptor()->IsVariableLength() ? 0xffffffff : GetVarDescriptor()->GetCount(), writeCnt);
// if we are writing the entire list in, then we don't need to read each index
bool all = (writeCnt==fDataRecList.size());
// write list
int i, written=0;
for(i=0;i<total;i++)
{
if ( (dirtyOnly && fDataRecList[i]->IsDirty()) ||
(!dirtyOnly && fDataRecList[i]->IsUsed()) )
{
if (!all)
plSDL::VariableLengthWrite(s,
GetVarDescriptor()->IsVariableLength() ? 0xffffffff : GetVarDescriptor()->GetCount(), i); // idx
fDataRecList[i]->Write(s, timeConvert, dirtyOnly); // item
written++;
}
}
hsAssert(writeCnt==written, "write mismatch");
return true;
}
//
//
//
void plSDStateVariable::DumpToObjectDebugger(bool dirtyOnly, int level) const
{
plNetObjectDebuggerBase* dbg = plNetObjectDebuggerBase::GetInstance();
if (!dbg)
return;
std::string pad;
int i;
for(i=0;i<level; i++)
pad += " ";
int cnt = dirtyOnly ? GetDirtyCount() : GetUsedCount();
dbg->LogMsg(xtl::format( "%sSDVar, name:%s dirtyOnly:%d count:%d",
pad.c_str(), GetName(), dirtyOnly, cnt).c_str());
for(i=0;i<GetCount();i++)
{
if ( (dirtyOnly && fDataRecList[i]->IsDirty()) ||
(!dirtyOnly && fDataRecList[i]->IsUsed()) )
{
fDataRecList[i]->DumpToObjectDebugger(nil, dirtyOnly, level+1);
}
}
}
void plSDStateVariable::DumpToStream(hsStream* stream, bool dirtyOnly, int level) const
{
std::string pad;
int i;
for(i=0;i<level; i++)
pad += " ";
int cnt = dirtyOnly ? GetDirtyCount() : GetUsedCount();
stream->WriteString(xtl::format( "%sSDVar, name:%s dirtyOnly:%d count:%d",
pad.c_str(), GetName(), dirtyOnly, cnt).c_str());
for(i=0;i<GetCount();i++)
{
if ( (dirtyOnly && fDataRecList[i]->IsDirty()) ||
(!dirtyOnly && fDataRecList[i]->IsUsed()) )
{
fDataRecList[i]->DumpToStream(stream, nil, dirtyOnly, level+1);
}
}
}
//
// Checks to see if data contents are the same on two matching vars.
//
bool plSDStateVariable::operator==(const plSDStateVariable &other) const
{
hsAssert(GetSDVarDescriptor()->GetStateDescriptor() == other.GetSDVarDescriptor()->GetStateDescriptor(),
"SD var descriptor mismatch in equality check");
if (GetCount() != other.GetCount())
return false; // different list sizes
int i;
for(i=0;i<GetCount(); i++)
{
if (! (*GetStateDataRecord(i) == *other.GetStateDataRecord(i)))
return false;
}
return true;
}
void plSDStateVariable::SetFromDefaults(bool timeStampNow)
{
int i;
for(i=0;i<GetCount(); i++)
GetStateDataRecord(i)->SetFromDefaults(timeStampNow);
}
void plSDStateVariable::TimeStamp( const plUnifiedTime & ut/*=plUnifiedTime::GetCurrentTime()*/ )
{
hsAssert( false, "not impl" );
}
void plSDStateVariable::FlagNewerState(const plSDStateVariable& other, bool respectAlwaysNew)
{
int i;
for(i=0;i<GetCount(); i++)
GetStateDataRecord(i)->FlagNewerState(*other.GetStateDataRecord(i), respectAlwaysNew);
}
void plSDStateVariable::FlagAlwaysNewState()
{
int i;
for(i=0;i<GetCount(); i++)
GetStateDataRecord(i)->FlagAlwaysNewState();
}