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

Porting V2 Settings and Time Interval Changes to V1

Browse Source
This commit is contained in:
ninjakickja 2024-01-20 09:18:29 +08:00
parent 5e52596b5c
commit 65280a8f17
2 changed files with 100 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
Assets/Mirror/Components/NetworkTransform/HybridNetworkTransform.cs
View File

@ -15,14 +15,30 @@ public class HybridNetworkTransform : NetworkBehaviour
[Tooltip("The Transform component to sync. May be on on this GameObject, or on a child.")] [Tooltip("The Transform component to sync. May be on on this GameObject, or on a child.")]
public Transform target; public Transform target;
[Header("Sync Settings")]
[Tooltip("Select the attributes to sync")]
[SerializeField] protected SyncSettings syncSettings = SyncSettings.SyncPosX | SyncSettings.SyncPosY | SyncSettings.SyncPosZ | SyncSettings.SyncRot;
protected FullHeader fullHeader;
[SerializeField] protected FullHeader syncSettings; [Header("Rotation")]
[Tooltip("Send Rotation data as uncompressed Quaternion, compressed Quaternion (smallest 3) or by Euler Angles")]
[SerializeField] protected RotationSettings rotationSettings = RotationSettings.Compressed;
[Tooltip("Sensitivity of changes needed before an updated state is sent over the network. This will be used for precision if Euler Angles is chosen")]
public float rotationSensitivity = 0.01f;
[Header("Full Send Interval Multiplier")] [Header("Precision")]
[Tooltip("Check/Sync every multiple of Network Manager send interval (= 1 / NM Send Rate), instead of every send interval.\n(30 NM send rate, and 3 interval, is a send every 0.1 seconds)\nA larger interval means less network sends, which has a variety of upsides. The drawbacks are delays and lower accuracy, you should find a nice balance between not sending too much, but the results looking good for your particular scenario.")] [Tooltip("Position is rounded in order to drastically minimize bandwidth.\n\nFor example, a precision of 0.01 rounds to a centimeter. In other words, sub-centimeter movements aren't synced until they eventually exceeded an actual centimeter.\n\nDepending on how important the object is, a precision of 0.01-0.10 (1-10 cm) is recommended.\n\nFor example, even a 1cm precision combined with delta compression cuts the Benchmark demo's bandwidth in half, compared to sending every tiny change.")]
[Range(1, 120)] [Range(0.00_01f, 1f)] // disallow 0 division. 1mm to 1m precision is enough range.
public uint fullSendIntervalMultiplier = 30; public float positionPrecision = 0.01f; // 1 cm
private uint fullSendIntervalCounter = 0; [Range(0.00_01f, 1f)] // disallow 0 division. 1mm to 1m precision is enough range.
public float scalePrecision = 0.01f; // 1 cm
[Header("Full Send Frequency")]
[Tooltip("Number of full snapshots to send per second.")]
public float fullSendFrequency = 1;
private float fullSendInterval => 1 / fullSendFrequency;
//public uint fullSendIntervalMultiplier = 30;
//private uint fullSendIntervalCounter = 0;
double lastFullSendIntervalTime = double.MinValue; double lastFullSendIntervalTime = double.MinValue;
private byte lastSentFullSyncIndex = 0; private byte lastSentFullSyncIndex = 0;
private SyncDataFull lastSentFullSyncData; private SyncDataFull lastSentFullSyncData;
@ -30,12 +46,15 @@ public class HybridNetworkTransform : NetworkBehaviour
private SyncDataFull lastReceivedFullSyncData; private SyncDataFull lastReceivedFullSyncData;
private QuantizedSnapshot lastReceivedFullQuantized; private QuantizedSnapshot lastReceivedFullQuantized;
/*[Header("Delta Send Interval Multiplier")]
[Header("Delta Send Interval Multiplier")]
[Tooltip("Check/Sync every multiple of Network Manager send interval (= 1 / NM Send Rate), instead of every send interval.\n(30 NM send rate, and 3 interval, is a send every 0.1 seconds)\nA larger interval means less network sends, which has a variety of upsides. The drawbacks are delays and lower accuracy, you should find a nice balance between not sending too much, but the results looking good for your particular scenario.")] [Tooltip("Check/Sync every multiple of Network Manager send interval (= 1 / NM Send Rate), instead of every send interval.\n(30 NM send rate, and 3 interval, is a send every 0.1 seconds)\nA larger interval means less network sends, which has a variety of upsides. The drawbacks are delays and lower accuracy, you should find a nice balance between not sending too much, but the results looking good for your particular scenario.")]
[Range(1, 120)] [Range(1, 120)]*/
public uint deltaSendIntervalMultiplier = 1; [Header("Delta Send Frequency")]
private uint deltaSendIntervalCounter = 0; [Tooltip("Number of delta snapshots to send per second.")]
public float deltaSendFrequency = 30;
private float deltaSendInterval => 1 / deltaSendFrequency;
//public uint deltaSendIntervalMultiplier = 1;
//private uint deltaSendIntervalCounter = 0;
double lastDeltaSendIntervalTime = double.MinValue; double lastDeltaSendIntervalTime = double.MinValue;
[Header("Timeline Offset")] [Header("Timeline Offset")]
@ -55,54 +74,58 @@ public class HybridNetworkTransform : NetworkBehaviour
// When everything works, we are receiving NT snapshots every 10 frames, but start interpolating after 2. // When everything works, we are receiving NT snapshots every 10 frames, but start interpolating after 2.
// Even if I assume we had 2 snapshots to begin with to start interpolating (which we don't), by the time we reach 13th frame, we are out of snapshots, and have to wait 7 frames for next snapshot to come. This is the reason why we absolutely need the timestamp adjustment. We are starting way too early to interpolate. // Even if I assume we had 2 snapshots to begin with to start interpolating (which we don't), by the time we reach 13th frame, we are out of snapshots, and have to wait 7 frames for next snapshot to come. This is the reason why we absolutely need the timestamp adjustment. We are starting way too early to interpolate.
// //
protected double timeStampAdjustment => NetworkServer.sendInterval * (deltaSendIntervalMultiplier - 1);
protected double offset => timelineOffset ? NetworkServer.sendInterval * deltaSendIntervalMultiplier : 0;
[Header("Rotation")]
[Tooltip("Sensitivity of changes needed before an updated state is sent over the network")]
public float rotationSensitivity = 0.01f;
[Header("Precision")]
[Tooltip("Position is rounded in order to drastically minimize bandwidth.\n\nFor example, a precision of 0.01 rounds to a centimeter. In other words, sub-centimeter movements aren't synced until they eventually exceeded an actual centimeter.\n\nDepending on how important the object is, a precision of 0.01-0.10 (1-10 cm) is recommended.\n\nFor example, even a 1cm precision combined with delta compression cuts the Benchmark demo's bandwidth in half, compared to sending every tiny change.")]
[Range(0.00_01f, 1f)] // disallow 0 division. 1mm to 1m precision is enough range.
public float positionPrecision = 0.01f; // 1 cm
[Range(0.00_01f, 1f)] // disallow 0 division. 1mm to 1m precision is enough range.
public float scalePrecision = 0.01f; // 1 cm
protected double timeStampAdjustment => Mathf.Max(0, deltaSendInterval - NetworkServer.sendInterval);
protected double offset => timelineOffset ? deltaSendInterval : 0;
// interpolation is on by default, but can be disabled to jump to // interpolation is on by default, but can be disabled to jump to
// the destination immediately. some projects need this. // the destination immediately. some projects need this.
[Header("Interpolation")] [Header("Interpolation")]
[Tooltip("Set to false to have a snap-like effect on position movement.")] [Tooltip("Set to false to have a snap-like effect.")]
public bool interpolatePosition = true; [SerializeField]
[Tooltip("Set to false to have a snap-like effect on rotations.")] public InterpolateSettings interpolateSettings = InterpolateSettings.Position | InterpolateSettings.Rotation | InterpolateSettings.Scale;
public bool interpolateRotation = true;
[Tooltip("Set to false to remove scale smoothing. Example use-case: Instant flipping of sprites that use -X and +X for direction.")]
public bool interpolateScale = true;
// CoordinateSpace /////////////////////////////////////////////////////////// // CoordinateSpace ///////////////////////////////////////////////////////////
[Header("Coordinate Space")] [Header("Coordinate Space")]
[Tooltip("Local by default. World may be better when changing hierarchy, or non-NetworkTransforms root position/rotation/scale values.")] [Tooltip("Local by default. World may be better when changing hierarchy, or non-NetworkTransforms root position/rotation/scale values.")]
public CoordinateSpace coordinateSpace = CoordinateSpace.Local; public ReferenceSpace coordinateSpace = ReferenceSpace.Local;
protected bool IsClientWithAuthority => isClient && authority; protected bool IsClientWithAuthority => isClient && authority;
public readonly SortedList<double, TransformSnapshot> clientSnapshots = new SortedList<double, TransformSnapshot>(16); public readonly SortedList<double, TransformSnapshot> clientSnapshots = new SortedList<double, TransformSnapshot>(16);
public readonly SortedList<double, TransformSnapshot> serverSnapshots = new SortedList<double, TransformSnapshot>(16); public readonly SortedList<double, TransformSnapshot> serverSnapshots = new SortedList<double, TransformSnapshot>(16);
protected bool syncPosition => (syncSettings & FullHeader.SyncPosX) > 0 protected bool syncPosition => (fullHeader & FullHeader.SyncPosX) > 0
|| (syncSettings & FullHeader.SyncPosY) > 0 || (fullHeader & FullHeader.SyncPosY) > 0
|| (syncSettings & FullHeader.SyncPosZ) > 0; || (fullHeader & FullHeader.SyncPosZ) > 0;
protected bool syncRotation => (syncSettings & FullHeader.SyncRot) > 0; protected bool syncRotation => (fullHeader & FullHeader.SyncRot) > 0;
protected bool syncScale => (syncSettings & FullHeader.SyncScale) > 0; protected bool syncScale => (fullHeader & FullHeader.SyncScale) > 0;
private void Awake()
{
InitFullHeader();
}
private void InitFullHeader()
{
fullHeader = (FullHeader)syncSettings;
if (rotationSettings == RotationSettings.Compressed)
{
fullHeader |= FullHeader.CompressRot;
}
else if (rotationSettings == RotationSettings.EulerAngles)
{
fullHeader |= FullHeader.UseEulerAngles;
}
}
protected override void OnValidate() protected override void OnValidate()
{ {
base.OnValidate(); base.OnValidate();
if ((syncSettings & (FullHeader.CompressRot & FullHeader.UseEulerAngles)) > 0) syncSettings &= ~FullHeader.CompressRot; if ((fullHeader & (FullHeader.CompressRot & FullHeader.UseEulerAngles)) > 0) fullHeader &= ~FullHeader.CompressRot;
deltaSendIntervalMultiplier = Math.Min(deltaSendIntervalMultiplier, fullSendIntervalMultiplier); deltaSendFrequency = Mathf.Max (deltaSendFrequency, fullSendFrequency);
fullSendIntervalMultiplier = Math.Max(deltaSendIntervalMultiplier, fullSendIntervalMultiplier); fullSendFrequency = Mathf.Min (deltaSendFrequency, fullSendFrequency);
} }
#region Apply Interpolation #region Apply Interpolation
@ -176,9 +199,9 @@ protected virtual void Apply(TransformSnapshot interpolated, TransformSnapshot e
// scale, then we should not touch scale etc. // scale, then we should not touch scale etc.
// interpolate parts // interpolate parts
if (syncPosition) SetPosition(interpolatePosition ? interpolated.position : endGoal.position); if (syncPosition) SetPosition((interpolateSettings & InterpolateSettings.Position) > 0 ? interpolated.position : endGoal.position);
if (syncRotation) SetRotation(interpolateRotation ? interpolated.rotation : endGoal.rotation); if (syncRotation) SetRotation((interpolateSettings & InterpolateSettings.Rotation) > 0 ? interpolated.rotation : endGoal.rotation);
if (syncScale) SetScale(interpolateScale ? interpolated.scale : endGoal.scale); if (syncScale) SetScale((interpolateSettings & InterpolateSettings.Scale) > 0 ? interpolated.scale : endGoal.scale);
} }
#endregion #endregion
@ -216,7 +239,7 @@ public override void OnDeserialize(NetworkReader reader, bool initialState)
if (syncRotation) rotation = reader.ReadQuaternion(); if (syncRotation) rotation = reader.ReadQuaternion();
if (syncScale) scale = reader.ReadVector3(); if (syncScale) scale = reader.ReadVector3();
SyncDataFull syncData = new SyncDataFull(index, syncSettings, position, rotation, scale); SyncDataFull syncData = new SyncDataFull(index, fullHeader, position, rotation, scale);
if (isServer) OnClientToServerSyncFull(syncData); if (isServer) OnClientToServerSyncFull(syncData);
else if (isClient) OnServerToClientSyncFull(syncData); else if (isClient) OnServerToClientSyncFull(syncData);
@ -266,11 +289,14 @@ void UpdateServerBroadcast()
// authoritative movement done by the host will have to be broadcasted // authoritative movement done by the host will have to be broadcasted
// here by checking IsClientWithAuthority. // here by checking IsClientWithAuthority.
// TODO send same time that NetworkServer sends time snapshot? // TODO send same time that NetworkServer sends time snapshot?
CheckLastSendTime();
//CheckLastSendTime();
if (syncDirection == SyncDirection.ServerToClient || IsClientWithAuthority) if (syncDirection == SyncDirection.ServerToClient || IsClientWithAuthority)
{ {
if (fullSendIntervalCounter == fullSendIntervalMultiplier) ServerBroadcastFull(); if (AccurateInterval.Elapsed(NetworkTime.localTime, fullSendInterval, ref lastFullSendIntervalTime))
else if (deltaSendIntervalCounter == deltaSendIntervalMultiplier) ServerBroadcastDelta(); ServerBroadcastFull();
else if (AccurateInterval.Elapsed(NetworkTime.localTime, deltaSendInterval, ref lastDeltaSendIntervalTime))
ServerBroadcastDelta();
} }
} }
@ -299,12 +325,15 @@ void UpdateClientBroadcast()
// DO NOT send nulls if not changed 'since last send' either. we // DO NOT send nulls if not changed 'since last send' either. we
// send unreliable and don't know which 'last send' the other end // send unreliable and don't know which 'last send' the other end
// received successfully. // received successfully.
CheckLastSendTime();
//CheckLastSendTime();
if (syncDirection == SyncDirection.ServerToClient) return; if (syncDirection == SyncDirection.ServerToClient) return;
if (fullSendIntervalCounter == fullSendIntervalMultiplier) ClientBroadcastFull(); if (AccurateInterval.Elapsed(NetworkTime.localTime, fullSendInterval, ref lastFullSendIntervalTime))
else if (deltaSendIntervalCounter == deltaSendIntervalMultiplier) ClientBroadcastDelta(); ClientBroadcastFull();
else if (AccurateInterval.Elapsed(NetworkTime.localTime, deltaSendInterval, ref lastDeltaSendIntervalTime))
ClientBroadcastDelta();
} }
#endregion #endregion
@ -493,7 +522,7 @@ protected virtual SyncDataFull ConstructFullSyncData(bool updateIndex)
{ {
return new SyncDataFull( return new SyncDataFull(
updateIndex? NextFullSyncIndex() : lastSentFullSyncIndex, updateIndex? NextFullSyncIndex() : lastSentFullSyncIndex,
syncSettings, fullHeader,
GetPosition(), GetPosition(),
GetRotation(), GetRotation(),
GetScale() GetScale()
@ -521,13 +550,13 @@ protected virtual SyncDataDelta DeriveDelta(QuantizedSnapshot current)
syncDataDelta.position = current.position - lastSentFullQuantized.position; syncDataDelta.position = current.position - lastSentFullQuantized.position;
if ((syncSettings & FullHeader.SyncPosX) > 0 && syncDataDelta.position.x != 0) if ((fullHeader & FullHeader.SyncPosX) > 0 && syncDataDelta.position.x != 0)
syncDataDelta.deltaHeader |= DeltaHeader.PosX; syncDataDelta.deltaHeader |= DeltaHeader.PosX;
if ((syncSettings & FullHeader.SyncPosY) > 0 && syncDataDelta.position.y != 0) if ((fullHeader & FullHeader.SyncPosY) > 0 && syncDataDelta.position.y != 0)
syncDataDelta.deltaHeader |= DeltaHeader.PosY; syncDataDelta.deltaHeader |= DeltaHeader.PosY;
if ((syncSettings & FullHeader.SyncPosZ) > 0 && syncDataDelta.position.z != 0) if ((fullHeader & FullHeader.SyncPosZ) > 0 && syncDataDelta.position.z != 0)
{ {
syncDataDelta.deltaHeader |= DeltaHeader.PosZ; syncDataDelta.deltaHeader |= DeltaHeader.PosZ;
} }
@ -545,9 +574,9 @@ protected virtual SyncDataDelta DeriveDelta(QuantizedSnapshot current)
// 2) If NonEulerAngles is false, we check the next 3 for each individual axis. // 2) If NonEulerAngles is false, we check the next 3 for each individual axis.
// 3) If NonEulerAngles is true, we are sending Quaternion. We piggyback on the RotX bit to tell us // 3) If NonEulerAngles is true, we are sending Quaternion. We piggyback on the RotX bit to tell us
// if it is compressed Quat or uncompressed Quat. // if it is compressed Quat or uncompressed Quat.
if ((syncSettings & FullHeader.SyncRot) > 0) if ((fullHeader & FullHeader.SyncRot) > 0)
{ {
if ((syncSettings & FullHeader.UseEulerAngles) > 0) if ((fullHeader & FullHeader.UseEulerAngles) > 0)
{ {
Compression.ScaleToLong(lastSentFullQuantized.rotation.eulerAngles, rotationSensitivity, out Vector3Long lastRotationEuler); Compression.ScaleToLong(lastSentFullQuantized.rotation.eulerAngles, rotationSensitivity, out Vector3Long lastRotationEuler);
Compression.ScaleToLong(current.rotation.eulerAngles, rotationSensitivity, out Vector3Long currentRotationEuler); Compression.ScaleToLong(current.rotation.eulerAngles, rotationSensitivity, out Vector3Long currentRotationEuler);
@ -564,7 +593,7 @@ protected virtual SyncDataDelta DeriveDelta(QuantizedSnapshot current)
{ {
syncDataDelta.quatRotation = current.rotation; syncDataDelta.quatRotation = current.rotation;
syncDataDelta.deltaHeader |= DeltaHeader.SendQuat; syncDataDelta.deltaHeader |= DeltaHeader.SendQuat;
if ((syncSettings & FullHeader.CompressRot) > 0) if ((fullHeader & FullHeader.CompressRot) > 0)
{ {
syncDataDelta.deltaHeader |= DeltaHeader.SendQuatCompressed; syncDataDelta.deltaHeader |= DeltaHeader.SendQuatCompressed;
} }
@ -572,7 +601,7 @@ protected virtual SyncDataDelta DeriveDelta(QuantizedSnapshot current)
} }
} }
if ((syncSettings & FullHeader.SyncScale) > 0) if ((fullHeader & FullHeader.SyncScale) > 0)
{ {
syncDataDelta.scale = current.scale - lastSentFullQuantized.scale; syncDataDelta.scale = current.scale - lastSentFullQuantized.scale;
if (syncDataDelta.scale != Vector3Long.zero) if (syncDataDelta.scale != Vector3Long.zero)
@ -635,7 +664,7 @@ protected void AddSnapshot(SortedList<double, TransformSnapshot> snapshots, doub
); );
} }
protected virtual void CheckLastSendTime() /*protected virtual void CheckLastSendTime()
{ {
// We check interval every frame, and then send if interval is reached. // We check interval every frame, and then send if interval is reached.
// So by the time sendIntervalCounter == sendIntervalMultiplier, data is sent, // So by the time sendIntervalCounter == sendIntervalMultiplier, data is sent,
@ -653,26 +682,26 @@ protected virtual void CheckLastSendTime()
if (AccurateInterval.Elapsed(NetworkTime.localTime, NetworkServer.sendInterval, ref lastDeltaSendIntervalTime)) if (AccurateInterval.Elapsed(NetworkTime.localTime, NetworkServer.sendInterval, ref lastDeltaSendIntervalTime))
deltaSendIntervalCounter++; deltaSendIntervalCounter++;
} }*/
#region Snapshot Functions #region Snapshot Functions
// snapshot functions ////////////////////////////////////////////////// // snapshot functions //////////////////////////////////////////////////
// get local/world position // get local/world position
protected virtual Vector3 GetPosition() => protected virtual Vector3 GetPosition() =>
coordinateSpace == CoordinateSpace.Local ? target.localPosition : target.position; coordinateSpace == ReferenceSpace.Local ? target.localPosition : target.position;
// get local/world rotation // get local/world rotation
protected virtual Quaternion GetRotation() => protected virtual Quaternion GetRotation() =>
coordinateSpace == CoordinateSpace.Local ? target.localRotation : target.rotation; coordinateSpace == ReferenceSpace.Local ? target.localRotation : target.rotation;
// get local/world scale // get local/world scale
protected virtual Vector3 GetScale() => protected virtual Vector3 GetScale() =>
coordinateSpace == CoordinateSpace.Local ? target.localScale : target.lossyScale; coordinateSpace == ReferenceSpace.Local ? target.localScale : target.lossyScale;
// set local/world position // set local/world position
protected virtual void SetPosition(Vector3 position) protected virtual void SetPosition(Vector3 position)
{ {
if (coordinateSpace == CoordinateSpace.Local) if (coordinateSpace == ReferenceSpace.Local)
target.localPosition = position; target.localPosition = position;
else else
target.position = position; target.position = position;
@ -681,7 +710,7 @@ protected virtual void SetPosition(Vector3 position)
// set local/world rotation // set local/world rotation
protected virtual void SetRotation(Quaternion rotation) protected virtual void SetRotation(Quaternion rotation)
{ {
if (coordinateSpace == CoordinateSpace.Local) if (coordinateSpace == ReferenceSpace.Local)
target.localRotation = rotation; target.localRotation = rotation;
else else
target.rotation = rotation; target.rotation = rotation;
@ -690,7 +719,7 @@ protected virtual void SetRotation(Quaternion rotation)
// set local/world position // set local/world position
protected virtual void SetScale(Vector3 scale) protected virtual void SetScale(Vector3 scale)
{ {
if (coordinateSpace == CoordinateSpace.Local) if (coordinateSpace == ReferenceSpace.Local)
target.localScale = scale; target.localScale = scale;
// Unity doesn't support setting world scale. // Unity doesn't support setting world scale.
// OnValidate disables syncScale in world mode. // OnValidate disables syncScale in world mode.
@ -705,9 +734,9 @@ protected virtual void CleanUpFullSyncDataPositionSync(ref SyncDataFull syncData
{ {
Vector3 currentPosition = GetPosition(); Vector3 currentPosition = GetPosition();
if ((syncSettings & FullHeader.SyncPosX) == 0) syncData.position.x = currentPosition.x; if ((fullHeader & FullHeader.SyncPosX) == 0) syncData.position.x = currentPosition.x;
if ((syncSettings & FullHeader.SyncPosY) == 0) syncData.position.y = currentPosition.y; if ((fullHeader & FullHeader.SyncPosY) == 0) syncData.position.y = currentPosition.y;
if ((syncSettings & FullHeader.SyncPosZ) == 0) syncData.position.z = currentPosition.z; if ((fullHeader & FullHeader.SyncPosZ) == 0) syncData.position.z = currentPosition.z;
} }
#endregion #endregion
} }

3
Assets/Mirror/Components/NetworkTransform/HybridNetworkTransformV2.cs
View File

@ -19,6 +19,7 @@ public class HybridNetworkTransformV2 : NetworkBehaviour
[Header("Sync Settings")] [Header("Sync Settings")]
[Tooltip("Select the attributes to sync")] [Tooltip("Select the attributes to sync")]
[SerializeField] protected SyncSettings syncSettings = SyncSettings.SyncPosX | SyncSettings.SyncPosY | SyncSettings.SyncPosZ | SyncSettings.SyncRot; [SerializeField] protected SyncSettings syncSettings = SyncSettings.SyncPosX | SyncSettings.SyncPosY | SyncSettings.SyncPosZ | SyncSettings.SyncRot;
protected FullHeader fullHeader;
[Header("Rotation")] [Header("Rotation")]
[Tooltip("Send Rotation data as uncompressed Quaternion, compressed Quaternion (smallest 3) or by Euler Angles")] [Tooltip("Send Rotation data as uncompressed Quaternion, compressed Quaternion (smallest 3) or by Euler Angles")]
@ -33,7 +34,7 @@ public class HybridNetworkTransformV2 : NetworkBehaviour
[Range(0.00_01f, 1f)] // disallow 0 division. 1mm to 1m precision is enough range. [Range(0.00_01f, 1f)] // disallow 0 division. 1mm to 1m precision is enough range.
public float scalePrecision = 0.01f; // 1 cm public float scalePrecision = 0.01f; // 1 cm
protected FullHeader fullHeader;
/*[Header("Full Send Interval Multiplier")] /*[Header("Full Send Interval Multiplier")]
[Tooltip("Check/Sync every multiple of Network Manager send interval (= 1 / NM Send Rate), instead of every send interval.\n(30 NM send rate, and 3 interval, is a send every 0.1 seconds)\nA larger interval means less network sends, which has a variety of upsides. The drawbacks are delays and lower accuracy, you should find a nice balance between not sending too much, but the results looking good for your particular scenario.")] [Tooltip("Check/Sync every multiple of Network Manager send interval (= 1 / NM Send Rate), instead of every send interval.\n(30 NM send rate, and 3 interval, is a send every 0.1 seconds)\nA larger interval means less network sends, which has a variety of upsides. The drawbacks are delays and lower accuracy, you should find a nice balance between not sending too much, but the results looking good for your particular scenario.")]