mirror of
https://github.com/ZDoom/qzdoom-gpl.git
synced 2024-11-17 09:41:21 +00:00
cf11cbdb30
SVN r4 (trunk)
722 lines
16 KiB
C++
722 lines
16 KiB
C++
/*
|
|
** dobject.cpp
|
|
** Implements the base class DObject, which most other classes derive from
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** Copyright 1998-2005 Randy Heit
|
|
** All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
**
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "cmdlib.h"
|
|
#include "actor.h"
|
|
#include "dobject.h"
|
|
#include "m_alloc.h"
|
|
#include "doomstat.h" // Ideally, DObjects can be used independant of Doom.
|
|
#include "d_player.h" // See p_user.cpp to find out why this doesn't work.
|
|
#include "g_game.h" // Needed for bodyque.
|
|
#include "c_dispatch.h"
|
|
#include "i_system.h"
|
|
#include "r_state.h"
|
|
#include "stats.h"
|
|
|
|
TArray<TypeInfo *> TypeInfo::m_RuntimeActors;
|
|
TypeInfo **TypeInfo::m_Types;
|
|
unsigned short TypeInfo::m_NumTypes;
|
|
unsigned short TypeInfo::m_MaxTypes;
|
|
unsigned int TypeInfo::TypeHash[256]; // Why can't I use TypeInfo::HASH_SIZE?
|
|
|
|
#if defined(_MSC_VER) || defined(__GNUC__)
|
|
#include "autosegs.h"
|
|
|
|
TypeInfo DObject::_StaticType =
|
|
{
|
|
"DObject",
|
|
NULL,
|
|
sizeof(DObject),
|
|
};
|
|
|
|
void TypeInfo::StaticInit ()
|
|
{
|
|
TAutoSegIterator<TypeInfo *, &CRegHead, &CRegTail> probe;
|
|
|
|
while (++probe != NULL)
|
|
{
|
|
probe->RegisterType ();
|
|
}
|
|
}
|
|
#else
|
|
TypeInfo DObject::_StaticType(NULL, "DObject", NULL, sizeof(DObject));
|
|
#endif
|
|
|
|
static cycle_t StaleCycles;
|
|
static int StaleCount;
|
|
|
|
void TypeInfo::RegisterType ()
|
|
{
|
|
// Add type to list
|
|
if (m_NumTypes == m_MaxTypes)
|
|
{
|
|
m_MaxTypes = m_MaxTypes ? m_MaxTypes*2 : 256;
|
|
m_Types = (TypeInfo **)Realloc (m_Types, m_MaxTypes * sizeof(*m_Types));
|
|
}
|
|
m_Types[m_NumTypes] = this;
|
|
TypeIndex = m_NumTypes;
|
|
m_NumTypes++;
|
|
|
|
// Add type to hash table. Types are inserted into each bucket
|
|
// lexicographically, and the prefix character is ignored.
|
|
unsigned int bucket = MakeKey (Name+1) % HASH_SIZE;
|
|
unsigned int *hashpos = &TypeHash[bucket];
|
|
while (*hashpos != 0)
|
|
{
|
|
int lexx = strcmp (Name+1, m_Types[*hashpos-1]->Name+1);
|
|
// (The Lexx is the most powerful weapon of destruction
|
|
// in the two universes.)
|
|
|
|
if (lexx > 0)
|
|
{ // This type should come later in the chain
|
|
hashpos = &m_Types[*hashpos-1]->HashNext;
|
|
}
|
|
else if (lexx == 0)
|
|
{ // This type has already been inserted
|
|
I_FatalError ("Class %s already registered", Name);
|
|
}
|
|
else
|
|
{ // Type comes right here
|
|
break;
|
|
}
|
|
}
|
|
HashNext = *hashpos;
|
|
*hashpos = TypeIndex + 1;
|
|
}
|
|
|
|
// Case-sensitive search (preferred)
|
|
const TypeInfo *TypeInfo::FindType (const char *name)
|
|
{
|
|
if (name != NULL)
|
|
{
|
|
unsigned int index = TypeHash[MakeKey (name) % HASH_SIZE];
|
|
|
|
while (index != 0)
|
|
{
|
|
int lexx = strcmp (name, m_Types[index-1]->Name + 1);
|
|
if (lexx > 0)
|
|
{
|
|
index = m_Types[index-1]->HashNext;
|
|
}
|
|
else if (lexx == 0)
|
|
{
|
|
return m_Types[index-1];
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Case-insensitive search
|
|
const TypeInfo *TypeInfo::IFindType (const char *name)
|
|
{
|
|
if (name != NULL)
|
|
{
|
|
for (int i = 0; i < TypeInfo::m_NumTypes; i++)
|
|
{
|
|
if (stricmp (TypeInfo::m_Types[i]->Name + 1, name) == 0)
|
|
return TypeInfo::m_Types[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Create a new object that this type represents
|
|
DObject *TypeInfo::CreateNew () const
|
|
{
|
|
BYTE *mem = (BYTE *)Malloc (SizeOf);
|
|
ConstructNative (mem);
|
|
((DObject *)mem)->SetClass (const_cast<TypeInfo *>(this));
|
|
|
|
// If this is a scripted extension of a class but not an actor,
|
|
// initialize any extended space to zero. Actors have defaults, so
|
|
// we can initialize them better
|
|
if (ActorInfo != NULL)
|
|
{
|
|
AActor *actor = (AActor *)mem;
|
|
memcpy (&(actor->x), &(((AActor *)ActorInfo->Defaults)->x), SizeOf - ((BYTE *)&actor->x - (BYTE *)actor));
|
|
}
|
|
else if (ParentType != 0 &&
|
|
ConstructNative == ParentType->ConstructNative &&
|
|
SizeOf > ParentType->SizeOf)
|
|
{
|
|
memset (mem + ParentType->SizeOf, 0, SizeOf - ParentType->SizeOf);
|
|
}
|
|
return (DObject *)mem;
|
|
}
|
|
|
|
// Create a new type based on an existing type
|
|
TypeInfo *TypeInfo::CreateDerivedClass (char *name, unsigned int size)
|
|
{
|
|
TypeInfo *type = new TypeInfo;
|
|
|
|
type->Name = name;
|
|
type->ParentType = this;
|
|
type->SizeOf = size;
|
|
type->Pointers = NULL;
|
|
type->ConstructNative = ConstructNative;
|
|
type->RegisterType();
|
|
type->Meta = Meta;
|
|
type->FlatPointers = NULL;
|
|
|
|
// If this class has an actor info, then any classes derived from it
|
|
// also need an actor info.
|
|
if (this->ActorInfo != NULL)
|
|
{
|
|
FActorInfo *info = type->ActorInfo = new FActorInfo;
|
|
info->Class = type;
|
|
info->Defaults = new BYTE[size];
|
|
info->GameFilter = GAME_Any;
|
|
info->SpawnID = 0;
|
|
info->DoomEdNum = -1;
|
|
info->OwnedStates = NULL;
|
|
info->NumOwnedStates = 0;
|
|
|
|
memcpy (info->Defaults, ActorInfo->Defaults, SizeOf);
|
|
if (size > SizeOf)
|
|
{
|
|
memset (info->Defaults + SizeOf, 0, size - SizeOf);
|
|
}
|
|
m_RuntimeActors.Push (type);
|
|
}
|
|
else
|
|
{
|
|
type->ActorInfo = NULL;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
// Create the FlatPointers array, if it doesn't exist already.
|
|
// It comprises all the Pointers from superclasses plus this class's own Pointers.
|
|
// If this class does not define any new Pointers, then FlatPointers will be set
|
|
// to the same array as the super class's.
|
|
void TypeInfo::BuildFlatPointers ()
|
|
{
|
|
static const size_t TheEnd = ~0;
|
|
|
|
if (FlatPointers != NULL)
|
|
{ // Already built: Do nothing.
|
|
return;
|
|
}
|
|
else if (ParentType == NULL)
|
|
{ // No parent: FlatPointers is the same as Pointers.
|
|
if (Pointers == NULL)
|
|
{ // No pointers: Make FlatPointers a harmless non-NULL.
|
|
FlatPointers = &TheEnd;
|
|
}
|
|
else
|
|
{
|
|
FlatPointers = Pointers;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ParentType->BuildFlatPointers ();
|
|
if (Pointers == NULL)
|
|
{ // No new pointers: Just use the same FlatPointers as the parent.
|
|
FlatPointers = ParentType->FlatPointers;
|
|
}
|
|
else
|
|
{ // New pointers: Create a new FlatPointers array and add them.
|
|
int numPointers, numSuperPointers;
|
|
|
|
// Count pointers defined by this class.
|
|
for (numPointers = 0; Pointers[numPointers] != ~(size_t)0; numPointers++)
|
|
{ }
|
|
// Count pointers defined by superclasses.
|
|
for (numSuperPointers = 0; ParentType->FlatPointers[numSuperPointers] != ~(size_t)0; numSuperPointers++)
|
|
{ }
|
|
|
|
// Concatenate them into a new array
|
|
size_t *flat = new size_t[numPointers + numSuperPointers + 1];
|
|
if (numSuperPointers > 0)
|
|
{
|
|
memcpy (flat, ParentType->FlatPointers, sizeof(size_t)*numSuperPointers);
|
|
}
|
|
memcpy (flat + numSuperPointers, Pointers, sizeof(size_t)*(numPointers+1));
|
|
FlatPointers = flat;
|
|
}
|
|
}
|
|
}
|
|
|
|
FMetaTable::~FMetaTable ()
|
|
{
|
|
FreeMeta ();
|
|
}
|
|
|
|
FMetaTable::FMetaTable (const FMetaTable &other)
|
|
{
|
|
Meta = NULL;
|
|
CopyMeta (&other);
|
|
}
|
|
|
|
FMetaTable &FMetaTable::operator = (const FMetaTable &other)
|
|
{
|
|
CopyMeta (&other);
|
|
return *this;
|
|
}
|
|
|
|
void FMetaTable::FreeMeta ()
|
|
{
|
|
while (Meta != NULL)
|
|
{
|
|
FMetaData *meta = Meta;
|
|
|
|
switch (meta->Type)
|
|
{
|
|
case META_String:
|
|
delete meta->Value.String;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
Meta = meta->Next;
|
|
delete meta;
|
|
}
|
|
}
|
|
|
|
void FMetaTable::CopyMeta (const FMetaTable *other)
|
|
{
|
|
const FMetaData *meta_src;
|
|
FMetaData **meta_dest;
|
|
|
|
FreeMeta ();
|
|
|
|
meta_src = other->Meta;
|
|
meta_dest = &Meta;
|
|
while (meta_src != NULL)
|
|
{
|
|
FMetaData *newmeta = new FMetaData (meta_src->Type, meta_src->ID);
|
|
switch (meta_src->Type)
|
|
{
|
|
case META_String:
|
|
newmeta->Value.String = copystring (meta_src->Value.String);
|
|
break;
|
|
default:
|
|
newmeta->Value = meta_src->Value;
|
|
break;
|
|
}
|
|
*meta_dest = newmeta;
|
|
meta_dest = &newmeta->Next;
|
|
meta_src = meta_src->Next;
|
|
}
|
|
*meta_dest = NULL;
|
|
}
|
|
|
|
FMetaData *FMetaTable::FindMeta (EMetaType type, DWORD id) const
|
|
{
|
|
FMetaData *meta = Meta;
|
|
|
|
while (meta != NULL)
|
|
{
|
|
if (meta->ID == id && meta->Type == type)
|
|
{
|
|
return meta;
|
|
}
|
|
meta = meta->Next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
FMetaData *FMetaTable::FindMetaDef (EMetaType type, DWORD id)
|
|
{
|
|
FMetaData *meta = FindMeta (type, id);
|
|
if (meta == NULL)
|
|
{
|
|
meta = new FMetaData (type, id);
|
|
meta->Next = Meta;
|
|
meta->Value.String = NULL;
|
|
Meta = meta;
|
|
}
|
|
return meta;
|
|
}
|
|
|
|
void FMetaTable::SetMetaInt (DWORD id, int parm)
|
|
{
|
|
FMetaData *meta = FindMetaDef (META_Int, id);
|
|
meta->Value.Int = parm;
|
|
}
|
|
|
|
int FMetaTable::GetMetaInt (DWORD id) const
|
|
{
|
|
FMetaData *meta = FindMeta (META_Int, id);
|
|
return meta != NULL ? meta->Value.Int : 0;
|
|
}
|
|
|
|
void FMetaTable::SetMetaFixed (DWORD id, fixed_t parm)
|
|
{
|
|
FMetaData *meta = FindMetaDef (META_Fixed, id);
|
|
meta->Value.Fixed = parm;
|
|
}
|
|
|
|
fixed_t FMetaTable::GetMetaFixed (DWORD id) const
|
|
{
|
|
FMetaData *meta = FindMeta (META_Fixed, id);
|
|
return meta != NULL ? meta->Value.Fixed : 0;
|
|
}
|
|
|
|
void FMetaTable::SetMetaString (DWORD id, const char *parm)
|
|
{
|
|
FMetaData *meta = FindMetaDef (META_String, id);
|
|
ReplaceString (&meta->Value.String, parm);
|
|
}
|
|
|
|
const char *FMetaTable::GetMetaString (DWORD id) const
|
|
{
|
|
FMetaData *meta = FindMeta (META_String, id);
|
|
return meta != NULL ? meta->Value.String : NULL;
|
|
}
|
|
|
|
CCMD (dumpclasses)
|
|
{
|
|
const TypeInfo *root;
|
|
int i;
|
|
int shown, omitted;
|
|
bool showall = true;
|
|
|
|
if (argv.argc() > 1)
|
|
{
|
|
root = TypeInfo::IFindType (argv[1]);
|
|
if (root == NULL)
|
|
{
|
|
Printf ("Class '%s' not found\n", argv[1]);
|
|
return;
|
|
}
|
|
if (stricmp (argv[1], "Actor") == 0)
|
|
{
|
|
if (argv.argc() < 3 || stricmp (argv[2], "all") != 0)
|
|
{
|
|
showall = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
root = NULL;
|
|
}
|
|
|
|
shown = omitted = 0;
|
|
for (i = 0; i < TypeInfo::m_NumTypes; i++)
|
|
{
|
|
if (root == NULL ||
|
|
(TypeInfo::m_Types[i]->IsDescendantOf (root) &&
|
|
(showall || TypeInfo::m_Types[i] == root ||
|
|
TypeInfo::m_Types[i]->ActorInfo != root->ActorInfo)))
|
|
{
|
|
Printf (" %s\n", TypeInfo::m_Types[i]->Name + 1);
|
|
shown++;
|
|
}
|
|
else
|
|
{
|
|
omitted++;
|
|
}
|
|
}
|
|
Printf ("%d classes shown, %d omitted\n", shown, omitted);
|
|
}
|
|
|
|
TArray<DObject *> DObject::Objects;
|
|
TArray<size_t> DObject::FreeIndices;
|
|
TArray<DObject *> DObject::ToDestroy;
|
|
bool DObject::Inactive;
|
|
|
|
DObject::DObject ()
|
|
: ObjectFlags(0), Class(0)
|
|
{
|
|
if (FreeIndices.Pop (Index))
|
|
Objects[Index] = this;
|
|
else
|
|
Index = Objects.Push (this);
|
|
}
|
|
|
|
DObject::DObject (TypeInfo *inClass)
|
|
: ObjectFlags(0), Class(inClass)
|
|
{
|
|
if (FreeIndices.Pop (Index))
|
|
Objects[Index] = this;
|
|
else
|
|
Index = Objects.Push (this);
|
|
}
|
|
|
|
DObject::~DObject ()
|
|
{
|
|
if (!Inactive)
|
|
{
|
|
if (!(ObjectFlags & OF_MassDestruction))
|
|
{
|
|
RemoveFromArray ();
|
|
DestroyScan (this);
|
|
}
|
|
else if (!(ObjectFlags & OF_Cleanup))
|
|
{
|
|
// object is queued for deletion, but is not being deleted
|
|
// by the destruction process, so remove it from the
|
|
// ToDestroy array and do other necessary stuff.
|
|
unsigned int i;
|
|
|
|
for (i = ToDestroy.Size() - 1; i-- > 0; )
|
|
{
|
|
if (ToDestroy[i] == this)
|
|
{
|
|
ToDestroy[i] = NULL;
|
|
break;
|
|
}
|
|
}
|
|
DestroyScan (this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DObject::Destroy ()
|
|
{
|
|
if (!Inactive)
|
|
{
|
|
if (!(ObjectFlags & OF_MassDestruction))
|
|
{
|
|
RemoveFromArray ();
|
|
ObjectFlags |= OF_MassDestruction;
|
|
ToDestroy.Push (this);
|
|
}
|
|
}
|
|
else
|
|
delete this;
|
|
}
|
|
|
|
void DObject::BeginFrame ()
|
|
{
|
|
StaleCycles = 0;
|
|
StaleCount = 0;
|
|
}
|
|
|
|
void DObject::EndFrame ()
|
|
{
|
|
clock (StaleCycles);
|
|
if (ToDestroy.Size ())
|
|
{
|
|
StaleCount += (int)ToDestroy.Size ();
|
|
DestroyScan ();
|
|
//Printf ("Destroyed %d objects\n", ToDestroy.Size());
|
|
|
|
DObject *obj;
|
|
while (ToDestroy.Pop (obj))
|
|
{
|
|
if (obj)
|
|
{
|
|
obj->ObjectFlags |= OF_Cleanup;
|
|
delete obj;
|
|
}
|
|
}
|
|
}
|
|
unclock (StaleCycles);
|
|
}
|
|
|
|
void DObject::RemoveFromArray ()
|
|
{
|
|
if (Objects.Size() == Index + 1)
|
|
{
|
|
DObject *dummy;
|
|
Objects.Pop (dummy);
|
|
}
|
|
else if (Objects.Size() > Index)
|
|
{
|
|
Objects[Index] = NULL;
|
|
FreeIndices.Push (Index);
|
|
}
|
|
}
|
|
|
|
void DObject::PointerSubstitution (DObject *old, DObject *notOld)
|
|
{
|
|
unsigned int i, highest;
|
|
highest = Objects.Size ();
|
|
|
|
for (i = 0; i <= highest; i++)
|
|
{
|
|
DObject *current = i < highest ? Objects[i] : &bglobal;
|
|
if (current)
|
|
{
|
|
const TypeInfo *info = current->GetClass();
|
|
const size_t *offsets = info->FlatPointers;
|
|
if (offsets == NULL)
|
|
{
|
|
const_cast<TypeInfo *>(info)->BuildFlatPointers();
|
|
offsets = info->FlatPointers;
|
|
}
|
|
while (*offsets != ~(size_t)0)
|
|
{
|
|
if (*(DObject **)((BYTE *)current + *offsets) == old)
|
|
{
|
|
*(DObject **)((BYTE *)current + *offsets) = notOld;
|
|
}
|
|
offsets++;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < BODYQUESIZE; ++i)
|
|
{
|
|
if (bodyque[i] == old)
|
|
{
|
|
bodyque[i] = static_cast<AActor *>(notOld);
|
|
}
|
|
}
|
|
|
|
// This is an ugly hack, but it's the best I can do for now.
|
|
for (i = 0; i < MAXPLAYERS; i++)
|
|
{
|
|
if (playeringame[i])
|
|
players[i].FixPointers (old, notOld);
|
|
}
|
|
}
|
|
|
|
// Search for references to a single object and NULL them.
|
|
// It should not be listed in ToDestroy.
|
|
void DObject::DestroyScan (DObject *obj)
|
|
{
|
|
PointerSubstitution (obj, NULL);
|
|
}
|
|
|
|
// Search for references to all objects scheduled for
|
|
// destruction and NULL them.
|
|
void DObject::DestroyScan ()
|
|
{
|
|
unsigned int i, highest;
|
|
int j, destroycount;
|
|
DObject **destroybase;
|
|
destroycount = (int)ToDestroy.Size ();
|
|
if (destroycount == 0)
|
|
return;
|
|
destroybase = &ToDestroy[0] + destroycount;
|
|
destroycount = -destroycount;
|
|
highest = Objects.Size ();
|
|
|
|
for (i = 0; i <= highest; i++)
|
|
{
|
|
DObject *current = i < highest ? Objects[i] : &bglobal;
|
|
if (current)
|
|
{
|
|
const TypeInfo *info = current->GetClass();
|
|
const size_t *offsets = info->FlatPointers;
|
|
if (offsets == NULL)
|
|
{
|
|
const_cast<TypeInfo *>(info)->BuildFlatPointers();
|
|
offsets = info->FlatPointers;
|
|
}
|
|
while (*offsets != ~(size_t)0)
|
|
{
|
|
j = destroycount;
|
|
do
|
|
{
|
|
if (*(DObject **)((BYTE *)current + *offsets) == *(destroybase + j))
|
|
{
|
|
*(DObject **)((BYTE *)current + *offsets) = NULL;
|
|
}
|
|
} while (++j);
|
|
offsets++;
|
|
}
|
|
}
|
|
}
|
|
|
|
j = destroycount;
|
|
do
|
|
{
|
|
for (i = 0; i < BODYQUESIZE; ++i)
|
|
{
|
|
if (bodyque[i] == *(destroybase + j))
|
|
{
|
|
bodyque[i] = NULL;
|
|
}
|
|
}
|
|
|
|
} while (++j);
|
|
|
|
// This is an ugly hack, but it's the best I can do for now.
|
|
for (i = 0; i < MAXPLAYERS; i++)
|
|
{
|
|
if (playeringame[i])
|
|
{
|
|
j = destroycount;
|
|
do
|
|
{
|
|
players[i].FixPointers (*(destroybase + j), NULL);
|
|
} while (++j);
|
|
}
|
|
}
|
|
}
|
|
|
|
void STACK_ARGS DObject::StaticShutdown ()
|
|
{
|
|
Inactive = true;
|
|
}
|
|
|
|
void DObject::Serialize (FArchive &arc)
|
|
{
|
|
ObjectFlags |= OF_SerialSuccess;
|
|
}
|
|
|
|
void DObject::CheckIfSerialized () const
|
|
{
|
|
if (!(ObjectFlags & OF_SerialSuccess))
|
|
{
|
|
I_Error (
|
|
"BUG: %s::Serialize\n"
|
|
"(or one of its superclasses) needs to call\n"
|
|
"Super::Serialize\n",
|
|
StaticType ()->Name);
|
|
}
|
|
}
|
|
|
|
FArchive &operator<< (FArchive &arc, const TypeInfo * &info)
|
|
{
|
|
if (arc.IsStoring ())
|
|
{
|
|
arc.UserWriteClass (info);
|
|
}
|
|
else
|
|
{
|
|
arc.UserReadClass (info);
|
|
}
|
|
return arc;
|
|
}
|
|
|
|
ADD_STAT (destroys, out)
|
|
{
|
|
sprintf (out, "Pointer fixing: %d in %04.1f ms",
|
|
StaleCount, SecondsPerCycle * (double)StaleCycles * 1000);
|
|
}
|