NetworkTransform misses sync when GameObject is re-enabled; add option for automatic reassertion

[Wyndar]

Description
When using NetworkTransform in server-authoritative mode, if a NetworkObject is deactivated on clients (e.g. via SetActive(false) or scene streaming), any transform changes (e.g. via Teleport) made while it's inactive are not propagated to the client once it's re-enabled. This results in position mismatches, where the client sees the object at its old position while the server has already moved it.

There is no warning, and the desync is silent unless manually corrected.

Reproduction Steps
Spawn a server-authoritative NetworkObject with a NetworkTransform

Deactivate the object on all clients (via RPC or reparenting in a disabled object)

On the server, call Teleport(...) to move the object

Reactivate the object after a short delay

Observe: the client does not reflect the new position

Expected Behavior
Clients should receive the latest authoritative position of the object when it becomes active again.

Workarounds
Currently, we must:

Reapply Teleport() after reactivating the object, or

Use a coroutine to delay the teleport until the object is re-enabled, or

Use custom NetworkVariable logic or whatever boiler plate works instead of NetworkTransform

Suggested Fixes
Add a forceResyncOnEnable bool on NetworkTransform

Internally store the last known transform state, and resend it on reactivation

Or provide an OnNetworkObjectReenabled callback for developers to manually reassert state

[marcusx2]

This is the same for ClientNetworkTransform

[NoelStephensUnity]

So,
This is actually a performance related thing where if you disabled the GameObject then the NetworkTransform authority instance will exit early when checking for state changes. The assumption made was if you have disabled the GameObject then you wouldn't be moving it or be concerned of synchronizing position when something is disabled.

We could provide a property that lets you bypass this check:

        private void OnNetworkTick(bool isCalledFromParent = false)
        {
            // If not active, then ignore the update
            if (!gameObject.activeInHierarchy)
            {
                return;
            }

That would allow you to control whether it would send updates or not while it is disabled.

For the time being, something along the lines of this:

public class ControlNetworkTransform : NetworkTransform
{
    private bool m_WasDisabled;

    private void OnDisable()
    {
        if (IsSpawned && CanCommitToTransform)
        {
            m_WasDisabled = true;
        }
    }

    private void OnEnable()
    {
        if (m_WasDisabled && IsSpawned && CanCommitToTransform)
        {
            m_WasDisabled = false;
            SetState(transform.position, transform.rotation, teleportDisabled: false);
        }
    }
}

Should resolve your issue (similar to what you pointed out in the work arounds).

[marcusx2]

We actually only want to send updates when it is enabled, not disabled. The problem is that if you disable the gameobject, when you reenable the synchronization breaks. So you can never disable the gameobject with the networktransform.

EDIT

Just re-read the original post. In my case, I just move when it's enabled, but it still breaks if I ever disable the gameobject with the networktransform.