NetworkTransform

NetworkTransform replicates a Transform the way NGO's does: per-axis selection, change thresholds, local or world space, server or owner authority, buffered or smooth-damped interpolation on the receiving side, teleport, half-float and quaternion compression, and reliable or unreliable delivery. It rides the sync channel described in Physics, handover state and the sync channel, so it works on the entity root and on any child transform (a turret, a door, a held item) alike.

One thing is different from NGO, and it matters for what the component does on the root of an entity. Read that section first if you are porting a NetworkTransform from NGO.

The root is a special case

Every entity's root position, rotation and velocity already travel in the identity's world-state stream at full tick rate to every ghost and client, and remote copies already interpolate them through RemoteInterpolator. A NetworkTransform on the entity root therefore does not send position or rotation again. On the root it adds three things:

• scale, which the identity stream does not carry;
• Teleport, which makes every remote copy snap instead of interpolating and clears the identity interpolator too;
• owner authority, where the owning client's pose has to reach the worker somehow. In that mode the root's position and rotation do go in the chunk, but only on the owner-to-worker leg; from the worker on they travel in the identity stream as usual.

On a child transform the component replicates everything you select. IsRoot tells you which case a given instance is in (Identity.transform == transform).

Options

The inspector groups the options as the source does. Defaults are in the third column.

Axes to synchronize

Thresholds

Thresholds compare against what was last sent, not the previous tick's value, so slow drift still accumulates into an update.

Space and delivery

World-space values are container-local on the wire, like the identity stream: the authority converts with Container.ToLocal and the receiver resolves them with the container index carried by the same tick's message (NetworkIdentity.SyncContainer). You never see container space in your own code.

Precision

Interpolation (non-authoritative copies)

Authority

Server versus owner authority

AuthorityMode lives on NetworkSyncBehaviour, the base NetworkTransform shares with NetworkAnimator.

Server (default): the authoritative worker is the source of truth. Once per tick it runs AuthorityTick, compares against the last send, marks the behaviour dirty, and the worker packs the chunk into that tick's EntityState (to the gateway) and GhostSyncState (to workers holding ghosts). Every client, the owner included, follows.

Owner: NGO's ClientNetworkTransform. The owning client drives the transform:

The properties involved:

Handover is unaffected by the mode. The worker still moves the entity between containers; the owner's RPCs simply route to the new worker through the gateway. On a gained authority the send counter resets so the new worker opens with a keyframe.

Interpolation modes

Non-authoritative copies (remote entities on a client, ghosts on a worker) present the state from RemoteTick(renderTick). On a client that runs once per frame at NetworkTime.RenderTick, a few ticks behind the newest snapshot (NebulaConfig.InterpolationDelayTicks); on a worker it runs once per tick, one tick behind, before Physics.SyncTransforms so ghost colliders are in place for that tick's raycasts.

Buffered (NGO's Lerp / Legacy Lerp): received states go into a 64-entry ring indexed by tick. RemoteTick finds the samples on either side of renderTick and lerps (or slerps the position with SlerpPosition). When renderTick is at or past the newest sample the newest is held; there is no velocity to extrapolate with, unlike the identity stream. Exact, a few ticks behind.

SmoothDamp (NGO's Smooth Dampening): no buffer. Each RemoteTick moves the transform toward the newest known state with Vector3.SmoothDamp for position and scale (PositionMaxInterpolationTime, ScaleMaxInterpolationTime) and a slerp by dt / RotationMaxInterpolationTime for rotation, where dt is the tick interval on a worker and Time.deltaTime on a client. Never behind, never exact.

Regardless of mode, a state is applied immediately (and the buffer cleared) when it is a teleport, when Interpolate is off, when it arrived with tick 0 (the spawn snapshot a late joiner or fresh ghost receives), or on the relaying worker.

Deltas carry only the fields that changed, so the receiver keeps a merged "newest known" state and fills unsent fields and unsynchronised axes from it. Every buffered sample is therefore complete.

Teleport and SetState

Both are authority only (IsSyncAuthority); calling them on a spawned copy without authority logs a warning and does nothing.

// Move instantly; remotes snap instead of interpolating.
void Teleport(Vector3 position, Quaternion rotation, Vector3 scale);

// Set any subset (null leaves a part alone), in the configured space. teleport defaults to true.
void SetState(Vector3? position = null, Quaternion? rotation = null, Vector3? scale = null, bool teleport = true);

Position and rotation are interpreted in the configured space (InLocalSpace, or world). A teleport forces position, rotation and scale into the next chunk with the Teleport flag, even on the root, and remote copies of a root NetworkTransform also clear Identity.Interpolator and re-seed it with the new pose so the identity stream does not lerp across the jump. SetState(..., teleport: false) moves the transform and lets ordinary change detection pick it up on the next AuthorityTick.

Hooks

Two virtual methods, with NGO's names, take a TransformState:

public struct TransformState
{
    public uint Tick;
    public Vector3 Position;
    public Quaternion Rotation;
    public Vector3 Scale;
    public bool HasPosition, HasRotation, HasScale;   // fields without a Has* flag were not part of the update
    public bool Teleport;
    public bool InLocalSpace;
}

// Authority, just before a state is written. Modify it to send something other than the transform.
protected virtual void OnAuthorityPushTransformState(ref TransformState state) { }

// Non-authoritative copies, after a received state was applied or buffered.
protected virtual void OnNetworkTransformStateUpdated(ref TransformState state) { }

In OnAuthorityPushTransformState the position and rotation are in wire space (local, or container-local for world sync) and the Has* flags decide what goes on the wire, so clearing HasScale suppresses the scale for that send. In OnNetworkTransformStateUpdated the values have been converted back to stored space (world or local) and Tick is the tick they belong to (0 for a spawn snapshot).

Delivery and keyframes

SyncDelivery is Delivery.Sequenced when UseUnreliableDeltas is on, otherwise Delivery.ReliableOrdered. The worker sends one message per delivery class per entity per tick, so a reliable animator and an unreliable transform on the same entity travel separately.

Keyframes (WriteSyncState(writer, full: true), every selected field) go out:

• on the first send after this copy gained authority (a new epoch always opens with keyframes, which is what fresh ghosts and the gateway's late-joiner cache start from);
• every NetworkIdentity.SyncKeyframeInterval ticks (30, half a second at 60 Hz): for an unreliable transform whether or not it is dirty, for a reliable one only if it is dirty that tick;
• in the spawn snapshot (WriteSyncSnapshot).

Between keyframes an unreliable transform sends deltas; a lost delta shows as a held pose until the next delta or keyframe. Reliable transforms never lose a delta and pay for it in head-of-line blocking.

NGO to Nebula

Related