diff --git a/docs/advanced-topics/inscene_parenting_player.md b/docs/advanced-topics/inscene_parenting_player.md
index 290e3fcab..f95b93437 100644
--- a/docs/advanced-topics/inscene_parenting_player.md
+++ b/docs/advanced-topics/inscene_parenting_player.md
@@ -49,8 +49,9 @@ public class ParentPlayerToInSceneNetworkObject : NetworkBehaviour
// As long as the client (player) is in the connected clients list
if (NetworkManager.ConnectedClients.ContainsKey(clientId))
{
- // Set the player as a child of this in-scene placed NetworkObject
- NetworkManager.ConnectedClients[clientId].PlayerObject.transform.parent = transform;
+ // Set the player as a child of this in-scene placed NetworkObject
+ // We parent in local space by setting the WorldPositionStays value to false
+ NetworkManager.ConnectedClients[clientId].PlayerObject.TrySetParent(NetworkObject, false);
}
}
}
@@ -83,5 +84,5 @@ You should place this script on your in-scene placed `NetworkObject` (i.e. the f
:::note
-Remove any parenting code you might have had from your player prefab before using the above script.
+Remove any parenting code you might have had from your player prefab before using the above script. Depending upon your project's goals, you might be parenting all players under the same in-scene placed `NetworkObject` or you might intend to have each player parenting unique. If you want each player to be parented under a unique in-scene placed `NetworkObject` then you will need to have the same number of in-scene placed `NetworkObject`s as your maximum allowed players per game session. The above example will only parent all players under the same in-scene placed `NetworkObject`. You could extend the above example by migrating the scene event code into an in-scene placed `NetworkObject` that manages the parenting of players (i,e. name it something like `PlayerSpawnManager`) as they connect, make the `SetPlayerParent` method public, and add all in-scene placed `NetworkObject`s to a public list of GameObjects that the `PlayerSpawnManager` will reference and assign player's to as they connect while also freeing in-scene placed `NetworkObject`s as players disconnect during a game session.
:::
\ No newline at end of file
diff --git a/docs/advanced-topics/networkobject-parenting.md b/docs/advanced-topics/networkobject-parenting.md
index d209eafc4..d2aa66c25 100644
--- a/docs/advanced-topics/networkobject-parenting.md
+++ b/docs/advanced-topics/networkobject-parenting.md
@@ -151,7 +151,7 @@ Vehicle (GameObject->NetworkObject)
This would be considered an invalid parenting and would be reverted.
### Mildly Complex Valid Example:
-In order to resolve the previous invalid parenting issue, we would need to add a `NetworkObjet` component to the seats. This means we would need to:
+In order to resolve the previous invalid parenting issue, we would need to add a `NetworkObject` component to the seats. This means we would need to:
1. Spawn the vehicle and the seats:
```
Sun
@@ -185,8 +185,18 @@ Vehicle (GameObject->NetworkObject)
└─Seat2 (GameObject->NetworkObject)
```
+### Parenting & Transform Synchronization
+It is important to understand that without the use of a `NetworkTransform` clients are only synchronized with the transform values when:
+- A client is being synchronized with the NetworkObject in question:
+ - During the client's first synchronization after a client has their connection approved.
+ - When a server spawns a new `NetworkObject`.
+- A `NetworkObject` has been parented _(or a parent removed)_.
+ - The server can override the `NetworkBehaviour.OnNetworkObjectParentChanged` method and adjust the transform values when that is invoked.
+ - These transform changes will be synchronized with clients via the `ParentSyncMessage`
+
+
:::note Optional Auto Synchronized Parenting
-The Auto Object Parent Sync property of NetworkObject, enabled by default, allows you to disable automatic parent change synchronization in the event you want to implement your own parenting solution for one or more NetworkObjects.
+The Auto Object Parent Sync property of a `NetworkObject`, enabled by default, allows you to disable automatic parent change synchronization in the event you want to implement your own parenting solution for one or more NetworkObjects. It is important to understand that disabling the Auto Object Parent Sync option of a `NetworkObject` will treat the `NetworkObject`'s transform synchronization with *clients* as if its parent is the hierarchy root _(i.e. null)_.
:::
diff --git a/docs/basics/scenemanagement/inscene-placed-networkobjects.md b/docs/basics/scenemanagement/inscene-placed-networkobjects.md
index e3e758380..c1997e0c2 100644
--- a/docs/basics/scenemanagement/inscene-placed-networkobjects.md
+++ b/docs/basics/scenemanagement/inscene-placed-networkobjects.md
@@ -231,6 +231,30 @@ In-scene placed `NetworkObject`s follow the same parenting rules as [dynamically
- Under this scenario, you would want to use a hybrid approach where the in-scene placed `NetworkObject` dynamically spawns the item to be picked up.
- If you plan on using a bootstrap scene usage pattern where you use additive scene loading and unloading with no full scene-migration(s), then it is "OK" to parent in-scene placed NetworkObjects.
-:::warning
-Parenting in-scene placed `NetworkObject`s under `GameObject`s with no `NetworkObject` component will currently synchronize the child `NetworkObject` as if it is in world space on the client side. To work around this particular issue you should add a `NetworkTransform` to the child and enable local space synchronization.
-:::
\ No newline at end of file
+### Auto Object Parent Sync Option & Parenting
+ Already parented in-scene placed `NetworkObject`s Auto Object Parent Sync Usage:
+
+- When disabled, the NetworkObject ignores its parent and considers all of its transform values as being world space synchronized (i.e. no matter where you move or rotate its parent, it will maintain its current position and rotation)
+ - Typically, when disabling this you need to handle synchronizing the client either through your own custom messages or RPCS or add a NetworkTransform component to it. This is only useful if you want to have some global parent that might shift or have transform values that you don't want to impact the `NetworkObject` in question.
+- When enabled, the NetworkObject is aware of its parent and will treat all of its transform values as being local space synchronized.
+ - _This also applies to being pre-parented under a `GameObject` with no `NetworkObject` component._
+
+:::note
+_**The caveat to the above is scale**:_
+Scale is treated always as local space relative for pre-parented in-scene placed `NetworkObjects`.
+
+*For dynamically spawned NetworkObjects:*
+It depends upon what WorldPositionStays value you use when parenting the NetworkObject in question.
+WorldPositionStays = true: Everything is world space relative. _(default)_
+WorldPositionStays = false: Everything is local space relative. _(children offset relative to the parent)_
+:::
+
+
+### Parenting & Transform Synchronization
+It is important to understand that without the use of a `NetworkTransform` clients are only synchronized with the transform values when:
+- A client is being synchronized with the NetworkObject in question:
+ - During the client's first synchronization after a client has their connection approved.
+ - When a server spawns a new NetworkObject.
+- A NetworkObject has been parented (or a parent removed).
+ - The server can override the `NetworkBehaviour.OnNetworkObjectParentChanged` method and adjust the transform values when that is invoked.
+ - These transform changes will be synchronized with clients via the `ParentSyncMessage`
\ No newline at end of file
diff --git a/docusaurus.config.js b/docusaurus.config.js
index a85f0fecb..d111489a6 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -340,9 +340,13 @@ module.exports = {
lastVersion: "current",
versions: {
current: {
- label: '1.0.0',
+ label: '1.1.0',
path: 'current',
},
+ '1.0.0': {
+ label: '1.0.0',
+ path: '1.0.0',
+ },
'0.1.0': {
label: '0.1.0',
path: '0.1.0',
diff --git a/versioned_docs/version-1.0.0/about.md b/versioned_docs/version-1.0.0/about.md
new file mode 100644
index 000000000..50c967fd0
--- /dev/null
+++ b/versioned_docs/version-1.0.0/about.md
@@ -0,0 +1,55 @@
+---
+id: about
+title: About Netcode for GameObjects
+description: Learn more about the available APIs for Unity Multiplayer Networking, including Netcode for GameObjects and Transport.
+---
+
+Netcode for GameObjects (Netcode) is a high-level networking library built for Unity for you to abstract networking logic. It enables you to send GameObjects and world data across a networking session to multiplayer players at once. With Netcode, you can focus on building your game instead of low-level protocols and networking frameworks.
+
+To learn more about Netcode for GameObjects functionality and capabilities, explore the content below:
+
+
+
+| Getting Started | Hello World and Golden Paths | Education and Samples |
+| -- | -- | -- |
+| [Install Unity Netcode](installation/installation.md) [Migration from UNet to Netcode](installation/migratingfromUNet.md) [Upgrade to Unity Netcode Package](installation/migratingfrommlapi.md) | [Your First Networked Game](tutorials/helloworld.md) [Module One](tutorials/goldenpath_series/gp_module_one.md) [Module Two](tutorials/goldenpath_series/gp_module_two.md) | [Boss Room](learn/bossroom/getting-started-boss-room.md) [Bite Size Samples](learn/bitesize/bitesize-introduction.md) [Dilmer's Tutorials](learn/dilmer/dilmer-video.md) |
+
+
+
+Don't forget to check out our [Release Notes](https://docs-multiplayer.unity3d.com/releases/introduction) and [APIs](api/introduction.md)!
+
+## Before you begin
+
+Netcode supports the following versions:
+* Unity 2020.3, 2021.1, 2021.2, and 2021.3
+* Mono and IL2CPP [Scripting Backends](https://docs.unity3d.com/Manual/scripting-backends.html)
+
+Netcode supports the following platforms:
+* Windows, MacOS, and Linux
+* iOS and Android
+* XR platforms running on Windows, Android, and iOS operating systems
+* Most [**closed platforms**](https://unity.com/platform-installation), such as consoles. Contact us for more information about specific closed platforms.
+ * When working with consoles (such as PlayStation, Xbox, or Nintendo Switch), there may be Netcode-specific policies you should be aware of while testing and before launching your game live. Refer to the console's internal documentation for more information. This content is typically protected by NDA.
+
+:::caution Using WebGL
+Netcode does not support the WebGL platform because it does not allow access to IP Sockets.
+
+There are third party transports provided by the community that may enable you to use Netcode on WebGL platforms. A list of these transports are found [here](https://github.com/Unity-Technologies/multiplayer-community-contributions#transports).
+
+Use with caution:
+* You may encounter bugs and issues while using Netcode on WebGL, and we will not prioritize fixing those issues.
+* The server or host cannot be a WebGL client, but a Desktop or Mobile build.
+* You may experience **increased** latency and jitter because of the TCP protocol used by WebSockets.
+:::
+
+:::unity Content Licenses
+This is free under the permissive MIT [Licenses](/reference/license) by Unity and the Netcode collaborators. Netcode is open source with no attached costs or limitations, so you can develop features alongside Unity.
+:::
diff --git a/versioned_docs/version-1.0.0/advanced-topics/bufferserializer.md b/versioned_docs/version-1.0.0/advanced-topics/bufferserializer.md
new file mode 100644
index 000000000..31576e929
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/bufferserializer.md
@@ -0,0 +1,21 @@
+---
+id: bufferserializer
+title: BufferSerializer
+sidebar_label: BufferSerializer
+---
+
+`BufferSerializer` is the bi-directional serializer primarily used for serializing within [`INetworkSerializable`](inetworkserializable.md) types. It wraps [`FastBufferWriter` and `FastBufferReader`](fastbufferwriter-fastbufferreader.md) to provide high performance serialization, but has a couple of differences to make it more user-friendly:
+
+- Rather than writing separate methods for serializing and deserializing, `BufferSerializer` allows writing a single method that can handle both operations, which reduces the possibility of a mismatch between the two
+- `BufferSerializer` does bound checking on every read and write by default, making it easier to avoid mistakes around manual bounds checking required by `FastBufferWriter` and `FastBufferReader`
+
+These aren't without downsides, however:
+
+- `BufferSerializer` has to operate on an existing mutable value due to its bi-directional nature, which means values like `List.Count` have to be stored to a local variable before writing.
+- `BufferSerializer` is slightly slower than `FastBufferReader` and `FastBufferWriter` due to both the extra pass-through method calls and the mandatory bounds checking on each write.
+- `BufferSerializer` do not support any form of packed reads and writes.
+
+However, when those downsides are unreasonable, `BufferSerializer` offers two ways to perform more optimal serialization for either performance or bandwidth usage:
+
+- For performance, you can use `PreCheck(int amount)` followed by `SerializeValuePreChecked()` to perform bounds checking for multiple fields at once.
+- For both performance and bandwidth usage, you can obtain the wrapped underlying reader/writer via `serializer.GetFastBufferReader()` when `serializer.IsReader` is `true`, and `serializer.GetFastBufferWriter()` when `serializer.IsWriter` is `true`. These provide micro-performance improvements by removing a level of indirection, and also give you a type you can use with `BytePacker` and `ByteUnpacker`.
diff --git a/versioned_docs/version-1.0.0/advanced-topics/custom-serialization.md b/versioned_docs/version-1.0.0/advanced-topics/custom-serialization.md
new file mode 100644
index 000000000..e249c3131
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/custom-serialization.md
@@ -0,0 +1,57 @@
+---
+id: custom-serialization
+title: Custom Serialization
+---
+
+When using `RPC`'s, `NetworkVariable`'s or any other Netcode for GameObjects (Netcode) related task that requires serialization. The Netcode uses a default serialization pipeline that looks like this:
+
+``
+Custom Types => Built In Types => INetworkSerializable
+``
+
+That is, when Netcode first gets hold of a type, it will check for any custom types that the user have registered for serialization, after that it will check if it's a built in type, such as a Vector3, float etc. These are handled by default. If not, it will check if the type inherits `INetworkSerializable`, if it does, it will call it's write methods.
+
+By default, any type that satisfies the `unmanaged` generic constraint can be automatically serialized as RPC parameters. This includes all basic types (bool, byte, int, float, enum, etc) as well as any structs that contains only these basic types.
+
+With this flow, you can override **ALL** serialization for **ALL** types, even built in types, and with the API provided, it can even be done with types that you have not defined yourself, those who are behind a 3rd party wall, such as .NET types.
+
+To register a custom type, or override an already handled type, you need to create extension methods for `FastBufferReader.ReadValueSafe()` and `FastBufferWriter.WriteValueSafe()`:
+
+```csharp
+// Tells the Netcode how to serialize and deserialize Url in the future.
+// The class name doesn't matter here.
+public static class SerializationExtensions
+{
+ public static void ReadValueSafe(this FastBufferReader reader, out Url value)
+ {
+ reader.ReadValueSafe(out string val);
+ value = new Url(val);
+ }
+
+ public static void WriteValueSafe(this FastBufferWriter writer, in Url value)
+ {
+ writer.WriteValueSafe(instance.Value);
+ }
+}
+```
+
+The code generation for RPCs will automatically pick up and use these functions, and they'll become available via `FastBufferWriter` and `FastBufferReader` directly.
+
+You can also optionally use the same method to add support for `BufferSerializer.SerializeValue()`, if you wish, which will make this type readily available within [`INetworkSerializable`](/advanced-topics/serialization/inetworkserializable.md) types:
+
+```c#
+// The class name doesn't matter here.
+public static class SerializationExtensions
+{
+ public static void SerializeValue(this BufferSerializer serializer, ref Url value) where TReaderWriter: IReaderWriter
+ {
+ if (serializer.IsReader)
+ {
+ value = new Url();
+ }
+ serializer.SerializeValue(ref value.Value);
+ }
+}
+```
+
+Additionally, you can also add extensions for `FastBufferReader.ReadValue()`, `FastBufferWriter.WriteValue()`, and `BufferSerializer.SerializeValuePreChecked()` to provide more optimal implementations for manual serialization using `FastBufferReader.TryBeginRead()`, `FastBufferWriter.TryBeginWrite()`, and `BufferSerializer.PreCheck()`, respectively. However, none of these will be used for serializing RPCs - only `ReadValueSafe` and `WriteValueSafe` are used.
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/fastbufferwriter-fastbufferreader.md b/versioned_docs/version-1.0.0/advanced-topics/fastbufferwriter-fastbufferreader.md
new file mode 100644
index 000000000..63f8a7371
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/fastbufferwriter-fastbufferreader.md
@@ -0,0 +1,163 @@
+---
+id: fastbufferwriter-fastbufferreader
+title: FastBufferWriter and FastBufferReader
+sidebar_label: FastBufferWriter and FastBufferReader
+---
+The serialization and deserialization is done via `FastBufferWriter` and `FastBufferReader`. These have methods for serializing individual types and methods for serializing packed numbers, but in particular provide a high-performance method called `WriteValue()/ReadValue()` (for Writers and Readers, respectively) that can extremely quickly write an entire unmanaged struct to a buffer.
+
+There's a trade-off of CPU usage vs bandwidth in using this: Writing individual fields is slower (especially when it includes operations on unaligned memory), but allows the buffer to be filled more efficiently, both because it avoids padding for alignment in structs, and because it allows you to use `BytePacker.WriteValuePacked()`/`ByteUnpacker.ReadValuePacked()` and `BytePacker.WriteValueBitPacked()`/`ByteUnpacker.ReadValueBitPacked()`. The difference between these two is that the BitPacked variants pack more efficiently, but they reduce the valid range of values. See the section below for details on packing.
+
+
+**Example**
+
+```csharp
+struct ExampleStruct
+{
+ private float f;
+ private bool b;
+ private int i;
+
+ void Serialize(FastBufferWriter writer);
+}
+```
+
+In this example struct, `Serialize` can be implemented in two ways:
+
+```csharp
+void Serialize(FastBufferWriter writer)
+{
+ if(!writer.TryBeginWrite(sizeof(float) + sizeof(bool) + sizeof(i)))
+ {
+ throw new OverflowException("Not enough space in the buffer");
+ }
+ writer.WriteValue(f);
+ writer.WriteValue(b);
+ writer.WriteValue(i);
+}
+```
+
+```csharp
+void Serialize(FastBufferWriter writer)
+{
+ if(!writer.TryBeginWrite(sizeof(ExampleStruct)))
+ {
+ throw new OverflowException("Not enough space in the buffer");
+ }
+ writer.WriteValue(this);
+}
+```
+This creates efficiently packed data in the message, and can be further optimized by using `BytePacker.WriteValuePacked()` and `BytePacker.WriteValueBitPacked()`, but it has two downsides:
+- First, it involves more method calls and more instructions, making it slower.
+- Second, that it creates a greater opportunity for the serialize and deserialize code to become misaligned, since they must contain the same operations in the same order.
+
+You can also use a hybrid approach if you have a few values that will need to be packed and several that won't:
+
+```C#
+struct ExampleStruct
+{
+ struct Embedded
+ {
+ private byte a;
+ private byte b;
+ private byte c;
+ private byte d;
+ }
+ public Embedded embedded;
+ public float f;
+ public short i;
+
+ void Serialize(FastBufferWriter writer)
+ {
+ writer.WriteValue(embedded);
+ BytePacker.WriteValuePacked(writer, f);
+ BytePacker.WriteValuePacked(writer, i);
+ }
+}
+```
+
+This allows the four bytes of the embedded struct to be rapidly serialized as a single action, then adds the compacted data at the end, resulting in better bandwidth usage than serializing the whole struct as-is, but better performance than serializing it one byte at a time.
+
+
+## FastBufferWriter and FastBufferReader
+
+`FastBufferWriter` and `FastBufferReader` are replacements for the old `NetworkWriter` and `NetworkReader`. For those familiar with the old classes, there are some key differences:
+
+- `FastBufferWriter` uses `WriteValue()` as the name of the method for all types *except* [`INetworkSerializable`](serialization/inetworkserializable) types, which are serialized through `WriteNetworkSerializable()`
+- `FastBufferReader` similarly uses `ReadValue()` for all types except INetworkSerializable (which is read through `ReadNetworkSerializable`), with the output changed from a return value to an `out` parameter to allow for method overload resolution to pick the correct value.
+- `FastBufferWriter` and `FastBufferReader` outsource packed writes and reads to `BytePacker` and `ByteUnpacker`, respectively.
+- `FastBufferWriter` and `FastBufferReader` are **structs**, not **classes**. This means they can be constructed and destructed without GC allocations.
+- `FastBufferWriter` and `FastBufferReader` both use the same allocation scheme as Native Containers, allowing the internal buffers to be created and resized without creating any garbage and with the use of `Allocator.Temp` or `Allocator.TempJob`.
+- `FastBufferReader` can be instantiated using `Allocator.None` to operate on an existing buffer with no allocations and no copies.
+- Neither `FastBufferReader` nor `FastBufferWriter` inherits from nor contains a `Stream`.
+- `FastBufferReader` and `FastBufferWriter` are heavily optimized for speed, using aggressive inlining and unsafe code to achieve the fastest possible buffer storage and retrieval.
+- `FastBufferReader` and `FastBufferWriter` use unsafe typecasts and `UnsafeUtility.MemCpy` operations on `byte*` values, achieving native memory copy performance with no need to iterate or do bitwise shifts and masks.
+- `FastBufferReader` and `FastBufferWriter` are intended to make data easier to debug - one such thing to support will be a `#define MLAPI_FAST_BUFFER_UNPACK_ALL` that will disable all packing operations to make the buffers for messages that use them easier to read.
+- `FastBufferReader` and `FastBufferWriter` do not support runtime type discovery - there is no `WriteObject` or `ReadObject` implementation. All types must be known at compile time. This is to avoid garbage and boxing allocations.
+
+A core benefit of `NativeArray` is that it offers access to the allocation scheme of `Allocator.TempJob`. This uses a special type of allocation that is nearly as fast as stack allocation and involves no GC overhead, while being able to persist for a few frames. In general they are rarely if ever needed for more than a frame, but this does provide a very efficient option for creating buffers as needed, which avoids the need to use a pool for them. The only downside is that buffers created this way must be manually disposed after use, as they're not garbage collected.
+
+## Creating and Disposing FastBufferWriters and FastBufferReaders
+
+To create your own `FastBufferWriter`s and `FastBufferReader`s, it's important to note that struct default/parameterless constructors cannot be removed or overridden, but `FastBufferWriter` and `FastBufferReader` require constructor behavior to be functional.
+
+`FastBufferWriter` always owns its internal buffer and must be constructed with an initial size, an allocator, and a maximum size. If the maximum size is not provided or is less than or equal to the initial size, the `FastBufferWriter` cannot expand.
+
+`FastBufferReader` can be constructed to either own its buffer or reference an existing one via `Allocator.None`. Not all types are compatible with `Allocator.None` - only `byte*`, `NativeArray`, and `FastBufferWriter` input types can provide `Allocator.None`. You can obtain a `byte*` from a `byte[]` using the following method:
+
+```c#
+byte[] byteArray;
+fixed(byte* bytePtr = byteArray)
+{
+ // use bytePtr here
+}
+```
+
+It's important to note with `Allocator.None` that the `FastBufferReader` will be directly referencing a position in memory, which means the `FastBufferReader` must not live longer than the input buffer it references - and if the input buffer is a `byte[]`, the `FastBufferReader` must not live longer than the `fixed()` statement, because outside of that statement, the garbage collector is free to move that memory, which will cause random and unpredictable errors.
+
+Regardless which allocator you use (including `Allocator.None`), `FastBufferWriter` and `FastBufferReader` must always have `Dispose()` called on them when you're done with them. The best practice is to use them within `using` blocks.
+
+## Bounds Checking
+
+For performance reasons, by default, `FastBufferReader` and `FastBufferWriter` **do not do bounds checking** on each write. Rather, they require the use of specific bounds checking functions - `TryBeginRead(int amount)` and `TryBeginWrite(int amount)`, respectively. This improves performance by allowing you to verify the space exists for the multiple values in a single call, rather than doing that check on every single operation.
+
+:::info
+**In editor mode and development builds**, calling these functions records a watermark point, and any attempt to read or write past the watermark point will throw an exception. This ensures these functions are used properly, while avoiding the performance cost of per-operation checking in production builds. In production builds, attempting to read or write past the end of the buffer will cause undefined behavior, likely program instability and/or crashes.
+:::
+
+For convenience, every `WriteValue()` and `ReadValue()` method has an equivalent `WriteValueSafe()` and `ReadValueSafe()` that does bounds checking for you, throwing `OverflowException` if the boundary is exceeded. Additionally, some methods, such as arrays (where the amount of data being read can't be known until the size value is read) and [`INetworkSerializable`](inetworkserializable.md) values (where the size can't be predicted outside the implementation) will always do bounds checking internally.
+
+## Bitwise Reading and Writing
+
+Writing values in sizes measured in bits rather than bytes comes with a cost
+- First, it comes with a cost of having to track bitwise lengths and convert them to bytewise lenghts.
+- Second, it comes with a cost of having to remember to add padding after your bitwise writes and reads to ensure the next bytewise write or read functions correctly, and to make sure the buffer length includes any trailing bits.
+
+To address that, `FastBufferReader` and `FastBufferWriter` do not, themselves, have bitwise operations. When needed, however, you can create a `BitWriter` or `BitReader` instance, which is used ensure that no unaligned bits are left at the end - from the perspective of `FastBufferReader` and `FastBufferWriter`, only bytes are allowed. `BitWriter` and `BitReader` operate directly on the underlying buffer, so calling non-bitwise operations within a bitwise context is an error (and will raise an exception in non-production builds).
+
+```csharp
+FastBufferWriter writer = new FastBufferWriter(256, Allocator.TempJob);
+using(var bitWriter = writer.EnterBitwiseContext())
+{
+ bitWriter.WriteBit(a);
+ bitWriter.WriteBits(b, 5);
+} // Dispose automatically adds 2 more 0 bits to pad to the next byte.
+```
+
+## Packing
+
+Packing values is done using the utility classes `BytePacker` and `ByteUnpacker`. These generally offer two different ways of packing values:
+
+- `BytePacker.WriteValuePacked()`/`ByteUnpacker.ReadValuePacked()` are the most versatile. They can write any range of values that fit into the type, and also have special built-in methods for many common Unity types that can automatically pack the values contained within.
+
+- `BytePacker.WriteValueBitPacked()`/`ByteUnpacker.ReadValueBitPacked()` offer tighter/more optimal packing (the data in the buffer will never exceed `sizeof(type)`, which can happen with very large values using `WriteValuePacked()`, and will usually be one byte smaller than with `WriteValuePacked()` except for values <= 240, which will be one byte with both methods), but come with the limitations that they can only be used on integral types, and they use some bits of the type to encode length information, meaning that they reduce the usable size of the type. The sizes allowed by these functions are as follows:
+
+ | Type | Usable Size |
+ | ------ | ------------------------------------------------------------ |
+ | short | 14 bits + sign bit (-16,384 to 16,383) |
+ | ushort | 15 bits (0 to 32,767) |
+ | int | 29 bits + sign bit (-536,870,912 to 536,870,911) |
+ | uint | 30 bits (0 to 1,073,741,824) |
+ | long | 60 bits + sign bit (-1,152,921,504,606,846,976 to 1,152,921,504,606,846,975) |
+ | ulong | 61 bits (0 to 2,305,843,009,213,693,952) |
+
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/inscene_parenting_player.md b/versioned_docs/version-1.0.0/advanced-topics/inscene_parenting_player.md
new file mode 100644
index 000000000..290e3fcab
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/inscene_parenting_player.md
@@ -0,0 +1,87 @@
+---
+id: inscene-parenting-players
+title: Real world In-scene NetworkObject parenting of players solution
+description: In-scene NetworkObject parenting of players Solution
+---
+
+
+We received the following issue in Github.
+
+## Issue:
+
+When a player prefab contains a script that dynamically adds a parent to its transform, the client cannot join a game hosted by another client. [You can see orignal issue here](https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues/1211)
+
+Steps to reproduce the behavior:
+
+1. Set up basic networking game with at least one `GameObject` in a scene that is not the player.
+1. Add a script to the player prefab that adds parenting to its transform via `gameObject.transform.SetParent()` in the `Start()` method.
+1. Launch one instance of the game as Host.
+1. Launch another instance and try to join as Client.
+
+## Solution:
+
+
+If you want to do this when a player has first connected and all `NetworkObjects` (in-scene placed and already dynamically spawned by the server-host) have been fully synchronized with the client then we would recommend using the `NetworkManager.SceneManager.OnSceneEvent` to trap for the `C2S_SyncComplete` event.
+
+Here is an example script that we recommend using to achieve this:
+
+```csharp
+using Unity.Netcode;
+
+public class ParentPlayerToInSceneNetworkObject : NetworkBehaviour
+{
+ public override void OnNetworkSpawn()
+ {
+ if (IsServer)
+ {
+ // Server subscribes to the NetworkSceneManager.OnSceneEvent event
+ NetworkManager.SceneManager.OnSceneEvent += SceneManager_OnSceneEvent;
+
+ // Server player is parented under this NetworkObject
+ SetPlayerParent(NetworkManager.LocalClientId);
+ }
+ }
+
+ private void SetPlayerParent(ulong clientId)
+ {
+ if (IsSpawned && IsServer)
+ {
+ // As long as the client (player) is in the connected clients list
+ if (NetworkManager.ConnectedClients.ContainsKey(clientId))
+ {
+ // Set the player as a child of this in-scene placed NetworkObject
+ NetworkManager.ConnectedClients[clientId].PlayerObject.transform.parent = transform;
+ }
+ }
+ }
+
+ private void SceneManager_OnSceneEvent(SceneEvent sceneEvent)
+ {
+ // OnSceneEvent is very useful for many things
+ switch (sceneEvent.SceneEventType)
+ {
+ // The C2S_SyncComplete event tells the server that a client-player has:
+ // 1.) Connected and Spawned
+ // 2.) Loaded all scenes that were loaded on the server at the time of connecting
+ // 3.) Synchronized (instantiated and spawned) all NetworkObjects in the network session
+ case SceneEventData.SceneEventTypes.C2S_SyncComplete:
+ {
+ // As long as we are not the server-player
+ if (sceneEvent.ClientId != NetworkManager.LocalClientId)
+ {
+ // Set the newly joined and synchronized client-player as a child of this in-scene placed NetworkObject
+ SetPlayerParent(sceneEvent.ClientId);
+ }
+ break;
+ }
+ }
+ }
+}
+```
+
+You should place this script on your in-scene placed `NetworkObject` (i.e. the first `GameObject`) and do the parenting from it in order to avoid any timing issues of when it is spawned or the like. It only runs the script on the server-host side since parenting is server authoritative.
+
+
+:::note
+Remove any parenting code you might have had from your player prefab before using the above script.
+:::
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/clientrpc.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/clientrpc.md
new file mode 100644
index 000000000..1a875eec9
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/clientrpc.md
@@ -0,0 +1,123 @@
+---
+id: clientrpc
+title: ClientRpc
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+
+A `ClientRpc` can be invoked by the server to be executed on a client.
+
+
+
+
+
+
+
+## Declaring a ClientRpc
+Developers can declare a `ClientRpc` by marking a method with `[ClientRpc]` attribute and making sure to have `ClientRpc` suffix in the method name.
+
+```csharp
+[ClientRpc]
+void PongClientRpc(int somenumber, string sometext) { /* ... */ }
+```
+
+## Invoking a ClientRpc
+
+Developers can invoke a `ClientRpc` by making a direct function call with parameters:
+
+```csharp
+void Update()
+{
+ if (Input.GetKeyDown(KeyCode.P))
+ {
+ PongClientRpc(Time.frameCount, "hello, world"); // Server -> Client
+ }
+}
+```
+
+Marking method with ``[ClientRpc]`` attribute and putting `ClientRpc` suffix to the method name are required, otherwise it will prompt error messages:
+
+```csharp
+// Error: Invalid, missing 'ClientRpc' suffix in the method name
+[ClientRpc]
+void Pong(int somenumber, string sometext) { /* ... */ }
+
+// Error: Invalid, missing [ClientRpc] attribute on the method
+void PongClientRpc(int somenumber, string sometext) { /* ... */ }
+```
+
+`[ClientRpc]` attribute and matching `...ClientRpc` suffix in the method name are there to make it crystal clear for RPC call sites to know when they are executing an RPC, it will be replicated and executed on the client-side, without necessarily jumping into original RPC method declaration to find out if it was an RPC, if so whether it is a [ServerRpc](serverrpc.md) or `ClientRpc`:
+
+```csharp
+Pong(somenumber, sometext); // Is this an RPC call?
+
+PongRpc(somenumber, sometext); // Is this a ServerRpc call or ClientRpc call?
+
+PongClientRpc(somenumber, sometext); // This is clearly a ClientRpc call
+```
+
+## To Send to One Client, use ClientRpcSendParameters
+
+The following code provides an example of using `ClientRpcSendParameters`, which will allow you to send a `ClientRpc` to a specific Client connection(s) whereas the default Netcode for GameObjects's behavior is to broadcast to every single client.
+
+```csharp
+private void DoSomethingServerSide(int clientId)
+ {
+ // If is not the Server/Host then we should early return here!
+ if (!IsServer) return;
+
+
+ // NOTE! In case you know a list of ClientId's ahead of time, that does not need change,
+ // Then please consider caching this (as a member variable), to avoid Allocating Memory every time you run this function
+ ClientRpcParams clientRpcParams = new ClientRpcParams
+ {
+ Send = new ClientRpcSendParams
+ {
+ TargetClientIds = new ulong[]{clientId}
+ }
+ };
+
+ // Let's imagine that you need to compute a Random integer and want to send that to a client
+ const int maxValue = 4;
+ int randomInteger = Random.Range(0, maxValue);
+ DoSomethingClientRPC(randomInteger, clientRpcParams);
+ }
+
+ [ClientRpc]
+ private void DoSomethingClientRPC(int randomInteger, ClientRpcParams clientRpcParams = default)
+ {
+ if (IsOwner) return;
+
+ // Run your client-side logic here!!
+ Debug.LogFormat("GameObject: {0} has received a randomInteger with value: {1}", gameObject.name, randomInteger);
+ }
+```
+
+
+
+ Server can invoke a client RPC on a Network Object. The RPC will be placed in the local queue and then sent to a selection of clients (by default this selection is "all clients"). When received by a client, RPC will be executed on the client's version of the same Network Object.
+
+
+## Invoking a Client RPC from the Host.
+As the host is both a client and a server, if a host invokes a Client RPC, that RPC will be executed on the host too in addition to other clients.
+
+
+
+
+
+ Client Hosts can invoke Client RPCs on Network Objects. The RPC will be placed in the local queue and then, after a short delay the client RPC will be executed on the Client Host, and sent to the other clients. When client RPC is received by the client - it is executed on the Client's version of the same Network Object.
+
+
+See [examples](../../learn/bossroom/bossroom-actions) of how these were used in Boss Room.
+
+
+## See also
+
+* [ServerRpc](serverrpc.md)
+* [RPC Params](rpc-params.md)
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/custom-messages.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/custom-messages.md
new file mode 100644
index 000000000..66b2504c7
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/custom-messages.md
@@ -0,0 +1,301 @@
+---
+id: custom-messages
+title: Custom Messages
+description: A brief explanation of Custom Messages use in Netcode for GameObjects (Netcode) covering Named and Unnamed messages.
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+If you do not want to use the Netcode for GameObjects (Netcode) messaging system, you do not have to. You can use a thin layer called "Custom Messages" to implement your own messaging behavior and/or add custom targeting. They are unbound to any game object. Custom messages can be used in combination with [RPC messages](../messaging-system.md).
+
+There are two types of custom messages:
+- Unnamed
+- Named
+
+## Unnamed Messages
+Unnamed messages can be thought of as a single sending channel. A message sent has one receive handler, this is useful for building your own custom messaging system. Netcode for GameObjects handles delivering and receiving custom unnamed messages, you can provide your own "custom message headers" to determine the type of unnamed message being sent or received.
+
+### Unnamed Message Example
+Below is a very basic example of how you might implement your own messaging system using unnamed messages:
+```csharp
+using UnityEngine;
+using Unity.Collections;
+using Unity.Netcode;
+
+///
+/// Using an unnamed message to send a string message
+/// defined
+/// further down below.
+///
+public class UnnamedStringMessageHandler : CustomUnnamedMessageHandler
+{
+ ///
+ /// We override this method to define the unique message type
+ /// identifier for this child derived class
+ ///
+ protected override byte MessageType()
+ {
+ // As an example, we could define message type of 1 for string messages
+ return 1;
+ }
+
+ public override void OnNetworkSpawn()
+ {
+ // For this example, we always want to invoke the base
+ base.OnNetworkSpawn();
+
+ if (IsServer)
+ {
+ // Server broadcasts to all clients when a new client connects
+ // (just for example purposes)
+ NetworkManager.OnClientConnectedCallback += OnClientConnectedCallback;
+ }
+ else
+ {
+ // Clients send a greeting string message to the server
+ SendUnnamedMessage("I am a client connecting!");
+ }
+ }
+
+ public override void OnNetworkDespawn()
+ {
+ // For this example, we always want to invoke the base
+ base.OnNetworkDespawn();
+
+ // Whether server or not, unregister this.
+ NetworkManager.OnClientDisconnectCallback -= OnClientConnectedCallback;
+ }
+
+ private void OnClientConnectedCallback(ulong clientId)
+ {
+ // Server broadcasts a welcome string message to all clients that
+ // a new client has joined.
+ SendUnnamedMessage($"Everyone welcome the newly joined client ({clientId})!");
+ }
+
+ ///
+ /// For this example, we override this message to handle receiving the string
+ /// message.
+ ///
+ protected override void OnReceivedUnnamedMessage(ulong clientId, FastBufferReader reader)
+ {
+ var stringMessage = string.Empty;
+ reader.ReadValueSafe(out stringMessage);
+ if (IsServer)
+ {
+ Debug.Log($"Server received unnamed message of type ({MessageType()}) from client " +
+ $"({clientId}) that contained the string: \"{stringMessage}\"");
+
+ // As an example, we could also broadcast the client message to everyone
+ SendUnnamedMessage($"Newly connected client sent this greeting: \"{stringMessage}\"");
+ }
+ else
+ {
+ Debug.Log(stringMessage);
+ }
+ }
+
+ ///
+ /// For this example, we will send a string as the payload.
+ ///
+ /// IMPORTANT NOTE: You can construct your own header to be
+ /// written for custom message types, this example just uses
+ /// the message type value as the "header". This provides us
+ /// with the ability to have "different types" of unnamed
+ /// messages.
+ ///
+ public override void SendUnnamedMessage(string dataToSend)
+ {
+ var writer = new FastBufferWriter(1100, Allocator.Temp);
+ var customMessagingManager = NetworkManager.CustomMessagingManager;
+ // Tip: Placing the writer within a using scope assures it will
+ // be disposed upon leaving the using scope
+ using (writer)
+ {
+ // Write our message type
+ writer.WriteValueSafe(MessageType());
+
+ // Write our string message
+ writer.WriteValueSafe(dataToSend);
+ if (IsServer)
+ {
+ // This is a server-only method that will broadcast the unnamed message.
+ // Caution: Invoking this method on a client will throw an exception!
+ customMessagingManager.SendUnnamedMessageToAll(writer);
+ }
+ else
+ {
+ // This method can be used by a client or server (client to server or server to client)
+ customMessagingManager.SendUnnamedMessage(NetworkManager.ServerClientId, writer);
+ }
+ }
+ }
+}
+
+///
+/// A templated class to handle sending different data types
+/// per unique unnamed message type/child derived class.
+///
+public class CustomUnnamedMessageHandler : NetworkBehaviour
+{
+ ///
+ /// Since there is no unique way to identify unnamed messages,
+ /// adding a message type identifier to the message itself is
+ /// one way to handle know:
+ /// "what kind of unnamed message was received?"
+ ///
+ protected virtual byte MessageType()
+ {
+ // The default unnamed message type
+ return 0;
+ }
+
+ ///
+ /// For most cases, you want to register once your NetworkBehaviour's
+ /// NetworkObject (typically in-scene placed) is spawned.
+ ///
+ public override void OnNetworkSpawn()
+ {
+ // Both the server-host and client(s) will always subscribe to the
+ // the unnamed message received event
+ NetworkManager.CustomMessagingManager.OnUnnamedMessage += ReceiveMessage;
+ }
+
+ public override void OnNetworkDespawn()
+ {
+ // Unsubscribe when the associated NetworkObject is despawned.
+ NetworkManager.CustomMessagingManager.OnUnnamedMessage -= ReceiveMessage;
+ }
+
+ ///
+ /// This method needs to be overridden to handle reading a unique message type
+ /// (i.e. derived class)
+ ///
+ protected virtual void OnReceivedUnnamedMessage(ulong clientId, FastBufferReader reader)
+ {
+ }
+
+ ///
+ /// For this unnamed message example, we always read the message type
+ /// value to determine if it should be handled by this instance in the
+ /// event it is a child of the CustomUnnamedMessageHandler class.
+ ///
+ private void ReceiveMessage(ulong clientId, FastBufferReader reader)
+ {
+ var messageType = (byte)0;
+ // Read the message type value that is written first when we send
+ // this unnamed message.
+ reader.ReadValueSafe(out messageType);
+ // Example purposes only, you might handle this in a more optimal way
+ if (messageType == MessageType())
+ {
+ OnReceivedUnnamedMessage(clientId, reader);
+ }
+ }
+
+ ///
+ /// For simplicity, the default does nothing
+ ///
+ ///
+ public virtual void SendUnnamedMessage(T dataToSend)
+ {
+
+ }
+}
+```
+## Named Messages
+If you don't want to handle the complexity of creating your own messaging system, Netcode for GameObjects also provides you with the option to use custom "named messages". Custom named messages use the "message name" as the unique identifier (it creates a hash value from the name and links that to a received named message callback).
+:::tip
+If you are not quite sure if you need to incorporate the complexity of message identification and handling like you do with custom unnamed messages, you can always start with custom named messages and then if, at a later date, you determine you need "sub-message types" for a specific custom named message then you can always incorporate a type identifier (like you would with unnamed messages) into the named message payload itself.
+:::
+
+### Name Message Example
+Below is a very basic example of implementing a custom named message:
+```csharp
+using System;
+using UnityEngine;
+using Unity.Collections;
+using Unity.Netcode;
+public class CustomNamedMessageHandler : NetworkBehaviour
+{
+ [Tooltip("The name identifier used for this custom message handler.")]
+ public string MessageName = "MyCustomNamedMessage";
+
+ ///
+ /// For most cases, you want to register once your NetworkBehaviour's
+ /// NetworkObject (typically in-scene placed) is spawned.
+ ///
+ public override void OnNetworkSpawn()
+ {
+ // Both the server-host and client(s) register the custom named message.
+ NetworkManager.CustomMessagingManager.RegisterNamedMessageHandler(MessageName, ReceiveMessage);
+
+ if (IsServer)
+ {
+ // Server broadcasts to all clients when a new client connects (just for example purposes)
+ NetworkManager.OnClientConnectedCallback += OnClientConnectedCallback;
+ }
+ else
+ {
+ // Clients send a unique Guid to the server
+ SendMessage(Guid.NewGuid());
+ }
+ }
+
+ private void OnClientConnectedCallback(ulong obj)
+ {
+ SendMessage(Guid.NewGuid());
+ }
+
+ public override void OnNetworkDespawn()
+ {
+ // De-register when the associated NetworkObject is despawned.
+ NetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler(MessageName);
+ // Whether server or not, unregister this.
+ NetworkManager.OnClientDisconnectCallback -= OnClientConnectedCallback;
+ }
+
+ ///
+ /// Invoked when a custom message of type
+ ///
+ private void ReceiveMessage(ulong senderId, FastBufferReader messagePayload)
+ {
+ var receivedMessageContent = new ForceNetworkSerializeByMemcpy(new Guid());
+ messagePayload.ReadValueSafe(out receivedMessageContent);
+ if (IsServer)
+ {
+ Debug.Log($"Sever received GUID ({receivedMessageContent.Value}) from client ({senderId})");
+ }
+ else
+ {
+ Debug.Log($"Client received GUID ({receivedMessageContent.Value}) from the server.");
+ }
+ }
+
+ ///
+ /// Invoke this with a Guid by a client or server-host to send a
+ /// custom named message.
+ ///
+ public void SendMessage(Guid inGameIdentifier)
+ {
+ var messageContent = new ForceNetworkSerializeByMemcpy(inGameIdentifier);
+ var writer = new FastBufferWriter(1100, Allocator.Temp);
+ var customMessagingManager = NetworkManager.CustomMessagingManager;
+ using (writer)
+ {
+ writer.WriteValueSafe(messageContent);
+ if (IsServer)
+ {
+ // This is a server-only method that will broadcast the named message.
+ // Caution: Invoking this method on a client will throw an exception!
+ customMessagingManager.SendNamedMessageToAll(MessageName, writer);
+ }
+ else
+ {
+ // This is a client or server method that sends a named message to one target destination
+ // (client to server or server to client)
+ customMessagingManager.SendNamedMessage(MessageName, NetworkManager.ServerClientId, writer);
+ }
+ }
+ }
+}
+```
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/deprecation-of-return-values.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/deprecation-of-return-values.md
new file mode 100644
index 000000000..8f3da8a95
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/deprecation-of-return-values.md
@@ -0,0 +1,51 @@
+---
+id: deprecation-of-return-values
+title: Deprecation of Return Values
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+Netcode for GameObjects (Netcode) supports RPC return values on convenience RPCs.
+
+Example:
+
+```csharp
+public IEnumerator MyRpcCoroutine()
+{
+ RpcResponse response = InvokeServerRpc(MyRpcWithReturnValue, Random.Range(0f, 100f), Random.Range(0f, 100f));
+
+ while (!response.IsDone)
+ {
+ yield return null;
+ }
+
+ Debug.LogFormat("The final result was {0}!", response.Value);
+}
+
+[ServerRPC]
+public float MyRpcWithReturnValue(float x, float y)
+{
+ return x * y;
+}
+
+```
+
+This RFC also drops this feature and similar functionality can be achived as following:
+
+```csharp
+void MyRpcInvoker()
+{
+ MyRpcWithReturnValueRequestServerRpc(Random.Range(0f, 100f)), Random.Range(0f, 100f)));
+}
+
+[ServerRpc]
+void MyRpcWithReturnValueRequestServerRpc(float x, float y)
+{
+ MyRpcWithReturnValueResponseClientRpc(x * y);
+}
+
+[ClientRpc]
+void MyRpcWithReturnValueResponseClientRpc(float result)
+{
+ Debug.LogFormat("The final result was {0}!", result);
+}
+```
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/execution-table.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/execution-table.md
new file mode 100644
index 000000000..7dfbd2632
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/execution-table.md
@@ -0,0 +1,97 @@
+---
+id: execution-table
+title: Execution Table
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+The following table details the execution of `ServerRpc` and `ClientRpc` functions:
+
+| Function | Server | Client | Host (Server+Client) |
+|---|:---:|:---:|:---:|
+| ServerRpc Send | | | |
+| ServerRpc Execute | | | |
+| ClientRpc Send | | | |
+| ClientRpc Execute | | | |
+
+An RPC function typically doesn't execute its body immediately since the function call really is a stand-in for a network transmission. Since the host is both a client and a server, local RPCs targeting the host-server or host-client are invoked immediately. As such, avoid nesting RPCs when running in host mode as a ServerRpc method that invokes a ClientRpc method that invokes the same ServerRpc method (and repeat...) could cause a stack overflow.
+
+Structure of a typical `ServerRpc`:
+
+```csharp
+[ServerRpc]
+void MyServerRpc(int somenumber, string somestring)
+{
+ // Network Send Block (framework-code)
+ // Network Return Block (framework-code)
+ // RPC Method Body (user-code)
+}
+```
+
+Pseudo-code sample of a `ServerRpc`:
+
+```csharp
+[ServerRpc]
+void MyServerRpc(int somenumber, string somestring)
+{
+ // --- begin: injected framework-code
+ if (NetworkSend())
+ {
+ // this block will be executed if:
+ // - called from user-code on client
+ // - called from user-code on host
+
+ var writer = NetworkCreateWriter();
+ writer.WriteInt32(1234567890); // RPC method signature hash
+ writer.WriteInt32(somenumber);
+ writer.WriteChars(somestring);
+ NetworkSendRpc(writer);
+ }
+
+ if (NetworkReturn())
+ {
+ // this block will be executed if:
+ // - called from user-code
+ // - called from framework-code on client
+
+ return;
+ }
+ // --- end: injected framework-code
+
+ print($"MyServerRpc: {somenumber}");
+}
+```
+
+
+
+ Client can invoke a server RPC on a Network Object. The RPC will be placed in the local queue and then sent to the server, where it will be executed on the server version of the same Network Object.
+
+
+
+
+ Clients can invoke server RPCs on Client Hosts the same way they can invoke server RPCs on the regular servers: the RPC will be placed in the local queue and then sent to the Client Host, where it will be executed on the Client Host's version of the same Network Object.
+
+
+
+
+
+ When a server RPC is invoked by the Client Host, the RPC will be placed in a local queue and then executed on the Client Host after a short delay. The same happens for pure servers.
+
+
+
+
+
+
+
+
+ Client Hosts can invoke Client RPCs on Network Objects. The RPC will be placed in the local queue and then, after a short delay the client RPC will be executed on the Client Host, and sent to the other clients. When client RPC is received by the client - it is executed on the Client's version of the same Network Object.
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/reliabilty.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/reliabilty.md
new file mode 100644
index 000000000..442a9f46c
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/reliabilty.md
@@ -0,0 +1,47 @@
+---
+id: reliability
+title: Reliability
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+## Introduction
+RPCs **are reliable by default**. This means they are guaranteed to be received and executed on the remote side. However, sometimes developers might want to opt-out reliability, which is often the case for non-critical events such as particle effects, sounds effects etc.
+:::caution
+Packet reliability can be a two edged sword (pro and con):
+- **The Pro**: Under bad network conditions a reliable packet is guaranteed to be received by the target remote side.
+- **The Con**: Because the sender will continue trying to send a reliable packet if it does not get a "packet received" response, under bad network conditions too many reliable packets being sent can cause additional bandwidth overhead.
+:::
+
+### Reliable and Unreliable RPC Examples:
+Reliability configuration can be specified for both `ServerRpc` and `ClientRpc` methods at compile-time:
+
+```csharp
+
+[ServerRpc]
+void MyReliableServerRpc() { /* ... */ }
+
+[ServerRpc(Delivery = RpcDelivery.Unreliable)]
+void MyUnreliableServerRpc() { /* ... */ }
+
+[ClientRpc]
+void MyReliableClientRpc() { /* ... */ }
+
+[ClientRpc(Delivery = RpcDelivery.Unreliable)]
+void MyUnreliableClientRpc() { /* ... */ }
+```
+
+Reliable RPCs will be received on the remote end in the same order as they are fired but this in-order guarantee only applies to RPCs on the same `NetworkObject`. Different `NetworkObjects` might have reliable RPCs called but executed in different order compared to each other. To put more simply, **in-order reliable RPC execution is guaranteed per `NetworkObject` basis only**. If you determine an RPC is being updated frequently (i.e. several times per second), it _might_ be better suited as an unreliable RPC.
+:::caution
+When testing unreliable RPCs on a local network, the chance of an unreliable packet being dropped is reduced greatly (sometimes never). As such, you might want to use [`UnityTransport`'s Simulator Pipeline](https://docs-multiplayer.unity3d.com/transport/current/pipelines#simulator-pipeline) to simulate poor network conditions in order to better determine how dropped unreliable RPC messages impacts your project.
+:::
+
+:::tip
+Sometimes you might find out that you are sending parameters that are both critical and non-critical. Under this scenario you might benefit by splitting the RPC into two or more RPCs with the less critical parameters being sent unreliably (possibly at the same or higher frequency) while the more critical parameters are sent reliably (possibly at the same or lower frequency).
+:::
+
+### Additional RPC Facts
+- An RPC call made without an active connection will not be automatically added to the send queue and will be dropped/ignored.
+- Both reliable and unreliable RPC calls have to be made when there is an active network connection established between a client and the server. _The caveat to this rule is if you are running a host since a host is both a server and a client:_
+ - _A host can send RPC messages from the "host-server" to the "host-client" and vice versa._
+- Reliable RPC calls made during connection will be dropped if the sender disconnects before the RPC is sent.
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/rpc-compatibility.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/rpc-compatibility.md
new file mode 100644
index 000000000..23838fadc
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/rpc-compatibility.md
@@ -0,0 +1,92 @@
+---
+id: rpc-compatibility
+title: RPC migration and compatibility
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+This section provides information on compatibility and support for Unity Netcode for GameObjects (Netcode) features compared to previous Netcode versions. See the [Release Notes](../../../../releases/introduction) for more information.
+
+## Cross-Compatibility
+
+Learn more about standard RPC API's cross-compatibility only, not the framework as a whole. A method marked as RPC will be statically registered with its assembly-scoped method signature hash.
+
+A typical assembly-scoped method signature sample:
+
+```
+Game.dll / System.Void Shooter::PingServerRpc(System.Int32,MLAPI.Messaging.ServerRpcParams)
+```
+
+where:
+
+- `Game.dll` is the Assembly
+- `/` is a Separator
+- `System.Void Shooter::PingServerRpc(System.Int32,MLAPI.Messaging.ServerRpcParams)` is the Method signature:
+
+ - `System.Void` is the Return type
+ - `Shooter` is the Enclosing type
+ - `::` is the Scope resolution operator
+ - `PingServerRpc` is the Method name
+ - `(System.Int32,MLAPI.Messaging.ServerRpcParams)` is the Params with types (no param names)
+
+An RPC signature will be turned into a 32-bit integer using [xxHash](https://cyan4973.github.io/xxHash/) (XXH32) non-cryptographic hash algorithm.
+
+As expected, RPC signature therefore its hash will be changed if assembly, return type, enclosing type, method name and/or any method param type changes. Names of method parameters can be changed as they are not a part of the method signature.
+
+A change in the RPC signature will lead into a different send/receive codepath with different serialization code and execute a different method body. Previous versions of the RPC method will not be executed by the new RPC method with the new signature.
+
+| Compatibility | | Description |
+| -- | :--: | -- |
+| Cross-Build Compatibility | | As long as the RPC method signature is kept the same, it will be compatible between different builds. |
+| Cross-Version Compatibility | | As long as the RPC method signature is kept the same, it will be compatible between different versions. |
+| Cross-Project Compatibility | | Since project name or any project-specific token is not being a part of RPC signature, it is possible to have the exact same RPC method signature defined in different builds and they are not necessarily going to be compatible with each other. |
+
+## Deprecation of return values
+
+Netcode supports RPC return values on convenience RPCs.
+
+Example:
+
+```csharp
+public IEnumerator MyRpcCoroutine()
+{
+ RpcResponse response = InvokeServerRpc(MyRpcWithReturnValue, Random.Range(0f, 100f), Random.Range(0f, 100f));
+
+ while (!response.IsDone)
+ {
+ yield return null;
+ }
+
+ Debug.LogFormat("The final result was {0}!", response.Value);
+}
+
+[ServerRPC]
+public float MyRpcWithReturnValue(float x, float y)
+{
+ return x * y;
+}
+
+```
+
+To achieve similar functionality, use the following:
+
+```csharp
+void MyRpcInvoker()
+{
+ MyRpcWithReturnValueRequestServerRpc(Random.Range(0f, 100f), Random.Range(0f, 100f));
+}
+
+[ServerRpc]
+void MyRpcWithReturnValueRequestServerRpc(float x, float y)
+{
+ MyRpcWithReturnValueResponseClientRpc(x * y);
+}
+
+[ClientRpc]
+void MyRpcWithReturnValueResponseClientRpc(float result)
+{
+ Debug.LogFormat("The final result was {0}!", result);
+}
+```
+
+import useBaseUrl from '@docusaurus/useBaseUrl';
+import Link from '@docusaurus/Link';
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/rpc-params.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/rpc-params.md
new file mode 100644
index 000000000..0661cb2d9
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/rpc-params.md
@@ -0,0 +1,48 @@
+---
+id: rpc-params
+title: RPC Params
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+Both `ServerRpc` and `ClientRpc` methods can be configured either by `[ServerRpc]` and `[ClientRpc]` attributes at compile-time and `ServerRpcParams` and `ClientRpcParams` at runtime.
+
+Developers can put `ServerRpcParams` and `ClientRpcParams` as the last parameter (optionally). They can also be used for a consolidated space for `XXXRpcReceiveParams` and `XXXRpcSendParams`.
+
+The network framework will inject the corresponding `XXXRpcReceiveParams` to what the user had declared in code when invoked by network receive handling (framework code) and will consume `XXXRpcSendParams` when invoked by RPC send call (user code).
+
+
+## ServerRpc Params
+
+See the following for `ServerRpc` params:
+
+``` csharp
+// Both ServerRpc methods below are fine, `ServerRpcParams` is completely optional
+
+[ServerRpc]
+void AbcdServerRpc(int somenumber) { /* ... */ }
+
+[ServerRpc]
+void XyzwServerRpc(int somenumber, ServerRpcParams serverRpcParams = default) { /* ... */ }
+```
+
+[ServerRpcParams Documentation](../../api/Unity.Netcode.ServerRpcParams)
+
+## ClientRpc Params
+
+See the following for `ClientRpc` params:
+
+```csharp
+// Both ClientRpc methods below are fine, `ClientRpcParams` is completely optional
+
+[ClientRpc]
+void AbcdClientRpc(int framekey) { /* ... */ }
+
+[ClientRpc]
+void XyzwClientRpc(int framekey, ClientRpcParams clientRpcParams = default) { /* ... */ }
+```
+
+[ClientRpcParams Documentation](../../api/Unity.Netcode.ClientRpcParams)
+
+:::tip
+`ClientRpcSendParams`'s `TargetClientIds` property is a `ulong[]` which means everytime you try to specify a subset of target clients or even a single client target, you will have to allocate a `new ulong[]`. This pattern could quickly lead into lots of heap allocations and pressure GC which would cause GC spikes at runtime. We suggest developers cache their `ulong[]` variables or use an array pool to cycle `ulong[]` instances so that it would cause less heap allocations.
+:::
diff --git a/versioned_docs/version-1.0.0/advanced-topics/message-system/serverrpc.md b/versioned_docs/version-1.0.0/advanced-topics/message-system/serverrpc.md
new file mode 100644
index 000000000..4f8448595
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/message-system/serverrpc.md
@@ -0,0 +1,157 @@
+---
+id: serverrpc
+title: ServerRpc
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+## Introduction
+A `ServerRpc` provides you with the ability to send information from a client to a server just like you would invoke a method from within a class. A `ServerRpc` is a remote procedure call (RPC) that can be only invoked by a client and will always be received and executed on the server/host.
+
+## Declaring a ServerRpc
+You can declare a `ServerRpc` by:
+1. Creating a method that ends with the `ServerRpc` suffix within a `NetworkBehaviour` derived class.
+2. Adding the `[ServerRpc]` attribute above the method
+
+### Example of declaring a ServerRpc:
+```csharp
+public class SomeNetworkBehaviour : NetworkBehaviour
+{
+ [ServerRpc]
+ public void PingServerRpc(int pingCount)
+ {
+
+ }
+}
+```
+The above example uses the default [ServerRpc] attribute settings which only allows a client owner (client that owns `NetworkObject` associated with the `NetworkBehaviour` containing the `ServerRpc` method) invocation rights. Any client that is not the owner will not be allowed to invoke the `ServerRpc`.
+
+## ServerRpc Ownership And ServerRpcParams
+There are times where you might want any client to have `ServerRpc` invocation rights. You can easily accomplish this by setting the `ServerRpc` attribute's `RequireOwnership` parameter to false like in the example below:
+```csharp
+[ServerRpc(RequireOwnership = false)]
+public void MyGlobalServerRpc(ServerRpcParams serverRpcParams = default)
+{
+ var clientId = serverRpcParams.Receive.SenderClientId;
+ if (NetworkManager.ConnectedClients.ContainsKey(clientId))
+ {
+ var client = NetworkManager.ConnectedClients[clientId];
+ // Do things for this client
+ }
+}
+```
+In the above example, you will also notice that `MyGlobalServerRpc` takes a single parameter of type [`ServerRpcParams`](https://docs-multiplayer.unity3d.com/netcode/current/api/Unity.Netcode.ServerRpcParams). This parameter type is optional, but it can be very useful to identify **which client** was requesting the server invoke the RPC. The `ServerRpcParams.Receive.SenderClientId` property is automatically set upon the server receiving the `ServerRpc` request and used to get the server-side `NetworkClient` instance of the client (sender).
+:::important Best Practice
+Using the `ServerRpcParams.Receive.SenderClientId` property is considered the best practice to identify which client was invoking the `ServerRpc`. It is not recommended to send the client identifier via an additional `ulong` parameter added to the `ServerRpc`:
+```csharp
+[ServerRpc(RequireOwnership = false)]
+public void MyGlobalServerRpc(ulong clientId) // This is considered a bad practice (Not Recommended)
+{
+ if (NetworkManager.ConnectedClients.ContainsKey(clientId))
+ {
+ var client = NetworkManager.ConnectedClients[clientId];
+ // Do things for this client
+ }
+}
+```
+The primary reason, especially when `RequireOwnership == false`, is that it could introduce potential security issues. The secondary reason is that this value is already automatically provided to you via `ServerRpcParams` without the additional `ulong` parameter bandwidth overhead you would incur by sending the client identifier as a `ServerRpc` parameter.
+:::
+
+Now, taking the best practices example into consideration, you might want to have other valid parameters added to your `ServerRpc`. When adding additional parameters other than the `ServerRpcParams` parameter, you **must** declare `ServerRpcParams` as the **last** parameter of the `ServerRpc`:
+```csharp
+[ServerRpc(RequireOwnership = false)]
+public void PlayerShootGunServerRpc(Vector3 lookWorldPosition, ServerRpcParams serverRpcParams = default)
+{
+ var clientId = serverRpcParams.Receive.SenderClientId;
+ if (NetworkManager.ConnectedClients.ContainsKey(clientId))
+ {
+ var client = NetworkManager.ConnectedClients[clientId];
+ var castRay = new Ray(client.PlayerObject.transform.position, lookWorldPosition);
+ RaycastHit rayCastHit;
+ if (Physics.Raycast(castRay, out rayCastHit, 100.0f))
+ {
+ // Handle shooting something
+ }
+ }
+}
+```
+Looking at the above example, we can see the client invoking the `PlayerShootGunServerRpc` method passes in a world position based on perhaps a screen space crosshair position to world space position, the `ServerRpcParams`, and the `ServerRpc` doesn't require ownership.
+
+:::tip Alternate Owner Example
+Of course, if your project's design was such that a weapon changes ownership when it is picked up by a player, then you would only allow owners to invoke the method and would only need the one `Vector3` parameter like in the example below:
+```csharp
+[ServerRpc]
+public void PlayerOwnerShootGunServerRpc(Vector3 lookWorldPosition)
+{
+ if (NetworkManager.ConnectedClients.ContainsKey(OwnerClientId))
+ {
+ var client = NetworkManager.ConnectedClients[OwnerClientId];
+ var castRay = new Ray(client.PlayerObject.transform.position, lookWorldPosition);
+ RaycastHit rayCastHit;
+ if (Physics.Raycast(castRay, out rayCastHit, 100.0f))
+ {
+ // Handle shooting something
+ }
+ }
+}
+```
+:::
+
+## Invoking a ServerRpc
+From the example below that uses the `PlayerOwnerShootGunServerRpc` method, you can see that you would invoke it just any other method:
+
+```csharp
+private void Update()
+{
+ if (!IsSpawned || !IsOwner)
+ {
+ return;
+ }
+
+ if (Input.GetKeyDown(KeyCode.Space))
+ {
+ var point = new Vector3();
+ var currentEvent = Event.current;
+ var mousePos = new Vector2();
+
+ // Get the mouse position from Event.
+ // Note that the y position from Event is inverted.
+ mousePos.x = currentEvent.mousePosition.x;
+ mousePos.y = Camera.current.pixelHeight - currentEvent.mousePosition.y;
+
+ point = Camera.current.ScreenToWorldPoint(new Vector3(mousePos.x,
+ mousePos.y, Camera.current.nearClipPlane));
+
+ PlayerOwnerShootGunServerRpc(point);
+ }
+}
+```
+
+### ServerRpc Timing
+The following are a few timing diagrams to help provide additional visual context when invoking a `ServerRpc`.
+
+
+
+ Client can invoke a server RPC on a Network Object. The RPC will be placed in the local queue and then sent to the server, where it will be executed on the server version of the same Network Object.
+
+
+
+
+ Clients can invoke server RPCs on Client Hosts the same way they can invoke server RPCs on the regular servers: the RPC will be placed in the local queue and then sent to the Client Host, where it will be executed on the Client Host's version of the same Network Object.
+
+
+
+
+ When a server RPC is invoked by the Client Host, the RPC will be placed in a local queue and then executed on the Client Host after a short delay. The same happens for pure servers.
+
+
+## See Also
+
+* [ClientRpc](clientrpc.md)
+* [RPC Params](rpc-params.md)
+* See [examples](../../learn/bossroom/bossroom-actions) of how these were used in Boss Room.
diff --git a/versioned_docs/version-1.0.0/advanced-topics/messaging-system.md b/versioned_docs/version-1.0.0/advanced-topics/messaging-system.md
new file mode 100644
index 000000000..17c70607a
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/messaging-system.md
@@ -0,0 +1,81 @@
+---
+id: messaging-system
+title: Sending Events with RPCs
+description: An introduction to the messaging system in Unity MLAPI, including RPC's and Custom Messages.
+---
+import ImageSwitcher from '@site/src/ImageSwitcher.js';
+
+Netcode for GameObjects (Netcode) has two parts to its messaging system: RPCs and [Custom Messages](message-system/custom-messages.md). Both types have sub-types that change their behaviour, functionality, and performance. This page will focus on RPCs.
+
+## RPC: Remote Procedure Call
+
+The concept of an `RPC` is common not only in video games but in the software industry in general. They are ways to call methods on objects that are not in the same executable.
+
+
+
+ Client can invoke a server RPC on a Network Object. The RPC will be placed in the local queue and then sent to the server, where it will be executed on the server version of the same Network Object.
+
+
+At a high level, when calling an `RPC` client side, the SDK will take a note of the object, component, method and any parameters for that `RPC` and send that information over the network. The server will receive that information, find the specified object, find the specified method and call it on the specified object with the received parameters.
+
+When calling an `RPC`, you call a method remotely on an object that could be anywhere in the world. They are "events" you can trigger when needed.
+
+If you call an `RPC` method on your side, it will execute on a different machine.
+
+Netcode has two variations of RPCs to execute logic on either server-side or client-side: [`ServerRpc`](message-system/serverrpc.md) and [`ClientRpc`](message-system/clientrpc.md).
+
+
+
+ Server can invoke a client RPC on a Network Object. The RPC will be placed in the local queue and then sent to a selection of clients (by default this selection is "all clients"). When received by a client, RPC will be executed on the client's version of the same Network Object.
+
+
+
+:::info
+For more information see the wikipedia entry on [Remote Procedure Call's](https://en.wikipedia.org/wiki/Remote_procedure_call).
+:::
+
+### Netcode's RPCs
+
+See the following pages for more information:
+
+- [ClientRpc](message-system/clientrpc.md)
+- [ServerRpc](message-system/serverrpc.md)
+- [Reliability](message-system/reliabilty.md)
+- [Execution Table](message-system/execution-table.md)
+- [RPC Params](message-system/rpc-params.md)
+ - [Serialization Types and RPCs](message-system/../serialization/serialization-intro.md)
+
+There is also some additional design advice on RPC's and some usage examples on the following pages:
+
+- [RPC vs NetworkVariable](../learn/rpcvnetvar.md)
+- [RPC vs NewtorkVariables Examples](../learn/rpcnetvarexamples.md)
+
+:::note Migration and Compatibility
+See [RPC Migration and Compatibility](message-system/rpc-compatibility.md) for more information on updates, cross-compatibility, and deprecated methods for Unity RPC.
+:::
+
+## RPC method calls
+
+A typical SDK user (Unity developer) can declare multiple RPCs under a `NetworkBehaviour` and inbound/outbound RPC calls will be replicated as a part of its replication in a network frame.
+
+A method turned into an RPC is no longer a regular method, it will have its own implications on direct calls and in the network pipeline. See [Execution Table](message-system/execution-table.md).
+
+### RPC usage checklist:
+To use RPCs, make sure
+- ```[ClientRpc]``` or ```[ServerRpc]``` attributes are on your method
+- Your method name ends with ```ClientRpc``` or ```ServerRpc``` (ex: ```DoSomethingServerRpc()```)
+- your method is declared in a class that inherits from NetworkBehaviour
+ - your GameObject has a NetworkObject component attached
+- Make sure to call your RPC method server side or client side (using ```isClient``` or ```isServer```)
+- Only accept value types as parameters
+
+## Serialization Types and RPCs
+
+Instances of Serializable Types are passed into an RPC as parameters and are serialized and replicated to the remote side.
+
+See [Serialization](serialization/serialization-intro.md) for more information.
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/network-update-loop-system/index.md b/versioned_docs/version-1.0.0/advanced-topics/network-update-loop-system/index.md
new file mode 100644
index 000000000..e6808243b
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/network-update-loop-system/index.md
@@ -0,0 +1,54 @@
+---
+id: about-network-update-loop
+title: About Network Update Loop
+---
+
+Often there is a need to update netcode systems like RPC queue, transport IO, and others outside the standard `MonoBehaviour` event cycle.
+
+The Network Update Loop infrastructure utilizes Unity's low-level Player Loop API allowing for registering `INetworkUpdateSystems` with `NetworkUpdate()` methods to be executed at specific `NetworkUpdateStages` which may be either prior to or after `MonoBehaviour`-driven game logic execution.
+
+Typically you will interact with `NetworkUpdateLoop` for registration and `INetworkUpdateSystem` for implementation. Systems such as network tick and future features (such as network variable snapshotting) will rely on this pipeline.
+
+## Registration
+
+`NetworkUpdateLoop` exposes four methods for registration:
+
+| Method | Registers |
+| -- | -- |
+| `void RegisterNetworkUpdate(INetworkUpdateSystem updateSystem, NetworkUpdateStage updateStage)` | Registers an `INetworkUpdateSystem` to be executed on the specified `NetworkUpdateStage` |
+| `void RegisterAllNetworkUpdates(INetworkUpdateSystem updateSystem)` | Registers an `INetworkUpdateSystem` to be executed on all `NetworkUpdateStage`s |
+| `void UnregisterNetworkUpdate(INetworkUpdateSystem updateSystem, NetworkUpdateStage updateStage)` | Unregisters an `INetworkUpdateSystem` from the specified `NetworkUpdateStage` |
+| `void UnregisterAllNetworkUpdates(INetworkUpdateSystem updateSystem)` | Unregisters an `INetworkUpdateSystem` from all `NetworkUpdateStage`s |
+
+## Update Stages
+
+After injection, the player loops follows these stages. The player loop executes the `Initialization` stage and that invokes `NetworkUpdateLoop`'s `RunNetworkInitialization` method which iterates over registered `INetworkUpdateSystems` in `m_Initialization_Array` and calls `INetworkUpdateSystem.NetworkUpdate(UpdateStage)` on them.
+
+In all `NetworkUpdateStages`, it iterates over an array and calls the `NetworkUpdate` method over `INetworkUpdateSystem` interface, and the pattern is repeated.
+
+ B --> C --> D --> E --> F --> G
+`}/>
+
+| Stage | Method |
+| -- | -- |
+| `Initialization` | `RunNetworkInitialization` |
+| `EarlyUpdate` | `RunNetworkEarlyUpdate` `ScriptRunDelayedStartupFrame` Other systems |
+| `FixedUpdate` | `RunNetworkFixedUpdate` `ScriptRunBehaviourFixedUpdate` Other systems |
+| `PreUpdate` | `RunNetworkPreUpdate` `PhysicsUpdate` `Physics2DUpdate` Other systems |
+| `Update` | `RunNetworkUpdate` `ScriptRunBehaviourUpdate` Other systems |
+| `PreLateUpdate` | `RunNetworkPreLateUpdate` `ScriptRunBehaviourLateUpdate` |
+| `PostLateUpdate` | `PlayerSendFrameComplete` `RunNetworkPostLateUpdate` Other systems |
+
+## References
+
+See [Network Update Loop Reference](network-update-loop-reference.md) for process flow diagrams and code.
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/network-update-loop-system/network-update-loop-reference.md b/versioned_docs/version-1.0.0/advanced-topics/network-update-loop-system/network-update-loop-reference.md
new file mode 100644
index 000000000..857045c90
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/network-update-loop-system/network-update-loop-reference.md
@@ -0,0 +1,22 @@
+---
+id: network-update-loop-reference
+title: Network Update Loop Reference
+---
+
+The following diagrams provide insight into the Network Update Loop process and APIs.
+
+## Injecting NetworkUpdateLoop Systems Into PlayerLoop
+
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/networkobject-parenting.md b/versioned_docs/version-1.0.0/advanced-topics/networkobject-parenting.md
new file mode 100644
index 000000000..d209eafc4
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/networkobject-parenting.md
@@ -0,0 +1,192 @@
+---
+id: networkobject-parenting
+title: NetworkObject Parenting
+description: A `NetworkObject` parenting solution within Netcode for GameObjects (Netcode) to help developers with synchronizing transform parent-child relationships of `NetworkObjects`.
+
+---
+### Overview
+If you aren't completely familiar with transform parenting in Unity, then it is highly recommended to [review over the existing Unity documentation](https://docs.unity3d.com/Manual/class-Transform.html) before reading further. In order to properly synchronize all connected clients with any change in a `GameObject`'s transform parented status, Netcode for GameObjects (NGO) requires that the parent and child `GameObject`s have `NetworkObject` components attached to them.
+
+### Parenting Rules
+- Setting the parent of a child's `Transform` directly (i.e. `transform.parent = childTransform;`) will always use the default `WorldPositionStays` value of `true`.
+ - It is recommended to always use the `NetworkObject.TrySetParent` method when parenting if you plan on changing the `WorldPositionStays` default value.
+ - Likewise, it is also recommended to use the `NetworkObject.TryRemoveParent` method to remove a parent from a child.
+- When a server parents a spawned `NetworkObject` under another spawned `NetowrkObject` during a netcode game session this parent child relationship is replicated across the network to all connected and future late joining clients.
+- If, while editing a scene, you place an in-scene placed `NetworkObject` under a `GameObject` that does not have a `NetworkObject` component attached to it, NGO will preserve that parenting relationship.
+ - During runtime, this parent-child hierarchy will remain true unless user code removes the GameObject parent from the child NetworkObject.
+ - _Note: Once removed, NGO will not allow you to re-parent the `NetworkObject` back under the same or another `GameObject` that with no `NetworkObject` component attached to it._
+- You can perform the same parenting actions with in-scene placed `NetworkObject`s as you can with dynamically spawned `NetworkObject`s.
+ - Only in-scene placed `NetworkObject`s can have multiple generations of nested `NetworkObject` children.
+ - You can parent dynamically spawned `NetworkObject`s under in-scene placed `NetworkObject`s and vice versa.
+- To adjust a child's transform values when parenting or when removing a parent:
+ - Override the `NetworkBehaviour.OnNetworkObjectParentChanged` virtual method within a `NetworkBehaviour` attached to the child NetworkObject.
+ - When `OnNetworkObjectParentChanged` is invoked, on the server side, adjust the child's transform values within the overridden method.
+ - NGO will then synchronize all clients with the child's parenting and transform changes.
+
+:::tip
+When a NetworkObject is parented, NGO will synchronize both the parenting information along with the child's transform values. NGO uses the `WorldPositionStays` setting to determine whether to synchronize the local or world space transform values of the child `NetworkObject`. This means that a `NetworkObject` does not require you to include a `NetworkTransform` component if it never moves around, rotates, or changes its scale when it is not parented. This can be useful for world items a player might pickup (i.e. parent the item under the player) and the item in question needs to be adjusted relative to the player when it is parented or the parent is removed (i.e. dropped). This helps to reduce the item's over-all bandwidth and processing resources consumption.
+:::
+
+### OnNetworkObjectParentChanged
+[`NetworkBehaviour.OnNetworkObjectParentChanged`](https://docs-multiplayer.unity3d.com/netcode/current/api/Unity.Netcode.NetworkBehaviour#onnetworkobjectparentchangednetworkobject) is a virtual method you can override to be notified when a `NetworkObject`'s parent has changed. The [`MonoBehaviour.OnTransformParentChanged()`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnTransformParentChanged.html) method is used by `NetworkObject` to catch `transform.parent` changes and notify its associated `NetworkBehaviour`s.
+
+```csharp
+///
+/// Gets called when the parent NetworkObject of this NetworkBehaviour's NetworkObject has changed
+///
+virtual void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject) { }
+```
+
+:::caution Multi-Generation Children and Scale
+If you are dealing with more than one generation of nested children where each parent and child have scale values other than `Vector3.one`, then mixing the `WorldPositionStays` value when parenting and removing a parent will impact how the final scale is calculated! If you want to maintain the same values prior to parenting when removing a parent from a child, then you need to use the same `WorldPositionStays` value used when the child was parented.
+:::
+
+### Only A Server (or A Host) Can Parent NetworkObjects
+Similar to [Ownership](../basics/networkobject#ownership), only the server (or host) can control `NetworkObject` parenting.
+
+:::tip
+If you run into a situation where your client must trigger parenting a `NetworkObject`, one solution is for the client to send an RPC to the server. Upon receiving the RPC message, the server then handles parenting the `NetworkObject`.
+:::
+
+### Only Parent Under A `NetworkObject` Or Nothing (i.e. The Root or null)
+You can only parent a NetworkObject under another NetworkObject. The only exception is if you don't want the NetworkObject to have a parent. In this case, you would can remove the NetworkObject's parent by invoking `NetworkObject.TryRemoveParent`. If this operation succeeds, the the parent of the child will be set to `null` (root of the scene hierarchy).
+
+### Only Spawned NetworkObjects Can Be Parented
+A `NetworkObject` can only be parented if it is spawned and can only be parented under another spawned `NetworkObject`. This also means that `NetworkObject` parenting can only occur during a network session (netcode enabled game session). Think of `NetworkObject` parenting as a netcode event. In order for it to happen, you must have, at very minimum, a server or host instance started and listening.
+
+### Invalid Parenting Actions Are Reverted
+If an invalid/unsupported `NetworkObject` parenting action occurs, the attempted parenting action will be reverted back to the `NetworkObject`'s original parenting state.
+
+**For example:**
+If you had a `NetworkObject` who's current parent was root and tried to parent it in an invalid way (i.e. under a GameObject without a `NetworkObject` component) then a warning message would be logged and the `NetworkObject` would revert back to having root as its parent.
+
+### In-scene Object Parenting and Player Objects
+If you plan on parenting in-scene placed `NetworkObject`s with a player `NetworkObject` when it is initially spawned, you need to wait until the client has finished synchronizing with the server first. Since parenting can only be performed on the server side, you should perform the parenting action only when the server has received the `NetworkSceneManager` generated `SceneEventType.SynchronizeComplete` message from the client that owns the player `NetworkObject` to be parented (as a child or parent).
+:::info For More Information
+- [Real World In-scene NetworkObject Parenting of Players Solution](inscene_parenting_player.md)
+- [Scene Event Notifications](../basics/scenemanagement/scene-events#scene-event-notifications)
+- [In-Scene NetworkObjects](../basics/scenemanagement/inscene-placed-networkobjects.md)
+:::
+
+### WorldPositionStays usage
+When using the `NetworkObject.TrySetParent` or `NetworkObject.TryRemoveParent` methods, the `WorldPositionStays` parameter is synchronized with currently connected and late joining clients. When removing a child from its parent, you should use the same `WorldPositionStays` value that was used to parent the child. More specifically when `WorldPositionStays` is set to false this applies, but if you are using the defalt value of `true` then this is not required (because it is the default).
+
+When the `WorldPositionStays` parameter in `NetworkObject.TrySetParent` is the default value of `true`, this will preserve the world space values of the child `NetworkObject` relative to the parent. However, sometimes you might want to only preserve the local space values (i.e. pick up an object that only has some initial changes to the child's transform when parented). Through a combination of `NetworkObject.TrySetParent` and `NetworkBehaviour.OnNetworkObjectParentChanged` you can accomplish this without the need for a `NetworkTransform`. To better understand how this works, it is important to understand the order of operations for both of these two methods:
+
+**Server-Side**
+- `NetworkObject.TrySetParent` invokes `NetworkBehaviour.OnNetworkObjectParentChanged`
+ - You can make adjustments to the child's position, rotation, and scale in the overridden `OnNetworkObjectParentChanged` method.
+- The ParentSyncMessage is generated, the transform values are added to the message, and the message is then sent.
+ - ParentSyncMessage includes the child's position, rotation, and scale
+ - Currently connected or late joining clients will be synchronized with the parenting and the child's associated transform values
+
+**When to use a NetworkTransform**
+If you plan on the child `NetowrkObject` moving around, rotating, or scaling independently (when parented or not) then you will still want to use a NetworkTransform.
+If you only plan on making a one time adjustment to the child `NetworkObject`'s transform when parented or having a parent removed, then the child does not need a `NetworkTransform` component.
+
+:::info For More Information
+- [Learn More About WorldPositionStays](https://docs.unity3d.com/ScriptReference/Transform.SetParent.html)
+:::
+
+### Network Prefabs, Parenting, and NetworkTransforms
+Since the `NetworkTransform` component synchronizes the transform of a `GameObject` (with a `NetworkObject` component attached to it), it can become tricky to understand the parent-child transform relationship and how that translates when synchronizing late joining clients. Currently, a network prefab can only have one `NetworkObject` component within on the root `GameObject` of the prefab. However, you can have a complex hierarchy of `GameObject`s nested under the root `GameObjet` and each child `GameObject` can have a `NetworkBehaviour` attached to it. Since a `NetworkTransform` synchronizes the transform of the `GameObject` it is attached to, you might be tempted to setup a network prefab like this:
+
+```
+Network Prefab Root (GameObject with NetworkObject and NetworkTransform components attached to it)
+ ├─ Child #1 (GameObject with NetworkTransform component attached to it)
+ │
+ └─ Child #2 (GameObject with NetworkTransform component attached to it)
+```
+While this will not give you any warnings and, depending upon the transform settings of Child #1 & #2, it might appear to work properly (i.e. synchronizes clients, etc.), it is important to understand how the child `GameObject`, with no `NetworkObject` component attached to it, and parent `GameObject`, that does have a `NetworkObject` component attached to it, will be synchronized when a client connects to an already in-progress network session (i.e. late joins or late joining client). If Child #1 or Child #2 have had changes to their respective `GameObject`'s transform prior to a client joining, then upon a client late joining the two child `GameObject`'s transforms will not get synchronized during the initial synchronization period because they do not have `NetworkObject` components attached to them:
+
+```
+Network Prefab Root (Late joining client is synchronized with `GameObject`'s current transform state)
+ ├─ Child #1 (Late joining client *is not synchronized* with `GameObject`'s current transform state)
+ │
+ └─ Child #2 (Late joining client *is not synchronized* with `GameObject`'s current transform state)
+```
+This *is important* to understand because the `NetworkTransform` component initializes itself, during `NetworkTransform.OnNetworkSpawn`, with the `GameObject`'s current transform state. Just below, in the parenting examples, we provide you with some valid and invalid parenting rules. As such, you should take these rules into consideration when using `NetworkTransform` components if you plan on using a complex parent-child hierarchy and should make sure to organize your project's assets where any children that have `NetworkTransform` components attached to them also have `NetworkObject` components attached to them to avoid late-joining client synchronization issues.
+
+## Parenting Examples
+
+### Simple Example:
+Let's assume we have the following initial scene hierarchy before we attempt parenting:
+```
+Sun
+Tree
+Camera
+Player (GameObject->NetworkObject)
+Vehicle (GameObject->NetworkObject)
+```
+Both the player and vehicle `NetworkObject`s are spawned and the player moves towards the vehicle and wants to "get into" the vehicle. The player's client sends perhaps a "use object" RPC command to the server. In turn, the server then parents the player under the vehicle and changes the player's model pose to sitting. Since both `NetworkObject`s are spawned and the server is receiving an RPC to perform the parenting action, the parenting action performed by the server is considered valid and the player is then parented under the vehicle as it is shown below:
+
+```
+Sun
+Tree
+Camera
+Vehicle (GameObject->NetworkObject)
+ └─ Player (GameObject->NetworkObject)
+```
+
+### Mildly Complex Invalid Example:
+```
+Sun
+Tree
+Camera
+Player (GameObject->NetworkObject)
+Vehicle (GameObject->NetworkObject)
+ ├─ Seat1 (GameObject)
+ └─ Seat2 (GameObject)
+```
+In the above example, the vehicle has two GameObjects nested under the vehicle's root GameObject to represent the two available seats. If we tried to parent the player under Seat1:
+```
+Sun
+Tree
+Camera
+Vehicle (GameObject->NetworkObject)
+ ├─Seat1 (GameObject)
+ │ └─Player (GameObject->NetworkObject)
+ └─Seat2 (GameObject)
+```
+This would be considered an invalid parenting and would be reverted.
+
+### Mildly Complex Valid Example:
+In order to resolve the previous invalid parenting issue, we would need to add a `NetworkObjet` component to the seats. This means we would need to:
+1. Spawn the vehicle and the seats:
+```
+Sun
+Tree
+Camera
+Player (GameObject->NetworkObject)
+Vehicle (GameObject->NetworkObject)
+Seat1 (GameObject->NetworkObject)
+Seat2 (GameObject->NetworkObject)
+```
+
+2. Once spawned, parent the seats under the vehicle
+
+```
+Sun
+Tree
+Camera
+Player (GameObject->NetworkObject)
+Vehicle (GameObject->NetworkObject)
+ ├─ Seat1 (GameObject->NetworkObject)
+ └─ Seat2 (GameObject->NetworkObject)
+```
+3. Finally, some time later a player wants to get into the vehicle and the player is parented under Seat1:
+```
+Sun
+Tree
+Camera
+Vehicle (GameObject->NetworkObject)
+ ├─Seat1 (GameObject->NetworkObject)
+ │ └─Player (GameObject->NetworkObject)
+ └─Seat2 (GameObject->NetworkObject)
+```
+
+:::note Optional Auto Synchronized Parenting
+The Auto Object Parent Sync property of NetworkObject, enabled by default, allows you to disable automatic parent change synchronization in the event you want to implement your own parenting solution for one or more NetworkObjects.
+:::
+
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/networktime-ticks.md b/versioned_docs/version-1.0.0/advanced-topics/networktime-ticks.md
new file mode 100644
index 000000000..3d6308007
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/networktime-ticks.md
@@ -0,0 +1,203 @@
+---
+id: networktime-ticks
+title: NetworkTime and Ticks
+sidebar_label: NetworkTime & Ticks
+---
+
+## LocalTime and ServerTime
+
+Why are there two different time values and which one should be used?
+
+Netcode for GameObjects (Netcode) uses a star topology. That means all communications happen between the clients and the server/host and never between clients directly. Messages take time to transmit over the network. That's why `RPCs` and `NetworkVariable` will not happen immediately on other machines. `NetworkTime` allows to use time while considering those transmission delays.
+
+- `LocalTime` on a client is ahead of the server. If a server RPC is sent at `LocalTime` from a client it will roughly arrive at `ServerTime` on the server.
+- `ServerTime` on clients is behind the server. If a client RPC is sent at `ServerTime` from the server to clients it will roughly arrive at `ServerTime` on the clients.
+
+
+
+>Server: Delay when sending message
+ Note over Server: Message arrives at ServerTime.
+ Note over Server: On server: ServerTime == LocalTime.
+ Note over Server: Send message to clients at LocalTime.
+ Server->>Receiver: Delay when sending message
+ Note over Receiver: Message arrives at ServerTime.
+`}/>
+
+
+
+
+`LocalTime`
+- Use for player objects with client authority.
+- Use if just a general time value is needed.
+
+`ServerTime`:
+- For player objects with server authority (E.g. by sending inputs to the server via RPCs)
+- In sync with position updates of `NetworkTransform` for all `NetworkObjects` where the client is not authoritative over the transform.
+- For everything on non client controlled `NetworkObjects`.
+
+## Examples
+
+### Example 1: Using network time to synchronize environments
+
+Many games have environmental objects which move in a fixed pattern. By using network time these objects can be moved without having to synchronize their positions with a `NetworkTransform`.
+
+For instance the following code could be used to create a moving elevator platform for a client authoritative game:
+
+```csharp
+using Unity.Netcode;
+using UnityEngine;
+
+public class MovingPlatform : MonoBehaviour
+{
+ public void Update()
+ {
+ // Move up and down by 5 meters and change direction every 3 seconds.
+ var positionY = Mathf.PingPong(NetworkManager.Singleton.LocalTime.TimeAsFloat / 3f, 1f) * 5f;
+ transform.position = new Vector3(0, positionY, 0);
+ }
+}
+```
+
+### Example 2: Using network time to create a synced event
+
+Most of the time aligning an effect precisely to time is not needed. But in some cases for important effects or gameplay events it can help to improve consistency especially for clients with bad network connections.
+
+```csharp
+using System.Collections;
+using Unity.Netcode;
+using UnityEngine;
+using UnityEngine.Assertions;
+
+public class SyncedEventExample : NetworkBehaviour
+{
+ public GameObject ParticleEffect;
+
+ // Called by the client to create a synced particle event at its own position.
+ public void ClientCreateSyncedEffect()
+ {
+ Assert.IsTrue(IsOwner);
+ var time = NetworkManager.LocalTime.Time;
+ CreateSyncedEffectServerRpc(time);
+ StartCoroutine(WaitAndSpawnSyncedEffect(0)); // Create the effect immediately locally.
+ }
+
+ private IEnumerator WaitAndSpawnSyncedEffect(float timeToWait)
+ {
+ // Note sometimes the timeToWait will be negative on the server or the receiving clients if a message got delayed by the network for a long time. This usually happens only in rare cases. Custom logic could be implemented to deal with that scenario.
+ if (timeToWait > 0)
+ {
+ yield return new WaitForSeconds(timeToWait);
+ }
+
+ Instantiate(ParticleEffect, transform.position, Quaternion.identity);
+ }
+
+ [ServerRpc]
+ private void CreateSyncedEffectServerRpc(double time)
+ {
+ CreateSyncedEffectClientRpc(time); // Call a client RPC to also create the effect on each client.
+ var timeToWait = time - NetworkManager.ServerTime.Time;
+ StartCoroutine(WaitAndSpawnSyncedEffect((float)timeToWait)); // Create the effect on the server but wait for the right time.
+ }
+
+ [ClientRpc]
+ private void CreateSyncedEffectClientRpc(double time)
+ {
+ // The owner already created the effect so skip them.
+ if (IsOwner == false)
+ {
+ var timeToWait = time - NetworkManager.ServerTime.Time;
+ StartCoroutine(WaitAndSpawnSyncedEffect((float)timeToWait)); // Create the effect on the client but wait for the right time.
+ }
+ }
+}
+```
+
+>Server: CreateSyncedEffectServerRpc
+ Server->>Receiver: CreateSyncedEffectClientRpc
+ Note over Server: ServerTime = 9.95 #38; timeToWait = 0.05
+ Note over Server: StartCoroutine(WaitAndSpawnSyncedEffect(0.05))
+ Server->>Server: WaitForSeconds(0.05);
+ Note over Server: Instantiate effect at ServerTime = 10.0
+ Note over Receiver: ServerTime = 9.93 #38; timeToWait = 0.07
+ Note over Receiver: StartCoroutine(WaitAndSpawnSyncedEffect(0.07))
+ Receiver->>Receiver: WaitForSeconds(0.07);
+ Note over Receiver: Instantiate effect at ServerTime = 10.0
+`}/>
+
+
+
+:::note
+Some components such as `NetworkTransform` add additional buffering. When trying to align an RPC event like in this example, an additional delay would need to be added.
+:::
+
+## Network Ticks
+
+Network ticks are run at a fixed rate. The 'Tick Rate' field on the `NetworkManager` can be used to set the tick rate.
+
+What does changing the network tick affect? Changes to `NetworkVariables` are not sent immediately. Instead during each network tick changes to `NetworkVariables` are collected and sent out to other peers.
+
+To run custom code once per network tick (before `NetworkVariable` changes are collected) the `Tick` event on the `NetworkTickSystem` can be used.
+```cs
+public override void OnNetworkSpawn()
+{
+ NetworkManager.NetworkTickSystem.Tick += Tick;
+}
+
+private void Tick()
+{
+ Debug.Log($"Tick: {NetworkManager.LocalTime.Tick}");
+}
+
+public override void OnNetworkDespawn() // don't forget to unsubscribe
+{
+ NetworkManager.NetworkTickSystem.Tick -= Tick;
+}
+```
+
+:::tip
+When using `FixedUpdate` or physics in your game, set the network tick rate to the same rate as the fixed update rate. The `FixedUpdate` rate can be changed in `Edit > Project Settings > Time > Fixed Timestep`
+:::
+
+## Network FixedTime
+
+`Network FixedTime` can be used to get a time value representing the time during a network tick. This works similar to `FixedUpdate` where `Time.fixedTime` represents the time during the `FixedUpdate`.
+
+```cs
+public void Update()
+{
+ double time = NetworkManager.Singleton.LocalTime.Time; // time during this Update
+ double fixedTime = NetworkManager.Singleton.LocalTime.FixedTime; // time during the previous network tick
+}
+```
+
+## NetworkTime Precision
+
+Network time values are calculated using double precisions. This allows time to stay accurate on long running servers. For game servers which run sessions for a long time (multiple hours or days) do not convert this value in a float and always use doubles for time related calculations.
+
+For games with short play sessions casting the time to float is safe or `TimeAsFloat` can be used.
+
+## NetworkTimeSystem Configuration
+
+:::caution
+The properties of the `NetworkTimeSystem` should be left untouched on the server/host. Changing the values on the client is sufficient to change the behavior of the time system.
+:::
+
+The way network time gets calculated can be configured in the `NetworkTimeSystem` if needed. See the API docs (TODO LINK) for information about the properties which can be modified. All properties can be safely adjusted at runtime. For instance buffer values could be increased for a player with a bad connection.
+
+
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/object-pooling.md b/versioned_docs/version-1.0.0/advanced-topics/object-pooling.md
new file mode 100644
index 000000000..cd4d6ffb3
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/object-pooling.md
@@ -0,0 +1,28 @@
+---
+id: object-pooling
+title: Object Pooling
+---
+
+Netcode for GameObjects (Netcode) provides built-in support for Object Pooling, which allows you to override the default Netcode destroy and spawn handlers with your own logic. This allows you to store destroyed network objects in a pool to reuse later. This is useful for frequently used objects, such as projectiles, and is a way to increase the application's overall performance. By pre-instantiating and reusing the instances of those objects, object pooling removes the need to create or destroy objects at runtime, which could save a lot of work for the CPU. This means that instead of creating or destroying the same object over and over again, it is simply deactivated after use, then, when another object is needed, the pool recycles one of the deactivated objects and reactivates it.
+
+See [Introduction to Object Pooling](https://learn.unity.com/tutorial/introduction-to-object-pooling) to learn more about the importance of pooling objects.
+
+## NetworkPrefabInstanceHandler
+
+You can register your own spawn handlers by including the `INetworkPrefabInstanceHandler` interface and registering with the `NetworkPrefabHandler`.
+```csharp
+ public interface INetworkPrefabInstanceHandler
+ {
+ NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation);
+ void Destroy(NetworkObject networkObject);
+ }
+```
+Netcode will use the `Instantiate` and `Destroy` methods in place of default spawn handlers for the `NetworkObject` used during spawning and despawning. Because the message to instantiate a new `NetworkObject` originates from a Host or Server, both will not have the Instantiate method invoked. All clients (excluding a Host) will have the instantiate method invoked if the `INetworkPrefabInstanceHandler` implementation is registered with `NetworkPrefabHandler` (`NetworkManager.PrefabHandler`) and a Host or Server spawns the registered/associated `NetworkObject`.
+
+The following example is from the Boss Room Sample. It shows how object pooling is used to handle the different projectile objects. In that example, the class `NetworkObjectPool` is the data structure containing the pooled objects and the class `PooledPrefabInstanceHandler` is the handler implementing `INetworkPrefabInstanceHandler`.
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/main/Assets/Scripts/Infrastructure/NetworkObjectPool.cs
+```
+
+Let's have a look at `NetworkObjectPool` first. `PooledPrefabsList` contains a list of prefabs to handle, with an initial number of instances to spawn for each. In the `Start` method, it initialises the different pools for each prefab as queues inside the `pooledObjects` dictionary. It also instantiates the handlers for each prefab and registers them. To use these objects, a user then needs to obtain it via the `GetNetworkObject` method before spawning it, then return the object to the pool after use with `ReturnNetworkObject` before despawning it. This only needs to be done on the server, as the `PooledPrefabInstanceHandler` will handle it on the client(s) when the network object's `Spawn` or `Despawn` method is called, via its `Instantiate` and `Destroy` methods. Inside those methods, the `PooledPrefabInstanceHandler` simply calls the pool to get the corresponding object, or to return it.
diff --git a/versioned_docs/version-1.0.0/advanced-topics/physics.md b/versioned_docs/version-1.0.0/advanced-topics/physics.md
new file mode 100644
index 000000000..7533304fa
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/physics.md
@@ -0,0 +1,33 @@
+---
+id: physics
+title: Physics
+Description: Brief explanation on using Physics in Netcode for GameObjects
+---
+
+There are many different ways to do physics in multiplayer games. Netcode for GameObjects (Netcode) has a built in approach which allows for server authoritative physics where the physics simulation is only run on the server. To enable network physics add a `NetworkRigidbody` component to your object.
+
+## NetworkRigidbody
+
+`NetworkRigidbody` is a component which sets the `Rigidbody` of the `GameObject` into kinematic mode on every peer except the server. That way a realistic physics simulation can be run on the server and the resulting positions can be synchronized to the clients without any interference.
+
+To use `NetworkRigidbody` add a `Rigidbody`, `NetworkTransform` and `NetworkRigidbody` component to your `NetworkObject`.
+
+Some collision events are not fired when using `NetworkRigidbody`.
+- On the `server` all collision and trigger events (such as OnCollisionEnter) will fire as expected and you can access / modify values of the `Rigidbody` such as velocity.
+- On the `clients` the rigidbody will be kinematic. Trigger events will still be fired but collision events will not be fired when colliding with other networked rigidbodies.
+
+:::tip
+If there is a need for a gameplay event to happen on a collision you can listen to `OnCollisionEnter` function on the server and synchronize the event via ClientRpc to all clients.
+:::
+
+## NetworkRigidbody2D
+
+`NetworkRigidbody2D` works in the same way as `NetworkRigidbody` but for 2d physics (`Rigidbody2D`) instead.
+
+## NetworkRigidbody & ClientNetworkTransform
+
+`NetworkRigidbody` can be used in combination with the [ClientNetworkTransform](../components/networktransform.md#clientnetworktransform) package sample to allow the owner client of a `NetworkObject` to move it authoritatively. In this mode collisions will only result in realistic dynamic collisions if the object is colliding with other `NetworkObjects` which are owned by the same client.
+
+:::note
+Add the `ClientNetworkTransform` component first to your `GameObject` else the `NetworkRigidbody` will automatically add a regular `NetworkTransform`.
+:::
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/reconnecting-mid-game.md b/versioned_docs/version-1.0.0/advanced-topics/reconnecting-mid-game.md
new file mode 100644
index 000000000..783df14cc
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/reconnecting-mid-game.md
@@ -0,0 +1,57 @@
+---
+id: reconnecting-mid-game
+title: Reconnecting Mid-Game
+---
+
+In a multiplayer game, clients may get disconnected from the server for a variety of reasons (network issues, application/device crashes, etc). For those reasons, you may want to allow your players to reconnect to the game.
+
+## Considerations
+
+Review the following considerations before allowing clients to reconnect in the middle of an active game:
+
+- Clients may have specific state and in-game data associated with them. If you want them to reconnect with that same state and data, implement a mechanism to maintain the association of state and data with the client for when they reconnect. See [Session Management](session-management.md) for more information.
+- Depending on your game's requirements, make sure the client's state is properly reset and ready to connect before attempting reconnection. This may require resetting some external services.
+- When using [scene management](../basics/scenemanagement/scene-management-overview.md) and multiple additive scenes, there is a specific case to keep in mind. During the synchronization process, which launches when connecting to a game, if the client's active main scene is the same as the server's, it will not initiate a scene load in single mode for that scene. Instead, it will load all additive scenes that are currently loaded on the server. This means that if the client has additive scenes currently loaded, it will not unload them like it would if the client's main scene was different than the server's.
+ - For example, if during a game, the server loads **main scene A**, then additively loads scenes **B** and **C**, the client has all three loaded. If the client disconnects and reconnects without changing scenes, the scene synchronization process recognizes that **main scene A** is already loaded on the client, and then simply proceeds to load the server's additive scenes. In that case, the client loads the scenes **B** and **C** a second time and then has two copies of those scenes loaded.
+
+ However, if, while the client is disconnected, the server loads or unloads a scene additively, there is also a mismatch between the scenes loaded on the client and on the server. For example, if the server unloads scene **C** and loads scene **D**, the client loads scene **D** when synchronizing, but doesn't unload scene C, so the client has loaded scenes **A**, **B** (twice), **C**, and **D**, while the server only has loaded scenes **A**, **B**, and **D**.
+ - If you want to avoid this behavior, you can
+ - Load a different scene in single mode on the client when disconnecting
+ - Unload additive scenes on the client when disconnecting
+ - Unload additive scenes on the client when reconnecting
+ - Use the `NetworkSceneManager.VerifySceneBeforeLoading` callback to prevent loading scenes already loaded on the client. However, this will not handle unloading scenes that were unloaded by the server between the time the client disconnected and reconnected.
+
+
+## Automatic reconnection
+
+For a smoother experience for your players, clients can automatically attempt to reconnect to a game when connection is lost unexpectedly.
+
+To implement automatic reconnection:
+- Define what will trigger the reconnection process and when it will start.
+ - For example, you can use the `NetworkManager.OnClientDisconnectCallback` callback, or some other unique event depending on your game.
+- Ensure the `NetworkManager` properly shuts down before attempting any reconnection.
+ - You can use the `NetworkManager.ShutdownInProgress` property to manage this.
+- Add additional checks to ensure automatic reconnection does not trigger under the wrong conditions.
+ - Examples
+ - A client purposefully quits a game
+ - The server shuts down as expected when the game session ends
+ - A client gets kicked from a game
+ - A client is denied during connection approval
+
+Depending on your game, you may want to add the following features as well:
+- Include multiple reconnection attempts in case of failure. You need to define how many attempts these should be, ensure that `NetworkManager` properly shuts down between each attempt, and reset the client's state (if needed).
+- Provide an option for players to cancel the reconnection process. This may be useful when there are a lot of reconnection attempts or when each attempt lasts a long duration.
+
+### Automatic reconnection example
+
+Check out our [Boss Room sample](../learn/bossroom/getting-started-boss-room.md) for an example implementation of automatic reconnection.
+
+The entry point for this feature is in [this class](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/main/Assets/Scripts/ConnectionManagement/ConnectionState/ClientReconnectingState.cs). Boss Room's implementation uses a state inside a state machine that starts a coroutine on entering it (`ReconnectCoroutine`) that attempts to reconnect a few times sequentially, until it either succeeds, surpasses the defined maximum number of attempts, or is cancelled. (See `OnClientConnected`, `OnClientDisconnect`, `OnDisconnectReasonReceived`, and `OnUserRequestedShutdown`)
+
+The reconnecting state is entered when a client disconnects unexpectedly. (See `OnClientDisconnect` in [this class](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/main/Assets/Scripts/ConnectionManagement/ConnectionState/ClientConnectedState.cs))
+
+:::note
+This sample connects with [Lobby](https://docs.unity.com/lobby/unity-lobby-service-overview.html) and [Relay](https://docs.unity.com/relay/get-started.html) services, so the client must make sure it has properly left the lobby before each reconnection attempt.
+
+For more information about how Boss Room leverages Lobby and Relay, see [Getting Started with Boss Room](../learn/bossroom/getting-started-boss-room.md#register-the-project-with-unity-gaming-services-ugs)
+:::
diff --git a/versioned_docs/version-1.0.0/advanced-topics/serialization/cprimatives.md b/versioned_docs/version-1.0.0/advanced-topics/serialization/cprimatives.md
new file mode 100644
index 000000000..1b98df5d6
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/serialization/cprimatives.md
@@ -0,0 +1,19 @@
+---
+id: cprimitives
+title: C# Primitives
+---
+
+C# Primitive types will be serialized by built-in serialization code. These types include `bool`, `char`, `sbyte`, `byte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, and `string`.
+
+```csharp
+[ServerRpc]
+void FooServerRpc(int somenumber, string sometext) { /* ... */ }
+
+void Update()
+{
+ if (Input.GetKeyDown(KeyCode.P))
+ {
+ FooServerRpc(Time.frameCount, "hello, world"); // Client -> Server
+ }
+}
+```
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/serialization/enum-types.md b/versioned_docs/version-1.0.0/advanced-topics/serialization/enum-types.md
new file mode 100644
index 000000000..2d4cb3bc0
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/serialization/enum-types.md
@@ -0,0 +1,33 @@
+---
+id: enum_types
+title: Enum Types
+---
+
+A user-defined enum type will be serialized by built-in serialization code (with underlying integer type).
+
+```csharp
+enum SmallEnum : byte
+{
+ A,
+ B,
+ C
+}
+
+enum NormalEnum // default -> int
+{
+ X,
+ Y,
+ Z
+}
+
+[ServerRpc]
+void ConfigServerRpc(SmallEnum smallEnum, NormalEnum normalEnum) { /* ... */ }
+
+void Update()
+{
+ if (Input.GetKeyDown(KeyCode.P))
+ {
+ ConfigServerRpc(SmallEnum.A, NormalEnum.X); // Client -> Server
+ }
+}
+```
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/serialization/inetworkserializable.md b/versioned_docs/version-1.0.0/advanced-topics/serialization/inetworkserializable.md
new file mode 100644
index 000000000..ddee8297b
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/serialization/inetworkserializable.md
@@ -0,0 +1,241 @@
+---
+id: inetworkserializable
+title: INetworkSerializable
+sidebar_label: INetworkSerializable
+---
+
+The `INetworkSerializable` interface can be used to define custom serializable types.
+
+:::caution
+All examples provided will work with RPCs and custom messages but some examples will not work with `NetworkVariable` due to the unmanaged type restriction.
+**NetworkVariable Type Litmus Test for INetworkSerializable Implementations:**
+- If the implementation itself can be a null (i.e. a class), then it cannot be used
+- If it contains any property that can be null (i.e. arrays), then it cannot be used
+
+The alternative is to create your own `NetworkVariableBase` derived `type` specific class.
+:::
+
+```csharp
+struct MyComplexStruct : INetworkSerializable
+{
+ public Vector3 Position;
+ public Quaternion Rotation;
+
+ // INetworkSerializable
+ void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
+ {
+ serializer.SerializeValue(ref Position);
+ serializer.SerializeValue(ref Rotation);
+ }
+ // ~INetworkSerializable
+}
+```
+
+Types implementing `INetworkSerializable` are supported by `NetworkSerializer`, `RPC`s and `NetworkVariable`s.
+
+```csharp
+
+[ServerRpc]
+void MyServerRpc(MyComplexStruct myStruct) { /* ... */ }
+
+void Update()
+{
+ if (Input.GetKeyDown(KeyCode.P))
+ {
+ MyServerRpc(
+ new MyComplexStruct
+ {
+ Position = transform.position,
+ Rotation = transform.rotation
+ }); // Client -> Server
+ }
+}
+```
+
+## Nested serial types
+
+Nested serial types will be `null` unless you initialize following one of these methods:
+
+* Manually before calling `SerializeValue` if `serializer.IsReader` (or something like that)
+* Initialize in the default constructor
+
+This is by design. You may see the values as null until properly initialized. The serializer is not deserializing them, the `null` value is simply applied before it can be serialized.
+
+## Conditional Serialization
+
+As you have more control over serialization of a struct, you might implement conditional serialization at runtime.
+
+More advanced use-cases are explored in following examples.
+
+### Example: Array
+:::caution
+The below `INetworkSerializable` implementation example works only with RPCs and/or custom messages. The below implementation uses an array within an `INetworkSerializable` implementation. Arrays can be `null` and are not supported by the `NetworkVariable` class. As an alternative, you can write your own `NetworkVariableBase` derived class that does support managed or unmanaged value types.
+[Read More About Custom NetworkVariable Implementations](../../basics/networkvariable.md)
+:::
+
+```csharp
+public struct MyCustomStruct : INetworkSerializable
+{
+ public int[] Array;
+
+ public void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
+ {
+ // Length
+ int length = 0;
+ if (!serializer.IsReader)
+ {
+ length = Array.Length;
+ }
+
+ serializer.SerializeValue(ref length);
+
+ // Array
+ if (serializer.IsReader)
+ {
+ Array = new int[length];
+ }
+
+ for (int n = 0; n < length; ++n)
+ {
+ serializer.SerializeValue(ref Array[n]);
+ }
+ }
+}
+```
+
+**Reading:**
+
+- (De)serialize `length` back from the stream
+- Iterate over `Array` member `n=length` times
+- (De)serialize value back into Array[n] element from the stream
+
+
+**Writing:**
+
+- Serialize length=Array.Length into stream
+- Iterate over Array member n=length times
+- Serialize value from Array[n] element into the stream
+
+
+The `BufferSerializer.IsReader` flag is being utilized here to determine whether or not to set `length` value to prepare before writing into the stream — we then use it to determine whether or not to create a new `int[]` instance with `length` size to set `Array` before reading values from the stream. There's also an equivalent but opposite `BufferSerializer.IsWriting`
+
+
+### Example: Move
+
+```csharp
+
+public struct MyMoveStruct : INetworkSerializable
+{
+ public Vector3 Position;
+ public Quaternion Rotation;
+
+ public bool SyncVelocity;
+ public Vector3 LinearVelocity;
+ public Vector3 AngularVelocity;
+
+ void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
+ {
+ // Position & Rotation
+ serializer.SerializeValue(ref Position);
+ serializer.SerializeValue(ref Rotation);
+
+ // LinearVelocity & AngularVelocity
+ serializer.SerializeValue(ref SyncVelocity);
+ if (SyncVelocity)
+ {
+ serializer.SerializeValue(ref LinearVelocity);
+ serializer.SerializeValue(ref AngularVelocity);
+ }
+ }
+}
+```
+
+**Reading:**
+
+- (De)serialize `Position` back from the stream
+- (De)serialize `Rotation` back from the stream
+- (De)serialize `SyncVelocity` back from the stream
+- Check if `SyncVelocity` is set to true, if so:
+ - (De)serialize `LinearVelocity` back from the stream
+ - (De)serialize `AngularVelocity` back from the stream
+
+**Writing:**
+
+- Serialize `Position` into the stream
+- Serialize `Rotation` into the stream
+- Serialize `SyncVelocity` into the stream
+- Check if `SyncVelocity` is set to true, if so:
+ - Serialize `LinearVelocity` into the stream
+ - Serialize `AngularVelocity` into the stream
+
+Unlike the [Array](#example-array) example above, in this example we do not use `BufferSerializer.IsReader` flag to change serialization logic but to change the value of a serialized flag itself.
+
+- If the `SyncVelocity` flag is set to true, both the `LinearVelocity` and `AngularVelocity` will be serialized into the stream
+- When the `SyncVelocity` flag is set to `false`, we will leave `LinearVelocity` and `AngularVelocity` with default values.
+
+## Recursive Nested Serialization
+
+It is possible to recursively serialize nested members with `INetworkSerializable` interface down in the hierarchy tree.
+
+Review the following example:
+
+```csharp
+
+public struct MyStructA : INetworkSerializable
+{
+ public Vector3 Position;
+ public Quaternion Rotation;
+
+ void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
+ {
+ serializer.SerializeValue(ref Position);
+ serializer.SerializeValue(ref Rotation);
+ }
+}
+
+public struct MyStructB : INetworkSerializable
+{
+ public int SomeNumber;
+ public string SomeText;
+ public MyStructA StructA;
+
+ void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
+ {
+ serializer.SerializeValue(ref SomeNumber);
+ serializer.SerializeValue(ref SomeText);
+ StructA.NetworkSerialize(serializer);
+ }
+}
+```
+If we were to serialize `MyStructA` alone, it would serialize `Position` and `Rotation` into the stream using `NetworkSerializer`.
+
+However, if we were to serialize `MyStructB`, it would serialize `SomeNumber` and `SomeText` into the stream, then serialize `StructA` by calling `MyStructA`'s `void NetworkSerialize(NetworkSerializer)` method, which serializes `Position` and `Rotation` into the same stream.
+
+:::note
+Technically, there is no hard-limit on how many `INetworkSerializable` fields you can serialize down the tree hierarchy. In practice, consider memory and bandwidth boundaries for best performance.
+:::
+
+:::tip
+You can conditionally serialize in recursive nested serialization scenario and make use of both features.
+:::
+
+:::caution
+While you can have nested `INetworkSerializable` implementations (i.e. an `INetworkSerializable` implementation with `INetworkSerializable` implementations as properties) like demonstrated in the example above, you cannot have derived children of an `INetworkSerializable` implementation.
+**Unsupported Example**
+```csharp
+/// This is not supported.
+public struct MyStructB : MyStructA
+{
+ public int SomeNumber;
+ public string SomeText;
+
+ void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
+ {
+ serializer.SerializeValue(ref SomeNumber);
+ serializer.SerializeValue(ref SomeText);
+ serializer.SerializeValue(ref Position);
+ serializer.SerializeValue(ref Rotation);
+ }
+}
+```
+:::
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/serialization/networkobject-serialization.md b/versioned_docs/version-1.0.0/advanced-topics/serialization/networkobject-serialization.md
new file mode 100644
index 000000000..921ff57a9
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/serialization/networkobject-serialization.md
@@ -0,0 +1,95 @@
+---
+id: networkobject-serialization
+title: NetworkObject & NetworkBehaviour
+description: Brief explanation on using NetworkObject & NetworkBehaviour in Network for GameObjects
+---
+
+`GameObjects`, `NetworkObjects` and `NetworkBehaviour` are not serializable types so they cannot be used in `RPCs` or `NetworkVariables` by default.
+
+There are two convenience wrappers which can be used to send a reference to a `NetworkObject` or a `NetworkBehaviour` over RPCs or `NetworkVariables`.
+
+## NetworkObjectReference
+
+`NetworkObjectReference` can be used to serialize a reference to a `NetworkObject`. It can only be used on already spawned `NetworkObjects`.
+
+Here is an example of using `NetworkObject` reference to send a target `NetworkObject` over an RPC:
+```csharp
+public class Weapon : NetworkBehaviour
+{
+ public void ShootTarget(GameObject target)
+ {
+ var targetObject = target.GetComponent();
+ ShootTargetServerRpc(targetObject);
+ }
+
+ [ServerRpc]
+ public void ShootTargetServerRpc(NetworkObjectReference target)
+ {
+ if (target.TryGet(out NetworkObject targetObject))
+ {
+ // deal damage or something to target object.
+ }
+ else
+ {
+ // Target not found on server, likely because it already has been destroyed/despawned.
+ }
+ }
+}
+```
+
+### Implicit Operators
+
+There are also implicit operators which convert from/to `NetworkObject/GameObject` which can be used to simplify code. For instance the above example can also be written in the following way:
+```csharp
+public class Weapon : NetworkBehaviour
+{
+ public void ShootTarget(GameObject target)
+ {
+ ShootTargetServerRpc(target);
+ }
+
+ [ServerRpc]
+ public void ShootTargetServerRpc(NetworkObjectReference target)
+ {
+ NetworkObject targetObject = target;
+ }
+}
+```
+:::note
+The implicit conversion to `NetworkObject` / `GameObject` will result in `Null` if the reference can not be found.
+:::
+
+## NetworkBehaviourReference
+
+`NetworkBehaviourReference` works similar to `NetworkObjectReference` but is used to reference a specific `NetworkBehaviour` component on a spawned `NetworkObject`.
+
+```cs
+public class Health : NetworkBehaviour
+{
+ public NetworkVariable Health = new NetworkVariable();
+}
+
+public class Weapon : NetworkBehaviour
+{
+ public void ShootTarget(GameObject target)
+ {
+ var health = target.GetComponent();
+ ShootTargetServerRpc(health, 10);
+ }
+
+ [ServerRpc]
+ public void ShootTargetServerRpc(NetworkBehaviourReference health, int damage)
+ {
+ if (health.TryGet(out Health healthComponent))
+ {
+ healthComponent.Health.Value -= damage;
+ }
+ }
+}
+```
+
+## How NetworkObjectReference & NetworkBehaviourReference work
+
+`NetworkObjectReference` and `NetworkBehaviourReference` are convenience wrappers which serialize the id of a `NetworkObject` when being sent and on the receiving end retrieve the corresponding ` ` with that id. `NetworkBehaviourReference` sends an additional index which is used to find the right `NetworkBehaviour` on the `NetworkObject`.
+
+Both of them are structs implementing the `INetworkSerializable` interface.
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/serialization/serialization-arrays.md b/versioned_docs/version-1.0.0/advanced-topics/serialization/serialization-arrays.md
new file mode 100644
index 000000000..a265e0c65
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/serialization/serialization-arrays.md
@@ -0,0 +1,44 @@
+---
+id: arrays
+title: Arrays
+---
+
+Arrays of [C# primitive types](cprimatives.md), like `int[]`, and [Unity primitive types](unity-primatives.md), such as `Vector3`, are serialized by built-in serialization code. Otherwise, any array of types that are not handled by the built-in serialization code, such as `string[]`, needs to be handled through a container class or structure that implements the [`INetworkSerializable`](inetworkserializable.md) interface.
+
+### Built-In Primitive Types Example
+Using built-in primitive types is fairly straight forward:
+```csharp
+[ServerRpc]
+void HelloServerRpc(int[] scores, Color[] colors) { /* ... */ }
+```
+
+### INetworkSerializable Implementation Example
+There are many ways to handle sending an array of managed types.
+The below example is a simple `string` container class that implements `INetworkSerializable` and can be used as an array of "StringContainers":
+```csharp
+[ClientRpc]
+void SendMessagesClientRpc(StringContainer[] messages)
+{
+ foreach (var stringContainer in stringContainers)
+ {
+ Debug.Log($"{stringContainer.SomeText}");
+ }
+}
+
+public class StringContainer : INetworkSerializable
+{
+ public string SomeText;
+ public void NetworkSerialize(BufferSerializer serializer) where T : IReaderWriter
+ {
+ if (serializer.IsWriter)
+ {
+ serializer.GetFastBufferWriter().WriteValueSafe(SomeText);
+ }
+ else
+ {
+ serializer.GetFastBufferReader().ReadValueSafe(out SomeText);
+ }
+ }
+}
+```
+
diff --git a/versioned_docs/version-1.0.0/advanced-topics/serialization/serialization-intro.md b/versioned_docs/version-1.0.0/advanced-topics/serialization/serialization-intro.md
new file mode 100644
index 000000000..271dd10ba
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/serialization/serialization-intro.md
@@ -0,0 +1,14 @@
+---
+id: serialization-intro
+title: About Serialization
+---
+Multiplayer framework has built-in serialization support for C# and Unity primitive types out-of-the-box, also with ability to further extend network serialization for user defined types implementing `INetworkSerializable` interface.
+
+See the following sections:
+
+* [C# Primitives](cprimatives.md)
+* [Unity Primitives](unity-primatives.md)
+* [Enum Types](enum-types.md)
+* [Arrays](serialization-arrays.md)
+* [INetworkSerializable](inetworkserializable.md)
+* [NetworkObjects & NetworkBehaviours](networkobject-serialization.md)
diff --git a/versioned_docs/version-1.0.0/advanced-topics/serialization/unity-primatives.md b/versioned_docs/version-1.0.0/advanced-topics/serialization/unity-primatives.md
new file mode 100644
index 000000000..acd3d7e3b
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/serialization/unity-primatives.md
@@ -0,0 +1,19 @@
+---
+id: unity-primitives
+title: Unity Primitives
+---
+
+Unity Primitive `Color`, `Color32`, `Vector2`, `Vector3`, `Vector4`, `Quaternion`, `Ray`, `Ray2D` types will be serialized by built-in serialization code.
+
+```csharp
+[ClientRpc]
+void BarClientRpc(Color somecolor) { /* ... */ }
+
+void Update()
+{
+ if (Input.GetKeyDown(KeyCode.P))
+ {
+ BarClientRpc(Color.red); // Server -> Client
+ }
+}
+```
\ No newline at end of file
diff --git a/versioned_docs/version-1.0.0/advanced-topics/session-management.md b/versioned_docs/version-1.0.0/advanced-topics/session-management.md
new file mode 100644
index 000000000..c642fce71
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/session-management.md
@@ -0,0 +1,41 @@
+---
+id: session-management
+title: Session Management
+---
+
+You can use session management to ensure that when a player disconnects, some data is kept and accurately assigned back to that player when they reconnect.
+
+## Linking data to players
+
+To reassign data to the right player when they reconnect, we need to link this data to the player.
+
+The **clientId** generated by Netcode for GameObjects (Netcode) cannot be used, because it generates when a player connects and is disposed of when they disconnect. That ID may then be assigned to a different player if they connect to the server after the first one disconnected.
+
+To properly link data to a specific player, we need an ID that is not tied to the current connection, but persists through time and is unique to that player. Some options include
+* A login system with unique player accounts
+* A Globally Unique Identifier (GUID). For example, a GUID generated via `System.Guid.NewGuid()` and then saved to the `PlayerPrefs` client side.
+
+With this unique identifier, we can map each player's data that is needed when reconnecting, such as the current state of their character (last known position, health, etc). We then ensure this data is up to date and kept host side after a player disconnects to properly repopulate that player's data when they reconnect.
+
+You can also decide to clear all data when a session completes or add a timeout to purge the data after a specific amount of time.
+
+## Reconnection
+
+Reconnecting players depends on your game. For example, if we use a [Player Object](../basics/networkobject.md#player-objects), a new `Default Player Prefab` automatically spawns when any player connects to the game (including when they reconnect). You can then use the player's previously saved session data to update that object so that its state returns to what it was before disconnecting. In those cases, we would need to keep all the important data that we want to restore and map it to the player using our identification system. This data could be saved when a player disconnects, or updated periodically. We can then use the `OnNetworkSpawn` event on the Player Object's `NetworkBehavior`(s) to obtain this data and apply it where needed.
+
+In cases where we don't use the Player Object approach and instead manually attribute client ownership to `NetworkObject`(s), we could keep the objects that a player owns when they disconnect, and set the reconnected player as their new owner. To accomplish this, the only data we would need to keep would be the mapping between those objects and their owning player's identifier, then when a player reconnects we could use this mapping to set them as the new owner. This mapping can be as simple as a dictionary mapping the player identifier with the `NetworkObjectId`(s) of the `NetworkObject`(s) they own. Then, in the `OnClientConnectedCallback` from the `NetworkManager`, the server could set the ownership of these objects.
+
+## Example using the Player Object approach
+Here is an example from the Boss Room sample, showing some simple session management. The game uses the Player Object approach and a GUID to identify unique players.
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/main/Packages/com.unity.multiplayer.samples.coop/Utilities/Net/SessionManager.cs
+```
+
+This class allows BossRoom to handle player session data, represented by a struct `T` implementing the `ISessionPlayerData` interface, by providing mechanisms to initialize, obtain and edit that data, and to associate it to a specific player. It also handles the clearing of data that is no longer used and the reinitialization of data between sessions.
+
+In this case, since game sessions are quite short, the session data is only cleared for disconnected players when a session ends, or if a player leaves before a session starts. This makes sure that if a player disconnects during a session and then reconnects during the next session, the game properly treats it as a new connection. The definition of when a session ends and when a session starts might vary from game to game, but in BossRoom a session is considered to start after character selection and end when the players win or loose the game and enter the post-game scene. In other cases, one might want to add a timeout to session data and clear it after a specified time instead.
+
+This code is in Boss Room's utilities package so it can be easily reused. You can add this package via the `Package Manager` window in the Unity Editor by selecting `add from Git URL` and adding the following URL: "https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop.git?path=/Packages/com.unity.multiplayer.samples.coop#main"
+
+Or you can directly add this line to your `manifest.json` file: "com.unity.multiplayer.samples.coop": "https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop.git?path=/Packages/com.unity.multiplayer.samples.coop#main"
diff --git a/versioned_docs/version-1.0.0/advanced-topics/transports.md b/versioned_docs/version-1.0.0/advanced-topics/transports.md
new file mode 100644
index 000000000..7db696fe7
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/transports.md
@@ -0,0 +1,35 @@
+---
+id: transports
+title: Transports
+description: A transport collects messages from your application and transmits them safely over the network. It ensures that all packets arrive and in order, if needed.
+---
+
+Unity Netcode for GameObjects (Netcode) uses Unity Transport by default and supports UNet Transport (deprecated) up to Unity 2022.2 version.
+
+## So what is a transport layer?
+
+The transport layer establishes communication between your application and different hosts in a network.
+
+A transport layer can provide:
+* *Connection-oriented communication* to ensure a robust connection before exchanging data with a handshake protocol.
+* *Maintain order delivery* for your packets to fix any discrepancies from the network layer in case of packet drops or device interruption.
+* *Ensure data integrity* by requesting retransmission of missing or corrupted data through using checksums.
+* *Control the data flow* in a network connection to avoid buffer overflow or underflow--causing unnecessary network performance issues.
+* *Manage network congestion* by mediating flow rates and node overloads.
+* *Adjust data streams* to transmit as byte streams or packets.
+
+## Unity Transport Package (UTP)
+
+Netcode's default transport Unity Transport (UTP) is an entire transport layer that you can use to add multiplayer and network features to your project with or without Netcode. See the Transport [documentation](../../../transport/current/about) for more information and how to [install](../../../transport/current/install).
+
+## Unity’s UNet Transport Layer API
+
+UNet is a deprecated solution that is no longer supported after Unity 2022.2. Unity Transport Package (UTP) is the default transport for Netcode for GameObjects. We recommend transitioning to UTP as soon as possible.
+
+### Community Transports or Writing Your Own
+
+You can use any of the community contributed custom transport implementations or write your own.
+
+The community transports are interchangeable transport layers for Netcode and can be installed with the Unity Package Manager. After installation, the transport package will appear in the **Select Transport** dropdown of the `NetworkManager`. Check out the [Netcode community contributed transports](https://github.com/Unity-Technologies/multiplayer-community-contributions/tree/main/Transports) for more information.
+
+To start writing your own and contributing to the community, check out the [Netcode community contribution repository](https://github.com/Unity-Technologies/multiplayer-community-contributions) for starting points and how to add your content.
diff --git a/versioned_docs/version-1.0.0/advanced-topics/ways-to-synchronize.md b/versioned_docs/version-1.0.0/advanced-topics/ways-to-synchronize.md
new file mode 100644
index 000000000..e497592d9
--- /dev/null
+++ b/versioned_docs/version-1.0.0/advanced-topics/ways-to-synchronize.md
@@ -0,0 +1,38 @@
+---
+id: ways-synchronize
+title: Synchronizing States & Events
+---
+
+## Introduction
+Netcode for GameObjects (Netcode) includes three options for synchronizing game states and/or events:
+- Messaging System
+ - Remote Procedure Calls (RPCs)
+ - Custom Messages
+- NetworkVariables
+ - Handled by the "internal" messaging system and [categorized under "Networking".](../basics/networkvariable.md)
+
+While each of the above options can be used for the same thing, synchronizing states or events, they all have specific use cases and limitations.
+
+## Messaging System
+The Netcode messaging system provides you with the ability to handle sending and receiving messages or events. The entire messaging system supports the serialization of most primitive value `type`s as well as any classes and/or structures that implement the `INetworkSerializable` interface.
+
+### Remote Procedure Calls
+RPCs can be viewed as a way to send an event notification as well as a way to handle direct communication between a server and a client (or vice versa). This is sometimes useful when the ownership scope of the `NetworkBehavior`, that the remote procedure call is declared within, belongs to the server but you still want one or more clients to be able to communicate with the associated `NetworkObject`.
+**Some Usage Examples:**
+- A ServerRpc could be used by a client to notify the server that the player is trying to use a world object (i.e. a door, a vehicle, etc.)
+- A ClientRpc could be used by a server to notify a specific client of a special reconnection key or some other player specific information that doesn't require its state to be synchronized with all current and any future late joining client(s).
+
+**The are two types of RPC methods:**
+- **ServerRpc:** A client invoked remote procedure call received by and executed on the server-side.
+ - [Read More About ServerRpc](../advanced-topics/message-system/serverrpc.md)
+- **ClientRpc:** A server invoked remote procedure call received by and executed on one or more clients.
+ - [Read More About ClientRpc](../advanced-topics/message-system/clientrpc.md)
+
+### Custom Messages
+Custom messages provide you with the ability to create your own "netcode message type" to handle scenarios where you might just need to create your own custom message.
+[Read More About Custom Messages](../advanced-topics/message-system/custom-messages.md)
+
+## NetworkVariable System
+A NetworkVariable is most commonly used to synchronize state between both connected and late joining clients. The `NetworkVariable` system only supports non-nullable value `type`s, but also provides support for `INetworkSerializable` implementations as well you can create your own `NetworkVariable` class by deriving from the `NetworkVariableBase` abstract class. If you want something to always be synchronized with current and late-joining clients, then it is likely a good `NetworkVariable` candidate.
+
+[Read More About NetworkVariable](../basics/networkvariable.md)
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.Arithmetic.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.Arithmetic.md
new file mode 100644
index 000000000..3780e6a0d
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.Arithmetic.md
@@ -0,0 +1,187 @@
+---
+id: Unity.Netcode.Arithmetic
+title: Unity.Netcode.Arithmetic
+---
+
+# Class Arithmetic
+
+
+Arithmetic helper class
+
+
+
+
+
+
+
+##### Inheritance
+
+
+System.Object
+
+
+
+
+Arithmetic
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.Object.Equals(System.Object)
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetHashCode()
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.MemberwiseClone()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+System.Object.ToString()
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public static class Arithmetic
+```
+
+
+
+### Methods
+
+#### VarIntSize(UInt64)
+
+
+Gets the output size in bytes after VarInting a unsigned integer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int VarIntSize(ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|-------|------------------------------------------|
+| System.UInt64 | value | The unsigned integer whose length to get |
+
+##### Returns
+
+| Type | Description |
+|--------------|---------------------|
+| System.Int32 | The amount of bytes |
+
+#### ZigZagDecode(UInt64)
+
+
+Decides a ZigZag encoded integer back to a signed integer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static long ZigZagDecode(ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|-------|----------------------|
+| System.UInt64 | value | The unsigned integer |
+
+##### Returns
+
+| Type | Description |
+|--------------|-----------------------------------|
+| System.Int64 | The signed version of the integer |
+
+#### ZigZagEncode(Int64)
+
+
+ZigZag encodes a signed integer and maps it to a unsigned integer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static ulong ZigZagEncode(long value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------|------------------------------|
+| System.Int64 | value | The signed integer to encode |
+
+##### Returns
+
+| Type | Description |
+|---------------|-----------------------------------------|
+| System.UInt64 | A ZigZag encoded version of the integer |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.BitCounter.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.BitCounter.md
new file mode 100644
index 000000000..a7d1fa7a6
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.BitCounter.md
@@ -0,0 +1,219 @@
+---
+id: Unity.Netcode.BitCounter
+title: Unity.Netcode.BitCounter
+---
+
+# Class BitCounter
+
+
+Utility class to count the number of bytes or bits needed to serialize a
+value.
+
+
+
+
+
+
+
+##### Inheritance
+
+
+System.Object
+
+
+
+
+BitCounter
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.Object.Equals(System.Object)
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetHashCode()
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.MemberwiseClone()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+System.Object.ToString()
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public static class BitCounter
+```
+
+
+
+### Methods
+
+#### GetUsedBitCount(UInt32)
+
+
+Get the minimum number of bits required to represent the given value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetUsedBitCount(uint value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|-------|-------------|
+| System.UInt32 | value | The value |
+
+##### Returns
+
+| Type | Description |
+|--------------|-----------------------------|
+| System.Int32 | The number of bits required |
+
+#### GetUsedBitCount(UInt64)
+
+
+Get the minimum number of bits required to represent the given value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetUsedBitCount(ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|-------|-------------|
+| System.UInt64 | value | The value |
+
+##### Returns
+
+| Type | Description |
+|--------------|-----------------------------|
+| System.Int32 | The number of bits required |
+
+#### GetUsedByteCount(UInt32)
+
+
+Get the minimum number of bytes required to represent the given value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetUsedByteCount(uint value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|-------|-------------|
+| System.UInt32 | value | The value |
+
+##### Returns
+
+| Type | Description |
+|--------------|------------------------------|
+| System.Int32 | The number of bytes required |
+
+#### GetUsedByteCount(UInt64)
+
+
+Get the minimum number of bytes required to represent the given value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetUsedByteCount(ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|-------|-------------|
+| System.UInt64 | value | The value |
+
+##### Returns
+
+| Type | Description |
+|--------------|------------------------------|
+| System.Int32 | The number of bytes required |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.BitReader.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.BitReader.md
new file mode 100644
index 000000000..3773af45f
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.BitReader.md
@@ -0,0 +1,235 @@
+---
+id: Unity.Netcode.BitReader
+title: Unity.Netcode.BitReader
+---
+
+# Struct BitReader
+
+
+Helper class for doing bitwise reads for a FastBufferReader. Ensures all
+bitwise reads end on proper byte alignment so FastBufferReader doesn't
+have to be concerned with misaligned reads.
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public ref struct BitReader
+```
+
+
+
+### Properties
+
+#### BitAligned
+
+
+Whether or not the current BitPosition is evenly divisible by 8. I.e.
+whether or not the BitPosition is at a byte boundary.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly bool BitAligned { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+### Methods
+
+#### Dispose()
+
+
+Pads the read bit count to byte alignment and commits the read back to
+the reader
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void Dispose()
+```
+
+
+
+#### ReadBit(out Boolean)
+
+
+Read a single bit from the buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadBit(out bool bit)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|------|-------------------------------------------------------------|
+| System.Boolean | bit | Out value of the bit. True represents 1, False represents 0 |
+
+#### ReadBits(out Byte, UInt32)
+
+
+Read bits from stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadBits(out byte value, uint bitCount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|----------|---------------------------|
+| System.Byte | value | Value to store bits into. |
+| System.UInt32 | bitCount | Amount of bits to read. |
+
+#### ReadBits(out UInt64, UInt32)
+
+
+Read a certain amount of bits from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadBits(out ulong value, uint bitCount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|----------|---------------------------|
+| System.UInt64 | value | Value to store bits into. |
+| System.UInt32 | bitCount | Amount of bits to read |
+
+#### TryBeginReadBits(UInt32)
+
+
+Verifies the requested bit count can be read from the buffer. This
+exists as a separate method to allow multiple bit reads to be bounds
+checked with a single call. If it returns false, you may not read, and
+in editor and development builds, attempting to do so will throw an
+exception. In release builds, attempting to do so will read junk memory.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool TryBeginReadBits(uint bitCount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|----------|-------------------------------------------|
+| System.UInt32 | bitCount | Number of bits you want to read, in total |
+
+##### Returns
+
+| Type | Description |
+|----------------|----------------------------------------------------------------|
+| System.Boolean | True if you can read, false if that would exceed buffer bounds |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.BitWriter.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.BitWriter.md
new file mode 100644
index 000000000..4156edcf0
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.BitWriter.md
@@ -0,0 +1,243 @@
+---
+id: Unity.Netcode.BitWriter
+title: Unity.Netcode.BitWriter
+---
+
+# Struct BitWriter
+
+
+Helper class for doing bitwise writes for a FastBufferWriter. Ensures
+all bitwise writes end on proper byte alignment so FastBufferWriter
+doesn't have to be concerned with misaligned writes.
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public ref struct BitWriter
+```
+
+
+
+### Properties
+
+#### BitAligned
+
+
+Whether or not the current BitPosition is evenly divisible by 8. I.e.
+whether or not the BitPosition is at a byte boundary.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly bool BitAligned { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+### Methods
+
+#### Dispose()
+
+
+Pads the written bit count to byte alignment and commits the write back
+to the writer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void Dispose()
+```
+
+
+
+#### TryBeginWriteBits(Int32)
+
+
+Allows faster serialization by batching bounds checking. When you know
+you will be writing multiple fields back-to-back and you know the total
+size, you can call TryBeginWriteBits() once on the total size, and then
+follow it with calls to WriteBit() or WriteBits().
+
+Bitwise write operations will throw OverflowException in editor and
+development builds if you go past the point you've marked using
+TryBeginWriteBits(). In release builds, OverflowException will not be
+thrown for performance reasons, since the point of using TryBeginWrite
+is to avoid bounds checking in the following operations in release
+builds. Instead, attempting to write past the marked position in release
+builds will write to random memory and cause undefined behavior, likely
+including instability and crashes.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool TryBeginWriteBits(int bitCount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|----------|--------------------------------------------|
+| System.Int32 | bitCount | Number of bits you want to write, in total |
+
+##### Returns
+
+| Type | Description |
+|----------------|-----------------------------------------------------------------|
+| System.Boolean | True if you can write, false if that would exceed buffer bounds |
+
+#### WriteBit(Boolean)
+
+
+Write a single bit to the buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteBit(bool bit)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|------|---------------------------------------------------------|
+| System.Boolean | bit | Value of the bit. True represents 1, False represents 0 |
+
+#### WriteBits(Byte, UInt32)
+
+
+Write bits to stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteBits(byte value, uint bitCount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|----------|--------------------------|
+| System.Byte | value | Value to get bits from. |
+| System.UInt32 | bitCount | Amount of bits to write. |
+
+#### WriteBits(UInt64, UInt32)
+
+
+Write s certain amount of bits to the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteBits(ulong value, uint bitCount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|----------|-------------------------|
+| System.UInt64 | value | Value to get bits from. |
+| System.UInt32 | bitCount | Amount of bits to write |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.BufferSerializer-1.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.BufferSerializer-1.md
new file mode 100644
index 000000000..1d02aa91c
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.BufferSerializer-1.md
@@ -0,0 +1,2026 @@
+---
+id: Unity.Netcode.BufferSerializer-1
+title: Unity.Netcode.BufferSerializer-1
+---
+
+# Struct BufferSerializer\
+
+
+Two-way serializer wrapping FastBufferReader or FastBufferWriter.
+
+Implemented as a ref struct for two reasons:
+
+1. The BufferSerializer cannot outlive the FBR/FBW it wraps or using it
+ will cause a crash
+2. The BufferSerializer must always be passed by reference and can't be
+ copied
+
+Ref structs help enforce both of those rules: they can't ref live the
+stack context in which they were created, and they're always passed by
+reference no matter what.
+
+BufferSerializer doesn't wrapp FastBufferReader or FastBufferWriter
+directly because it can't. ref structs can't implement interfaces, and
+in order to be able to have two different implementations with the same
+interface (which allows us to avoid an "if(IsReader)" on every call),
+the thing directly wrapping the struct has to implement an interface. So
+IReaderWriter exists as the interface, which is implemented by a normal
+struct, while the ref struct wraps the normal one to enforce the two
+above requirements. (Allowing direct access to the IReaderWriter struct
+would allow dangerous things to happen because the struct's lifetime
+could outlive the Reader/Writer's.)
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public ref struct BufferSerializer
+ where TReaderWriter : IReaderWriter
+```
+
+
+
+##### Type Parameters
+
+| Name | Description |
+|---------------|---------------------------|
+| TReaderWriter | The implementation struct |
+
+### Properties
+
+#### IsReader
+
+
+Check if the contained implementation is a reader
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly bool IsReader { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+#### IsWriter
+
+
+Check if the contained implementation is a writer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly bool IsWriter { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+### Methods
+
+#### GetFastBufferReader()
+
+
+Retrieves the FastBufferReader instance. Only valid if IsReader = true,
+throws InvalidOperationException otherwise.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferReader GetFastBufferReader()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|------------------|-----------------|
+| FastBufferReader | Reader instance |
+
+#### GetFastBufferWriter()
+
+
+Retrieves the FastBufferWriter instance. Only valid if IsWriter = true,
+throws InvalidOperationException otherwise.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferWriter GetFastBufferWriter()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|------------------|-----------------|
+| FastBufferWriter | Writer instance |
+
+#### PreCheck(Int32)
+
+
+Performs an advance check to ensure space is available to read/write one
+or more values. This provides a performance benefit for serializing
+multiple values using the SerializeValuePreChecked methods. But note
+that the benefit is small and only likely to be noticeable if
+serializing a very large number of items.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool PreCheck(int amount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|--------|-------------|
+| System.Int32 | amount | |
+
+##### Returns
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+#### SerializeNetworkSerializable\(ref T)
+
+
+Read or write a NetworkSerializable value. SerializeValue() is the
+preferred method to do this - this is provided for backward
+compatibility only.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeNetworkSerializable(ref T value)
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|--------------------------|
+| T | value | The values to read/write |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------------|
+| T | The network serializable type |
+
+#### SerializeValue(ref Color)
+
+
+Read or write a Color value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Color value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------------|
+| Color | value | The value to read/write |
+
+#### SerializeValue(ref Color\[\])
+
+
+Read or write an array of Color values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Color[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------------|
+| Color\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Color32)
+
+
+Read or write a Color32 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Color32 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Color32 | value | The value to read/write |
+
+#### SerializeValue(ref Color32\[\])
+
+
+Read or write an array of Color32 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Color32[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Color32\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Quaternion)
+
+
+Read or write a Quaternion value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Quaternion value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Quaternion | value | The value to read/write |
+
+#### SerializeValue(ref Quaternion\[\])
+
+
+Read or write an array of Quaternion values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Quaternion[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------------|
+| Quaternion\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Ray)
+
+
+Read or write a Ray value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Ray value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------------------|
+| Ray | value | The value to read/write |
+
+#### SerializeValue(ref Ray\[\])
+
+
+Read or write an array of Ray values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Ray[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------------|
+| Ray\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Ray2D)
+
+
+Read or write a Ray2D value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Ray2D value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------------|
+| Ray2D | value | The value to read/write |
+
+#### SerializeValue(ref Ray2D\[\])
+
+
+Read or write an array of Ray2D values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Ray2D[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------------|
+| Ray2D\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Byte)
+
+
+Read or write a single byte
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|-------------------------|
+| System.Byte | value | The value to read/write |
+
+#### SerializeValue(ref String, Boolean)
+
+
+Read or write a string
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|------------------------------------------------------------------|
+| System.String | s | The value to read/write |
+| System.Boolean | oneByteChars | If true, characters will be limited to one-byte ASCII characters |
+
+#### SerializeValue(ref Vector2)
+
+
+Read or write a Vector2 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector2 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector2 | value | The value to read/write |
+
+#### SerializeValue(ref Vector2\[\])
+
+
+Read or write an array of Vector2 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector2[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector2\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector2Int)
+
+
+Read or write a Vector2Int value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector2Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Vector2Int | value | The value to read/write |
+
+#### SerializeValue(ref Vector2Int\[\])
+
+
+Read or write an array of Vector2Int values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector2Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------------|
+| Vector2Int\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector3)
+
+
+Read or write a Vector3 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector3 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector3 | value | The value to read/write |
+
+#### SerializeValue(ref Vector3\[\])
+
+
+Read or write an array of Vector3 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector3[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector3\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector3Int)
+
+
+Read or write a Vector3Int value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector3Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Vector3Int | value | The value to read/write |
+
+#### SerializeValue(ref Vector3Int\[\])
+
+
+Read or write an array of Vector3Int values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector3Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------------|
+| Vector3Int\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector4)
+
+
+Read or write a Vector4 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector4 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector4 | value | The value to read/write |
+
+#### SerializeValue(ref Vector4\[\])
+
+
+Read or write an array of Vector4 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref Vector4[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector4\[\] | value | The values to read/write |
+
+#### SerializeValue\(ref T, FastBufferWriter.ForEnums)
+
+
+Read or write an enum value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read/write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\(ref T, FastBufferWriter.ForFixedStrings)
+
+
+Read or write a FixedString value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T value, FastBufferWriter.ForFixedStrings unused = default(FastBufferWriter.ForFixedStrings))
+ where T : struct, INativeList, IUTF8Bytes
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------------------------|--------|---------------------------------------------------------------------------|
+| T | value | The values to read/write |
+| FastBufferWriter.ForFixedStrings | unused | An unused parameter used for enabling overload resolution of FixedStrings |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------------|
+| T | The network serializable type |
+
+#### SerializeValue\(ref T, FastBufferWriter.ForNetworkSerializable)
+
+
+Read or write a struct or class value implementing INetworkSerializable
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read/write |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\(ref T, FastBufferWriter.ForPrimitives)
+
+
+Read or write a primitive value (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read/write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\(ref T, FastBufferWriter.ForStructs)
+
+
+Read or write a struct value implementing ISerializeByMemcpy
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read/write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\(ref T\[\], FastBufferWriter.ForEnums)
+
+
+Read or write an array of enum values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T[] value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The value to read/write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\(ref T\[\], FastBufferWriter.ForNetworkSerializable)
+
+
+Read or write an array of struct or class values implementing
+INetworkSerializable
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T[] value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read/write |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\(ref T\[\], FastBufferWriter.ForPrimitives)
+
+
+Read or write an array of primitive values (int, bool, etc) Accepts any
+value that implements the given interfaces, but is not guaranteed to
+work correctly on values that are not primitives.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T[] value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read/write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\(ref T\[\], FastBufferWriter.ForStructs)
+
+
+Read or write an array of struct values implementing ISerializeByMemcpy
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValue(ref T[] value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read/write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValuePreChecked(ref Color)
+
+
+Serialize a Color, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Color value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------------|
+| Color | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Color\[\])
+
+
+Serialize a Color array, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Color[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|-------------------------|
+| Color\[\] | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Color32)
+
+
+Serialize a Color32, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Color32 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Color32 | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Color32\[\])
+
+
+Serialize a Color32 array, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Color32[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|-------------------------|
+| Color32\[\] | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Quaternion)
+
+
+Serialize a Quaternion, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Quaternion value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Quaternion | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Quaternion\[\])
+
+
+Serialize a Quaternion array, "pre-checked", which skips buffer checks.
+In debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Quaternion[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|-------------------------|
+| Quaternion\[\] | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Ray)
+
+
+Serialize a Ray, "pre-checked", which skips buffer checks. In debug and
+editor builds, a check is made to ensure you've called "PreCheck" before
+calling this. In release builds, calling this without calling "PreCheck"
+may read or write past the end of the buffer, which will cause memory
+corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Ray value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------------------|
+| Ray | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Ray\[\])
+
+
+Serialize a Ray array, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Ray[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Ray\[\] | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Ray2D)
+
+
+Serialize a Ray2D, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Ray2D value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------------|
+| Ray2D | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Ray2D\[\])
+
+
+Serialize a Ray2D array, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Ray2D[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|-------------------------|
+| Ray2D\[\] | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Byte)
+
+
+Serialize a byte, "pre-checked", which skips buffer checks. In debug and
+editor builds, a check is made to ensure you've called "PreCheck" before
+calling this. In release builds, calling this without calling "PreCheck"
+may read or write past the end of the buffer, which will cause memory
+corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|-------------------------|
+| System.Byte | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref String, Boolean)
+
+
+Serialize a string, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|------------------------------------------------------------------|
+| System.String | s | The value to read/write |
+| System.Boolean | oneByteChars | If true, characters will be limited to one-byte ASCII characters |
+
+#### SerializeValuePreChecked(ref Vector2)
+
+
+Serialize a Vector2, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector2 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector2 | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Vector2\[\])
+
+
+Serialize a Vector2 array, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector2[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector2\[\] | value | The values to read/write |
+
+#### SerializeValuePreChecked(ref Vector2Int)
+
+
+Serialize a Vector2Int, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector2Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Vector2Int | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Vector2Int\[\])
+
+
+Serialize a Vector2Int array, "pre-checked", which skips buffer checks.
+In debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector2Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------------|
+| Vector2Int\[\] | value | The values to read/write |
+
+#### SerializeValuePreChecked(ref Vector3)
+
+
+Serialize a Vector3, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector3 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector3 | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Vector3\[\])
+
+
+Serialize a Vector3 array, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector3[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector3\[\] | value | The values to read/write |
+
+#### SerializeValuePreChecked(ref Vector3Int)
+
+
+Serialize a Vector3Int, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector3Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Vector3Int | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Vector3Int\[\])
+
+
+Serialize a Vector3Int array, "pre-checked", which skips buffer checks.
+In debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector3Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|-------------------------|
+| Vector3Int\[\] | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Vector4)
+
+
+Serialize a Vector4, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector4 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector4 | value | The value to read/write |
+
+#### SerializeValuePreChecked(ref Vector4\[\])
+
+
+Serialize a Vector4Array, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref Vector4[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|-------------------------|
+| Vector4\[\] | value | The value to read/write |
+
+#### SerializeValuePreChecked\(ref T, FastBufferWriter.ForEnums)
+
+
+Serialize an enum, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref T value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|--------------------------------------------------------------------|
+| T | value | The values to read/write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution of enums |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------------|
+| T | The network serializable type |
+
+#### SerializeValuePreChecked\(ref T, FastBufferWriter.ForFixedStrings)
+
+
+Serialize a FixedString, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref T value, FastBufferWriter.ForFixedStrings unused = default(FastBufferWriter.ForFixedStrings))
+ where T : struct, INativeList, IUTF8Bytes
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------------------------|--------|-----------------------------------------------------------------------------------------|
+| T | value | The value to read/write |
+| FastBufferWriter.ForFixedStrings | unused | An unused parameter that can be used for enabling overload resolution for fixed strings |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------------|
+| T | The network serializable type |
+
+#### SerializeValuePreChecked\(ref T, FastBufferWriter.ForPrimitives)
+
+
+Serialize a primitive, "pre-checked", which skips buffer checks. In
+debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref T value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read/write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------------|
+| T | The network serializable type |
+
+#### SerializeValuePreChecked\(ref T, FastBufferWriter.ForStructs)
+
+
+Serialize a struct, "pre-checked", which skips buffer checks. In debug
+and editor builds, a check is made to ensure you've called "PreCheck"
+before calling this. In release builds, calling this without calling
+"PreCheck" may read or write past the end of the buffer, which will
+cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref T value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------|
+| T | value | The values to read/write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution of structs |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------------|
+| T | The network serializable type |
+
+#### SerializeValuePreChecked\(ref T\[\], FastBufferWriter.ForEnums)
+
+
+Serialize an array of enums, "pre-checked", which skips buffer checks.
+In debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref T[] value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|--------------------------------------------------------------------|
+| T\[\] | value | The values to read/write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution of enums |
+
+##### Type Parameters
+
+| Name | Description |
+|------|--------------------------------------------|
+| T | The network serializable types in an array |
+
+#### SerializeValuePreChecked\(ref T\[\], FastBufferWriter.ForPrimitives)
+
+
+Serialize an array of primitives, "pre-checked", which skips buffer
+checks. In debug and editor builds, a check is made to ensure you've
+called "PreCheck" before calling this. In release builds, calling this
+without calling "PreCheck" may read or write past the end of the buffer,
+which will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref T[] value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|-------------------------------------------------------------------------|
+| T\[\] | value | The values to read/write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution of primitives |
+
+##### Type Parameters
+
+| Name | Description |
+|------|--------------------------------------------|
+| T | The network serializable types in an array |
+
+#### SerializeValuePreChecked\(ref T\[\], FastBufferWriter.ForStructs)
+
+
+Serialize an array of structs, "pre-checked", which skips buffer checks.
+In debug and editor builds, a check is made to ensure you've called
+"PreCheck" before calling this. In release builds, calling this without
+calling "PreCheck" may read or write past the end of the buffer, which
+will cause memory corruption and undefined behavior.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SerializeValuePreChecked(ref T[] value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------|
+| T\[\] | value | The values to read/write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution of structs |
+
+##### Type Parameters
+
+| Name | Description |
+|------|--------------------------------------------|
+| T | The network serializable types in an array |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.BytePacker.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.BytePacker.md
new file mode 100644
index 000000000..393162779
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.BytePacker.md
@@ -0,0 +1,1110 @@
+---
+id: Unity.Netcode.BytePacker
+title: Unity.Netcode.BytePacker
+---
+
+# Class BytePacker
+
+
+Utility class for packing values in serialization. ByteUnpacker to
+unpack packed values.
+
+
+
+
+
+
+
+##### Inheritance
+
+
+System.Object
+
+
+
+
+BytePacker
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.Object.Equals(System.Object)
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetHashCode()
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.MemberwiseClone()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+System.Object.ToString()
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public static class BytePacker
+```
+
+
+
+### Fields
+
+#### BitPackedIntMax
+
+
+Maximum serializable value for a BitPacked int
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const int BitPackedIntMax = 536870911
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+#### BitPackedIntMin
+
+
+Minimum serializable value size for a BitPacked int
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const int BitPackedIntMin = -536870912
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+#### BitPackedLongMax
+
+
+Maximum serializable value for a BitPacked long
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const long BitPackedLongMax = 1152921504606846975L
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int64 | |
+
+#### BitPackedLongMin
+
+
+Minimum serializable value size for a BitPacked long
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const long BitPackedLongMin = -1152921504606846976L
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int64 | |
+
+#### BitPackedShortMax
+
+
+Maximum serializable value for a BitPacked short
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const short BitPackedShortMax = 16383
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int16 | |
+
+#### BitPackedShortMin
+
+
+Minimum serializable value size for a BitPacked ushort
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const short BitPackedShortMin = -16384
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int16 | |
+
+#### BitPackedUintMax
+
+
+Maximum serializable value for a BitPacked uint (minimum for unsigned is
+0)
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const uint BitPackedUintMax = 1073741823U
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|---------------|-------------|
+| System.UInt32 | |
+
+#### BitPackedULongMax
+
+
+Maximum serializable value for a BitPacked ulong (minimum for unsigned
+is 0)
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const ulong BitPackedULongMax = 2305843009213693951UL
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|---------------|-------------|
+| System.UInt64 | |
+
+#### BitPackedUshortMax
+
+
+Maximum serializable value for a BitPacked ushort (minimum for unsigned
+is 0)
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public const ushort BitPackedUshortMax = 32767
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|---------------|-------------|
+| System.UInt16 | |
+
+### Methods
+
+#### WriteValueBitPacked(FastBufferWriter, Int16)
+
+
+Writes a 14-bit signed short to the buffer in a bit-encoded packed
+format. The first bit indicates whether the value is 1 byte or 2. The
+sign bit takes up another bit. That leaves 14 bits for the value. A
+value greater than 2^14-1 or less than -2^14 will throw an exception in
+editor and development builds. In release builds builds the exception is
+not thrown and the value is truncated by losing its two most significant
+bits after zig-zag encoding.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValueBitPacked(FastBufferWriter writer, short value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Int16 | value | The value to pack |
+
+#### WriteValueBitPacked(FastBufferWriter, Int32)
+
+
+Writes a 29-bit signed int to the buffer in a bit-encoded packed format.
+The first two bits indicate whether the value is 1, 2, 3, or 4 bytes.
+The sign bit takes up another bit. That leaves 29 bits for the value. A
+value greater than 2^29-1 or less than -2^29 will throw an exception in
+editor and development builds. In release builds builds the exception is
+not thrown and the value is truncated by losing its three most
+significant bits after zig-zag encoding.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValueBitPacked(FastBufferWriter writer, int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Int32 | value | The value to pack |
+
+#### WriteValueBitPacked(FastBufferWriter, Int64)
+
+
+Writes a 60-bit signed long to the buffer in a bit-encoded packed
+format. The first three bits indicate whether the value is 1, 2, 3, 4,
+5, 6, 7, or 8 bytes. The sign bit takes up another bit. That leaves 60
+bits for the value. A value greater than 2^60-1 or less than -2^60 will
+throw an exception in editor and development builds. In release builds
+builds the exception is not thrown and the value is truncated by losing
+its four most significant bits after zig-zag encoding.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValueBitPacked(FastBufferWriter writer, long value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Int64 | value | The value to pack |
+
+#### WriteValueBitPacked(FastBufferWriter, UInt16)
+
+
+Writes a 15-bit unsigned short to the buffer in a bit-encoded packed
+format. The first bit indicates whether the value is 1 byte or 2. That
+leaves 15 bits for the value. A value greater than 2^15-1 will throw an
+exception in editor and development builds. In release builds builds the
+exception is not thrown and the value is truncated by losing its most
+significant bit.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValueBitPacked(FastBufferWriter writer, ushort value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.UInt16 | value | The value to pack |
+
+#### WriteValueBitPacked(FastBufferWriter, UInt32)
+
+
+Writes a 30-bit unsigned int to the buffer in a bit-encoded packed
+format. The first two bits indicate whether the value is 1, 2, 3, or 4
+bytes. That leaves 30 bits for the value. A value greater than 2^30-1
+will throw an exception in editor and development builds. In release
+builds builds the exception is not thrown and the value is truncated by
+losing its two most significant bits.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValueBitPacked(FastBufferWriter writer, uint value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.UInt32 | value | The value to pack |
+
+#### WriteValueBitPacked(FastBufferWriter, UInt64)
+
+
+Writes a 61-bit unsigned long to the buffer in a bit-encoded packed
+format. The first three bits indicate whether the value is 1, 2, 3, 4,
+5, 6, 7, or 8 bytes. That leaves 31 bits for the value. A value greater
+than 2^61-1 will throw an exception in editor and development builds. In
+release builds builds the exception is not thrown and the value is
+truncated by losing its three most significant bits.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValueBitPacked(FastBufferWriter writer, ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.UInt64 | value | The value to pack |
+
+#### WriteValuePacked(FastBufferWriter, Color)
+
+
+Convenience method that writes four varint floats from the color to the
+buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Color color)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Color | color | Color to write |
+
+#### WriteValuePacked(FastBufferWriter, Color32)
+
+
+Convenience method that writes four varint floats from the color to the
+buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Color32 color)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Color32 | color | Color to write |
+
+#### WriteValuePacked(FastBufferWriter, Quaternion)
+
+
+Writes the rotation to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Quaternion rotation)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|----------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Quaternion | rotation | Rotation to write |
+
+#### WriteValuePacked(FastBufferWriter, Ray)
+
+
+Convenience method that writes two packed Vector3 from the ray to the
+buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Ray ray)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Ray | ray | Ray to write |
+
+#### WriteValuePacked(FastBufferWriter, Ray2D)
+
+
+Convenience method that writes two packed Vector2 from the ray to the
+buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Ray2D ray2d)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Ray2D | ray2d | Ray2D to write |
+
+#### WriteValuePacked(FastBufferWriter, Boolean)
+
+
+Write a bool to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, bool value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Boolean | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Byte)
+
+
+Write a byte to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Byte | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Char)
+
+
+Write a two-byte character as a varint to the buffer. WARNING: If the
+value you're writing is \> 2287, this will use MORE space (3 bytes
+instead of 2), and if your value is \> 240 you'll get no savings at all.
+Only use this if you're certain your value will be small.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, char c)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Char | c | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Double)
+
+
+Write double-precision floating point value to the buffer as a varint
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, double value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Double | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Int16)
+
+
+Write a signed short (Int16) as a ZigZag encoded varint to the buffer.
+WARNING: If the value you're writing is \> 2287, this will use MORE
+space (3 bytes instead of 2), and if your value is \> 240 you'll get no
+savings at all. Only use this if you're certain your value will be
+small.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, short value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Int16 | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Int32)
+
+
+Write a signed int (Int32) as a ZigZag encoded varint to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Int32 | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Int64)
+
+
+Write a signed long (Int64) as a ZigZag encoded varint to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, long value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Int64 | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, SByte)
+
+
+Write a signed byte to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, sbyte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.SByte | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Single)
+
+
+Write single-precision floating point value to the buffer as a varint
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, float value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.Single | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, String)
+
+
+Writes a string in a packed format
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, string s)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.String | s | The value to pack |
+
+#### WriteValuePacked(FastBufferWriter, UInt16)
+
+
+Write an unsigned short (UInt16) as a varint to the buffer. WARNING: If
+the value you're writing is \> 2287, this will use MORE space (3 bytes
+instead of 2), and if your value is \> 240 you'll get no savings at all.
+Only use this if you're certain your value will be small.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, ushort value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.UInt16 | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, UInt32)
+
+
+Write an unsigned int (UInt32) to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, uint value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.UInt32 | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, UInt64)
+
+
+Write an unsigned long (UInt64) to the buffer.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| System.UInt64 | value | Value to write |
+
+#### WriteValuePacked(FastBufferWriter, Vector2)
+
+
+Convenience method that writes two varint floats from the vector to the
+buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Vector2 vector2)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|---------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Vector2 | vector2 | Vector to write |
+
+#### WriteValuePacked(FastBufferWriter, Vector3)
+
+
+Convenience method that writes three varint floats from the vector to
+the buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Vector3 vector3)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|---------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Vector3 | vector3 | Vector to write |
+
+#### WriteValuePacked(FastBufferWriter, Vector4)
+
+
+Convenience method that writes four varint floats from the vector to the
+buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, Vector4 vector4)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|---------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| Vector4 | vector4 | Vector to write |
+
+#### WriteValuePacked\(FastBufferWriter, TEnum)
+
+
+Write a packed enum value.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void WriteValuePacked(FastBufferWriter writer, TEnum value)
+ where TEnum : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|------------------------|
+| FastBufferWriter | writer | The writer to write to |
+| TEnum | value | The value to write |
+
+##### Type Parameters
+
+| Name | Description |
+|-------|--------------|
+| TEnum | An enum type |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.ByteUnpacker.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.ByteUnpacker.md
new file mode 100644
index 000000000..911a3d783
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.ByteUnpacker.md
@@ -0,0 +1,850 @@
+---
+id: Unity.Netcode.ByteUnpacker
+title: Unity.Netcode.ByteUnpacker
+---
+
+# Class ByteUnpacker
+
+
+Byte Unpacking Helper Class Use this class to unpack values during
+deserialization for values that were packed. BytePacker to pack unpacked
+values
+
+
+
+
+
+
+
+##### Inheritance
+
+
+System.Object
+
+
+
+
+ByteUnpacker
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.Object.Equals(System.Object)
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetHashCode()
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.MemberwiseClone()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+System.Object.ToString()
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public static class ByteUnpacker
+```
+
+
+
+### Methods
+
+#### ReadValueBitPacked(FastBufferReader, out Int16)
+
+
+Read a bit-packed 14-bit signed short from the stream. See BytePacker.cs
+for a description of the format.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValueBitPacked(FastBufferReader reader, out short value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Int16 | value | The value to read |
+
+#### ReadValueBitPacked(FastBufferReader, out Int32)
+
+
+Read a bit-packed 29-bit signed int from the stream. See BytePacker.cs
+for a description of the format.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValueBitPacked(FastBufferReader reader, out int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Int32 | value | The value to read |
+
+#### ReadValueBitPacked(FastBufferReader, out Int64)
+
+
+Read a bit-packed 60-bit signed long from the stream. See BytePacker.cs
+for a description of the format.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValueBitPacked(FastBufferReader reader, out long value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Int64 | value | The value to read |
+
+#### ReadValueBitPacked(FastBufferReader, out UInt16)
+
+
+Read a bit-packed 15-bit unsigned short from the stream. See
+BytePacker.cs for a description of the format.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValueBitPacked(FastBufferReader reader, out ushort value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.UInt16 | value | The value to read |
+
+#### ReadValueBitPacked(FastBufferReader, out UInt32)
+
+
+Read a bit-packed 30-bit unsigned int from the stream. See BytePacker.cs
+for a description of the format.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValueBitPacked(FastBufferReader reader, out uint value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.UInt32 | value | The value to read |
+
+#### ReadValueBitPacked(FastBufferReader, out UInt64)
+
+
+Read a bit-packed 61-bit signed long from the stream. See BytePacker.cs
+for a description of the format.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValueBitPacked(FastBufferReader reader, out ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.UInt64 | value | The value to read |
+
+#### ReadValuePacked(FastBufferReader, out Color)
+
+
+Convenience method that reads four varint floats from the color from the
+stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Color color)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Color | color | Color to read |
+
+#### ReadValuePacked(FastBufferReader, out Color32)
+
+
+Convenience method that reads four varint floats from the color from the
+stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Color32 color)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Color32 | color | Color to read |
+
+#### ReadValuePacked(FastBufferReader, out Quaternion)
+
+
+Reads the rotation from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Quaternion rotation)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|----------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Quaternion | rotation | Rotation to read |
+
+#### ReadValuePacked(FastBufferReader, out Ray)
+
+
+Convenience method that reads two packed Vector3 from the ray from the
+stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Ray ray)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Ray | ray | Ray to read |
+
+#### ReadValuePacked(FastBufferReader, out Ray2D)
+
+
+Convenience method that reads two packed Vector2 from the ray from the
+stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Ray2D ray2d)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Ray2D | ray2d | Ray2D to read |
+
+#### ReadValuePacked(FastBufferReader, out Boolean)
+
+
+Read a boolean from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out bool value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Boolean | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Byte)
+
+
+Read a byte from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Byte | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Char)
+
+
+Read a two-byte character as a varint from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out char c)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Char | c | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Double)
+
+
+Read double-precision floating point value from the stream as a varint
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out double value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Double | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Int16)
+
+
+Read an usigned short (Int16) as a varint from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out short value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Int16 | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Int32)
+
+
+Read a signed int (Int32) as a ZigZag encoded varint from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Int32 | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Int64)
+
+
+Read a signed long (Int64) as a ZigZag encoded varint from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out long value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Int64 | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out SByte)
+
+
+Read a signed byte from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out sbyte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.SByte | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Single)
+
+
+Read single-precision floating point value from the stream as a varint
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out float value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.Single | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out String)
+
+
+Reads a string in a packed format
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out string s)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.String | s | |
+
+#### ReadValuePacked(FastBufferReader, out UInt16)
+
+
+Read an unsigned short (UInt16) as a varint from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out ushort value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.UInt16 | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out UInt32)
+
+
+Read an unsigned int (UInt32) from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out uint value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.UInt32 | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out UInt64)
+
+
+Read an unsigned long (UInt64) from the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out ulong value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| System.UInt64 | value | Value to read |
+
+#### ReadValuePacked(FastBufferReader, out Vector2)
+
+
+Convenience method that reads two varint floats from the vector from the
+stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Vector2 vector2)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|---------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Vector2 | vector2 | Vector to read |
+
+#### ReadValuePacked(FastBufferReader, out Vector3)
+
+
+Convenience method that reads three varint floats from the vector from
+the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Vector3 vector3)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|---------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Vector3 | vector3 | Vector to read |
+
+#### ReadValuePacked(FastBufferReader, out Vector4)
+
+
+Convenience method that reads four varint floats from the vector from
+the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out Vector4 vector4)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|---------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| Vector4 | vector4 | Vector to read |
+
+#### ReadValuePacked\(FastBufferReader, out TEnum)
+
+
+Read a packed enum value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static void ReadValuePacked(FastBufferReader reader, out TEnum value)
+ where TEnum : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|--------|-------------------------|
+| FastBufferReader | reader | The reader to read from |
+| TEnum | value | The value that's read |
+
+##### Type Parameters
+
+| Name | Description |
+|-------|----------------------|
+| TEnum | Type of enum to read |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|
+| System.InvalidOperationException | Throws InvalidOperationException if an enum somehow ends up not being the size of a byte, short, int, or long (which should be impossible) |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcAttribute.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcAttribute.md
new file mode 100644
index 000000000..1e375fa69
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcAttribute.md
@@ -0,0 +1,393 @@
+---
+id: Unity.Netcode.ClientRpcAttribute
+title: Unity.Netcode.ClientRpcAttribute
+---
+
+# Class ClientRpcAttribute
+
+
+Marks a method as ClientRpc.
+
+A ClientRpc marked method will be fired by the server but executed on
+clients.
+
+
+
+
+
+
+
+##### Inheritance
+
+
+System.Object
+
+
+
+
+System.Attribute
+
+
+
+
+RpcAttribute
+
+
+
+
+ClientRpcAttribute
+
+
+
+
+
+
+##### Implements
+
+
+
+System.Runtime.InteropServices.\_Attribute
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+RpcAttribute.Delivery
+
+
+
+
+
+System.Attribute.Equals(System.Object)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.Assembly,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.Assembly,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.MemberInfo,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.Module,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.Module,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttribute(System.Reflection.ParameterInfo,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Assembly)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Assembly,
+System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Assembly,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Assembly,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,
+System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.MemberInfo,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Module)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Module,
+System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Module,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.Module,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,
+System.Boolean)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,
+System.Type)
+
+
+
+
+
+System.Attribute.GetCustomAttributes(System.Reflection.ParameterInfo,
+System.Type, System.Boolean)
+
+
+
+
+
+System.Attribute.GetHashCode()
+
+
+
+
+
+System.Attribute.IsDefaultAttribute()
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.Assembly, System.Type)
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.Assembly, System.Type,
+System.Boolean)
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.MemberInfo, System.Type)
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.MemberInfo, System.Type,
+System.Boolean)
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.Module, System.Type)
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.Module, System.Type,
+System.Boolean)
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.ParameterInfo, System.Type)
+
+
+
+
+
+System.Attribute.IsDefined(System.Reflection.ParameterInfo, System.Type,
+System.Boolean)
+
+
+
+
+
+System.Attribute.Match(System.Object)
+
+
+
+
+
+System.Attribute.System.Runtime.InteropServices.\_Attribute.GetIDsOfNames(System.Guid,
+System.IntPtr, System.UInt32, System.UInt32, System.IntPtr)
+
+
+
+
+
+System.Attribute.System.Runtime.InteropServices.\_Attribute.GetTypeInfo(System.UInt32,
+System.UInt32, System.IntPtr)
+
+
+
+
+
+System.Attribute.System.Runtime.InteropServices.\_Attribute.GetTypeInfoCount(System.UInt32)
+
+
+
+
+
+System.Attribute.System.Runtime.InteropServices.\_Attribute.Invoke(System.UInt32,
+System.Guid, System.UInt32, System.Int16, System.IntPtr, System.IntPtr,
+System.IntPtr, System.IntPtr)
+
+
+
+
+
+System.Attribute.TypeId
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.MemberwiseClone()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+System.Object.ToString()
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+[AttributeUsage(AttributeTargets.Method)]
+public class ClientRpcAttribute : RpcAttribute, _Attribute
+```
+
+
+
+### Implements
+
+
+
+System.Runtime.InteropServices.\_Attribute
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcParams.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcParams.md
new file mode 100644
index 000000000..c0d2382d5
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcParams.md
@@ -0,0 +1,126 @@
+---
+id: Unity.Netcode.ClientRpcParams
+title: Unity.Netcode.ClientRpcParams
+---
+
+# Struct ClientRpcParams
+
+
+Client-Side RPC Can be used with any client-side remote procedure call
+Note: Typically this is used primarily for sending to a specific list of
+clients as opposed to the default (all). ClientRpcSendParams
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ClientRpcParams
+```
+
+
+
+### Fields
+
+#### Receive
+
+
+The client RPC receive parameters (currently a place holder)
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public ClientRpcReceiveParams Receive
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|------------------------|-------------|
+| ClientRpcReceiveParams | |
+
+#### Send
+
+
+The client RPC send parameters provides you with the ability to send to
+a specific list of clients
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public ClientRpcSendParams Send
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|---------------------|-------------|
+| ClientRpcSendParams | |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcReceiveParams.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcReceiveParams.md
new file mode 100644
index 000000000..caf7b0bbf
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcReceiveParams.md
@@ -0,0 +1,72 @@
+---
+id: Unity.Netcode.ClientRpcReceiveParams
+title: Unity.Netcode.ClientRpcReceiveParams
+---
+
+# Struct ClientRpcReceiveParams
+
+
+Client-Side RPC Place holder. ServerRpcParams Note: Server will always
+be the sender, so this structure is a place holder
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ClientRpcReceiveParams
+```
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcSendParams.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcSendParams.md
new file mode 100644
index 000000000..3cbecd3b1
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.ClientRpcSendParams.md
@@ -0,0 +1,130 @@
+---
+id: Unity.Netcode.ClientRpcSendParams
+title: Unity.Netcode.ClientRpcSendParams
+---
+
+# Struct ClientRpcSendParams
+
+
+Client-Side RPC The send parameters, when sending client RPCs, provides
+you wil the ability to target specific clients as a managed or unmanaged
+list: TargetClientIds and TargetClientIdsNativeArray
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ClientRpcSendParams
+```
+
+
+
+### Fields
+
+#### TargetClientIds
+
+
+IEnumerable version of target id list - use either this OR
+TargetClientIdsNativeArray Note: Even if you provide a value type such
+as NativeArray, enumerating it will cause boxing. If you want to avoid
+boxing, use TargetClientIdsNativeArray
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public IReadOnlyList TargetClientIds
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|--------------------------------|-------------|
+| IReadOnlyList\ | |
+
+#### TargetClientIdsNativeArray
+
+
+NativeArray version of target id list - use either this OR
+TargetClientIds This option avoids any GC allocations but is a bit
+trickier to use.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public NativeArray? TargetClientIdsNativeArray
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|-------------------------------------------------|-------------|
+| System.Nullable\\> | |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate.md
new file mode 100644
index 000000000..7c7ea402c
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate.md
@@ -0,0 +1,37 @@
+---
+id: Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate
+title: Unity.Netcode.CustomMessagingManager.HandleNamedMessageDelegate
+---
+
+# Delegate CustomMessagingManager.HandleNamedMessageDelegate
+
+
+Delegate used to handle named messages
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public delegate void HandleNamedMessageDelegate(ulong senderClientId, FastBufferReader messagePayload);
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|----------------|-------------|
+| System.UInt64 | senderClientId | |
+| FastBufferReader | messagePayload | |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.UnnamedMessageDelegate.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.UnnamedMessageDelegate.md
new file mode 100644
index 000000000..40558bb4a
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.UnnamedMessageDelegate.md
@@ -0,0 +1,37 @@
+---
+id: Unity.Netcode.CustomMessagingManager.UnnamedMessageDelegate
+title: Unity.Netcode.CustomMessagingManager.UnnamedMessageDelegate
+---
+
+# Delegate CustomMessagingManager.UnnamedMessageDelegate
+
+
+Delegate used for incoming unnamed messages
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public delegate void UnnamedMessageDelegate(ulong clientId, FastBufferReader reader);
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|----------|----------------------------------------|
+| System.UInt64 | clientId | The clientId that sent the message |
+| FastBufferReader | reader | The stream containing the message data |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.md
new file mode 100644
index 000000000..81a3f2f52
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.CustomMessagingManager.md
@@ -0,0 +1,337 @@
+---
+id: Unity.Netcode.CustomMessagingManager
+title: Unity.Netcode.CustomMessagingManager
+---
+
+# Class CustomMessagingManager
+
+
+The manager class to manage custom messages, note that this is different
+from the NetworkManager custom messages. These are named and are much
+easier to use.
+
+
+
+
+
+
+
+##### Inheritance
+
+
+System.Object
+
+
+
+
+CustomMessagingManager
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.Object.Equals(System.Object)
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetHashCode()
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.MemberwiseClone()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+System.Object.ToString()
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public class CustomMessagingManager
+```
+
+
+
+### Methods
+
+#### RegisterNamedMessageHandler(String, CustomMessagingManager.HandleNamedMessageDelegate)
+
+
+Registers a named message handler delegate.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void RegisterNamedMessageHandler(string name, CustomMessagingManager.HandleNamedMessageDelegate callback)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------------------------------|----------|-------------------------------------------------------|
+| System.String | name | Name of the message. |
+| CustomMessagingManager.HandleNamedMessageDelegate | callback | The callback to run when a named message is received. |
+
+#### SendNamedMessage(String, IReadOnlyList\, FastBufferWriter, NetworkDelivery)
+
+
+Sends the named message
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SendNamedMessage(string messageName, IReadOnlyList clientIds, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|-----------------|-------------------------------------------|
+| System.String | messageName | The message name to send |
+| IReadOnlyList\ | clientIds | The clients to send to |
+| FastBufferWriter | messageStream | The message stream containing the data |
+| NetworkDelivery | networkDelivery | The delivery type (QoS) to send data with |
+
+#### SendNamedMessage(String, UInt64, FastBufferWriter, NetworkDelivery)
+
+
+Sends a named message
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SendNamedMessage(string messageName, ulong clientId, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-----------------|-------------------------------------------|
+| System.String | messageName | The message name to send |
+| System.UInt64 | clientId | The client to send the message to |
+| FastBufferWriter | messageStream | The message stream containing the data |
+| NetworkDelivery | networkDelivery | The delivery type (QoS) to send data with |
+
+#### SendNamedMessageToAll(String, FastBufferWriter, NetworkDelivery)
+
+
+Sends a named message to all clients
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SendNamedMessageToAll(string messageName, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-----------------|-------------------------------------------|
+| System.String | messageName | The message name to send |
+| FastBufferWriter | messageStream | The message stream containing the data |
+| NetworkDelivery | networkDelivery | The delivery type (QoS) to send data with |
+
+#### SendUnnamedMessage(IReadOnlyList\, FastBufferWriter, NetworkDelivery)
+
+
+Sends unnamed message to a list of clients
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SendUnnamedMessage(IReadOnlyList clientIds, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|-----------------|---------------------------------------------------|
+| IReadOnlyList\ | clientIds | The clients to send to, sends to everyone if null |
+| FastBufferWriter | messageBuffer | The message stream containing the data |
+| NetworkDelivery | networkDelivery | The delivery type (QoS) to send data with |
+
+#### SendUnnamedMessage(UInt64, FastBufferWriter, NetworkDelivery)
+
+
+Sends a unnamed message to a specific client
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SendUnnamedMessage(ulong clientId, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-----------------|-------------------------------------------|
+| System.UInt64 | clientId | The client to send the message to |
+| FastBufferWriter | messageBuffer | The message stream containing the data |
+| NetworkDelivery | networkDelivery | The delivery type (QoS) to send data with |
+
+#### SendUnnamedMessageToAll(FastBufferWriter, NetworkDelivery)
+
+
+Sends unnamed message to all clients
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void SendUnnamedMessageToAll(FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-----------------|-------------------------------------------|
+| FastBufferWriter | messageBuffer | The message stream containing the data |
+| NetworkDelivery | networkDelivery | The delivery type (QoS) to send data with |
+
+#### UnregisterNamedMessageHandler(String)
+
+
+Unregisters a named message handler.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void UnregisterNamedMessageHandler(string name)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|------|--------------------------|
+| System.String | name | The name of the message. |
+
+### Events
+
+#### OnUnnamedMessage
+
+
+Event invoked when unnamed messages arrive
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public event CustomMessagingManager.UnnamedMessageDelegate OnUnnamedMessage
+```
+
+
+
+##### Event Type
+
+| Type | Description |
+|-----------------------------------------------|-------------|
+| CustomMessagingManager.UnnamedMessageDelegate | |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferReader.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferReader.md
new file mode 100644
index 000000000..5fddc0f82
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferReader.md
@@ -0,0 +1,2701 @@
+---
+id: Unity.Netcode.FastBufferReader
+title: Unity.Netcode.FastBufferReader
+---
+
+# Struct FastBufferReader
+
+
+Optimized class used for reading values from a byte stream
+FastBufferWriter BytePacker ByteUnpacker
+
+
+
+
+
+
+
+##### Implements
+
+
+
+System.IDisposable
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct FastBufferReader : IDisposable
+```
+
+
+
+### Constructors
+
+#### FastBufferReader(NativeArray\, Allocator, Int32, Int32, Allocator)
+
+
+Create a FastBufferReader from a NativeArray.
+
+A new buffer will be created using the given and the value will be
+copied in. FastBufferReader will then own the data.
+
+The exception to this is when the passed in is Allocator.None. In this
+scenario, ownership of the data remains with the caller and the reader
+will point at it directly. When created with Allocator.None,
+FastBufferReader will allocate some internal data using Allocator.Temp
+so it should be treated as if it's a ref struct and not allowed to
+outlive the context in which it was created (it should neither be
+returned from that function nor stored anywhere in heap memory). This is
+true, unless the param is explicitly set to i.e.: Allocator.Persistent
+in which case it would allow the internal data to Persist for longer,
+but the caller should manually call Dispose() when it is no longer
+needed.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferReader(NativeArray buffer, Allocator copyAllocator, int length = -1, int offset = 0, Allocator internalAllocator = null)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| NativeArray\ | buffer | |
+| Allocator | copyAllocator | The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance |
+| System.Int32 | length | |
+| System.Int32 | offset | |
+| Allocator | internalAllocator | The allocator type used for internal data when this reader points directly at a buffer owned by someone else |
+
+#### FastBufferReader(ArraySegment\, Allocator, Int32, Int32)
+
+
+Create a FastBufferReader from an ArraySegment.
+
+A new buffer will be created using the given allocator and the value
+will be copied in. FastBufferReader will then own the data.
+
+Allocator.None is not supported for byte\[\]. If you need this
+functionality, use a fixed() block and ensure the FastBufferReader isn't
+used outside that block.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferReader(ArraySegment buffer, Allocator copyAllocator, int length = -1, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------------------------|---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| System.ArraySegment\ | buffer | The buffer to copy from |
+| Allocator | copyAllocator | The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance |
+| System.Int32 | length | The number of bytes to copy (all if this is -1) |
+| System.Int32 | offset | The offset of the buffer to start copying from |
+
+#### FastBufferReader(Byte\*, Allocator, Int32, Int32, Allocator)
+
+
+Create a FastBufferReader from an existing byte buffer.
+
+A new buffer will be created using the given and the value will be
+copied in. FastBufferReader will then own the data.
+
+The exception to this is when the passed in is Allocator.None. In this
+scenario, ownership of the data remains with the caller and the reader
+will point at it directly. When created with Allocator.None,
+FastBufferReader will allocate some internal data using Allocator.Temp,
+so it should be treated as if it's a ref struct and not allowed to
+outlive the context in which it was created (it should neither be
+returned from that function nor stored anywhere in heap memory). This is
+true, unless the param is explicitly set to i.e.: Allocator.Persistent
+in which case it would allow the internal data to Persist for longer,
+but the caller should manually call Dispose() when it is no longer
+needed.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferReader(byte *buffer, Allocator copyAllocator, int length, int offset = 0, Allocator internalAllocator = null)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| System.Byte\* | buffer | The buffer to copy from |
+| Allocator | copyAllocator | The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance |
+| System.Int32 | length | The number of bytes to copy |
+| System.Int32 | offset | The offset of the buffer to start copying from |
+| Allocator | internalAllocator | The allocator type used for internal data when this reader points directly at a buffer owned by someone else |
+
+#### FastBufferReader(Byte\[\], Allocator, Int32, Int32)
+
+
+Create a FastBufferReader from an existing byte array.
+
+A new buffer will be created using the given allocator and the value
+will be copied in. FastBufferReader will then own the data.
+
+Allocator.None is not supported for byte\[\]. If you need this
+functionality, use a fixed() block and ensure the FastBufferReader isn't
+used outside that block.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferReader(byte[] buffer, Allocator copyAllocator, int length = -1, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------|---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| System.Byte\[\] | buffer | The buffer to copy from |
+| Allocator | copyAllocator | The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance |
+| System.Int32 | length | The number of bytes to copy (all if this is -1) |
+| System.Int32 | offset | The offset of the buffer to start copying from |
+
+#### FastBufferReader(FastBufferReader, Allocator, Int32, Int32, Allocator)
+
+
+Create a FastBufferReader from another existing FastBufferReader. This
+is typically used when you want to change the copyAllocator that a
+reader is allocated to - for example, upgrading a Temp reader to a
+Persistent one to be processed later.
+
+A new buffer will be created using the given and the value will be
+copied in. FastBufferReader will then own the data.
+
+The exception to this is when the passed in is Allocator.None. In this
+scenario, ownership of the data remains with the caller and the reader
+will point at it directly. When created with Allocator.None,
+FastBufferReader will allocate some internal data using Allocator.Temp,
+so it should be treated as if it's a ref struct and not allowed to
+outlive the context in which it was created (it should neither be
+returned from that function nor stored anywhere in heap memory).
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferReader(FastBufferReader reader, Allocator copyAllocator, int length = -1, int offset = 0, Allocator internalAllocator = null)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| FastBufferReader | reader | The reader to copy from |
+| Allocator | copyAllocator | The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance |
+| System.Int32 | length | The number of bytes to copy (all if this is -1) |
+| System.Int32 | offset | The offset of the buffer to start copying from |
+| Allocator | internalAllocator | The allocator type used for internal data when this reader points directly at a buffer owned by someone else |
+
+#### FastBufferReader(FastBufferWriter, Allocator, Int32, Int32, Allocator)
+
+
+Create a FastBufferReader from a FastBufferWriter.
+
+A new buffer will be created using the given and the value will be
+copied in. FastBufferReader will then own the data.
+
+The exception to this is when the passed in is Allocator.None. In this
+scenario, ownership of the data remains with the caller and the reader
+will point at it directly. When created with Allocator.None,
+FastBufferReader will allocate some internal data using Allocator.Temp,
+so it should be treated as if it's a ref struct and not allowed to
+outlive the context in which it was created (it should neither be
+returned from that function nor stored anywhere in heap memory). This is
+true, unless the param is explicitly set to i.e.: Allocator.Persistent
+in which case it would allow the internal data to Persist for longer,
+but the caller should manually call Dispose() when it is no longer
+needed.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferReader(FastBufferWriter writer, Allocator copyAllocator, int length = -1, int offset = 0, Allocator internalAllocator = null)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| FastBufferWriter | writer | The writer to copy from |
+| Allocator | copyAllocator | The allocator type used for internal data when copying an existing buffer if other than Allocator.None is specified, that memory will be owned by this FastBufferReader instance |
+| System.Int32 | length | The number of bytes to copy (all if this is -1) |
+| System.Int32 | offset | The offset of the buffer to start copying from |
+| Allocator | internalAllocator | The allocator type used for internal data when this reader points directly at a buffer owned by someone else |
+
+### Properties
+
+#### IsInitialized
+
+
+Gets a value indicating whether the reader has been initialized and a
+handle allocated.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly bool IsInitialized { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+#### Length
+
+
+Get the total length of the buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly int Length { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+#### Position
+
+
+Get the current read position
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly int Position { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+### Methods
+
+#### Dispose()
+
+
+System.IDisposable implementation that frees the allocated buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void Dispose()
+```
+
+
+
+#### EnterBitwiseContext()
+
+
+Retrieve a BitReader to be able to perform bitwise operations on the
+buffer. No bytewise operations can be performed on the buffer until
+bitReader.Dispose() has been called. At the end of the operation,
+FastBufferReader will remain byte-aligned.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public BitReader EnterBitwiseContext()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|-----------|-------------|
+| BitReader | A BitReader |
+
+#### GetUnsafePtr()
+
+
+Gets a direct pointer to the underlying buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public byte *GetUnsafePtr()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|---------------|---------------------|
+| System.Byte\* | System.Byte pointer |
+
+#### GetUnsafePtrAtCurrentPosition()
+
+
+Gets a direct pointer to the underlying buffer at the current read
+position
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public byte *GetUnsafePtrAtCurrentPosition()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|---------------|---------------------|
+| System.Byte\* | System.Byte pointer |
+
+#### ReadByte(out Byte)
+
+
+Read a byte to the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadByte(out byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|-----------------------|
+| System.Byte | value | Stores the read value |
+
+#### ReadBytes(Byte\*, Int32, Int32)
+
+
+Read multiple bytes to the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadBytes(byte *value, int size, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|--------|---------------------------------------------------|
+| System.Byte\* | value | Pointer to the destination buffer |
+| System.Int32 | size | Number of bytes to read - MUST BE \<= BUFFER SIZE |
+| System.Int32 | offset | Offset of the byte buffer to store into |
+
+#### ReadBytes(ref Byte\[\], Int32, Int32)
+
+
+Read multiple bytes from the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadBytes(ref byte[] value, int size, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------|--------|---------------------------------------------------|
+| System.Byte\[\] | value | Pointer to the destination buffer |
+| System.Int32 | size | Number of bytes to read - MUST BE \<= BUFFER SIZE |
+| System.Int32 | offset | Offset of the byte buffer to store into |
+
+#### ReadByteSafe(out Byte)
+
+
+Read a byte to the stream.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadByteSafe(out byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|-----------------------|
+| System.Byte | value | Stores the read value |
+
+#### ReadBytesSafe(Byte\*, Int32, Int32)
+
+
+Read multiple bytes to the stream
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadBytesSafe(byte *value, int size, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|--------|---------------------------------------------------|
+| System.Byte\* | value | Pointer to the destination buffer |
+| System.Int32 | size | Number of bytes to read - MUST BE \<= BUFFER SIZE |
+| System.Int32 | offset | Offset of the byte buffer to store into |
+
+#### ReadBytesSafe(ref Byte\[\], Int32, Int32)
+
+
+Read multiple bytes from the stream
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadBytesSafe(ref byte[] value, int size, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------|--------|---------------------------------------------------|
+| System.Byte\[\] | value | Pointer to the destination buffer |
+| System.Int32 | size | Number of bytes to read - MUST BE \<= BUFFER SIZE |
+| System.Int32 | offset | Offset of the byte buffer to store into |
+
+#### ReadNetworkSerializable\(out T)
+
+
+Read an INetworkSerializable
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadNetworkSerializable(out T value)
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------------------------|
+| T | value | INetworkSerializable instance |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+##### Exceptions
+
+| Type | Condition |
+|--------------------------------|-----------|
+| System.NotImplementedException | |
+
+#### ReadNetworkSerializable\(out T\[\])
+
+
+Read an array of INetworkSerializables
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadNetworkSerializable(out T[] value)
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------------------|
+| T\[\] | value | INetworkSerializable instance |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-----------------------------------------------|
+| T | the array to read the values of type `T` into |
+
+##### Exceptions
+
+| Type | Condition |
+|--------------------------------|-----------|
+| System.NotImplementedException | |
+
+#### ReadPartialValue\(out T, Int32, Int32)
+
+
+Read a partial value. The value is zero-initialized and then the
+specified number of bytes is read into it.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadPartialValue(out T value, int bytesToRead, int offsetBytes = 0)
+ where T : struct
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------------|------------------------------------------|
+| T | value | Value to read |
+| System.Int32 | bytesToRead | Number of bytes |
+| System.Int32 | offsetBytes | Offset into the value to write the bytes |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------------------|
+| T | the type value to read the value into |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|-----------|
+| System.InvalidOperationException | |
+| System.OverflowException | |
+
+#### ReadValue(out Color)
+
+
+Read a Color
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Color value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------|
+| Color | value | the value to read |
+
+#### ReadValue(out Color\[\])
+
+
+Read a Color array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Color[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------|
+| Color\[\] | value | the values to read |
+
+#### ReadValue(out Color32)
+
+
+Read a Color32
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Color32 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Color32 | value | the value to read |
+
+#### ReadValue(out Color32\[\])
+
+
+Read a Color32 array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Color32[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Color32\[\] | value | the values to read |
+
+#### ReadValue(out Quaternion)
+
+
+Read a Quaternion
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Quaternion value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------|
+| Quaternion | value | the value to read |
+
+#### ReadValue(out Quaternion\[\])
+
+
+Read a Quaternion array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Quaternion[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------|
+| Quaternion\[\] | value | the values to read |
+
+#### ReadValue(out Ray)
+
+
+Read a Ray
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Ray value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------------|
+| Ray | value | the value to read |
+
+#### ReadValue(out Ray\[\])
+
+
+Read a Ray array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Ray[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Ray\[\] | value | the values to read |
+
+#### ReadValue(out Ray2D)
+
+
+Read a Ray2D
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Ray2D value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------|
+| Ray2D | value | the value to read |
+
+#### ReadValue(out Ray2D\[\])
+
+
+Read a Ray2D array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Ray2D[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------|
+| Ray2D\[\] | value | the values to read |
+
+#### ReadValue(out String, Boolean)
+
+
+Reads a string NOTE: ALLOCATES
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|--------------------------------------------------------------------------|
+| System.String | s | Stores the read string |
+| System.Boolean | oneByteChars | Whether or not to use one byte per character. This will only allow ASCII |
+
+#### ReadValue(out Vector2)
+
+
+Read a Vector2
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector2 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Vector2 | value | the value to read |
+
+#### ReadValue(out Vector2\[\])
+
+
+Read a Vector2 array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector2[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Vector2\[\] | value | the values to read |
+
+#### ReadValue(out Vector2Int)
+
+
+Read a Vector2Int
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector2Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------|
+| Vector2Int | value | the value to read |
+
+#### ReadValue(out Vector2Int\[\])
+
+
+Read a Vector2Int array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector2Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------|
+| Vector2Int\[\] | value | the values to read |
+
+#### ReadValue(out Vector3)
+
+
+Read a Vector3
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector3 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Vector3 | value | the value to read |
+
+#### ReadValue(out Vector3\[\])
+
+
+Read a Vector3 array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector3[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Vector3\[\] | value | the values to read |
+
+#### ReadValue(out Vector3Int)
+
+
+Read a Vector3Int
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector3Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------|
+| Vector3Int | value | the value to read |
+
+#### ReadValue(out Vector3Int\[\])
+
+
+Read a Vector3Int array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector3Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|-------------------|
+| Vector3Int\[\] | value | the value to read |
+
+#### ReadValue(out Vector4)
+
+
+Read a Vector4
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector4 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Vector4 | value | the value to read |
+
+#### ReadValue(out Vector4\[\])
+
+
+Read a Vector4
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out Vector4[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Vector4\[\] | value | the values to read |
+
+#### ReadValue\(out T, FastBufferWriter.ForEnums)
+
+
+Read an enum value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T, FastBufferWriter.ForFixedStrings)
+
+
+Read a FixedString value. This method is a little difficult to use,
+since you have to know the size of the string before reading it, but is
+useful when the string is a known, fixed size. Note that the size of the
+string is also encoded, so the size to call TryBeginRead on is actually
+the fixed size (in bytes) plus sizeof(int)
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T value, FastBufferWriter.ForFixedStrings unused = default(FastBufferWriter.ForFixedStrings))
+ where T : struct, INativeList, IUTF8Bytes
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | the value to read |
+| FastBufferWriter.ForFixedStrings | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T, FastBufferWriter.ForNetworkSerializable)
+
+
+Read a NetworkSerializable value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T, FastBufferWriter.ForPrimitives)
+
+
+Read a primitive value (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T, FastBufferWriter.ForStructs)
+
+
+Read a struct
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T\[\], FastBufferWriter.ForEnums)
+
+
+Read an enum array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T[] value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T\[\], FastBufferWriter.ForNetworkSerializable)
+
+
+Read a NetworkSerializable array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T[] value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T\[\], FastBufferWriter.ForPrimitives)
+
+
+Read a primitive value array (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T[] value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValue\(out T\[\], FastBufferWriter.ForStructs)
+
+
+Read a struct array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValue(out T[] value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe(out Color)
+
+
+Read a Color
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Color value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------|
+| Color | value | the value to read |
+
+#### ReadValueSafe(out Color\[\])
+
+
+Read a Collor array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Color[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------|
+| Color\[\] | value | the values to read |
+
+#### ReadValueSafe(out Color32)
+
+
+Read a Color32
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Color32 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Color32 | value | the value to read |
+
+#### ReadValueSafe(out Color32\[\])
+
+
+Read a Color32 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Color32[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Color32\[\] | value | the values to read |
+
+#### ReadValueSafe(out Quaternion)
+
+
+Read a Quaternion
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Quaternion value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------|
+| Quaternion | value | the value to read |
+
+#### ReadValueSafe(out Quaternion\[\])
+
+
+Read a Quaternion array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Quaternion[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------|
+| Quaternion\[\] | value | the values to read |
+
+#### ReadValueSafe(out Ray)
+
+
+Read a Ray
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Ray value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------------|
+| Ray | value | the value to read |
+
+#### ReadValueSafe(out Ray\[\])
+
+
+Read a Ray array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Ray[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Ray\[\] | value | the values to read |
+
+#### ReadValueSafe(out Ray2D)
+
+
+Read a Ray2D
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Ray2D value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------|
+| Ray2D | value | the value to read |
+
+#### ReadValueSafe(out Ray2D\[\])
+
+
+Read a Ray2D array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Ray2D[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------|
+| Ray2D\[\] | value | the values to read |
+
+#### ReadValueSafe(out String, Boolean)
+
+
+Reads a string. NOTE: ALLOCATES
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|--------------------------------------------------------------------------|
+| System.String | s | Stores the read string |
+| System.Boolean | oneByteChars | Whether or not to use one byte per character. This will only allow ASCII |
+
+#### ReadValueSafe(out Vector2)
+
+
+Read a Vector2
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector2 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Vector2 | value | the value to read |
+
+#### ReadValueSafe(out Vector2\[\])
+
+
+Read a Vector2 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector2[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Vector2\[\] | value | the values to read |
+
+#### ReadValueSafe(out Vector2Int)
+
+
+Read a Vector2Int
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector2Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------|
+| Vector2Int | value | the value to read |
+
+#### ReadValueSafe(out Vector2Int\[\])
+
+
+Read a Vector2Int array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector2Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------|
+| Vector2Int\[\] | value | the values to read |
+
+#### ReadValueSafe(out Vector3)
+
+
+Read a Vector3
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector3 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Vector3 | value | the value to read |
+
+#### ReadValueSafe(out Vector3\[\])
+
+
+Read a Vector3 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector3[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Vector3\[\] | value | the values to read |
+
+#### ReadValueSafe(out Vector3Int)
+
+
+Read a Vector3Int
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector3Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------|
+| Vector3Int | value | the value to read |
+
+#### ReadValueSafe(out Vector3Int\[\])
+
+
+Read a Vector3Int array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector3Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------|
+| Vector3Int\[\] | value | the values to read |
+
+#### ReadValueSafe(out Vector4)
+
+
+Read a Vector4
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector4 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------|
+| Vector4 | value | the value to read |
+
+#### ReadValueSafe(out Vector4\[\])
+
+
+Read a Vector4 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out Vector4[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------|
+| Vector4\[\] | value | the values to read |
+
+#### ReadValueSafe\(out T, FastBufferWriter.ForEnums)
+
+
+Read an enum value
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T, FastBufferWriter.ForFixedStrings)
+
+
+Read a FixedString value.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T value, FastBufferWriter.ForFixedStrings unused = default(FastBufferWriter.ForFixedStrings))
+ where T : struct, INativeList, IUTF8Bytes
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | the value to read |
+| FastBufferWriter.ForFixedStrings | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T, FastBufferWriter.ForNetworkSerializable)
+
+
+Read a NetworkSerializable value
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T, FastBufferWriter.ForPrimitives)
+
+
+Read a primitive value (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T, FastBufferWriter.ForStructs)
+
+
+Read a struct
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T\[\], FastBufferWriter.ForEnums)
+
+
+Read an enum array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T[] value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T\[\], FastBufferWriter.ForNetworkSerializable)
+
+
+Read a NetworkSerializable array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T[] value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T\[\], FastBufferWriter.ForPrimitives)
+
+
+Read a primitive value (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T[] value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The value to read |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### ReadValueSafe\(out T\[\], FastBufferWriter.ForStructs)
+
+
+Read a struct array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple reads at once by calling TryBeginRead.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void ReadValueSafe(out T[] value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to read |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### Seek(Int32)
+
+
+Move the read position in the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void Seek(int where)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------|-------------------------------------------------------------|
+| System.Int32 | where | Absolute value to move the position to, truncated to Length |
+
+#### ToArray()
+
+
+Returns an array representation of the underlying byte buffer.
+!!Allocates a new array!!
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public byte[] ToArray()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|-----------------|-------------|
+| System.Byte\[\] | byte array |
+
+#### TryBeginRead(Int32)
+
+
+Allows faster serialization by batching bounds checking. When you know
+you will be reading multiple fields back-to-back and you know the total
+size, you can call TryBeginRead() once on the total size, and then
+follow it with calls to ReadValue() instead of ReadValueSafe() for
+faster serialization.
+
+Unsafe read operations will throw OverflowException in editor and
+development builds if you go past the point you've marked using
+TryBeginRead(). In release builds, OverflowException will not be thrown
+for performance reasons, since the point of using TryBeginRead is to
+avoid bounds checking in the following operations in release builds.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool TryBeginRead(int bytes)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------|-------------------------|
+| System.Int32 | bytes | Amount of bytes to read |
+
+##### Returns
+
+| Type | Description |
+|----------------|----------------------------------------------|
+| System.Boolean | True if the read is allowed, false otherwise |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|--------------------------------------|
+| System.InvalidOperationException | If called while in a bitwise context |
+
+#### TryBeginReadValue\(in T)
+
+
+Allows faster serialization by batching bounds checking. When you know
+you will be reading multiple fields back-to-back and you know the total
+size, you can call TryBeginRead() once on the total size, and then
+follow it with calls to ReadValue() instead of ReadValueSafe() for
+faster serialization.
+
+Unsafe read operations will throw OverflowException in editor and
+development builds if you go past the point you've marked using
+TryBeginRead(). In release builds, OverflowException will not be thrown
+for performance reasons, since the point of using TryBeginRead is to
+avoid bounds checking in the following operations in release builds.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool TryBeginReadValue(in T value)
+ where T : struct
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|----------------------------|
+| T | value | The value you want to read |
+
+##### Returns
+
+| Type | Description |
+|----------------|----------------------------------------------|
+| System.Boolean | True if the read is allowed, false otherwise |
+
+##### Type Parameters
+
+| Name | Description |
+|------|--------------------------------------------------|
+| T | the type `T` of the value you are trying to read |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|--------------------------------------|
+| System.InvalidOperationException | If called while in a bitwise context |
+
+### Implements
+
+
+
+System.IDisposable
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForEnums.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForEnums.md
new file mode 100644
index 000000000..da359b9e3
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForEnums.md
@@ -0,0 +1,79 @@
+---
+id: Unity.Netcode.FastBufferWriter.ForEnums
+title: Unity.Netcode.FastBufferWriter.ForEnums
+---
+
+# Struct FastBufferWriter.ForEnums
+
+
+This empty struct exists to allow overloading WriteValue based on
+generic constraints. At the bytecode level, constraints aren't included
+in the method signature, so if multiple methods exist with the same
+signature, it causes a compile error because they would end up being
+emitted as the same method, even if the constraints are different.
+Adding an empty struct with a default value gives them different
+signatures in the bytecode, which then allows the compiler to do
+overload resolution based on the generic constraints without the user
+having to pass the struct in themselves.
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ForEnums
+```
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForFixedStrings.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForFixedStrings.md
new file mode 100644
index 000000000..67db70d45
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForFixedStrings.md
@@ -0,0 +1,79 @@
+---
+id: Unity.Netcode.FastBufferWriter.ForFixedStrings
+title: Unity.Netcode.FastBufferWriter.ForFixedStrings
+---
+
+# Struct FastBufferWriter.ForFixedStrings
+
+
+This empty struct exists to allow overloading WriteValue based on
+generic constraints. At the bytecode level, constraints aren't included
+in the method signature, so if multiple methods exist with the same
+signature, it causes a compile error because they would end up being
+emitted as the same method, even if the constraints are different.
+Adding an empty struct with a default value gives them different
+signatures in the bytecode, which then allows the compiler to do
+overload resolution based on the generic constraints without the user
+having to pass the struct in themselves.
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ForFixedStrings
+```
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForNetworkSerializable.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForNetworkSerializable.md
new file mode 100644
index 000000000..a22b81baa
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForNetworkSerializable.md
@@ -0,0 +1,79 @@
+---
+id: Unity.Netcode.FastBufferWriter.ForNetworkSerializable
+title: Unity.Netcode.FastBufferWriter.ForNetworkSerializable
+---
+
+# Struct FastBufferWriter.ForNetworkSerializable
+
+
+This empty struct exists to allow overloading WriteValue based on
+generic constraints. At the bytecode level, constraints aren't included
+in the method signature, so if multiple methods exist with the same
+signature, it causes a compile error because they would end up being
+emitted as the same method, even if the constraints are different.
+Adding an empty struct with a default value gives them different
+signatures in the bytecode, which then allows the compiler to do
+overload resolution based on the generic constraints without the user
+having to pass the struct in themselves.
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ForNetworkSerializable
+```
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForPrimitives.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForPrimitives.md
new file mode 100644
index 000000000..f13ef9e15
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForPrimitives.md
@@ -0,0 +1,79 @@
+---
+id: Unity.Netcode.FastBufferWriter.ForPrimitives
+title: Unity.Netcode.FastBufferWriter.ForPrimitives
+---
+
+# Struct FastBufferWriter.ForPrimitives
+
+
+This empty struct exists to allow overloading WriteValue based on
+generic constraints. At the bytecode level, constraints aren't included
+in the method signature, so if multiple methods exist with the same
+signature, it causes a compile error because they would end up being
+emitted as the same method, even if the constraints are different.
+Adding an empty struct with a default value gives them different
+signatures in the bytecode, which then allows the compiler to do
+overload resolution based on the generic constraints without the user
+having to pass the struct in themselves.
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ForPrimitives
+```
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForStructs.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForStructs.md
new file mode 100644
index 000000000..97acaa0ef
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.ForStructs.md
@@ -0,0 +1,79 @@
+---
+id: Unity.Netcode.FastBufferWriter.ForStructs
+title: Unity.Netcode.FastBufferWriter.ForStructs
+---
+
+# Struct FastBufferWriter.ForStructs
+
+
+This empty struct exists to allow overloading WriteValue based on
+generic constraints. At the bytecode level, constraints aren't included
+in the method signature, so if multiple methods exist with the same
+signature, it causes a compile error because they would end up being
+emitted as the same method, even if the constraints are different.
+Adding an empty struct with a default value gives them different
+signatures in the bytecode, which then allows the compiler to do
+overload resolution based on the generic constraints without the user
+having to pass the struct in themselves.
+
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ForStructs
+```
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.md
new file mode 100644
index 000000000..4a1463397
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.FastBufferWriter.md
@@ -0,0 +1,2864 @@
+---
+id: Unity.Netcode.FastBufferWriter
+title: Unity.Netcode.FastBufferWriter
+---
+
+# Struct FastBufferWriter
+
+
+Optimized class used for writing values into a byte stream
+FastBufferReader BytePacker ByteUnpacker
+
+
+
+
+
+
+
+##### Implements
+
+
+
+System.IDisposable
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct FastBufferWriter : IDisposable
+```
+
+
+
+### Constructors
+
+#### FastBufferWriter(Int32, Allocator, Int32)
+
+
+Create a FastBufferWriter.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public FastBufferWriter(int size, Allocator allocator, int maxSize = -1)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-----------|-----------------------------------------------------------------------------|
+| System.Int32 | size | Size of the buffer to create |
+| Allocator | allocator | Allocator to use in creating it |
+| System.Int32 | maxSize | Maximum size the buffer can grow to. If less than size, buffer cannot grow. |
+
+### Properties
+
+#### Capacity
+
+
+The current total buffer size
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly int Capacity { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+#### IsInitialized
+
+
+Gets a value indicating whether the writer has been initialized and a
+handle allocated.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly bool IsInitialized { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+#### Length
+
+
+The total amount of bytes that have been written to the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly int Length { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+#### MaxCapacity
+
+
+The maximum possible total buffer size
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly int MaxCapacity { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+#### Position
+
+
+The current write position
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public readonly int Position { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+### Methods
+
+#### CopyFrom(FastBufferWriter)
+
+
+Copy the contents of another writer into this writer. The contents will
+be copied from the beginning of the other writer to its current
+position. They will be copied to this writer starting at this writer's
+current position.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void CopyFrom(FastBufferWriter other)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-------|-------------------|
+| FastBufferWriter | other | Writer to copy to |
+
+#### CopyTo(FastBufferWriter)
+
+
+Copy the contents of this writer into another writer. The contents will
+be copied from the beginning of this writer to its current position.
+They will be copied to the other writer starting at the other writer's
+current position.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void CopyTo(FastBufferWriter other)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------|-------|-------------------|
+| FastBufferWriter | other | Writer to copy to |
+
+#### Dispose()
+
+
+System.IDisposable implementation that frees the allocated buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void Dispose()
+```
+
+
+
+#### EnterBitwiseContext()
+
+
+Retrieve a BitWriter to be able to perform bitwise operations on the
+buffer. No bytewise operations can be performed on the buffer until
+bitWriter.Dispose() has been called. At the end of the operation,
+FastBufferWriter will remain byte-aligned.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public BitWriter EnterBitwiseContext()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|-----------|-------------|
+| BitWriter | A BitWriter |
+
+#### GetUnsafePtr()
+
+
+Gets a direct pointer to the underlying buffer
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public byte *GetUnsafePtr()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|---------------|-------------|
+| System.Byte\* | |
+
+#### GetUnsafePtrAtCurrentPosition()
+
+
+Gets a direct pointer to the underlying buffer at the current read
+position
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public byte *GetUnsafePtrAtCurrentPosition()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|---------------|-------------|
+| System.Byte\* | |
+
+#### GetWriteSize(String, Boolean)
+
+
+Get the required size to write a string
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetWriteSize(string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|--------------------------------------------------------------------------|
+| System.String | s | The string to write |
+| System.Boolean | oneByteChars | Whether or not to use one byte per character. This will only allow ASCII |
+
+##### Returns
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+#### GetWriteSize\()
+
+
+Get the size required to write an unmanaged value of type T
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetWriteSize()
+ where T : struct
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+#### GetWriteSize\(in T)
+
+
+Get the write size for a FixedString
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetWriteSize(in T value)
+ where T : struct, INativeList, IUTF8Bytes
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------|
+| T | value | |
+
+##### Returns
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+#### GetWriteSize\(in T, FastBufferWriter.ForStructs)
+
+
+Get the write size for any general unmanaged value The ForStructs value
+here makes this the lowest-priority overload so other versions will be
+prioritized over this if they match
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetWriteSize(in T value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|-------------|
+| T | value | |
+| FastBufferWriter.ForStructs | unused | |
+
+##### Returns
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+#### GetWriteSize\(T\[\], Int32, Int32)
+
+
+Get the required size to write an unmanaged array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static int GetWriteSize(T[] array, int count = -1, int offset = 0)
+ where T : struct
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|--------|---------------------------------|
+| T\[\] | array | The array to write |
+| System.Int32 | count | The amount of elements to write |
+| System.Int32 | offset | Where in the array to start |
+
+##### Returns
+
+| Type | Description |
+|--------------|-------------|
+| System.Int32 | |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+#### Seek(Int32)
+
+
+Move the write position in the stream. Note that moving forward past the
+current length will extend the buffer's Length value even if you don't
+write.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void Seek(int where)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------|---------------------------------------------------------------|
+| System.Int32 | where | Absolute value to move the position to, truncated to Capacity |
+
+#### ToArray()
+
+
+Returns an array representation of the underlying byte buffer.
+!!Allocates a new array!!
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public byte[] ToArray()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|-----------------|-------------|
+| System.Byte\[\] | |
+
+#### Truncate(Int32)
+
+
+Truncate the stream by setting Length to the specified value. If
+Position is greater than the specified value, it will be moved as well.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void Truncate(int where = -1)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------|---------------------------------------------------------------------|
+| System.Int32 | where | The value to truncate to. If -1, the current position will be used. |
+
+#### TryBeginWrite(Int32)
+
+
+Allows faster serialization by batching bounds checking. When you know
+you will be writing multiple fields back-to-back and you know the total
+size, you can call TryBeginWrite() once on the total size, and then
+follow it with calls to WriteValue() instead of WriteValueSafe() for
+faster serialization.
+
+Unsafe write operations will throw OverflowException in editor and
+development builds if you go past the point you've marked using
+TryBeginWrite(). In release builds, OverflowException will not be thrown
+for performance reasons, since the point of using TryBeginWrite is to
+avoid bounds checking in the following operations in release builds.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool TryBeginWrite(int bytes)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------|--------------------------|
+| System.Int32 | bytes | Amount of bytes to write |
+
+##### Returns
+
+| Type | Description |
+|----------------|-----------------------------------------------|
+| System.Boolean | True if the write is allowed, false otherwise |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|--------------------------------------|
+| System.InvalidOperationException | If called while in a bitwise context |
+
+#### TryBeginWriteInternal(Int32)
+
+
+Internal version of TryBeginWrite. Differs from TryBeginWrite only in
+that it won't ever move the AllowedWriteMark backward.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool TryBeginWriteInternal(int bytes)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|-------|-------------|
+| System.Int32 | bytes | |
+
+##### Returns
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|-----------|
+| System.InvalidOperationException | |
+
+#### TryBeginWriteValue\(in T)
+
+
+Allows faster serialization by batching bounds checking. When you know
+you will be writing multiple fields back-to-back and you know the total
+size, you can call TryBeginWrite() once on the total size, and then
+follow it with calls to WriteValue() instead of WriteValueSafe() for
+faster serialization.
+
+Unsafe write operations will throw OverflowException in editor and
+development builds if you go past the point you've marked using
+TryBeginWrite(). In release builds, OverflowException will not be thrown
+for performance reasons, since the point of using TryBeginWrite is to
+avoid bounds checking in the following operations in release builds.
+Instead, attempting to write past the marked position in release builds
+will write to random memory and cause undefined behavior, likely
+including instability and crashes.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool TryBeginWriteValue(in T value)
+ where T : struct
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|---------------------------------------------|
+| T | value | The value of the type `T` you want to write |
+
+##### Returns
+
+| Type | Description |
+|----------------|-----------------------------------------------|
+| System.Boolean | True if the write is allowed, false otherwise |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------|
+| T | The value type to write |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|--------------------------------------|
+| System.InvalidOperationException | If called while in a bitwise context |
+
+#### WriteByte(Byte)
+
+
+Write a byte to the stream.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteByte(byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|----------------|
+| System.Byte | value | Value to write |
+
+#### WriteBytes(Byte\*, Int32, Int32)
+
+
+Write multiple bytes to the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteBytes(byte *value, int size, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|--------|-----------------------------------------|
+| System.Byte\* | value | Value to write |
+| System.Int32 | size | Number of bytes to write |
+| System.Int32 | offset | Offset into the buffer to begin writing |
+
+#### WriteBytes(Byte\[\], Int32, Int32)
+
+
+Write multiple bytes to the stream
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteBytes(byte[] value, int size = -1, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------|--------|-----------------------------------------|
+| System.Byte\[\] | value | Value to write |
+| System.Int32 | size | Number of bytes to write |
+| System.Int32 | offset | Offset into the buffer to begin writing |
+
+#### WriteByteSafe(Byte)
+
+
+Write a byte to the stream.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteByteSafe(byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|----------------|
+| System.Byte | value | Value to write |
+
+#### WriteBytesSafe(Byte\*, Int32, Int32)
+
+
+Write multiple bytes to the stream
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteBytesSafe(byte *value, int size, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|--------|-----------------------------------------|
+| System.Byte\* | value | Value to write |
+| System.Int32 | size | Number of bytes to write |
+| System.Int32 | offset | Offset into the buffer to begin writing |
+
+#### WriteBytesSafe(Byte\[\], Int32, Int32)
+
+
+Write multiple bytes to the stream
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteBytesSafe(byte[] value, int size = -1, int offset = 0)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------|--------|-----------------------------------------|
+| System.Byte\[\] | value | Value to write |
+| System.Int32 | size | Number of bytes to write |
+| System.Int32 | offset | Offset into the buffer to begin writing |
+
+#### WriteNetworkSerializable\(in T)
+
+
+Write an INetworkSerializable
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteNetworkSerializable(in T value)
+ where T : INetworkSerializable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|--------------------|
+| T | value | The value to write |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+#### WriteNetworkSerializable\(T\[\], Int32, Int32)
+
+
+Write an array of INetworkSerializables
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteNetworkSerializable(T[] array, int count = -1, int offset = 0)
+ where T : INetworkSerializable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|--------|--------------------|
+| T\[\] | array | The value to write |
+| System.Int32 | count | |
+| System.Int32 | offset | |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+#### WritePartialValue\(T, Int32, Int32)
+
+
+Write a partial value. The specified number of bytes is written from the
+value and the rest is ignored.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WritePartialValue(T value, int bytesToWrite, int offsetBytes = 0)
+ where T : struct
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|--------------|--------------------------------------------------|
+| T | value | Value to write |
+| System.Int32 | bytesToWrite | Number of bytes |
+| System.Int32 | offsetBytes | Offset into the value to begin reading the bytes |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+##### Exceptions
+
+| Type | Condition |
+|----------------------------------|-----------|
+| System.InvalidOperationException | |
+| System.OverflowException | |
+
+#### WriteValue(in Color)
+
+
+Write a Color
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Color value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|--------------------|
+| Color | value | the value to write |
+
+#### WriteValue(Color\[\])
+
+
+Write a Color array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Color[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|---------------------|
+| Color\[\] | value | the values to write |
+
+#### WriteValue(in Color32)
+
+
+Write a Color32
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Color32 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Color32 | value | the value to write |
+
+#### WriteValue(Color32\[\])
+
+
+Write a Color32 array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Color32[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Color32\[\] | value | the values to write |
+
+#### WriteValue(in Quaternion)
+
+
+Write a Quaternion
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Quaternion value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|--------------------|
+| Quaternion | value | the value to write |
+
+#### WriteValue(Quaternion\[\])
+
+
+Write a Quaternion array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Quaternion[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|---------------------|
+| Quaternion\[\] | value | the values to write |
+
+#### WriteValue(in Ray)
+
+
+Write a Ray
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Ray value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|--------------------|
+| Ray | value | the value to write |
+
+#### WriteValue(Ray\[\])
+
+
+Write a Ray array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Ray[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|---------------------|
+| Ray\[\] | value | the values to write |
+
+#### WriteValue(in Ray2D)
+
+
+Write a Ray2D
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Ray2D value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|--------------------|
+| Ray2D | value | the value to write |
+
+#### WriteValue(Ray2D\[\])
+
+
+Write a Ray2D array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Ray2D[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|---------------------|
+| Ray2D\[\] | value | the values to write |
+
+#### WriteValue(String, Boolean)
+
+
+Writes a string
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|--------------------------------------------------------------------------|
+| System.String | s | The string to write |
+| System.Boolean | oneByteChars | Whether or not to use one byte per character. This will only allow ASCII |
+
+#### WriteValue(in Vector2)
+
+
+Write a Vector2
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Vector2 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Vector2 | value | the value to write |
+
+#### WriteValue(Vector2\[\])
+
+
+Write a Vector2 array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Vector2[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Vector2\[\] | value | the values to write |
+
+#### WriteValue(in Vector2Int)
+
+
+Write a Vector2Int
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Vector2Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|--------------------|
+| Vector2Int | value | the value to write |
+
+#### WriteValue(Vector2Int\[\])
+
+
+Write a Vector2Int array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Vector2Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|---------------------|
+| Vector2Int\[\] | value | the values to write |
+
+#### WriteValue(in Vector3)
+
+
+Write a Vector3
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Vector3 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Vector3 | value | the value to write |
+
+#### WriteValue(Vector3\[\])
+
+
+Write a Vector3 array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Vector3[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Vector3\[\] | value | the values to write |
+
+#### WriteValue(in Vector3Int)
+
+
+Write a Vector3Int
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Vector3Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|--------------------|
+| Vector3Int | value | the value to write |
+
+#### WriteValue(Vector3Int\[\])
+
+
+Write a Vector3Int array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Vector3Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------|
+| Vector3Int\[\] | value | the value to write |
+
+#### WriteValue(in Vector4)
+
+
+Write a Vector4
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in Vector4 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Vector4 | value | the value to write |
+
+#### WriteValue(Vector4\[\])
+
+
+Write a Vector4
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(Vector4[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Vector4\[\] | value | the values to write |
+
+#### WriteValue\(in T, FastBufferWriter.ForEnums)
+
+
+Write an enum value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in T value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(in T, FastBufferWriter.ForFixedStrings)
+
+
+Write a FixedString value. Writes only the part of the string that's
+actually used. When calling TryBeginWrite, ensure you calculate the
+write size correctly (preferably by calling
+FastBufferWriter.GetWriteSize())
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in T value, FastBufferWriter.ForFixedStrings unused = default(FastBufferWriter.ForFixedStrings))
+ where T : struct, INativeList, IUTF8Bytes
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | the value to write |
+| FastBufferWriter.ForFixedStrings | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(in T, FastBufferWriter.ForNetworkSerializable)
+
+
+Write a NetworkSerializable value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in T value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(in T, FastBufferWriter.ForPrimitives)
+
+
+Write a primitive value (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in T value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(in T, FastBufferWriter.ForStructs)
+
+
+Write a struct
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(in T value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(T\[\], FastBufferWriter.ForEnums)
+
+
+Write an enum array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(T[] value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(T\[\], FastBufferWriter.ForNetworkSerializable)
+
+
+Write a NetworkSerializable array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(T[] value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to write |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(T\[\], FastBufferWriter.ForPrimitives)
+
+
+Write a primitive value array (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(T[] value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValue\(T\[\], FastBufferWriter.ForStructs)
+
+
+Write a struct array
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValue(T[] value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe(in Color)
+
+
+Write a Color
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Color value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|--------------------|
+| Color | value | the value to write |
+
+#### WriteValueSafe(Color\[\])
+
+
+Write a Collor array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Color[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|---------------------|
+| Color\[\] | value | the values to write |
+
+#### WriteValueSafe(in Color32)
+
+
+Write a Color32
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Color32 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Color32 | value | the value to write |
+
+#### WriteValueSafe(Color32\[\])
+
+
+Write a Color32 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Color32[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Color32\[\] | value | the values to write |
+
+#### WriteValueSafe(in Quaternion)
+
+
+Write a Quaternion
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Quaternion value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|--------------------|
+| Quaternion | value | the value to write |
+
+#### WriteValueSafe(Quaternion\[\])
+
+
+Write a Quaternion array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Quaternion[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|---------------------|
+| Quaternion\[\] | value | the values to write |
+
+#### WriteValueSafe(in Ray)
+
+
+Write a Ray
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Ray value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|--------------------|
+| Ray | value | the value to write |
+
+#### WriteValueSafe(Ray\[\])
+
+
+Write a Ray array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Ray[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|---------------------|
+| Ray\[\] | value | the values to write |
+
+#### WriteValueSafe(in Ray2D)
+
+
+Write a Ray2D
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Ray2D value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|--------------------|
+| Ray2D | value | the value to write |
+
+#### WriteValueSafe(Ray2D\[\])
+
+
+Write a Ray2D array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Ray2D[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|---------------------|
+| Ray2D\[\] | value | the values to write |
+
+#### WriteValueSafe(String, Boolean)
+
+
+Writes a string
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|--------------------------------------------------------------------------|
+| System.String | s | The string to write |
+| System.Boolean | oneByteChars | Whether or not to use one byte per character. This will only allow ASCII |
+
+#### WriteValueSafe(in Vector2)
+
+
+Write a Vector2
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Vector2 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Vector2 | value | the value to write |
+
+#### WriteValueSafe(Vector2\[\])
+
+
+Write a Vector2 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Vector2[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Vector2\[\] | value | the values to write |
+
+#### WriteValueSafe(in Vector2Int)
+
+
+Write a Vector2Int
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Vector2Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|--------------------|
+| Vector2Int | value | the value to write |
+
+#### WriteValueSafe(Vector2Int\[\])
+
+
+Write a Vector2Int array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Vector2Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|---------------------|
+| Vector2Int\[\] | value | the values to write |
+
+#### WriteValueSafe(in Vector3)
+
+
+Write a Vector3
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Vector3 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Vector3 | value | the value to write |
+
+#### WriteValueSafe(Vector3\[\])
+
+
+Write a Vector3 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Vector3[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Vector3\[\] | value | the values to write |
+
+#### WriteValueSafe(in Vector3Int)
+
+
+Write a Vector3Int
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Vector3Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|--------------------|
+| Vector3Int | value | the value to write |
+
+#### WriteValueSafe(Vector3Int\[\])
+
+
+Write a Vector3Int array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Vector3Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|---------------------|
+| Vector3Int\[\] | value | the values to write |
+
+#### WriteValueSafe(in Vector4)
+
+
+Write a Vector4
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in Vector4 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------|
+| Vector4 | value | the value to write |
+
+#### WriteValueSafe(Vector4\[\])
+
+
+Write a Vector4 array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(Vector4[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|---------------------|
+| Vector4\[\] | value | the values to write |
+
+#### WriteValueSafe\(in T, FastBufferWriter.ForEnums)
+
+
+Write an enum value
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in T value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(in T, FastBufferWriter.ForFixedStrings)
+
+
+Write a FixedString value. Writes only the part of the string that's
+actually used.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in T value, FastBufferWriter.ForFixedStrings unused = default(FastBufferWriter.ForFixedStrings))
+ where T : struct, INativeList, IUTF8Bytes
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | the value to write |
+| FastBufferWriter.ForFixedStrings | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(in T, FastBufferWriter.ForNetworkSerializable)
+
+
+Write a NetworkSerializable value
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in T value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(in T, FastBufferWriter.ForPrimitives)
+
+
+Write a primitive value (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in T value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(in T, FastBufferWriter.ForStructs)
+
+
+Write a struct
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(in T value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(T\[\], FastBufferWriter.ForEnums)
+
+
+Write an enum array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(T[] value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(T\[\], FastBufferWriter.ForNetworkSerializable)
+
+
+Write a NetworkSerializable array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(T[] value, FastBufferWriter.ForNetworkSerializable unused = default(FastBufferWriter.ForNetworkSerializable))
+ where T : INetworkSerializable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to write |
+| FastBufferWriter.ForNetworkSerializable | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(T\[\], FastBufferWriter.ForPrimitives)
+
+
+Write a primitive value (int, bool, etc) Accepts any value that
+implements the given interfaces, but is not guaranteed to work correctly
+on values that are not primitives.
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(T[] value, FastBufferWriter.ForPrimitives unused = default(FastBufferWriter.ForPrimitives))
+ where T : struct, IComparable, IConvertible, IComparable, IEquatable
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The value to write |
+| FastBufferWriter.ForPrimitives | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### WriteValueSafe\(T\[\], FastBufferWriter.ForStructs)
+
+
+Write a struct array
+
+"Safe" version - automatically performs bounds checking. Less efficient
+than bounds checking for multiple writes at once by calling
+TryBeginWrite.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public void WriteValueSafe(T[] value, FastBufferWriter.ForStructs unused = default(FastBufferWriter.ForStructs))
+ where T : struct, INetworkSerializeByMemcpy
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------------|--------|----------------------------------------------------------------------------------------|
+| T\[\] | value | The values to write |
+| FastBufferWriter.ForStructs | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+### Implements
+
+
+
+System.IDisposable
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.ForceNetworkSerializeByMemcpy-1.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.ForceNetworkSerializeByMemcpy-1.md
new file mode 100644
index 000000000..8cc74cd3c
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.ForceNetworkSerializeByMemcpy-1.md
@@ -0,0 +1,323 @@
+---
+id: Unity.Netcode.ForceNetworkSerializeByMemcpy-1
+title: Unity.Netcode.ForceNetworkSerializeByMemcpy-1
+---
+
+# Struct ForceNetworkSerializeByMemcpy\
+
+
+This is a wrapper that adds `INetworkSerializeByMemcpy` support to
+existing structs that the developer doesn't have the ability to modify
+(for example, external structs like `Guid`).
+
+
+
+
+
+
+
+##### Implements
+
+
+
+INetworkSerializeByMemcpy
+
+
+
+
+
+System.IEquatable\\>
+
+
+
+
+
+
+##### Inherited Members
+
+
+
+System.ValueType.ToString()
+
+
+
+
+
+System.Object.Equals(System.Object, System.Object)
+
+
+
+
+
+System.Object.GetType()
+
+
+
+
+
+System.Object.ReferenceEquals(System.Object, System.Object)
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public struct ForceNetworkSerializeByMemcpy : INetworkSerializeByMemcpy, IEquatable> where T : struct, IEquatable
+```
+
+
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------|
+| T | |
+
+### Constructors
+
+#### ForceNetworkSerializeByMemcpy(T)
+
+
+The default constructor for ForceNetworkSerializeByMemcpy\
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public ForceNetworkSerializeByMemcpy(T value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|------------------------------------|
+| T | value | sets the initial value of type `T` |
+
+### Fields
+
+#### Value
+
+
+The wrapped value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public T Value
+```
+
+
+
+##### Field Value
+
+| Type | Description |
+|------|-------------|
+| T | |
+
+### Methods
+
+#### Equals(Object)
+
+
+Check if this value is equal to a boxed object value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public override bool Equals(object obj)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|------|----------------------------------|
+| System.Object | obj | The boxed value to check against |
+
+##### Returns
+
+| Type | Description |
+|----------------|---------------|
+| System.Boolean | true if equal |
+
+##### Overrides
+
+
+
+System.ValueType.Equals(System.Object)
+
+
+
+#### Equals(ForceNetworkSerializeByMemcpy\)
+
+
+Check if wrapped values are equal
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public bool Equals(ForceNetworkSerializeByMemcpy other)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------------------------|-------|---------------|
+| ForceNetworkSerializeByMemcpy\ | other | Other wrapper |
+
+##### Returns
+
+| Type | Description |
+|----------------|---------------|
+| System.Boolean | true if equal |
+
+#### GetHashCode()
+
+
+Obtains the wrapped value's hash code
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public override int GetHashCode()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|--------------|---------------------------|
+| System.Int32 | Wrapped value's hash code |
+
+##### Overrides
+
+
+
+System.ValueType.GetHashCode()
+
+
+
+### Operators
+
+#### Implicit(T to ForceNetworkSerializeByMemcpy\)
+
+
+Convert implicitly from a T value to a ForceNetworkSerializeByMemcpy
+wrapper
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static implicit operator ForceNetworkSerializeByMemcpy(T underlyingValue)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-----------------|-------------|
+| T | underlyingValue | the value |
+
+##### Returns
+
+| Type | Description |
+|------------------------------------|---------------|
+| ForceNetworkSerializeByMemcpy\ | a new wrapper |
+
+#### Implicit(ForceNetworkSerializeByMemcpy\ to T)
+
+
+Convert implicitly from the ForceNetworkSerializeByMemcpy wrapper to the
+underlying value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+public static implicit operator T(ForceNetworkSerializeByMemcpy container)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------------------------------|-----------|-------------|
+| ForceNetworkSerializeByMemcpy\ | container | The wrapper |
+
+##### Returns
+
+| Type | Description |
+|------|----------------------|
+| T | The underlying value |
+
+### Implements
+
+
+
+INetworkSerializeByMemcpy
+
+
+
+
+
+System.IEquatable\
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.HashSize.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.HashSize.md
new file mode 100644
index 000000000..7dd66c93a
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.HashSize.md
@@ -0,0 +1,52 @@
+---
+id: Unity.Netcode.HashSize
+title: Unity.Netcode.HashSize
+---
+
+# Enum HashSize
+
+
+Represents the length of a var int encoded hash Note that the HashSize
+does not say anything about the actual final output due to the var int
+encoding It just says how many bytes the maximum will be
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public enum HashSize : byte
+```
+
+
+
+### Fields
+
+Name
+
+
+
+
+
+
+
+
+
+Description
+
+VarIntEightBytes
+
+Eight byte hash
+
+VarIntFourBytes
+
+Four byte hash
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkPrefabInstanceHandler.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkPrefabInstanceHandler.md
new file mode 100644
index 000000000..08b70bc48
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkPrefabInstanceHandler.md
@@ -0,0 +1,114 @@
+---
+id: Unity.Netcode.INetworkPrefabInstanceHandler
+title: Unity.Netcode.INetworkPrefabInstanceHandler
+---
+
+# Interface INetworkPrefabInstanceHandler
+
+
+Interface for customizing, overriding, spawning, and destroying Network
+Prefabs Used by NetworkPrefabHandler
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public interface INetworkPrefabInstanceHandler
+```
+
+
+
+### Methods
+
+#### Destroy(NetworkObject)
+
+
+Invoked on Client and Server Once an implementation is registered with
+the NetworkPrefabHandler, this method will be called when a Network
+Prefab associated NetworkObject is:
+
+Server Side: destroyed or despawned with the destroy parameter equal to
+true If Despawn(Boolean) is invoked with the default destroy parameter
+(i.e. false) then this method will NOT be invoked!
+
+Client Side: destroyed when the client receives a destroy object message
+from the server or host.
+
+Note on Pooling: When this method is invoked, you do not need to destroy
+the NetworkObject as long as you want your pool to persist. The most
+common approach is to make the NetworkObject inactive by calling .
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void Destroy(NetworkObject networkObject)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|---------------|-----------------------------------|
+| NetworkObject | networkObject | The NetworkObject being destroyed |
+
+#### Instantiate(UInt64, Vector3, Quaternion)
+
+
+Client Side Only Once an implementation is registered with the
+NetworkPrefabHandler, this method will be called every time a Network
+Prefab associated NetworkObject is spawned on clients
+
+Note On Hosts: Use the RegisterHostGlobalObjectIdHashValues(GameObject,
+List\) method to register all targeted NetworkPrefab
+overrides manually since the host will be acting as both a server and
+client.
+
+Note on Pooling: If you are using a NetworkObject pool, don't forget to
+make the NetworkObject active via the method.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+NetworkObject Instantiate(ulong ownerClientId, Vector3 position, Quaternion rotation)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------|---------------|-----------------------------------------------------------------------|
+| System.UInt64 | ownerClientId | the owner for the NetworkObject to be instantiated |
+| Vector3 | position | the initial/default position for the NetworkObject to be instantiated |
+| Quaternion | rotation | the initial/default rotation for the NetworkObject to be instantiated |
+
+##### Returns
+
+| Type | Description |
+|---------------|-------------|
+| NetworkObject | |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkSerializable.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkSerializable.md
new file mode 100644
index 000000000..4f666846e
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkSerializable.md
@@ -0,0 +1,65 @@
+---
+id: Unity.Netcode.INetworkSerializable
+title: Unity.Netcode.INetworkSerializable
+---
+
+# Interface INetworkSerializable
+
+
+Interface for implementing custom serializable types.
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public interface INetworkSerializable
+```
+
+
+
+### Methods
+
+#### NetworkSerialize\(BufferSerializer\)
+
+
+Provides bi-directional serialization to read and write the desired data
+to serialize this type.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void NetworkSerialize(BufferSerializer serializer)
+ where T : IReaderWriter
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------------------|------------|---------------------------------------------------|
+| BufferSerializer\ | serializer | The serializer to use to read and write the data. |
+
+##### Type Parameters
+
+| Name | Description |
+|------|--------------------------------------------------------------------------------------------------------------------------|
+| T | Either BufferSerializerReader or BufferSerializerWriter, depending whether the serializer is in read mode or write mode. |
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkSerializeByMemcpy.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkSerializeByMemcpy.md
new file mode 100644
index 000000000..05d939cf4
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkSerializeByMemcpy.md
@@ -0,0 +1,37 @@
+---
+id: Unity.Netcode.INetworkSerializeByMemcpy
+title: Unity.Netcode.INetworkSerializeByMemcpy
+---
+
+# Interface INetworkSerializeByMemcpy
+
+
+This interface is a "tag" that can be applied to a struct to mark that
+struct as being serializable by memcpy. It's up to the developer of the
+struct to analyze the struct's contents and ensure it is actually
+serializable by memcpy. This requires all of the members of the struct
+to be `unmanaged` Plain-Old-Data values - if your struct contains a
+pointer (or a type that contains a pointer, like `NativeList<T>`), it
+should be serialized via `INetworkSerializable` or via
+`FastBufferReader`/`FastBufferWriter` extension methods.
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public interface INetworkSerializeByMemcpy
+```
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkUpdateSystem.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkUpdateSystem.md
new file mode 100644
index 000000000..7199ac02e
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.INetworkUpdateSystem.md
@@ -0,0 +1,87 @@
+---
+id: Unity.Netcode.INetworkUpdateSystem
+title: Unity.Netcode.INetworkUpdateSystem
+---
+
+# Interface INetworkUpdateSystem
+
+
+Defines the required interface of a network update system being executed
+by the NetworkUpdateLoop.
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public interface INetworkUpdateSystem
+```
+
+
+
+### Methods
+
+#### NetworkUpdate(NetworkUpdateStage)
+
+
+The update method that is being executed in the context of related
+NetworkUpdateStage.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void NetworkUpdate(NetworkUpdateStage updateStage)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------------|-------------|------------------------------------------------|
+| NetworkUpdateStage | updateStage | The NetworkUpdateStage that is being executed. |
+
+### Extension Methods
+
+
+
+NetworkUpdateLoop.RegisterAllNetworkUpdates(INetworkUpdateSystem)
+
+
+
+
+
+NetworkUpdateLoop.RegisterNetworkUpdate(INetworkUpdateSystem,
+NetworkUpdateStage)
+
+
+
+
+
+NetworkUpdateLoop.UnregisterAllNetworkUpdates(INetworkUpdateSystem)
+
+
+
+
+
+NetworkUpdateLoop.UnregisterNetworkUpdate(INetworkUpdateSystem,
+NetworkUpdateStage)
+
+
+
+
+
diff --git a/versioned_docs/version-1.0.0/api/Unity.Netcode.IReaderWriter.md b/versioned_docs/version-1.0.0/api/Unity.Netcode.IReaderWriter.md
new file mode 100644
index 000000000..a9bc4916d
--- /dev/null
+++ b/versioned_docs/version-1.0.0/api/Unity.Netcode.IReaderWriter.md
@@ -0,0 +1,1958 @@
+---
+id: Unity.Netcode.IReaderWriter
+title: Unity.Netcode.IReaderWriter
+---
+
+# Interface IReaderWriter
+
+
+Interface for an implementation of one side of a two-way serializer
+
+
+
+
+
+
+###### **Namespace**: Unity.Netcode
+
+###### **Assembly**: MLAPI.dll
+
+##### Syntax
+
+
+``` lang-csharp
+public interface IReaderWriter
+```
+
+
+
+### Properties
+
+#### IsReader
+
+
+Check whether this implementation is a "reader" - if it's been
+constructed to deserialize data
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+bool IsReader { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+#### IsWriter
+
+
+Check whether this implementation is a "writer" - if it's been
+constructed to serialize data
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+bool IsWriter { get; }
+```
+
+
+
+##### Property Value
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+### Methods
+
+#### GetFastBufferReader()
+
+
+Get the underlying FastBufferReader struct. Only valid when IsReader ==
+true
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+FastBufferReader GetFastBufferReader()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|------------------|-----------------------------|
+| FastBufferReader | underlying FastBufferReader |
+
+#### GetFastBufferWriter()
+
+
+Get the underlying FastBufferWriter struct. Only valid when IsWriter ==
+true
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+FastBufferWriter GetFastBufferWriter()
+```
+
+
+
+##### Returns
+
+| Type | Description |
+|------------------|-----------------------------|
+| FastBufferWriter | underlying FastBufferWriter |
+
+#### PreCheck(Int32)
+
+
+Performs an advance check to ensure space is available to read/write one
+or more values. This provides a performance benefit for serializing
+multiple values using the SerializeValuePreChecked methods. But note
+that the benefit is small and only likely to be noticeable if
+serializing a very large number of items.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+bool PreCheck(int amount)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|--------------|--------|-------------|
+| System.Int32 | amount | |
+
+##### Returns
+
+| Type | Description |
+|----------------|-------------|
+| System.Boolean | |
+
+#### SerializeNetworkSerializable\(ref T)
+
+
+Read or write a NetworkSerializable value. SerializeValue() is the
+preferred method to do this - this is provided for backward
+compatibility only.
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeNetworkSerializable(ref T value)
+ where T : INetworkSerializable, new()
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------------------|
+| T | value | The value to read/write |
+
+##### Type Parameters
+
+| Name | Description |
+|------|-------------------------------|
+| T | The network serializable type |
+
+#### SerializeValue(ref Color)
+
+
+Read or write a Color value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Color value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------------|
+| Color | value | The value to read/write |
+
+#### SerializeValue(ref Color\[\])
+
+
+Read or write an array of Color values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Color[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------------|
+| Color\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Color32)
+
+
+Read or write a Color32 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Color32 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Color32 | value | The value to read/write |
+
+#### SerializeValue(ref Color32\[\])
+
+
+Read or write an array of Color32 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Color32[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Color32\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Quaternion)
+
+
+Read or write a Quaternion value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Quaternion value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Quaternion | value | The value to read/write |
+
+#### SerializeValue(ref Quaternion\[\])
+
+
+Read or write an array of Quaternion values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Quaternion[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------------|
+| Quaternion\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Ray)
+
+
+Read or write a Ray value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Ray value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------|-------|-------------------------|
+| Ray | value | The value to read/write |
+
+#### SerializeValue(ref Ray\[\])
+
+
+Read or write an array of Ray values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Ray[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|--------------------------|
+| Ray\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Ray2D)
+
+
+Read or write a Ray2D value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Ray2D value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------|-------|-------------------------|
+| Ray2D | value | The value to read/write |
+
+#### SerializeValue(ref Ray2D\[\])
+
+
+Read or write an array of Ray2D values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Ray2D[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-----------|-------|--------------------------|
+| Ray2D\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Byte)
+
+
+Read or write a single byte
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref byte value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|-------------------------|
+| System.Byte | value | The value to read/write |
+
+#### SerializeValue(ref String, Boolean)
+
+
+Read or write a string
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref string s, bool oneByteChars = false)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|--------------|------------------------------------------------------------------|
+| System.String | s | The value to read/write |
+| System.Boolean | oneByteChars | If true, characters will be limited to one-byte ASCII characters |
+
+#### SerializeValue(ref Vector2)
+
+
+Read or write a Vector2 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector2 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector2 | value | The value to read/write |
+
+#### SerializeValue(ref Vector2\[\])
+
+
+Read or write an array of Vector2 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector2[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector2\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector2Int)
+
+
+Read or write a Vector2Int value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector2Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Vector2Int | value | The value to read/write |
+
+#### SerializeValue(ref Vector2Int\[\])
+
+
+Read or write an array of Vector2Int values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector2Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------------|
+| Vector2Int\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector3)
+
+
+Read or write a Vector3 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector3 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector3 | value | The value to read/write |
+
+#### SerializeValue(ref Vector3\[\])
+
+
+Read or write an array of Vector3 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector3[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector3\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector3Int)
+
+
+Read or write a Vector3Int value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector3Int value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|------------|-------|-------------------------|
+| Vector3Int | value | The value to read/write |
+
+#### SerializeValue(ref Vector3Int\[\])
+
+
+Read or write an array of Vector3Int values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector3Int[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|----------------|-------|--------------------------|
+| Vector3Int\[\] | value | The values to read/write |
+
+#### SerializeValue(ref Vector4)
+
+
+Read or write a Vector4 value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector4 value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------|-------|-------------------------|
+| Vector4 | value | The value to read/write |
+
+#### SerializeValue(ref Vector4\[\])
+
+
+Read or write an array of Vector4 values
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref Vector4[] value)
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|-------------|-------|--------------------------|
+| Vector4\[\] | value | The values to read/write |
+
+#### SerializeValue\(ref T, FastBufferWriter.ForEnums)
+
+
+Read or write an enum value
+
+
+
+
+
+
+##### Declaration
+
+
+``` lang-csharp
+void SerializeValue(ref T value, FastBufferWriter.ForEnums unused = default(FastBufferWriter.ForEnums))
+ where T : struct, Enum
+```
+
+
+
+##### Parameters
+
+| Type | Name | Description |
+|---------------------------|--------|----------------------------------------------------------------------------------------|
+| T | value | The value to read/write |
+| FastBufferWriter.ForEnums | unused | An unused parameter used for enabling overload resolution based on generic constraints |
+
+##### Type Parameters
+
+| Name | Description |
+|------|---------------------------|
+| T | The type being serialized |
+
+#### SerializeValue\