niko
624 lines
16 KiB
C#
624 lines
16 KiB
C#
using System;
|
|
|
|
namespace UnityEngine.Networking
|
|
{
|
|
// Token: 0x0200005C RID: 92
|
|
[AddComponentMenu("Network/NetworkTransformChild")]
|
|
public class NetworkTransformChild : NetworkBehaviour
|
|
{
|
|
// Token: 0x170000B8 RID: 184
|
|
// (get) Token: 0x0600046E RID: 1134 RVA: 0x000195D8 File Offset: 0x000177D8
|
|
// (set) Token: 0x0600046F RID: 1135 RVA: 0x000195F3 File Offset: 0x000177F3
|
|
public Transform target
|
|
{
|
|
get
|
|
{
|
|
return this.m_Target;
|
|
}
|
|
set
|
|
{
|
|
this.m_Target = value;
|
|
this.OnValidate();
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B9 RID: 185
|
|
// (get) Token: 0x06000470 RID: 1136 RVA: 0x00019604 File Offset: 0x00017804
|
|
public uint childIndex
|
|
{
|
|
get
|
|
{
|
|
return this.m_ChildIndex;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BA RID: 186
|
|
// (get) Token: 0x06000471 RID: 1137 RVA: 0x00019620 File Offset: 0x00017820
|
|
// (set) Token: 0x06000472 RID: 1138 RVA: 0x0001963B File Offset: 0x0001783B
|
|
public float sendInterval
|
|
{
|
|
get
|
|
{
|
|
return this.m_SendInterval;
|
|
}
|
|
set
|
|
{
|
|
this.m_SendInterval = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BB RID: 187
|
|
// (get) Token: 0x06000473 RID: 1139 RVA: 0x00019648 File Offset: 0x00017848
|
|
// (set) Token: 0x06000474 RID: 1140 RVA: 0x00019663 File Offset: 0x00017863
|
|
public NetworkTransform.AxisSyncMode syncRotationAxis
|
|
{
|
|
get
|
|
{
|
|
return this.m_SyncRotationAxis;
|
|
}
|
|
set
|
|
{
|
|
this.m_SyncRotationAxis = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BC RID: 188
|
|
// (get) Token: 0x06000475 RID: 1141 RVA: 0x00019670 File Offset: 0x00017870
|
|
// (set) Token: 0x06000476 RID: 1142 RVA: 0x0001968B File Offset: 0x0001788B
|
|
public NetworkTransform.CompressionSyncMode rotationSyncCompression
|
|
{
|
|
get
|
|
{
|
|
return this.m_RotationSyncCompression;
|
|
}
|
|
set
|
|
{
|
|
this.m_RotationSyncCompression = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BD RID: 189
|
|
// (get) Token: 0x06000477 RID: 1143 RVA: 0x00019698 File Offset: 0x00017898
|
|
// (set) Token: 0x06000478 RID: 1144 RVA: 0x000196B3 File Offset: 0x000178B3
|
|
public float movementThreshold
|
|
{
|
|
get
|
|
{
|
|
return this.m_MovementThreshold;
|
|
}
|
|
set
|
|
{
|
|
this.m_MovementThreshold = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BE RID: 190
|
|
// (get) Token: 0x06000479 RID: 1145 RVA: 0x000196C0 File Offset: 0x000178C0
|
|
// (set) Token: 0x0600047A RID: 1146 RVA: 0x000196DB File Offset: 0x000178DB
|
|
public float interpolateRotation
|
|
{
|
|
get
|
|
{
|
|
return this.m_InterpolateRotation;
|
|
}
|
|
set
|
|
{
|
|
this.m_InterpolateRotation = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BF RID: 191
|
|
// (get) Token: 0x0600047B RID: 1147 RVA: 0x000196E8 File Offset: 0x000178E8
|
|
// (set) Token: 0x0600047C RID: 1148 RVA: 0x00019703 File Offset: 0x00017903
|
|
public float interpolateMovement
|
|
{
|
|
get
|
|
{
|
|
return this.m_InterpolateMovement;
|
|
}
|
|
set
|
|
{
|
|
this.m_InterpolateMovement = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C0 RID: 192
|
|
// (get) Token: 0x0600047D RID: 1149 RVA: 0x00019710 File Offset: 0x00017910
|
|
// (set) Token: 0x0600047E RID: 1150 RVA: 0x0001972B File Offset: 0x0001792B
|
|
public NetworkTransform.ClientMoveCallback3D clientMoveCallback3D
|
|
{
|
|
get
|
|
{
|
|
return this.m_ClientMoveCallback3D;
|
|
}
|
|
set
|
|
{
|
|
this.m_ClientMoveCallback3D = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C1 RID: 193
|
|
// (get) Token: 0x0600047F RID: 1151 RVA: 0x00019738 File Offset: 0x00017938
|
|
public float lastSyncTime
|
|
{
|
|
get
|
|
{
|
|
return this.m_LastClientSyncTime;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C2 RID: 194
|
|
// (get) Token: 0x06000480 RID: 1152 RVA: 0x00019754 File Offset: 0x00017954
|
|
public Vector3 targetSyncPosition
|
|
{
|
|
get
|
|
{
|
|
return this.m_TargetSyncPosition;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C3 RID: 195
|
|
// (get) Token: 0x06000481 RID: 1153 RVA: 0x00019770 File Offset: 0x00017970
|
|
public Quaternion targetSyncRotation3D
|
|
{
|
|
get
|
|
{
|
|
return this.m_TargetSyncRotation3D;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000482 RID: 1154 RVA: 0x0001978C File Offset: 0x0001798C
|
|
private void OnValidate()
|
|
{
|
|
if (this.m_Target != null)
|
|
{
|
|
Transform transform = this.m_Target.parent;
|
|
if (transform == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkTransformChild target cannot be the root transform.");
|
|
}
|
|
this.m_Target = null;
|
|
return;
|
|
}
|
|
while (transform.parent != null)
|
|
{
|
|
transform = transform.parent;
|
|
}
|
|
this.m_Root = transform.gameObject.GetComponent<NetworkTransform>();
|
|
if (this.m_Root == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkTransformChild root must have NetworkTransform");
|
|
}
|
|
this.m_Target = null;
|
|
return;
|
|
}
|
|
}
|
|
this.m_ChildIndex = uint.MaxValue;
|
|
NetworkTransformChild[] components = this.m_Root.GetComponents<NetworkTransformChild>();
|
|
uint num = 0U;
|
|
while ((ulong)num < (ulong)((long)components.Length))
|
|
{
|
|
if (components[(int)((UIntPtr)num)] == this)
|
|
{
|
|
this.m_ChildIndex = num;
|
|
break;
|
|
}
|
|
num += 1U;
|
|
}
|
|
if (this.m_ChildIndex == 4294967295U)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkTransformChild component must be a child in the same hierarchy");
|
|
}
|
|
this.m_Target = null;
|
|
}
|
|
if (this.m_SendInterval < 0f)
|
|
{
|
|
this.m_SendInterval = 0f;
|
|
}
|
|
if (this.m_SyncRotationAxis < NetworkTransform.AxisSyncMode.None || this.m_SyncRotationAxis > NetworkTransform.AxisSyncMode.AxisXYZ)
|
|
{
|
|
this.m_SyncRotationAxis = NetworkTransform.AxisSyncMode.None;
|
|
}
|
|
if (this.movementThreshold < 0f)
|
|
{
|
|
this.movementThreshold = 0f;
|
|
}
|
|
if (this.interpolateRotation < 0f)
|
|
{
|
|
this.interpolateRotation = 0.01f;
|
|
}
|
|
if (this.interpolateRotation > 1f)
|
|
{
|
|
this.interpolateRotation = 1f;
|
|
}
|
|
if (this.interpolateMovement < 0f)
|
|
{
|
|
this.interpolateMovement = 0.01f;
|
|
}
|
|
if (this.interpolateMovement > 1f)
|
|
{
|
|
this.interpolateMovement = 1f;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000483 RID: 1155 RVA: 0x0001998D File Offset: 0x00017B8D
|
|
private void Awake()
|
|
{
|
|
this.m_PrevPosition = this.m_Target.localPosition;
|
|
this.m_PrevRotation = this.m_Target.localRotation;
|
|
if (base.localPlayerAuthority)
|
|
{
|
|
this.m_LocalTransformWriter = new NetworkWriter();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000484 RID: 1156 RVA: 0x000199CC File Offset: 0x00017BCC
|
|
public override bool OnSerialize(NetworkWriter writer, bool initialState)
|
|
{
|
|
if (!initialState)
|
|
{
|
|
if (base.syncVarDirtyBits == 0U)
|
|
{
|
|
writer.WritePackedUInt32(0U);
|
|
return false;
|
|
}
|
|
writer.WritePackedUInt32(1U);
|
|
}
|
|
this.SerializeModeTransform(writer);
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000485 RID: 1157 RVA: 0x00019A1C File Offset: 0x00017C1C
|
|
private void SerializeModeTransform(NetworkWriter writer)
|
|
{
|
|
writer.Write(this.m_Target.localPosition);
|
|
if (this.m_SyncRotationAxis != NetworkTransform.AxisSyncMode.None)
|
|
{
|
|
NetworkTransform.SerializeRotation3D(writer, this.m_Target.localRotation, this.syncRotationAxis, this.rotationSyncCompression);
|
|
}
|
|
this.m_PrevPosition = this.m_Target.localPosition;
|
|
this.m_PrevRotation = this.m_Target.localRotation;
|
|
}
|
|
|
|
// Token: 0x06000486 RID: 1158 RVA: 0x00019A88 File Offset: 0x00017C88
|
|
public override void OnDeserialize(NetworkReader reader, bool initialState)
|
|
{
|
|
if (!base.isServer || !NetworkServer.localClientActive)
|
|
{
|
|
if (!initialState)
|
|
{
|
|
if (reader.ReadPackedUInt32() == 0U)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
this.UnserializeModeTransform(reader, initialState);
|
|
this.m_LastClientSyncTime = Time.time;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000487 RID: 1159 RVA: 0x00019ADC File Offset: 0x00017CDC
|
|
private void UnserializeModeTransform(NetworkReader reader, bool initialState)
|
|
{
|
|
if (base.hasAuthority)
|
|
{
|
|
reader.ReadVector3();
|
|
if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
|
|
{
|
|
NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
|
|
}
|
|
}
|
|
else if (base.isServer && this.m_ClientMoveCallback3D != null)
|
|
{
|
|
Vector3 vector = reader.ReadVector3();
|
|
Vector3 zero = Vector3.zero;
|
|
Quaternion quaternion = Quaternion.identity;
|
|
if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
|
|
{
|
|
quaternion = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
|
|
}
|
|
if (this.m_ClientMoveCallback3D(ref vector, ref zero, ref quaternion))
|
|
{
|
|
this.m_TargetSyncPosition = vector;
|
|
if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
|
|
{
|
|
this.m_TargetSyncRotation3D = quaternion;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.m_TargetSyncPosition = reader.ReadVector3();
|
|
if (this.syncRotationAxis != NetworkTransform.AxisSyncMode.None)
|
|
{
|
|
this.m_TargetSyncRotation3D = NetworkTransform.UnserializeRotation3D(reader, this.syncRotationAxis, this.rotationSyncCompression);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000488 RID: 1160 RVA: 0x00019BE3 File Offset: 0x00017DE3
|
|
private void FixedUpdate()
|
|
{
|
|
if (base.isServer)
|
|
{
|
|
this.FixedUpdateServer();
|
|
}
|
|
if (base.isClient)
|
|
{
|
|
this.FixedUpdateClient();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000489 RID: 1161 RVA: 0x00019C0C File Offset: 0x00017E0C
|
|
private void FixedUpdateServer()
|
|
{
|
|
if (base.syncVarDirtyBits == 0U)
|
|
{
|
|
if (NetworkServer.active)
|
|
{
|
|
if (base.isServer)
|
|
{
|
|
if (this.GetNetworkSendInterval() != 0f)
|
|
{
|
|
float num = (this.m_Target.localPosition - this.m_PrevPosition).sqrMagnitude;
|
|
if (num < this.movementThreshold)
|
|
{
|
|
num = Quaternion.Angle(this.m_PrevRotation, this.m_Target.localRotation);
|
|
if (num < this.movementThreshold)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
base.SetDirtyBit(1U);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600048A RID: 1162 RVA: 0x00019CBC File Offset: 0x00017EBC
|
|
private void FixedUpdateClient()
|
|
{
|
|
if (this.m_LastClientSyncTime != 0f)
|
|
{
|
|
if (NetworkServer.active || NetworkClient.active)
|
|
{
|
|
if (base.isServer || base.isClient)
|
|
{
|
|
if (this.GetNetworkSendInterval() != 0f)
|
|
{
|
|
if (!base.hasAuthority)
|
|
{
|
|
if (this.m_LastClientSyncTime != 0f)
|
|
{
|
|
if (this.m_InterpolateMovement > 0f)
|
|
{
|
|
this.m_Target.localPosition = Vector3.Lerp(this.m_Target.localPosition, this.m_TargetSyncPosition, this.m_InterpolateMovement);
|
|
}
|
|
else
|
|
{
|
|
this.m_Target.localPosition = this.m_TargetSyncPosition;
|
|
}
|
|
if (this.m_InterpolateRotation > 0f)
|
|
{
|
|
this.m_Target.localRotation = Quaternion.Slerp(this.m_Target.localRotation, this.m_TargetSyncRotation3D, this.m_InterpolateRotation);
|
|
}
|
|
else
|
|
{
|
|
this.m_Target.localRotation = this.m_TargetSyncRotation3D;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600048B RID: 1163 RVA: 0x00019DEC File Offset: 0x00017FEC
|
|
private void Update()
|
|
{
|
|
if (base.hasAuthority)
|
|
{
|
|
if (base.localPlayerAuthority)
|
|
{
|
|
if (!NetworkServer.active)
|
|
{
|
|
if (Time.time - this.m_LastClientSendTime > this.GetNetworkSendInterval())
|
|
{
|
|
this.SendTransform();
|
|
this.m_LastClientSendTime = Time.time;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600048C RID: 1164 RVA: 0x00019E54 File Offset: 0x00018054
|
|
private bool HasMoved()
|
|
{
|
|
float num = (this.m_Target.localPosition - this.m_PrevPosition).sqrMagnitude;
|
|
bool flag;
|
|
if (num > 1E-05f)
|
|
{
|
|
flag = true;
|
|
}
|
|
else
|
|
{
|
|
num = Quaternion.Angle(this.m_Target.localRotation, this.m_PrevRotation);
|
|
flag = num > 1E-05f;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x0600048D RID: 1165 RVA: 0x00019ECC File Offset: 0x000180CC
|
|
[Client]
|
|
private void SendTransform()
|
|
{
|
|
if (this.HasMoved() && ClientScene.readyConnection != null)
|
|
{
|
|
this.m_LocalTransformWriter.StartMessage(16);
|
|
this.m_LocalTransformWriter.Write(base.netId);
|
|
this.m_LocalTransformWriter.WritePackedUInt32(this.m_ChildIndex);
|
|
this.SerializeModeTransform(this.m_LocalTransformWriter);
|
|
this.m_PrevPosition = this.m_Target.localPosition;
|
|
this.m_PrevRotation = this.m_Target.localRotation;
|
|
this.m_LocalTransformWriter.FinishMessage();
|
|
ClientScene.readyConnection.SendWriter(this.m_LocalTransformWriter, this.GetNetworkChannel());
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600048E RID: 1166 RVA: 0x00019F74 File Offset: 0x00018174
|
|
internal static void HandleChildTransform(NetworkMessage netMsg)
|
|
{
|
|
NetworkInstanceId networkInstanceId = netMsg.reader.ReadNetworkId();
|
|
uint num = netMsg.reader.ReadPackedUInt32();
|
|
GameObject gameObject = NetworkServer.FindLocalObject(networkInstanceId);
|
|
if (gameObject == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Received NetworkTransformChild data for GameObject that doesn't exist");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NetworkTransformChild[] components = gameObject.GetComponents<NetworkTransformChild>();
|
|
if (components == null || components.Length == 0)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("HandleChildTransform no children");
|
|
}
|
|
}
|
|
else if ((ulong)num >= (ulong)((long)components.Length))
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("HandleChildTransform childIndex invalid");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NetworkTransformChild networkTransformChild = components[(int)((UIntPtr)num)];
|
|
if (networkTransformChild == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("HandleChildTransform null target");
|
|
}
|
|
}
|
|
else if (!networkTransformChild.localPlayerAuthority)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("HandleChildTransform no localPlayerAuthority");
|
|
}
|
|
}
|
|
else if (!netMsg.conn.clientOwnedObjects.Contains(networkInstanceId))
|
|
{
|
|
if (LogFilter.logWarn)
|
|
{
|
|
Debug.LogWarning("NetworkTransformChild netId:" + networkInstanceId + " is not for a valid player");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
networkTransformChild.UnserializeModeTransform(netMsg.reader, false);
|
|
networkTransformChild.m_LastClientSyncTime = Time.time;
|
|
if (!networkTransformChild.isClient)
|
|
{
|
|
networkTransformChild.m_Target.localPosition = networkTransformChild.m_TargetSyncPosition;
|
|
networkTransformChild.m_Target.localRotation = networkTransformChild.m_TargetSyncRotation3D;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600048F RID: 1167 RVA: 0x0001A108 File Offset: 0x00018308
|
|
public override int GetNetworkChannel()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
// Token: 0x06000490 RID: 1168 RVA: 0x0001A120 File Offset: 0x00018320
|
|
public override float GetNetworkSendInterval()
|
|
{
|
|
return this.m_SendInterval;
|
|
}
|
|
|
|
// Token: 0x040001DE RID: 478
|
|
[SerializeField]
|
|
private Transform m_Target;
|
|
|
|
// Token: 0x040001DF RID: 479
|
|
[SerializeField]
|
|
private uint m_ChildIndex;
|
|
|
|
// Token: 0x040001E0 RID: 480
|
|
private NetworkTransform m_Root;
|
|
|
|
// Token: 0x040001E1 RID: 481
|
|
[SerializeField]
|
|
private float m_SendInterval = 0.1f;
|
|
|
|
// Token: 0x040001E2 RID: 482
|
|
[SerializeField]
|
|
private NetworkTransform.AxisSyncMode m_SyncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ;
|
|
|
|
// Token: 0x040001E3 RID: 483
|
|
[SerializeField]
|
|
private NetworkTransform.CompressionSyncMode m_RotationSyncCompression = NetworkTransform.CompressionSyncMode.None;
|
|
|
|
// Token: 0x040001E4 RID: 484
|
|
[SerializeField]
|
|
private float m_MovementThreshold = 0.001f;
|
|
|
|
// Token: 0x040001E5 RID: 485
|
|
[SerializeField]
|
|
private float m_InterpolateRotation = 0.5f;
|
|
|
|
// Token: 0x040001E6 RID: 486
|
|
[SerializeField]
|
|
private float m_InterpolateMovement = 0.5f;
|
|
|
|
// Token: 0x040001E7 RID: 487
|
|
[SerializeField]
|
|
private NetworkTransform.ClientMoveCallback3D m_ClientMoveCallback3D;
|
|
|
|
// Token: 0x040001E8 RID: 488
|
|
private Vector3 m_TargetSyncPosition;
|
|
|
|
// Token: 0x040001E9 RID: 489
|
|
private Quaternion m_TargetSyncRotation3D;
|
|
|
|
// Token: 0x040001EA RID: 490
|
|
private float m_LastClientSyncTime;
|
|
|
|
// Token: 0x040001EB RID: 491
|
|
private float m_LastClientSendTime;
|
|
|
|
// Token: 0x040001EC RID: 492
|
|
private Vector3 m_PrevPosition;
|
|
|
|
// Token: 0x040001ED RID: 493
|
|
private Quaternion m_PrevRotation;
|
|
|
|
// Token: 0x040001EE RID: 494
|
|
private const float k_LocalMovementThreshold = 1E-05f;
|
|
|
|
// Token: 0x040001EF RID: 495
|
|
private const float k_LocalRotationThreshold = 1E-05f;
|
|
|
|
// Token: 0x040001F0 RID: 496
|
|
private NetworkWriter m_LocalTransformWriter;
|
|
}
|
|
}
|