ResourceBackupData ManagedResource::backup(bool clearExisting)
{
SPtr<ManagedSerializableObject> serializableObject = ManagedSerializableObject::createFromExisting(mManagedInstance);
ResourceBackupData backupData;
if (serializableObject != nullptr)
{
MemorySerializer ms;
backupData.size = 0;
backupData.data = ms.encode(serializableObject.get(), backupData.size);
}
else
{
backupData.size = 0;
backupData.data = nullptr;
}
if (clearExisting)
{
if (mManagedInstance != nullptr)
{
mManagedInstance = nullptr;
MonoUtil::freeGCHandle(mManagedHandle);
mManagedHandle = 0;
}
}
return backupData;
}
MonoObject* ScriptSerializableUtility::internal_Create(MonoReflectionType* reflType)
{
if (reflType == nullptr)
return nullptr;
::MonoClass* monoClass = MonoUtil::getClass(reflType);
MonoClass* engineClass = MonoManager::instance().findClass(monoClass);
SPtr<ManagedSerializableTypeInfo> typeInfo = ScriptAssemblyManager::instance().getTypeInfo(engineClass);
if (typeInfo == nullptr)
{
LOGWRN("Cannot create an instance of type \"" +
engineClass->getFullName() + "\", it is not marked as serializable.");
return nullptr;
}
SPtr<ManagedSerializableFieldData> data = ManagedSerializableFieldData::createDefault(typeInfo);
MemorySerializer ms;
// Note: This code unnecessarily encodes to binary and decodes from it. I could have added a specialized create method that does it directly,
// but didn't feel the extra code was justified.
UINT32 size = 0;
UINT8* encodedData = ms.encode(data.get(), size);
SPtr<ManagedSerializableFieldData> createdData = std::static_pointer_cast<ManagedSerializableFieldData>(ms.decode(encodedData, size));
createdData->deserialize();
return createdData->getValueBoxed(typeInfo);
}
void CmdDeleteSO::recordSO(const HSceneObject& sceneObject)
{
MemorySerializer serializer;
mSerializedObject = serializer.encode(mSceneObject.get(), mSerializedObjectSize);
HSceneObject parent = mSceneObject->getParent();
if (parent != nullptr)
mSerializedObjectParentId = parent->getInstanceId();
mSceneObjectProxy = CmdUtility::createProxy(mSceneObject);
}
ScriptSerializedSceneObject::ScriptSerializedSceneObject(MonoObject* instance, const HSceneObject& so, bool recordHierarchy)
: ScriptObject(instance), mSO(so), mRecordHierarchy(recordHierarchy), mSerializedObject(nullptr), mSerializedObjectSize(0)
{
if (mSO.isDestroyed())
return;
UINT32 numChildren = mSO->getNumChildren();
HSceneObject* children = nullptr;
if (!mRecordHierarchy)
{
children = bs_stack_new<HSceneObject>(numChildren);
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = mSO->getChild(i);
children[i] = child;
child->setParent(HSceneObject());
}
}
bool isInstantiated = !mSO->hasFlag(SOF_DontInstantiate);
mSO->_setFlags(SOF_DontInstantiate);
MemorySerializer serializer;
mSerializedObject = serializer.encode(mSO.get(), mSerializedObjectSize);
if (isInstantiated)
mSO->_unsetFlags(SOF_DontInstantiate);
mSceneObjectProxy = EditorUtility::createProxy(mSO);
if (!mRecordHierarchy)
{
for (UINT32 i = 0; i < numChildren; i++)
children[i]->setParent(mSO->getHandle());
bs_stack_delete(children, numChildren);
}
}
void CmdRecordSO::recordSO(const HSceneObject& sceneObject)
{
UINT32 numChildren = mSceneObject->getNumChildren();
HSceneObject* children = nullptr;
if (!mRecordHierarchy)
{
children = bs_stack_new<HSceneObject>(numChildren);
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = mSceneObject->getChild(i);
children[i] = child;
child->setParent(HSceneObject());
}
}
bool isInstantiated = !mSceneObject->hasFlag(SOF_DontInstantiate);
mSceneObject->_setFlags(SOF_DontInstantiate);
MemorySerializer serializer;
mSerializedObject = serializer.encode(mSceneObject.get(), mSerializedObjectSize);
if (isInstantiated)
mSceneObject->_unsetFlags(SOF_DontInstantiate);
mSceneObjectProxy = EditorUtility::createProxy(mSceneObject);
if (!mRecordHierarchy)
{
for (UINT32 i = 0; i < numChildren; i++)
children[i]->setParent(sceneObject->getHandle());
bs_stack_delete(children, numChildren);
}
}
