+Unity Runtime codeHEADmaster

1 files changed, 1162 insertions, 0 deletions

diff --git a/Runtime/BaseClasses/BaseObject.h b/Runtime/BaseClasses/BaseObject.h
new file mode 100644
index 0000000..52613be
--- /dev/null
+++ b/Runtime/BaseClasses/BaseObject.h
@@ -0,0 +1,1162 @@
+#ifndef BASEOBJECT_H
+#define BASEOBJECT_H
+
+#include "Runtime/Utilities/LogAssert.h"
+#include "Runtime/Serialize/SerializeUtility.h"
+#include "Runtime/Serialize/SerializationMetaFlags.h"
+#include "Configuration/UnityConfigure.h"
+#include "Runtime/Utilities/Prefetch.h"
+#include "Runtime/Scripting/Backend/ScriptingTypes.h"
+#include "Runtime/Misc/Allocator.h"
+#include "Runtime/Utilities/dynamic_array.h"
+
+#include <string>
+#include <vector>
+
+#include "Runtime/Utilities/dense_hash_map.h"
+#include "Runtime/Utilities/HashFunctions.h"
+
+#include "Runtime/BaseClasses/ClassIDs.h"
+
+class ProxyTransfer;
+class SafeBinaryRead;
+template<bool kSwap>
+class StreamedBinaryRead;
+template<bool kSwap>
+class StreamedBinaryWrite;
+class RemapPPtrTransfer;
+class TypeTree;
+class Object;
+struct EventEntry;
+#if SUPPORT_TEXT_SERIALIZATION
+class YAMLRead;
+class YAMLWrite;
+#endif
+
+#include "ObjectDefines.h"
+#include <string>
+#include <typeinfo>
+
+//#define		DefineClassID( x, classID )
+//#define		ClassID( x )
+
+// Every non-abstract class that is derived from object has to place this inside the class Declaration
+// (REGISTER_DERIVED_CLASS (Foo, Object))
+
+// Every abstract class that is derived from object has to place this inside the class Declaration
+// (REGISTER_DERIVED_ABSTRACT_CLASS (Foo, Object))
+
+//In the cpp file of every object derived class you have to place eg. IMPLEMENT_CLASS (Foo)
+//#define IMPLEMENT_CLASS(x)
+// or IMPLEMENT_CLASS_HAS_INIT (x) which will call the static class Function InitializeClass (); on startup.
+
+using std::string;
+
+template<class T>
+class PPtr
+{
+	SInt32	m_InstanceID;
+	#if !UNITY_RELEASE
+		mutable T*			m_DEBUGPtr;
+	#endif
+
+	protected:
+
+	inline void AssignObject (const Object* o);
+
+	private:
+	static string s_TypeString;
+
+	public:
+
+	static const char* GetTypeString ();
+	static bool IsAnimationChannel () { return false; }
+	static bool MightContainPPtr () { return true; }
+	static bool AllowTransferOptimization () { return false; }
+
+	template<class TransferFunction>
+	void Transfer (TransferFunction& transfer);
+
+	// Assignment
+	explicit PPtr (int instanceID)
+	{
+		m_InstanceID = instanceID;
+		#if !UNITY_RELEASE
+		m_DEBUGPtr = NULL;
+		#endif
+	}
+	PPtr (const T* o)								{ AssignObject (o); }
+	PPtr (const PPtr<T>& o)
+	{
+		m_InstanceID = o.m_InstanceID;
+		#if !UNITY_RELEASE
+		m_DEBUGPtr = NULL;
+		#endif
+	}
+
+	PPtr ()
+	{
+		#if !UNITY_RELEASE
+		m_DEBUGPtr = NULL;
+		#endif
+		m_InstanceID = 0;
+	}
+
+	PPtr& operator = (const T* o)				{ AssignObject (o); return *this; }
+	PPtr& operator = (const PPtr<T>& o)
+	{
+		#if !UNITY_RELEASE
+		m_DEBUGPtr = NULL;
+		#endif
+		m_InstanceID = o.m_InstanceID; return *this;
+	}
+
+	void SetInstanceID (int instanceID)		{ m_InstanceID = instanceID; }
+	int GetInstanceID ()const					{ return m_InstanceID; }
+
+	// Comparison
+	bool operator <  (const PPtr& p)const	{ return m_InstanceID < p.m_InstanceID; }
+	bool operator == (const PPtr& p)const	{ return m_InstanceID == p.m_InstanceID; }
+	bool operator != (const PPtr& p)const	{ return m_InstanceID != p.m_InstanceID; }
+
+	// MSVC gets confused whether it should use operator bool(), or operator T* with implicit
+	// comparison to NULL. So we add explicit functions and use them instead.
+	bool IsNull() const;
+	bool IsValid() const;
+
+	operator T* () const;
+	T* operator -> () const;
+	T& operator * () const;
+};
+
+template<class T>
+class ImmediatePtr
+{
+	mutable intptr_t m_Ptr;
+	#if !UNITY_RELEASE
+	mutable T* m_DEBUGPtr;
+	#endif
+
+	void AssignInstanceID (int instanceID)
+	{
+		AssertIf (instanceID & 1); m_Ptr = instanceID | 1; AssertIf ((m_Ptr & 1) == 0);
+		#if !UNITY_RELEASE
+		m_DEBUGPtr = NULL;
+		#endif
+	}
+	void AssignObject (const T* o)
+	{
+		m_Ptr = (intptr_t)o; AssertIf (m_Ptr & 1);
+		#if !UNITY_RELEASE
+		m_DEBUGPtr = const_cast<T*>(o);
+		#endif
+	}
+	void Load () const
+	{
+		AssertIf ((m_Ptr & 1) == 0);
+		T* loaded = PPtr<T> (m_Ptr & (~1));
+		m_Ptr = (intptr_t)(loaded);
+		AssertIf (m_Ptr & 1);
+		#if !UNITY_RELEASE
+		m_DEBUGPtr = loaded;
+		#endif
+	}
+
+	inline T* GetPtr () const
+	{
+		if ((m_Ptr & 1) == 0)
+		{
+			return (T*)(m_Ptr);
+		}
+		else
+		{
+			Load ();
+			return (T*)(m_Ptr);
+		}
+	}
+
+	static string s_TypeString;
+
+	public:
+
+	bool IsLoaded () const;
+
+	static const char* GetTypeString ();
+	static bool IsAnimationChannel ()						{ return false; }
+	static bool MightContainPPtr ()							{ return true; }
+	static bool AllowTransferOptimization ()				{ return false; }
+
+	template<class TransferFunction>
+	void Transfer (TransferFunction& transfer);
+
+	// Assignment
+	ImmediatePtr (const T* o)								{ AssignObject (o);  }
+	ImmediatePtr (const ImmediatePtr<T>& o)					{ m_Ptr = o.m_Ptr; }
+	ImmediatePtr () 										{ m_Ptr = 0; }
+
+	ImmediatePtr& operator = (const T* o)					{ AssignObject (o); return *this; }
+
+	void SetInstanceID (int instanceID)						{ AssignInstanceID (instanceID); }
+	int GetInstanceID ()const
+	{
+		if ((m_Ptr & 1) == 0 && m_Ptr != 0)
+		{
+			T* o = (T*)(m_Ptr);
+			SInt32 instanceID = o->GetInstanceID ();
+			AssertIf (instanceID & 1);
+			return instanceID;
+		}
+		else
+			return m_Ptr & (~1);
+	}
+
+	inline bool operator == (const T* p)const	{ return GetPtr () == p; }
+	inline bool operator != (const T* p)const	{ return GetPtr () != p; }
+
+	inline operator T* () const	{ return GetPtr (); }
+	inline T* operator -> () const { T* o = GetPtr (); AssertIf (o == NULL); return o; }
+	inline T& operator * () const	{ T* o = GetPtr (); AssertIf (o == NULL); ANALYSIS_ASSUME(o); return *o; }
+};
+
+template<typename T> class PtrToType;
+template<typename T> class PtrToType<T*>
+{
+public:
+	typedef T value_type;
+};
+
+template<class T, class U>
+T dynamic_pptr_cast (U* ptr)
+{
+	typedef typename PtrToType<T>::value_type Type;
+	T castedPtr = (T)(ptr);
+	if (castedPtr && castedPtr->IsDerivedFrom ( Type::GetClassIDStatic ()))
+		return castedPtr;
+	else
+		return NULL;
+}
+
+template<class T, class U>
+T dynamic_pptr_cast (const PPtr<U>& ptr)
+{
+	U* o = ptr;
+	return dynamic_pptr_cast<T> (o);
+}
+
+template<class T> inline
+T dynamic_instanceID_cast (int instanceID)
+{
+	Object* o = PPtr<Object> (instanceID);
+	return dynamic_pptr_cast<T> (o);
+}
+
+template<class T, class U>
+PPtr<T> assert_pptr_cast (const PPtr<U>& ptr)
+{
+	#if DEBUGMODE
+		U* u = ptr;
+		AssertIf (dynamic_pptr_cast<U*> (u) == NULL && u != NULL);
+	#endif
+	return PPtr<T> (ptr.GetInstanceID ());
+}
+
+// Enables boost::mem_fn to use PPtr properly, needed for boost::bind
+template<typename T> inline T * get_pointer(PPtr<T> const & p)
+{
+    return p;
+}
+
+
+enum ObjectCreationMode
+{
+	// Create the object from the main thread in a perfectly normal way
+	kCreateObjectDefault = 0,
+	// Create the object from another thread. Might assign an instance ID but will not register with IDToPointer map.
+	// Objects created like this, need to call,  AwakeFromLoadThraded, and Object::RegisterInstanceID and AwakeFromLoad (kDidLoadThreaded); from the main thread
+	kCreateObjectFromNonMainThread = 1,
+	// Create the object and register the instance id but do not lock the object
+	// creation mutex because the code calling it already called LockObjectCreation mutex.
+	kCreateObjectDefaultNoLock = 2
+};
+
+
+enum AwakeFromLoadMode
+{
+	// This is the default, usually called from the inspector or various serialization methods
+	kDefaultAwakeFromLoad = 0,
+	// The object was loaded from disk
+	kDidLoadFromDisk = 1 << 0,
+	// The object was loaded from a loading thread (in almost all cases through loading from disk asynchronously)
+	kDidLoadThreaded = 1 << 1,
+	// Object was instantiated and is now gettings it's first Awake function or it was created from code and gets the Awake function called
+	kInstantiateOrCreateFromCodeAwakeFromLoad = 1 << 2,
+	// GameObject was made active or a component was added to an active game object
+	kActivateAwakeFromLoad = 1 << 3,
+
+	kDefaultAwakeFromLoadInvalid = -1
+};
+
+class BaseAllocator;
+
+enum ObjectDeleteMode
+{
+	kUnknownMode = 0
+};
+
+class EXPORT_COREMODULE Object
+{
+	protected:
+	virtual ~Object ();
+
+	public:
+
+	Object (MemLabelId label, ObjectCreationMode mode);
+
+
+	/// By default the destructor might get executed on another thread.
+	/// This lets us distribute large level unloads to another thread and thus avoid hiccups.
+	/// Some classes need to deallocate resources on the main thread.
+	/// You can implement this function to delete the resources.
+	///
+	/// The destructor will still be called in this case, thus you need to ensure that values are set to NULL.
+	/// MainThreadCleanup is only called if the deallocations are done on another thread.
+	/// Thus the destructor needs to handle the case where it is not called correctly.
+	///
+	/// If you override the function return true, since it indicates that the class requires the function to be called.
+	/// SA: DoesClassRequireMainThreadDeallocation
+	virtual bool MainThreadCleanup ();
+
+	/// To destroy objects use delete_object instead of delete operator
+	/// The default way to destroy objects is using the DestroyObject Function, which also destroys the object from it's file
+	/// Must be protected by LockObjectCreation / UnlockObjectCreation
+	friend void delete_object_internal_step1 (Object* p);
+	friend void delete_object_internal_step2 (Object* p);
+
+	/// AwakeFromLoad is called after an object was read using Transfer (Either from disk or a vector)
+	/// This means it is called after the inspector has been updated, after it is loaded from disk, after a prefab has been modified or
+	/// the animation system has changed values behind your back.
+	virtual void AwakeFromLoad (AwakeFromLoadMode awakeMode)
+	{
+	#if !UNITY_RELEASE
+		m_AwakeCalled		= 1;
+
+		if( awakeMode & kDidLoadThreaded )
+			m_AwakeDidLoadThreadedCalled = 1;
+	#endif
+	}
+
+	virtual void AwakeFromLoadThreaded ()
+	{
+	#if !UNITY_RELEASE
+		m_AwakeThreadedCalled			= 1;
+		m_AwakeCalled					= 0;
+		m_AwakeDidLoadThreadedCalled	= 0;
+	#endif
+	}
+
+	/// For Subclasses: Makes sure that persistent variables are correct and if not corrects them
+	/// It is called after Prefab propagation, SafeBinaryRead and PropertyEditor changes.
+	/// It is called before AwakeFromLoad
+	virtual void CheckConsistency () { }
+
+	/// Override Reset in order to setup default values for the Object
+
+	/// The difference between setting up default values in the constructor
+	/// and Reset is that Reset is only called when the editor creates a new object
+	/// or when the object uses SerializeSafeBinary read.
+	/// Thus Reset can be used as a performance optimization for touching variables which are serialized only once during load.
+	/// * All variables that are serialized and Reset in the Reset function, do not have to be initialized in the constructor*
+	/// Reset functions might get called from different threads during loading, thus they may not derefence other objects, in that case use SmartReset.
+	/// You can always rely on that AwakeFromLoad is called after Reset has been called.
+	virtual void Reset ()
+	{
+	#if !UNITY_RELEASE
+		m_ResetCalled					= 1;
+		m_AwakeCalled					= 0;
+		m_AwakeThreadedCalled			= 0;
+		m_AwakeDidLoadThreadedCalled	= 0;
+	#endif
+	}
+
+	// Smart Reset is called when Reset is selected or when AddComponent is called and a new ScriptableObject is created.
+	// If you want to for example adjust a collider bounding volume by the renderers mesh, use SmartReset, you can not use Reset for this!
+	virtual void SmartReset ()
+	{
+	#if !UNITY_RELEASE
+		m_ResetCalled					= 1;
+		m_AwakeCalled					= 0;
+		m_AwakeThreadedCalled			= 0;
+		m_AwakeDidLoadThreadedCalled	= 0;
+	#endif
+	}
+
+#if !UNITY_RELEASE
+	// use it to check AwakeFromLoad/AwakeFromLoadThreaded/Reset/SmartReset were correctly called
+	void CheckCorrectAwakeUsage();
+
+	// hacks to set debug flags in cases you REALLY know what you are doing
+
+	// call when you don't want to Reset in case of object fully inited and don't need to be reset to default state
+	// e.g. if you de-serialize object - you don't need reset
+	inline void HackSetResetWasCalled() { m_ResetCalled = 1; }
+
+	// call when AwakeFromLoad has some side-effects so you need to postpone that call for indefinite time
+	// e.g. AudioClip will try to load sound in AwakeFromLoad, so you better do this only when needed
+	inline void HackSetAwakeWasCalled() { m_AwakeCalled = 1; }
+
+	// same as HackSetAwakeWasCalled but for Awake with kDidLoadThreaded param
+	inline void HackSetAwakeDidLoadThreadedWasCalled () { m_AwakeDidLoadThreadedCalled = true; }
+	#else
+	inline void HackSetResetWasCalled() {}
+	inline void HackSetAwakeWasCalled() {}
+	inline void HackSetAwakeDidLoadThreadedWasCalled() {}
+	#endif
+
+	/// Get and set the name
+	virtual char const* GetName () const { return ""; };
+	virtual void SetName (char const* /*name*/) {  }
+	void SetNameCpp (const std::string& name) { SetName(name.c_str()); }
+
+	#if UNITY_EDITOR
+	/// Return true if you want the inspector to automatically refresh without SetDirty being called.
+	virtual bool HasDebugmodeAutoRefreshInspector () { return false; }
+	virtual void WarnInstantiateDisallowed () {}
+	#endif
+
+	/// Returns the classID of the class
+	static int GetClassIDStatic ()				{ return ClassID (Object); }
+
+	// Is the class sealed (No other class can inherit from it)
+	// A sealed class can perform a GetComponent call faster,
+	// since it can compare the ClassID directly instead of using the RTTI system.
+	static bool IsSealedClass ()				{ return false; }
+
+	/// Returns true if the class is abstract
+	static bool IsAbstract ()						{ return true; }
+
+	/// Creates an object of type classID.
+	/// if instanceID is 0 a unique id will be generated  if its non 0 the object will have the specified instanceID
+	static Object* Produce (int classID, int instanceID = 0, MemLabelId = kMemBaseObject, ObjectCreationMode mode = kCreateObjectDefault);
+
+
+	// Static initializa and destroy for BaseObject
+	static void StaticInitialize();
+	static void StaticDestroy();
+
+	/// Registers instance id with IDToPointerMap
+	/// useful for thread loading with delayed activation from main thread
+	/// Can only be called from main thead
+	static void RegisterInstanceID (Object* obj);
+	static void RegisterInstanceIDNoLock (Object* obj);
+
+	/// Allocates new instanceID and registers it with IDToPointerMap
+	/// Can only be called from main thead
+	static Object* AllocateAndAssignInstanceID (Object* obj);
+	static Object* AllocateAndAssignInstanceIDNoLock (Object* obj);
+
+	#if UNITY_EDITOR
+	virtual void CloneAdditionalEditorProperties (Object& /*source*/) {  }
+
+	/// Can assign variable allows you to do additional type checking when assiging a variable
+	/// in the property	inspector.
+	/// Eg. MonoBehaviours checks if a monobehaviour can be assigned based on the actual Mono class
+	virtual bool CanAssignMonoVariable (const char* /*property*/, Object* /*object*/) { return false; }
+
+	#endif
+
+	virtual bool ShouldIgnoreInGarbageDependencyTracking ()				{ return false; }
+
+	/// Gets the class ID
+	ClassIDType GetClassID () const										{ Assert(m_CachedClassID != 0); return (ClassIDType)m_CachedClassID; }
+	/// Gets the instance ID
+	int			GetInstanceID () const									{ AssertIf(m_InstanceID == 0); return m_InstanceID; }
+	bool		IsInstanceIDCreated () const							{ return m_InstanceID != 0; }
+
+	/// Is this instance derived from compareClassID
+	bool		IsDerivedFrom (int compareClassID)const					{ return IsDerivedFromClassID (GetClassID (), compareClassID); }
+
+	#if UNITY_EDITOR
+
+	/// Has this object been synced with the PersistentManager
+	bool IsPersistentDirty () const						{ return m_DirtyIndex != 0; }
+
+	void SetPersistentDirtyIndex (UInt32 dirtyIndex);
+	UInt32 GetPersistentDirtyIndex () { return m_DirtyIndex; }
+
+	////@TODO: Rename this to SetPersistentDirty
+
+	/// Whenever variables that are being serialized in Transfer change, SetDirty () should be called
+	/// This will allow tracking of objects that have changed since the last saving to disk or over the network
+	void SetDirty ();
+
+	/// This method can be called if you need to unload an object from memory even if it's dirty.
+	void ClearPersistentDirty ();
+
+	// Callback support for callbacks when SetDirty is called
+	typedef void ObjectDirtyCallbackFunction (Object* ptr);
+	static void RegisterDirtyCallback (ObjectDirtyCallbackFunction* callback);
+	static ObjectDirtyCallbackFunction* GetDirtyCallback ();
+
+	void SetFileIDHint (LocalIdentifierInFileType hint) { m_FileIDHint = hint; }
+	LocalIdentifierInFileType GetFileIDHint () const { return m_FileIDHint; }
+
+	#else
+	void SetDirty () {  }
+	void ClearPersistentDirty () { }
+
+	#endif
+
+
+	// The name of the class
+	const std::string& GetClassName () const;
+
+	enum
+	{
+		kHideInHierarchy = 1 << 0,
+		kHideInspector = 1 << 1,
+		kDontSave = 1 << 2,
+		kNotEditable = 1 << 3,
+		kHideAndDontSave = kDontSave | kHideInHierarchy | kNotEditable
+	};
+
+	int GetHideFlags () const { return m_HideFlags; }
+	bool TestHideFlag (int mask) const { return (m_HideFlags & mask) == mask; }
+	bool TestHideFlagAny (int mask) const { return (m_HideFlags & mask) != 0; }
+
+	virtual void SetHideFlags (int flags) { m_HideFlags = flags; }
+	void SetHideFlagsObjectOnly (int flags) { Assert(flags < (1 << kHideFlagsBits)); m_HideFlags = flags; }
+
+	/// You must document all usage here in order to provide clear overview and avoid overlaps
+	/// - Transform root calculation for animation component, when binding animation states (Runtime only)
+	void SetTemporaryFlags (int flags) { Assert(flags < (1 << kTemporaryFlagsBits));  m_TemporaryFlags = flags; }
+	int GetTemporaryFlags () const { return m_TemporaryFlags; }
+#if UNITY_WINRT
+	/// Used by WinRT's GarbageCollectSharedAssets
+	void SetTemporaryUnusedAssetsFlags (int flags) { m_TemporaryUnusedAssetsFlags = flags; }
+	int GetTemporaryUnusedAssetsFlags () const { return m_TemporaryUnusedAssetsFlags; }
+#endif
+
+#if ENABLE_SCRIPTING
+	int GetGCHandle () const { return m_MonoReference; }
+#endif
+
+	/// Overall memory allocated for this object. Should calculate any memory allocated by other subystems as well.
+	/// For example if OpenGL allocates memory for a texture it must return how much memory we "think" OpenGL will allocate for the texture.
+	virtual int GetRuntimeMemorySize () const;
+
+	/// Is this object persistent?
+	bool IsPersistent () const { return m_IsPersistent; }
+
+	typedef InstanceIdToObjectPtrHashMap IDToPointerMap;
+
+	/// How many objects are there in memory?
+	static IDToPointerMap::size_type GetLoadedObjectCount ()				{ return ms_IDToPointer->size (); }
+
+	// Finds the pointer to the object referenced by instanceID (NULL if none found in memory)
+	static Object* IDToPointer (int inInstanceID);
+	static Object* IDToPointerThreadSafe (int inInstanceID);
+
+	/// This function may not be called unless you use LockObjectCreation / UnlockObjectCreation from another thread first...
+	/// If you don't know 100% what you are doing use: IDToPointerThreadSafe instead
+	static Object* IDToPointerNoThreadCheck (int inInstanceID);
+
+	/// Finds out if classID is derived from compareClassID
+	static bool IsDerivedFromClassID (int classID, int derivedFromClassID);
+
+	/// Returns the super Class ID of classID.
+	/// if classID doesnt have any super Class	it will return ClassID (Object)
+	static int GetSuperClassID (int classID);
+
+	/// Returns all classIDs that are derived from ClassID
+	static void FindAllDerivedClasses (int classID, std::vector<SInt32>* allDerivedClasses, bool returnOnlyNonAbstractClasses = true);
+	/// Returns how many objects are derived from classID
+	/// If allDerivedObjects != NULL, adds all derived object instanceIDs to the container
+	static int FindAllDerivedObjects (int classID, std::vector<SInt32>* derivedObjects, bool sorted = false);
+
+	static int FindObjectsOfType (int classID, std::vector<Object*>* derivedObjects, bool sorted = false);
+	template<class T>
+	static int FindObjectsOfType (std::vector<T*>* derivedObjects)
+	{
+		std::vector<Object*>* casted = reinterpret_cast<std::vector<Object*>*> (derivedObjects);
+		return FindObjectsOfType (T::GetClassIDStatic (), casted);
+	}
+
+	static int FindObjectsOfType (int classID, dynamic_array<Object*>* derivedObjects, bool sorted = false);
+	template<class T>
+	static int FindObjectsOfType (dynamic_array<T*>* derivedObjects)
+	{
+		dynamic_array<Object*>* casted = reinterpret_cast<dynamic_array<Object*>*> (derivedObjects);
+		return FindObjectsOfType (T::GetClassIDStatic (), casted);
+	}
+
+	template<class T>
+	static int FindObjectsOfTypeSorted (std::vector<T*>* derivedObjects)
+	{
+		std::vector<Object*>* casted = reinterpret_cast<std::vector<Object*>*> (derivedObjects);
+		return FindObjectsOfType (T::GetClassIDStatic (), casted, true);
+	}
+
+
+
+	/// Get the class name from the classID
+	static const std::string& ClassIDToString (int classID);
+	/// Get the classID from the class name, returns -1 if no classID was found
+	static int StringToClassID (const std::string& classString);
+	static int StringToClassIDCaseInsensitive (const std::string& classString);
+	static int StringToClassID (const char* classString);
+
+	/// Callback support for callbacks when an object is destroyed
+	typedef void ObjectDestroyCallbackFunction (int instanceID);
+	static void RegisterDestroyedCallback (ObjectDestroyCallbackFunction* callback);
+
+	/// Sets up the rtti for all classes that are derived from Object and
+	/// use the macro IMPLEMENT_CLASS or IMPLEMENT_CLASS_HAS_INIT
+	/// Calls the static function InitializeClass on every class that used
+	/// IMPLEMENT_CLASS_HAS_INIT instead of IMPLEMENT_CLASS
+	static void InitializeAllClasses ();
+	static void CallInitializeClassEarly();
+	static void CallInitializeClass();
+	static void CallPostInitializeClass();
+
+	static void CleanupAllClasses ();
+
+	/// Checks if an array of instance id's are loaded.
+	/// If an instanceID is loaded it is set to 0.
+	static void CheckInstanceIDsLoaded (SInt32* instanceIDs, int size);
+
+
+	typedef Object* FactoryFunction (MemLabelId label, ObjectCreationMode mode);
+	struct RTTI
+	{
+		RTTI*                    base;// super rtti class
+		Object::FactoryFunction* factory;// the factory function of the class
+		int                      classID;// the class ID of the class
+		std::string              className;// the name of the class
+		int                      size;// sizeof (Class)
+		bool                     isAbstract;// is the class Abstract?
+	};
+
+	/// Returns the RTTI information for a classID
+	static RTTI*  ClassIDToRTTI (int classID);
+
+	MemLabelId GetMemoryLabel () const;
+
+	static void DoneLoadingManagers ();
+
+	static IDToPointerMap& GetIDToPointerMapInternal () { return *ms_IDToPointer; }
+
+	virtual int GetClassIDVirtualInternal () const { AssertString("Bad"); return ClassID(Object); }
+	void PreCleanupObject ();
+
+	// Generic Event callback support.
+	typedef void EventCallback (void* userData, void* sender, int eventType);
+
+	void AddEvent (EventCallback* callback, void* userData);
+	void RemoveEvent (EventCallback* callback, void* userData);
+	bool HasEvent (EventCallback* callback, const void* userData) const;
+	void InvokeEvent (int eventType);
+
+private:
+
+	static	UInt32*				ms_IsDerivedFromBitMap;
+	static	unsigned               ms_MaxClassID;
+	static	IDToPointerMap*         ms_IDToPointer;
+	static	UInt32* ms_ClassIDMask;
+	static	UInt32* ms_ClassIsDerivedFrom;
+
+	SInt32                m_InstanceID;
+
+	enum Bits
+	{
+		kMemLabelBits = 13,
+		kIsRootOwnerBits = 1,
+		kTemporaryFlagsBits = 1,
+		kHideFlagsBits = 4,
+		kIsPersistentBits = 1,
+		kCachedClassIDBits = 12
+	};
+
+
+	UInt32                m_MemLabel      : kMemLabelBits;       // 13 bits
+	UInt32                m_IsRootOwner   : kIsRootOwnerBits;    // 14 bits
+	UInt32                m_TemporaryFlags: kTemporaryFlagsBits; // 15 bits
+	UInt32                m_HideFlags     : kHideFlagsBits;      // 19 bits
+	UInt32                m_IsPersistent  : kIsPersistentBits;   // 20 bits
+	UInt32				  m_CachedClassID : kCachedClassIDBits;  // 32 bits
+
+	EventEntry*           m_EventIndex;
+
+
+	#if !UNITY_RELEASE
+	UInt32				  m_DEBUGCLASSID:16;
+	UInt32                m_AwakeCalled:1;
+	UInt32				  m_ResetCalled:1;
+	UInt32				  m_AwakeThreadedCalled:1;
+	UInt32				  m_AwakeDidLoadThreadedCalled:1;
+	#endif
+
+	#if ENABLE_MONO
+	UInt32                m_MonoReference;
+	#elif UNITY_FLASH
+	SInt32				  m_MonoReference;
+	#elif UNITY_WINRT
+	SInt32				  m_MonoReference;
+	UInt32				  m_TemporaryUnusedAssetsFlags;
+	#endif
+	#if ENABLE_SCRIPTING
+	ScriptingObjectPtr      m_ScriptingObjectPointer;
+	#endif
+
+	#if UNITY_EDITOR
+	UInt32                m_DirtyIndex;
+	LocalIdentifierInFileType m_FileIDHint;
+	#endif
+
+	public:
+
+	#if ENABLE_SCRIPTING
+	void SetupWeakHandle ();
+	bool RevertWeakHandle ();
+
+	void SetCachedScriptingObject (ScriptingObjectPtr cachedPointer);
+	ScriptingObjectPtr GetCachedScriptingObject () { return m_ScriptingObjectPointer; }
+	#endif
+
+private:
+
+	static void CalculateCachedClassID (Object* obj);
+	static void InsertObjectInMap (Object* obj);
+
+	void SetIsPersistent (bool p);
+
+	Object (const Object& o);					// Disallow copy constructor
+	Object& operator = (const Object& o);	// Disallow assignment
+
+	void SetInstanceID (int inID)				{ m_InstanceID = inID; }
+
+	protected:
+
+	static void RegisterClass (int inClassID, int inBaseClass, const std::string& inName, int size, FactoryFunction* inFunc, bool isAbstract);
+
+	static Object* PRODUCE (MemLabelId /*label*/, ObjectCreationMode /*mode*/)						{ AssertString ("Can't produce abstract class"); return NULL; }
+
+	template<class TransferFunction>
+	void Transfer (TransferFunction& transfer);
+
+	public:
+
+	/// Returns whether or not the class needs one typetree per object, not per classID
+	/// Having a per object typetree makes serialization considerably slower because safeBinaryTransfer is always used
+	/// Since no TypeTree can be generated before reading the object.
+	/// The File size will also increase because the typetree is not shared among the same classes.
+	/// It is used for example in PythonBehaviour
+	/// Also for one class you have to always returns true or always false.
+	virtual bool GetNeedsPerObjectTypeTree () const { return false; }
+
+	// Sets up RTTI, the object factory (Produce) and string <-> classID
+	// conversion. RegisterClass() has to be called once for every class
+	// derived from object, before any Objects are allocated
+	static void RegisterClass ();
+
+	// Required by serialization
+	virtual void VirtualRedirectTransfer (StreamedBinaryWrite<false>&){ AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+	virtual void VirtualRedirectTransfer (StreamedBinaryRead<false>&) { AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+	virtual void VirtualRedirectTransfer (RemapPPtrTransfer&)	{ AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+	virtual void VirtualRedirectTransfer (ProxyTransfer&)		{ AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+#if SUPPORT_SERIALIZED_TYPETREES
+	virtual void VirtualRedirectTransfer (StreamedBinaryRead<true>&) { AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+	virtual void VirtualRedirectTransfer (SafeBinaryRead&)		{ AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+	virtual void VirtualRedirectTransfer (StreamedBinaryWrite<true>&){ AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+#endif
+#if SUPPORT_TEXT_SERIALIZATION
+	virtual void VirtualRedirectTransfer (YAMLRead&)	{ AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+	virtual void VirtualRedirectTransfer (YAMLWrite&)	{ AssertString ("Serialization not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+	virtual void VirtualStrippedRedirectTransfer (YAMLWrite& t) { VirtualRedirectTransfer(t); }
+#endif
+#if ENABLE_SERIALIZATION_BY_CODEGENERATION
+	virtual void DoLivenessCheck (RemapPPtrTransfer&)	{ AssertString ("DoLivenessCheck not implemented for type " + Object::ClassIDToString (GetClassID ())); }
+#endif
+	static const char* GetClassStringStatic (){ return "Object"; }
+	static const char* GetPPtrTypeString (){ return "PPtr<Object>"; }
+
+	friend class PersistentManager;
+	friend class SerializedFile;
+};
+
+struct LocalSerializedObjectIdentifier
+{
+	SInt32 localSerializedFileIndex;
+	#if LOCAL_IDENTIFIER_IN_FILE_SIZE == 64
+	UInt64 localIdentifierInFile;
+	#else
+	SInt32 localIdentifierInFile;
+	#endif
+
+	LocalSerializedObjectIdentifier()
+	{
+		localIdentifierInFile = 0;
+		localSerializedFileIndex = 0;
+	}
+};
+
+typedef void InstanceIDResolveCallback (SInt32 id, LocalSerializedObjectIdentifier& localIdentifier, void* context);
+void SetInstanceIDResolveCallback (InstanceIDResolveCallback* callback, const void* context = NULL);
+
+void EXPORT_COREMODULE InstanceIDToLocalSerializedObjectIdentifier (SInt32 id, LocalSerializedObjectIdentifier& localIdentifier);
+void EXPORT_COREMODULE LocalSerializedObjectIdentifierToInstanceID (const LocalSerializedObjectIdentifier& fileID, SInt32& memoryID);
+EXPORT_COREMODULE Object* ReadObjectFromPersistentManager (int instanceID);
+
+#if THREADED_LOADING
+EXPORT_COREMODULE Object* InstanceIDToObjectThreadSafe (int instanceID);
+#else
+#	define InstanceIDToObjectThreadSafe  PPtr<Object>
+#endif
+
+// This is used by the build game process. When writing for game release
+// we want to null all pptrs that can't be loaded anymore.
+// And when building default resources (culls all external references)
+enum { kWriteNULLWhenNotLoaded = 1 << 0, kConstrainedExternalReferences = 1 << 1 };
+void SetSerializeWritePPtrFlags (int flags, const std::set<string>& paths);
+
+void EXPORT_COREMODULE SetDisableImmediateDestruction (bool disable);
+bool EXPORT_COREMODULE GetDisableImmediateDestruction ();
+
+
+/// Returns if the object can possibly be loaded or is already in memory, without actually performing the loading.
+bool IsObjectAvailable (int instanceID);
+
+//Implementation
+#if UNITY_RELEASE
+#	if UNITY_PS3
+	__attribute__((always_inline)) inline Object* Object::IDToPointer (int inInstanceID)
+#else
+	inline Object* Object::IDToPointer (int inInstanceID)
+#	endif
+{
+	if( !ms_IDToPointer ) return NULL;
+	IDToPointerMap::const_iterator i = ms_IDToPointer->find (inInstanceID);
+	if (i != ms_IDToPointer->end ())
+		return i->second;
+	else
+		return NULL;
+}
+#endif
+
+template<class T>
+inline void PPtr<T>::AssignObject (const Object* o)
+{
+	if (o == NULL)
+		m_InstanceID = 0;
+	else
+		m_InstanceID = o->GetInstanceID ();
+	#if !UNITY_RELEASE
+	m_DEBUGPtr = (T*) (o);
+	#endif
+}
+
+template<class T> inline
+PPtr<T>::operator T* () const
+{
+	if (GetInstanceID () == 0)
+ 		return NULL;
+
+	Object* temp = Object::IDToPointer (GetInstanceID ());
+	if (temp == NULL)
+		temp = ReadObjectFromPersistentManager (GetInstanceID ());
+
+	#if !UNITY_RELEASE
+	m_DEBUGPtr = (T*) (temp);
+	#endif
+
+	#if DEBUGMODE || UNITY_EDITOR
+		T* casted = dynamic_pptr_cast<T*> (temp);
+		if (casted == temp)
+			return casted;
+		else
+		{
+			ErrorStringObject ("PPtr cast failed when dereferencing! Casting from " + temp->GetClassName () + " to " + T::GetClassStringStatic () + "!", temp);
+			return casted;
+		}
+	#else
+		return static_cast<T*> (temp);
+	#endif
+}
+
+template<class T> inline
+T* PPtr<T>::operator -> () const
+{
+	Object* temp = Object::IDToPointer (GetInstanceID ());
+	if (temp == NULL)
+		temp = ReadObjectFromPersistentManager (GetInstanceID ());
+
+	#if !UNITY_RELEASE
+		m_DEBUGPtr = (T*) (temp);
+	#endif
+
+	#if DEBUGMODE || !GAMERELEASE
+		T* casted = dynamic_pptr_cast<T*> (temp);
+		if (casted != NULL)
+			return casted;
+		else
+		{
+			if (temp != NULL)
+			{
+				ErrorStringObject ("PPtr cast failed when dereferencing! Casting from " + temp->GetClassName () + " to " + T::GetClassStringStatic () + "!", temp);
+			}
+			else
+			{
+				ErrorString ("Dereferencing NULL PPtr!");
+			}
+			return casted;
+		}
+	#else
+		return static_cast<T*> (temp);
+	#endif
+}
+
+template<class T> inline
+T& PPtr<T>::operator * () const
+{
+	Object* temp = Object::IDToPointer (GetInstanceID ());
+	if (temp == NULL)
+		temp = ReadObjectFromPersistentManager (GetInstanceID ());
+
+	#if !UNITY_RELEASE
+		m_DEBUGPtr = (T*) (temp);
+	#endif
+
+	#if DEBUGMODE || !GAMERELEASE
+		T* casted = dynamic_pptr_cast<T*> (temp);
+		if (casted != NULL)
+			return *casted;
+		else
+		{
+			if (temp != NULL)
+			{
+				ErrorStringObject ("PPtr cast failed when dereferencing! Casting from " + temp->GetClassName () + " to " + T::GetClassStringStatic () + "!", temp);
+			}
+			else
+			{
+				ErrorString ("Dereferencing NULL PPtr!");
+			}
+			ANALYSIS_ASSUME(casted);
+			return *casted;
+		}
+	#else
+		return *static_cast<T*> (temp);
+	#endif
+}
+
+template<class T> inline
+bool PPtr<T>::IsNull() const
+{
+	T* casted = *this;
+	return casted == NULL;
+}
+
+template<class T> inline
+bool PPtr<T>::IsValid() const
+{
+	T* casted = *this;
+	return casted != NULL;
+}
+
+template<class T>
+string PPtr<T>::s_TypeString;
+
+template<class T> inline
+const char* PPtr<T>::GetTypeString ()
+{
+	return T::GetPPtrTypeString ();
+}
+
+template<class T>
+template<class TransferFunction> inline
+void PPtr<T>::Transfer (TransferFunction& transfer)
+{
+	LocalSerializedObjectIdentifier localIdentifier;
+
+	if (transfer.NeedsInstanceIDRemapping ())
+	{
+		AssertIf (!transfer.IsWriting () && !transfer.IsReading ());
+
+		if (transfer.IsReading ())
+		{
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+			LocalSerializedObjectIdentifierToInstanceID (localIdentifier, m_InstanceID);
+		}
+		else if (transfer.IsWriting ())
+		{
+			InstanceIDToLocalSerializedObjectIdentifier (m_InstanceID, localIdentifier);
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+		}
+		else
+		{
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+		}
+	}
+	else
+	{
+		transfer.Transfer (m_InstanceID, "m_FileID", kHideInEditorMask);
+		transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+	}
+}
+
+template<class T> inline
+bool ImmediatePtr<T>::IsLoaded () const
+{
+	if (m_Ptr & 1)
+	{
+		return Object::IDToPointer(m_Ptr & (~1)) != NULL;
+	}
+	else
+	{
+		AssertIf(Object::IDToPointer(GetInstanceID()) == NULL);
+		return true;
+	}
+}
+template<class T>
+string ImmediatePtr<T>::s_TypeString;
+
+template<class T> inline
+const char* ImmediatePtr<T>::GetTypeString ()
+{
+	if(s_TypeString.empty())
+	{
+		SET_ALLOC_OWNER(NULL);
+		s_TypeString = string ("PPtr<") + T::GetClassStringStatic () + ">";
+	}
+	return s_TypeString.c_str ();
+}
+
+template<class T>
+template<class TransferFunction> inline
+void ImmediatePtr<T>::Transfer (TransferFunction& transfer)
+{
+	LocalSerializedObjectIdentifier localIdentifier;
+
+	if (transfer.NeedsInstanceIDRemapping ())
+	{
+		AssertIf (!transfer.IsWriting () && !transfer.IsReading ());
+
+		if (transfer.IsReading ())
+		{
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+			SInt32 instanceID;
+			LocalSerializedObjectIdentifierToInstanceID (localIdentifier, instanceID);
+			AssignInstanceID (instanceID);
+		}
+		else if (transfer.IsWriting ())
+		{
+			InstanceIDToLocalSerializedObjectIdentifier (GetInstanceID (), localIdentifier);
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+		}
+		else
+		{
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+		}
+	}
+	else
+	{
+		if (transfer.IsReading ())
+		{
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+			SetInstanceID (localIdentifier.localSerializedFileIndex);
+		}
+		else if (transfer.IsWriting ())
+		{
+			localIdentifier.localSerializedFileIndex = GetInstanceID ();
+			localIdentifier.localIdentifierInFile = 0;
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+			AssertIf (localIdentifier.localSerializedFileIndex != GetInstanceID ());
+		}
+		else
+		{
+			transfer.Transfer (localIdentifier.localSerializedFileIndex, "m_FileID", kHideInEditorMask);
+			transfer.Transfer (localIdentifier.localIdentifierInFile, "m_PathID", kHideInEditorMask);
+		}
+	}
+}
+#if UNITY_PS3
+#define USE_NEW_IS_DERIVED_FROM 1
+#else
+#define USE_NEW_IS_DERIVED_FROM 0
+#endif
+
+#if !USE_NEW_IS_DERIVED_FROM
+#if UNITY_RELEASE
+inline bool Object::IsDerivedFromClassID (int classID, int compareClass)
+{
+	AssertIf (classID >= ms_MaxClassID || classID < 0);
+	AssertIf (compareClass >= ms_MaxClassID || compareClass < 0);
+	int index = classID * ms_MaxClassID + compareClass;
+	int block = index >> 5;
+	int bit = index - (block << 5);
+	return (ms_IsDerivedFromBitMap[block]) & (1 << bit);
+}
+#endif
+#else
+#define CLASS_ID_MASK_BITS 4
+#define CLASS_ID_MASK_IDS 0x0fffffff
+inline bool Object::IsDerivedFromClassID(int klass, int base)
+{
+	int klassId = ms_ClassIsDerivedFrom[klass];
+	int baseId = ms_ClassIsDerivedFrom[base];
+	int mask = ms_ClassIDMask[ 0xf&(baseId >> (32-CLASS_ID_MASK_BITS))];
+	return (klassId&mask) == (baseId&CLASS_ID_MASK_IDS);
+}
+#endif
+
+void LockObjectCreation ();
+void UnlockObjectCreation ();
+
+// Destroys a Object removing from memory and disk when needed.
+// Might load the object as part of destruction which is probably unwanted.
+// @TODO: Refactor code to not do that
+void EXPORT_COREMODULE DestroySingleObject (Object* o);
+void UnloadObject (Object* o);
+
+/// Destroys the object if it is loaded. (Will not load the object from disk if it is not loaded at the moment)
+/// Will remove it from any remapping tables
+/// Will not removed it from the actual serialized file, with the assumption that the file will be unloaded from disk later.
+void DestroyWithoutLoadingButDontDestroyFromFile (int instanceID);
+
+#if DEBUGMODE
+typedef std::set<int, std::less<int>, STL_ALLOCATOR(kMemPermanent,int) > VerifyRegisteredClass;
+void EXPORT_COREMODULE AddVerifyClassRegistration (int classID);
+typedef std::set<int, std::less<int>, STL_ALLOCATOR(kMemBaseObject, int) > RegisteredClassSet;
+const RegisteredClassSet& GetVerifyClassRegistration ();
+#endif
+
+/// Helper to create object correctly from code. Will call Reset and AwakeFromLoad
+template <typename T> T* CreateObjectFromCode( AwakeFromLoadMode awakeMode=kInstantiateOrCreateFromCodeAwakeFromLoad, MemLabelId label = kMemBaseObject )
+{
+	Assert(Object::ClassIDToRTTI(T::GetClassIDStatic()) != NULL);
+	T* obj = NEW_OBJECT_USING_MEMLABEL(T, label);
+	SET_ALLOC_OWNER(obj);
+	obj->Reset();
+	obj->AwakeFromLoad(awakeMode);
+	return obj;
+}
+
+template<typename T>
+inline T* ResetAndAwake (T* object)
+{
+	object->Reset();
+	object->AwakeFromLoad (kDefaultAwakeFromLoad);
+	return object;
+}
+
+void delete_object_internal (Object* p);
+void delete_object_internal_step1 (Object* object);
+void delete_object_internal_step2 (Object* object);
+
+#endif