void ScriptSerializedSceneObject::internal_Restore(ScriptSerializedSceneObject* thisPtr)
{
HSceneObject sceneObj = thisPtr->mSO;
if (sceneObj.isDestroyed())
return;
HSceneObject parent = sceneObj->getParent();
UINT32 numChildren = sceneObj->getNumChildren();
HSceneObject* children = nullptr;
if (!thisPtr->mRecordHierarchy)
{
children = bs_stack_new<HSceneObject>(numChildren);
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = sceneObj->getChild(i);
children[i] = child;
child->setParent(HSceneObject());
}
}
sceneObj->destroy(true);
GameObjectManager::instance().setDeserializationMode(GODM_RestoreExternal | GODM_UseNewIds);
MemorySerializer serializer;
SPtr<SceneObject> restored = std::static_pointer_cast<SceneObject>(
serializer.decode(thisPtr->mSerializedObject, thisPtr->mSerializedObjectSize));
EditorUtility::restoreIds(restored->getHandle(), thisPtr->mSceneObjectProxy);
restored->setParent(parent);
if (!thisPtr->mRecordHierarchy)
{
for (UINT32 i = 0; i < numChildren; i++)
children[i]->setParent(restored->getHandle());
bs_stack_delete(children, numChildren);
}
restored->_instantiate();
}
void CmdDeleteSO::revert()
{
if (mSceneObject == nullptr)
return;
HSceneObject parent;
if (mSerializedObjectParentId != 0)
parent = GameObjectManager::instance().getObject(mSerializedObjectParentId);
GameObjectManager::instance().setDeserializationMode(GODM_RestoreExternal | GODM_UseNewIds);
// Object might still only be queued for destruction, but we need to fully destroy it since we're about to replace
// the potentially only reference to the old object
if (!mSceneObject.isDestroyed())
mSceneObject->destroy(true);
MemorySerializer serializer;
SPtr<SceneObject> restored = std::static_pointer_cast<SceneObject>(serializer.decode(mSerializedObject, mSerializedObjectSize));
CmdUtility::restoreIds(restored->getHandle(), mSceneObjectProxy);
restored->setParent(parent);
}
void ManagedResource::restore(MonoObject* instance, const ResourceBackupData& data)
{
mManagedInstance = instance;
if (mManagedInstance != nullptr)
{
mManagedHandle = MonoUtil::newGCHandle(mManagedInstance);
if (data.data != nullptr)
{
MemorySerializer ms;
SPtr<ManagedSerializableObject> serializableObject = std::static_pointer_cast<ManagedSerializableObject>(ms.decode(data.data, data.size));
SPtr<ManagedResourceMetaData> managedResMetaData = std::static_pointer_cast<ManagedResourceMetaData>(mMetaData);
SPtr<ManagedSerializableObjectInfo> currentObjInfo = nullptr;
if (ScriptAssemblyManager::instance().getSerializableObjectInfo(managedResMetaData->typeNamespace, managedResMetaData->typeName, currentObjInfo))
serializableObject->deserialize(mManagedInstance, currentObjInfo);
}
}
else
{
// Could not restore resource
ManagedResourceManager::instance().unregisterManagedResource(mMyHandle);
}
}
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);
}
