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

Merged master

Browse Source
This commit is contained in:
MrGadget1024 2023-03-14 07:28:23 -04:00
commit 801aca4889
5 changed files with 160 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Assets/Mirror/Components/NetworkTransformReliable/NetworkTransformReliable.cs
View File

@ -109,7 +109,6 @@ protected virtual void UpdateClient()
// only while we have snapshots
if (clientSnapshots.Count > 0)
{
// step the interpolation without touching time.
// NetworkClient is responsible for time globally.
SnapshotInterpolation.StepInterpolation(
@ -122,7 +121,6 @@ protected virtual void UpdateClient()
// interpolate & apply
TransformSnapshot computed = TransformSnapshot.Interpolate(from, to, t);
Apply(computed, to);
}
}
}

44
Assets/Mirror/Components/NetworkTransformUnreliable/NetworkTransform.cs
View File

@ -46,7 +46,7 @@ void Update()
else if (isClient) UpdateClient();
}
void UpdateServer()
void UpdateServerBroadcast()
{
// broadcast to all clients each 'sendInterval'
// (client with authority will drop the rpc)
@ -118,7 +118,10 @@ void UpdateServer()
}
#endif
}
}
void UpdateServerInterpolation()
{
// apply buffered snapshots IF client authority
// -> in server authority, server moves the object
// so no need to apply any snapshots there.
@ -131,8 +134,8 @@ void UpdateServer()
connectionToClient != null &&
!isOwned)
{
if (serverSnapshots.Count > 0)
{
if (serverSnapshots.Count == 0) return;
// step the transform interpolation without touching time.
// NetworkClient is responsible for time globally.
SnapshotInterpolation.StepInterpolation(
@ -147,12 +150,17 @@ void UpdateServer()
Apply(computed, to);
}
}
void UpdateServer()
{
// broadcast to all clients each 'sendInterval'
UpdateServerBroadcast();
// apply buffered snapshots IF client authority
UpdateServerInterpolation();
}
void UpdateClient()
{
// client authority, and local player (= allowed to move myself)?
if (IsClientWithAuthority)
void UpdateClientBroadcast()
{
// https://github.com/vis2k/Mirror/pull/2992/
if (!NetworkClient.ready) return;
@ -217,13 +225,12 @@ void UpdateClient()
#endif
}
}
// for all other clients (and for local player if !authority),
// we need to apply snapshots from the buffer
else
void UpdateClientInterpolation()
{
// only while we have snapshots
if (clientSnapshots.Count > 0)
{
if (clientSnapshots.Count == 0) return;
// step the interpolation without touching time.
// NetworkClient is responsible for time globally.
SnapshotInterpolation.StepInterpolation(
@ -237,6 +244,19 @@ void UpdateClient()
TransformSnapshot computed = TransformSnapshot.Interpolate(from, to, t);
Apply(computed, to);
}
void UpdateClient()
{
// client authority, and local player (= allowed to move myself)?
if (IsClientWithAuthority)
{
UpdateClientBroadcast();
}
// for all other clients (and for local player if !authority),
// we need to apply snapshots from the buffer
else
{
UpdateClientInterpolation();
}
}

8
Assets/Mirror/Transports/KCP/kcp2k/VERSION.txt
View File

@ -1,3 +1,11 @@
V1.33 [2023-03-14]
- perf: KcpServer/Client RawReceive now call socket.Poll to avoid non-blocking
socket's allocating a new SocketException in case they WouldBlock.
fixes https://github.com/MirrorNetworking/Mirror/issues/3413
- perf: KcpServer/Client RawSend now call socket.Poll to avoid non-blocking
socket's allocating a new SocketException in case they WouldBlock.
fixes https://github.com/MirrorNetworking/Mirror/issues/3413
V1.32 [2023-03-12]
- fix: KcpPeer RawInput now doesn't disconnect in case of random internet noise

18
Assets/Mirror/Transports/KCP/kcp2k/highlevel/KcpClient.cs
View File

@ -131,6 +131,15 @@ protected virtual bool RawReceive(out ArraySegment<byte> segment)
try
{
// when using non-blocking sockets, ReceiveFrom may return WouldBlock.
// in C#, WouldBlock throws a SocketException, which is expected.
// unfortunately, creating the SocketException allocates in C#.
// let's poll first to avoid the WouldBlock allocation.
// note that this entirely to avoid allocations.
// non-blocking UDP doesn't need Poll in other languages.
// and the code still works without the Poll call.
if (!socket.Poll(0, SelectMode.SelectRead)) return false;
// ReceiveFrom allocates. we used bound Receive.
// returns amount of bytes written into buffer.
// throws SocketException if datagram was larger than buffer.
@ -166,6 +175,15 @@ protected virtual void RawSend(ArraySegment<byte> data)
{
try
{
// when using non-blocking sockets, SendTo may return WouldBlock.
// in C#, WouldBlock throws a SocketException, which is expected.
// unfortunately, creating the SocketException allocates in C#.
// let's poll first to avoid the WouldBlock allocation.
// note that this entirely to avoid allocations.
// non-blocking UDP doesn't need Poll in other languages.
// and the code still works without the Poll call.
if (!socket.Poll(0, SelectMode.SelectWrite)) return;
socket.Send(data.Array, data.Offset, data.Count, SocketFlags.None);
}
// for non-blocking sockets, SendTo may throw WouldBlock.

22
Assets/Mirror/Transports/KCP/kcp2k/highlevel/KcpServer.cs
View File

@ -154,6 +154,15 @@ protected virtual bool RawReceiveFrom(out ArraySegment<byte> segment, out int co
try
{
// when using non-blocking sockets, ReceiveFrom may return WouldBlock.
// in C#, WouldBlock throws a SocketException, which is expected.
// unfortunately, creating the SocketException allocates in C#.
// let's poll first to avoid the WouldBlock allocation.
// note that this entirely to avoid allocations.
// non-blocking UDP doesn't need Poll in other languages.
// and the code still works without the Poll call.
if (!socket.Poll(0, SelectMode.SelectRead)) return false;
// NOTE: ReceiveFrom allocates.
// we pass our IPEndPoint to ReceiveFrom.
// receive from calls newClientEP.Create(socketAddr).
@ -206,11 +215,20 @@ protected virtual void RawSend(int connectionId, ArraySegment<byte> data)
return;
}
try
{
// when using non-blocking sockets, SendTo may return WouldBlock.
// in C#, WouldBlock throws a SocketException, which is expected.
// unfortunately, creating the SocketException allocates in C#.
// let's poll first to avoid the WouldBlock allocation.
// note that this entirely to avoid allocations.
// non-blocking UDP doesn't need Poll in other languages.
// and the code still works without the Poll call.
if (!socket.Poll(0, SelectMode.SelectWrite)) return;
// send to the the endpoint.
// do not send to 'newClientEP', as that's always reused.
// fixes https://github.com/MirrorNetworking/Mirror/issues/3296
try
{
socket.SendTo(data.Array, data.Offset, data.Count, SocketFlags.None, connection.remoteEndPoint);
}
// for non-blocking sockets, SendTo may throw WouldBlock.