InnoLab/com.unity.netcode.gameobjects
Archived
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

com.unity.netcode.gameobjects@1.0.0-pre.7

Browse Source 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.0.0-pre.7] - 2022-04-01

### Added

- Added editor only check prior to entering into play mode if the currently open and active scene is in the build list and if not displays a dialog box asking the user if they would like to automatically add it prior to entering into play mode. (#1828)
- Added `UnityTransport` implementation and `com.unity.transport` package dependency (#1823)
- Added `NetworkVariableWritePermission` to `NetworkVariableBase` and implemented `Owner` client writable netvars. (#1762)
- `UnityTransport` settings can now be set programmatically. (#1845)
- `FastBufferWriter` and Reader IsInitialized property. (#1859)

### Changed

- Updated `UnityTransport` dependency on `com.unity.transport` to 1.0.0 (#1849)

### Removed

- Removed `SnapshotSystem` (#1852)
- Removed `com.unity.modules.animation`, `com.unity.modules.physics` and `com.unity.modules.physics2d` dependencies from the package (#1812)
- Removed `com.unity.collections` dependency from the package (#1849)

### Fixed
- Fixed in-scene placed NetworkObjects not being found/ignored after a client disconnects and then reconnects. (#1850)
- Fixed issue where `UnityTransport` send queues were not flushed when calling `DisconnectLocalClient` or `DisconnectRemoteClient`. (#1847)
- Fixed NetworkBehaviour dependency verification check for an existing NetworkObject not searching from root parent transform relative GameObject. (#1841)
- Fixed issue where entries were not being removed from the NetworkSpawnManager.OwnershipToObjectsTable. (#1838)
- Fixed ClientRpcs would always send to all connected clients by default as opposed to only sending to the NetworkObject's Observers list by default. (#1836)
- Fixed clarity for NetworkSceneManager client side notification when it receives a scene hash value that does not exist in its local hash table. (#1828)
- Fixed client throws a key not found exception when it times out using UNet or UTP. (#1821)
- Fixed network variable updates are no longer limited to 32,768 bytes when NetworkConfig.EnsureNetworkVariableLengthSafety is enabled. The limits are now determined by what the transport can send in a message. (#1811)
- Fixed in-scene NetworkObjects get destroyed if a client fails to connect and shuts down the NetworkManager. (#1809)
- Fixed user never being notified in the editor that a NetworkBehaviour requires a NetworkObject to function properly. (#1808)
- Fixed PlayerObjects and dynamically spawned NetworkObjects not being added to the NetworkClient's OwnedObjects (#1801)
- Fixed issue where NetworkManager would continue starting even if the NetworkTransport selected failed. (#1780)
- Fixed issue when spawning new player if an already existing player exists it does not remove IsPlayer from the previous player (#1779)
- Fixed lack of notification that NetworkManager and NetworkObject cannot be added to the same GameObject with in-editor notifications (#1777)
- Fixed parenting warning printing for false positives (#1855)
This commit is contained in:
Unity Technologies
2022-04-01 00:00:00 +00:00
parent 5b4aaa8b59
commit 60e2dabef4
123 changed files with 5751 additions and 3419 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
Runtime/Transports/UTP/BatchedReceiveQueue.cs Normal file
View File

@@ -0,0 +1,96 @@
using System;
using Unity.Networking.Transport;
namespace Unity.Netcode.Transports.UTP
{
/// <summary>Queue for batched messages received through UTP.</summary>
/// <remarks>This is meant as a companion to <see cref="BatchedSendQueue"/>.</remarks>
internal class BatchedReceiveQueue
{
private byte[] m_Data;
private int m_Offset;
private int m_Length;
public bool IsEmpty => m_Length <= 0;
/// <summary>
/// Construct a new receive queue from a <see cref="DataStreamReader"/> returned by
/// <see cref="NetworkDriver"/> when popping a data event.
/// </summary>
/// <param name="reader">The <see cref="DataStreamReader"/> to construct from.</param>
public BatchedReceiveQueue(DataStreamReader reader)
{
m_Data = new byte[reader.Length];
unsafe
{
fixed (byte* dataPtr = m_Data)
{
reader.ReadBytes(dataPtr, reader.Length);
}
}
m_Offset = 0;
m_Length = reader.Length;
}
/// <summary>
/// Push the entire data from a <see cref="DataStreamReader"/> (as returned by popping an
/// event from a <see cref="NetworkDriver">) to the queue.
/// </summary>
/// <param name="reader">The <see cref="DataStreamReader"/> to push the data of.</param>
public void PushReader(DataStreamReader reader)
{
// Resize the array and copy the existing data to the beginning if there's not enough
// room to copy the reader's data at the end of the existing data.
var available = m_Data.Length - (m_Offset + m_Length);
if (available < reader.Length)
{
if (m_Length > 0)
{
Array.Copy(m_Data, m_Offset, m_Data, 0, m_Length);
}
m_Offset = 0;
while (m_Data.Length - m_Length < reader.Length)
{
Array.Resize(ref m_Data, m_Data.Length * 2);
}
}
unsafe
{
fixed (byte* dataPtr = m_Data)
{
reader.ReadBytes(dataPtr + m_Offset + m_Length, reader.Length);
}
}
m_Length += reader.Length;
}
/// <summary>Pop the next full message in the queue.</summary>
/// <returns>The message, or the default value if no more full messages.</returns>
public ArraySegment<byte> PopMessage()
{
if (m_Length < sizeof(int))
{
return default;
}
var messageLength = BitConverter.ToInt32(m_Data, m_Offset);
if (m_Length - sizeof(int) < messageLength)
{
return default;
}
var data = new ArraySegment<byte>(m_Data, m_Offset + sizeof(int), messageLength);
m_Offset += sizeof(int) + messageLength;
m_Length -= sizeof(int) + messageLength;
return data;
}
}
}

11
Runtime/Transports/UTP/BatchedReceiveQueue.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e9ead10b891184bd5b8f2650fd66a5b1
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

233
Runtime/Transports/UTP/BatchedSendQueue.cs Normal file
View File

@@ -0,0 +1,233 @@
using System;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Networking.Transport;
namespace Unity.Netcode.Transports.UTP
{
/// <summary>Queue for batched messages meant to be sent through UTP.</summary>
/// <remarks>
/// Messages should be pushed on the queue with <see cref="PushMessage"/>. To send batched
/// messages, call <see cref="FillWriter"> with the <see cref="DataStreamWriter"/> obtained from
/// <see cref="NetworkDriver.BeginSend"/>. This will fill the writer with as many messages as
/// possible. If the send is successful, call <see cref="Consume"/> to remove the data from the
/// queue.
///
/// This is meant as a companion to <see cref="BatchedReceiveQueue"/>, which should be used to
/// read messages sent with this queue.
/// </remarks>
internal struct BatchedSendQueue : IDisposable
{
private NativeArray<byte> m_Data;
private NativeArray<int> m_HeadTailIndices;
/// <summary>Overhead that is added to each message in the queue.</summary>
public const int PerMessageOverhead = sizeof(int);
// Indices into m_HeadTailIndicies.
private const int k_HeadInternalIndex = 0;
private const int k_TailInternalIndex = 1;
/// <summary>Index of the first byte of the oldest data in the queue.</summary>
private int HeadIndex
{
get { return m_HeadTailIndices[k_HeadInternalIndex]; }
set { m_HeadTailIndices[k_HeadInternalIndex] = value; }
}
/// <summary>Index one past the last byte of the most recent data in the queue.</summary>
private int TailIndex
{
get { return m_HeadTailIndices[k_TailInternalIndex]; }
set { m_HeadTailIndices[k_TailInternalIndex] = value; }
}
public int Length => TailIndex - HeadIndex;
public bool IsEmpty => HeadIndex == TailIndex;
public bool IsCreated => m_Data.IsCreated;
/// <summary>Construct a new empty send queue.</summary>
/// <param name="capacity">Maximum capacity of the send queue.</param>
public BatchedSendQueue(int capacity)
{
m_Data = new NativeArray<byte>(capacity, Allocator.Persistent);
m_HeadTailIndices = new NativeArray<int>(2, Allocator.Persistent);
HeadIndex = 0;
TailIndex = 0;
}
public void Dispose()
{
if (IsCreated)
{
m_Data.Dispose();
m_HeadTailIndices.Dispose();
}
}
/// <summary>Append data at the tail of the queue. No safety checks.</summary>
private void AppendDataAtTail(ArraySegment<byte> data)
{
unsafe
{
var writer = new DataStreamWriter((byte*)m_Data.GetUnsafePtr() + TailIndex, m_Data.Length - TailIndex);
writer.WriteInt(data.Count);
fixed (byte* dataPtr = data.Array)
{
writer.WriteBytes(dataPtr + data.Offset, data.Count);
}
}
TailIndex += sizeof(int) + data.Count;
}
/// <summary>Append a new message to the queue.</summary>
/// <param name="message">Message to append to the queue.</param>
/// <returns>
/// Whether the message was appended successfully. The only way it can fail is if there's
/// no more room in the queue. On failure, nothing is written to the queue.
/// </returns>
public bool PushMessage(ArraySegment<byte> message)
{
if (!IsCreated)
{
return false;
}
// Check if there's enough room after the current tail index.
if (m_Data.Length - TailIndex >= sizeof(int) + message.Count)
{
AppendDataAtTail(message);
return true;
}
// Check if there would be enough room if we moved data at the beginning of m_Data.
if (m_Data.Length - TailIndex + HeadIndex >= sizeof(int) + message.Count)
{
// Move the data back at the beginning of m_Data.
unsafe
{
UnsafeUtility.MemMove(m_Data.GetUnsafePtr(), (byte*)m_Data.GetUnsafePtr() + HeadIndex, Length);
}
TailIndex = Length;
HeadIndex = 0;
AppendDataAtTail(message);
return true;
}
return false;
}
/// <summary>
/// Fill as much of a <see cref="DataStreamWriter"/> as possible with data from the head of
/// the queue. Only full messages (and their length) are written to the writer.
/// </summary>
/// <remarks>
/// This does NOT actually consume anything from the queue. That is, calling this method
/// does not reduce the length of the queue. Callers are expected to call
/// <see cref="Consume"/> with the value returned by this method afterwards if the data can
/// be safely removed from the queue (e.g. if it was sent successfully).
///
/// This method should not be used together with <see cref="FillWriterWithBytes"> since this
/// could lead to a corrupted queue.
/// </remarks>
/// <param name="writer">The <see cref="DataStreamWriter"/> to write to.</param>
/// <returns>How many bytes were written to the writer.</returns>
public int FillWriterWithMessages(ref DataStreamWriter writer)
{
if (!IsCreated || Length == 0)
{
return 0;
}
unsafe
{
var reader = new DataStreamReader((byte*)m_Data.GetUnsafePtr() + HeadIndex, Length);
var writerAvailable = writer.Capacity;
var readerOffset = 0;
while (readerOffset < Length)
{
reader.SeekSet(readerOffset);
var messageLength = reader.ReadInt();
if (writerAvailable < sizeof(int) + messageLength)
{
break;
}
else
{
writer.WriteInt(messageLength);
var messageOffset = HeadIndex + reader.GetBytesRead();
writer.WriteBytes((byte*)m_Data.GetUnsafePtr() + messageOffset, messageLength);
writerAvailable -= sizeof(int) + messageLength;
readerOffset += sizeof(int) + messageLength;
}
}
return writer.Capacity - writerAvailable;
}
}
/// <summary>
/// Fill the given <see cref="DataStreamWriter"/> with as many bytes from the queue as
/// possible, disregarding message boundaries.
/// </summary>
///<remarks>
/// This does NOT actually consume anything from the queue. That is, calling this method
/// does not reduce the length of the queue. Callers are expected to call
/// <see cref="Consume"/> with the value returned by this method afterwards if the data can
/// be safely removed from the queue (e.g. if it was sent successfully).
///
/// This method should not be used together with <see cref="FillWriterWithMessages"/> since
/// this could lead to reading messages from a corrupted queue.
/// </remarks>
/// <param name="writer">The <see cref="DataStreamWriter"/> to write to.</param>
/// <returns>How many bytes were written to the writer.</returns>
public int FillWriterWithBytes(ref DataStreamWriter writer)
{
if (!IsCreated || Length == 0)
{
return 0;
}
var copyLength = Math.Min(writer.Capacity, Length);
unsafe
{
writer.WriteBytes((byte*)m_Data.GetUnsafePtr() + HeadIndex, copyLength);
}
return copyLength;
}
/// <summary>Consume a number of bytes from the head of the queue.</summary>
/// <remarks>
/// This should only be called with a size that matches the last value returned by
/// <see cref="FillWriter"/>. Anything else will result in a corrupted queue.
/// </remarks>
/// <param name="size">Number of bytes to consume from the queue.</param>
public void Consume(int size)
{
if (size >= Length)
{
HeadIndex = 0;
TailIndex = 0;
}
else
{
HeadIndex += size;
}
}
}
}

11
Runtime/Transports/UTP/BatchedSendQueue.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ddf8f97f695d740f297dc42242b76b8c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Runtime/Transports/UTP/NetworkMetricsContext.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Unity.Netcode.Transports.UTP
{
public struct NetworkMetricsContext
{
public uint PacketSentCount;
public uint PacketReceivedCount;
}
}

11
Runtime/Transports/UTP/NetworkMetricsContext.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: adb0270501ff1421896ce15cc75bd56a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

70
Runtime/Transports/UTP/NetworkMetricsPipelineStage.cs Normal file
View File

@@ -0,0 +1,70 @@
#if MULTIPLAYER_TOOLS
#if MULTIPLAYER_TOOLS_1_0_0_PRE_7
using AOT;
using Unity.Burst;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Networking.Transport;
using UnityEngine;
namespace Unity.Netcode.Transports.UTP
{
[BurstCompile]
internal unsafe struct NetworkMetricsPipelineStage : INetworkPipelineStage
{
static TransportFunctionPointer<NetworkPipelineStage.ReceiveDelegate> ReceiveFunction = new TransportFunctionPointer<NetworkPipelineStage.ReceiveDelegate>(Receive);
static TransportFunctionPointer<NetworkPipelineStage.SendDelegate> SendFunction = new TransportFunctionPointer<NetworkPipelineStage.SendDelegate>(Send);
static TransportFunctionPointer<NetworkPipelineStage.InitializeConnectionDelegate> InitializeConnectionFunction = new TransportFunctionPointer<NetworkPipelineStage.InitializeConnectionDelegate>(InitializeConnection);
public NetworkPipelineStage StaticInitialize(byte* staticInstanceBuffer,
int staticInstanceBufferLength,
NetworkSettings settings)
{
return new NetworkPipelineStage(
ReceiveFunction,
SendFunction,
InitializeConnectionFunction,
ReceiveCapacity: 0,
SendCapacity: 0,
HeaderCapacity: 0,
SharedStateCapacity: UnsafeUtility.SizeOf<NetworkMetricsContext>());
}
public int StaticSize => 0;
[BurstCompile(DisableDirectCall = true)]
[MonoPInvokeCallback(typeof(NetworkPipelineStage.ReceiveDelegate))]
private static void Receive(ref NetworkPipelineContext networkPipelineContext,
ref InboundRecvBuffer inboundReceiveBuffer,
ref NetworkPipelineStage.Requests requests,
int systemHeaderSize)
{
var networkMetricContext = (NetworkMetricsContext*)networkPipelineContext.internalSharedProcessBuffer;
networkMetricContext->PacketReceivedCount++;
}
[BurstCompile(DisableDirectCall = true)]
[MonoPInvokeCallback(typeof(NetworkPipelineStage.SendDelegate))]
private static int Send(ref NetworkPipelineContext networkPipelineContext,
ref InboundSendBuffer inboundSendBuffer,
ref NetworkPipelineStage.Requests requests,
int systemHeaderSize)
{
var networkMetricContext = (NetworkMetricsContext*)networkPipelineContext.internalSharedProcessBuffer;
networkMetricContext->PacketSentCount++;
return 0;
}
[BurstCompile(DisableDirectCall = true)]
[MonoPInvokeCallback(typeof(NetworkPipelineStage.InitializeConnectionDelegate))]
private static void InitializeConnection(byte* staticInstanceBuffer, int staticInstanceBufferLength,
byte* sendProcessBuffer, int sendProcessBufferLength, byte* receiveProcessBuffer, int receiveProcessBufferLength,
byte* sharedProcessBuffer, int sharedProcessBufferLength)
{
var networkMetricContext = (NetworkMetricsContext*)sharedProcessBuffer;
networkMetricContext->PacketSentCount = 0;
networkMetricContext->PacketReceivedCount = 0;
}
}
}
#endif
#endif

11
Runtime/Transports/UTP/NetworkMetricsPipelineStage.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 52b1ce9f83ce049c59327064bf70cee8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

1222
Runtime/Transports/UTP/UnityTransport.cs Normal file
View File

File diff suppressed because it is too large Load Diff

11
Runtime/Transports/UTP/UnityTransport.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6960e84d07fb87f47956e7a81d71c4e6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: