+Unity Runtime codeHEADmaster

1 files changed, 1393 insertions, 0 deletions

diff --git a/Runtime/BaseClasses/BaseObject.cpp b/Runtime/BaseClasses/BaseObject.cpp
new file mode 100644
index 0000000..1f4c88a
--- /dev/null
+++ b/Runtime/BaseClasses/BaseObject.cpp
@@ -0,0 +1,1393 @@
+#include "UnityPrefix.h"
+#include "Configuration/UnityConfigure.h"
+#include "BaseObject.h"
+#include "Runtime/Serialize/PersistentManager.h"
+#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
+#include "Runtime/Utilities/dynamic_bitset.h"
+#include "Runtime/Utilities/CStringHash.h"
+#include "Runtime/Utilities/InitializeAndCleanup.h"
+#include "Runtime/Scripting/ScriptingUtility.h"
+#include "Runtime/Profiler/MemoryProfilerStats.h"
+#include "Runtime/Scripting/Backend/ScriptingBackendApi.h"
+#include "EventManager.h"
+#include "EventIDs.h"
+#if ENABLE_MONO
+#include "Runtime/Mono/MonoIncludes.h"
+#endif
+
+#include "Runtime/Scripting/ScriptingUtility.h"
+
+#if defined(__MWERKS__)
+#include <hash_map>
+#endif
+
+#include "Configuration/UnityConfigure.h"
+#if THREADED_LOADING
+#include "Runtime/Threads/ThreadSpecificValue.h"
+#include "Runtime/Threads/ProfilerMutex.h"
+#endif
+
+#if !UNITY_EXTERNAL_TOOL
+#include "Runtime/Profiler/Profiler.h"
+#include "Runtime/Profiler/MemoryProfiler.h"
+#endif
+#include "Runtime/Allocator/MemoryManager.h"
+
+using namespace std;
+
+#define SHOW_REGISTERED_CLASS_INFO 0
+
+
+#if THREADED_LOADING
+#define CHECK_IN_MAIN_THREAD DebugAssertIf(!Thread::EqualsCurrentThreadID(GetPersistentManager().GetMainThreadID()));
+#define DEBUG_CHECK_IN_MAIN_THREAD AssertIf(!Thread::EqualsCurrentThreadID(GetPersistentManager().GetMainThreadID()));
+#else
+#define CHECK_IN_MAIN_THREAD
+#define DEBUG_CHECK_IN_MAIN_THREAD
+#endif
+
+
+static bool IsDerivedFromRTTI (const Object::RTTI* klass, const Object::RTTI* derivedFrom)
+{
+	const Object::RTTI* i = klass;
+	while (i)
+	{
+		if (derivedFrom == i)
+			return true;
+
+		i = i->base;
+	}
+	return false;
+}
+
+struct RegisterClassCallbackStruct
+{
+	RegisterClassCallback* registerClass;
+	RegisterClassCallback* initClassEarly;
+	RegisterClassCallback* initClass;
+	RegisterClassCallback* postInitClass;
+	RegisterClassCallback* cleanupClass;
+
+	RegisterClassCallbackStruct()
+	{
+		registerClass = initClassEarly = initClass = postInitClass = cleanupClass = NULL;
+	}
+};
+
+typedef UNITY_VECTOR(kMemPermanent, RegisterClassCallbackStruct) RegisterClassCallbacks;
+
+Object::IDToPointerMap*   Object::ms_IDToPointer = NULL;
+UInt32*	               Object::ms_IsDerivedFromBitMap = NULL;
+unsigned                    Object::ms_MaxClassID = 0;
+#if USE_NEW_IS_DERIVED_FROM
+UInt32 gClassIDMask[32];
+UInt32* Object::ms_ClassIDMask = 0;
+UInt32* Object::ms_ClassIsDerivedFrom = 0;
+#endif
+
+static RegisterClassCallbacks*                gRegisterClassCallbacks = NULL;
+
+#if defined(__MWERKS__)
+#error("Metrowerks should not be used")
+#endif
+
+#if DEBUGMODE
+RegisteredClassSet* gVerifyRegisteredClasses = NULL;
+#endif
+
+typedef map<char*, SInt32, smaller_cstring> StringToClassIDMap;
+typedef pair<const SInt32, Object::RTTI> SInt32RTTIPair;
+typedef map<SInt32, Object::RTTI, less<SInt32>, STL_ALLOCATOR(kMemPermanent, SInt32RTTIPair) > RTTIMap;
+
+static StringToClassIDMap*                    gStringToClassID = NULL;
+static RTTIMap*                               gRTTI = NULL;
+static dynamic_bitset*                        gRegisteredClassIDs = NULL;
+static dynamic_bitset*                        gIsDerivedFromBitMap = NULL;
+static Object::ObjectDestroyCallbackFunction* gDestroyedCallbackFunc = NULL;
+
+static int*                                   gBaseObjectManagerContainer = NULL;
+
+namespace BaseObjectManager
+{
+	void StaticInitialize()
+	{
+		gBaseObjectManagerContainer = UNITY_NEW_AS_ROOT(int, kMemBaseObject, "Managers", "BaseObjectManager");
+		SET_ALLOC_OWNER(gBaseObjectManagerContainer);
+		gStringToClassID = UNITY_NEW(StringToClassIDMap, kMemBaseObject);
+		gRTTI = UNITY_NEW(RTTIMap, kMemBaseObject);
+		gRegisteredClassIDs = UNITY_NEW(dynamic_bitset, kMemBaseObject);
+		gIsDerivedFromBitMap = UNITY_NEW(dynamic_bitset, kMemBaseObject);
+		Object::StaticInitialize();
+	}
+	void StaticDestroy()
+	{
+		Object::StaticDestroy();
+		UNITY_DELETE(gStringToClassID, kMemBaseObject);
+		UNITY_DELETE(gRTTI, kMemBaseObject);
+		UNITY_DELETE(gRegisteredClassIDs, kMemBaseObject);
+		UNITY_DELETE(gIsDerivedFromBitMap, kMemBaseObject);
+#if DEBUGMODE
+		UNITY_DELETE(gVerifyRegisteredClasses, kMemBaseObject); // allocated on first access
+#endif
+		UNITY_DELETE(gBaseObjectManagerContainer, kMemBaseObject);
+	}
+}
+
+static RegisterRuntimeInitializeAndCleanup s_BaseObjectManagerCallbacks(BaseObjectManager::StaticInitialize, BaseObjectManager::StaticDestroy);
+
+#if UNITY_EDITOR
+static Object::ObjectDirtyCallbackFunction*	  gSetDirtyCallbackFunc = NULL;
+#endif
+
+PROFILER_INFORMATION (gObjectCreationMutexLockInfo, "Object.CreateObject mutex lock", kProfilerLoading)
+
+#if THREADED_LOADING
+Mutex           gCreateObjectMutex;
+#if DEBUGMODE
+static UNITY_TLS_VALUE(int) gCheckObjectCreationMutex;
+#endif
+#endif
+
+void LockObjectCreation ()
+{
+	#if THREADED_LOADING
+	LOCK_MUTEX (gCreateObjectMutex, gObjectCreationMutexLockInfo);
+	#if DEBUGMODE
+		++gCheckObjectCreationMutex;
+	#endif
+	#endif
+}
+
+void UnlockObjectCreation ()
+{
+	#if THREADED_LOADING
+	gCreateObjectMutex.Unlock();
+	#if DEBUGMODE
+		--gCheckObjectCreationMutex;
+	#endif
+	#endif
+}
+
+
+static SInt32   gLowestInstanceID = -10;
+static bool   gDisableImmediateDestruction = false;
+
+#if UNITY_EDITOR
+InstanceIDResolveCallback* gInstanceIDResolveCallback = NULL;
+const void* gInstanceIDResolveContext = NULL;
+
+void SetInstanceIDResolveCallback (InstanceIDResolveCallback callback, const void* context)
+{
+	gInstanceIDResolveCallback = callback;
+	gInstanceIDResolveContext = context;
+}
+#endif
+
+void InstanceIDToLocalSerializedObjectIdentifier (SInt32 id, LocalSerializedObjectIdentifier& localIdentifier)
+{
+	#if UNITY_EDITOR
+	// Early out if referenced object is null
+	if (id == 0)
+	{
+		localIdentifier.localSerializedFileIndex = 0;
+		localIdentifier.localIdentifierInFile = 0;
+		return;
+	}
+
+	if (gInstanceIDResolveCallback == NULL)
+	{
+		GetPersistentManager ().InstanceIDToLocalSerializedObjectIdentifierInternal (id, localIdentifier);
+		return;
+	}
+	else
+	{
+		gInstanceIDResolveCallback (id, localIdentifier, const_cast<void*>(gInstanceIDResolveContext));
+	}
+	#else
+	GetPersistentManager ().InstanceIDToLocalSerializedObjectIdentifierInternal (id, localIdentifier);
+	#endif
+}
+
+void LocalSerializedObjectIdentifierToInstanceID (const LocalSerializedObjectIdentifier& localIdentifier, SInt32& instanceID)
+{
+	GetPersistentManager ().LocalSerializedObjectIdentifierToInstanceIDInternal (localIdentifier, instanceID);
+}
+
+Object* ReadObjectFromPersistentManager (int id)
+{
+	if (id == 0)
+		return NULL;
+	else
+	{
+		// In the Player it is not possible to call MakeObjectPersistent,
+		// thus instance id's that are positive are the only ones that can be loaded from disk
+		#if !UNITY_EDITOR
+		if (id < 0)
+		{
+			#if DEBUGMODE
+			//AssertIf(GetPersistentManager ().ReadObject (id));
+			#endif
+			return NULL;
+		}
+		#endif
+
+		Object* o = GetPersistentManager ().ReadObject (id);
+		return o;
+	}
+}
+
+void DestroyWithoutLoadingButDontDestroyFromFile (int instanceID)
+{
+	GetPersistentManager ().MakeObjectUnpersistent (instanceID, kDontDestroyFromFile);
+	UnloadObject(Object::IDToPointer(instanceID));
+}
+
+void DestroySingleObject (Object* o)
+{
+	if (o == NULL)
+		return;
+
+	if (o->IsPersistent())
+		GetPersistentManager ().MakeObjectUnpersistent (o->GetInstanceID (), kDestroyFromFile);
+
+	// Lock changes to IDToPointer so that we can safely lookup pointers using IDToPointerThreadSafe
+	LockObjectCreation();
+
+	delete_object_internal (o);
+
+	UnlockObjectCreation();
+}
+
+
+Object::Object (MemLabelId label, ObjectCreationMode mode)
+{
+	Assert(label.label < (1 << kMemLabelBits));
+	m_MemLabel = label.label;
+	m_InstanceID = 0;
+	m_EventIndex = NULL;
+
+	#if ENABLE_SCRIPTING
+	m_MonoReference = 0;
+	m_ScriptingObjectPointer = SCRIPTING_NULL;
+	#endif
+
+	#if !UNITY_RELEASE
+	m_AwakeCalled					= 0;
+	m_ResetCalled					= 0;
+	m_AwakeThreadedCalled			= 0;
+	m_AwakeDidLoadThreadedCalled	= 0;
+	#endif
+
+
+	#if UNITY_EDITOR
+	m_DirtyIndex = 0;
+	m_FileIDHint = 0;
+	#endif
+	m_HideFlags = 0;
+	m_TemporaryFlags = 0;
+	m_IsPersistent = false;
+
+	DebugAssert(GetMemoryManager().GetAllocator(GetMemoryLabel())->Contains(this));
+	m_IsRootOwner = GetMemoryManager().GetAllocator(GetMemoryLabel())->GetProfilerHeader(this) != NULL;
+	#if UNITY_WINRT
+	m_TemporaryUnusedAssetsFlags = 0;
+	#endif
+}
+
+void Object::CalculateCachedClassID (Object* obj) 
+{
+	Assert(obj->GetClassIDVirtualInternal() < (1 << kCachedClassIDBits));
+	obj->m_CachedClassID = obj->GetClassIDVirtualInternal();
+}
+
+void Object::InsertObjectInMap( Object* obj )
+{
+	SET_ALLOC_OWNER(gBaseObjectManagerContainer);
+	Assert (ms_IDToPointer->find (obj->GetInstanceID ()) == ms_IDToPointer->end ());
+	ms_IDToPointer->insert (make_pair (obj->GetInstanceID (), obj));
+	
+	PROFILER_REGISTER_OBJECT(obj);
+}
+
+void Object::RegisterInstanceID (Object* obj)
+{
+	CHECK_IN_MAIN_THREAD
+
+	LockObjectCreation();
+	Assert (obj != NULL);
+	AssertIf(obj->m_InstanceID == 0);
+	InsertObjectInMap (obj);
+	
+	UnlockObjectCreation();
+}
+
+void Object::RegisterInstanceIDNoLock (Object* obj)
+{
+	CHECK_IN_MAIN_THREAD
+	Assert (obj != NULL);
+	AssertIf (obj->m_InstanceID == 0);
+	CalculateCachedClassID (obj);
+	InsertObjectInMap (obj);
+}
+
+
+Object* Object::AllocateAndAssignInstanceID (Object* obj)
+{
+	CHECK_IN_MAIN_THREAD
+	AssertIf(obj->m_InstanceID != 0);
+
+	LockObjectCreation();
+
+	// Create a new unique instanceID for this Object.
+	// The created id will be negative beginning with -1
+	// Ids loaded from a file will be positive beginning with 1
+	gLowestInstanceID-=2;
+	obj->SetInstanceID (gLowestInstanceID);
+	AssertIf (obj->GetInstanceID () & 1);
+
+	CalculateCachedClassID (obj);
+	InsertObjectInMap (obj);
+
+	UnlockObjectCreation();
+
+	obj->SetDirty();
+
+	return obj;
+}
+
+Object* Object::AllocateAndAssignInstanceIDNoLock (Object* obj)
+{
+	CHECK_IN_MAIN_THREAD
+	AssertIf(obj->m_InstanceID != 0);
+
+	// Create a new unique instanceID for this Object.
+	// The created id will be negative beginning with -1
+	// Ids loaded from a file will be positive beginning with 1
+	gLowestInstanceID-=2;
+	obj->SetInstanceID (gLowestInstanceID);
+	AssertIf (obj->GetInstanceID () & 1);
+	
+	CalculateCachedClassID (obj);
+
+	InsertObjectInMap (obj);
+
+	obj->SetDirty();
+
+	return obj;
+}
+
+enum { kMonoObjectCachedPtrOffset = 12 };
+
+
+// This must be executed on the main thread
+void delete_object_internal_step1 (Object* object)
+{
+	PROFILER_UNREGISTER_OBJECT(object);
+	
+#if !UNITY_RELEASE
+	object->CheckCorrectAwakeUsage();
+#endif
+	
+#if THREADED_LOADING && DEBUGMODE
+	Assert(gCheckObjectCreationMutex >= 1);
+#endif
+	
+	// Send destroy message & clear event index
+	if (object->m_EventIndex != NULL)
+	{
+		GetEventManager().InvokeEvent(object->m_EventIndex, object, kWillDestroyEvent);
+		GetEventManager().RemoveEvent(object->m_EventIndex);
+		object->m_EventIndex = NULL;
+	}
+	
+	// Remove this objects instanceID from the table.
+	AssertIf (Object::ms_IDToPointer->find (object->GetInstanceID ()) == Object::ms_IDToPointer->end ());
+	Object::ms_IDToPointer->erase (object->GetInstanceID ());
+
+	if (gDestroyedCallbackFunc)
+		gDestroyedCallbackFunc (object->GetInstanceID ());
+	
+	object->m_InstanceID = 0;
+}
+
+Object::~Object ()
+{
+	// Ensure PreCleanupObject was called
+	#if DEBUGMODE
+	Assert(m_InstanceID == 0);
+	#endif	
+	
+#if ENABLE_MONO //if unity3.5 succesfully shipped with this assert it may be removed. here to verify an assumption made in a refactor.
+	Assert((m_MonoReference==0) == (m_ScriptingObjectPointer==NULL));
+#endif
+	
+#if ENABLE_SCRIPTING
+	if (m_ScriptingObjectPointer)
+		SetCachedScriptingObject(SCRIPTING_NULL);
+#endif
+}
+
+bool Object::MainThreadCleanup ()
+{
+	AssertString("MainThreadCleanup is not implemented for this class. See DoesClassRequireMainThreadDeallocation");
+	return false;
+}
+
+void Object::SetIsPersistent( bool p )
+{
+	PROFILER_CHANGE_PERSISTANCY(GetInstanceID(), m_IsPersistent, p);
+	m_IsPersistent = p;
+}
+
+#if ENABLE_SCRIPTING
+
+#if UNITY_PS3 || UNITY_XENON
+	extern "C" char* GC_clear_stack(char*);
+#endif
+
+void Object::SetupWeakHandle ()
+{
+	if (m_MonoReference != 0)
+	{
+		register ScriptingObjectPtr object = scripting_gchandle_get_target(m_MonoReference);
+		UInt32 weakref = scripting_gchandle_weak_new (object);
+		SetCachedScriptingObject(SCRIPTING_NULL);
+
+#if UNITY_PS3 || UNITY_XENON
+		// we need to make sure the object doesn't continue living on the stack.		// fixes http://fogbugz.unity3d.com/default.asp?444901#1065992062
+		GC_clear_stack((char*)object);
+#endif
+		object = SCRIPTING_NULL;
+		m_MonoReference = weakref;
+	}
+}
+
+bool Object::RevertWeakHandle ()
+{
+	if (m_MonoReference != 0)
+	{
+		ScriptingObjectPtr target = scripting_gchandle_get_target (m_MonoReference);
+		scripting_gchandle_free(m_MonoReference);
+		m_MonoReference = 0;
+		if (target)
+		{
+			SetCachedScriptingObject(target);
+#if UNITY_WINRT
+			// Restore cached ptr for managed object, not sure why we don't do this for Mono as well, because we reset cachedPtr in SetupWeakHandle
+			// But on Mono it seems cachedPtr persists ?!
+			// Maybe it's related to cachedPtr optimization
+			register ScriptingObjectOfType<Object> instance(m_ScriptingObjectPointer);
+			instance.SetCachedPtr(this);
+#endif
+		}
+		return target != SCRIPTING_NULL;
+	}
+	else
+		return false;
+}
+
+
+void Object::SetCachedScriptingObject (ScriptingObjectPtr object)
+{
+	if (object)
+	{
+		AssertIf(m_MonoReference != 0);
+		m_MonoReference = scripting_gchandle_new (object);
+		m_ScriptingObjectPointer = object;
+		return;
+	}
+
+	if (m_ScriptingObjectPointer == SCRIPTING_NULL)
+	{
+		AssertString("Dont do this");
+		return;
+	}
+
+	register ScriptingObjectOfType<Object> instance(m_ScriptingObjectPointer);
+	instance.SetCachedPtr(0);
+
+	scripting_gchandle_free (m_MonoReference);
+	m_MonoReference = 0;
+
+	m_ScriptingObjectPointer = SCRIPTING_NULL;
+#if UNITY_WINRT
+	instance = ScriptingObjectPtr(SCRIPTING_NULL);
+#else
+	instance = SCRIPTING_NULL;
+#endif
+}
+#endif
+
+void Object::RegisterDestroyedCallback (ObjectDestroyCallbackFunction* callback)
+{
+	gDestroyedCallbackFunc = callback;
+}
+
+// Register base class
+void Object::RegisterClass ()
+{
+	RegisterClass (ClassID (Object), -1, "Object", sizeof (Object), NULL, true);
+}
+
+void Object::RegisterClass (int inClassID, int inBaseClass, const string& inName, int byteSize, FactoryFunction* inFunc, bool isAbstract)
+{
+	if (ClassIDToRTTI (inClassID))
+		return;
+
+	// Store ClassID -> RTTI
+	AssertIf (gRTTI->find (inClassID) != gRTTI->end ());
+	RTTIMap::iterator baseClass = gRTTI->find (inBaseClass);
+	AssertIf (baseClass == gRTTI->end () && inBaseClass != -1);
+	Object::RTTI& classInfo = (*gRTTI)[inClassID];
+	classInfo.base = baseClass == gRTTI->end () ? NULL : &baseClass->second;
+	classInfo.factory = inFunc;
+	classInfo.className = inName;
+	classInfo.classID = inClassID;
+	classInfo.isAbstract = isAbstract;
+	classInfo.size = byteSize;
+
+	// Store String -> ClassID
+	AssertIf (gStringToClassID->find (const_cast<char*> (inName.c_str ())) != gStringToClassID->end ());
+	(*gStringToClassID)[const_cast<char*> (classInfo.className.c_str ())] = inClassID;
+}
+
+Object* Object::Produce (int classID, int instanceID, MemLabelId memLabel, ObjectCreationMode mode)
+{
+	// Object is already loaded assert
+	AssertIf (mode == kCreateObjectDefault && IDToPointer (instanceID) != NULL);
+	AssertIf (instanceID == 0 && mode == kCreateObjectFromNonMainThread);
+	#if THREADED_LOADING
+	AssertIf (!Thread::EqualsCurrentThreadID(GetPersistentManager().GetMainThreadID()) && mode != kCreateObjectFromNonMainThread);
+	#endif
+	AssertIf (instanceID & 1);
+
+	// Find the appropriate Factory.
+	RTTIMap::iterator i;
+	i = gRTTI->find (classID);
+	if (i == gRTTI->end () || i->second.factory == NULL)
+	{
+		return NULL;
+	}
+
+	Object* o;
+	if (instanceID != 0)
+	{
+		o = i->second.factory (memLabel, mode);
+		if (o == NULL)
+			return NULL;
+		o->SetInstanceID(instanceID);
+		CalculateCachedClassID (o);
+
+		// Register instanceID and set dirty
+		if (mode == kCreateObjectDefault)
+		{
+			RegisterInstanceID(o);
+			o->SetDirty();
+		}
+		else if (mode == kCreateObjectDefaultNoLock)
+		{
+			RegisterInstanceIDNoLock(o);
+			o->SetDirty();
+		}
+
+		return o;
+	}
+	else
+	{
+		AssertIf(mode != kCreateObjectDefaultNoLock && mode != kCreateObjectDefault);
+		o = i->second.factory (memLabel, mode);
+
+		if (mode == kCreateObjectDefaultNoLock)
+			AllocateAndAssignInstanceIDNoLock(o);
+		else
+			AllocateAndAssignInstanceID(o);
+		return o;
+	}
+}
+
+void Object::CheckInstanceIDsLoaded (SInt32* instanceIDs, int size)
+{
+	for (int i=0;i<size;i++)
+	{
+		if (ms_IDToPointer->count (instanceIDs[i]))
+			instanceIDs[i] = 0;
+	}
+}
+
+#if !UNITY_RELEASE
+Object* Object::IDToPointer (int inInstanceID)
+{
+	DEBUG_CHECK_IN_MAIN_THREAD
+
+	return Object::IDToPointerNoThreadCheck (inInstanceID);
+}
+#endif
+
+Object* Object::IDToPointerThreadSafe (int inInstanceID)
+{
+	LockObjectCreation();
+	Object* obj = Object::IDToPointerNoThreadCheck (inInstanceID);
+		UnlockObjectCreation();
+		return obj;
+}
+
+Object* Object::IDToPointerNoThreadCheck (int inInstanceID)
+{
+	if( !ms_IDToPointer) return NULL;
+
+	IDToPointerMap::const_iterator i = ms_IDToPointer->find (inInstanceID);
+	if (i != ms_IDToPointer->end ())
+	{
+		return i->second;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+#if THREADED_LOADING
+Object* InstanceIDToObjectThreadSafe (int instanceID)
+{
+	if (Thread::EqualsCurrentThreadID (GetPersistentManager().GetMainThreadID()))
+		return PPtr<Object> (instanceID);
+	else
+	{
+		Object* obj = Object::IDToPointerThreadSafe(instanceID);
+		if (obj == NULL)
+			return GetPersistentManager().ReadObjectThreaded(instanceID);
+		else
+		return obj;
+	}
+}
+#endif
+
+void Object::FindAllDerivedClasses (int classID, vector<SInt32>* derivedClasses, bool onlyNonAbstract)
+{
+	AssertIf (derivedClasses == NULL);
+	RTTIMap::iterator i;
+	for (i=gRTTI->begin ();i!=gRTTI->end ();i++)
+	{
+		if (IsDerivedFromClassID (i->first, classID) && (!onlyNonAbstract || !i->second.isAbstract))
+			derivedClasses->push_back (i->first);
+	}
+}
+
+struct GetConstFirst
+{
+	template<typename T1, typename T2>
+	const T1& operator()(const std::pair<T1, T2>& p) const {
+		return p.first;
+	}
+};
+
+struct GetConstSecond
+{
+	template<typename T1, typename T2>
+	const T2& operator()(const std::pair<T1, T2>& p) const {
+		return p.second;
+	}
+};
+
+struct IsDerivedFromClass
+{
+	IsDerivedFromClass(int classID): m_ClassID(classID) {}
+	bool operator()(const Object::IDToPointerMap::value_type& el) const
+	{
+		return el.second->IsDerivedFrom (m_ClassID);
+	}
+private:
+	int m_ClassID;
+};
+
+inline int DerivedObjectCount(const Object::IDToPointerMap& objmap, int classID)
+{
+	return std::count_if(objmap.begin(), objmap.end(), IsDerivedFromClass(classID));
+}
+
+template<typename ObjectGetter, typename Container, typename Predicate>
+inline int FindAllDerivedObjectsImpl (const Object::IDToPointerMap& objmap, int classID,
+	ObjectGetter getter, Container* derivedObjects, bool sorted, Predicate pred)
+{
+	if (NULL == derivedObjects)
+		return DerivedObjectCount(objmap, classID);
+
+	int count = 0;
+	for (typename Object::IDToPointerMap::const_iterator i = objmap.begin();
+		i != objmap.end(); ++i)
+	{
+		if (i->second->IsDerivedFrom (classID))
+		{
+			derivedObjects->push_back (getter(*i));
+			count++;
+		}
+	}
+
+	if (sorted && count)
+		std::sort(derivedObjects->begin(), derivedObjects->end(), pred);
+
+	return count;
+}
+
+int Object::FindAllDerivedObjects (int classID, vector<SInt32>* derivedObjects, bool sorted)
+{
+	return FindAllDerivedObjectsImpl (*ms_IDToPointer, classID,
+		GetConstFirst(), derivedObjects, sorted, std::less<SInt32>());
+}
+
+struct CompareInstanceID
+{
+	bool operator () (const Object* lhs, const Object* rhs)  const
+	{
+		return lhs->GetInstanceID() < rhs->GetInstanceID();
+	}
+};
+
+int Object::FindObjectsOfType (int classID, vector<Object*>* derivedObjects, bool sorted)
+{
+	return FindAllDerivedObjectsImpl (*ms_IDToPointer, classID,
+		GetConstSecond(), derivedObjects, sorted, CompareInstanceID());
+}
+
+int Object::FindObjectsOfType (int classID, dynamic_array<Object*>* derivedObjects, bool sorted)
+{
+	int count = 0;
+	IDToPointerMap::iterator i;
+	for (i=ms_IDToPointer->begin ();i!=ms_IDToPointer->end ();i++)
+	{
+		if (i->second->IsDerivedFrom (classID))
+		{
+			if (derivedObjects != NULL)
+				derivedObjects->push_back (i->second);
+			count++;
+		}
+	}
+
+
+	if (sorted && derivedObjects != NULL)
+	{
+		CompareInstanceID compare;
+		sort(derivedObjects->begin(), derivedObjects->end(), compare);
+	}
+
+
+	return count;
+}
+
+
+const std::string& Object::ClassIDToString (int ID)
+{
+	static std::string emptyString;
+	RTTIMap::iterator i = gRTTI->find (ID);
+	if (i == gRTTI->end ())
+		return emptyString;
+	else
+		return i->second.className;
+}
+
+int Object::StringToClassID (const string& classString)
+{
+	StringToClassIDMap::iterator i;
+	i = gStringToClassID->find (const_cast<char*> (classString.c_str ()));
+	if (i == gStringToClassID->end ())
+		return -1;
+	else
+		return i->second;
+}
+
+int Object::StringToClassIDCaseInsensitive (const string& classString)
+{
+	StringToClassIDMap::iterator i;
+	string lowerClass = ToLower(classString);
+	for (StringToClassIDMap::iterator i = gStringToClassID->begin(); i!=gStringToClassID->end(); i++)
+	{
+		if (ToLower(string(i->first)) == lowerClass)
+			return i->second;
+	}
+	return -1;
+}
+
+int Object::StringToClassID (const char* classString)
+{
+	StringToClassIDMap::iterator i;
+	i = gStringToClassID->find (const_cast<char*> (classString));
+	if (i == gStringToClassID->end ())
+		return -1;
+	else
+		return i->second;
+}
+
+const std::string& Object::GetClassName () const
+{
+	return Object::ClassIDToString (GetClassID ());
+}
+
+int Object::GetSuperClassID (int classID)
+{
+	RTTIMap::iterator i = gRTTI->find (classID);
+	AssertIf (i == gRTTI->end ());
+	if (i->second.base)
+		return i->second.base->classID;
+	else
+		return ClassID (Object);
+}
+
+Object::RTTI* Object::ClassIDToRTTI (int classID)
+{
+	RTTIMap::iterator i = gRTTI->find (classID);
+	if (i == gRTTI->end ())
+		return NULL;
+	else
+		return &i->second;
+}
+
+struct BuildClassInfo
+{
+	Object::RTTI* klass;
+	Object::RTTI* base;
+	UInt32 id;
+	UInt32 subclasses;
+	UInt32 level;
+	UInt32 newId;
+	UInt32 subClassIdAssign;
+	void Clear(){
+	       base = 0;
+	       klass = 0;
+	       id = (UInt32)-1;
+	       subclasses = 0;
+	       level = 0xffffffff;
+	       newId = -1;
+	       subClassIdAssign = 0;
+	}
+	void Init(Object::RTTI* klass, Object::RTTI* base)
+	{
+		this->klass = klass;
+		this->base = base;
+	}
+	bool operator <( const BuildClassInfo& o) const
+	{
+		return level < o.level;
+	}
+};
+int bitsRequired(int subclasses)
+{
+	int r = 0;
+	while(subclasses)
+	{
+		r++;
+		subclasses >>= 1;
+	}
+	return r;
+}
+
+void Object::StaticInitialize()
+{
+	SET_ALLOC_OWNER(gBaseObjectManagerContainer);
+	Object::ms_IDToPointer = UNITY_NEW(Object::IDToPointerMap (1024 * 128), kMemBaseObject);
+}
+
+void Object::StaticDestroy()
+{
+	UNITY_DELETE(Object::ms_IDToPointer,kMemBaseObject);
+}
+
+void Object::InitializeAllClasses ()
+{
+	SET_ALLOC_OWNER(gBaseObjectManagerContainer);
+	
+	if (gRegisterClassCallbacks == NULL)
+		return;
+
+#if SHOW_REGISTERED_CLASS_INFO
+	int registeredClasses = 0;
+#endif
+
+	RegisterClassCallbacks& callbacks = *gRegisterClassCallbacks;
+	// The callback is the RegisterClass function defined in ObjectDefines.h
+	// It calls the static Object::RegisterClass function which sets up the rtti system
+	for (int i=0;i<callbacks.size ();i++)
+	{
+		if (callbacks[i].registerClass)
+		{
+			callbacks[i].registerClass ();
+#if SHOW_REGISTERED_CLASS_INFO
+			++registeredClasses;
+#endif
+		}
+	}
+
+#if SHOW_REGISTERED_CLASS_INFO
+	printf_console ("Object::InitializeAllClasses: %d total, %d registered\n", callbacks.size(), registeredClasses);
+#endif
+
+	AssertIf (gRTTI->empty ());
+
+	// Setup ms_IsDerivedFrom lookup bitmap
+	if (UNITY_EDITOR)
+	{
+		ms_MaxClassID = (--gRTTI->end ())->first + 1;
+		Assert(kLargestEditorClassID == ms_MaxClassID);
+	}
+	else
+	{
+		ms_MaxClassID = kLargestRuntimeClassID;
+	}
+
+	gIsDerivedFromBitMap->resize (ms_MaxClassID * ms_MaxClassID, false);
+	ms_IsDerivedFromBitMap = (UInt32*) gIsDerivedFromBitMap->m_bits;
+	gRegisteredClassIDs->resize (ms_MaxClassID, false);
+	for (int i=0;i<ms_MaxClassID;i++)
+	{
+		RTTIMap::iterator iRTTI = gRTTI->find (i);
+		(*gRegisteredClassIDs)[i] = iRTTI != gRTTI->end ();
+		if ((*gRegisteredClassIDs)[i])
+		{
+			for (int j=0;j<ms_MaxClassID;j++)
+			{
+				RTTIMap::iterator jRTTI = gRTTI->find (j);
+				if (jRTTI != gRTTI->end ())
+					(*gIsDerivedFromBitMap)[i * ms_MaxClassID + j] = IsDerivedFromRTTI (&iRTTI->second, &jRTTI->second);
+			}
+		}
+	}
+
+#if USE_NEW_IS_DERIVED_FROM
+	ms_ClassIDMask = &gClassIDMask[0];
+	ms_ClassIsDerivedFrom = new UInt32[ms_MaxClassID];
+	memset(ms_ClassIsDerivedFrom, 0xffffffff, sizeof(UInt32) * ms_MaxClassID);
+	ms_ClassIsDerivedFrom[0] = 1;
+	BuildClassInfo* info = (BuildClassInfo*)alloca(sizeof(BuildClassInfo) * ms_MaxClassID);
+	for(int i = 0; i < ms_MaxClassID; ++i)
+		info[i].Clear();
+	int maxSubClasses[32];
+	int bitShift[32];
+	memset(maxSubClasses, 0, sizeof(maxSubClasses));
+	memset(bitShift, 0, sizeof(bitShift));
+	//search for the base class
+	typedef RTTIMap::iterator itr;
+	for(itr i = gRTTI->begin(); i != gRTTI->end(); ++i)
+	{
+		Object::RTTI& r = i->second;
+		SInt32 oldId = i->first;
+		info[oldId].Init(&r, r.base);
+		info[oldId].id = oldId;
+		int level = 0;
+		Object::RTTI* base = r.base;
+		while(base)
+		{
+			++level;
+			base = base->base;
+		}
+		info[oldId].level = level;
+		if(r.base)
+			info[r.base->classID].subclasses++;
+	}
+	std::sort(&info[0], ms_MaxClassID + &info[0]);
+	for(int i = 0; i < ms_MaxClassID; ++i)
+	{
+		int level = info[i].level;
+		maxSubClasses[level] = info[i].subclasses > maxSubClasses[level] ? info[i].subclasses : maxSubClasses[level];
+	}
+	int totalBits = 1;
+	UInt32 mask = 1;
+	bitShift[0] = 0;
+	gClassIDMask[0] = 1;
+	for(int i = 1; i < 32; ++i)
+	{
+		int bitsReq = bitsRequired(maxSubClasses[i-1]);
+		int bitsReq1 = bitsReq;
+		while(bitsReq--)
+			mask = (mask<<1) | 1;
+
+		bitShift[i] = totalBits;
+		totalBits += bitsReq1;
+		AssertIf(totalBits > 32 - CLASS_ID_MASK_BITS); //OUT OF BITS
+		gClassIDMask[i] = mask;
+	}
+#define VERIFY_CLASS_IDS 0
+#if VERIFY_CLASS_IDS
+	std::set<UInt32> ClassIdSet;
+#endif
+	int lastIndex = 0;
+	for(int i = 0; i < ms_MaxClassID; ++i)
+	{
+		Object::RTTI* klass = info[i].klass;
+		Object::RTTI* base = info[i].base;
+		int level = info[i].level;
+		int parentId = 0;
+		int parentIndex = -1;
+		int parentSubIndex = 1;
+		if(base)
+		{
+			for(int j = 0; j < ms_MaxClassID; ++j)
+			{
+				if(info[j].klass == base)
+				{
+					parentIndex = j;
+					break;
+				}
+			}
+			AssertIf(parentIndex >= i);
+			parentId = info[parentIndex].newId & CLASS_ID_MASK_IDS;
+			AssertIf(-1 == parentId);
+			parentSubIndex = info[parentIndex].subClassIdAssign++;
+		}
+		else
+		{
+			parentSubIndex = 1;
+			if(i != 0)
+			{
+				lastIndex = i;
+				break;
+			}
+		}
+		int shift = bitShift[level];
+		int id = (parentSubIndex << shift) | parentId;
+		int fullId = id | (level<<(32-CLASS_ID_MASK_BITS));
+#if VERIFY_CLASS_IDS
+		AssertIf(ClassIdSet.find(fullId) != ClassIdSet.end() || ClassIdSet.find(id) != ClassIdSet.end() ); // DUPE CLASSID. should never happen
+		ClassIdSet.insert(id);
+		ClassIdSet.insert(fullId);
+#endif
+		info[i].newId = fullId;
+		ms_ClassIsDerivedFrom[info[i].id] = fullId;
+		AssertIf(info[i].subClassIdAssign != 0);
+		info[i].subClassIdAssign = 1;
+	}
+#endif
+}
+
+void Object::CallInitializeClass()
+{
+	RegisterClassCallbacks& callbacks = *gRegisterClassCallbacks;
+
+	// Call the IntializeClass function for classes that registered for it (IMPLEMENT_CLASS_HAS_INIT)
+	// This is done after all classes are registered and the rtti setup
+	// so that the rtti system can be used insie InitializeClass ()
+	for (int i=0;i<callbacks.size ();i++)
+	{
+		if (callbacks[i].initClass)
+		{
+			callbacks[i].initClass ();
+		}
+	}
+}
+
+void Object::CallPostInitializeClass()
+{
+	RegisterClassCallbacks& callbacks = *gRegisterClassCallbacks;
+
+	// Call the PostIntializeClass function for classes that registered for it (IMPLEMENT_CLASS_HAS_POSTINIT)
+	// This is done after all classes are registered and the rtti setup
+	// so that the rtti system can be used inside PostInitializeClass ()
+	for (int i=0;i<callbacks.size ();i++)
+	{
+		if (callbacks[i].postInitClass)
+		{
+			callbacks[i].postInitClass ();
+		}
+	}
+}
+
+void Object::AddEvent (EventCallback* callback, void* userData)
+{
+	m_EventIndex = GetEventManager().AddEvent(callback, userData, m_EventIndex);
+}
+
+void Object::RemoveEvent (EventCallback* callback, void* userData)
+{
+	m_EventIndex = GetEventManager().RemoveEvent(m_EventIndex, callback, userData);
+}
+
+bool Object::HasEvent (EventCallback* callback, const void* userData) const
+{
+	return EventManager::HasEvent(m_EventIndex, callback, userData);
+}
+
+void Object::InvokeEvent (int eventType)
+{
+	EventManager::InvokeEvent(m_EventIndex, this, eventType);
+}
+
+bool IsObjectAvailable (int instanceID)
+{
+	Object* temp = Object::IDToPointer (instanceID);
+	if (temp != NULL)
+		return true;
+
+	return GetPersistentManager ().IsObjectAvailable (instanceID);
+}
+#if !USE_NEW_IS_DERIVED_FROM
+#if !UNITY_RELEASE
+
+bool Object::IsDerivedFromClassID (int classID, int compareClass)
+{
+	if (classID >= ms_MaxClassID || classID < 0)
+	{
+		char buffy[512];
+		sprintf (buffy, "The class with classID: %d out of bounds", classID);
+		AssertString (buffy);
+		return false;
+	}
+	if (compareClass >= ms_MaxClassID || compareClass < 0)
+	{
+	/*
+		char buffy[512];
+		sprintf (buffy, "The compare class with classID: %d out of bounds", compareClass);
+		AssertString (buffy);
+	*/
+		return false;
+	}
+
+	AssertIf (classID >= ms_MaxClassID || classID < 0);
+	AssertIf (compareClass >= ms_MaxClassID || compareClass < 0);
+
+
+	if (!(*gRegisteredClassIDs)[classID])
+	{
+		char buffy[512];
+		sprintf (buffy, "The class with classID: %d is not registered (see ClassIDs.h)", classID);
+		AssertString (buffy);
+
+	}
+
+	// When doing classID stripping
+	#if !ALLOW_CLASS_ID_STRIPPING
+	if (!(*gRegisteredClassIDs)[compareClass])
+	{
+		char buffy[512];
+		sprintf (buffy, "The class with classID: %d is not registered (see ClassIDs.h)", compareClass);
+		AssertString (buffy);
+	}
+	#endif
+
+	int index = classID * ms_MaxClassID + compareClass;
+	int block = index >> 5;
+	int bit = index - (block << 5);
+	return (ms_IsDerivedFromBitMap[block]) & (1 << bit);
+}
+
+#endif
+#endif
+
+INSTANTIATE_TEMPLATE_TRANSFER_WITH_DECL (Object, EXPORTDLL);
+
+template<class TransferFunction>
+void Object::Transfer (TransferFunction& transfer)
+{
+#if UNITY_EDITOR
+	if (!transfer.IsSerializingForGameRelease() && SerializePrefabIgnoreProperties(transfer))
+	{
+		UInt32 flags = m_HideFlags;
+		transfer.Transfer(flags, "m_ObjectHideFlags", kHideInEditorMask);
+		m_HideFlags = flags;
+	}
+
+	if (transfer.GetFlags () & kSerializeDebugProperties)
+	{
+		SInt32 instanceID = GetInstanceID ();
+		transfer.Transfer (instanceID, "m_InstanceID");
+
+		LocalIdentifierInFileType fileID;
+		if (IsPersistent ())
+			fileID = GetPersistentManager ().GetLocalFileID (instanceID);
+		else
+			fileID = GetFileIDHint ();
+
+		transfer.Transfer (fileID, "m_LocalIdentfierInFile");
+	}
+#endif
+}
+
+#if UNITY_EDITOR
+
+void Object::RegisterDirtyCallback (ObjectDirtyCallbackFunction* callback)
+{
+	gSetDirtyCallbackFunc = callback;
+}
+
+Object::ObjectDirtyCallbackFunction* Object::GetDirtyCallback ()
+{
+	return gSetDirtyCallbackFunc;
+}
+
+void Object::SetDirty ()
+{
+	// When we run out of dirty indices, make sure it stays at 1
+	m_DirtyIndex++;
+	if (m_DirtyIndex == 0)
+		m_DirtyIndex = 1;
+
+	if (gSetDirtyCallbackFunc)
+		gSetDirtyCallbackFunc (this);
+
+	#if !UNITY_RELEASE
+		m_DEBUGCLASSID = GetClassID ();
+	#endif
+}
+
+void Object::ClearPersistentDirty ()
+{
+	m_DirtyIndex = 0;
+}
+
+void Object::SetPersistentDirtyIndex (UInt32 dirtyValue)
+{
+	m_DirtyIndex = dirtyValue;
+}
+
+
+#endif
+
+#if DEBUGMODE
+void AddVerifyClassRegistration (int classID)
+{
+	if (gVerifyRegisteredClasses == NULL)
+	{
+		SET_ALLOC_OWNER(gBaseObjectManagerContainer);
+		gVerifyRegisteredClasses = UNITY_NEW(RegisteredClassSet, kMemManager)();
+	}
+	gVerifyRegisteredClasses->insert(classID);
+}
+const RegisteredClassSet& GetVerifyClassRegistration ()
+{
+	if (gVerifyRegisteredClasses == NULL)
+	{
+		SET_ALLOC_OWNER(gBaseObjectManagerContainer);
+		gVerifyRegisteredClasses = UNITY_NEW(RegisteredClassSet, kMemManager)();
+	}
+	return *gVerifyRegisteredClasses;
+}
+
+#endif
+
+
+void RegisterInitializeClassCallback (int classID,
+									  RegisterClassCallback* registerClass,
+									  RegisterClassCallback* initClass,
+									  RegisterClassCallback* postInitClass,
+									  RegisterClassCallback* cleanupClass)
+{
+	if (gRegisterClassCallbacks == NULL)
+	{
+		SET_ALLOC_OWNER(gBaseObjectManagerContainer);
+		gRegisterClassCallbacks = UNITY_NEW(RegisterClassCallbacks,kMemBaseObject);
+	}
+	if (gRegisterClassCallbacks->size () <= classID)
+		gRegisterClassCallbacks->resize (classID + 1);
+
+	RegisterClassCallbacks& callbacks = *gRegisterClassCallbacks;
+	if (callbacks[classID].registerClass != NULL || callbacks[classID].initClass != NULL || callbacks[classID].postInitClass != NULL || callbacks[classID].cleanupClass != NULL)
+	{
+		char buffer[512];
+		sprintf (buffer, "ClassID: %d is already registered. ClassID's have to be unique", classID);
+		FatalErrorString (buffer);
+		AssertBreak(false);
+	}
+	callbacks[classID].registerClass = registerClass;
+	callbacks[classID].initClass = initClass;
+	callbacks[classID].postInitClass = postInitClass;
+	callbacks[classID].cleanupClass = cleanupClass;
+}
+
+void Object::CleanupAllClasses ()
+{
+	AssertIf(!ms_IDToPointer->empty());
+
+	if (!gRegisterClassCallbacks)
+		return;
+
+	RegisterClassCallbacks& callbacks = *gRegisterClassCallbacks;
+	for (int i=0;i<callbacks.size ();i++)
+	{
+		if (callbacks[i].cleanupClass)
+			callbacks[i].cleanupClass ();
+	}
+
+	UNITY_DELETE(gRegisterClassCallbacks, kMemBaseObject);
+}
+
+void SetDisableImmediateDestruction (bool disable)
+{
+	gDisableImmediateDestruction = disable;
+}
+
+bool GetDisableImmediateDestruction ()
+{
+	return gDisableImmediateDestruction;
+}
+
+void delete_object_internal (Object* p)
+{
+	if (!p)
+		return;
+
+	delete_object_internal_step1 (p);
+	delete_object_internal_step2 (p);
+}
+
+// This can be execute on any thread.
+void delete_object_internal_step2 (Object* p)
+{
+	MemLabelId label = p->GetMemoryLabel();
+	p->~Object ();
+	UNITY_FREE(label, p);
+}
+
+void UnloadObject (Object* p)
+{
+	if (!p)
+		return;
+
+	LockObjectCreation();
+	delete_object_internal(p);
+	UnlockObjectCreation();
+}
+
+void Object::DoneLoadingManagers()
+{
+	// We are done loading managers. Start instance IDs from a high constant value here,
+	// so new managers and built-in resources can be added without changed instanceIDs
+	// used by the content.
+	if (gLowestInstanceID > -10000)
+	{
+		gLowestInstanceID = -10000;
+	}
+}
+
+MemLabelId Object::GetMemoryLabel() const
+{
+	MemLabelIdentifier id = (MemLabelIdentifier)m_MemLabel;
+	MemLabelId label(id, NULL);
+	if(m_IsRootOwner)
+		label.SetRootHeader(GET_ALLOC_HEADER((void*)this, label));
+	return label;
+}
+
+int Object::GetRuntimeMemorySize() const
+{
+#if ENABLE_MEM_PROFILER
+	return GetMemoryProfiler()->GetRelatedMemorySize((void*)this);
+#else
+	return 0;
+#endif
+}
+
+
+#if !UNITY_RELEASE
+
+void Object::CheckCorrectAwakeUsage()
+{
+	// check only if saw that object already to allow delayed awake and immediate destroy
+	if ( m_AwakeCalled == 0 )
+		AssertStringObject(Format("Awake has not been called '%s' (%s). Figure out where the object gets created and call AwakeFromLoad correctly.", GetName(), GetClassName().c_str()), this);
+
+	if ( m_ResetCalled == 0 )
+		AssertStringObject(Format("Reset has not been called '%s' (%s). Figure out where the object gets created and call Reset correctly.", GetName(), GetClassName().c_str()), this);
+
+	if ( m_AwakeThreadedCalled && !m_AwakeDidLoadThreadedCalled )
+		AssertStringObject(Format("AwakeFromLoadThreaded has not been called '%s' (%s). Figure out where the object gets created and call AwakeFromLoadThreaded correctly.", GetName(), GetClassName().c_str()), this);
+}
+
+
+#endif // !UNITY_RELEASE