void Prefab::initialize(const HSceneObject& sceneObject)
{
sceneObject->mPrefabDiff = nullptr;
UINT32 newNextLinkId = PrefabUtility::generatePrefabIds(sceneObject, mNextLinkId);
if (newNextLinkId < mNextLinkId)
{
BS_EXCEPT(InternalErrorException, "Prefab ran out of IDs to assign. " \
"Consider increasing the size of the prefab ID data type.");
}
mNextLinkId = newNextLinkId;
// If there are any child prefab instances, make sure to update their diffs so they are saved with this prefab
Stack<HSceneObject> todo;
todo.push(sceneObject);
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
UINT32 childCount = current->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = current->getChild(i);
if (!child->mPrefabLinkUUID.empty())
PrefabUtility::recordPrefabDiff(child);
else
todo.push(child);
}
}
// Clone the hierarchy for internal storage
mRoot = sceneObject->clone(false);
mRoot->mParent = nullptr;
// Remove objects with "dont save" flag
todo.push(mRoot);
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
if (current->hasFlag(SOF_DontSave))
current->destroy();
else
{
UINT32 numChildren = current->getNumChildren();
for (UINT32 i = 0; i < numChildren; i++)
todo.push(current->getChild(i));
}
}
}
void Prefab::initialize(const HSceneObject& sceneObject)
{
sceneObject->mPrefabDiff = nullptr;
PrefabUtility::generatePrefabIds(sceneObject);
// If there are any child prefab instances, make sure to update their diffs so they are saved with this prefab
Stack<HSceneObject> todo;
todo.push(sceneObject);
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
UINT32 childCount = current->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = current->getChild(i);
if (!child->mPrefabLinkUUID.empty())
PrefabUtility::recordPrefabDiff(child);
else
todo.push(child);
}
}
// Clone the hierarchy for internal storage
if (mRoot != nullptr)
mRoot->destroy(true);
mRoot = sceneObject->clone(false);
mRoot->mParent = nullptr;
mRoot->mLinkId = -1;
// Remove objects with "dont save" flag
todo.push(mRoot);
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
if (current->hasFlag(SOF_DontSave))
current->destroy();
else
{
UINT32 numChildren = current->getNumChildren();
for (UINT32 i = 0; i < numChildren; i++)
todo.push(current->getChild(i));
}
}
}
void PrefabUtility::clearPrefabIds(const HSceneObject& sceneObject, bool recursive)
{
Stack<HSceneObject> todo;
todo.push(sceneObject);
while (!todo.empty())
{
HSceneObject currentSO = todo.top();
todo.pop();
for (auto& component : currentSO->mComponents)
component->mLinkId = (UINT32)-1;
if (recursive)
{
UINT32 numChildren = (UINT32)currentSO->getNumChildren();
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = currentSO->getChild(i);
child->mLinkId = (UINT32)-1;
if (child->mPrefabLinkUUID.empty())
todo.push(child);
}
}
}
}
UINT32 PrefabUtility::generatePrefabIds(const HSceneObject& sceneObject, UINT32 startingId)
{
Stack<HSceneObject> todo;
todo.push(sceneObject);
while (!todo.empty())
{
HSceneObject currentSO = todo.top();
todo.pop();
for (auto& component : currentSO->mComponents)
{
if (component->getLinkId() == (UINT32)-1)
component->mLinkId = startingId++;
}
UINT32 numChildren = (UINT32)currentSO->getNumChildren();
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = currentSO->getChild(i);
if (!child->hasFlag(SOF_DontSave))
{
if (child->getLinkId() == (UINT32)-1)
child->mLinkId = startingId++;
if(child->mPrefabLinkUUID.empty())
todo.push(currentSO->getChild(i));
}
}
}
return startingId;
}
Vector<HBone> CAnimation::findChildBones()
{
Stack<HSceneObject> todo;
todo.push(SO());
Vector<HBone> bones;
while (todo.size() > 0)
{
HSceneObject currentSO = todo.top();
todo.pop();
HBone bone = currentSO->getComponent<CBone>();
if (bone != nullptr)
{
bone->_setParent(static_object_cast<CAnimation>(getHandle()), true);
bones.push_back(bone);
}
int childCount = currentSO->getNumChildren();
for (int i = 0; i < childCount; i++)
{
HSceneObject child = currentSO->getChild(i);
if (child->getComponent<CAnimation>() != nullptr)
continue;
todo.push(child);
}
}
return bones;
}
void PrefabUtility::restoreLinkedInstanceData(const HSceneObject& so, SceneObjectProxy& proxy,
UnorderedMap<UINT32, GameObjectInstanceDataPtr>& linkedInstanceData)
{
Stack<HSceneObject> todo;
todo.push(so);
// Root is not in the instance data map because its link ID belongs to the parent prefab, if any
so->_setInstanceData(proxy.instanceData);
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
Vector<HComponent>& components = current->mComponents;
for (auto& component : components)
{
if (component->getLinkId() != (UINT32)-1)
{
auto iterFind = linkedInstanceData.find(component->getLinkId());
if (iterFind != linkedInstanceData.end())
{
component->_setInstanceData(iterFind->second);
component._setHandleData(component.getInternalPtr());
}
}
}
UINT32 numChildren = current->getNumChildren();
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = current->getChild(i);
if (child->getLinkId() != (UINT32)-1)
{
auto iterFind = linkedInstanceData.find(child->getLinkId());
if (iterFind != linkedInstanceData.end())
child->_setInstanceData(iterFind->second);
}
if (child->mPrefabLinkUUID.empty())
todo.push(child);
}
}
}
void PrefabUtility::recordPrefabDiff(const HSceneObject& sceneObject)
{
HSceneObject topLevelObject = sceneObject;
while (topLevelObject != nullptr)
{
if (!topLevelObject->mPrefabLinkUUID.empty())
break;
if (topLevelObject->mParent != nullptr)
topLevelObject = topLevelObject->mParent;
else
topLevelObject = nullptr;
}
if (topLevelObject == nullptr)
topLevelObject = sceneObject;
Stack<HSceneObject> todo;
todo.push(topLevelObject);
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
if (!current->mPrefabLinkUUID.empty())
{
current->mPrefabDiff = nullptr;
HPrefab prefabLink = static_resource_cast<Prefab>(gResources().loadFromUUID(current->mPrefabLinkUUID, false, false));
if (prefabLink.isLoaded(false))
current->mPrefabDiff = PrefabDiff::create(prefabLink->_getRoot(), current->getHandle());
}
UINT32 childCount = current->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = current->getChild(i);
todo.push(child);
}
}
gResources().unloadAllUnused();
}
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 CRigidbody::updateColliders()
{
Stack<HSceneObject> todo;
todo.push(SO());
while(!todo.empty())
{
HSceneObject currentSO = todo.top();
todo.pop();
if(currentSO->hasComponent<CCollider>())
{
Vector<HCollider> colliders = currentSO->getComponents<CCollider>();
for (auto& entry : colliders)
{
if (!entry->isValidParent(mThisHandle))
continue;
Collider* collider = entry->_getInternal();
if (collider == nullptr)
continue;
entry->setRigidbody(mThisHandle, true);
mChildren.push_back(entry);
collider->setRigidbody(mInternal.get());
mInternal->addCollider(collider->_getInternal());
}
}
UINT32 childCount = currentSO->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = currentSO->getChild(i);
if (child->hasComponent<CRigidbody>())
continue;
todo.push(child);
}
}
}
void Prefab::_updateChildInstances()
{
Stack<HSceneObject> todo;
todo.push(mRoot);
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
UINT32 childCount = current->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = current->getChild(i);
if (!child->mPrefabLinkUUID.empty())
PrefabUtility::updateFromPrefab(child);
else
todo.push(child);
}
}
}
void CmdBreakPrefab::revert()
{
if (mPrefabRoot == nullptr || mPrefabRoot.isDestroyed())
return;
mPrefabRoot->_setPrefabLinkUUID(mPrefabLinkUUID);
mPrefabRoot->_setPrefabDiff(mPrefabDiff);
Stack<HSceneObject> todo;
todo.push(mPrefabRoot);
while (!todo.empty())
{
HSceneObject currentSO = todo.top();
todo.pop();
const Vector<HComponent>& components = currentSO->getComponents();
for (auto& component : components)
{
auto iterFind = mLinkIds.find(component->getInstanceId());
if (iterFind != mLinkIds.end())
component->_setLinkId(iterFind->second);
}
UINT32 numChildren = (UINT32)currentSO->getNumChildren();
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = currentSO->getChild(i);
auto iterFind = mLinkIds.find(child->getInstanceId());
if (iterFind != mLinkIds.end())
child->_setLinkId(iterFind->second);
if (child->_getPrefabLinkUUID().empty())
todo.push(child);
}
}
}
void PrefabUtility::updateFromPrefab(const HSceneObject& so)
{
HSceneObject topLevelObject = so;
while (topLevelObject != nullptr)
{
if (!topLevelObject->mPrefabLinkUUID.empty())
break;
if (topLevelObject->mParent != nullptr)
topLevelObject = topLevelObject->mParent;
else
topLevelObject = nullptr;
}
Stack<HSceneObject> todo;
todo.push(topLevelObject);
// Find any prefab instances
Vector<HSceneObject> prefabInstanceRoots;
while (!todo.empty())
{
HSceneObject current = todo.top();
todo.pop();
if (!current->mPrefabLinkUUID.empty())
prefabInstanceRoots.push_back(current);
UINT32 childCount = current->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = current->getChild(i);
todo.push(child);
}
}
// Stores data about the new prefab instance and its original parent and link id
// (as those aren't stored in the prefab diff)
struct RestoredPrefabInstance
{
HSceneObject newInstance;
HSceneObject originalParent;
SPtr<PrefabDiff> diff;
UINT32 originalLinkId;
};
Vector<RestoredPrefabInstance> newPrefabInstanceData;
// For each prefab instance load its reference prefab from the disk and check if it changed. If it has changed
// instantiate the prefab and destroy the current instance. Then apply instance specific changes stored in a
// prefab diff, if any, as well as restore the original parent and link id (link id of the root prefab instance
// belongs to the parent prefab if any). Finally fix any handles pointing to the old objects so that they now point
// to the newly instantiated objects. To the outside world it should be transparent that we just destroyed and then
// re-created from scratch the entire hierarchy.
// Need to do this bottom up to ensure I don't destroy the parents before children
for (auto iter = prefabInstanceRoots.rbegin(); iter != prefabInstanceRoots.rend(); ++iter)
{
HSceneObject current = *iter;
HPrefab prefabLink = static_resource_cast<Prefab>(gResources().loadFromUUID(current->mPrefabLinkUUID, false, false));
if (prefabLink.isLoaded(false) && prefabLink->getHash() != current->mPrefabHash)
{
// Save IDs, destroy original, create new, restore IDs
SceneObjectProxy soProxy;
UnorderedMap<UINT32, GameObjectInstanceDataPtr> linkedInstanceData;
recordInstanceData(current, soProxy, linkedInstanceData);
HSceneObject parent = current->getParent();
SPtr<PrefabDiff> prefabDiff = current->mPrefabDiff;
current->destroy(true);
HSceneObject newInstance = prefabLink->_clone();
// When restoring instance IDs it is important to make all the new handles point to the old GameObjectInstanceData.
// This is because old handles will have different GameObjectHandleData and we have no easy way of accessing it to
// change to which GameObjectInstanceData it points. But the GameObjectManager ensures that all handles deserialized
// at once (i.e. during the ::instantiate() call above) will share GameObjectHandleData so we can simply replace
// to what they point to, affecting all of the handles to that object. (In another words, we can modify the
// new handles at this point, but old ones must keep referencing what they already were.)
restoreLinkedInstanceData(newInstance, soProxy, linkedInstanceData);
restoreUnlinkedInstanceData(newInstance, soProxy);
newPrefabInstanceData.push_back({ newInstance, parent, prefabDiff, newInstance->getLinkId() });
}
}
// Once everything is instantiated, apply diffs, restore old parents & link IDs for root.
for (auto& entry : newPrefabInstanceData)
{
// Diffs must be applied after everything is instantiated and instance data restored since it may contain
// game object handles within or external to its prefab instance.
if (entry.diff != nullptr)
entry.diff->apply(entry.newInstance);
entry.newInstance->mPrefabDiff = entry.diff;
entry.newInstance->setParent(entry.originalParent, false);
entry.newInstance->mLinkId = entry.originalLinkId;
}
gResources().unloadAllUnused();
}
void ScriptGizmoManager::update()
{
GizmoManager::instance().clearGizmos();
HSceneObject rootSO = SceneManager::instance().getRootNode();
Stack<HSceneObject> todo;
todo.push(rootSO);
bool isParentSelected = false;
UINT32 parentSelectedPopIdx = 0;
Vector<HSceneObject> selectedObjects = Selection::instance().getSceneObjects();
while (!todo.empty())
{
if (isParentSelected && parentSelectedPopIdx == (UINT32)todo.size())
{
isParentSelected = false;
}
HSceneObject curSO = todo.top();
todo.pop();
bool isSelected = std::count(selectedObjects.begin(), selectedObjects.end(), curSO) > 0;
if (isSelected && !isParentSelected)
{
isParentSelected = true;
parentSelectedPopIdx = (UINT32)todo.size();
}
const Vector<HComponent>& components = curSO->getComponents();
for (auto& component : components)
{
if (rtti_is_of_type<ManagedComponent>(component.get()))
{
ManagedComponent* managedComponent = static_cast<ManagedComponent*>(component.get());
auto iterFind = mGizmoDrawers.find(managedComponent->getManagedFullTypeName());
if (iterFind != mGizmoDrawers.end())
{
UINT32 flags = iterFind->second.flags;
bool drawGizmo = false;
if (((flags & (UINT32)DrawGizmoFlags::Selected) != 0) && isSelected)
drawGizmo = true;
if (((flags & (UINT32)DrawGizmoFlags::ParentSelected) != 0) && isParentSelected)
drawGizmo = true;
if (((flags & (UINT32)DrawGizmoFlags::NotSelected) != 0) && !isSelected && !isParentSelected)
drawGizmo = true;
if (drawGizmo)
{
bool pickable = (flags & (UINT32)DrawGizmoFlags::Pickable) != 0;
GizmoManager::instance().startGizmo(curSO);
GizmoManager::instance().setPickable(pickable);
void* params[1] = { managedComponent->getManagedInstance() };
iterFind->second.drawGizmosMethod->invoke(nullptr, params);
GizmoManager::instance().endGizmo();
}
}
}
}
for (UINT32 i = 0; i < curSO->getNumChildren(); i++)
todo.push(curSO->getChild(i));
}
}
void CmdBreakPrefab::commit()
{
clear();
if (mSceneObject == nullptr || mSceneObject.isDestroyed())
return;
HSceneObject rootObj = mSceneObject;
while (rootObj != nullptr)
{
if (!rootObj->_getPrefabLinkUUID().empty())
break;
if (rootObj->getParent() != nullptr)
rootObj = rootObj->getParent();
else
rootObj = nullptr;
}
if (rootObj != nullptr)
{
mPrefabRoot = rootObj;
mPrefabLinkUUID = rootObj->_getPrefabLinkUUID();
mPrefabDiff = rootObj->_getPrefabDiff();
Stack<HSceneObject> todo;
todo.push(mPrefabRoot);
while (!todo.empty())
{
HSceneObject currentSO = todo.top();
todo.pop();
const Vector<HComponent>& components = currentSO->getComponents();
for (auto& component : components)
{
UINT32 linkId = component->getLinkId();
if (linkId != (UINT32)-1)
mLinkIds[component->getInstanceId()] = linkId;
mLinkIds[component->getInstanceId()] = component->getLinkId();
}
UINT32 numChildren = (UINT32)currentSO->getNumChildren();
for (UINT32 i = 0; i < numChildren; i++)
{
HSceneObject child = currentSO->getChild(i);
UINT32 linkId = child->getLinkId();
if (linkId != (UINT32)-1)
mLinkIds[child->getInstanceId()] = linkId;
if (child->_getPrefabLinkUUID().empty())
todo.push(child);
}
}
}
mSceneObject->breakPrefabLink();
}
void PrefabDiff::applyDiff(const SPtr<PrefabObjectDiff>& diff, const HSceneObject& object)
{
if ((diff->soFlags & (UINT32)SceneObjectDiffFlags::Name) != 0)
object->setName(diff->name);
if ((diff->soFlags & (UINT32)SceneObjectDiffFlags::Position) != 0)
object->setPosition(diff->position);
if ((diff->soFlags & (UINT32)SceneObjectDiffFlags::Rotation) != 0)
object->setRotation(diff->rotation);
if ((diff->soFlags & (UINT32)SceneObjectDiffFlags::Scale) != 0)
object->setScale(diff->scale);
if ((diff->soFlags & (UINT32)SceneObjectDiffFlags::Active) != 0)
object->setActive(diff->isActive);
// Note: It is important to remove objects and components first, before adding them.
// Some systems rely on the fact that applyDiff added components/objects are
// always at the end.
const Vector<HComponent>& components = object->getComponents();
for (auto& removedId : diff->removedComponents)
{
for (auto component : components)
{
if (removedId == component->getLinkId())
{
component->destroy();
break;
}
}
}
for (auto& removedId : diff->removedChildren)
{
UINT32 childCount = object->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = object->getChild(i);
if (removedId == child->getLinkId())
{
child->destroy();
break;
}
}
}
for (auto& addedComponentData : diff->addedComponents)
{
BinarySerializer bs;
SPtr<Component> component = std::static_pointer_cast<Component>(bs._decodeFromIntermediate(addedComponentData));
object->addAndInitializeComponent(component);
}
for (auto& addedChildData : diff->addedChildren)
{
BinarySerializer bs;
SPtr<SceneObject> sceneObject = std::static_pointer_cast<SceneObject>(bs._decodeFromIntermediate(addedChildData));
sceneObject->setParent(object);
if(object->isInstantiated())
sceneObject->_instantiate();
}
for (auto& componentDiff : diff->componentDiffs)
{
for (auto& component : components)
{
if (componentDiff->id == component->getLinkId())
{
IDiff& diffHandler = component->getRTTI()->getDiffHandler();
diffHandler.applyDiff(component.getInternalPtr(), componentDiff->data);
break;
}
}
}
for (auto& childDiff : diff->childDiffs)
{
UINT32 childCount = object->getNumChildren();
for (UINT32 i = 0; i < childCount; i++)
{
HSceneObject child = object->getChild(i);
if (childDiff->id == child->getLinkId())
{
applyDiff(childDiff, child);
break;
}
}
}
}
SPtr<PrefabObjectDiff> PrefabDiff::generateDiff(const HSceneObject& prefab, const HSceneObject& instance)
{
SPtr<PrefabObjectDiff> output;
if (prefab->getName() != instance->getName())
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->name = instance->getName();
output->soFlags |= (UINT32)SceneObjectDiffFlags::Name;
}
if (prefab->getPosition() != instance->getPosition())
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->position = instance->getPosition();
output->soFlags |= (UINT32)SceneObjectDiffFlags::Position;
}
if (prefab->getRotation() != instance->getRotation())
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->rotation = instance->getRotation();
output->soFlags |= (UINT32)SceneObjectDiffFlags::Rotation;
}
if (prefab->getScale() != instance->getScale())
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->scale = instance->getScale();
output->soFlags |= (UINT32)SceneObjectDiffFlags::Scale;
}
if (prefab->getActive() != instance->getActive())
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->isActive = instance->getActive();
output->soFlags |= (UINT32)SceneObjectDiffFlags::Active;
}
UINT32 prefabChildCount = prefab->getNumChildren();
UINT32 instanceChildCount = instance->getNumChildren();
// Find modified and removed children
for (UINT32 i = 0; i < prefabChildCount; i++)
{
HSceneObject prefabChild = prefab->getChild(i);
SPtr<PrefabObjectDiff> childDiff;
bool foundMatching = false;
for (UINT32 j = 0; j < instanceChildCount; j++)
{
HSceneObject instanceChild = instance->getChild(j);
if (prefabChild->getLinkId() == instanceChild->getLinkId())
{
if (instanceChild->mPrefabLinkUUID.empty())
childDiff = generateDiff(prefabChild, instanceChild);
foundMatching = true;
break;
}
}
if (foundMatching)
{
if (childDiff != nullptr)
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->childDiffs.push_back(childDiff);
}
}
else
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->removedChildren.push_back(prefabChild->getLinkId());
}
}
// Find added children
for (UINT32 i = 0; i < instanceChildCount; i++)
{
HSceneObject instanceChild = instance->getChild(i);
if (instanceChild->hasFlag(SOF_DontSave))
continue;
bool foundMatching = false;
if (instanceChild->getLinkId() != -1)
{
for (UINT32 j = 0; j < prefabChildCount; j++)
{
HSceneObject prefabChild = prefab->getChild(j);
if (prefabChild->getLinkId() == instanceChild->getLinkId())
{
foundMatching = true;
break;
}
}
}
if (!foundMatching)
{
BinarySerializer bs;
SPtr<SerializedObject> obj = bs._encodeToIntermediate(instanceChild.get());
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->addedChildren.push_back(obj);
}
}
const Vector<HComponent>& prefabComponents = prefab->getComponents();
const Vector<HComponent>& instanceComponents = instance->getComponents();
UINT32 prefabComponentCount = (UINT32)prefabComponents.size();
UINT32 instanceComponentCount = (UINT32)instanceComponents.size();
// Find modified and removed components
for (UINT32 i = 0; i < prefabComponentCount; i++)
{
HComponent prefabComponent = prefabComponents[i];
SPtr<PrefabComponentDiff> childDiff;
bool foundMatching = false;
for (UINT32 j = 0; j < instanceComponentCount; j++)
{
HComponent instanceComponent = instanceComponents[j];
if (prefabComponent->getLinkId() == instanceComponent->getLinkId())
{
BinarySerializer bs;
SPtr<SerializedObject> encodedPrefab = bs._encodeToIntermediate(prefabComponent.get());
SPtr<SerializedObject> encodedInstance = bs._encodeToIntermediate(instanceComponent.get());
IDiff& diffHandler = prefabComponent->getRTTI()->getDiffHandler();
SPtr<SerializedObject> diff = diffHandler.generateDiff(encodedPrefab, encodedInstance);
if (diff != nullptr)
{
childDiff = bs_shared_ptr_new<PrefabComponentDiff>();
childDiff->id = prefabComponent->getLinkId();
childDiff->data = diff;
}
foundMatching = true;
break;
}
}
if (foundMatching)
{
if (childDiff != nullptr)
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->componentDiffs.push_back(childDiff);
}
}
else
{
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->removedComponents.push_back(prefabComponent->getLinkId());
}
}
// Find added components
for (UINT32 i = 0; i < instanceComponentCount; i++)
{
HComponent instanceComponent = instanceComponents[i];
bool foundMatching = false;
if (instanceComponent->getLinkId() != -1)
{
for (UINT32 j = 0; j < prefabComponentCount; j++)
{
HComponent prefabComponent = prefabComponents[j];
if (prefabComponent->getLinkId() == instanceComponent->getLinkId())
{
foundMatching = true;
break;
}
}
}
if (!foundMatching)
{
BinarySerializer bs;
SPtr<SerializedObject> obj = bs._encodeToIntermediate(instanceComponent.get());
if (output == nullptr)
output = bs_shared_ptr_new<PrefabObjectDiff>();
output->addedComponents.push_back(obj);
}
}
if (output != nullptr)
output->id = instance->getLinkId();
return output;
}