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.

405 lines
8.9 KiB

/*==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/>.
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 "hsStream.h"
#include "plSDL.h"
#include "hsStlUtils.h"
#include "pnKeyedObject/plUoid.h"
#include "pnNetCommon/plNetApp.h"
#include "pnMessage/plMessage.h"
#include "plUnifiedTime/plUnifiedTime.h"
const UInt8 plVarDescriptor::kVersion=3; // for Read/Write format
/////////////////////////////////////////////////////////////////////////////////
// State Var
/////////////////////////////////////////////////////////////////////////////////
plVarDescriptor::plVarDescriptor() :
fName(nil),
fCount(1),
fType(kNone),
fTypeString(nil),
fDefault(nil),
fFlags(0)
{
}
plVarDescriptor::~plVarDescriptor()
{
delete [] fName;
delete [] fDefault;
delete [] fTypeString;
}
//
// Set type from a string. Return false on err.
//
bool plVarDescriptor::SetType(const char* type)
{
if (!type)
return false;
if (!stricmp(type, "vector3"))
fType=kVector3;
else
if (!stricmp(type, "point3"))
fType=kPoint3;
else
if (!stricmp(type, "rgb"))
fType=kRGB;
else
if (!stricmp(type, "rgba"))
fType=kRGBA;
else
if (!stricmp(type, "rgb8"))
fType=kRGB8;
else
if (!stricmp(type, "rgba8"))
fType=kRGBA8;
else
if (!strnicmp(type, "quat",4))
fType=kQuaternion;
else
if (!stricmp(type, "rgba"))
fType=kRGBA;
else
if (!stricmp(type, "int"))
fType=kInt;
else
if (!stricmp(type, "byte"))
fType=kByte;
else
if (!stricmp(type, "short"))
fType=kShort;
else
if (!stricmp(type, "float"))
fType=kFloat;
else
if (!stricmp(type, "double"))
fType=kDouble;
else
if (!stricmp(type, "time"))
fType=kTime;
else
if (!stricmp(type, "ageTimeOfDay"))
fType=kAgeTimeOfDay;
else
if (!stricmp(type, "bool"))
fType=kBool;
else
if (!stricmp(type, "string32"))
fType=kString32;
else
if (!stricmp(type, "plKey"))
fType=kKey;
else
if (!stricmp(type, "message") || !stricmp(type, "creatable") )
fType=kCreatable;
else
if (*type=='$')
fType=kStateDescriptor;
else
return false; // err
delete [] fTypeString;
fTypeString = hsStrcpy(type);
return true; // ok
}
void plVarDescriptor::CopyFrom(const plVarDescriptor* other)
{
SetName(other->GetName());
SetDefault(other->GetDefault());
SetCount(other->GetCount());
SetDisplayOptions(other->GetDisplayOptions());
delete [] fTypeString;
fTypeString=hsStrcpy(other->GetTypeString());
fType = other->GetType();
fFlags = other->fFlags;
}
//
// Var descriptors are read and written by state descriptors
//
bool plVarDescriptor::Read(hsStream* s)
{
UInt8 version;
s->ReadSwap(&version);
if (version != kVersion)
{
if (plSDLMgr::GetInstance()->GetNetApp())
plSDLMgr::GetInstance()->GetNetApp()->WarningMsg("SDL VarDescriptor version mismatch, read %d, should be %d - ignoring",
version, kVersion);
return false;
}
delete [] fName;
fName=s->ReadSafeString();
plMsgStdStringHelper::Peek(fDisplayOptions, s);
fCount=s->ReadSwap32();
fType=(Type)s->ReadByte();
delete [] fDefault;
fDefault = s->ReadSafeString();
fFlags = s->ReadSwap32();
return true;
}
//
// Var descriptors are read and written by state descriptors
//
void plVarDescriptor::Write(hsStream* s) const
{
s->WriteSwap(kVersion);
s->WriteSafeString(fName);
plMsgStdStringHelper::Poke(fDisplayOptions, s);
s->WriteSwap32(fCount);
s->WriteByte((UInt8)fType);
s->WriteSafeString(fDefault);
s->WriteSwap32(fFlags);
}
/////////////////////////////////////////////////////////////////////////////////
// plSimpleVarDescriptor
/////////////////////////////////////////////////////////////////////////////////
plSimpleVarDescriptor::plSimpleVarDescriptor() :
fAtomicType(kNone),
fAtomicCount(1)
{
}
// size in bytes
int plSimpleVarDescriptor::GetAtomicSize() const
{
switch(fAtomicType)
{
case kInt:
return sizeof(int)*GetAtomicCount();
case kByte:
return sizeof(byte)*GetAtomicCount();
case kShort:
return sizeof(short)*GetAtomicCount();
case kAgeTimeOfDay:
case kFloat:
return sizeof(float)*GetAtomicCount();
case kTime:
return sizeof(plUnifiedTime)*GetAtomicCount();
case kDouble:
return sizeof(double)*GetAtomicCount();
case kBool:
return sizeof(bool)*GetAtomicCount();
case kString32:
return sizeof(String32)*GetAtomicCount();
case kKey:
return sizeof(plUoid)*GetAtomicCount();
default:
return -1; // err
}
}
// size of var in bytes
int plSimpleVarDescriptor::GetSize() const
{
int size=GetAtomicSize();
return size>=0 ? size*GetCount() : size;
}
//
// Set type from a string. Return false on err.
// Sets atomicCount and atomicType
//
bool plSimpleVarDescriptor::SetType(const char* type)
{
if (!type)
return false;
if (!plVarDescriptor::SetType(type))
return false;
if (!stricmp(type, "vector3"))
{
fAtomicCount = 3;
fAtomicType=kFloat;
}
else
if (!stricmp(type, "point3"))
{
fAtomicCount = 3;
fAtomicType=kFloat;
}
else
if (!stricmp(type, "rgb"))
{
fAtomicCount = 3;
fAtomicType=kFloat;
}
else
if (!stricmp(type, "rgba"))
{
fAtomicCount = 4;
fAtomicType=kFloat;
}
else
if (!stricmp(type, "rgb8"))
{
fAtomicCount = 3;
fAtomicType=kByte;
}
else
if (!stricmp(type, "rgba8"))
{
fAtomicCount = 4;
fAtomicType=kByte;
}
else
if (!strnicmp(type, "quat",4))
{
fAtomicCount = 4;
fAtomicType=kFloat;
}
else
if (!stricmp(type, "int"))
fAtomicType=kInt;
else
if (!stricmp(type, "byte"))
fAtomicType=kByte;
else
if (!stricmp(type, "short"))
fAtomicType=kShort;
else
if (!stricmp(type, "float"))
fAtomicType=kFloat;
else
if (!stricmp(type, "double"))
fAtomicType=kDouble;
else
if (!stricmp(type, "time"))
fAtomicType=kTime;
else
if (!stricmp(type, "ageTimeOfDay"))
fAtomicType=kAgeTimeOfDay;
else
if (!stricmp(type, "bool"))
fAtomicType=kBool;
else
if (!stricmp(type, "string32"))
fAtomicType=kString32;
else
if (!stricmp(type, "plKey"))
fAtomicType=kKey;
else
if (!stricmp(type, "message") || !stricmp(type, "creatable"))
fAtomicType=kCreatable;
else
return false; // err
return true; // ok
}
void plSimpleVarDescriptor::CopyFrom(const plSimpleVarDescriptor* other)
{
plVarDescriptor::CopyFrom(other);
fAtomicCount=other->GetAtomicCount();
fAtomicType=other->GetAtomicType();
}
//
// Var descriptors are read and written by state descriptors
//
bool plSimpleVarDescriptor::Read(hsStream* s)
{
if (!plVarDescriptor::Read(s))
return false;
fAtomicCount=s->ReadSwap16();
fAtomicType=(Type)s->ReadByte();
return true;
}
//
// Var descriptors are read and written by state descriptors
//
void plSimpleVarDescriptor::Write(hsStream* s) const
{
plVarDescriptor::Write(s);
s->WriteSwap16((Int16)fAtomicCount);
s->WriteByte((UInt8)fAtomicType);
}
/////////////////////////////////////////////////////////////////////////////////
// plSDVarDescriptor
// A var which references another state descriptor
/////////////////////////////////////////////////////////////////////////////////
void plSDVarDescriptor::CopyFrom(const plSDVarDescriptor* other)
{
plVarDescriptor::CopyFrom(other);
SetStateDesc(other->GetStateDescriptor());
}
//
// Var descriptors are read and written by state descriptors
//
bool plSDVarDescriptor::Read(hsStream* s)
{
if (!plVarDescriptor::Read(s))
return false;
char* sdName=s->ReadSafeString();
UInt16 version = s->ReadSwap16();
plStateDescriptor* sd=plSDLMgr::GetInstance()->FindDescriptor(sdName, version);
hsAssert( sd, xtl::format("Failed to find sdl descriptor: %s,%d. Missing legacy descriptor?", sdName, version ).c_str() );
SetStateDesc(sd);
delete [] sdName;
return true;
}
//
// Var descriptors are read and written by state descriptors
//
void plSDVarDescriptor::Write(hsStream* s) const
{
plVarDescriptor::Write(s);
s->WriteSafeString(GetStateDescriptor()->GetName());
UInt16 version=GetStateDescriptor()->GetVersion();
s->WriteSwap(version);
}