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); }