void vHavokTriggerVolume::Serialize( VArchive &ar )
{
char iLocalVersion = VHAVOKTRIGGERVOLUME_VERSION_CURRENT;
IVObjectComponent::Serialize(ar);
if (ar.IsLoading())
{
char iFileVersion = 0;
ar >> iFileVersion;
VASSERT_MSG(iFileVersion <= iLocalVersion, "Invalid file version. Please re-export");
ar >> Havok_ShapeType;
ar >> Havok_MotionType;
ar >> Havok_QualityType;
ar >> Havok_CollisionLayer;
ar >> Havok_CollisionGroup;
ar >> Havok_SubSystemId;
ar >> Havok_SubSystemDontCollideWith;
ar >> Debug_Color;
VisTriggerSourceComponent_cl *pComp = NULL;
ar >> pComp;m_spOnObjectEnter = pComp;
ar >> pComp;m_spOnObjectLeave = pComp;
ar >> pComp;m_spOnCharacterEnter = pComp;
ar >> pComp;m_spOnCharacterLeave = pComp;
}
void VFmodEvent::Serialize( VArchive &ar )
{
VisObject3D_cl::Serialize(ar);
char iVersion = -1;
if (ar.IsLoading())
{
ar >> iVersion;
VASSERT(iVersion >= VFMOD_EVENT_VERSION_0 && iVersion <= VFMOD_EVENT_VERSION_CURRENT);
// load resource
char szEventProjectPath[FS_MAX_PATH+1];
char szEventGroupName[FS_MAX_PATH+1];
ar.ReadStringBinary(szEventProjectPath, FS_MAX_PATH);
ar.ReadStringBinary(szEventGroupName, FS_MAX_PATH);
// event properties
ar >> m_sEventName;
// @@@ Force events to be non-disposable
//m_iFlags |= VFMOD_FLAG_NODISPOSE;
ar >> m_iFlags;
if(iVersion >= VFMOD_EVENT_VERSION_1)
{
ar >> m_bPlayedOnce;
}
//TODO: serialize added events!
void VAnimationComponent::Serialize( VArchive &ar )
{
char iLocalVersion = 0;
IVObjectComponent::Serialize(ar);
if (ar.IsLoading())
{
ar >> iLocalVersion;
VASSERT_MSG(iLocalVersion == 0, "Invalid local version. Please re-export");
char pBuffer[512];
ar.ReadStringBinary(pBuffer, 512);
if(pBuffer && pBuffer[0])
{
unsigned int flags = 0;
float time = 0;
bool isPlaying = true;
ar >> flags;
ar >> time;
ar >> isPlaying;
Play(pBuffer, (flags&VANIMCTRL_LOOP)!=0);
if(!isPlaying) Pause();
SetTime(time);
}
// ----------------------------------------------------------------------------
void vHavokGenericConstraintDesc::Serialize( VArchive &ar )
{
vHavokConstraintDesc::Serialize(ar);
if (ar.IsLoading())
{
unsigned int iVersion = 0;
ar >> iVersion;
VASSERT((iVersion > 0) && (iVersion <= s_iSerialVersion));
m_vGenericPivot.SerializeAsVisVector (ar);
m_vAngularAxis.SerializeAsVisVector (ar);
int iTmp;
ar >> iTmp; m_eXMotion = (VGenericMotion_e)iTmp;
ar >> iTmp; m_eYMotion = (VGenericMotion_e)iTmp;
ar >> iTmp; m_eZMotion = (VGenericMotion_e)iTmp;
ar >> iTmp; m_eAngularMotion = (VGenericMotion_e)iTmp;
ar >> m_fLinearMin;
ar >> m_fLinearMax;
ar >> m_fAngularMin;
ar >> m_fAngularMax;
ar >> m_fVelocityTarget;
ar >> m_fTau;
ar >> m_fMinForce;
ar >> m_fMaxForce;
ar >> m_fLinearFriction;
ar >> m_fAngularFriction;
}
void VLineFollowerComponent::Serialize(VArchive &ar)
{
char iLocalVersion = 1;
IVObjectComponent::Serialize(ar);
if (ar.IsLoading())
{
ar >> iLocalVersion;
VASSERT_MSG(iLocalVersion==1, "Invalid local version. Please re-export");
ar.ReadStringBinary(Model_AnimationName, sizeof(Model_AnimationName));
ar.ReadStringBinary(Path_Key, sizeof(Path_Key));
ar >> Path_NumberSteps;
ar >> Path_TriggerDistance;
ar >> Path_InitialOffset;
ar >> Model_DeltaRotation;
ar >> Model_GroundOffset;
ar >> Model_CapsuleHeight;
ar >> Model_CapsuleRadius;
ar >> Debug_DisplayBoxes;
Debug_RenderMesh = false;
CommonInit();
}
void VSkyLayer::SerializeX( VArchive &ar )
{
char iVersion = 0;
if (ar.IsLoading())
{
ar >> iVersion; VVERIFY(iVersion==0 && "Invalid sky serialization version");
// main properties
char mapping;
ar >> mapping;
ar >> m_vMappingParams;
ar >> m_vColor;
ar >> m_vTextureTransform;
ar >> m_vScrollSpeed;
SetMapping((VIS_SKY_MappingType)mapping);
// textures
float fProgressStep = mapping==VIS_SKYMAPPING_CUBEMAP ? 100.f/6.f : 100.f;
float fProgress = 0.f;
VMemoryTempBuffer<FS_MAX_PATH> buffer;
SAFE_LOAD_TEXTURE(m_spTexture, mapping==VIS_SKYMAPPING_SPHERICAL || mapping==VIS_SKYMAPPING_CYLINDRICAL);
for (int i=0;i<6;i++)
SAFE_LOAD_TEXTURE(m_spCubemapFace[i],mapping==VIS_SKYMAPPING_CUBEMAP);
} else
void VFmodSoundObject::Serialize( VArchive &ar )
{
VisObject3D_cl::Serialize(ar);
char iVersion = -1;
if (ar.IsLoading())
{
ar >> iVersion;
VASSERT(iVersion >= VFMOD_SOUNDOBJECT_VERSION_0 && iVersion <= VFMOD_SOUNDOBJECT_VERSION_CURRENT);
// first, load resource file
int iResourceFlags;
char szResourceFile[FS_MAX_PATH+1];
ar >> iResourceFlags;
ar.ReadStringBinary(szResourceFile, FS_MAX_PATH);
m_spResource = VFmodManager::GlobalManager().LoadSoundResource(szResourceFile, iResourceFlags);
// sound properties
ar >> m_iFlags;
ar >> m_iPriority;
ar >> m_fVolume >> m_fPan >> m_fConeInside >> m_fConeOutside;
ar >> m_fFadeMin >> m_fFadeMax;
ar >> m_bFading;
ar >> m_fVolumeFadeTime >> m_fVolumeFadeDuration;
ar >> m_fVolumeFadeStart >> m_fVolumeFadeTarget;
ar >> m_fPitch;
if(iVersion >= VFMOD_SOUNDOBJECT_VERSION_1)
{
ar >> m_bPlayedOnce;
}
void VFmodCollisionMeshInstance::Serialize( VArchive &ar )
{
if (ar.IsLoading())
{
char iVersion = -1;
bool bActive;
int iMeshType;
ar >> iVersion;
VASSERT(iVersion >= V_FMODCOLLISIONMESHINSTANCE_VERSION_0 && iVersion <= V_FMODCOLLISIONMESHINSTANCE_VERSION_CURRENT);
VisObject3D_cl::Serialize(ar);
ar >> bActive;
m_vScale.SerializeAsVec3(ar);
ar >> m_fDirectOcclusion >> m_fReverbOcclusion;
ar >> iMeshType; // mesh type; 0==VBaseMesh
if (iMeshType==0)
{
VBaseMesh *pMesh = (VBaseMesh *)ar.ReadProxyObject();
SetCollisionMesh(pMesh, m_fDirectOcclusion, m_fReverbOcclusion);
}
else
{
VASSERT(!"Yet unsupported mesh type for sound collision geometry");
}
SetActive(bActive);
}
void RPG_PlayerCharacterSynchronizationGroup::Synchronize(const VNetworkViewContext& context, VNetworkSynchronizationGroupInstanceInfo_t &instanceInfo, VArchive &ar)
{
RPG_PlayerCharacter *pObj = (RPG_PlayerCharacter*) instanceInfo.m_pInstance;
VHistoryData* pData = (VHistoryData*) instanceInfo.m_pCustomData;
if (ar.IsLoading())
{
// Get timing
__int64 iTimeMS;
ar >> iTimeMS; //8 byte
ar >> pData->m_iDataFlagsToSend; // 1 byte
//hkvLog::Warning("Server time: %.5f", iTimeMS / 1000.0f);
if (pData->m_iDataFlagsToSend & VCD_POSITION)
{
float fX, fY, fZ;
ar >> fX; //4 byte
ar >> fY; //4 byte
ar >> fZ; //4 byte
hkvVec3 vNewPosition (fX, fY, fZ);
pData->m_positionHistory.Write (vNewPosition, iTimeMS);
}
void VPostProcessScreenMasks::Serialize( VArchive &ar )
{
char iLocalVersion = 0;
if (ar.IsLoading())
{
ar >> iLocalVersion;
ar >> m_bActive;
}
void VTextLabel::Serialize( VArchive &ar )
{
char iLocalVersion = 0;
VDlgControlBase::Serialize(ar);
if (ar.IsLoading())
{
ar >> iLocalVersion; VASSERT_MSG(iLocalVersion==0,"Invalid version");
ar >> m_TextCfg;
} else
void VDlgControlBase::Serialize( VArchive &ar )
{
VWindowBase::Serialize(ar);
if (ar.IsLoading())
{
} else
{
}
}
void VLookupItem::Serialize( VArchive &ar )
{
char iLocalVersion = 0;
VListControlItem::Serialize(ar);
if (ar.IsLoading())
{
ar >> iLocalVersion; VASSERT_MSG(iLocalVersion==0,"Invalid version");
ar >> m_iMatchColor;
} else
void VRendererNodeCommon::Serialize( VArchive &ar )
{
char iLocalVersion = RENDERERNODEBASE_VERSION_CURRENT;
if (ar.IsLoading())
{
ar >> iLocalVersion;
VASSERT_MSG(iLocalVersion >= RENDERERNODEBASE_VERSION_1 && iLocalVersion <= RENDERERNODEBASE_VERSION_CURRENT,
"VRendererNodeCommon: Invalid version number");
}
// ----------------------------------------------------------------------------
void vHavokStiffSpringConstraintDesc::Serialize( VArchive &ar )
{
vHavokConstraintDesc::Serialize(ar);
if (ar.IsLoading())
{
unsigned int iVersion = 0;
ar >> iVersion;
VASSERT((iVersion > 0) && (iVersion <= s_iSerialVersion));
}
void VSimpleCopyPostprocess::Serialize( VArchive &ar )
{
if (ar.IsLoading())
{
ar >> m_bActive;
VRendererNodeCommon* pDummy;
ar >> pDummy;
}
void VUndoableSectorAction::Serialize( VArchive &ar )
{
VisTypedEngineObject_cl::Serialize(ar);
char iLocalVersion = 0;
if (ar.IsLoading())
{
ar >> iLocalVersion;VASSERT_MSG(iLocalVersion==0, "Invalid version number");
ar >> m_iSectorX >> m_iSectorY;
}
// ----------------------------------------------------------------------------
void vHavokConstraintChainRendererBase::Serialize(VArchive &ar)
{
IVObjectComponent::Serialize(ar);
if (ar.IsLoading())
{
unsigned int iVersion = 0;
ar >> iVersion;
VASSERT_MSG((iVersion > 0) && (iVersion <= s_iSerialVersion), "Invalid version of serialized data!");
}
void VItemContainer::Serialize( VArchive &ar )
{
char iLocalVersion = 0;
VDlgControlBase::Serialize(ar);
if (ar.IsLoading())
{
ar >> iLocalVersion; VASSERT_MSG(iLocalVersion==0,"Invalid version");
ar >> m_Frame;
m_SubItems.SerializeX(ar);
} else
void VPostProcessFXAA::Serialize( VArchive &ar )
{
if (ar.IsLoading())
{
ar >> m_bActive;
unsigned int iQuality;
ar >> iQuality;
Quality = QualityLevel(iQuality);
}
void VTimedValueComponent::Serialize( VArchive &ar )
{
char iLocalVersion = 0;
IVObjectComponent::Serialize(ar);
hkvLog::Warning("VTimedValueComponent is not intended to be (de-)serialized. It should only be created by Lua script.");
if (ar.IsLoading())
{
ar >> iLocalVersion;
VASSERT_MSG(iLocalVersion == 0, "Invalid local version. Please re-export");
}
void VSkeletalBoneProxyObject::Serialize( VArchive &ar )
{
VisObject3D_cl::Serialize(ar);
char iLocalVersion = 0;
if (ar.IsLoading())
{
ar >> iLocalVersion; VASSERT_MSG(iLocalVersion==0,"Invalid version number");
ar >> m_iBoneIndex;
VASSERT_MSG(m_iBoneIndex==-1 || m_iBoneIndex<((VisBaseEntity_cl *)m_pParent)->GetMesh()->GetSkeleton()->GetBoneCount(), "Invalid bone index");
} else
void VisClothDeformer_cl::Serialize( VArchive &ar )
{
VisTypedEngineObject_cl::Serialize(ar);
if (ar.IsLoading())
{
}
else
{
}
}
void VDialogFrame::SerializeX( VArchive &ar )
{
char iLocalVersion = 0;
if (ar.IsLoading())
{
ar >> iLocalVersion; VASSERT_MSG(iLocalVersion==0,"Invalid version");
ar >> m_pOwner;
VTextureObject *pTex = (VTextureObject *)ar.ReadProxyObject();
SetTexture(pTex);
ar >> m_iColor;
} else
// ---------------------------------------------------------------------------------
// Method: Serialize
// Author: Fabian Roeken, Patrick Harms
// ---------------------------------------------------------------------------------
void VisMouseCamera_cl::Serialize( VArchive& ar )
{
VisBaseEntity_cl::Serialize( ar );
if ( ar.IsLoading() )
{
ar >> m_SpeedMode;
// all base initialization takes place now :-)
BaseInit();
}
inline void SerializeX(VArchive &ar)
{
if (ar.IsLoading())
{
int iBitCount;
ar >> iBitCount;
AllocateBitfield(iBitCount);
const int iIntCount = GetIntCount();
if (iIntCount>0)
ar.Read(GetIntArray(),iIntCount*sizeof(int),"i",iIntCount);
} else
void vHavokPointToPlaneConstraintDesc::Serialize( VArchive &ar )
{
vHavokConstraintDesc::Serialize(ar);
if (ar.IsLoading())
{
unsigned int iVersion = 0;
ar >> iVersion;
VASSERT((iVersion > 0) && (iVersion <= s_iSerialVersion));
m_vPointToPlanePivot.SerializeAsVisVector (ar);
m_vPlaneNormal.SerializeAsVisVector (ar);
}
void VCustomVolumeObject::Serialize( VArchive &ar )
{
VisObject3D_cl::Serialize(ar);
if(ar.IsLoading())
{
unsigned int uiVersion = 0;
ar >> uiVersion;
VASSERT(uiVersion == VV_Version1);
ar >> m_sStaticMeshPath;
ar >> m_bCustomStaticMesh;
m_vScale.SerializeAsVec3(ar);
}
void VUINodeRotator::Serialize( VArchive &ar )
{
VPushButton::Serialize(ar);
char iLocalVersion = 0;
if (ar.IsLoading())
{
} else
{
}
}
// ----------------------------------------------------------------------------
void vHavokDebugConstraintChainRenderer::Serialize(VArchive &ar)
{
vHavokConstraintChainRendererBase::Serialize(ar);
if (ar.IsLoading())
{
unsigned int iVersion = 0;
ar >> iVersion;
VASSERT_MSG((iVersion > 0) && (iVersion <= s_iSerialVersion), "Invalid version of serialized data!");
ar >> Render_Color;
}
