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;
	}
}