charleslemaux/Mirror
1
0
Fork 0
mirror of https://github.com/MirrorNetworking/Mirror.git synced 2024-11-17 18:40:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

SCALE WIP

Browse Source
This commit is contained in:
miwarnec 2024-11-05 12:10:10 +01:00
parent 8e83da26b4
commit 62c3799257
1 changed files with 407 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

439
Assets/Mirror/Components/NetworkTransform/NetworkTransformHybrid2022.cs
View File

@ -51,11 +51,13 @@ public class NetworkTransformHybrid2022 : NetworkBehaviour
byte lastSerializedBaselineTick = 0;
Vector3 lastSerializedBaselinePosition = Vector3.zero;
Quaternion lastSerializedBaselineRotation = Quaternion.identity;
Vector3 lastSerializedBaselineScale = Vector3.one;
// save last deserialized baseline to delta decompress against
byte lastDeserializedBaselineTick = 0;
Vector3 lastDeserializedBaselinePosition = Vector3.zero; // unused, but keep for delta
Quaternion lastDeserializedBaselineRotation = Quaternion.identity; // unused, but keep for delta
Vector3 lastDeserializedBaselineScale = Vector3.one; // unused, but keep for delta
// only sync when changed hack /////////////////////////////////////////
[Header("Sync Only If Changed")]
@ -81,7 +83,7 @@ public class NetworkTransformHybrid2022 : NetworkBehaviour
[Header("Sensitivity"), Tooltip("Sensitivity of changes needed before an updated state is sent over the network")]
public float positionSensitivity = 0.01f;
public float rotationSensitivity = 0.01f;
// public float scaleSensitivity = 0.01f;
public float scaleSensitivity = 0.01f;
[Tooltip("Enable to send all unreliable messages twice. Only useful for extremely fast-paced games since it doubles bandwidth costs.")]
public bool unreliableRedundancy = false;
@ -93,7 +95,7 @@ public class NetworkTransformHybrid2022 : NetworkBehaviour
[Header("Selective Sync & interpolation")]
public bool syncPosition = true;
public bool syncRotation = true;
// public bool syncScale = false; // rarely used. disabled for perf so we can rely on transform.GetPositionAndRotation.
public bool syncScale = false;
// BEGIN CUSTOM CHANGE /////////////////////////////////////////////////
// TODO rename to avoid double negative
@ -143,13 +145,13 @@ protected virtual void ApplySnapshot(TransformSnapshot interpolated)
// scale, then we should not touch scale etc.
if (syncPosition) target.localPosition = interpolated.position;
if (syncRotation) target.localRotation = interpolated.rotation;
// if (syncScale) target.localScale = interpolated.scale;
if (syncScale) target.localScale = interpolated.scale;
}
// check if position / rotation / scale changed since last _full reliable_ sync.
// squared comparisons for performance
[MethodImpl(MethodImplOptions.AggressiveInlining)]
bool Changed(Vector3 currentPosition, Quaternion currentRotation)//, Vector3 currentScale)
bool Changed(Vector3 currentPosition, Quaternion currentRotation, Vector3 currentScale)
{
if (syncPosition)
{
@ -169,14 +171,35 @@ bool Changed(Vector3 currentPosition, Quaternion currentRotation)//, Vector3 cur
}
}
// if (syncScale && Vector3.Distance(last.scale, current.scale) >= scalePrecision)
// if (syncScale && (current.scale - last.scale).sqrMagnitude >= scalePrecisionSqr)
// return true;
if (syncScale)
{
float scaleDelta = Vector3.Distance(currentScale, lastSerializedBaselineScale);
if (scaleDelta >= scaleSensitivity)
{
return true;
}
}
return false;
}
// cmd baseline ////////////////////////////////////////////////////////
[Command(channel = Channels.Reliable)] // reliable baseline
void CmdClientToServerBaseline_PositionRotationScale(byte baselineTick, Vector3 position, Quaternion rotation, Vector3 scale)
{
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselinePosition = position;
lastDeserializedBaselineRotation = rotation;
lastDeserializedBaselineScale = scale;
// debug draw: baseline
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.yellow, 10f);
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnClientToServerDeltaSync(baselineTick, position, rotation, scale);
}
[Command(channel = Channels.Reliable)] // reliable baseline
void CmdClientToServerBaseline_PositionRotation(byte baselineTick, Vector3 position, Quaternion rotation)
{
@ -189,7 +212,34 @@ void CmdClientToServerBaseline_PositionRotation(byte baselineTick, Vector3 posit
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnClientToServerDeltaSync(baselineTick, position, rotation);//, scale);
OnClientToServerDeltaSync(baselineTick, position, rotation, Vector3.one);
}
[Command(channel = Channels.Reliable)] // reliable baseline
void CmdClientToServerBaseline_PositionScale(byte baselineTick, Vector3 position, Vector3 scale)
{
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselinePosition = position;
lastDeserializedBaselineScale = scale;
// debug draw: baseline
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.yellow, 10f);
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnClientToServerDeltaSync(baselineTick, position, Quaternion.identity, scale);
}
[Command(channel = Channels.Reliable)] // reliable baseline
void CmdClientToServerBaseline_RotationScale(byte baselineTick, Quaternion rotation, Vector3 scale)
{
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselineRotation = rotation;
lastDeserializedBaselineScale = scale;
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnClientToServerDeltaSync(baselineTick, Vector3.zero, rotation, scale);
}
[Command(channel = Channels.Reliable)] // reliable baseline
@ -203,7 +253,7 @@ void CmdClientToServerBaseline_Position(byte baselineTick, Vector3 position)
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnClientToServerDeltaSync(baselineTick, position, Quaternion.identity);//, scale);
OnClientToServerDeltaSync(baselineTick, position, Quaternion.identity, Vector3.one);
}
[Command(channel = Channels.Reliable)] // reliable baseline
@ -214,7 +264,18 @@ void CmdClientToServerBaseline_Rotation(byte baselineTick, Quaternion rotation)
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnClientToServerDeltaSync(baselineTick, Vector3.zero, rotation);//, scale);
OnClientToServerDeltaSync(baselineTick, Vector3.zero, rotation, Vector3.one);
}
[Command(channel = Channels.Reliable)] // reliable baseline
void CmdClientToServerBaseline_Scale(byte baselineTick, Vector3 scale)
{
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselineScale = scale;
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnClientToServerDeltaSync(baselineTick, Vector3.zero, Quaternion.identity, scale);
}
// cmd delta ///////////////////////////////////////////////////////////
@ -225,14 +286,31 @@ void CmdClientToServerDelta_Position(byte baselineTick, Vector3 position)
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
// Debug.Log($"[{name}] server received delta for baseline #{lastDeserializedBaselineTick}");
OnClientToServerDeltaSync(baselineTick, position, Quaternion.identity);//, scale);
OnClientToServerDeltaSync(baselineTick, position, Quaternion.identity, Vector3.one);
}
[Command(channel = Channels.Unreliable)] // unreliable delta
void CmdClientToServerDelta_Rotation(byte baselineTick, Quaternion rotation)
{
// Debug.Log($"[{name}] server received delta for baseline #{lastDeserializedBaselineTick}");
OnClientToServerDeltaSync(baselineTick, Vector3.zero, rotation);//, scale);
OnClientToServerDeltaSync(baselineTick, Vector3.zero, rotation, Vector3.one);
}
[Command(channel = Channels.Unreliable)] // unreliable delta
void CmdClientToServerDelta_Scale(byte baselineTick, Vector3 scale)
{
// Debug.Log($"[{name}] server received delta for baseline #{lastDeserializedBaselineTick}");
OnClientToServerDeltaSync(baselineTick, Vector3.zero, Quaternion.identity, scale);
}
[Command(channel = Channels.Unreliable)] // unreliable delta
void CmdClientToServerDelta_PositionRotationScale(byte baselineTick, Vector3 position, Quaternion rotation, Vector3 scale)
{
// debug draw: delta
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
// Debug.Log($"[{name}] server received delta for baseline #{lastDeserializedBaselineTick}");
OnClientToServerDeltaSync(baselineTick, position, rotation, scale);
}
[Command(channel = Channels.Unreliable)] // unreliable delta
@ -242,11 +320,28 @@ void CmdClientToServerDelta_PositionRotation(byte baselineTick, Vector3 position
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
// Debug.Log($"[{name}] server received delta for baseline #{lastDeserializedBaselineTick}");
OnClientToServerDeltaSync(baselineTick, position, rotation);//, scale);
OnClientToServerDeltaSync(baselineTick, position, rotation, Vector3.one);
}
[Command(channel = Channels.Unreliable)] // unreliable delta
void CmdClientToServerDelta_PositionScale(byte baselineTick, Vector3 position, Vector3 scale)
{
// debug draw: delta
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
// Debug.Log($"[{name}] server received delta for baseline #{lastDeserializedBaselineTick}");
OnClientToServerDeltaSync(baselineTick, position, Quaternion.identity, scale);
}
[Command(channel = Channels.Unreliable)] // unreliable delta
void CmdClientToServerDelta_RotationScale(byte baselineTick, Quaternion rotation, Vector3 scale)
{
// Debug.Log($"[{name}] server received delta for baseline #{lastDeserializedBaselineTick}");
OnClientToServerDeltaSync(baselineTick, Vector3.zero, rotation, scale);
}
// local authority client sends sync message to server for broadcasting
protected virtual void OnClientToServerDeltaSync(byte baselineTick, Vector3 position, Quaternion rotation)//, Vector3 scale)
protected virtual void OnClientToServerDeltaSync(byte baselineTick, Vector3 position, Quaternion rotation, Vector3 scale)
{
// only apply if in client authority mode
if (syncDirection != SyncDirection.ClientToServer) return;
@ -280,11 +375,37 @@ protected virtual void OnClientToServerDeltaSync(byte baselineTick, Vector3 posi
Time.timeAsDouble,
position,
rotation,
Vector3.one // scale
scale
));
}
// rpc baseline ////////////////////////////////////////////////////////
[ClientRpc(channel = Channels.Reliable)] // reliable baseline
void RpcServerToClientBaseline_PositionRotationScale(byte baselineTick, Vector3 position, Quaternion rotation, Vector3 scale)
{
// baseline is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
// save last deserialized baseline tick number to compare deltas against
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselinePosition = position;
lastDeserializedBaselineRotation = rotation;
lastDeserializedBaselineScale = scale;
// debug draw: baseline
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.yellow, 10f);
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(baselineTick, position, rotation, scale);
}
[ClientRpc(channel = Channels.Reliable)] // reliable baseline
void RpcServerToClientBaseline_PositionRotation(byte baselineTick, Vector3 position, Quaternion rotation)
{
@ -307,7 +428,54 @@ void RpcServerToClientBaseline_PositionRotation(byte baselineTick, Vector3 posit
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(baselineTick, position, rotation);//, Vector3.zero);//, scale);
OnServerToClientDeltaSync(baselineTick, position, rotation, Vector3.one);
}
[ClientRpc(channel = Channels.Reliable)] // reliable baseline
void RpcServerToClientBaseline_PositionScale(byte baselineTick, Vector3 position, Vector3 scale)
{
// baseline is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
// save last deserialized baseline tick number to compare deltas against
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselinePosition = position;
lastDeserializedBaselineScale = scale;
// debug draw: baseline
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.yellow, 10f);
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(baselineTick, position, Quaternion.identity, scale);
}
[ClientRpc(channel = Channels.Reliable)] // reliable baseline
void RpcServerToClientBaseline_RotationScale(byte baselineTick, Quaternion rotation, Vector3 scale)
{
// baseline is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
// save last deserialized baseline tick number to compare deltas against
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselineRotation = rotation;
lastDeserializedBaselineScale = scale;
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(baselineTick, Vector3.zero, rotation, scale);
}
[ClientRpc(channel = Channels.Reliable)] // reliable baseline
@ -331,7 +499,7 @@ void RpcServerToClientBaseline_Position(byte baselineTick, Vector3 position)
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(baselineTick, position, Quaternion.identity);//, Vector3.zero);//, scale);
OnServerToClientDeltaSync(baselineTick, position, Quaternion.identity, Vector3.one);
}
[ClientRpc(channel = Channels.Reliable)] // reliable baseline
@ -352,10 +520,49 @@ void RpcServerToClientBaseline_Rotation(byte baselineTick, Quaternion rotation)
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(baselineTick, Vector3.zero, rotation);//, Vector3.zero);//, scale);
OnServerToClientDeltaSync(baselineTick, Vector3.zero, rotation, Vector3.one);
}
[ClientRpc(channel = Channels.Reliable)] // reliable baseline
void RpcServerToClientBaseline_Scale(byte baselineTick, Vector3 scale)
{
// baseline is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
// save last deserialized baseline tick number to compare deltas against
lastDeserializedBaselineTick = baselineTick;
lastDeserializedBaselineScale = scale;
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(baselineTick, Vector3.zero, Quaternion.identity, scale);
}
// rpc delta ///////////////////////////////////////////////////////////
[ClientRpc(channel = Channels.Unreliable)] // unreliable delta
void RpcServerToClientDelta_PositionRotationScale(byte baselineTick, Vector3 position, Quaternion rotation, Vector3 scale)
{
// delta is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
// debug draw: delta
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
OnServerToClientDeltaSync(baselineTick, position, rotation, scale);
}
[ClientRpc(channel = Channels.Unreliable)] // unreliable delta
void RpcServerToClientDelta_PositionRotation(byte baselineTick, Vector3 position, Quaternion rotation)
{
@ -371,9 +578,41 @@ void RpcServerToClientDelta_PositionRotation(byte baselineTick, Vector3 position
// debug draw: delta
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
OnServerToClientDeltaSync(baselineTick, position, rotation);//, scale);
OnServerToClientDeltaSync(baselineTick, position, rotation, Vector3.one);
}
[ClientRpc(channel = Channels.Unreliable)] // unreliable delta
void RpcServerToClientDelta_PositionScale(byte baselineTick, Vector3 position, Vector3 scale)
{
// delta is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
// debug draw: delta
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
OnServerToClientDeltaSync(baselineTick, position, Quaternion.identity, scale);
}
[ClientRpc(channel = Channels.Unreliable)] // unreliable delta
void RpcServerToClientDelta_RotationScale(byte baselineTick, Quaternion rotation, Vector3 scale)
{
// delta is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
OnServerToClientDeltaSync(baselineTick, Vector3.zero, rotation, scale);
}
[ClientRpc(channel = Channels.Unreliable)] // unreliable delta
void RpcServerToClientDelta_Position(byte baselineTick, Vector3 position)
@ -390,10 +629,9 @@ void RpcServerToClientDelta_Position(byte baselineTick, Vector3 position)
// debug draw: delta
if (debugDraw) Debug.DrawLine(position, position + Vector3.up, Color.white, 10f);
OnServerToClientDeltaSync(baselineTick, position, Quaternion.identity);//, scale);
OnServerToClientDeltaSync(baselineTick, position, Quaternion.identity, Vector3.one);
}
[ClientRpc(channel = Channels.Unreliable)] // unreliable delta
void RpcServerToClientDelta_Rotation(byte baselineTick, Quaternion rotation)
{
@ -406,11 +644,26 @@ void RpcServerToClientDelta_Rotation(byte baselineTick, Quaternion rotation)
// in other words: never apply the rpcs in host mode.
if (isServer) return;
OnServerToClientDeltaSync(baselineTick, Vector3.zero, rotation);//, scale);
OnServerToClientDeltaSync(baselineTick, Vector3.zero, rotation, Vector3.one);
}
[ClientRpc(channel = Channels.Unreliable)] // unreliable delta
void RpcServerToClientDelta_Scale(byte baselineTick, Vector3 scale)
{
// delta is broadcast to all clients.
// ignore if this object is owned by this client.
if (IsClientWithAuthority) return;
// host mode: baseline Rpc is also sent through host's local connection and applied.
// applying host's baseline as last deserialized would overwrite the owner client's data and cause jitter.
// in other words: never apply the rpcs in host mode.
if (isServer) return;
OnServerToClientDeltaSync(baselineTick, Vector3.zero, Quaternion.identity, scale);
}
// server broadcasts sync message to all clients
protected virtual void OnServerToClientDeltaSync(byte baselineTick, Vector3 position, Quaternion rotation)//, Vector3 scale)
protected virtual void OnServerToClientDeltaSync(byte baselineTick, Vector3 position, Quaternion rotation, Vector3 scale)
{
// in host mode, the server sends rpcs to all clients.
// the host client itself will receive them too.
@ -466,7 +719,7 @@ protected virtual void OnServerToClientDeltaSync(byte baselineTick, Vector3 posi
Time.timeAsDouble,
position,
rotation,
Vector3.one // scale
scale
));
}
@ -484,16 +737,33 @@ void UpdateServerBaseline(double localTime)
// perf: get position/rotation directly. TransformSnapshot is too expensive.
// TransformSnapshot snapshot = ConstructSnapshot();
target.GetLocalPositionAndRotation(out Vector3 position, out Quaternion rotation);
Vector3 scale = target.localScale;
// save bandwidth by only transmitting what is needed.
// -> ArraySegment with random data is slower since byte[] copying
// -> Vector3? and Quaternion? nullables takes more bandwidth
byte frameCount = (byte)Time.frameCount; // perf: only access Time.frameCount once!
if (syncPosition && syncRotation)
if (syncPosition && syncRotation && syncScale)
{
// no unreliable redundancy: baseline is reliable
RpcServerToClientBaseline_PositionRotationScale(frameCount, position, rotation, scale);
}
else if (syncPosition && syncRotation)
{
// no unreliable redundancy: baseline is reliable
RpcServerToClientBaseline_PositionRotation(frameCount, position, rotation);
}
else if (syncPosition && syncScale)
{
// no unreliable redundancy: baseline is reliable
RpcServerToClientBaseline_PositionScale(frameCount, position, scale);
}
else if (syncRotation && syncScale)
{
// no unreliable redundancy: baseline is reliable
RpcServerToClientBaseline_RotationScale(frameCount, rotation, scale);
}
else if (syncPosition)
{
// no unreliable redundancy: baseline is reliable
@ -504,6 +774,15 @@ void UpdateServerBaseline(double localTime)
// no unreliable redundancy: baseline is reliable
RpcServerToClientBaseline_Rotation(frameCount, rotation);
}
else if (syncScale)
{
// no unreliable redundancy: baseline is reliable
RpcServerToClientBaseline_Scale(frameCount, scale);
}
// position, rotation, scale
// position, rotation, !scale
// position,
// save the last baseline's tick number.
// included in baseline to identify which one it was on client
@ -512,6 +791,7 @@ void UpdateServerBaseline(double localTime)
lastBaselineTime = NetworkTime.localTime;
lastSerializedBaselinePosition = position;
lastSerializedBaselineRotation = rotation;
lastSerializedBaselineScale = scale;
// baseline was just sent after a change. reset change detection.
changedSinceBaseline = false;
@ -567,6 +847,7 @@ void UpdateServerDelta(double localTime)
// perf: get position/rotation directly. TransformSnapshot is too expensive.
// TransformSnapshot snapshot = ConstructSnapshot();
target.GetLocalPositionAndRotation(out Vector3 position, out Quaternion rotation);
Vector3 scale = target.localScale;
// look for changes every unreliable sendInterval!
// every reliable interval isn't enough, this would cause MrG's grid issue:
@ -576,7 +857,7 @@ void UpdateServerDelta(double localTime)
// => client wouldn't know we moved back to A1
// every update works, but it's unnecessary overhead since sends only happen every sendInterval
// every unreliable sendInterval is the perfect place to look for changes.
if (onlySyncOnChange && Changed(position, rotation))
if (onlySyncOnChange && Changed(position, rotation, scale))
changedSinceBaseline = true;
// only sync on change:
@ -586,13 +867,35 @@ void UpdateServerDelta(double localTime)
// save bandwidth by only transmitting what is needed.
// -> ArraySegment with random data is slower since byte[] copying
// -> Vector3? and Quaternion? nullables takes more bandwidth
if (syncPosition && syncRotation)
if (syncPosition && syncRotation && syncScale)
{
// unreliable redundancy to make up for potential message drops
RpcServerToClientDelta_PositionRotationScale(lastSerializedBaselineTick, position, rotation, scale);
if (unreliableRedundancy)
RpcServerToClientDelta_PositionRotationScale(lastSerializedBaselineTick, position, rotation, scale);
}
else if (syncPosition && syncRotation)
{
// unreliable redundancy to make up for potential message drops
RpcServerToClientDelta_PositionRotation(lastSerializedBaselineTick, position, rotation);
if (unreliableRedundancy)
RpcServerToClientDelta_PositionRotation(lastSerializedBaselineTick, position, rotation);
}
else if (syncPosition && syncScale)
{
// unreliable redundancy to make up for potential message drops
RpcServerToClientDelta_PositionScale(lastSerializedBaselineTick, position, scale);
if (unreliableRedundancy)
RpcServerToClientDelta_PositionScale(lastSerializedBaselineTick, position, scale);
}
else if (syncRotation && syncScale)
{
// unreliable redundancy to make up for potential message drops
RpcServerToClientDelta_RotationScale(lastSerializedBaselineTick, rotation, scale);
if (unreliableRedundancy)
RpcServerToClientDelta_RotationScale(lastSerializedBaselineTick, rotation, scale);
}
else if (syncPosition)
{
// unreliable redundancy to make up for potential message drops
@ -607,7 +910,13 @@ void UpdateServerDelta(double localTime)
if (unreliableRedundancy)
RpcServerToClientDelta_Rotation(lastSerializedBaselineTick, rotation);
}
else if (syncScale)
{
// unreliable redundancy to make up for potential message drops
RpcServerToClientDelta_Scale(lastSerializedBaselineTick, scale);
if (unreliableRedundancy)
RpcServerToClientDelta_Scale(lastSerializedBaselineTick, scale);
}
lastDeltaTime = localTime;
}
@ -676,16 +985,33 @@ void UpdateClientBaseline(double localTime)
// perf: get position/rotation directly. TransformSnapshot is too expensive.
// TransformSnapshot snapshot = ConstructSnapshot();
target.GetLocalPositionAndRotation(out Vector3 position, out Quaternion rotation);
Vector3 scale = target.localScale;
// save bandwidth by only transmitting what is needed.
// -> ArraySegment with random data is slower since byte[] copying
// -> Vector3? and Quaternion? nullables takes more bandwidth
byte frameCount = (byte)Time.frameCount; // perf: only access Time.frameCount once!
if (syncPosition && syncRotation)
if (syncPosition && syncRotation && syncScale)
{
// no unreliable redundancy: baseline is reliable
CmdClientToServerBaseline_PositionRotationScale(frameCount, position, rotation, scale);
}
else if (syncPosition && syncRotation)
{
// no unreliable redundancy: baseline is reliable
CmdClientToServerBaseline_PositionRotation(frameCount, position, rotation);
}
else if (syncPosition && syncScale)
{
// no unreliable redundancy: baseline is reliable
CmdClientToServerBaseline_PositionScale(frameCount, position, scale);
}
else if (syncRotation && syncScale)
{
// no unreliable redundancy: baseline is reliable
CmdClientToServerBaseline_RotationScale(frameCount, rotation, scale);
}
else if (syncPosition)
{
// no unreliable redundancy: baseline is reliable
@ -696,6 +1022,11 @@ void UpdateClientBaseline(double localTime)
// no unreliable redundancy: baseline is reliable
CmdClientToServerBaseline_Rotation(frameCount, rotation);
}
else if (syncScale)
{
// no unreliable redundancy: baseline is reliable
CmdClientToServerBaseline_Scale(frameCount, scale);
}
// save the last baseline's tick number.
// included in baseline to identify which one it was on client
@ -704,6 +1035,7 @@ void UpdateClientBaseline(double localTime)
lastBaselineTime = NetworkTime.localTime;
lastSerializedBaselinePosition = position;
lastSerializedBaselineRotation = rotation;
lastSerializedBaselineScale = scale;
// baseline was just sent after a change. reset change detection.
changedSinceBaseline = false;
@ -748,6 +1080,7 @@ void UpdateClientDelta(double localTime)
// perf: get position/rotation directly. TransformSnapshot is too expensive.
// TransformSnapshot snapshot = ConstructSnapshot();
target.GetLocalPositionAndRotation(out Vector3 position, out Quaternion rotation);
Vector3 scale = target.localScale;
// look for changes every unreliable sendInterval!
//
@ -758,7 +1091,7 @@ void UpdateClientDelta(double localTime)
// => server wouldn't know we moved back to A1
// every update works, but it's unnecessary overhead since sends only happen every sendInterval
// every unreliable sendInterval is the perfect place to look for changes.
if (onlySyncOnChange && Changed(position, rotation))
if (onlySyncOnChange && Changed(position, rotation, scale))
changedSinceBaseline = true;
// only sync on change:
@ -768,16 +1101,39 @@ void UpdateClientDelta(double localTime)
// save bandwidth by only transmitting what is needed.
// -> ArraySegment with random data is slower since byte[] copying
// -> Vector3? and Quaternion? nullables takes more bandwidth
if (syncPosition && syncRotation)
if (syncPosition && syncRotation && syncScale)
{
CmdClientToServerDelta_PositionRotationScale(lastSerializedBaselineTick, position, rotation, scale);
if (unreliableRedundancy)
CmdClientToServerDelta_PositionRotationScale(lastSerializedBaselineTick, position, rotation, scale);
}
else if (syncPosition && syncRotation)
{
// send snapshot without timestamp.
// receiver gets it from batch timestamp to save bandwidth.
// unreliable redundancy to make up for potential message drops
CmdClientToServerDelta_PositionRotation(lastSerializedBaselineTick, position, rotation);
if (unreliableRedundancy)
CmdClientToServerDelta_PositionRotation(lastSerializedBaselineTick, position, rotation);
}
else if (syncPosition && syncScale)
{
CmdClientToServerDelta_PositionScale(lastSerializedBaselineTick, position, scale);
if (unreliableRedundancy)
CmdClientToServerDelta_PositionScale(lastSerializedBaselineTick, position, scale);
}
else if (syncRotation && syncScale)
{
CmdClientToServerDelta_RotationScale(lastSerializedBaselineTick, rotation, scale);
if (unreliableRedundancy)
CmdClientToServerDelta_RotationScale(lastSerializedBaselineTick, rotation, scale);
}
else if (syncPosition)
{
// send snapshot without timestamp.
// receiver gets it from batch timestamp to save bandwidth.
// unreliable redundancy to make up for potential message drops
CmdClientToServerDelta_Position(lastSerializedBaselineTick, position);
if (unreliableRedundancy)
@ -785,11 +1141,19 @@ void UpdateClientDelta(double localTime)
}
else if (syncRotation)
{
// send snapshot without timestamp.
// receiver gets it from batch timestamp to save bandwidth.
// unreliable redundancy to make up for potential message drops
CmdClientToServerDelta_Rotation(lastSerializedBaselineTick, rotation);
if (unreliableRedundancy)
CmdClientToServerDelta_Rotation(lastSerializedBaselineTick, rotation);
}
else if (syncScale)
{
CmdClientToServerDelta_Scale(lastSerializedBaselineTick, scale);
if (unreliableRedundancy)
CmdClientToServerDelta_Scale(lastSerializedBaselineTick, scale);
}
lastDeltaTime = localTime;
}
@ -977,11 +1341,13 @@ public virtual void Reset()
lastSerializedBaselineTick = 0;
lastSerializedBaselinePosition = Vector3.zero;
lastSerializedBaselineRotation = Quaternion.identity;
lastSerializedBaselineScale = Vector3.one;
changedSinceBaseline = false;
lastDeserializedBaselineTick = 0;
lastDeserializedBaselinePosition = Vector3.zero;
lastDeserializedBaselineRotation = Quaternion.identity;
lastDeserializedBaselineScale = Vector3.one;
// Debug.Log($"[{name}] Reset to baselineTick=0");
}
@ -1003,6 +1369,7 @@ public override void OnSerialize(NetworkWriter writer, bool initialState)
// perf: get position/rotation directly. TransformSnapshot is too expensive.
// TransformSnapshot snapshot = ConstructSnapshot();
target.GetLocalPositionAndRotation(out Vector3 position, out Quaternion rotation);
Vector3 scale = target.localScale;
// always include the tick for deltas to compare against.
byte frameCount = (byte)Time.frameCount; // perf: only access Time.frameCount once!
@ -1010,6 +1377,7 @@ public override void OnSerialize(NetworkWriter writer, bool initialState)
if (syncPosition) writer.WriteVector3(position);
if (syncRotation) writer.WriteQuaternion(rotation);
if (syncScale) writer.WriteVector3(scale);
// IMPORTANT
// OnSerialize(initial) is called for the spawn payload whenever
@ -1025,6 +1393,7 @@ public override void OnSerialize(NetworkWriter writer, bool initialState)
lastBaselineTime = NetworkTime.localTime;
lastSerializedBaselinePosition = position;
lastSerializedBaselineRotation = rotation;
lastSerializedBaselineScale = scale;
}
}
@ -1039,6 +1408,7 @@ public override void OnDeserialize(NetworkReader reader, bool initialState)
lastDeserializedBaselineTick = reader.ReadByte();
Vector3 position = Vector3.zero;
Quaternion rotation = Quaternion.identity;
Vector3 scale = Vector3.one;
if (syncPosition)
{
@ -1050,10 +1420,15 @@ public override void OnDeserialize(NetworkReader reader, bool initialState)
rotation = reader.ReadQuaternion();
lastDeserializedBaselineRotation = rotation;
}
if (syncScale)
{
scale = reader.ReadVector3();
lastDeserializedBaselineScale = scale;
}
// if baseline counts as delta, insert it into snapshot buffer too
if (baselineIsDelta)
OnServerToClientDeltaSync(lastDeserializedBaselineTick, position, rotation);//, scale);
OnServerToClientDeltaSync(lastDeserializedBaselineTick, position, rotation, scale);
}
}
// CUSTOM CHANGE ///////////////////////////////////////////////////////////