NetworkObject.GlobalObjectIdHash serializes invalid values when in Prefab Mode

[Yoraiz0r]

Description

NetworkObject.GlobalObjectIdHash serializes to a non-unique invalid value if it is saved when the object that holds it is in Prefab Mode.

Specifically, the issue originates from var globalObjectIdString = UnityEditor.GlobalObjectId.GetGlobalObjectIdSlow(this).ToString();, in NetworkObject.GenerateGlobalObjectIdHash which will always return GlobalObjectId_V1-0-00000000000000000000000000000000-0-0 in prefab mode.

Once the object has a corrupt hash, it seems impossible to fix, and the prefab is doomed to stay corrupt without manual script tampering.

Reproduce Steps

1. In the project view window, right click -> create -> 'Prefab'
2. Double click the prefab to enter 'Prefab Mode' in which you can edit the newly made prefab
3. Add a 'NetworkObject' component and witness its readonly GlobalObjectIdHash to be 951099334 which is the hash of GlobalObjectId_V1-0-00000000000000000000000000000000-0-0.
4. Ctrl+S to save the prefab
5. Inspect the newly made New Prefab.prefab file in any text editor of your choice, and witness that GlobalObjectIdHash: 951099334
6. (bonus), exit prefab mode, and select New Prefab in the project view, witness that the GlobalObjectIdHash is a non-951099334 value, despite being serialized as such.

Actual Outcome

GlobalObjectIdHash is broken and non-unique, unusable.

Expected Outcome

GlobalObjectIdHash should always be unique traceable to a unique object between different clients.

Screenshots

If applicable, add screenshots to help explain your problem.

Environment

• OS: Windows 10
• Unity Version: 2023.1.3f1
• Netcode Version: 1.5.1

[slb1988]

You can fix like this.

    internal void GenerateGlobalObjectIdHash()
    {
        // do NOT regenerate GlobalObjectIdHash for NetworkPrefabs while Editor is in PlayMode
        if (UnityEditor.EditorApplication.isPlaying && !string.IsNullOrEmpty(gameObject.scene.name))
        {
            return;
        }

        // do NOT regenerate GlobalObjectIdHash if Editor is transitioning into or out of PlayMode
        if (!UnityEditor.EditorApplication.isPlaying && UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
        {
            return;
        }

        var globalObjectId = UnityEditor.GlobalObjectId.GetGlobalObjectIdSlow(this);
        if (globalObjectId.assetGUID.Empty() && globalObjectId.identifierType == 0 &&
            globalObjectId.targetObjectId == 0 && globalObjectId.targetPrefabId == 0)
        {
            return;
        }

        var lastIdHash = GlobalObjectIdHash;
        var globalObjectIdString = globalObjectId.ToString();
        GlobalObjectIdHash = XXHash.Hash32(globalObjectIdString);
        if (lastIdHash != GlobalObjectIdHash)
        {
            UnityEditor.EditorUtility.SetDirty(this.gameObject);
        }
    }

[Yoraiz0r]

This assignment does look good in preventing invalid global - but some checks can probably be removed? the global id documentation seems to hint that if the identifier is 0 (null) the rest of the id is invalid so no need to check for empty / target object id / target prefab id.

I've gone and tested that there is still discrepency between the prefab mode determining invalid asset guid versus the project view asset - printing the globalObjectId.assetGUID results in 0000's for the prefab mode presentation, see this.

Looking into how to solve this, this seems to yield the desirable result in linking back to the project view (original asset's GlobalId)

        internal void GenerateGlobalObjectIdHash()
        {
            // do NOT regenerate GlobalObjectIdHash for NetworkPrefabs while Editor is in PlayMode
            if (EditorApplication.isPlaying && !string.IsNullOrEmpty(gameObject.scene.name))
                return;

            // do NOT regenerate GlobalObjectIdHash if Editor is transitioning into or out of PlayMode
            if (!EditorApplication.isPlaying && EditorApplication.isPlayingOrWillChangePlaymode)
                return;

            var globalId = GetGlobalId();

            const int nullIdentifier = 0;
            if (globalId.identifierType == nullIdentifier)
                return;

            var oldValue= GlobalObjectIdHash;
            GlobalObjectIdHash = globalId.ToString().Hash32();
            if (GlobalObjectIdHash != oldValue)
                EditorUtility.SetDirty(this);
        }

        private GlobalObjectId GetGlobalId()
        {
            var instanceGlobalId = GlobalObjectId.GetGlobalObjectIdSlow(this);
            var stage = PrefabStageUtility.GetPrefabStage(gameObject);
            if (!stage || stage.assetPath == null)
                return instanceGlobalId;
            
            var theAsset = AssetDatabase.LoadAssetAtPath<NetworkObject>(stage.assetPath);
            if (!theAsset)
                return instanceGlobalId;

            const string globalIdTemplate = "GlobalObjectId_V1-{0}-{1}-{2}-{3}";
            if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(theAsset, out var guid, out long localId))
                return instanceGlobalId;

            var prefabGlobalIdText = string.Format(globalIdTemplate, 1, guid, localId, 0);
            if (!GlobalObjectId.TryParse(prefabGlobalIdText, out var prefabGlobalId))
                return instanceGlobalId;

            return prefabGlobalId;
        }

I still wonder if there is a more reliable way to obtain a valid GlobalId, so that editing in prefab mode doesn't introduce undesired or uninitialized changes. This works for now though.

[slb1988]

I take assetGUID & identifierType &targetObjectId & targetPrefabId into consider becasue these all been used by globalObjectId .ToString(). In the native Code it just return nullIdentifier with default 0 value.

[NoelStephensUnity]

@Yoraiz0r & @slb1988
Thank you both for your detailed response and time spent investigating this issue.
I am going to be testing both of your suggested approaches (possibly end up with a combination of both), and will post back here with the results. This is an area that has needed attention indeed, and again...wanted to thank you both for your time spent on this. (very promising suggested fixes)
🥇 👍

[Yoraiz0r]

@NoelStephensUnity
Awesome!

I'd also like to suggest that while the serialized value for the globalId is invalid, such as when in a not-yet-saved scene, as per the caveats in the documentation, there should be a notable inspector warning with suggestions on fix action. I don't know how would retroactively saving the scene fix this with the current OnValidate method, but that may be a desirable feature improvement?

[NoelStephensUnity]

@Yoraiz0r
Well, so far the testing of your suggested fix is looking good. It actually solves for the issue with in-scene placed NetworkObjects where if you created a prefab from something you built within an open scene you would have to:

• Delete the source in-scene placed NetworkObject
• Create an instance from the newly created network prefab

The one part that I need to investigate a bit further is the last block of code:

            var prefabGlobalIdText = string.Format(globalIdTemplate, 1, guid, localId, 0);
            if (!GlobalObjectId.TryParse(prefabGlobalIdText, out var prefabGlobalId))
                return instanceGlobalId;

            return prefabGlobalId;

Regarding a scene not being saved, it is really for a newly created scene and to go from the current running list of issues with GlobalObjectIdHash generation to just "make sure you save your scene at least once"... I think that is an acceptable requirement. I might look into implementing the ISerializationCallbackReceiver in order to make sure no invalid GlobalObjectIdHash values remain.

But so far your suggestions are looking good!

👍