(playerCubeController.GetType(), DisplayPlayerCubeControllerProperties, playerCubeController.PlayerCubeControllerPropertiesVisible, SetExpanded);
+ base.OnInspectorGUI();
+ }
+}
+#endif
+
+
+public class PlayerCubeController : NetworkTransform
+{
+#if UNITY_EDITOR
+ // These bool properties ensure that any expanded or collapsed property views
+ // within the inspector view will be saved and restored the next time the
+ // asset/prefab is viewed.
+ public bool PlayerCubeControllerPropertiesVisible;
+#endif
+ public float Speed = 10;
+ public bool ApplyVerticalInputToZAxis;
+ private Vector3 m_Motion;
+
+ private void Update()
+ {
+ // If not spawned or we don't have authority, then don't update
+ if (!IsSpawned || !HasAuthority)
+ {
+ return;
+ }
+
+ // Handle acquiring and applying player input
+ m_Motion = Vector3.zero;
+ m_Motion.x = Input.GetAxis("Horizontal");
+
+ // Determine whether the vertical input is applied to the Y or Z axis
+ if (!ApplyVerticalInputToZAxis)
+ {
+ m_Motion.y = Input.GetAxis("Vertical");
+ }
+ else
+ {
+ m_Motion.z = Input.GetAxis("Vertical");
+ }
+
+ // If there is any player input magnitude, then apply that amount of
+ // motion to the transform
+ if (m_Motion.magnitude > 0)
+ {
+ transform.position += m_Motion * Speed * Time.deltaTime;
+ }
+ }
+}
+```
+
+2. In the open **SampleScene**, create a 3D cube and name it **PlayerCube**.
+
+3. Add a NetworkObject component to the **PlayerCube**.
+
+4. Set the NetworkObject Ownership to **None**.
+5. Add the **PlayerCubeController** to the **PlayerCube**.
+
+6. Create a Prefabs folder in the root Assets folder.
+7. Drag and drop the **PlayerCube** object into the newly created Prefabs folder.
+
+8. Delete the **PlayerCube** object from your scene.
+9. Open the Network Manager, navigate to **Prefab Settings**, and set the **Default Player Prefab** to be the newly created **PlayerCube**.
+
+10. Save all changes to the scene.
+
+## Next steps
+
+Hit play, fill out the **Profile Name** and **Session Name**, then click **Create or Join Session**. The profile name is the name of the player, so ensure this is different on every client. The session name is the identifier of the session you are joining, so this should be the same on every client. If everything has been set up correctly you will see the game create a session, connect to it, and spawn a PlayerCube.
+
+If you create a build and connect a new profile to the same session you will see a second PlayerCube spawn and sync up with the first.
+
+
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/distributed-authority-webgl.md b/com.unity.netcode.gameobjects/Documentation~/learn/distributed-authority-webgl.md
new file mode 100644
index 0000000000..1508bbddb8
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/distributed-authority-webgl.md
@@ -0,0 +1,39 @@
+# Distributed authority and WebGL quickstart
+
+Use this guide to learn how to create your first [distributed authority](../terms-concepts/distributed-authority.md) Netcode for GameObjects WebGL project.
+
+This guide is intended as an addition to the [distributed authority general quickstart](distributed-authority-quick-start.md) page, which provides more details about setting up Netcode for GameObjects to use distributed authority.
+
+> [!NOTE]
+> The distributed authority service provided by the [Multiplayer Services package](https://docs.unity.com/ugs/en-us/manual/mps-sdk/manual) offers a free tier for bandwidth and connectivity hours, allowing you to develop and test without immediate cost. Refer to the [Unity Gaming Services pricing page](https://unity.com/products/gaming-services/pricing) for complete details.
+
+## Prerequisites
+
+Before you begin, you need the following general requirements to use the distributed authority network topology:
+
+- An active Unity account with a valid license.
+- The [Unity Hub](https://unity.com/download).
+- A supported version of the Unity 6 Editor. Refer to the [Netcode for GameObjects requirements](https://docs-multiplayer.unity3d.com/netcode/current/installation).
+ - When installing the Editor, make sure to include the **WebGL Build Support** module.
+
+You also need the following packages and minimum versions for a WebGL distributed authority session:
+
+- Netcode for GameObjects version 2.1.1+
+- Unity Transport version 2.3.0+
+ - Note that you don't need to create a self-signed certificate to connect to a distributed authority session.
+- Multiplayer Services version 1.0.2+
+
+## Create and set up your project
+
+Follow the instructions on the [distributed authority general quickstart](distributed-authority-quick-start.md) page.
+
+## Configure the transport to use websockets
+
+Enable the **Use Web Sockets** checkbox on the **DistributedAuthorityTransport** component that was added to the **NetworkManager** object. 
+
+## Build and run with WebGL
+
+1. Navigate to **File** > **Build Profiles** to open the **Build Profiles** window. Select WebGL as your target platform.
+1. From the **Build Profiles** window, click **Build and Run**.
+ - Unity launches a small web hosting app to provide the HTTP services required to launch the WebGL application in your browser.
+1. Once you have one instance of your WebGL project running, you can copy the URI from your browser and paste it into another window or tab, which creates and connects another player to the same session.
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/faq.md b/com.unity.netcode.gameobjects/Documentation~/learn/faq.md
new file mode 100644
index 0000000000..81d5536282
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/faq.md
@@ -0,0 +1,97 @@
+# Frequently asked questions
+
+The FAQ provides immediate answers for questions collected from the Community on developing games with Multiplayer, including Netcode for GameObjects (Netcode), Transport, and more.
+
+## Unity Netcode for GameObjects (Netcode)
+
+
+
+### Does Netcode have a Public Roadmap?
+
+See the [Multiplayer Networking Public Roadmap](https://unity.com/roadmap/unity-platform/multiplayer-networking) to review, suggest, and vote on features for all Multiplayer Networking, Netcode, and documentation.
+
+### Implement a Dedicated Server vs a Listen Server, would I need to make changes to the codebase?
+
+Netcode works with both a Listen Server and a Dedicated Server model. You just have to be careful that you're using things like `IsServer` and `IsHost` correctly.
+
+### Does Netcode have any Matchmaking functionality?
+
+You would have to implement matchmaking using third party matchmaking services. Netcode has no matchmaking functionality.
+
+### What are recommendations for getting a game connecting over the internet?
+
+The Multiplayer Technology Team recommend the following:
+
+1. Upload your server build to a cloud provider or another server machine and run it there.
+2. Host your game locally and open ports in your router.
+
+ It should work just like over LAN you just have to connect to the public IP itself. Make sure to open UDP on the router. Many forward ports tutorials are available to review, including this option https://portforward.com/.
+
+3. Use a Relay.
+
+ [Unity Relay](https://docs.unity.com/relay/introduction.html) offers a way for game developers to securely offer increased connectivity between players by using a join code style workflow without needing to invest in a third-party solution. The Relay service enables developers to connect players together using a listen server. Instead of using dedicated game servers (DGS), the Relay service provides connectivity through a universal Relay server acting as a proxy.
+
+ Another option is to use something like the `SteamP2PTransport`, which will work without the need of setting up any servers if you release your game on Steam.
+
+### Is it good for add Spawnable object into NetworkConfig after start host?
+
+Yes, but you need to ensure that all your clients add the same object to their configurations as well. You can't only add it on the host.
+
+### How do I join from two devices on the same network?
+
+The client need to use the local IPv4 address of your server. On Windows, you can find that address by opening the Command Prompt and typing `ipconfig`. Search for the `IPv4 Address` value on the server's machine.
+
+Your client needs an input field to input the server's IP. If you just need something for prototyping, you can use [NetworkManagerHud](https://github.com/Unity-Technologies/multiplayer-community-contributions/tree/main/com.community.netcode.extensions/Runtime/NetworkManagerHud). You should attach this code to the NetworkManager GameObject.
+
+### What's the best method for spawning?
+
+Spawning can always be done on the host/server. If you want to give a client control over spawning objects, you need to implement a server RPC that you call on the client to spawn the object.
+
+### What are best practices for handing physics with Netcode?
+
+Networked physics is complicated, with many different ways to handle them. Currently, physics can be a little difficult to handle with Netcode and the built-in `NetworkTransform`.
+
+The Multiplayer Technology Team recommends the following:
+
+- Simulate the physics on the server and transforms on the client.
+- Remove the Rigidbody component from all your client objects and have just the server drive the position of the physics object. This should help reduce stutter on the client.
+
+### How do you implement on Steam?
+
+The Steam transport should be quite straightforward to use. Just add it to your project and set the `ConnectToSteamID` in the transport on the client to connect to the host that's all you need.
+
+
+
+## Boss Room and Bitesize Samples
+
+
+
+### Why do I get path too long errors with Boss Room on Windows?
+
+Using Windows' built-in extracting tool may generate an `Error 0x80010135: Path too long` error window which can invalidate the extraction process.
+
+As a workaround, shorten the zip file to a single character (for example "c.zip") and move it to the shortest path on your computer (such as in root `C:\`) and retry. If that solution fails, another workaround is to extract the downloaded zip file using an application like 7zip.
+
+### Why do I get unidentified developer errors with Boss Room?
+
+If you try to run a build on OSX and receive a warning dialog mentioning an "unidentified developer," you might need to override your security settings for this application:
+
+1. In the Finder on your Mac, locate the application you want to open.
+
+> [!NOTE]
+> Don't use Launchpad, it doesn't allow you to access the shortcut menu.
+
+1. Control-click the app icon, then choose **Open** from the shortcut menu.
+1. Select **Open**.
+
+The app is saved as an exception to your security settings. You can open it in the future by double-clicking it just as you can any registered app.
+
+See [Apple Support](https://support.apple.com/guide/mac-help/open-a-mac-app-from-an-unidentified-developer-mh40616/mac) for details.
+
+### Why is there an `InitBootStrap` scene as the startup scene for Boss Room and Bitesize Samples?
+
+The initial reason is that in Netcode the `NetworkManager` is a singleton class. The Bitesize Samples Team initially created it in the main menu, but when the host was leaving the in-game/networked scene, the Network Manager was getting destroyed, which led to not being able to host a game again without restarting the game instance.
+
+The Bootstrap scene ensures that the NetworkManager and other singletons are initialized first and will be there when you get back to main menu.
+
+
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/lagandpacketloss.md b/com.unity.netcode.gameobjects/Documentation~/learn/lagandpacketloss.md
new file mode 100644
index 0000000000..3f381dcbb3
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/lagandpacketloss.md
@@ -0,0 +1,48 @@
+# Understanding latency
+
+Multiplayer games operating over the internet have to manage adverse network factors that don't affect single-player or LAN-only multiplayer games, most notably [network latency](#network-latency). Latency (also known as lag) is the delay between a user taking an action and seeing the expected result. When latency is too high, a game feels unresponsive and slow.
+
+Generally, 200ms of latency is the point at which users notice gameplay degradation, although different types of games can tolerate more or less latency. For example, first-person shooter games perform best with less than 100ms of latency, whereas real-time strategy games can tolerate higher latency values of up to 500ms before gameplay is meaningfully impacted.
+
+In addition to the sources of latency described on this page, [ticks and update rates](ticks-and-update-rates.md) can also affect the user experience of your game.
+
+## Sources of latency
+
+There are a number of factors that contribute to latency, some of which can be minimized, although it's impossible to get rid of latency entirely.
+
+### Non-network latency
+
+Non-network latency refers to latency incurred by processes that happen before there's any involvement with the network. This is an area where you have more control over optimization to reduce latency (whereas network conditions are often beyond your control). Non-network latency is also referred to as input lag: the time it takes user input to be rendered on screen.
+
+Factors that contribute to non-network latency include:
+
+- **Input sampling delay**: The time it takes for an input device, such as a mouse or keyboard, to recognize that it's been activated and the time it takes for the game to detect that change.
+- **Render pipeline delay**: The time it takes for the GPU to render the outcome of inputs, which are often batched together to be processed in groups rather than individually.
+- **Vertical synchronization (VSync)**: A graphics technology that synchronizes the frame rate of the GPU with the refresh rate of the connected monitor. VSync can reduce undesirable visual behavior known as screen tearing, at the cost of increased latency incurred by the reduced frame rate.
+- **Display processing delay**: Display devices typically process incoming signals to some degree (such as deinterlacing and noise cancellation), which adds to latency.
+- **Pixel response time**: LCD screen pixels physically take time to change their brightness in response to inputs.
+
+### Network latency
+
+Network latency refers to latency incurred by interactions over the network after local processing is complete.
+
+Factors that contribute to network latency include:
+
+- **Processing delay**: The time it takes for the network router to read packet headers and forward them to the appropriate location. Processing delay also includes any encryption, network address translation (NAT), or network mapping that the router might be doing. This delay is generally small, but can add up when packets move between multiple locations.
+- **Transmission delay**: The time it takes for packets to be transmitted across the network. Transmission delay is proportional to the size of the packet (in bits) and is usually greatest in the parts of the network that connect directly to end users, which often have lower relative bandwidth. Sending fewer, larger packets can reduce transmission delay, because more bits are spent on game data rather than packet headers.
+- **Queueing delay**: The time packets spend waiting in queues. When a router receives more packets than it can process, those packets are added to a queue, which causes delays. Similarly, network interfaces can only output a limited number of packets at a time, so there can also be transmission queues. These queueing delays can add significantly to latency.
+- **Propagation delay**: The time it takes for signals to physically travel across the network. In [client-server topologies](../terms-concepts/network-topologies.md), this can be optimized by having servers located geographically closer to players.
+
+#### Round-trip time and pings
+
+Round-trip time (RTT) is a measure of how long it takes a packet to travel from one location on a network to another and receive a response packet back. You can use RTT to understand how much network latency your game is experiencing in different network conditions.
+
+A ping is a simplified way of measuring RTT that involves sending a very basic message, with no processing at either end of the interaction, to get a general idea of network responsiveness and latency.
+
+The time between sending the request and receiving the answer is the value of your ping. Sending and receiving data can take different amounts of time: for example, with a 20ms ping it might take 15ms to send a request from the client to the server and only 5ms to receive a response. Higher ping values indicate a lot of network latency, which can make games feel slow and unresponsive.
+
+#### Jitter and packet loss
+
+RTT can be affected by changing network conditions and is unlikely to remain constant, usually hovering around an average value. The degree to which this average value varies is referred to as jitter. Jitter can affect network latency mitigation and cause packets to arrive out of order.
+
+In addition to being delayed, packets can also be lost, which degrades gameplay experience either by losing key information and causing unpredictable behavior, or requiring it to be sent again, causing delays.
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/listenserverhostarchitecture.md b/com.unity.netcode.gameobjects/Documentation~/learn/listenserverhostarchitecture.md
new file mode 100644
index 0000000000..154fcd2e2c
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/listenserverhostarchitecture.md
@@ -0,0 +1,80 @@
+# Create a game with a listen server and host architecture
+
+## What is a listen server
+
+A listen server acts as both a server and client on a single player's machine for multiplayer game play. This means one player both plays the game and owns the game world while other players connect to this server.
+
+This set up has performance, security, and cost considerations for implementation.
+
+### Disadvantages
+
+- Network performance relies on the residential internet connection of the host player and their machine's output efficiency. Both may cause the remote players connecting to the host to suffer performance issues.
+- The host player may have a large latency advantage over the remote players.
+- With access to all of the game world's information, the host player has an easier opportunity to cheat.
+- The server, i.e. the game ceases to exist when the host player leaves the game.
+
+### Advantages
+
+- Essentially free compared to dedicated server options.
+- Doesn't require special infrastructure or forward planning to set up. This makes them common use for LAN parties because latency and bandwidth issues aren't a concern.
+
+## When to use a listen server architecture
+
+Listen server architecture is a popular choice for single player games that want to provide the option to add a friend into an existing game world. Listen servers are best suited for a smaller player group (< 12) and games that don't require a persistent world.
+
+> [!NOTE]
+> *Persistent world* in Netcode for GameObjects means "a persistent online world."
+> For example, the game state isn't bound to a player or a session, but is typically tied to the host.
+
+In contrast to dedicated servers, listen servers are cheaper without the need to run dedicated authoritative servers for a game. Often, the listen server approach is chosen to avoid setting up a system to orchestrate the game server fleet.
+
+> [!NOTE]
+> You still need to set up matchmaking for your player to join together to play. A listen server game requires redirecting players to the client-hosted server.
+
+## Connecting to a listen server
+
+Personal computers are hidden behind NATs (Network Address Translation devices) and routers to protect them from direct access. To connect to a listen server, you may choose an option such as [port forwarding](#port-forwarding), a [relay server](#relay-server), [NAT punch-through](#nat-punchthrough), or a [NAT punch with relay fallback](#nat-punch-and-relay-fallback).
+
+### Port Forwarding
+
+With port forwarding, the host can allow another player to connect to a listen server by forwarding a public port on their router to a machine in their local network.
+
+Considerations:
+
+* It has risks. By opening ports, you create direct pathways for hackers and malware attacks to access your system.
+* The host must manually open the ports on their router, and this requires some technical knowledge the average user may not have.
+* The host may not always have access to their router and would not be able to open a port. For example, the host may be using a mobile device, a corporate network, or public WiFi.
+
+Port forwarding may not be a viable option for a released game but can be useful for development. For more information about port forwarding, see https://portforward.com/.
+
+### Relay Server
+
+A dedicated server has ports already forwarded for players to connect anytime. These servers can run in the cloud or a data center. The relay server option uses these servers to send data between players.
+
+In a listen server relay scenario, the host and all clients connect to the same listen server. Clients send packets to the relay server, which then redirects these packets to the intended recipient.
+
+Advantages:
+
+* Compared to direct connecting through port forwarding, a relay server should always work for any client.
+* A relay server knows when the host client disconnects and can inform the other clients or start a host migration process.
+
+Disadvantages:
+
+A relay server costs money, and the round trip times for packet exchange may be higher because they have to go through the relay server instead of being sent directly to the other client.
+
+### NAT Punch-through
+
+Network Address Translation (NAT) punch-through, also known as hole punching, opens a direct connection without port forwarding. When successful, clients are directly connected to each other to exchange packets. However, depending on the NAT types among the clients, NAT punching often fails.
+
+Ways to NAT punch:
+* Session Traversal Utilities for NAT [STUN](../reference/glossary/network-terms.md#session-traversal-utilities-for-nat-stun)
+* Interactive Connectivity Establishment [ICE](../reference/glossary/network-terms.md#interactive-connectivity-establishment-ice)
+* User Datagram Protocol [(UDP) hole punching](../reference/glossary/network-terms.md#udp-hole-punching)
+
+Because of its high rate of failure, NAT punch-through is typically only used with a relay fallback.
+
+### NAT Punch and Relay Fallback
+
+This option combines NAT punching with a relay fallback. Clients first try to connect to the host by NAT punching and default back to the relay server on failure. This reduces the workload on the relay server while allowing clients to still connect to the host.
+
+It is widely used because it reduces the hosting costs of relay servers.
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/rpcnetvarexamples.md b/com.unity.netcode.gameobjects/Documentation~/learn/rpcnetvarexamples.md
new file mode 100644
index 0000000000..9e4ee6e21f
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/rpcnetvarexamples.md
@@ -0,0 +1,64 @@
+# RPCs vs NetworkVariables examples
+
+This page has examples of how the Small Coop Sample (Boss Room) uses `RPC`s and `NetworkVariable`s. It gives guidance on when to use `RPC`s versus `NetworkVariable`s in your own projects.
+
+See the [RPC vs NetworkVariable](rpcvnetvar.md) tutorial for more information.
+
+## RPCs for movement
+
+Boss Room uses RPCs to send movement inputs.
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/UserInput/ClientInputSender.cs
+```
+
+Boss Room wants the full history of inputs sent, not just the latest value. There is no need for `NetworkVariable`s, you just want to blast your inputs to the server. Since Boss Room isn't a twitch shooter, it sends inputs as reliable `RPC`s without worrying about the latency an input loss would add.
+
+## Arrow's GameObject vs Fireball's VFX
+
+The archer's arrows use a standalone `GameObject` that's replicated over time. Since this object's movements are slow, the Boss Room development team decided to use state (via the `NetworkTransform`) to replicate the ability's status (in case a client connected while the arrow was flying).
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/GameplayObjects/Projectiles/PhysicsProjectile.cs
+```
+
+Boss Room might have used an `RPC` instead (for the Mage's projectile attack). Since the Mage's projectile fires quickly, the player experience isn't affected by the few milliseconds where a newly connected client might miss the projectile. In fact, it helps Boss Room save on bandwidth when managing a replicated object. Instead, Boss Room sends a single RPC to trigger the FX client side.
+
+```csharp reference
+
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/GameplayObjects/Projectiles/FXProjectile.cs
+
+```
+
+## Breakable state
+
+Boss Room might have used a "break" `RPC` to set a breakable object as broken and play the appropriate visual effects. Applying the "replicate information when a player joins the game mid-game" rule of thumb, the Boss Room development team used `NetworkVariable`s instead. Boss Room uses the `OnValueChanged` callback on those values to play the visual effects (and an initial check when spawning the `NetworkBehaviour`).
+
+```csharp reference
+
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/GameplayObjects/Breakable.cs#L59-L78
+
+```
+
+The visual changes:
+
+```csharp reference
+
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/GameplayObjects/Breakable.cs#L146-L156
+
+```
+
+**Error when connecting after imps have died**: The following is a small gotcha the Boss Room development team encountered while developing Boss Room. Using `NetworkVariable`s isn't magical. If you use `OnValueChanged`, you still need to make sure you initialize your values when spawning for the first time. `OnValueChanged` isn't called when connecting for the first time, only for the next value changes.
+
+
+
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/GameplayObjects/Character/ServerAnimationHandler.cs#L23-L30
+```
+
+## Hit points
+
+Boss Room syncs all character and object hit points through `NetworkVariable`s, making it easy to collect data.
+
+If Boss Room synced this data through `RPC`s, Boss Room would need to keep a list of `RPC`s to send to connecting players to ensure they get the latest hit point values for each object. Keeping a list of `RPC`s for each object to send to those `RPC`s on connecting would be a maintainability nightmare. By using `NetworkVariable`s, Boss Room lets the SDK do the work.
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/rpcvnetvar.md b/com.unity.netcode.gameobjects/Documentation~/learn/rpcvnetvar.md
new file mode 100644
index 0000000000..6a95d6bce0
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/rpcvnetvar.md
@@ -0,0 +1,79 @@
+# RPC vs NetworkVariable
+
+Choosing the wrong data syncing mechanism can create bugs, use too much bandwidth, and add too much complexity to your code.
+Netcode for GameObjects (Netcode) has two main ways of syncing information between players: RPCs ([Remote Procedure Calls](../advanced-topics/messaging-system.md)) and replicated states [(`NetworkVariable`s)](../basics/networkvariable). They both send messages over the network. The logic and your design around how they send messages is what will make you choose one over the other.
+
+## Choosing between `NetworkVariable`s or RPCs
+
+- Use RPCs for transient events, information only useful for a moment when it's received.
+- Use `NetworkVariable`s for persistent states, for information that will be around more than a moment.
+
+A quick way to choose which to use is to ask yourself: "Should a player joining mid-game get that information?"
+
+
+
+Using the Boss Room's door as an example. A player's client needs to receive the information that the door is open to play the right animations.
+
+If we sent an RPC to all clients, then all players connecting mid-game after that RPC is sent will miss that information and have the wrong visual on their clients.
+
+
+
+In that case, it's preferable to use `NetworkVariable`s as show below:
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/GameplayObjects/SwitchedDoor.cs#L10-L26
+```
+
+It uses a `BoolNetworkVariable` to represent the `IsOpen` state. If one player opens the door and a second player connects after this, the host replicates all the world's information to that new player, including the door's state.
+
+`NetworkVariable`s are eventually consistent. This means not all value changes will be synced, contrary to RPCs, where five calls to an RPC will produce five RPC sends on the network.
+
+
+
+`NetworkVariable`s will save on bandwidth for you, making sure to only send values when the data has changed. However, if you want all value changes, RPCs might be best.
+
+## Why not use `NetworkVariable`s for everything?
+
+RPCs are simpler.
+
+If you have a temporary event like an explosion, you don't need a replicated state for this. It would not make sense. You would have an "unexploded" state that would need to be synced every time a new player connected? From a design perspective, you might not want to represent these events as state.
+
+An explosion can use an RPC for the event, but the effect of the explosion should be using `NetworkVariable`s (for example player's knockback and health decrease). A newly connected player doesn't care about an explosion that happened five seconds ago. They do care about the current health of the players around that explosion though.
+
+Actions in Boss Room are a great example for this. The area of effect action (`AoeAction`) triggers an RPC when the action is activated (showing a VFX around the affected area). The imp's health (`NetworkVariable`s) is updated. If a new player connects, they will see the damaged imps. We would not care about the area of effect ability's VFX, which works great with a transient RPC.
+
+`AoeActionInput.cs` Shows the input being updated client side and not waiting for the server. It then calls an RPC when clicking on the area to affect.
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/Action/Input/AoeActionInput.cs
+```
+
+`AOEAction.cs` has server-side logic detecting enemies inside the area and applying damage. It then broadcasts an RPC to tell all clients to play the VFX at the appropriate position. Character's state will automatically update with their respective `NetworkVariable`s update (health and alive status for example).
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/Action/ConcreteActions/AOEAction.cs#L8-L-40
+```
+
+The following snippet of code is triggered by an RPC coming from the server
+
+```csharp reference
+https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/v2.2.0/Assets/Scripts/Gameplay/Action/ConcreteActions/AOEAction.cs#L77-L82
+```
+
+If you want to make sure two variables are received at the same time, RPCs are great for this.
+
+If you change `NetworkVariables` "a" and "b", there is no guarantee they will both be received client side at the same time.
+
+
+
+Sending them as two parameters in the same RPC ensures they will be received at the same time client side.
+
+
+
+`NetworkVariable`s are great when you only care about the latest value.
+
+## Summary
+
+`NetworkVariable`s are great for managing state, to make sure everyone has the latest value. Use them when you want to make sure newly connected players get an up to date world state.
+
+RPCs are great for sending transient events. Use them when transmitting short-lived events.
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/sample-dedicated-server.md b/com.unity.netcode.gameobjects/Documentation~/learn/sample-dedicated-server.md
new file mode 100644
index 0000000000..7e4f5abb75
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/sample-dedicated-server.md
@@ -0,0 +1,198 @@
+# Dedicated game server sample
+
+## Dedicated Game Server sample
+
+[The Dedicated Game Server sample](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.bitesize/tree/main/Experimental/DedicatedGameServer) project demonstrates how the dedicated server model works and the tools that you can use to test multiplayer in the editor.
+
+This project uses the following packages and services:
+
+* [Dedicated Server](https://docs.unity3d.com/Packages/com.unity.dedicated-server@1.0/manual/index.html)
+* [Netcode For GameObjects](https://docs-multiplayer.unity3d.com/netcode/current/about/)
+* [Unity Transport](https://docs-multiplayer.unity3d.com/transport/current/about/)
+* [Multiplayer Play Mode](https://docs-multiplayer.unity3d.com/mppm/current/about/)
+* [Game Server Hosting](https://docs.unity.com/ugs/en-us/manual/game-server-hosting/manual/welcome-to-multiplay)
+* [Matchmaker](https://docs.unity.com/ugs/en-us/manual/matchmaker/manual/matchmaker-overview)
+
+
+### Sample features
+
+This section describes how the following features are configured to use the dedicated server:
+
+- [Dedicated Game Server sample](#dedicated-game-server-sample)
+ - [Sample features](#sample-features)
+ - [Project settings](#project-settings)
+ - [Strip generic components from the server](#strip-generic-components-from-the-server)
+ - [Split scripts across the client, server, or network](#split-scripts-across-the-client-server-or-network)
+ - [Synchronize animations between clients](#synchronize-animations-between-clients)
+ - [Automatically synchronized animations](#automatically-synchronized-animations)
+ - [Manually synchronized animations](#manually-synchronized-animations)
+ - [Navigation](#navigation)
+ - [Use multiplayer roles to control game logic](#use-multiplayer-roles-to-control-game-logic)
+- [Integrate with Unity Gaming Services (UGS)](#integrate-with-unity-gaming-services-ugs)
+- [Set default command line arguments](#set-default-command-line-arguments)
+
+### Project settings
+
+In this sample some GameObjects and components exist on the clients, some exist on the server, and some exist on both. This section explains how this sample strips generic GameObjects and components from the client or the server.
+
+#### Strip generic components from the server
+
+This project automatically strips the rendering, UI, and Audio components. To learn which settings automatically strip components, perform the following actions:
+
+* Open the Project Settings window (menu: **Edit** > **Project Settings**).
+* Select **Multiplayer Roles**.
+* Select **Content Selection**.
+
+For more information, refer to [Automatically remove components from a Multiplayer Role](https://docs.unity3d.com/Packages/com.unity.dedicated-server@1.0/manual/automatic-selection.html).
+
+This sample strips other components and GameObjects from the server manually. To learn how to do this, refer to [Control which GameObjects and components exist on the client or the server](https://docs.unity3d.com/Packages/com.unity.dedicated-server@1.0/manual/content-selection.html).
+
+#### Split scripts across the client, server, or network
+
+This sample splits the logic of the Player Character and the AI Character into separate scripts so that you can use the Content Selection window to run each character separately on the client, server and network. For example, the `PlayerCharacter` script logic is split into the following scripts:
+* Client Player Character. This script only exists on the clients.
+* Server Player Character.This script only exists on the server.
+* Networked Player Character: This script inherits from `NetworkBehaviour`.It synchronizes data and sends messages between the server and clients. This script exists on both clients and the server.
+
+These scripts separate the logic of each player which means you can strip the components that each script uses. For example, Client Player Character is the only script that uses the Player Character’s `CharacterController` component, so you can safely strip the `CharacterController` component from the server. To learn where the scripts in this sample exist, do the following:
+1. Select a Player Character GameObject.
+2. Open the GameObject’s Inspector window.
+3. Refer to the script component’s [Multiplayer role icon](https://docs.unity3d.com/Packages/com.unity.dedicated-server@1.0/manual/mutliplayer-roles-icons.html).
+
+The logic for scripts that contain a small class, like the doors and switches in this sample scene, exist in a single script that inherits from ``NetworkBehaviour``.
+
+#### Synchronize animations between clients
+
+This sample handles synchronizes animations between clients in the following ways:
+
+* Automatically synchronized animations. This process uses the NetworkAnimator component.
+* Manually synchronized animations. Use this process to strip animators from the server.
+
+##### Automatically synchronized animations
+
+The Animator component and the NetworkAnimator script synchronize animations across the clients and servers. The server or the owner of the animations, for example a PlayerCharacter script that uses a `ClientNetworkAnimator`, handles and automatically synchronizes animations between clients. This is necessary for animations that drive logic on the server. For example, in this sample the door animation (door_boss_ani) is synchronized automatically, but its game state determines whether to enable or disable its colliders and navmesh obstacles.
+
+##### Manually synchronized animations
+
+The Animator components on the AICharacter prefab in this sample are stripped from the server to reduce the build size which reduces the bandwidth and CPU resources that the server uses. This means that the NetworkAnimator doesn’t automatically synchronize animations between clients and requires manually synchronized animations.
+
+Each client uses data and events that are synchronized between them to drive the animation. The server handles their movement, and synchronizes their speed and transform values. Clients use that information to drive the character’s animation.
+
+`ServerAICharacter.cs`:
+
+```
+void Update()
+ {
+ if (!m_NavMeshAgent.pathPending && m_NavMeshAgent.remainingDistance < k_ReachDist)
+ {
+ GotoNextPoint();
+ }
+ m_NetworkedAICharacter.Speed = m_NavMeshAgent.velocity.magnitude;
+ }
+```
+
+`ClientAICharacter.cs`:
+
+```
+void Update()
+ {
+ if (m_NetworkedAICharacter.IsSpawned)
+ {
+ m_Animator.SetFloat(k_AnimIdSpeed, m_NetworkedAICharacter.Speed);
+ }
+ }
+```
+
+#### Navigation
+
+The AI characters in this sample use the navigation system. The AI characters exist on the server which means their navigation data and components are not required on clients and can be stripped. This includes the Navmesh and the NavMeshAgent, NavMeshModifier, and NavMeshObstacle components.
+
+Other GameObjects specific to servers are also stripped from clients, like the player spawn locations and the patrols.
+
+#### Use multiplayer roles to control game logic
+
+This sample assigns a [Multiplayer Role](https://docs.unity3d.com/Packages/com.unity.dedicated-server@1.0/manual/multiplayer-roles.html) to move Clients and Servers to different scenes when the application starts.
+
+```
+///
+ /// Initializes the application's network-related behaviour according to the configuration. Servers load the main
+ /// game scene and automatically start. Clients load the metagame scene and, if autoconnect is set to true, attempt
+ /// to connect to a server automatically based on the IP and port passed through the configuration or the command
+ /// line arguments.
+ ///
+
+ void InitializeNetworkLogic()
+ {
+ var commandLineArgumentsParser = new CommandLineArgumentsParser();
+ ushort listeningPort = (ushort) commandLineArgumentsParser.Port;
+ switch (MultiplayerRolesManager.ActiveMultiplayerRoleMask)
+ {
+ case MultiplayerRoleFlags.Server:
+ //lock framerate on dedicated servers
+ Application.targetFrameRate = commandLineArgumentsParser.TargetFramerate;
+ QualitySettings.vSyncCount = 0;
+ m_ConnectionManager.StartServerIP(k_DefaultServerListenAddress, listeningPort);
+ break;
+ case MultiplayerRoleFlags.Client:
+ {
+ SceneManager.LoadScene("MetagameScene");
+ if (AutoConnectOnStartup)
+ {
+ m_ConnectionManager.StartClient(k_DefaultClientAutoConnectServerAddress, listeningPort);
+ }
+ break;
+ }
+ case MultiplayerRoleFlags.ClientAndServer:
+ throw new ArgumentOutOfRangeException("MultiplayerRole", "ClientAndServer is an invalid multiplayer role in this sample. Please select the Client or Server role.");
+ }
+ }
+```
+
+The Multiplayer Role also defines how the game handles connection events:
+
+```
+void OnConnectionEvent(ConnectionEvent evt)
+ {
+ if (MultiplayerRolesManager.ActiveMultiplayerRoleMask == MultiplayerRoleFlags.Server)
+ {
+ switch (evt.status)
+ {
+ case ConnectStatus.GenericDisconnect:
+ case ConnectStatus.ServerEndedSession:
+ case ConnectStatus.StartServerFailed:
+ // If server ends networked session or fails to start, quit the application
+ Quit();
+ break;
+ case ConnectStatus.Success:
+ // If server successfully starts, load game scene
+ NetworkManager.Singleton.SceneManager.LoadScene("GameScene01", LoadSceneMode.Single);
+ break;
+ }
+ }
+ else
+ {
+ switch (evt.status)
+ {
+ case ConnectStatus.GenericDisconnect:
+ case ConnectStatus.UserRequestedDisconnect:
+ case ConnectStatus.ServerEndedSession:
+ // If client is disconnected, return to metagame scene
+ SceneManager.LoadScene("MetagameScene");
+ break;
+ }
+ }
+ }
+```
+
+## Integrate with Unity Gaming Services (UGS)
+
+This sample uses the following Unity Gaming Services (UGS):
+
+* The [Game Server Hosting](https://docs.unity.com/ugs/en-us/manual/game-server-hosting/manual/welcome) service hosts the dedicated server builds in the cloud.
+* The [Matchmaker](https://docs.unity.com/ugs/en-us/manual/matchmaker/manual/matchmaker-overview) service allows clients to connect to those servers.
+
+## Set default command line arguments
+
+Some of the parameters in this sample are set in command line arguments, for example, the port that the servers listen on and the target framerate of the server which apply in a build. When you test a project in the editor, Unity uses a fallback value instead.
+
+This allows the Game Server Hosting service to specify which port a server uses when it is allocated. This sample uses the `DedicatedServer.Arguments` static class to read those values. It uses the [CLI Arguments Defaults](https://docs.unity3d.com/Packages/com.unity.dedicated-server@1.0/manual/cli-arguments.html) feature of the [Dedicated Server package](https://docs.unity3d.com/Packages/com.unity.dedicated-server@1.0/manual/index.html) to provide default values for those arguments.
diff --git a/com.unity.netcode.gameobjects/Documentation~/learn/ticks-and-update-rates.md b/com.unity.netcode.gameobjects/Documentation~/learn/ticks-and-update-rates.md
new file mode 100644
index 0000000000..2ab45e73c2
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/learn/ticks-and-update-rates.md
@@ -0,0 +1,31 @@
+# Tick and update rates
+
+In addition to the effects of [latency](lagandpacketloss.md), gameplay experience in a multiplayer game is also affected by the server's [tick rate](#tick-rate) and the client's [update rate](#update-rate). Low tick and update rates reduce game responsiveness and add to perceived latency for users.
+
+## Tick rate
+
+Tick rate, also known as the simulation rate, is a measure of how frequently the server updates the game state. At the beginning of a tick, the server starts to process the data it's received from clients since the last tick and runs the necessary simulations to update the game state. The updated game state is then sent back to the clients. The faster the server finishes a tick, the earlier clients can receive the updated game state (subject to the client's [update rate](#update-rate)).
+
+
+
+Tick rate is measured in hertz (Hz). For example, a tick rate of 60 Hz means the server updates the game state sixty times a second, whereas a tick rate of 30 Hz means the server updates the game states only thirty times a second. Higher tick rates produce a more responsive game experience, at the cost of increased load on the simulating server.
+
+When a server fails to process all incoming client data before the end of the current tick, it produces gameplay issues such as rubber banding, player teleporting, hits getting rejected, and physics failing. As such, there's a balance between having a high tick rate to create responsive gameplay and ensuring that the server has enough time to process all client data before the end of a tick.
+
+## Update rate
+
+Update rate is a measure of how frequently the client sends and receives data to and from the server. It's also measured in hertz and, like tick rate, a higher update rate results in a more responsive game at the cost of increased processing and network demands on the client and server.
+
+
+
+In addition to adding to perceived latency, low update rates can cause their own issues, such as multiple updates being bundled together and arriving at the same time, causing undesirable behavior.
+
+In the example of 'super bullets': if an in-game gun is capable of shooting more times per second than the client can update, then at some point the impact of more than one bullet will be communicated in the same update. For players receiving this update, it will seem as if a single bullet is doing more damage than it should, because they're actually receiving updates from multiple bullets at once.
+
+The diagram below illustrates the difference between a 10 Hz update rate and a 60 Hz update rate. With a 10 Hz update rate, the game sends updates to the server ten times a second, so a gun that can fire 600 rounds per minute (RPM), or ten times a second, will only ever send a single bullet per update. A gun that fires at 750 RPM, more than ten times a second, will end up running into the super bullet problem. A higher update rate of 60 Hz resolves this issue, ensuring that there are enough updates for each bullet to arrive separately in its own update.
+
+
+
+### Discrepancy between tick rate and update rate
+
+If the update rate of a client is lower than the tick rate of the server, then the client won't see the benefit of the high tick rate, because it will only receive updates at the client update rate, even if multiple ticks have been processed in the interim.
diff --git a/com.unity.netcode.gameobjects/Documentation~/network-components.md b/com.unity.netcode.gameobjects/Documentation~/network-components.md
new file mode 100644
index 0000000000..98c90a92ec
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/network-components.md
@@ -0,0 +1,14 @@
+# Network components
+
+Understand the network components involved in a Netcode for GameObjects project.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[NetworkObject](basics/networkobject.md)** | A NetworkObject is a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) with a NetworkObject component and at least one [NetworkBehaviour](networkbehaviour.md) component, which enables the GameObject to respond to and interact with netcode. |
+| **[PlayerObjects and player prefabs](basics/playerobjects.md)** | PlayerObjects are an optional feature in Netcode for GameObjects that you can use to assign a [NetworkObject](networkobject.md) to a specific client. A client can only have one PlayerObject. |
+| **[NetworkObject parenting](advanced-topics/networkobject-parenting.md)** | Understand how NetworkObjects are parented in Netcode for GameObjects. |
+| **[NetworkBehaviour](networkbehaviour-landing.md)**| Understand how to use NetworkBehaviour components in your Netcode for GameObjects project. |
+| **[Physics](advanced-topics/physics.md)**| Netcode for GameObjects has a built in approach which allows for server-authoritative physics where the physics simulation only runs on the server. |
+| **[NetworkManager](components/networkmanager.md)**| The `NetworkManager` is a required Netcode for GameObjects component that has all of your project's netcode-related settings. Think of it as the central netcode hub for your netcode-enabled project. |
+| **[NetworkTransform](components/networktransform.md)**| [NetworkTransform](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.Components.NetworkTransform.html) is a concrete class that inherits from [NetworkBehaviour](../basics/networkbehaviour.md) and synchronizes [Transform](https://docs.unity3d.com/Manual/class-Transform.html) properties across the network, ensuring that the position, rotation, and scale of a [GameObject](https://docs.unity3d.com/Manual/working-with-gameobjects.html) are replicated to other clients. |
+| **[NetworkAnimator](components/networkanimator.md)**| The `NetworkAnimator` component provides you with a fundamental example of how to synchronize animations during a network session. Animation states are synchronized with players joining an existing network session and any client already connected before the animation state changing. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/network-synchronization.md b/com.unity.netcode.gameobjects/Documentation~/network-synchronization.md
new file mode 100644
index 0000000000..30d5576881
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/network-synchronization.md
@@ -0,0 +1,13 @@
+# Network synchronization
+
+Manage latency and performance in your Netcode for GameObjects project.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Ways to synchronize](advanced-topics/ways-to-synchronize.md)** | Netcode for GameObjects has three options for synchronizing game states and events. |
+| **[NetworkVariables](networkvariables-landing.md)** | Use NetworkVariables to synchronize properties between servers and clients in a persistent manner. |
+| **[Remote procedure calls (RPCs)](rpc-landing.md)** | Any process can communicate with any other process by sending a remote procedure call (RPC). |
+| **[Custom messages](advanced-topics/message-system/custom-messages.md)** | Create a custom message system for your Netcode for GameObjects project. |
+| **[Connection events](advanced-topics/connection-events.md)** | When you need to react to connection or disconnection events for yourself or other clients, you can use `NetworkManager.OnConnectionEvent` as a unified source of information about changes in the network. |
+| **[Network update loop](network-update-loop.md)** | 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 before or after `MonoBehaviour`-driven game logic execution. |
+| **[Network time and ticks](advanced-topics/networktime-ticks.md)** | Understand how network time and ticks work while synchronizing your project. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/network-topologies.md b/com.unity.netcode.gameobjects/Documentation~/network-topologies.md
new file mode 100644
index 0000000000..c40ac9b69d
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/network-topologies.md
@@ -0,0 +1,9 @@
+# Network topologies
+
+Understand and decide which network topology to use in your project.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Network topologies](terms-concepts/network-topologies.md)** | Network topology defines how a network is arranged. In the context of multiplayer games, this primarily relates to how clients, hosts, and servers are connected and communicate. Different network topologies have different benefits and drawbacks, depending on the type of game you want to make. |
+| **[Client-server](terms-concepts/client-server.md)** | Client-server is one possible [network topology](network-topologies.md) you can use for your multiplayer game. |
+| **[Listen server host architecture](learn/listenserverhostarchitecture.md)**| A listen server acts as both a server and client on a single player's machine for multiplayer game play. This means one player both plays the game and owns the game world while other players connect to this server. |
diff --git a/com.unity.netcode.gameobjects/Documentation~/network-update-loop.md b/com.unity.netcode.gameobjects/Documentation~/network-update-loop.md
new file mode 100644
index 0000000000..d705e8e073
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/network-update-loop.md
@@ -0,0 +1,8 @@
+# Network update loop
+
+Understand how network information is updated in Netcode for GameObjects projects.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[About network update loop](advanced-topics/network-update-loop-system/index.md)** | 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 before or after `MonoBehaviour`-driven game logic execution. |
+| **[Network update loop reference](advanced-topics/network-update-loop-system/network-update-loop-reference.md)** | Diagrams that provide insight into the Network Update Loop process and APIs. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/networkbehaviour-landing.md b/com.unity.netcode.gameobjects/Documentation~/networkbehaviour-landing.md
new file mode 100644
index 0000000000..6821d75fbd
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/networkbehaviour-landing.md
@@ -0,0 +1,9 @@
+# NetworkBehaviour
+
+Understand how to use NetworkBehaviour components in your project.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[NetworkBehaviour](basics/networkbehaviour.md)** | [`NetworkBehaviour`](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@latest?subfolder=/api/Unity.Netcode.NetworkBehaviour.html) is an abstract class that derives from [`MonoBehaviour`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) and is primarily used to create unique netcode or game logic. To replicate any netcode-aware properties or send and receive RPCs, a [GameObject](https://docs.unity3d.com/Manual/GameObjects.html) must have a [NetworkObject](networkobject.md) component and at least one `NetworkBehaviour` component.
+ |
+| **[Synchronize](basics/networkbehaviour-synchronize.md)** | You can use NetworkBehaviours to synchronize settings before, during, and after spawning NetworkObjects. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/networking-concepts.md b/com.unity.netcode.gameobjects/Documentation~/networking-concepts.md
new file mode 100644
index 0000000000..f39ffa870c
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/networking-concepts.md
@@ -0,0 +1,8 @@
+# Networking concepts
+
+Understand the networking concepts that underpin Netcode for GameObjects.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Authority](terms-concepts/authority.md)** | Multiplayer games are games that are played between many different game instances. Each game instance has their own copy of the game world and behaviors within that game world. To have a shared game experience, each networked object is required to have an **authority**. |
+| **[Network topologies](network-topologies.md)** | Understand and decide which network topology to use in your project. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/networkvariables-landing.md b/com.unity.netcode.gameobjects/Documentation~/networkvariables-landing.md
new file mode 100644
index 0000000000..12e51a3f10
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/networkvariables-landing.md
@@ -0,0 +1,8 @@
+# NetworkVariables
+
+Manage latency and performance in your Netcode for GameObjects project.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[NetworkVariable](basics/networkvariable.md)** | Use NetworkVariables to synchronize properties between servers and clients in a persistent manner. |
+| **[Custom NetworkVariables](basics/custom-networkvariables.md)** | In addition to the standard [`NetworkVariable`s](networkvariable.md) available in Netcode for GameObjects, you can also create custom `NetworkVariable`s for advanced implementations. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/ownership-authority.md b/com.unity.netcode.gameobjects/Documentation~/ownership-authority.md
new file mode 100644
index 0000000000..49f661088c
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/ownership-authority.md
@@ -0,0 +1,8 @@
+# Ownership and authority
+
+Understand ownership and authority in Netcode for GameObjects.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Understanding ownership and authority](basics/ownership.md)** | Understand the ownership and authority options that Netcode for GameObjects supports. |
+| **[Ownership race conditions](basics/race-conditions.md)** | Ownership race conditions can occur when two players (clients) want to take ownership of the same NetworkObject at the same time. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/relay/relay.md b/com.unity.netcode.gameobjects/Documentation~/relay/relay.md
new file mode 100644
index 0000000000..844a9d3b24
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/relay/relay.md
@@ -0,0 +1,178 @@
+# Using Unity Relay
+
+With [Netcode for GameObjects](https://docs-multiplayer.unity3d.com/netcode/current/about/) you can use an IP address and a port to connect a client to a host over the internet. However, using an IP address to establish a connection doesn't always work. Instead, you can use [Unity Relay](https://docs.unity.com/ugs/en-us/manual/relay/manual/introduction) to initiate a connection between multiple clients and a host.
+
+Many factors impact how you connect to the remote host. To connect to a remote host, use one of the following methods:
+
+* Perform a [NAT punchthrough](../learn/listenserverhostarchitecture.md#option-c-nat-punchthrough): This advanced technique directly connects to the host computer, even if it's on another network.
+* Use a [relay server](https://docs.unity.com/relay/en/manual/relay-servers): A relay server exists on the internet with a public-facing IP that you and the host can access. After the client and the host connect to a relay server, they can send data to each other through the relay server.
+
+Netcode for GameObjects doesn't offer tools to help you punch through a NAT. However, you can use the Unity Relay service to relay all technology based on Unity Transport.
+
+## Using Unity Relay
+
+To access a Unity Relay server, do the following:
+
+* As the host, request an allocation on the relay server.
+* As a client, use the [join code](https://docs.unity.com/relay/en/manual/join-codes) that the host creates to connect to the relay server. This code allows the host and clients to communicate through the relay server without disclosing their IP addresses and ports directly.
+
+### Enable Unity Relay in a project
+
+To enable and set up Unity Relay in a project, follow the steps in [Get started with Relay](https://docs.unity.com/relay/en/manual/get-started).
+
+### Test the Unity Relay service in the Unity Editor
+
+From Unity version 2022.3, you can test the Relay service with Netcode for GameObjects in the Editor. To do this, do the following:
+
+1. Follow the steps in [Get started with Netcode for GameObjects](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/get-started-ngo/).
+2. Follow the steps in [Get started with Relay](https://docs.unity.com/relay/en/manual/get-started).
+3. Open the inspector window and select the Network Manager.
+4. Navigate to the Start Connection section.
+5. Check the **Try Relay in the editor** box.
+6. Select **Start Server** or **Start Host** to start the server or host.
+7. In the inspector, copy the [join code](https://docs.unity.com/relay/en/manual/join-codes).
+8. Enter the join code in a new window running the same project.
+9. Select **Start Client**.
+
+This means you don't need to create UI elements to test the Relay service.
+
+If the connection fails then an error message appears in the UI and console.
+
+
+If Relay connects, a message appears in the inspector that displays the join code.
+
+
+You can copy the join code to share it, or test it in a project in a separate window. Refer to [testing locally](../tutorials/testing/testing_locally.md) for more details.
+
+> [!NOTE]
+> This Relay integration is only available in the Editor, which means you can't use it in a build. Instead, use the code snippets at the end of this page. These snippets use the Unity Transport Package. To do this in projects that don't use Transport, refer to the Relay documentation.
+
+### Create an allocation on a Relay server
+
+To create an [allocation](https://docs.unity.com/relay/en/manual/allocations) on a Relay server, make an authenticated call to the Unity backend using the SDK. To do this, call the `CreateAllocationAsync` method on the host with the maximum number of expected peers. For example, a host that requests a maximum of three peer connections reserves four slots for a four-player game. This function can throw exceptions, which you can catch to learn about the error that caused them.
+
+```csharp
+//Ask Unity Services to allocate a Relay server that will handle up to eight players: seven peers and the host.
+Allocation allocation = await Unity.Services.Relay.RelayService.Instance.CreateAllocationAsync(7);
+```
+
+The `Allocation` class represents all the necessary data for a [host player](https://docs.unity.com/relay/manual/players#Host) to start hosting using the specific Relay server allocated. You don't need to understand each part of this allocation; you only need to feed them to your chosen transport that handles the Relay communication on its own. For reference, here's a simple overview of those parameters:
+
+* A `RelayServer` class containing the IP and port of your allocation's server.
+
+* The allocation ID in a Base64 form and GUID form referred to as `AllocationIdBytes` and `AllocationId`.
+
+* A blob of encrypted bytes representing the [connection data](https://docs.unity.com/relay/en/manual/connection-data) (known as `ConnectionData`) allows users to connect to this host.
+
+* A Base64 encoded `Key` for message signature.
+
+Each allocation creates a unique [join code](https://docs.unity.com/relay/en/manual/join-codes) suitable for sharing over instant messages or other means. This join code allows your clients to join your game. You can retrieve it by calling the Relay SDK like so:
+
+```csharp
+string joinCode = await Unity.Services.Relay.RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId);
+```
+
+With those two calls, you now have your Relay allocation ready and the associated join code. Pass the allocation parameters to your host transport and send the join code (a simple string) over the Internet by the mean of your choice to your clients.
+
+Remember to [authenticate](https://docs.unity.com/relay/en/manual/authentication) your users before using SDK methods. The easiest way is the anonymous one (shown in the following code snippet), but you can use more advanced techniques.
+
+```csharp
+//Initialize the Unity Services engine
+await UnityServices.InitializeAsync();
+if (!AuthenticationService.Instance.IsSignedIn)
+{
+ //If not already logged, log the user in
+ await AuthenticationService.Instance.SignInAnonymouslyAsync();
+}
+```
+
+### Join an allocation on a Relay server
+
+To join an allocation on a Relay server, the following must be true:
+
+* The host of the game has created a Relay allocation.
+* The client has received a join code.
+
+To join a relay, a client requests all the allocation parameters from the join code to join the game. To do this, use the join code to call the `JoinAllocationAsync` method as the following code snippet demonstrates:
+
+```csharp
+//Ask Unity Services to join a Relay allocation based on our join code
+JoinAllocation allocation = await Unity.Services.Relay.RelayService.Instance.JoinAllocationAsync(joinCode);
+```
+For more information about the join code connection process, refer to [Connection flow](https://docs.unity.com/relay/manual/connection-flow#4).
+
+### Pass allocation data to a transport component
+
+When an allocation exists, you need to make all traffic that comes from Netcode for GameObjects go through the Relay. To do this, perform the following actions to pass the allocation parameters to UnityTransport:
+
+1. Retrieve Unity transport from your `NetworkManager`:
+```csharp
+//Retrieve the Unity transport used by the NetworkManager
+UnityTransport transport = NetworkManager.Singleton.gameObject.GetComponent();
+```
+
+2. Call the `SetRelayServerData` method on the retrieved transport by passing the allocation data that you retrieved, as well as the connection type (here set to [dtls](https://docs.unity.com/relay/en/manual/dtls-encryption)). For example:
+
+```csharp
+transport.SetRelayServerData(new RelayServerData(allocation, connectionType:"dtls"));
+```
+
+3. Call `StartClient`, `StartHost` or `StartServer` and use the Netcode library.
+
+## Code sample
+
+Use the following code to work with the [Relay server](https://docs.unity.com/relay/en/manual/relay-servers). To start a server instead of a host, replace the `StartHost` call with `StartServer` in `StartHostWithRelay`.
+
+For more information, refer to [Unity Relay](https://docs.unity.com/ugs/en-us/manual/relay/manual/introduction).
+
+```csharp
+///
+/// Creates a relay server allocation and start a host
+///
+/// The maximum amount of clients that can connect to the relay
+/// The join code
+public async Task StartHostWithRelay(int maxConnections=5)
+{
+ //Initialize the Unity Services engine
+ await UnityServices.InitializeAsync();
+ //Always authenticate your users beforehand
+ if (!AuthenticationService.Instance.IsSignedIn)
+ {
+ //If not already logged, log the user in
+ await AuthenticationService.Instance.SignInAnonymouslyAsync();
+ }
+
+ // Request allocation and join code
+ Allocation allocation = await RelayService.Instance.CreateAllocationAsync(maxConnections);
+ var joinCode = await RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId);
+ // Configure transport
+ NetworkManager.Singleton.GetComponent().SetRelayServerData(new RelayServerData(allocation, "dtls"));
+ // Start host
+ return NetworkManager.Singleton.StartHost() ? joinCode : null;
+}
+
+///
+/// Join a Relay server based on the JoinCode received from the Host or Server
+///
+/// The join code generated on the host or server
+/// True if the connection was successful
+public async Task StartClientWithRelay(string joinCode)
+{
+ //Initialize the Unity Services engine
+ await UnityServices.InitializeAsync();
+ //Always authenticate your users beforehand
+ if (!AuthenticationService.Instance.IsSignedIn)
+ {
+ //If not already logged, log the user in
+ await AuthenticationService.Instance.SignInAnonymouslyAsync();
+ }
+
+ // Join allocation
+ var joinAllocation = await RelayService.Instance.JoinAllocationAsync(joinCode: joinCode);
+ // Configure transport
+ NetworkManager.Singleton.GetComponent().SetRelayServerData(new RelayServerData(joinAllocation, "dtls"));
+ // Start client
+ return !string.IsNullOrEmpty(joinCode) && NetworkManager.Singleton.StartClient();
+}
+
+```
diff --git a/com.unity.netcode.gameobjects/Documentation~/rpc-landing.md b/com.unity.netcode.gameobjects/Documentation~/rpc-landing.md
new file mode 100644
index 0000000000..d2da74114b
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/rpc-landing.md
@@ -0,0 +1,13 @@
+# Remote procedure calls (RPCs)
+
+Manage latency and performance in your Netcode for GameObjects project.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Messaging system](advanced-topics/messaging-system.md)** | Netcode for GameObjects has two parts to its messaging system: [remote procedure calls (RPCs)](message-system/rpc.md) and [custom messages](message-system/custom-messages.md). Both types have sub-types that change their behavior, functionality, and performance. |
+| **[RPC](advanced-topics/message-system/rpc.md)** | Any process can communicate with any other process by sending a remote procedure call (RPC). |
+| **[Reliability](advanced-topics/message-system/reliability.md)** | RPCs are reliable by default. This means they're 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 and sound effects. |
+| **[RPC params](advanced-topics/message-system/rpc-params.md)** | Understand how to configure your RPCs. |
+| **[RPC vs NetworkVariables](learn/rpcvnetvar.md)** | Understand the different use cases for RPCs and NetworkVariables. |
+| **[RPC and NetworkVariable examples](learn/rpcnetvarexamples.md)** | Examples of RPCs and NetworkVariables. |
+| **[RPC compatibility](advanced-topics/message-system/rpc-compatibility.md)** | Information on compatibility and support for Unity Netcode for GameObjects features compared to previous Netcode versions. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/samples/release-notes/bitesize-changelog.md b/com.unity.netcode.gameobjects/Documentation~/samples/release-notes/bitesize-changelog.md
new file mode 100644
index 0000000000..cbd5904dc6
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/samples/release-notes/bitesize-changelog.md
@@ -0,0 +1,7 @@
+# Multiplayer Bitesize samples
+
+The following content tracks features, updates, bug fixes, and refactoring for the next release of the Multiplayer Bitesize samples project. Since Multiplayer Bitesize is open source, you can access the full release notes and changelogs in the [com.unity.multiplayer.samples.bitesize GitHub repository](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.bitesize).
+
+| Release | Date | Changelog |
+|---|---|---|
+| 1.1.0 | 2022-12-13 | [1.1.0](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.bitesize/releases/tag/v1.1.0) |
diff --git a/com.unity.netcode.gameobjects/Documentation~/samples/release-notes/bossroom-changelog.md b/com.unity.netcode.gameobjects/Documentation~/samples/release-notes/bossroom-changelog.md
new file mode 100644
index 0000000000..e9fe3f9441
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/samples/release-notes/bossroom-changelog.md
@@ -0,0 +1,16 @@
+# Boss Room changelog
+
+The following content tracks features, updates, bug fixes, and refactoring for the next release of the Boss Room sample project. Since Boss Room is open source, you can access the full release notes and changelogs in the [com.unity.multiplayer.samples.coop GitHub repository](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop).
+
+| Release | Date | Changelog |
+|---|---|---|
+| 2.1.0 | 2023-04-27 | [2.1.0](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v2.1.0) |
+| 2.0.4 | 2022-12-14 | [2.0.4](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v2.0.4) |
+| 2.0.3 | 2022-12-09 | [2.0.3](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v2.0.3) |
+| 2.0.2 | 2022-11-01 | [2.0.2](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v2.0.2) |
+| 2.0.1 | 2022-10-25 | [2.0.1](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v2.0.1) |
+| 2.0.1 | 2022-10-06 | [2.0.1](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v2.0.0) |
+| 1.3.1-pre | 2022-09-15 | [1.3.1-pre](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v1.3.1-pre) |
+| 1.3.0-pre | 2022-06-23 | [1.3.0-pre](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v1.2.0-pre) |
+| 1.2.0-pre | 2022-04-28 | [1.2.0-pre](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v1.1.2-pre) |
+| 1.1.2-pre | 2022-04-14 | [1.1.2-pre](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/releases/tag/v1.1.1-pre) |
diff --git a/com.unity.netcode.gameobjects/Documentation~/scene-management.md b/com.unity.netcode.gameobjects/Documentation~/scene-management.md
new file mode 100644
index 0000000000..e2c9772d2d
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/scene-management.md
@@ -0,0 +1,9 @@
+# Scene management
+
+Understand scene management in Netcode for GameObjects.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Scene management overview](basics/scenemanagement/scene-management-overview.md)** | Introduction to scene management in Netcode for GameObjects. |
+| **[Integrated management](integrated-management.md)** | The Netcode for GameObjects scene management solution is enabled by default and provides you with a fully functional netcode scene management solution. |
+| **[Custom management](basics/scenemanagement/custom-management.md)** | If your project has needs that go beyond the scope of the Netcode integrated scene management solution, you can disable scene management in the Editor through `NetworkManager`'s properties. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/serialization.md b/com.unity.netcode.gameobjects/Documentation~/serialization.md
new file mode 100644
index 0000000000..370183ef56
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/serialization.md
@@ -0,0 +1,14 @@
+# Serialization
+
+Netcode for GameObjects 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.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[C# primitives](advanced-topics/serialization/cprimitives.md)** | C# primitive types are serialized by built-in serialization code. These types include `bool`, `char`, `sbyte`, `byte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, and `string`. |
+| **[Unity primitives](advanced-topics/serialization/unity-primitives.md)** | Unity Primitive `Color`, `Color32`, `Vector2`, `Vector3`, `Vector4`, `Quaternion`, `Ray`, `Ray2D` types will be serialized by built-in serialization code. |
+| **[Enum types](advanced-topics/serialization/enum-types.md)** | A user-defined enum type will be serialized by built-in serialization code (with underlying integer type). |
+| **[Arrays](advanced-topics/serialization/serialization-arrays.md)** | Netcode for GameObjects has built-in serialization code for arrays of [C# value-type primitives](advanced-topics/serialization/cprimitives.md), like `int[]`, and [Unity primitive types](advanced-topics/serialization/unity-primitives.md). Any arrays of types that aren't handled by the built-in serialization code, such as `string[]`, need to be handled using a container class or structure that implements the [`INetworkSerializable`](advanced-topics/serialization/inetworkserializable.md) interface. |
+| **[INetworkSerializable](advanced-topics/serialization/inetworkserializable.md)** | You can use the `INetworkSerializable` interface to define custom serializable types. |
+| **[Custom serialization](advanced-topics/custom-serialization.md)** | Create custom serialization types. |
+| **[NetworkObject serialization](advanced-topics/serialization/networkobject-serialization.md)** | `GameObjects`, `NetworkObjects` and `NetworkBehaviour` aren't serializable types so they can't 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`. |
+| **[FastBufferWriter and FastBufferReader](advanced-topics/fastbufferwriter-fastbufferreader.md)** | 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. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/session-management-landing.md b/com.unity.netcode.gameobjects/Documentation~/session-management-landing.md
new file mode 100644
index 0000000000..2fbdfe0624
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/session-management-landing.md
@@ -0,0 +1,8 @@
+# Session management
+
+Understand how to set up session management in Netcode for GameObjects.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Session management](advanced-topics/session-management.md)** | Use session management to keep data when a player disconnects and accurately reassign it to the player when they reconnect. |
+| **[Reconnecting mid-game](advanced-topics/reconnecting-mid-game.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/spawn-despawn.md b/com.unity.netcode.gameobjects/Documentation~/spawn-despawn.md
new file mode 100644
index 0000000000..fda545daff
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/spawn-despawn.md
@@ -0,0 +1,10 @@
+# Spawning and despawning
+
+Spawn and despawn objects in your project.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Object spawning](basics/object-spawning.md)** | Spawning in Netcode for GameObjects means to instantiate and/or spawn the object that is synchronized between all clients by the server. |
+| **[Object pooling](advanced-topics/object-pooling.md)** | Netcode for GameObjects provides built-in support for Object Pooling, which allows you to override the default Netcode destroy and spawn handlers with your own logic. |
+| **[Object visibility](basics/object-visibility.md)** | Object (NetworkObject) visibility is a Netcode for GameObjects term used to describe whether a `NetworkObject` is visible to one or more clients as it pertains to a netcode/network perspective. |
+| **[Spawning synchronization](basics/spawning-synchronization.md)** | Ensuring that objects spawn in a synchronized manner across clients can be difficult, although the challenges differ depending on which [network topology](terms-concepts/network-topologies.md) you're using. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/authority.md b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/authority.md
new file mode 100644
index 0000000000..2b7f027931
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/authority.md
@@ -0,0 +1,31 @@
+# Authority
+
+Multiplayer games are games that are played between many different game instances. Each game instance has their own copy of the game world and behaviors within that game world. To have a shared game experience, each networked object is required to have an **authority**.
+
+The authority of a networked object has the ultimate power to make definitive decisions about that object. Each object must have one and only one authority. The authority has the final control over all state and behavior of that object.
+
+The authoritative game instance is the game instance that has authority over a given networked object. This game instance is responsible for simulating networked game behavior. The authority is able to mediate the effects of network lag, and is responsible for reconciling behavior if many players are attempting to simultaneously interact with the same object.
+
+## Authority models
+
+Netcode for GameObjects provides two authority models: [server authority](#server-authority) and [distributed authority](#distributed-authority).
+
+### Server authority
+
+The server authority model has a single game instance that is defined as the server. That game instance is responsible for running the main simulation and managing all aspects of running the networked game. Server authority is the authority model used for [client-server games](client-server.md).
+
+The server authority model has the strength of providing a centralized authority to manage any potential game state conflicts. This allows the implementation of systems such as game state rollback and competitive client prediction. However, this can come at the cost of adding latencies, because all state changes must be sent to the server game instance, processed, and then sent out to other game instances.
+
+Server authority games can also be resource intensive. The server runs the simulation for the entire game world, and so the server needs to be powerful enough to handle the simulation and networking of all connected game clients. This resource requirement can become expensive.
+
+Server authority is primarily used by performance-sensitive games, such as first-person shooters, or competitive games where having a central server authority is necessary to minimize cheating and the effects of bad actors.
+
+### Distributed authority
+
+The distributed authority model shares authority between game instances. Each game instance is the authority for a subdivision of the networked objects in the game and is responsible for running the simulation for their subdivision of objects. Updates are shared from other game instances for the rest of the simulation.
+
+The authority of each networked object is responsible for simulating the behavior and managing any aspects of running the networked game that relate to the objects it is the authority of.
+
+Because distributed authority games share the simulation between each connected client, they are less resource intensive. Each machine connected to the game processes a subdivision of the simulation, so no single machine needs to have the capacity to process the entire simulation. This results in a multiplayer game experience that can run on cheaper machines and is less resource intensive.
+
+The distributed authority model is the authority model used for [distributed authority games](distributed-authority.md).
diff --git a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/client-server.md b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/client-server.md
new file mode 100644
index 0000000000..76490a4181
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/client-server.md
@@ -0,0 +1,15 @@
+# Client-server topologies
+
+Client-server is one possible [network topology](network-topologies.md) you can use for your multiplayer game.
+
+## Defining client-server
+
+In a client-server topology, a central server is responsible for running the main simulation and managing all aspects of running the networked game, including simulating physics, spawning and despawning objects, and authorizing client requests. Players connect to the server using separate client programs to see and interact with the game.
+
+Client-server encompasses a number of potential network arrangements. The most common is a dedicated game server, in which a specialized server manages the game and exists solely for that purpose. An alternative client-server arrangement is to have a [listen server](../learn/listenserverhostarchitecture.md), in which the game server runs on the same machine as a client.
+
+## Use cases for client-server
+
+Dedicated servers are often the most expensive network topology, but also offer the highest performance and can provide additional functionality such as competitive client prediction, rollback, and a centralized authority to manage any potential client conflicts. However, this comes at the cost of added latencies when communicating state changes from one client to another, as all state changes must be sent from client to server, processed, and then sent back out to other clients.
+
+Client-server is primarily used by performance-sensitive games, such as first-person shooters, or competitive games where having a central server authority is necessary to minimize cheating and the effects of bad actors.
diff --git a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/distributed-authority.md b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/distributed-authority.md
new file mode 100644
index 0000000000..4207f88e13
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/distributed-authority.md
@@ -0,0 +1,34 @@
+# Distributed authority topologies
+
+## Distributed authority networks
+
+The [distributed authority network topology](network-topologies.md#distributed-authority) is one possible [network topology](network-topologies.md) available within Netcode for GameObjects. Distributed authority games use the [distributed authority model](authority.md#distributed-authority).
+
+The traditional [client-server network topology](network-topologies.md/#client-server) has a dedicated game instance running the game simulation. This means all state changes must be communicated to the server and then the server communicates those updates to all other connected clients. This design works well when using a powerful dedicated game server, however significant latencies are added when communicating state changes with a [listen server architecture](../learn/listenserverhostarchitecture.md).
+
+> [!NOTE]
+> The distributed authority service provided by the [Multiplayer Services package](https://docs.unity.com/ugs/en-us/manual/mps-sdk/manual) offers a free tier for bandwidth and connectivity hours, allowing you to develop and test without immediate cost. Refer to the [Unity Gaming Services pricing page](https://unity.com/products/gaming-services/pricing) for complete details.
+
+## Considerations
+
+Using a distributed authority topology is typically not suitable for high-performance competitive games that require an accurate predictive motion model. The distributed authority model successfully addresses a lot of visual and input-related issues, but does have some limitations:
+
+* Since authority and ownership of objects is distributed across clients, there's typically no single physics simulation governing the interaction of all objects. This can require approaching physics-related gameplay differently compared to a traditional client-server context.
+* Depending on the platform and overall design of your product, it can be easier for bad actors to cheat. The authority model gives more trust to individual clients. Evaluate your cheating tolerance when developing with distributed authority.
+
+## Session ownership
+
+When using the distributed authority topology, it's necessary to have a single dedicated client that's responsible for managing and synchronizing global game state-related tasks. This client is referred to as the session owner.
+
+The initial session owner is the first client that joins when the session is created. If this client disconnects during the game, a new session owner is automatically selected and promoted from within the clients that are currently connected.
+
+## More information about distributed authority
+
+For more information about how distributed authority works in Netcode for GameObjects, see the following pages in the documentation:
+
+- [Distributed authority quickstart](../learn/distributed-authority-quick-start.md)
+- [Understanding ownership and authority](../basics/ownership.md)
+- [Race conditions](../basics/race-conditions.md)
+- [Spawning synchronization](../basics/spawning-synchronization.md)
+- [Deferred despawning](../basics/deferred-despawning.md)
+- [Distributed Authority Social Hub sample](../learn/bitesize/bitesize-socialhub.md)
diff --git a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/mutliplayer-terms.md b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/mutliplayer-terms.md
new file mode 100644
index 0000000000..9b64a61fa8
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/mutliplayer-terms.md
@@ -0,0 +1,7 @@
+# Multiplayer Networking Terminology
+
+The following are essential, high-level terms used in multiplayer networking and Netcode for GameObjects:
+
+import MTTterms from '/static/shared/_terminology.md';
+
+
diff --git a/com.unity.netcode.gameobjects/Documentation~/terms-concepts/network-topologies.md b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/network-topologies.md
new file mode 100644
index 0000000000..eb5cd1b8d9
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/terms-concepts/network-topologies.md
@@ -0,0 +1,45 @@
+# Network topologies
+
+Network topology defines how a network is arranged. In the context of multiplayer games, this primarily relates to how clients, hosts, and servers are connected and communicate. Different network topologies have different benefits and drawbacks, depending on the type of game you want to make.
+
+## Network topologies
+
+The network topologies that Netcode for GameObjects supports are based on the two primary [authority models](authority.md).
+
+### Client-server
+
+Client-server games use a [server authority model](authority.md#server-authority). In this network topology the server has final authority on the state of the game. Each client sends updates to the server, and the server runs the main game simulation. The game has a single server and many clients.
+
+Within the client-server network topology there are two main [network architectures](client-server.md). These are the dedicated game server (where a dedicated machine runs only the game simulation), and the listen-server architecture (where a single game instance runs both the game simulation and a playing game client).
+
+For more details about client-server topologies, refer to the [Client-server topologies page](client-server.md).
+
+### Distributed authority
+
+In a distributed authority topology, game instances share responsibility for owning and tracking the state of objects in the network using a [distributed authority model](authority.md#distributed-authority). A small, lightweight central state service tracks a minimal amount of game state and routes network traffic. There is no server simulating the game: each connected game instance runs a subdivision of the simulation.
+
+Distributed authority topologies are useful for keeping costs down, and solve a lot of the input-related issues typically addressed using client prediction systems. However, the lack of a central authority can make them more vulnerable to cheating and bad actors.
+
+For more details about distributed authority topologies, refer to the [Distributed authority page](distributed-authority.md).
+
+## Network topology comparison
+
+The primary differences between [client-server](client-server.md) and [distributed authority](distributed-authority.md) topologies are cost, security, and latency. There are further considerations for these metrics based on the different [client-server network architectures](client-server.md) that can be used.
+
+* **Cost**: Client-server topologies using a dedicated game server are typically an expensive option due to the hardware and running costs involved in maintaining a powerful server machine, although this does allow for higher performance and better [tick rates](../learn/ticks-and-update-rates.md). Distributed authority networks are cheaper, since they lack a dedicated central server and game simulations run solely on clients. Listen servers are running on an already existing game instance and so there is no extra cost involved.
+* **Security**: Because the distributed authority topology spreads authority across multiple clients, any one client may be compromised and/or cheating without making the entire experience unplayable. With a client-server architecture, a dedicated game server is much more resilient to compromised clients, while listen servers have a single point of failure if the game instance hosting the server is compromised.
+* **Latency**: In a distributed authority topology, game state updates are sent to the distributed authority service which then proxies those messages directly to the other connected clients. With the client-server topology, latency can depend greatly based on the location and [network architecture](client-server.md) of the server.
+
+## Which network topology will meet your project's needs?
+
+Both of the network topologies that are provided by Netcode for GameObjects are suitable for a wide range of use-cases. The following questions can help you determine if a certain network topology will fit the needs of your project.
+
+Does your project require:
+
+* A centralized, trusted server for the purpose of securing specific game states from being modified by bad actors?
+ * If you answered yes, then the client-server topology is likely to be the best fit for your project's needs. The distributed authority topology relies on the assumption that each game instance can be trusted therefore it is not a reliable authority mode for games where local game instances may be attempting to cheat.
+
+* Client-side prediction with rollback capabilities?
+ * If you answered yes, then the client-server topology is likely to be the best fit for your project's needs.
+
+If you're looking for a development flow with simple instantiation and spawning of visually synchronized objects, then the distributed authority topology could be a good fit for your project's needs.
diff --git a/com.unity.netcode.gameobjects/Documentation~/testing-debugging.md b/com.unity.netcode.gameobjects/Documentation~/testing-debugging.md
new file mode 100644
index 0000000000..e7075845d2
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/testing-debugging.md
@@ -0,0 +1,14 @@
+# Testing and debugging
+
+Understand how to set up session management in Netcode for GameObjects.
+
+| **Topic** | **Description** |
+| :------------------------------ | :------------------------------- |
+| **[Testing locally](tutorials/testing/testing_locally.md)** | Use session management to keep data when a player disconnects and accurately reassign it to the player when they reconnect. |
+| **[Testing with artificial conditions](tutorials/testing/testing_with_artificial_conditions.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
+| **[Testing client connection management](tutorials/testing/testing_client_connection_management.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
+| **[Logging](basics/logging.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
+| **[Techniques and tricks for debugging multiplayer games](tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
+| **[Command-line helper](tutorials/command-line-helper.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
+| **[Troubleshooting](troubleshooting/troubleshooting.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
+| **[Error messages](troubleshooting/error-messages.md)** | In a multiplayer game, clients might get disconnected from the server for a variety of reasons (such as network issues or application/device crashes). For those reasons, you might want to allow your players to reconnect to the game. |
\ No newline at end of file
diff --git a/com.unity.netcode.gameobjects/Documentation~/troubleshooting/error-messages.md b/com.unity.netcode.gameobjects/Documentation~/troubleshooting/error-messages.md
new file mode 100644
index 0000000000..461da3a2a5
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/troubleshooting/error-messages.md
@@ -0,0 +1,28 @@
+# Netcode for GameObjects error messages
+
+Learn more about Unity error messages, including error collecting, issues that cause them, and how to handle.
+
+## Error Capturing
+
+Error messages are captured and returned through Unity Editor Diagnostics (required) and Roslyn Analyzers.
+
+* Unity ILPP and Editor errors are the source of truth. ILPP occurs in Unity and returns error messages, which prevents you from building/playing your game (hard compile errors).
+* [Roslyn Analyzers](https://devblogs.microsoft.com/dotnet/write-better-code-faster-with-roslyn-analyzers/) provide immediate feedback within the IDE, without jumping back to Unity to let it compile with your new changes.
+
+## NetworkObject errors
+
+**Error:**
+* `Can't find pending soft sync object. Is the projects the same? UnityEngine.Debug:LogError(Object)`
+* `ArgumentNullException: Can't spawn null object Parameter name: netObject`
+
+This exception should only occur if your scenes aren't the same, for example if the scene of your server has a `NetworkObject` which isn't present in the client scene. Verify the scene objects work correctly by entering playmode in both editors.
+
+## ServerRPC errors
+
+**Error:**
+* Server: `[Netcode] Only owner can invoke ServerRPC that is marked to require ownership`
+* Host: `KeyNotFoundException: The given key wasn't present in the dictionary.`
+
+The ServerRPC should only be used on the server. Make sure to add `isServer` check before calling.
+
+If the call is added correctly but still returns a `nullreferenceexception`, `NetworkManager.Singleton` may be returning `null`. Verify you created the `GameObject` with a `NetworkManager` component, which handles all initialization. `NetworkManager.Singleton` is a reference to a instance of the `NetworkManager` component.
diff --git a/com.unity.netcode.gameobjects/Documentation~/troubleshooting/troubleshooting.md b/com.unity.netcode.gameobjects/Documentation~/troubleshooting/troubleshooting.md
new file mode 100644
index 0000000000..6704a33d63
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/troubleshooting/troubleshooting.md
@@ -0,0 +1,40 @@
+# Troubleshooting
+
+See the following information for common troubleshooting for Netcode for GameObjects.
+
+## NullReferenceException when trying to start a server/host/client
+
+**Issue:** When trying to start a server, host, or client by executing one of these lines of code:
+
+```csharp
+NetworkManager.Singleton.StartServer()
+NetworkManager.Singleton.StartHost()
+NetworkManager.Singleton.StartClient()
+```
+
+The following exception is thrown:
+
+```csharp
+NullReferenceException: Object reference not set to an instance of an object
+```
+
+**Solution:** You most likely forgot to add the `NetworkManager` component to a game object in your scene.
+
+## NullReferenceException when trying to send an RPC to the server
+
+**Issue:** When the client tries to run `InvokeServerRpc`, the following exception is thrown:
+
+```csharp
+NullReferenceException: Object reference not set to an instance of an object
+```
+
+**Solution:** You most likely forgot to `Spawn()` your object. Run `Spawn()` on your `NetworkObject` component as the server to fix this issue.
+
+## Server build is using 100% CPU
+
+**Issue**: When running an MLAPI server created from a server build it has a cpu usage of 100% blocking all my other applications.
+
+**Solution**: Unity server builds try to push as many Updates per second as possible. On a server this is most often not necessary. You can limit the target frame rate to reduce the amounts of Updates with this:
+```csharp
+Application.targetFrameRate = 30;
+```
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/command-line-helper.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/command-line-helper.md
new file mode 100644
index 0000000000..6843db541f
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/command-line-helper.md
@@ -0,0 +1,178 @@
+# Create a command-line helper for testing
+
+This page walks you through how to create a command-line helper that launches your project outside the Unity Editor to make testing builds easier.
+
+Using a command-line helper script to launch multiple instances of a game build isn't the only way to test a multiplayer game. You can also use the Unity Editor or the [Multiplayer Play Mode package](https://docs-multiplayer.unity3d.com/mppm/current/about/).
+
+## Create the command-line helper
+
+1. Right-click the **Assets** folder in the **Projects** tab, then select **Create** > **Folder**.
+2. Name the new folder **Scripts**.
+3. Right-click the **Scripts** folder you created, then select **Create** > **C# Script**.
+4. Name the script **NetworkCommandLine**.
+5. Right-click on **NetworkManager** within the **Hierarchy** list, then select **Create Empty**.
+6. Name the new GameObject **NetworkCommandLine**.
+7. With the `NetworkCommandLine` GameObject selected, select **Add Component** from the **Inspector** tab.
+8. For the new component, select **Scripts** > **Network Command Line** (the `NetworkCommandLine.cs` script you created earlier).
+9. Double-click on the **NetworkCommandLine.cs** script from the **Project** tab to open it in a text editor.
+10. Edit the `NetworkCommandLine.cs` script to match the following code snippet:
+
+```csharp
+using System.Collections.Generic;
+using Unity.Netcode;
+using UnityEngine;
+
+public class NetworkCommandLine : MonoBehaviour
+{
+ private NetworkManager netManager;
+
+ void Start()
+ {
+ netManager = GetComponentInParent();
+
+ if (Application.isEditor) return;
+
+ var args = GetCommandlineArgs();
+
+ if (args.TryGetValue("-mode", out string mode))
+ {
+ switch (mode)
+ {
+ case "server":
+ netManager.StartServer();
+ break;
+ case "host":
+ netManager.StartHost();
+ break;
+ case "client":
+
+ netManager.StartClient();
+ break;
+ }
+ }
+ }
+
+ private Dictionary GetCommandlineArgs()
+ {
+ Dictionary argDictionary = new Dictionary();
+
+ var args = System.Environment.GetCommandLineArgs();
+
+ for (int i = 0; i < args.Length; ++i)
+ {
+ var arg = args[i].ToLower();
+ if (arg.StartsWith("-"))
+ {
+ var value = i < args.Length - 1 ? args[i + 1].ToLower() : null;
+ value = (value?.StartsWith("-") ?? false) ? null : value;
+
+ argDictionary.Add(arg, value);
+ }
+ }
+ return argDictionary;
+ }
+}
+```
+
+11. Save the file, then return to the Unity Editor.
+12. Open the Build Settings window by selecting **File** > **Build Settings**.
+13. Select **Player Settings…**.
+14. Beneath **Settings for PC, Mac, & Linux Standalone**, select **Resolution and Presentation** to open the section options.
+15. From **Resolution** > **Fullscreen Mode**, change **Fullscreen Window** to **Windowed**.
+16. Return to the Editor main window and save your scene.
+
+## Test the command-line helper
+
+Follow these instructions to test that the command-line helper script works.
+
+1. Select **File** > **Build and Run**.
+2. Create a new folder called `Build` inside your Hello World project folder.
+3. **Save As** the binary `HelloWorld`.
+
+Saving the project in this way causes the Unity Editor to build and launch the project in a new window. After it launches (and displays the plane), close the window you just launched.
+
+### Test on Windows
+
+To test on Windows:
+
+1. Open the Command Prompt.
+2. Use the following command to launch the server and the client. Make sure to replace the placeholder text within the angled brackets (`< >`) for all commands.
+ * You might get a [UAC prompt](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works) requesting permission to run the executable. Allow the executable to run to continue.
+
+Command to start the server:
+
+```cmd
+\HelloWorld.exe -mode server
+```
+
+Command to start the client:
+
+```cmd
+\HelloWorld.exe -mode client
+```
+
+To run these commands on a single line:
+
+```cmd
+\HelloWorld.exe -mode server & \HelloWorld.exe -mode client
+```
+
+Here's an example of what your command might look like when you replace the placeholder text in `< >`:
+
+```cmd
+\HelloWorld.exe -mode server & \HelloWorld.exe -mode client
+```
+There's no standard out stream on Windows by default, so you need to view the `Debug.log` file for the outputs. You can find the `Debug.log` files in:
+
+```cmd
+C:\Users\username\AppData\LocalLow\CompanyName\ProductName\Player.log
+```
+
+Where the `CompanyName` defaults to `DefaultCompany` for a new project and `ProductName` equals to the project's name.
+
+You can also change the Windows commands to create a `log.txt` file in the same folder as your `HelloWorld` folder.
+
+Change the commands as follows:
+
+Server command:
+
+```cmd
+\HelloWorld.exe -logfile log-server.txt -mode server
+```
+
+Client command:
+
+```cmd
+\HelloWorld.exe -logfile log-client.txt -mode client
+```
+
+Example (Running as a single command line):
+
+```cmd
+C:\Users\sarao>HelloWorld\Build\HelloWorld.exe -logfile log-server.txt -mode server & HelloWorld\Build\HelloWorld.exe -logfile log-client.txt -mode client
+```
+
+### Test on macOS
+
+Use the following instructions if you're using macOS:
+
+1. Open the Terminal app.
+2. Use the following command to launch the server and the client. Make sure to replace the placeholder text within the angled brackets (`< >`) for all commands.
+
+Command to start the server:
+
+```shell
+/HelloWorld.app/Contents/MacOS/ -mode server -logfile -
+```
+
+Command to start the client:
+
+```shell
+/HelloWorld.app/Contents/MacOS/ -mode client -logfile -
+```
+
+To run both as a single command:
+
+```shell
+/HelloWorld.app/Contents/MacOS/ -mode server -logfile - & HelloWorld.app/Contents/MacOS/ -mode client -logfile -
+```
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/get-started-with-ngo.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/get-started-with-ngo.md
new file mode 100644
index 0000000000..3510332f7f
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/get-started-with-ngo.md
@@ -0,0 +1,579 @@
+# Client-server quickstart for Netcode for GameObjects
+
+Use this guide to learn how to create your first [client-server](../terms-concepts/client-server.md) Netcode for GameObjects project. It walks you through creating a simple Hello World project that implements the basic features of Netcode for GameObjects.
+
+Refer to [Testing the command line helper](command-line-helper.md) to learn how to test your builds with a command-line helper.
+
+## Prerequisites
+
+Before you begin, you need the following:
+
+- An active Unity account with a valid license.
+- The [Unity Hub](https://unity.com/download).
+- A supported version of the Unity Editor. Refer to the [Netcode for GameObjects requirements](https://docs-multiplayer.unity3d.com/netcode/current/installation).
+
+Before continuing, create a new project using Unity Editor version 2022.3 or later.
+
+### Create an `Assets/Scripts/` folder
+
+If you don't already have an `Assets/Scripts/` folder, create one now:
+
+1. Right-click the **Assets** folder in the **Projects** tab, then select **Create** > **Folder**.
+2. Name the new folder **Scripts**.
+
+This is where you'll keep all your scripts as part of this Hello World project.
+
+## Install Netcode for GameObjects
+
+Refer to [Install Netcode for GameObjects](https://docs-multiplayer.unity3d.com/netcode/current/installation).
+
+## Add the basic components
+
+This section guides you through adding the essential components of a networked game:
+
+- [A NetworkManager component](#create-the-networkmanager-component)
+- [A player object](#create-an-object-to-spawn-for-each-connected-player)
+- [A scene](#add-your-scene-to-the-build)
+
+### Create the NetworkManager component
+
+This section guides you through creating a NetworkManager component.
+
+First, create the NetworkManager component:
+
+1. Right-click in the **Hierarchy** tab, then select **Create Empty** to create an empty GameObject.
+
+
+
+2. Rename the empty GameObject **NetworkManager**.
+
+
+
+3. Select **NetworkManager**, then select **Add Component** from the **Inspector** tab.
+
+
+
+4. Select **Netcode** > **NetworkManager** from the component list.
+
+
+
+5. In the Inspector tab, locate the Unity Transport section, then select **UnityTransport** as the **Protocol type**.
+
+
+
+
+
+6. Save the scene by pressing **Ctrl/Cmd** + **S** (or by selecting **File** > **Save**).
+
+### Create an object to spawn for each connected player
+
+> [!NOTE]
+> When you drop the prefab into the **PlayerPrefab** slot, you're telling the library that when a client connects to the game, it automatically spawns this prefab as the character for the connecting client. Netcode for GameObjects won't spawn a player object if you don't have any prefab set as the **PlayerPrefab**. Refer to [Player Objects](../basics/networkobject.md#finding-playerobjects).
+
+
+This section guides you through creating an object that spawns for each connected player.
+
+1. In the Unity Editor, right-click within the **Hierarchy** tab, then select **3D Object** > **Capsule**.
+2. Name the Capsule Object **Player**.
+3. With Player selected, add a NetworkObject component in the **Inspector** tab by selecting **Add Component** > **Netcode** > **NetworkObject**.
+4. Right-click within the **Assets** folder under the **Project** tab, then select **Create** > **Folder**.
+5. Name the folder **Prefabs**.
+6. Make the **Player** object you created earlier into a prefab by dragging it from the **Hierarchy** tab into the **Prefabs** folder.
+
+
+
+7. Delete the Player from the scene by selecting the Player capsule within the **Scene** tab, then pressing the **Delete** key (or **Cmd** + **Delete** for macOS).
+ * You can remove the Player GameObject from the scene because you assign this network prefab to the Player prefab property in the NetworkManager component. The library doesn't support defining a player object as an in-scene placed NetworkObject.
+8. Select **NetworkManager**.
+9. With NetworkManager selected, locate the **PlayerPrefab** field in the **Inspector** tab.
+
+
+
+10. Drag the **Player** prefab from the **Project** tab into the **PlayerPrefab** slot within the **NetworkManager** component in the **Inspector** tab.
+
+
+
+11. Add a 3D Plane (centered at 0,0,0) to the scene by right-clicking in the **Hierarchy** tab, then selecting **3D Object** > **Plane**.
+ * Adding the Plane adds a visual reference point to visualize the Player prefab's position, but it isn't necessary.
+
+
+12. Save the scene by pressing **Ctrl/Cmd** + **S** (selecting **File** > **Save**).
+
+### Scene management and the scenes in build list
+
+Netcode for GameObjects comes with an integrated scene management solution that helps you synchronize what scenes should be loaded by all connected clients. The `NetworkManager` **Enable Scene Management** property, enabled by default, determines whether the integrated scene management solution will be used for your project (or not). In order for the integrated scene management solution to work properly, you must add any scene you want to be synchronized to the scenes in build list. This section guides you through adding your current scene to the scenes in build list.
+
+1. Open the Build Settings window by selecting **File** > **Build Settings**.
+2. Select **Add Open Scenes**.
+3. **Scenes/SampleScene** is listed under **Scenes In Build**. You can close the Build Settings window.
+
+## Test starting a host in the Unity Editor
+
+Now that you have a **NetworkManager**, assigned a **PlayerPrefab**, and added your current scene to the scenes in build test, you can quickly verify everything is functioning/configured correctly via entering play mode in the Unity Editor. By starting a host, you are starting `NetworkManager` as both a server and a client at the same time.
+
+You can test your Hello World project using the Unity Editor or a command-line helper. If you choose the latter, refer to [Create a command line helper](../tutorials/command-line-helper/). Otherwise, refer to the following instructions to test using the Unity Editor. Only the Plane appears on the server until the first client connects. Then, Netcode for GameObjects spawns a new Player prefab for each connected client; however, they overlap in the Game view.
+
+1. Select **Play** from the top of the Unity Editor to start the scene.
+
+
+
+2. Select **NetworkManager** from the **Hierarchy** list.
+
+
+
+3. With **NetworkManager** selected (in the Hierarchy tab), select **Start Host** from the **Inspector** tab. Alternatively, you can use the in-game GUI buttons.
+
+
+
+If it works correctly, the option to **Stop Host** displays in the **Inspector** tab.
+
+
+### The `HelloWorldManager.cs` script
+
+Now that you have verified everything is configured correctly, you will want to have the ability to start the `NetworkManager` whether in play mode, as a stand alone build, or in another MPPM instance. This section will walk you through creating the `HelloWorldManager.cs` component script.
+
+1. Create a new script in the `Scripts` folder named `HelloWorldManager.cs`.
+2. Add this component to the `NetworkManager` `GameObject` in your scene.
+3. Copy the following code into the `HelloWorldManager.cs` script:
+
+```csharp
+using Unity.Netcode;
+using UnityEngine;
+
+namespace HelloWorld
+{
+ public class HelloWorldManager : MonoBehaviour
+ {
+ private NetworkManager m_NetworkManager;
+
+ void Awake()
+ {
+ m_NetworkManager = GetComponent();
+ }
+
+ void OnGUI()
+ {
+ GUILayout.BeginArea(new Rect(10, 10, 300, 300));
+ if (!m_NetworkManager.IsClient && !m_NetworkManager.IsServer)
+ {
+ StartButtons();
+ }
+ else
+ {
+ StatusLabels();
+
+ SubmitNewPosition();
+ }
+
+ GUILayout.EndArea();
+ }
+
+ static void StartButtons()
+ {
+ if (GUILayout.Button("Host")) m_NetworkManager.StartHost();
+ if (GUILayout.Button("Client")) m_NetworkManager.StartClient();
+ if (GUILayout.Button("Server")) m_NetworkManager.StartServer();
+ }
+
+ static void StatusLabels()
+ {
+ var mode = m_NetworkManager.IsHost ?
+ "Host" : m_NetworkManager.IsServer ? "Server" : "Client";
+
+ GUILayout.Label("Transport: " +
+ m_NetworkManager.NetworkConfig.NetworkTransport.GetType().Name);
+ GUILayout.Label("Mode: " + mode);
+ }
+
+ static void SubmitNewPosition()
+ {
+ if (GUILayout.Button(m_NetworkManager.IsServer ? "Move" : "Request Position Change"))
+ {
+ if (m_NetworkManager.IsServer && !m_NetworkManager.IsClient )
+ {
+ foreach (ulong uid in m_NetworkManager.ConnectedClientsIds)
+ m_NetworkManager.SpawnManager.GetPlayerNetworkObject(uid).GetComponent().Move();
+ }
+ else
+ {
+ var playerObject = m_NetworkManager.SpawnManager.GetLocalPlayerObject();
+ var player = playerObject.GetComponent();
+ player.Move();
+ }
+ }
+ }
+ }
+}
+```
+
+In your Hello World project, you created a NetworkManager by adding the pre-created NetworkManager component to a `GameObject`. This component allows you to start a Host, Client, or Server in Play Mode via the inspector view. The `HelloWorldManager.cs` script simplifies and extends this functionality by creating a runtime/play mode UI menu that allows you to select the three different `NetworkManager` modes you can start:
+
+- The **Host** starts the server and joins as a client.
+- The **Client** joins the server as a client player.
+- The **Server** starts the game as a server without instantiating a player.
+
+The `HelloWorldManager.cs` script accomplishes this menu within the `StartButtons().` After you select a button, the `StatusLabels()`method adds a label on-screen to display which mode you have selected. This helps distinguish Game view windows from each other when testing your multiplayer game.
+
+```csharp
+ static void StartButtons()
+ {
+ if (GUILayout.Button("Host")) NetworkManager.Singleton.StartHost();
+ if (GUILayout.Button("Client")) NetworkManager.Singleton.StartClient();
+ if (GUILayout.Button("Server")) NetworkManager.Singleton.StartServer();
+ }
+
+ static void StatusLabels()
+ {
+ var mode = NetworkManager.Singleton.IsHost ?
+ "Host" : NetworkManager.Singleton.IsServer ? "Server" : "Client";
+
+ GUILayout.Label("Transport: " +
+ NetworkManager.Singleton.NetworkConfig.NetworkTransport.GetType().Name);
+ GUILayout.Label("Mode: " + mode);
+ }
+```
+
+As seen in the earlier code snippet, the `HelloWorldManager.cs` script also uses the NetworkManager's instance via its singleton to grab properties like the `IsClient`, `IsServer`, and `IsLocalClient`. The `IsClient` and `IsServer` properties dictate the established connection state.
+
+The `HelloWorldManager.cs` script also introduces a new method called `SubmitNewPosition()` that the `HelloWorldPlayer` script uses to [create a simple RPC call](#add-simple-rpc-use).
+
+## Adding RPCs (Remote Procedure Calls)
+
+This section guides you through adding basic RPCs to the project. Save your scripts in your `Assets/Scripts/` folder. RPCs are used to call functions on remote clients or the server.
+
+Create a script named `RpcTest.cs`:
+
+1. In the **Project** tab, select **Assets** > **Scripts**.
+2. Right-click in the **Scripts** folder and select **Create** > **C# Script**.
+3. Name the script `RpcTest`.
+
+Add the `RpcTest.cs` script to the Player prefab:
+
+1. Select the **Player** prefab in **Assets** > **Prefabs**.
+2. In the **Inspector** tab (with the Player prefab selected), select **Add Component**.
+3. Select **Scripts** > **Rpc Test**.
+
+Edit the `RpcTest.cs` script:
+
+1. In the **Project** tab, select **Assets** > **Scripts** > **`RpcTest`**.
+2. In the **Inspector** tab (with the script selected), select **Open**. This opens this script in the default local text editor.
+3. Edit the `RpcTest.cs` script to match the following:
+
+```csharp
+using Unity.Netcode;
+using UnityEngine;
+
+public class RpcTest : NetworkBehaviour
+{
+ public override void OnNetworkSpawn()
+ {
+ if (!IsServer && IsOwner) //Only send an RPC to the server from the client that owns the NetworkObject of this NetworkBehaviour instance
+ {
+ ServerOnlyRpc(0, NetworkObjectId);
+ }
+ }
+
+ [Rpc(SendTo.ClientsAndHost)]
+ void ClientAndHostRpc(int value, ulong sourceNetworkObjectId)
+ {
+ Debug.Log($"Client Received the RPC #{value} on NetworkObject #{sourceNetworkObjectId}");
+ if (IsOwner) //Only send an RPC to the owner of the NetworkObject
+ {
+ ServerOnlyRpc(value + 1, sourceNetworkObjectId);
+ }
+ }
+
+ [Rpc(SendTo.Server)]
+ void ServerOnlyRpc(int value, ulong sourceNetworkObjectId)
+ {
+ Debug.Log($"Server Received the RPC #{value} on NetworkObject #{sourceNetworkObjectId}");
+ ClientAndHostRpc(value, sourceNetworkObjectId);
+ }
+}
+```
+
+4. Save the Scene by pressing **Ctrl/Cmd** + **S** (or by selecting **File** > **Save**).
+
+### Test the RPCs
+
+This section guides you through testing the RPCs you added in the earlier section.
+
+1. Select **File** > **Build Setting...**.
+2. In the **Build Setting** window, configure your build settings as needed.
+3. Click **Build** and choose a location to save your first build.
+4. After the first build is done, return to the **Build Setting** window.
+5. Click **Build** again and choose a different location to save your second build.
+ * Alternatively, you can run the builds by:
+ - Launching the client and server together in a terminal, as shown in [Testing the command line helper](command-line-helper.md).
+ - Using the Multiplayer Play Mode package, which lets you run multiple instances of the Unity Editor to test multiplayer functionality. Refer to [Multiplayer Play Mode](https://docs-multiplayer.unity3d.com/tools/current/mppm) to learn more.
+
+After the client and server spawn, a log displays in the **Console** of the client and server sending RPC messages to each other.
+
+The client kicks off the exchange in its `OnNetworkSpawn` call for the first time with a counter value of `0`. It then makes an RPC call to the server with the next value. The server receives this and calls the client. The Console displays the following for the server and client respectively.
+
+```log
+Server Received the RPC #0 on NetworkObject #1
+Server Received the RPC #1 on NetworkObject #1
+Server Received the RPC #2 on NetworkObject #1
+Server Received the RPC #3 on NetworkObject #1
+...
+```
+
+```log
+Client Received the RPC #0 on NetworkObject #1
+Client Received the RPC #1 on NetworkObject #1
+Client Received the RPC #2 on NetworkObject #1
+Client Received the RPC #3 on NetworkObject #1
+...
+```
+
+Only the client owning the `NetworkObject` owning the `RpcTest` script will send RPCs on the server, but they will all receive RPCs from the server. This means that if you test with multiple clients the consoles will log RPCs received once per `NetworkObject` per iteration on the server and all clients. If testing with a host and a client, you will see the following on the host's **Console**. This is because as a server it will receive the other client's server RPCs and as a client it will also receive its own client RPCs.
+
+```log
+Server Received the RPC #0 on NetworkObject #2
+Client Received the RPC #0 on NetworkObject #2
+Server Received the RPC #1 on NetworkObject #2
+Client Received the RPC #1 on NetworkObject #2
+Server Received the RPC #2 on NetworkObject #2
+Client Received the RPC #2 on NetworkObject #2
+Server Received the RPC #3 on NetworkObject #2
+Client Received the RPC #3 on NetworkObject #2
+...
+```
+
+> [!NOTE]
+> The `NetworkObjectId` here is `2` because the host also has a NetworkObject with the `RpcTest` script spawned for it, but it won't send the initial RPC starting the chain because it's a server.
+
+## Adding Netcode script to your player prefab
+
+At this point, you should have set up script and should have experimented with sending and receiving RPCs via the `RpcTest.cs` script above. This next step demonstrates how you can add additional netcode logic to your player prefab via the `HelloWorldPlayer.cs` script.
+
+1. Create a new script in the `Scripts` folder named `HelloWorldPlayer.cs`.
+2. Copy the following code into the `HelloWorldPlayer.cs` script and save it:
+
+```csharp
+using Unity.Netcode;
+using UnityEngine;
+
+namespace HelloWorld
+{
+ public class HelloWorldPlayer : NetworkBehaviour
+ {
+ public NetworkVariable Position = new NetworkVariable();
+
+ public override void OnNetworkSpawn()
+ {
+ if (IsOwner)
+ {
+ Move();
+ }
+ }
+
+ public void Move()
+ {
+ SubmitPositionRequestRpc();
+ }
+
+ [Rpc(SendTo.Server)]
+ void SubmitPositionRequestRpc(RpcParams rpcParams = default)
+ {
+ var randomPosition = GetRandomPositionOnPlane();
+ transform.position = randomPosition;
+ Position.Value = randomPosition;
+ }
+
+ static Vector3 GetRandomPositionOnPlane()
+ {
+ return new Vector3(Random.Range(-3f, 3f), 1f, Random.Range(-3f, 3f));
+ }
+
+ void Update()
+ {
+ transform.position = Position.Value;
+ }
+ }
+}
+```
+
+#### A Review of the `HelloWorldPlayer.cs` script
+
+The `HelloWorldPlayer.cs` script adds some basic movement to the Hello World project player. Both the server player and the client player can start player movement. However, the movement occurs through the server's position NetworkVariable, which means the server player can move immediately, but the client player must request a movement from the server, wait for the server to update the position NetworkVariable, then replicate the change locally.
+
+The `HelloWorldPlayer` class inherits from `Unity.Netcode`'s `NetworkBehaviour` instead of `MonoBehaviour`. This allows you to customize the networking code as you override what happens when the Player spawns.
+
+```csharp
+public class HelloWorldPlayer : NetworkBehaviour
+```
+
+For multiplayer games, every object runs on at least two machines: player one and player two. Because of this, you need to ensure both machines have the same behavior and have the correct information about the object. One of the instances that come into play then is to understand how the Player moves. Only one player controls how the Player object moves. The following code enforces this by validating if the machine running the code is the player's owner.
+
+```csharp
+ public override void OnNetworkSpawn()
+ {
+ if (IsOwner)
+ {
+ Move();
+ }
+ }
+```
+
+Any `MonoBehaviour` implementing a NetworkBehaviour component can override the Netcode for GameObjects method `OnNetworkSpawn()`. The `OnNetworkSpawn()` method fires in response to the `NetworkObject` spawning. The `HelloWorldPlayer` class overrides `OnNetworkSpawn` because clients and the server run different logic. You can override this behavior on any NetworkBehaviour component.
+
+Because the server and client can be the same machine and the Player's owner (aka Host), you want further to differentiate the two and have different Move behavior for each.
+
+If the current player is the server, the code determines a random position to spawn the Player. You can't find the spawn location if the current player is the client. You have to get it from the server.
+
+```csharp
+ public void Move()
+ {
+ SubmitPositionRequestRpc();
+ }
+
+ [Rpc(SendTo.Server)]
+ void SubmitPositionRequestRpc(RpcParams rpcParams = default)
+ {
+ var randomPosition = GetRandomPositionOnPlane();
+ transform.position = randomPosition;
+ Position.Value = randomPosition;
+ }
+
+ void Update()
+ {
+ transform.position = Position.Value;
+ }
+```
+
+#### Positioning the player using an RPC
+
+This section walks you through the `HelloWorldPlayer.cs` portion of the script that declares the `SubmitPositionRequestRpc` RPC.
+
+If the player is a server-owned player at `OnNetworkSpawn()`, you can immediately move this player, as suggested in the following code.
+
+```csharp
+ SubmitPositionRequestRpc();
+```
+
+You can call this `Rpc` when the player is a client or a server. When you call an `Rpc` with `SendTo.Server` on the server side, it executes in the same way as a local function call by default.
+
+The `Rpc` sets the position NetworkVariable on the server's instance of the player by just picking a random point on the plane.
+
+```csharp
+ [Rpc(SendTo.Server)]
+ void SubmitPositionRequestRpc(RpcParams rpcParams = default)
+ {
+ var randomPosition = GetRandomPositionOnPlane();
+ transform.position = randomPosition;
+ Position.Value = randomPosition;
+ }
+```
+
+The server instance of the player modifies the `Position` `NetworkVariable` through the `Rpc`. If the player is a client, it must apply the position locally inside the `Update` loop. (Since the two values are the same on the server, the server can run the same logic with no side effects, but you could also add `if(IsClient)` here.)
+
+```csharp
+ void Update()
+ {
+ transform.position = Position.Value;
+ }
+```
+
+Because the `HelloWorldPlayer.cs` script handles the position NetworkVariable, the `HelloWorldManager.cs` script can define the contents of `SubmitNewPosition()`.
+
+```csharp
+ static void SubmitNewPosition()
+ {
+ if (GUILayout.Button(NetworkManager.Singleton.IsServer ? "Move" : "Request Position Change"))
+ {
+ var playerObject = NetworkManager.Singleton.SpawnManager.GetLocalPlayerObject();
+ var player = playerObject.GetComponent();
+ player.Move();
+ }
+ }
+```
+
+The method in the code block above adds a contextual button that changes depending on whether the client is a server or a client. When you press the button this method creates, it finds your local player and calls `Move()`.
+
+You can now create a build that shows the concepts outlined above.
+
+Create two build instances: one for the host and the other for the client (to join the host's game).
+
+Both build instances can move the player with the GUI button. The server moves the player immediately and replicates the movement on the client.
+
+The client can request a new position, instructing the server to change that instance's position `NetworkVariable`. After the server updates the position `NetworkVariable`, the client applies that `NetworkVariable` position inside its `Update()` method.
+
+## Add the `HelloWorldPlayer.cs` script to the Player prefab
+
+This section guides you through adding the `HelloWorldPlayer.cs` script to the Player prefab.
+
+Select the Player prefab:
+
+1. From the **Project** tab, select **Assets** > **Prefabs**.
+2. Select **Player**.
+
+Add the `HelloWorldPlayer.cs` script to the Player prefab as a component:
+
+1. With the Player prefab selected, select **Add Component** from the Inspector tab.
+2. Select **Scripts** > **Hello World** > **Hello World Player**.
+
+
+## Add a NetworkTransform
+
+This section guides you through adding a `NetworkTransform` component that moves the player. `NetworkTransform` is a component used to synchronize the position, rotation, and scale of objects across the network.
+
+Add a NetworkTransform component to the Player prefab:
+
+1. Select the **Player** prefab in Assets > Prefabs.
+2. In the **Inspector** tab (with the Player prefab selected), select **Add Component**.
+3. Select **Netcode** > **NetworkTransform**.
+
+Create a script named `NetworkTransformTest.cs`.
+
+1. In the **Project** tab, go to **Assets** > **Scripts**.
+2. Right-click, then select **Create** > **C# Script**.
+3. Name it `NetworkTransformTest`.
+
+Add the `NetworkTransformTest` script to the Player prefab:
+
+1. Select the **Player** prefab in **Assets** > **Prefabs**.
+2. In the **Inspector** tab (with the Player prefab selected), select **Add Component**.
+3. Select **Scripts** > **Network Transform Test**.
+
+Edit the `NetworkTransformTest.cs` script:
+
+1. In the **Project** tab, select **Assets** > **Scripts** > **`NetworkTransformTest`**.
+2. In the **Inspector** tab (with the script selected), select **Open**. This opens this script in the default local text editor.
+3. Edit the `NetworkTransformTest.cs` script to match the following:
+
+```csharp
+using System;
+using Unity.Netcode;
+using UnityEngine;
+
+public class NetworkTransformTest : NetworkBehaviour
+{
+ void Update()
+ {
+ if (IsServer)
+ {
+ float theta = Time.frameCount / 10.0f;
+ transform.position = new Vector3((float) Math.Cos(theta), 0.0f, (float) Math.Sin(theta));
+ }
+ }
+}
+```
+
+4. Save the scene by pressing **Ctrl/Cmd** + **S** (or by selecting **File** > **Save**).
+
+### Test the NetworkTransform
+
+This section guides you through testing the NetworkTransform you added in the earlier section.
+
+1. Select **File** > **Build Setting...**.
+2. In the **Build Setting** window, configure your build settings as needed.
+3. Click **Build** and choose a location to save your first build.
+4. After the first build is done, return to the **Build Setting** window.
+5. Click **Build** again and choose a different location to save your second build.
+ * Alternatively, you can run the builds by:
+ - Launching the client and server together in a terminal, as shown in [Testing the command line helper](command-line-helper.md).
+ - Using the Multiplayer Play Mode package, which lets you run multiple instances of the Unity Editor to test multiplayer functionality. Refer to [Multiplayer Play Mode](https://docs-multiplayer.unity3d.com/tools/current/mppm) to learn more.
+
+After the client and server spawn, the player capsule moves in a circle on both the client and the server.
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/helloworld.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/helloworld.md
new file mode 100644
index 0000000000..5a60ff8690
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/helloworld.md
@@ -0,0 +1,276 @@
+# Your Netcode "Hello World" Project
+
+A "Hello World" program is a computer program that outputs or displays the message "Hello, World!". Normally it's the first program written by people learning to code. it's also used as a sanity test to make sure that a computer language is correctly installed and that the operator understands how to use it.
+
+This "Hello World" tutorial walks you through creating a project, installing Netcode for GameObjects (Netcode), and creating the basic components for your first networked game. it's also the base for the [Golden Path series](goldenpath_series/gp_intro.md).
+
+## Create a new project in Unity
+
+1. Open the **Unity Hub**.
+1. Click **New**.
+1. Select type '3D'
+1. Name the project *Hello World*.
+1. Select the location you want to save the project.
+
+## Install Netcode
+
+See the [install Netcode guide](../install.md) to install the Netcode package.
+
+## Create the Basic Components
+
+In this section we will create the basic building blocks of a multiplayer game.
+
+### Creating Network Manager and selecting the Transport
+
+In this section we add a Network Manager and add Unity Transport to our project. The [NetworkManager](../components/networkmanager.md) is the component that has all your project's netcode-related settings. Unity Transport is the transport layer that Netcode uses for communication between the server and the clients. See [here](../advanced-topics/transports.md) for more.
+
+1. Right-click in the **Hierarchy** tab of the main Unity Window.
+1. Select **Create Empty**.
+1. Rename the `GameObject` **NetworkManager**.
+2. Select **NetworkManager**.
+3. Click **Add Component** in the Inspector Tab.
+4. Select **Netcode** from the list shown.
+5. Select `NetworkManager` Component from the list displayed.
+6. Inside the `NetworkManager` component tab, locate the `NetworkTransport` field.
+7. Click "Select Transport".
+8. Select `UnityTransport`.
+9. Save your scene.
+
+## Creating an object to spawn for each connected player
+
+This section adds in a player object and spawns it for each connected player.
+
+1. Right-click in the **Hierarchy** tab of the Unity Window to create a **3D Object > Capsule**
+1. Rename it **Player**.
+1. While **Player** is selected, add a **Netcode** > `NetworkObject` component in the Inspector Tab.
+1. Click the **Assets** folder under the **Project** tab.
+2. Right-click inside the **Assets** folder to **Create** > **Folder** and call it **Prefabs**.
+3. Make **Player** a Prefab by dragging it to **Prefabs** folder you just created.
+4. Delete **Player** from scene.
+
+> [!NOTE]
+> We remove the **Player** object from the scene because we assign this network Prefab to the `Player Prefab` property in the `NetworkManager` component. The library does not support defining a player object as an in-scene placed `NetworkObject`.
+
+
+5. Select `NetworkManager`.
+6. Inside the `NetworkManager` component tab, locate the `Player Prefab` field.
+7. Drag this player Prefab from above into this field.
+
+> [!NOTE]
+> When you drop the Prefab into the `Player Prefab` slot, you are telling the library that when a client connects to the game, automatically spawn this Prefab as the character for the connecting client. If you don't have any Prefab set as the `Player Prefab` no player object will be spawned.
+
+1. Create a **3D Object->Plane**, centered at (0,0,0).
+1. Save your scene
+
+### Adding your scene to the build
+
+> [!NOTE]
+> When 'Enable Scene Management' is enabled for the NetworkManager (allowing the server to control which scenes should be loaded for the clients), we must ensure that the current scene has been added to the build, otherwise, we will be unable to enter play mode. This option is enabled by default.
+
+1. Click **File** > **Build Settings**, in the upper-left corner of the Unity window
+2. Click **Add Open Scenes**
+3. Close the `Build Settings` window.
+
+## Creating a command line helper
+
+This command line helper will allow us to launch builds with a command line argument that will start a networking session, either as a server, host, or client. This can make testing builds easier.
+
+1. Right-click the **Assets** folder and create a new folder by hovering over **Create** and selecting **Folder**. Name it **Scripts**.
+2. Create a script called `NetworkCommandLine` by right-clicking on your **Scripts** folder, hovering over **Create** and selecting **C# Script**.
+3. In the **Hierarchy** menu, right-click on the `NetworkManager` and choose **Create Empty**.
+
+ This will create an empty `GameObject` with `NetworkManager` as its parent.
+
+4. Rename this child `GameObject` `NetworkCommandLine`.
+5. With the new `NetworkCommandLine` object selected, click **Add Component** from the **Inspector** tab.
+6. Select **Scripts** from the drop-down and click on the `NetworkCommandLine.cs` script you created earlier.
+7. Open the `NetworkCommandLine.cs` script by double-clicking from the **Project** tab > **Assets** > **Scripts**. It will open in your text editor
+8. Edit the `NetworkCommandLine.cs` script to match the following:
+
+
+Click to show/hide the Code.
+
+
+
+``` csharp
+using System.Collections.Generic;
+using Unity.Netcode;
+using UnityEngine;
+
+public class NetworkCommandLine : MonoBehaviour
+{
+ private NetworkManager netManager;
+
+ void Start()
+ {
+ netManager = GetComponentInParent();
+
+ if (Application.isEditor) return;
+
+ var args = GetCommandlineArgs();
+
+ if (args.TryGetValue("-mode", out string mode))
+ {
+ switch (mode)
+ {
+ case "server":
+ netManager.StartServer();
+ break;
+ case "host":
+ netManager.StartHost();
+ break;
+ case "client":
+
+ netManager.StartClient();
+ break;
+ }
+ }
+ }
+
+ private Dictionary GetCommandlineArgs()
+ {
+ Dictionary argDictionary = new Dictionary();
+
+ var args = System.Environment.GetCommandLineArgs();
+
+ for (int i = 0; i < args.Length; ++i)
+ {
+ var arg = args[i].ToLower();
+ if (arg.StartsWith("-"))
+ {
+ var value = i < args.Length - 1 ? args[i + 1].ToLower() : null;
+ value = (value?.StartsWith("-") ?? false) ? null : value;
+
+ argDictionary.Add(arg, value);
+ }
+ }
+ return argDictionary;
+ }
+}
+```
+
+
+
+9. Paste the copied code into your code editor.
+1. Save your changes. Your script will reload in the Unity Editor.
+1. Back in the Editor, open **Edit** -> **Project Settings**
+1. Select the **Player tab**.
+1. Expand the **Resolution and Presentation**.
+1. From **Resolution** > **Fullscreen Mode**, change `Fullscreen Window` to `Windowed`.
+1. Back to the Editor main window, save your scene.
+
+
+> [!NOTE]
+> If you are using a Pro Unity license, you may want to disable the splash screen by unchecking **Splash Image** > **Splash Screen** > **Show Splash Screen**.
+
+### Testing the command line helper
+
+Now we will test that the command line helper script works.
+
+1. Select **File** > **Build and Run**.
+1. Create a new folder called `Build` inside your Hello World project folder.
+1. **Save As** the binary `HelloWorld`.
+1. Your project will build and launch in a new window, and you should see the plane.
+1. Quit your app.
+1. Now to launch from the command line.
+
+#### Windows
+
+For Windows you should do the following:
+
+
+1. Open your Command Prompt.
+1. Enter the following. Be sure to change the noted section `< >` of **both** commands to your project.
+
+> [!NOTE]
+> You may get a UAC prompt requesting permission for the binary to run you should allow it.
+
+ Server:
+ ```
+ \Build\HelloWorld.exe -mode server
+ ```
+
+ Client:
+ ```
+ \Build\HelloWorld.exe -mode client
+ ```
+
+ To run these commands on a single line:
+ ```
+ HelloWorld\Build\HelloWorld.exe -mode server & HelloWorld\Build\HelloWorld.exe -mode client
+ ```
+
+ Example:
+ ```
+ C:\Users\sarao>HelloWorld\Build\HelloWorld.exe -mode server & HelloWorld\Build\HelloWorld.exe -mode client
+ ```
+
+On Windows, no standard out stream exists by default, so you will need to view the Debug.log file to see the outputs. You can find the Debug.log files in:
+
+`C:\Users\username\AppData\LocalLow\CompanyName\ProductName\Player.log`
+
+Where the `CompanyName` should default to `DefaultCompany` for a new project and `ProductName` should be equal to the project's name.
+
+Alternatively you can modify the Windows commands to create a log.txt file in the same folder as your **HelloWorld** folder.
+
+Modify the commands as follows:
+
+ Server:
+ ```
+ \Build\HelloWorld.exe -logfile log-server.txt -mode server
+ ```
+
+ Client:
+ ```
+ \Build\HelloWorld.exe -logfile log-client.txt -mode client
+ ```
+
+ Example (Running as a single command line):
+ ```
+ C:\Users\sarao>HelloWorld\Build\HelloWorld.exe -logfile -log-server.txt -mode server & HelloWorld\Build\HelloWorld.exe -logfile log-client.txt -mode client
+ ```
+
+#### MacOS
+
+For Mac you should do the following:
+
+1. Open Terminal.
+2. Enter the following. Be sure to change the noted section `< >` of **both** commands to your project.
+
+Server
+```
+/Build/HelloWorld.app/Contents/MacOS/ -mode server -logfile -
+```
+
+Client
+```
+/Build/HelloWorld.app/Contents/MacOS/ -mode client -logfile -
+```
+
+Run both as a single command:
+```
+/Build/HelloWorld.app/Contents/MacOS/ -mode server -logfile - & ; ~ /Build/HelloWorld.app/Contents/MacOS/ -mode client -logfile -
+```
+
+## Testing Hello World
+
+### Route 1 - Editor
+Now, to see if everything works as expected we can test starting a host in the editor. A host plays the role of a server and a client at the same time.
+
+1. Click **Play**.
+1. Click the **Start Host** button in the **NetworkManager** GameObject's inspector.
+1. You should now see your scene with your Player Prefab spawned.
+
+### Route 2 - Command Line
+You can also use the command line helper to launch a server and one or more clients to connect to the server. You should see just the plane on the server until the first client connects. Then, a new Player Prefab will be spawned by Netcode for each connected client; however, they will be overlapped in the game view.
+
+## Next Steps
+
+See the following content to continue your journey using Netcode:
+
+* Build on the Hello World project to continue learning about different features of Netcode with the [Golden Path series](goldenpath_series/gp_intro.md).
+* Check out the educational samples to further explore Netcode and its abilities:
+ * [Boss Room](../learn/bossroom/getting-started-boss-room.md)
+ * [2D Spaceshooter Bitesize Sample](../learn/bitesize/bitesize-spaceshooter.md)
+ * [Invaders Bitesize Sample](../learn/bitesize/bitesize-invaders.md)
+ * [Client-Driven Bitesize Sample](../learn/bitesize/bitesize-clientdriven.md)
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md
new file mode 100644
index 0000000000..aadbec86b8
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/techniques_and_tricks_for_debugging_multiplayer_games.md
@@ -0,0 +1,176 @@
+# Techniques and tricks for debugging multiplayer games
+
+When debugging games, multiplayer games included, it helps to know the toolbag that we have at our disposal.
+
+All the conventional game development wisdom applies, however certain scenarios that are typical to multiplayer game development call for special tricks and approaches.
+
+Below is a list of practices and techniques that we use daily when working on the Boss Room sample. These recommendations, we find, compound into a more comfortable working experience when developing multiplayer games with Unity.
+
+## Debugging tricks for multiplayer games
+
+### Use ParrelSync clone-based workflow during development.
+
+[ParrelSync workflow](testing_locally.md#parrelsync) is faster than creating builds and it allows you to debug the separate editor instances via separate IDE debuggers.
+
+Use ParrelSync to run separate editor instances for your Host/Server and Client.
+
+### Use debug drawing techniques extensively
+
+Unity engine has two debug rendering APIs that are useful for the purposes of multiplayer game debugging:
+ - [Debug.DrawRay](https://docs.unity3d.com/ScriptReference/Debug.DrawRay.html)
+ - [Debug.DrawLine](https://docs.unity3d.com/ScriptReference/Debug.DrawLine.html)
+
+Both of these functions allow us to draw arbitrary debug lines that would be visible in the Scene view and in the Game view, provided Gizmo rendering is enabled (to enable Gizmo rendering in Game view you need to click on the `Gizmos` menu at the top of the Game view).
+
+The key trick here is to use different colors for different kinds of information and to make the lines stay long enough for visual inspection by setting `duration` parameter. This technique shines when it's combined with [screen recordings](#7-recording-the-video-of-gameplay) of [multiple peers running side by side in separate editor instances via ParrelSync](#1-use-parrelsync-workflow-during-development).
+
+The code below would render a green debug line that's 2 units tall at the position of the transform, and this line would stay on screen for 4 seconds:
+`Debug.DrawLine(this.transform.position, this.transform.position + Vector3.UP * 2f, Color.green, duration: 4f);`
+
+When working on Boss Room we found it valuable to draw debug lines for the following items:
+ - Visual position
+ - Network position
+ - Movement intention
+ - Object interactions
+
+### A Netcode Enabled Line Renderer
+Sometimes it's useful to have visual feedback that shows a specific direction, value, or any other useful debug metric pertinent to your project. Below is a fully working example of a netcode enabled line renderer that can be used for visual debugging purposes:
+```csharp
+using UnityEngine;
+using Unity.Netcode;
+public class NetcodeEnabledLineRenderer : NetworkBehaviour
+{
+ private LineRenderer m_LineRenderer;
+ private Vector3[] m_Positions;
+ private Material m_LineMaterial;
+
+ [Tooltip("The default state of the netcode debug render lines")]
+ [SerializeField]
+ private bool m_EnableDebugLines = true;
+
+ [Tooltip("The length of the line")]
+ public float LineLength = 4.0f;
+
+ [Tooltip("The width of the line")]
+ public float LineWidth = 0.3f;
+
+ private void Awake()
+ {
+ // Add a line renderer component
+ m_LineRenderer = gameObject.AddComponent();
+
+ // Switch to a legacy built-in shader that will work with just colors and/or a color gradient
+ m_LineMaterial = new Material(Shader.Find("Legacy Shaders/Particles/Alpha Blended Premultiply"));
+
+ // Assign this new material to the line renderer
+ m_LineRenderer.material = m_LineMaterial;
+
+ // Create our start color for the gradient
+ var colorKeyStart = new GradientColorKey();
+ colorKeyStart.color = Color.red;
+ // The "start" should be 0.0f
+ colorKeyStart.time = 0.0f;
+
+ // Create our end color for the gradient
+ var colorKeyEnd = new GradientColorKey();
+ colorKeyEnd.color = Color.blue;
+ // The "end" should be 1.0f
+ colorKeyEnd.time = 1.0f;
+
+ // Now create and apply the gradient
+ m_LineRenderer.colorGradient = new Gradient() { colorKeys =
+ new GradientColorKey[2] { colorKeyStart, colorKeyEnd },
+ mode = GradientMode.Blend };
+
+ //declare two positions for the start and end of the line
+ m_Positions = new Vector3[2];
+
+ //Ensure that the line renderer knows to draw in world space
+ m_LineRenderer.useWorldSpace = true;
+
+ //set the beginning and ending width of the line in units
+ m_LineRenderer.startWidth = 0.3f;
+ m_LineRenderer.endWidth = 0.3f;
+ }
+
+ public override void OnDestroy()
+ {
+ // With NetworkBehaviours, always make sure to invoke the
+ // base.OnDestroy method
+ base.OnDestroy();
+
+ // We should always destroy any runtime materials we create
+ if (m_LineMaterial != null)
+ {
+ Destroy(m_LineMaterial);
+ }
+ }
+
+ ///
+ /// Update the position of the line
+ ///
+ private void Update()
+ {
+ if (IsSpawned && m_EnableDebugLines)
+ {
+ //set the start and end positions of our line
+ m_Positions[0] = transform.position;
+ m_Positions[1] = transform.position + Vector3.up * LineLength;
+
+ //feed the values to the line renderer
+ m_LineRenderer.SetPositions(m_Positions);
+ }
+ }
+
+ ///
+ /// Example for having netcode debug render lines
+ ///
+ [Rpc(SendTo.ClientsAndHost)]
+ private void ToggleDebugLinesClientRpc(bool drawDebugLines)
+ {
+ m_EnableDebugLines = drawDebugLines;
+ }
+
+ ///
+ /// Server-Side only
+ /// Enables/Disables the debug line rendering
+ ///
+ public void DebugLinesEnabled(bool enableDebugLines)
+ {
+ if (IsSpawned && IsServer)
+ {
+ m_EnableDebugLines = enableDebugLines;
+ ToggleDebugLinesClientRpc(m_EnableDebugLines);
+ }
+ }
+}
+```
+
+### Use debug logging for situations where visual debugging isn't appropriate.
+
+Text-based logging is valuable for tracking down non-visual events (such as RPCs) and information.
+It is a good idea to include network tick and client id in log messages so that it's easier to build a timeline when reading the logs.
+
+### Use the artificial network conditioning tools.
+
+The options that are currently available to us are covered in the related [article on artificial network conditioning tools](testing_with_artificial_conditions.md).
+
+Of particular interest to us is the application-level network conditioning provided by [Network Simulator tools](https://docs-multiplayer.unity3d.com/tools/current/tools-network-simulator/), as it allows us to easily specify conditions for our individual peers that live within separate editors by means of ParrelSync.
+
+Artificial network conditions allow the errors and oddities that are hidden by nigh-absence of lag when running your instances locally to show up, and it's a good thing!
+
+### Capturing screen recordings of the game instances.
+
+First of all, it's valuable to record both your Client and Server at the same time - it allows you to compare what is happening on either peer in realtime.
+
+When recording your screen, sometimes it's hard to see if we are legitimately missing an update in our game or if it's just our recording refresh rate isn't synced with Unity's refresh calls.
+
+In debug builds it's a great idea to show the Peer ID and the current frame number somewhere in the corner of the screen - this way there is a visual reference to the number of the frame we're currently observing on the recording.
+
+Sometimes, despite us using good debug rendering and logging it's still hard to understand what's going on even when going through the frames one by one. Increasing our FixedTimeStep setting to a ridiculous value (something as high as `0.2`) helps to have more time to see what's going on.
+
+The same applies to high latencies (1000ms) - these stress the lag hiding techniques, allowing us to visualize what the different lag hiding techniques are doing.
+
+### Using breakpoints to debug a Client or Server
+
+You can use breakpoints to debug a game, but your connection may time out if you stay too long in this mode. Since it pauses your game, you can temporarily increase the timeout value to avoid disconnecting.
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_client_connection_management.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_client_connection_management.md
new file mode 100644
index 0000000000..2a9f867fff
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_client_connection_management.md
@@ -0,0 +1,56 @@
+# Testing Client Connection Management
+
+Managing client connections in a networked game can lead to many unexpected edge-cases which if not properly tested and handled may cause bugs. Here is a non-exhaustive list of test cases that should be handled, depending on what features a game provides, and things to look out for.
+
+### Clients connecting
+- test cases:
+ - Client connecting to a new game session
+ - Client connecting to a new game session after leaving a previous game session
+ - in the case of a client-hosted game, after ending a previous game as a host
+ - Client connecting to an ongoing game session (late-joining)
+ - Client reconnecting to an ongoing game session (see [Session Management](../../advanced-topics/session-management.md#Reconnection))
+ - Client failing to connect due to approval denied (see [Connection Approval](../../basics/connection-approval.md))
+- things to look out for:
+ - Client-Side:
+ - Does the state of the client before connecting have an impact (that is, if connecting after disconnecting from another game or hosting one)
+ - Does the game state get properly replicated from the server when connecting?
+ - Server-Side:
+ - Does the server properly handle reconnections or late-joining, if the game supports it, or does it deny approval if not?
+
+
+### Clients disconnecting
+- test cases:
+ - Client disconnecting gracefully by shutting down NetworkManager
+ - Client disconnecting by closing the application
+ - Client timing out when losing connection to the host/server
+ - By disabling internet on client
+ - By disabling it on the host/server
+- things to look out for:
+ - Client-side:
+ - Is the state of every object tied to the game session properly reset if not destroyed? (for example, if a NetworkBehaviour isn't destroyed when despawning, is its state properly reset via OnNetworkDespawn and OnNetworkSpawn?)
+ - Is the client brought back to a state from which it can try to connect to a new game?
+ - Server-Side:
+ - Is the server notified of this disconnection and does it handle it properly?
+ - If using outside services, are they notified of this? (for example if using a lobby service, is the client removed from the lobby?)
+
+### Host / Server starting the session
+- test cases:
+ - Host/Server starting a new game session
+ - Host/Server starting a new game session after shutting down a previous game session
+ - in the case of a client-hosted game, after disconnecting from a preivious game as a client
+- things to look out for:
+ - Server-side:
+ - Does the state of the application before starting a new session have an impact (that is, if starting after shutting down another game or disconnecting from one as a client)
+
+### Host / Server shutting down
+- test cases:
+ - Host/Server disconnecting gracefully by shutting down NetworkManager
+ - Host/Server disconnecting by closing the application
+ - If requiring services (i.e Unity Game Services or other services) to function:
+ - Host/Server timing out when losing connection to services
+- things to look out for:
+ - Client-side:
+ - Are clients notified of this shut down, and do they handle it?
+ - Server-side:
+ - Are the services used notified of this? (for example if using a lobby service, does the game properly close the lobby when shutting down the game session?)
+ - Is the state of every object tied to the game session properly reset if not destroyed? (for example, if a NetworkBehaviour isn't destroyed when despawning, is its state properly reset via OnNetworkDespawn and OnNetworkSpawn?)
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_locally.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_locally.md
new file mode 100644
index 0000000000..c393a08430
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_locally.md
@@ -0,0 +1,35 @@
+# Testing multiplayer games locally
+
+Testing a multiplayer game presents unique challenges:
+
+- You need to run multiple instances of the game to test multiplayer scenarios.
+- You also need to iterate quickly on custom code and asset changes and validate work in a multiplayer scenario.
+- You need to be able to debug work in a multiplayer scenario using Editor tools.
+
+There are several different ways you can test multiplayer games locally:
+
+- Using [player builds](#player-builds) to validate work on a target distribution platform, although player builds can be slow for local iteration.
+- Using the [Multiplayer Play Mode package](#multiplayer-play-mode) to simulate up to four players simultaneously on the same development device.
+- Using third-party tools such as [ParrelSync](https://github.com/VeriorPies/ParrelSync).
+
+## Player builds
+
+Player builds are best used to verify that your game works on target platforms or with a wider group of testers. Start by building an executable to distribute.
+
+1. Navigate to **File** > **Build Settings** in the menu bar.
+1. Click **Build**.
+
+### Local iteration using player builds
+
+After the executable build completes, you can distribute it to testers and launch several instances of the built executable to both host and join a game. You can also run the build alongside the Editor that produced it, which can be useful during iterative development.
+
+Though functional, this approach can be somewhat slow for the purposes of local iteration. You can use [Multiplayer Play Mode](#multiplayer-play-mode) to iterate locally at speed.
+
+> [!NOTE]
+> To run multiple instances of the same app, you need to use the command line on MacOS. Run `open -n YourAppName.app`.
+
+## Multiplayer Play Mode
+
+Multiplayer Play Mode is a Unity package you can use to simulate up to four players simultaneously on the same development device while using the same source assets on disk. It allows you to reduce project build times, run your game locally, and test the server-client relationship, all from within the Unity Editor.
+
+For more details, refer to the [Multiplayer Play Mode documentation](https://docs-multiplayer.unity3d.com/mppm/current/about/).
diff --git a/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_with_artificial_conditions.md b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_with_artificial_conditions.md
new file mode 100644
index 0000000000..019f6e7b84
--- /dev/null
+++ b/com.unity.netcode.gameobjects/Documentation~/tutorials/testing/testing_with_artificial_conditions.md
@@ -0,0 +1,205 @@
+# Testing multiplayer games with artificial network conditions
+
+When we are developing a multiplayer game that is intended to operate over the internet we inevitably have to deal with the reality of poor network conditions.
+
+Adverse network factors, such as latency, jitter, and packet loss all have to be taken into account during development and the tolerance thresholds for these should not be an afterthought or something relegated to an "optimization pass".
+
+> [!NOTE]
+> Not testing with artificial network conditions makes it significantly more likely to have unexpected behaviors when the game is running over the internet.
+
+This is challenging when we are [iterating on our game locally](testing_locally.md) - after all, all of the game instances are still running on the same network interface. It's reasonable to expect that there will be little to no latency between the clients, which is no good for our purposes - we want the network to **misbehave**.
+
+Thankfully there are a number of tools that can simulate adverse network conditions.
+
+For testing locally within the Editor, you can use the [Network Simulator tool](https://docs-multiplayer.unity3d.com/tools/current/tools-network-simulator/) along with [clone-based workflow via ParrelSync](testing_locally.md#parrelsync).
+
+For testing development builds with built-in artificial latency we suggest using [Network Simulator tools with some custom code to inject artificial conditions into the build](#debug-builds).
+
+For testing release builds we suggest using [Clumsy](#clumsy-windows) if you're on Windows and Network Link Conditioner if you're on [macOS](#network-link-conditioner-mac-os) or [iOS](#network-link-conditioner-ios). A scriptable alternative to Network Link Conditioner on macOS is [dummynet](#dummynet-dnctl-and-pftcl-mac-os), which offers great control and comes packaged with the operating system.
+
+> [!NOTE]
+> While artificial latency is great for simulating network conditions during development - it won't accurately emulate real world conditions. We recommend to test your game often on the targeted platforms and real live networking conditions.
+
+## How much lag/packet loss/jitter should we use?
+
+It's not immediately obvious what the values and options we should enable in our network conditioning tools. All of them allow us to alter various aspects of network conditions such as latency, jitter and packet loss, though the names for concepts and the specific functionality varies between tools.
+
+Determining which network conditions to test with is about what your users will encounter while playing your game, which will vary by region and by platform.
+
+However, deciding what experience degradation is acceptable is dependent on game genre and on your game design decisions and other requirements. It's up to you to determine what's acceptable, there's no single rule for this.
+
+What latency value to use for general development?
+
+To test Boss Room, we used around 100ms-150ms for desktop platforms and around 200ms-300ms for mobile platforms and 5%-10% packet loss. These are just the values we used, the actual values you should test with will depend on your target platform and region.
+
+> [!NOTE]
+> It's valuable to test at 100ms, 200ms, 500ms, even 1000ms and potentially higher to ensure that race conditions don't occur in different latency ranges.
+
+Next we should determine how much chaos we want to introduce - that's largely based on the target platform and the typical network conditions that our users would experience:
+ - Is the game meant to be played from a good broadband internet connection?
+ - Is the game meant to run on mobile networks?
+
+This question tells us if our users are likely to experience more jitter and packet loss - mobile networks are notorious for having widely varying quality of connection. Mobile users also can experience frequent network changes during active application usage, and even though [Unity Transport has reconnection mechanism](https://github.com/Unity-Technologies/com.unity.multiplayer.rfcs/blob/rfc/device-reconnection/text/0000-device-reconnection.md), it still requires our application to factor in the possibility of an occasional lag burst.
+
+What's important here is that testing purely with added delay and no packet loss and jitter is unrealistic. These values shouldn't be high - the baseline scenario isn't what we would call stress-testing, but they should be non-zero.
+
+Adding jitter to the base delay value adds a layer of chaotic unreliability that would make our peers behave in a more natural way, allowing us to tweak our interpolation, buffering and other techniques to compensate for these instabilities.
+
+Adding packet loss, apart from introducing even more effective delay to our system can also wreak havoc on our unreliable messages, thus allowing us to explore if we need more defensive logic surrounding our unreliable messages or if we should opt for a reliable message instead.
+
+### Different network conditions for different peers
+
+[Clumsy](#clumsy-on-windows), [Network Link Conditioner](#network-link-conditioner-mac-os) and [dummynet](#dummynet-dnctl-and-pftcl-mac-os) are introducing changes on OS level, thus all the instances of the game that we open on our local machine would run under the same network conditions.
+
+Don't forget to disable it once you're done debugging, else your network connection will feel slow!
+
+QA teams run playtests with multiple people, each with their own system-wide conditioning settings. We can imitate this workflow locally by setting different per-peer network conditions. This approach isn't as reflective of reality as good QA tests on different machines, but it allows us to test these more peculiar scenarios locally.
+
+There is a group of scenarios where we would want to test how the game behaves when a player with a different baseline connection quality from most of our other peers joins the game - an example of such case can be someone playing from a significantly remote location or connecting from a device that's on a mobile network.
+
+In this case we would want to have an ability to set artificial conditions on a per-peer basis, which is possible with the [Network Simulator tool](https://docs-multiplayer.unity3d.com/tools/current/tools-network-simulator/).
+
+### Clone-based workflow (ParrelSync)
+
+> [!NOTE]
+> ParallelSync is **not** supported by Unity. More information on its usage is available [here](https://github.com/VeriorPies/ParrelSync). Troubleshooting information can be found [here](https://github.com/VeriorPies/ParrelSync/wiki/Troubleshooting-&-FAQs)
+
+
+Simulator Tools effects only apply to editor instances and to [debug builds](#debug-builds), as such it matches well with [clone-based workflow via ParrelSync](testing_locally.md#parrelsync).
+
+Other tools should be used when testing release builds locally.
+
+To combine the benefits of Simulator Tools Window with ParrelSync - create or open a clone of your project, open up the simulator tools window in both the main project and the clone and play with the settings to alter how network behaves for each individual peer. Remember to re-launch your game if you change the values in the tools window - the effects only take place when the Unity Transport driver is being created.
+
+> [!NOTE]
+> With Simulator Tools we can't specify if inbound packets and outbound packets would experience different conditions - artificial latency, jitter and packet loss are bi-directional. Simulator Tools window settings won't be committed to version control and need to be set up manually on different editor instances.
+
+### Debug Builds
+
+Debug builds do allow for the possibility of applying artificial network conditions to the Unity Transport driver, but the Simulator Tools window itself only sets these values in the Editor.
+
+To set the latency, jitter and packet-loss percentage values for develop builds we need the following code to execute before `NetworkManager` attempts to connect (changing the values of the parameters as desired):
+
+```
+#if DEVELOPMENT_BUILD && !UNITY_EDITOR
+ NetworkManager.Singleton.GetComponent().SetDebugSimulatorParameters(
+ packetDelay: 120,
+ packetJitter: 5,
+ dropRate: 3);
+#endif
+```
+
+## System-wide network conditioners
+
+These tools are useful when we want to test builds as opposed to running multiple editor instances. It's also an option that works for **release** builds.
+
+> [!NOTE]
+> The solutions described below share some common features:
+> - They don't support latency variability over time, so in effect we can't imitate artificial jitter with them.
+> - They're system-wide, thus all the local instances of our game would run under the same network conditions.
+> - They allow to control the settings for sending and receiving separately.
+
+There are some inherent limitations that come with the system-wide level of application of these tools - they're not ideal for local testing of more than two peers because we can't have peers with different network conditions between them (if that is important for the test of course).
+
+> [!NOTE]
+> Some consoles offer similar functionality at the native SDK level. Check their documentation for details.
+
+### Clumsy (Windows)
+
+> [!NOTE]
+> dummynet is another option that can be used on Windows, however there are known issues when running it on Windows 10 related to signed driver enforcement setting. As such we found Clumsy to be a good default option on Windows.
+
+Follow the installation instructions on the official [Clumsy Webpage](https://jagt.github.io/clumsy/).
+
+To test the builds with Clumsy:
+ - Run Clumsy
+ - Run instance 1
+ - Run instance 2
+ - At any point you can adjust Clumsy settings and observe the changes in gameplay fidelity
+
+#### Settings quickstart
+
+ - Lag - that's our primary lever to control artificial latency
+ - Drop - that's our packet loss
+ - Throttle, Out of Order, Duplicate, Tamper - these will manifest as additional latency but should be automatically handled for us by Netcode.
+ - Since Clumsy doesn't have Jitter functionality - we can emulate jitter (inconsistent latency over time) by playing with these parameters. Their cumulative effect would produce artificial latency fluctuations.
+
+For further reading please refer to the Details section of the [Clumsy Webpage](https://jagt.github.io/clumsy/) - the settings explanation there goes more into the actual mechanics of each individual setting.
+
+
+### Network Link Conditioner (macOS)
+
+Apple's Network Link Conditioner can be downloaded from the [Additional Tools for XCode page](https://developer.apple.com/download/all/?q=Additional%20Tools). This page requires logging in with Apple developer account.
+Download the version that's appropriate for your XCode version and then run the .dmg file. Navigate to the `Hardware` folder and install the Network Link Conditioner panel.
+
+After that you will be able to find Network Link Conditioner in the System Preferences panel of your Mac:
+
+
+To test the builds with Network Link Conditioner:
+ - Run Network Link Conditioner
+ - Run instance 1
+ - Run instance 2
+ - At any point you can adjust Network Link Conditioner settings and observe the changes in gameplay fidelity
+
+#### Settings quickstart
+
+In order to get to the settings we need to go into the `Manage Profiles` menu and either pick one or create our own.
+
+ - Downlink and Uplink Bandwidth are useful for testing how our game would behave if it's starved for bandwidth, but generally tightening it too much would gradually degrade any networked game.
+ - Downlink and Uplink Packets Dropped % is exactly what it seems - packet loss percentage.
+ - Downlink and Uplink Delay are our levers for controlling artificial latency
+
+### Network Link Conditioner (iOS)
+
+Apple's iOS also has it's version of Network Link Conditioner.
+
+Your iOS device needs to be enabled for development, then you'd be able to find Network Link Conditioner in Settings > Developer > Network Link Conditioner.
+
+### dummynet, dnctl and pftcl (macOS)
+
+**[dummynet](https://manpagez.com/man/8/dnctl/)** is a traffic shaper, delay and bandwidth manager utility that comes standard with the macOS.
+
+ - **dnctl** is the command-line interface to operate the `dummynet` utiity.
+ - **pfctl** is the control interface for the internal firewall, which we can make obey dummynet rules, thus creating artificial network conditions on our host.
+
+To enable artificial conditions we need to create a `pf.conf` file in our user home directory with the following contents:
+```
+#Testing udp, such as most realtime games and audio-video calls
+dummynet in proto udp from any to any pipe 1
+dummynet out proto udp from any to any pipe 1
+```
+
+Then we need to run the following commands in the console:
+```
+sudo dnctl pipe 1 config delay 40 plr 0.1
+sudo dnctl show
+
+sudo pfctl -e
+sudo pfctl -f pf.conf
+```
+
+> [!NOTE]
+> This set of commands enables dummynet, but when we are done testing - we should disable it, otherwise our system would continue to experience these artificial network conditions!
+
+To disable dummynet execute the following:
+
+```
+sudo dnctl -q flush
+sudo dnctl show
+
+sudo pfctl -e
+sudo pfctl -f /etc/pf.conf
+```
+
+After you start dummynet, testing the builds is as easy as launching several instances of your game.
+
+#### Settings quickstart
+ - `bw` - this parameter controls bandwidth.
+ - `dnctl pipe 1 config bw 40Kbit/s` will set our bandwidth to 40 Kbit per second.
+ - `delay` - this parameter is our artificial latency.
+ - `dnctl pipe 1 config delay 100` will set our artificial latecny to 100 ms.
+ - `plr` - this parameter is our packet loss percentage.
+ - `dnctl pipe 1 config plr 0.1` will set our packet loss percetage to 10%
+
+You can chain these parameters to achieve a combination of these settings that will apply all of them at once:
+`dnctl pipe 1 config bw 40Kbit/s delay 100 plr 0.1`
diff --git a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs
index 1fb7eaed6f..96f0223ef3 100644
--- a/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs
@@ -1157,8 +1157,7 @@ internal void OnClientDisconnectFromServer(ulong clientId)
if (ownedObject)
{
// If destroying with owner, then always despawn and destroy (or defer destroying to prefab handler)
- // Handle an object with no observers other than the current disconnecting client as destroying with owner
- if (!ownedObject.DontDestroyWithOwner && (ownedObject.Observers.Count == 0 || (ownedObject.Observers.Count == 1 && ownedObject.Observers.Contains(clientId))))
+ if (!ownedObject.DontDestroyWithOwner)
{
if (ownedObject.IsSpawned)
{
@@ -1219,7 +1218,7 @@ internal void OnClientDisconnectFromServer(ulong clientId)
}
// Skip destroy with owner objects as they will be processed by the outer loop
- if (!childObject.DontDestroyWithOwner && (childObject.Observers.Count == 0 || (childObject.Observers.Count == 1 && childObject.Observers.Contains(clientId))))
+ if (!childObject.DontDestroyWithOwner)
{
continue;
}
diff --git a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
index c8cb98637b..cff2768405 100644
--- a/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs
@@ -1467,6 +1467,20 @@ private void HostServerInitialize()
ConnectionManager.InvokeOnClientConnectedCallback(LocalClientId);
}
+ ///
+ /// Get the TransportId from the associated ClientId.
+ ///
+ /// The ClientId to get the TransportId from
+ /// The TransportId associated with the given ClientId
+ public ulong GetTransportIdFromClientId(ulong clientId) => ConnectionManager.ClientIdToTransportId(clientId);
+
+ ///
+ /// Get the ClientId from the associated TransportId.
+ ///
+ /// The TransportId to get the ClientId from
+ /// The ClientId from the associated TransportId
+ public ulong GetClientIdFromTransportId(ulong transportId) => ConnectionManager.TransportIdToClientId(transportId);
+
///
/// Disconnects the remote client.
///
diff --git a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariablePermission.cs b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariablePermission.cs
index a0679715ce..1ea52239dc 100644
--- a/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariablePermission.cs
+++ b/com.unity.netcode.gameobjects/Runtime/NetworkVariable/NetworkVariablePermission.cs
@@ -3,6 +3,10 @@ namespace Unity.Netcode
///
/// The permission types for reading a var
///
+ ///
+ /// Only relevant when using the client/server network topology.
+ /// In distributed authority mode everyone can always read.
+ ///
public enum NetworkVariableReadPermission
{
///
diff --git a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
index 966326767a..3d8add579b 100644
--- a/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
+++ b/com.unity.netcode.gameobjects/Runtime/Spawning/NetworkSpawnManager.cs
@@ -1431,59 +1431,52 @@ internal void ServerDestroySpawnedSceneObjects()
internal void DespawnAndDestroyNetworkObjects()
{
-#if UNITY_2023_1_OR_NEWER
- var networkObjects = UnityEngine.Object.FindObjectsByType(FindObjectsSortMode.InstanceID);
-#else
- var networkObjects = UnityEngine.Object.FindObjectsOfType();
-#endif
-
- for (int i = 0; i < networkObjects.Length; i++)
+ var networkObjects = UnityEngine.Object.FindObjectsByType(FindObjectsSortMode.InstanceID).Where((c) => c.NetworkManager == NetworkManager);
+ for (int i = 0; i < networkObjects.Count(); i++)
{
- if (networkObjects[i].NetworkManager == NetworkManager)
+ var networkObject = networkObjects.ElementAt(i);
+ if (NetworkManager.PrefabHandler.ContainsHandler(networkObject))
{
- if (NetworkManager.PrefabHandler.ContainsHandler(networkObjects[i]))
- {
- OnDespawnObject(networkObjects[i], false);
- // Leave destruction up to the handler
- NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObjects[i]);
- }
- else
- {
- // If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
- // is unloaded. Otherwise, despawn and destroy it.
- var shouldDestroy = !(networkObjects[i].IsSceneObject == null || (networkObjects[i].IsSceneObject != null && networkObjects[i].IsSceneObject.Value));
+ OnDespawnObject(networkObject, false);
+ // Leave destruction up to the handler
+ NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObject);
+ }
+ else
+ {
+ // If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
+ // is unloaded. Otherwise, despawn and destroy it.
+ var shouldDestroy = !(networkObject.IsSceneObject == null || (networkObject.IsSceneObject != null && networkObject.IsSceneObject.Value));
- // If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
- if (shouldDestroy)
+ // If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
+ if (shouldDestroy)
+ {
+ // Check to see if there are any in-scene placed children that are marked to be destroyed with the scene
+ var childrenObjects = networkObject.GetComponentsInChildren();
+ foreach (var childObject in childrenObjects)
{
- // Check to see if there are any in-scene placed children that are marked to be destroyed with the scene
- var childrenObjects = networkObjects[i].GetComponentsInChildren();
- foreach (var childObject in childrenObjects)
+ if (childObject == networkObject)
{
- if (childObject == networkObjects[i])
- {
- continue;
- }
+ continue;
+ }
- // If the child is an in-scene placed NetworkObject then remove the child from the parent (which was dynamically spawned)
- // and set its parent to root
- if (childObject.IsSceneObject != null && childObject.IsSceneObject.Value)
- {
- childObject.TryRemoveParent(childObject.WorldPositionStays());
- }
+ // If the child is an in-scene placed NetworkObject then remove the child from the parent (which was dynamically spawned)
+ // and set its parent to root
+ if (childObject.IsSceneObject != null && childObject.IsSceneObject.Value)
+ {
+ childObject.TryRemoveParent(childObject.WorldPositionStays());
}
}
+ }
- // If spawned, then despawn and potentially destroy.
- if (networkObjects[i].IsSpawned)
- {
- OnDespawnObject(networkObjects[i], shouldDestroy);
- }
- else // Otherwise, if we are not spawned and we should destroy...then destroy.
- if (shouldDestroy)
- {
- UnityEngine.Object.Destroy(networkObjects[i].gameObject);
- }
+ // If spawned, then despawn and potentially destroy.
+ if (networkObject.IsSpawned)
+ {
+ OnDespawnObject(networkObject, shouldDestroy);
+ }
+ else // Otherwise, if we are not spawned and we should destroy...then destroy.
+ if (shouldDestroy)
+ {
+ UnityEngine.Object.Destroy(networkObject.gameObject);
}
}
}
@@ -1588,7 +1581,10 @@ internal void OnDespawnNonAuthorityObject([NotNull] NetworkObject networkObject,
destroyGameObject = true;
}
- OnDespawnObject(networkObject, destroyGameObject);
+ // When despawning from within the OnDespawnNonAuthorityObject method, we need to always set the authorityOverride to true
+ // since this is only ever invoked internally when the authority has notified a non-authority client that it should despawn
+ // and optionally destroy the NetworkObject (both invocations are based off of processing a DestroyObjectMessage).
+ OnDespawnObject(networkObject, destroyGameObject, true);
}
///
@@ -1622,9 +1618,21 @@ internal void OnDespawnObject(NetworkObject networkObject, bool destroyGameObjec
}
var distributedAuthority = NetworkManager.DistributedAuthorityMode;
- var hasDAAuthority = distributedAuthority && (networkObject.HasAuthority || (NetworkManager.DAHost && authorityOverride));
+
+ // Determine if this is a DA authority instance
+ var hasDAAuthority = distributedAuthority && (networkObject.HasAuthority || NetworkManager.DAHost);
+ // Determine if this is a CS authority instance
var hasClientServerAuthority = !distributedAuthority && NetworkManager.IsServer;
- var hasAuthority = hasDAAuthority || hasClientServerAuthority;
+
+ // We have authority if either of the above authority types are true =or= this is
+ // an authority driven despawn action being carried out by a non-authority instance.
+ var hasAuthority = hasDAAuthority || hasClientServerAuthority || authorityOverride;
+
+ // TODO-Fix: NetworkLog.CurrentLogLevel needs to either point to the correct NetworkManager instance
+ // for testing purposes =or= we need to remove all internal uses of NetworkLog.CurrentLogLevel and
+ // replace it with something like the below to assure that when running an integration test we are
+ // able to dynamically change the log level of any active NetworkManager instance and it will be honored.
+ var logLevel = NetworkManager.LogLevel;
// If we are shutting down the NetworkManager, then ignore resetting the parent
// and only attempt to remove the child's parent on the server-side
@@ -1641,6 +1649,7 @@ internal void OnDespawnObject(NetworkObject networkObject, bool destroyGameObjec
// Move child NetworkObjects to the root when parent NetworkObject is destroyed
foreach (var spawnedNetObj in objectsToRemoveParent)
{
+ // Ignore the object being despawned
if (spawnedNetObj == networkObject)
{
continue;
@@ -1652,9 +1661,10 @@ internal void OnDespawnObject(NetworkObject networkObject, bool destroyGameObjec
{
continue;
}
+
// For mixed authority hierarchies, if the parent is despawned then any removal of children
// is considered "authority approved". Set the AuthorityAppliedParenting flag.
- spawnedNetObj.AuthorityAppliedParenting = authorityOverride;
+ spawnedNetObj.AuthorityAppliedParenting = distributedAuthority && !networkObject.HasAuthority;
// Try to remove the parent using the cached WorldPositionStays value
// Note: WorldPositionStays will still default to true if this was an
@@ -1662,22 +1672,24 @@ internal void OnDespawnObject(NetworkObject networkObject, bool destroyGameObjec
// scene via the editor.
if (!spawnedNetObj.TryRemoveParentCachedWorldPositionStays())
{
- if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+ if (logLevel <= LogLevel.Normal)
{
- NetworkLog.LogError($"{nameof(NetworkObject)} #{spawnedNetObj.NetworkObjectId} could not be moved to the root when its parent {nameof(NetworkObject)} #{networkObject.NetworkObjectId} was being destroyed");
+ NetworkLog.LogError($"{spawnedNetObj.name} ({nameof(NetworkObject)}-{spawnedNetObj.NetworkObjectId}) could not be moved to the root when its parent, {networkObject.name} ({nameof(NetworkObject)}-{networkObject.NetworkObjectId}), was being destroyed");
}
}
else
- if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+ if (logLevel <= LogLevel.Developer)
{
- NetworkLog.LogWarning($"{nameof(NetworkObject)} #{spawnedNetObj.NetworkObjectId} moved to the root because its parent {nameof(NetworkObject)} #{networkObject.NetworkObjectId} is destroyed");
+ NetworkLog.LogWarning($"{spawnedNetObj.name} ({nameof(NetworkObject)}-{spawnedNetObj.NetworkObjectId}) moved to the root because its parent, {networkObject.name} ({nameof(NetworkObject)}-{networkObject.NetworkObjectId}), is destroyed");
}
}
}
networkObject.InvokeBehaviourNetworkDespawn();
- if (!NetworkManager.ShutdownInProgress && hasAuthority)
+ // Don't send messages if shutting down
+ // Otherwise send messages if we are the authority (either the server, or the DA mode authority of this object).
+ if (!NetworkManager.ShutdownInProgress && (hasDAAuthority || hasClientServerAuthority))
{
if (NetworkManager.NetworkConfig.RecycleNetworkIds)
{
@@ -1692,7 +1704,6 @@ internal void OnDespawnObject(NetworkObject networkObject, bool destroyGameObjec
/*
* Configure message targets
*/
-
// If we are using distributed authority and are not the DAHost, send a message to the Server (CMBService or DAHost)
if (hasDAAuthority && !NetworkManager.DAHost)
{
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/NetworkObjectDontDestroyWithOwnerTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/NetworkObjectDontDestroyWithOwnerTests.cs
index 9466148d38..286d4ffc8a 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/NetworkObjectDontDestroyWithOwnerTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/NetworkObject/NetworkObjectDontDestroyWithOwnerTests.cs
@@ -1,5 +1,7 @@
using System.Collections;
+using System.Collections.Generic;
using System.Linq;
+using System.Text;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
@@ -13,24 +15,33 @@ namespace Unity.Netcode.RuntimeTests
[TestFixture(HostOrServer.Server)]
internal class NetworkObjectDontDestroyWithOwnerTests : NetcodeIntegrationTest
{
- private const int k_NumberObjectsToSpawn = 32;
- protected override int NumberOfClients => 1;
+ private const int k_NumberObjectsToSpawn = 16;
+ protected override int NumberOfClients => 3;
- // TODO: [CmbServiceTests] Adapt to run with the service
- protected override bool UseCMBService()
+ public enum ParentedPass
{
- return false;
+ NoParent,
+ HasParent
}
- protected GameObject m_PrefabToSpawn;
+ protected GameObject m_DestroyWithOwnerPrefab;
+ protected GameObject m_DontDestroyWithOwnerPrefab;
protected GameObject m_PrefabNoObserversSpawn;
+ private ulong m_NonAuthorityClientId;
+
+ private List m_DontDestroyObjectIds = new List();
+ private List m_DestroyObjectIds = new List();
+
public NetworkObjectDontDestroyWithOwnerTests(HostOrServer hostOrServer) : base(hostOrServer) { }
protected override void OnServerAndClientsCreated()
{
- m_PrefabToSpawn = CreateNetworkObjectPrefab("ClientOwnedObject");
- m_PrefabToSpawn.GetComponent().DontDestroyWithOwner = true;
+ m_DontDestroyWithOwnerPrefab = CreateNetworkObjectPrefab("DontDestroyWith");
+ m_DontDestroyWithOwnerPrefab.GetComponent().DontDestroyWithOwner = true;
+ m_DontDestroyWithOwnerPrefab.GetComponent().SetOwnershipStatus(NetworkObject.OwnershipStatus.Transferable);
+
+ m_DestroyWithOwnerPrefab = CreateNetworkObjectPrefab("DestroyWith");
m_PrefabNoObserversSpawn = CreateNetworkObjectPrefab("NoObserversObject");
var prefabNoObserversNetworkObject = m_PrefabNoObserversSpawn.GetComponent();
@@ -38,46 +49,230 @@ protected override void OnServerAndClientsCreated()
prefabNoObserversNetworkObject.DontDestroyWithOwner = true;
}
- [UnityTest]
- public IEnumerator DontDestroyWithOwnerTest()
+ ///
+ /// Validates all instances of both prefab types have spawned on all clients.
+ ///
+ private bool HaveAllObjectInstancesSpawned(StringBuilder errorLog)
+ {
+ foreach (var networkManager in m_NetworkManagers)
+ {
+ var relativeSpawnedObjects = networkManager.SpawnManager.SpawnedObjects;
+ for (int i = 0; i < k_NumberObjectsToSpawn; i++)
+ {
+ var dontDestroyObjectId = m_DontDestroyObjectIds[i];
+ var destroyObjectId = m_DestroyObjectIds[i];
+ if (!relativeSpawnedObjects.ContainsKey(dontDestroyObjectId))
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][DontDestroyWithOwner] Has not spawned {nameof(NetworkObject)}-{dontDestroyObjectId}!");
+ }
+ if (!relativeSpawnedObjects.ContainsKey(destroyObjectId))
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][DestroyWithOwner] Has not spawned {nameof(NetworkObject)}-{destroyObjectId}!");
+ }
+ }
+ }
+ return errorLog.Length == 0;
+ }
+
+ ///
+ /// Helper method to spawn the two different sets of objects.
+ /// Those that will destroy with the owner and those that will not.
+ ///
+ /// type of prefab to use for spawning
+ private void SpawnAllObjects(bool dontDestroyWithOwner)
+ {
+ var networkObjectIds = new List();
+ var nonAuthority = m_NetworkManagers.Where((c) => c.LocalClientId == m_NonAuthorityClientId).First();
+ var objectToSpawn = dontDestroyWithOwner ? m_DontDestroyWithOwnerPrefab : m_DestroyWithOwnerPrefab;
+ var spawnedObjects = SpawnObjects(objectToSpawn, nonAuthority, k_NumberObjectsToSpawn);
+ foreach (var spawnedObject in spawnedObjects)
+ {
+ networkObjectIds.Add(spawnedObject.GetComponent().NetworkObjectId);
+ }
+
+ if (dontDestroyWithOwner)
+ {
+ m_DontDestroyObjectIds.Clear();
+ m_DontDestroyObjectIds.AddRange(networkObjectIds);
+ }
+ else
+ {
+ m_DestroyObjectIds.Clear();
+ m_DestroyObjectIds.AddRange(networkObjectIds);
+ }
+ }
+
+ ///
+ /// Validates that the dont destroy with owner object is parented under
+ /// the destroy with owner object.
+ ///
+ private bool HaveAllObjectInstancesParented(StringBuilder errorLog)
+ {
+ foreach (var networkManager in m_NetworkManagers)
+ {
+ var relativeSpawnedObjects = networkManager.SpawnManager.SpawnedObjects;
+ for (int i = 0; i < k_NumberObjectsToSpawn; i++)
+ {
+ var dontDestroyObjectId = m_DontDestroyObjectIds[i];
+ var destroyObjectId = m_DestroyObjectIds[i];
+ var dontDestroyObject = (NetworkObject)null;
+ var destroyObject = (NetworkObject)null;
+ if (!relativeSpawnedObjects.ContainsKey(dontDestroyObjectId))
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][DontDestroyWithOwner] Has not spawned {nameof(NetworkObject)}-{dontDestroyObjectId}!");
+ }
+ else
+ {
+ dontDestroyObject = relativeSpawnedObjects[dontDestroyObjectId];
+ }
+ if (!relativeSpawnedObjects.ContainsKey(destroyObjectId))
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][DestroyWithOwner] Has not spawned {nameof(NetworkObject)}-{destroyObjectId}!");
+ }
+ else
+ {
+ destroyObject = relativeSpawnedObjects[destroyObjectId];
+ }
+
+ if (dontDestroyObject != null && destroyObject != null && dontDestroyObject.transform.parent != destroyObject.transform)
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][Not Parented] {destroyObject.name} is not parented under {dontDestroyObject.name}!");
+ }
+ }
+ }
+ return errorLog.Length == 0;
+ }
+
+ ///
+ /// Parents the dont destroy with owner objects under the destroy with owner objects for the parenting portion of the test.
+ ///
+ private void ParentObjects()
+ {
+ var networkManager = !m_DistributedAuthority ? GetAuthorityNetworkManager() : m_NetworkManagers.Where((c) => c.LocalClientId == m_NonAuthorityClientId).First();
+ for (int i = 0; i < k_NumberObjectsToSpawn; i++)
+ {
+ var dontDestroyObjectId = m_DontDestroyObjectIds[i];
+ var destroyObjectId = m_DestroyObjectIds[i];
+ var dontDestroyObject = networkManager.SpawnManager.SpawnedObjects[dontDestroyObjectId];
+ var destroyObject = networkManager.SpawnManager.SpawnedObjects[destroyObjectId];
+ Assert.IsTrue(dontDestroyObject.TrySetParent(destroyObject), $"[Client-{networkManager.LocalClientId}][Parent Failure] Could not parent {destroyObject.name} under {dontDestroyObject.name}!");
+ }
+ }
+
+ ///
+ /// Validates that the non-authority owner client disconnection
+ /// was registered on all clients.
+ ///
+ private bool NonAuthorityHasDisconnected(StringBuilder errorLog)
{
- var client = m_ClientNetworkManagers[0];
- var clientId = client.LocalClientId;
- var networkObjects = SpawnObjects(m_PrefabToSpawn, m_ClientNetworkManagers[0], k_NumberObjectsToSpawn);
+ foreach (var networkManager in m_NetworkManagers)
+ {
+ if (!networkManager.IsListening)
+ {
+ continue;
+ }
- // wait for object spawn on client to reach k_NumberObjectsToSpawn + 1 (k_NumberObjectsToSpawn and 1 for the player)
- yield return WaitForConditionOrTimeOut(() => client.SpawnManager.GetClientOwnedObjects(clientId).Count() == k_NumberObjectsToSpawn + 1);
- Assert.False(s_GlobalTimeoutHelper.TimedOut, $"Timed out waiting for client to have 33 NetworkObjects spawned! Only {client.SpawnManager.GetClientOwnedObjects(clientId).Count()} were assigned!");
+ if (networkManager.ConnectedClientsIds.Contains(m_NonAuthorityClientId))
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][ClientDisconnect] Still thinks Client-{m_NonAuthorityClientId} is connected!");
+ }
+ }
+ return errorLog.Length == 0;
+ }
- // Since clients spawn their objects locally in distributed authority mode, we have to rebuild the list of the client
- // owned objects on the (DAHost) server-side because when the client disconnects it will destroy its local instances.
- if (m_DistributedAuthority)
+ ///
+ /// The primary validation for the .
+ /// This validates that:
+ /// - Spawned objects that are set to destroy with the owner gets destroyed/despawned when the owning client disconnects.
+ /// - Spawned objects that are set to not destroy with the owner are not destroyed/despawned when the owning client disconnects.
+ ///
+ private bool ValidateDontDestroyWithOwner(StringBuilder errorLog)
+ {
+ foreach (var networkManager in m_NetworkManagers)
{
- networkObjects.Clear();
- var serversideClientOwnedObjects = m_ServerNetworkManager.SpawnManager.GetClientOwnedObjects(clientId);
+ var relativeSpawnedObjects = networkManager.SpawnManager.SpawnedObjects;
+ for (int i = 0; i < k_NumberObjectsToSpawn; i++)
+ {
+ var dontDestroyObjectId = m_DontDestroyObjectIds[i];
+ var destroyObjectId = m_DestroyObjectIds[i];
+ if (!relativeSpawnedObjects.ContainsKey(dontDestroyObjectId))
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][DontDestroyWithOwner][!Despawned!] {nameof(NetworkObject)}-{dontDestroyObjectId} should not despawn upon the owner disconnecting!");
+ }
+ if (relativeSpawnedObjects.ContainsKey(destroyObjectId))
+ {
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][DestroyWithOwner][!Not Despawned!] {nameof(NetworkObject)}-{destroyObjectId} should have despawned upon the owner disconnecting!");
+ }
+ }
+ }
+ return errorLog.Length == 0;
+ }
- foreach (var networkObject in serversideClientOwnedObjects)
+ ///
+ /// The primary parented validation for the .
+ /// This validates that:
+ /// - Spawned objects that are set to destroy with the owner gets destroyed/despawned when the owning client disconnects.
+ /// - Spawned objects that are set to not destroy with the owner and parented under a spawned object set to destroy with owner that
+ /// the objects that are set to not destroy with the owner are not destroyed/despawned when the owning client disconnects.
+ ///
+ private bool ValidateParentedDontDestroyWithOwnerId(StringBuilder errorLog)
+ {
+ foreach (var networkManager in m_NetworkManagers)
+ {
+ var relativeSpawnedObjects = networkManager.SpawnManager.SpawnedObjects;
+ for (int i = 0; i < k_NumberObjectsToSpawn; i++)
{
- if (!networkObject.IsPlayerObject)
+ var dontDestroyObjectId = m_DontDestroyObjectIds[i];
+ var dontDestroyObjectOwnerId = relativeSpawnedObjects[dontDestroyObjectId].OwnerClientId;
+
+ if (dontDestroyObjectOwnerId == m_NonAuthorityClientId)
{
- networkObjects.Add(networkObject.gameObject);
+ errorLog.AppendLine($"[Client-{networkManager.LocalClientId}][DontDestroyWithOwner][!Owner!] {nameof(NetworkObject)}-{dontDestroyObjectId} should not still belong to Client-{m_NonAuthorityClientId}!");
}
}
}
+ return errorLog.Length == 0;
+ }
- // disconnect the client that owns all the clients
- NetcodeIntegrationTestHelpers.StopOneClient(client);
+ ///
+ /// This validates that:
+ /// - Spawned objects that are set to destroy with the owner gets destroyed/despawned when the owning client disconnects.
+ /// - Spawned objects that are set to not destroy with the owner are not destroyed/despawned when the owning client disconnects.
+ ///
+ [UnityTest]
+ public IEnumerator DontDestroyWithOwnerTest([Values] ParentedPass parentedPass)
+ {
+ var authority = GetAuthorityNetworkManager();
+ var nonAuthority = GetNonAuthorityNetworkManager();
+ m_NonAuthorityClientId = nonAuthority.LocalClientId;
+ SpawnAllObjects(true);
+ SpawnAllObjects(false);
+
+ // This should never fail.
+ Assert.IsTrue(m_DontDestroyObjectIds.Count == m_DestroyObjectIds.Count, $"Mismatch in spawn count! ({m_DontDestroyObjectIds.Count}) vs ({m_DestroyObjectIds.Count})");
- var remainingClients = Mathf.Max(0, TotalClients - 1);
- // wait for disconnect
- yield return WaitForConditionOrTimeOut(() => m_ServerNetworkManager.ConnectedClients.Count == remainingClients);
- Assert.False(s_GlobalTimeoutHelper.TimedOut, "Timed out waiting for client to disconnect!");
+ yield return WaitForConditionOrTimeOut(HaveAllObjectInstancesSpawned);
+ AssertOnTimeout($"Timed out waiting for all clients to spawn objects!");
- for (int i = 0; i < networkObjects.Count; i++)
+ if (parentedPass == ParentedPass.HasParent)
{
- var networkObject = networkObjects[i].GetComponent();
- // ensure ownership was transferred back
- Assert.That(networkObject.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+ ParentObjects();
+ yield return WaitForConditionOrTimeOut(HaveAllObjectInstancesParented);
+ AssertOnTimeout($"Timed out waiting for all DontDestroy objects to be parented under the Destroy objects!");
+ }
+
+ yield return StopOneClient(nonAuthority);
+
+ yield return WaitForConditionOrTimeOut(NonAuthorityHasDisconnected);
+ AssertOnTimeout($"Timed out waiting for all clients to register that Client-{m_NonAuthorityClientId} has disconnected!");
+
+ yield return WaitForConditionOrTimeOut(ValidateDontDestroyWithOwner);
+ AssertOnTimeout($"Timed out while validating the base-line DontDestroyWithOwnerTest results!");
+
+ if (parentedPass == ParentedPass.HasParent)
+ {
+ yield return WaitForConditionOrTimeOut(ValidateParentedDontDestroyWithOwnerId);
+ AssertOnTimeout($"Timed out while validating the parented don't destroy objects do not still belong to disconnected Client-{m_NonAuthorityClientId}!");
}
}
@@ -87,22 +282,55 @@ public IEnumerator NetworkShowThenClientDisconnects()
var authorityManager = GetAuthorityNetworkManager();
var networkObject = SpawnObject(m_PrefabNoObserversSpawn, authorityManager).GetComponent();
var longWait = new WaitForSeconds(0.25f);
+ // Wait long enough to assure that no client receives the spawn notification
yield return longWait;
+
+ foreach (var networkManager in m_NetworkManagers)
+ {
+ // Skip the authority as it will have an instance
+ if (networkManager == authorityManager)
+ {
+ continue;
+ }
+ Assert.False(networkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObject.NetworkObjectId), $"[Client-{networkManager.LocalClientId}]" +
+ $" Spawned an instance of {networkObject.name} when it was spawned with no observers!");
+ }
+
+ // Get a non-authority client, show the spawned object to it, and then make that client the owner.
var nonAuthorityManager = GetNonAuthorityNetworkManager();
- Assert.False(nonAuthorityManager.SpawnManager.SpawnedObjects.ContainsKey(networkObject.NetworkObjectId), $"[Client-{nonAuthorityManager.LocalClientId}] " +
- $"Already has an instance of {networkObject.name} when it should not!");
networkObject.NetworkShow(nonAuthorityManager.LocalClientId);
+ // This validates that the change in ownership is not sent when making a NetworkObject visible and changing the ownership
+ // within the same frame/callstack.
networkObject.ChangeOwnership(nonAuthorityManager.LocalClientId);
+ // Verifies the object was spawned on the non-authority client and that the non-authority client is the owner.
yield return WaitForConditionOrTimeOut(() => nonAuthorityManager.SpawnManager.SpawnedObjects.ContainsKey(networkObject.NetworkObjectId)
&& nonAuthorityManager.SpawnManager.SpawnedObjects[networkObject.NetworkObjectId].OwnerClientId == nonAuthorityManager.LocalClientId);
AssertOnTimeout($"[Client-{nonAuthorityManager.LocalClientId}] Failed to spawn {networkObject.name} when it was shown!");
+ foreach (var networkManager in m_NetworkManagers)
+ {
+ // Skip the authority and the non-authority client as they should now both have instances
+ if (networkManager == authorityManager || networkManager == nonAuthorityManager)
+ {
+ continue;
+ }
+
+ // No other client should have an instance
+ Assert.False(networkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObject.NetworkObjectId), $"[Client-{networkManager.LocalClientId}]" +
+ $" Spawned an instance of {networkObject.name} when it was shown to Client-{nonAuthorityManager.LocalClientId}!");
+ }
+
+ // Wait a few frames
yield return s_DefaultWaitForTick;
+ // Shutdown the non-authority client to assure this does not cause the spawned object to despawn
nonAuthorityManager.Shutdown();
+ // Wait long enough to assure all messages generated from the client shutting down have been processed
yield return longWait;
+
+ // Validate the object is still spawned
Assert.True(networkObject.IsSpawned, $"The spawned test prefab was despawned on the authority side when it shouldn't have been!");
}
}
diff --git a/com.unity.netcode.gameobjects/Tests/Runtime/NetworkShowHideTests.cs b/com.unity.netcode.gameobjects/Tests/Runtime/NetworkShowHideTests.cs
index f0e01a842c..074429b44d 100644
--- a/com.unity.netcode.gameobjects/Tests/Runtime/NetworkShowHideTests.cs
+++ b/com.unity.netcode.gameobjects/Tests/Runtime/NetworkShowHideTests.cs
@@ -113,9 +113,27 @@ public void SomeRandomClientRPC()
ClientIdsRpcCalledOn?.Add(NetworkManager.LocalClientId);
}
+ [Rpc(SendTo.Everyone)]
+ public void DistributedAuthorityRPC()
+ {
+ if (!Silent)
+ {
+ Debug.Log($"RPC called {NetworkManager.LocalClientId}");
+ }
+ ClientIdsRpcCalledOn?.Add(NetworkManager.LocalClientId);
+ }
+
public void TriggerRpc()
{
- SomeRandomClientRPC();
+ Debug.Log("triggering RPC");
+ if (NetworkManager.CMBServiceConnection)
+ {
+ DistributedAuthorityRPC();
+ }
+ else
+ {
+ SomeRandomClientRPC();
+ }
}
}
@@ -125,12 +143,6 @@ internal class NetworkShowHideTests : NetcodeIntegrationTest
{
protected override int NumberOfClients => 4;
- // TODO: [CmbServiceTests] https://jira.unity3d.com/browse/MTTB-1392
- protected override bool UseCMBService()
- {
- return false;
- }
-
private ulong m_ClientId0;
private GameObject m_PrefabToSpawn;
private GameObject m_PrefabSpawnWithoutObservers;
@@ -580,11 +592,15 @@ public IEnumerator NetworkHideChangeOwnershipNotHidden()
var firstClient = GetNonAuthorityNetworkManager(0);
var secondClient = GetNonAuthorityNetworkManager(1);
+ ShowHideObject.ValueAfterOwnershipChange = -1;
ShowHideObject.ClientTargetedNetworkObjects.Clear();
ShowHideObject.ObjectsPerClientId.Clear();
ShowHideObject.ClientIdToTarget = secondClient.LocalClientId;
ShowHideObject.Silent = true;
+ // only check for value change on one specific client
+ ShowHideObject.NetworkManagerOfInterest = firstClient;
+
var spawnedObject1 = SpawnObject(m_PrefabToSpawn, authority);
m_NetSpawnedObject1 = spawnedObject1.GetComponent();
@@ -597,12 +613,20 @@ public IEnumerator NetworkHideChangeOwnershipNotHidden()
// wait for three ticks
yield return WaitForTicks(authority, 3);
+ if (!m_DistributedAuthority)
+ {
+ // Client/Server ClientIdToTarget should not see any value change
+ Assert.That(ShowHideObject.ValueAfterOwnershipChange, Is.EqualTo(-1));
+ }
+ else
+ {
+ // Distributed Authority mode everyone can always read so the value change should already have happened
+ Assert.That(ShowHideObject.ValueAfterOwnershipChange, Is.EqualTo(1));
+ }
+
// check we'll actually be changing owners
Assert.False(ShowHideObject.ClientTargetedNetworkObjects[0].OwnerClientId == firstClient.LocalClientId);
- // only check for value change on one specific client
- ShowHideObject.NetworkManagerOfInterest = firstClient;
-
// change ownership
m_NetSpawnedObject1.ChangeOwnership(firstClient.LocalClientId);
@@ -731,10 +755,8 @@ public IEnumerator NetworkShowHideAroundListModify()
m_NetSpawnedObject1 = spawnedObject1.GetComponent();
// wait for host to have spawned and gained ownership
- while (ShowHideObject.GainOwnershipCount == 0)
- {
- yield return new WaitForSeconds(0.0f);
- }
+ yield return WaitForConditionOrTimeOut(() => m_NetSpawnedObject1.IsSpawned && m_NetSpawnedObject1.OwnerClientId == authority.LocalClientId);
+ AssertOnTimeout($"Timed out waiting for {m_NetSpawnedObject1.name} to spawn");
for (int i = 0; i < 4; i++)
{
@@ -767,8 +789,8 @@ public IEnumerator NetworkShowHideAroundListModify()
}
- Compare(ShowHideObject.ObjectsPerClientId[0].MyList, ShowHideObject.ObjectsPerClientId[1].MyList);
- Compare(ShowHideObject.ObjectsPerClientId[0].MyList, ShowHideObject.ObjectsPerClientId[2].MyList);
+ Compare(ShowHideObject.ObjectsPerClientId[authority.LocalClientId].MyList, ShowHideObject.ObjectsPerClientId[firstClient.LocalClientId].MyList);
+ Compare(ShowHideObject.ObjectsPerClientId[authority.LocalClientId].MyList, ShowHideObject.ObjectsPerClientId[secondClient.LocalClientId].MyList);
}
}
diff --git a/com.unity.netcode.gameobjects/package.json b/com.unity.netcode.gameobjects/package.json
index e29f475fc6..70eeba81b1 100644
--- a/com.unity.netcode.gameobjects/package.json
+++ b/com.unity.netcode.gameobjects/package.json
@@ -2,7 +2,7 @@
"name": "com.unity.netcode.gameobjects",
"displayName": "Netcode for GameObjects",
"description": "Netcode for GameObjects is a high-level netcode SDK that provides networking capabilities to GameObject/MonoBehaviour workflows within Unity and sits on top of underlying transport layer.",
- "version": "2.4.2",
+ "version": "2.4.3",
"unity": "6000.0",
"dependencies": {
"com.unity.nuget.mono-cecil": "1.11.4",
diff --git a/testproject/Assets/Samples/Physics/PhysicsSample.unity b/testproject/Assets/Samples/Physics/PhysicsSample.unity
index be9ffc7bec..02e23aaa77 100644
--- a/testproject/Assets/Samples/Physics/PhysicsSample.unity
+++ b/testproject/Assets/Samples/Physics/PhysicsSample.unity
@@ -13,7 +13,7 @@ OcclusionCullingSettings:
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
- serializedVersion: 9
+ serializedVersion: 10
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
@@ -38,13 +38,12 @@ RenderSettings:
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 0}
- m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
m_UseRadianceAmbientProbe: 0
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
- serializedVersion: 12
- m_GIWorkflowMode: 1
+ serializedVersion: 13
+ m_BakeOnSceneLoad: 1
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
@@ -67,9 +66,6 @@ LightmapSettings:
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
- m_FinalGather: 0
- m_FinalGatherFiltering: 1
- m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_MixedBakeMode: 2
m_BakeBackend: 1
@@ -97,7 +93,8 @@ LightmapSettings:
m_ExportTrainingData: 0
m_TrainingDataDestination: TrainingData
m_LightProbeSampleCountMultiplier: 4
- m_LightingDataAsset: {fileID: 0}
+ m_LightingDataAsset: {fileID: 112000000, guid: 29d2c44a6e01063478e1b9a607c770c6,
+ type: 2}
m_LightingSettings: {fileID: 4890085278179872738, guid: 7b34956cf0a136c4f8438c8ec088925e,
type: 2}
--- !u!196 &4
@@ -105,7 +102,7 @@ NavMeshSettings:
serializedVersion: 2
m_ObjectHideFlags: 0
m_BuildSettings:
- serializedVersion: 2
+ serializedVersion: 3
agentTypeID: 0
agentRadius: 0.5
agentHeight: 2
@@ -118,7 +115,7 @@ NavMeshSettings:
cellSize: 0.16666667
manualTileSize: 0
tileSize: 256
- accuratePlacement: 0
+ buildHeightMesh: 0
maxJobWorkers: 0
preserveTilesOutsideBounds: 0
debug:
@@ -129,6 +126,7 @@ PrefabInstance:
m_ObjectHideFlags: 0
serializedVersion: 2
m_Modification:
+ serializedVersion: 3
m_TransformParent: {fileID: 1273102349}
m_Modifications:
- target: {fileID: 6633621479308595792, guid: d725b5588e1b956458798319e6541d84,
@@ -242,6 +240,9 @@ PrefabInstance:
value: ConnectionModeButtons
objectReference: {fileID: 0}
m_RemovedComponents: []
+ m_RemovedGameObjects: []
+ m_AddedGameObjects: []
+ m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: d725b5588e1b956458798319e6541d84, type: 3}
--- !u!224 &64844349 stripped
RectTransform:
@@ -288,13 +289,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 255745774}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 5, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 7
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &400752937
GameObject:
@@ -322,13 +323,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 400752937}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 30.5, y: 0.49999994, z: 0}
m_LocalScale: {x: 1, y: 3, z: 62}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1832560339}
- m_RootOrder: 4
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!65 &400752939
BoxCollider:
@@ -338,9 +339,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 400752937}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &400752940
@@ -360,6 +369,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -418,13 +430,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 458716318}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: -431, y: -242.5, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 919834285}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &458716320
MonoBehaviour:
@@ -491,6 +503,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 593a2fe42fa9d37498c96f9a383b6521, type: 3}
m_Name:
m_EditorClassIdentifier:
+ NetworkManagerExpanded: 0
NetworkConfig:
ProtocolVersion: 0
NetworkTransport: {fileID: 489997094}
@@ -512,8 +525,12 @@ MonoBehaviour:
NetworkIdRecycleDelay: 120
RpcHashSize: 0
LoadSceneTimeOut: 120
- SpawnTimeout: 1
+ SpawnTimeout: 10
EnableNetworkLogs: 1
+ NetworkTopology: 0
+ UseCMBService: 0
+ AutoSpawnPlayerPrefabClientSide: 1
+ NetworkProfilingMetrics: 1
OldPrefabList: []
RunInBackground: 1
LogLevel: 1
@@ -524,13 +541,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 489997090}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0.000061035156, y: 0.000015258789, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &489997094
MonoBehaviour:
@@ -545,6 +562,8 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
m_ProtocolType: 0
+ m_UseWebSockets: 0
+ m_UseEncryption: 0
m_MaxPacketQueueSize: 128
m_MaxPayloadSize: 6144
m_HeartbeatTimeoutMS: 500
@@ -590,7 +609,6 @@ RectTransform:
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1683211036}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 1, y: 1}
@@ -665,13 +683,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 746479917}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: -30.5, y: 0.49999994, z: 0}
m_LocalScale: {x: 1, y: 3, z: 62}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1832560339}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!65 &746479919
BoxCollider:
@@ -681,9 +699,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 746479917}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &746479920
@@ -703,6 +729,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -772,7 +801,6 @@ RectTransform:
- {fileID: 458716319}
- {fileID: 1438933094}
m_Father: {fileID: 0}
- m_RootOrder: 4
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -836,7 +864,9 @@ Canvas:
m_OverrideSorting: 0
m_OverridePixelPerfect: 0
m_SortingBucketNormalizedSize: 0
+ m_VertexColorAlwaysGammaSpace: 0
m_AdditionalShaderChannelsFlag: 0
+ m_UpdateRectTransformForStandalone: 0
m_SortingLayerID: 0
m_SortingOrder: 0
m_TargetDisplay: 0
@@ -865,9 +895,8 @@ Light:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 953189865}
m_Enabled: 1
- serializedVersion: 10
+ serializedVersion: 11
m_Type: 1
- m_Shape: 0
m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
m_Intensity: 1
m_Range: 10
@@ -917,8 +946,12 @@ Light:
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
m_UseBoundingSphereOverride: 0
m_UseViewFrustumForShadowCasterCull: 1
+ m_ForceVisible: 0
m_ShadowRadius: 0
m_ShadowAngle: 0
+ m_LightUnit: 1
+ m_LuxAtDistance: 1
+ m_EnableSpotReflector: 1
--- !u!4 &953189867
Transform:
m_ObjectHideFlags: 0
@@ -926,13 +959,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 953189865}
+ serializedVersion: 2
m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
m_LocalPosition: {x: 0, y: 3, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
--- !u!1 &1048884480
GameObject:
@@ -975,9 +1008,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1048884480}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 1
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 2, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1048884483
@@ -997,6 +1038,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1037,13 +1081,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1048884480}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 5, y: -0.49, z: 5}
m_LocalScale: {x: 4, y: 1, z: 4}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 8
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1048884486
MonoBehaviour:
@@ -1098,9 +1142,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1098470047}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 1
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 2, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1098470050
@@ -1120,6 +1172,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1160,13 +1215,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1098470047}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: -5, y: -0.49, z: 5}
m_LocalScale: {x: 4, y: 1, z: 4}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 9
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1098470053
MonoBehaviour:
@@ -1213,6 +1268,7 @@ MonoBehaviour:
RayLength: 40
--- !u!120 &1234258167
LineRenderer:
+ serializedVersion: 2
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
@@ -1228,6 +1284,9 @@ LineRenderer:
m_ReflectionProbeUsage: 0
m_RayTracingMode: 0
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1300,16 +1359,20 @@ LineRenderer:
atime6: 0
atime7: 0
m_Mode: 0
+ m_ColorSpace: -1
m_NumColorKeys: 2
m_NumAlphaKeys: 2
numCornerVertices: 0
numCapVertices: 0
alignment: 0
textureMode: 0
+ textureScale: {x: 1, y: 1}
shadowBias: 0.5
generateLightingData: 0
+ m_MaskInteraction: 0
m_UseWorldSpace: 1
m_Loop: 0
+ m_ApplyActiveColorSpace: 0
--- !u!4 &1234258168
Transform:
m_ObjectHideFlags: 0
@@ -1317,19 +1380,20 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1234258165}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0.7071068, z: 0, w: 0.7071068}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1591214031}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 90, z: 0}
--- !u!1001 &1262577125
PrefabInstance:
m_ObjectHideFlags: 0
serializedVersion: 2
m_Modification:
+ serializedVersion: 3
m_TransformParent: {fileID: 919834285}
m_Modifications:
- target: {fileID: 2848221156307247792, guid: 3200770c16e3b2b4ebe7f604154faac7,
@@ -1449,6 +1513,9 @@ PrefabInstance:
objectReference: {fileID: 11400000, guid: c10d995498e0c514a853c3506031d3fb,
type: 2}
m_RemovedComponents: []
+ m_RemovedGameObjects: []
+ m_AddedGameObjects: []
+ m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: 3200770c16e3b2b4ebe7f604154faac7, type: 3}
--- !u!224 &1262577126 stripped
RectTransform:
@@ -1532,7 +1599,9 @@ Canvas:
m_OverrideSorting: 0
m_OverridePixelPerfect: 0
m_SortingBucketNormalizedSize: 0
+ m_VertexColorAlwaysGammaSpace: 0
m_AdditionalShaderChannelsFlag: 0
+ m_UpdateRectTransformForStandalone: 0
m_SortingLayerID: 0
m_SortingOrder: 0
m_TargetDisplay: 0
@@ -1550,7 +1619,6 @@ RectTransform:
m_Children:
- {fileID: 64844349}
m_Father: {fileID: 0}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -1583,13 +1651,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1279426894}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0.49999994, z: -30.5}
m_LocalScale: {x: 60, y: 3, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1832560339}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!65 &1279426896
BoxCollider:
@@ -1599,9 +1667,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1279426894}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1279426897
@@ -1621,6 +1697,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1685,6 +1764,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3834378536
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -1692,6 +1774,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!114 &1431888136
MonoBehaviour:
m_ObjectHideFlags: 0
@@ -1704,6 +1788,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: cb5f3e55f5dd247129d8a4979b80ebbb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_ClientServerToggle: {fileID: 1683211032}
m_TrackSceneEvents: 0
--- !u!4 &1431888137
@@ -1713,13 +1798,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1431888134}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 318.45444, y: 110.697815, z: 216.79077}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 6
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1437380283
GameObject:
@@ -1747,13 +1832,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1437380283}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0.49999994, z: 30.5}
m_LocalScale: {x: 60, y: 3, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1832560339}
- m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!65 &1437380285
BoxCollider:
@@ -1763,9 +1848,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1437380283}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1437380286
@@ -1785,6 +1878,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1849,7 +1945,6 @@ RectTransform:
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 919834285}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 1, y: 0}
m_AnchorMax: {x: 1, y: 0}
@@ -1939,9 +2034,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1500452675}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 1
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 2, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1500452678
@@ -1961,6 +2064,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2001,13 +2107,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1500452675}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: -5, y: -0.49, z: -5}
m_LocalScale: {x: 4, y: 1, z: 4}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 10
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1500452681
MonoBehaviour:
@@ -2044,6 +2150,7 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1591214030}
+ serializedVersion: 2
m_LocalRotation: {x: 0.7071068, y: 0, z: 0, w: 0.7071068}
m_LocalPosition: {x: -15, y: 0.5, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
@@ -2051,7 +2158,6 @@ Transform:
m_Children:
- {fileID: 1234258168}
m_Father: {fileID: 0}
- m_RootOrder: 12
m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
--- !u!1 &1683211032
GameObject:
@@ -2180,7 +2286,6 @@ RectTransform:
m_Children:
- {fileID: 500842512}
m_Father: {fileID: 919834285}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -2210,6 +2315,7 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1832560338}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0.000000059604645, z: 0}
m_LocalScale: {x: 0.5, y: 1, z: 0.5}
@@ -2221,7 +2327,6 @@ Transform:
- {fileID: 746479918}
- {fileID: 400752938}
m_Father: {fileID: 0}
- m_RootOrder: 5
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1893795022
GameObject:
@@ -2255,9 +2360,17 @@ Camera:
m_projectionMatrixMode: 1
m_GateFitMode: 2
m_FOVAxisMode: 0
+ m_Iso: 200
+ m_ShutterSpeed: 0.005
+ m_Aperture: 16
+ m_FocusDistance: 10
+ m_FocalLength: 50
+ m_BladeCount: 5
+ m_Curvature: {x: 2, y: 11}
+ m_BarrelClipping: 0.25
+ m_Anamorphism: 0
m_SensorSize: {x: 36, y: 24}
m_LensShift: {x: 0, y: 0}
- m_FocalLength: 50
m_NormalizedViewPortRect:
serializedVersion: 2
x: 0
@@ -2299,13 +2412,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1893795022}
+ serializedVersion: 2
m_LocalRotation: {x: 0.41890106, y: -0, z: -0, w: 0.9080319}
m_LocalPosition: {x: 0, y: 22.49, z: -23.08}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 49.530003, y: 0, z: 0}
--- !u!1 &1999837045
GameObject:
@@ -2333,13 +2446,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1999837045}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: -0.50000006, z: 0}
m_LocalScale: {x: 60, y: 1, z: 60}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1832560339}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!65 &1999837047
BoxCollider:
@@ -2349,9 +2462,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1999837045}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1999837048
@@ -2371,6 +2492,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2445,9 +2569,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2057085321}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 1
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 2, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &2057085324
@@ -2467,6 +2599,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2507,13 +2642,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2057085321}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 5, y: -0.49, z: -5}
m_LocalScale: {x: 4, y: 1, z: 4}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 11
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &2057085327
MonoBehaviour:
@@ -2527,3 +2662,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 08cb6173d0006264f829ee44732d3d08, type: 3}
m_Name:
m_EditorClassIdentifier:
+--- !u!1660057539 &9223372036854775807
+SceneRoots:
+ m_ObjectHideFlags: 0
+ m_Roots:
+ - {fileID: 1893795025}
+ - {fileID: 953189867}
+ - {fileID: 489997093}
+ - {fileID: 1273102349}
+ - {fileID: 919834285}
+ - {fileID: 1832560339}
+ - {fileID: 1431888137}
+ - {fileID: 255745776}
+ - {fileID: 1048884485}
+ - {fileID: 1098470052}
+ - {fileID: 1500452680}
+ - {fileID: 2057085326}
+ - {fileID: 1591214031}
diff --git a/testproject/Assets/Samples/Physics/PhysicsSample/LightingData.asset b/testproject/Assets/Samples/Physics/PhysicsSample/LightingData.asset
index 6866c0e915..5efce3dde6 100644
Binary files a/testproject/Assets/Samples/Physics/PhysicsSample/LightingData.asset and b/testproject/Assets/Samples/Physics/PhysicsSample/LightingData.asset differ
diff --git a/testproject/Assets/Samples/Physics/PhysicsSample/ReflectionProbe-0.exr.meta b/testproject/Assets/Samples/Physics/PhysicsSample/ReflectionProbe-0.exr.meta
index 7803ed084d..7c60c5dfa3 100644
--- a/testproject/Assets/Samples/Physics/PhysicsSample/ReflectionProbe-0.exr.meta
+++ b/testproject/Assets/Samples/Physics/PhysicsSample/ReflectionProbe-0.exr.meta
@@ -93,32 +93,6 @@ TextureImporter:
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- - serializedVersion: 4
- buildTarget: WebGL
- maxTextureSize: 2048
- resizeAlgorithm: 0
- textureFormat: -1
- textureCompression: 1
- compressionQuality: 50
- crunchedCompression: 0
- allowsAlphaSplitting: 0
- overridden: 0
- ignorePlatformSupport: 0
- androidETC2FallbackOverride: 0
- forceMaximumCompressionQuality_BC6H_BC7: 0
- - serializedVersion: 4
- buildTarget: WindowsStoreApps
- maxTextureSize: 2048
- resizeAlgorithm: 0
- textureFormat: -1
- textureCompression: 1
- compressionQuality: 50
- crunchedCompression: 0
- allowsAlphaSplitting: 0
- overridden: 0
- ignorePlatformSupport: 0
- androidETC2FallbackOverride: 0
- forceMaximumCompressionQuality_BC6H_BC7: 0
spriteSheet:
serializedVersion: 2
sprites: []
diff --git a/testproject/Assets/Samples/Physics/PhysiscSampleLightingSettings.lighting b/testproject/Assets/Samples/Physics/PhysiscSampleLightingSettings.lighting
index 3d81fd3433..4dac18b5c2 100644
--- a/testproject/Assets/Samples/Physics/PhysiscSampleLightingSettings.lighting
+++ b/testproject/Assets/Samples/Physics/PhysiscSampleLightingSettings.lighting
@@ -7,9 +7,8 @@ LightingSettings:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name: PhysiscSampleLightingSettings
- serializedVersion: 3
- m_GIWorkflowMode: 0
- m_EnableBakedLightmaps: 1
+ serializedVersion: 9
+ m_EnableBakedLightmaps: 0
m_EnableRealtimeLightmaps: 0
m_RealtimeEnvironmentLighting: 1
m_BounceScale: 1
@@ -18,9 +17,11 @@ LightingSettings:
m_UsingShadowmask: 1
m_BakeBackend: 1
m_LightmapMaxSize: 1024
+ m_LightmapSizeFixed: 0
+ m_UseMipmapLimits: 1
m_BakeResolution: 40
m_Padding: 2
- m_TextureCompression: 1
+ m_LightmapCompression: 3
m_AO: 0
m_AOMaxDistance: 1
m_CompAOExponent: 1
@@ -31,13 +32,11 @@ LightingSettings:
m_FilterMode: 1
m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
m_ExportTrainingData: 0
+ m_EnableWorkerProcessBaking: 1
m_TrainingDataDestination: TrainingData
m_RealtimeResolution: 2
m_ForceWhiteAlbedo: 0
m_ForceUpdates: 0
- m_FinalGather: 0
- m_FinalGatherRayCount: 256
- m_FinalGatherFiltering: 1
m_PVRCulling: 1
m_PVRSampling: 1
m_PVRDirectSampleCount: 32
@@ -46,8 +45,8 @@ LightingSettings:
m_PVREnvironmentReferencePointCount: 2048
m_LightProbeSampleCountMultiplier: 4
m_PVRBounces: 2
- m_PVRMinBounces: 1
- m_PVREnvironmentMIS: 1
+ m_PVRMinBounces: 2
+ m_PVREnvironmentImportanceSampling: 1
m_PVRFilteringMode: 1
m_PVRDenoiserTypeDirect: 1
m_PVRDenoiserTypeIndirect: 1
@@ -61,3 +60,4 @@ LightingSettings:
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
m_PVRFilteringAtrousPositionSigmaIndirect: 2
m_PVRFilteringAtrousPositionSigmaAO: 1
+ m_RespectSceneVisibilityWhenBakingGI: 0
diff --git a/testproject/Assets/Samples/PrefabPool/PrefabPoolExample.unity b/testproject/Assets/Samples/PrefabPool/PrefabPoolExample.unity
index b87af2814c..1866addd31 100644
--- a/testproject/Assets/Samples/PrefabPool/PrefabPoolExample.unity
+++ b/testproject/Assets/Samples/PrefabPool/PrefabPoolExample.unity
@@ -13,7 +13,7 @@ OcclusionCullingSettings:
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
- serializedVersion: 9
+ serializedVersion: 10
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
@@ -38,13 +38,12 @@ RenderSettings:
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 0}
- m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
m_UseRadianceAmbientProbe: 0
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
- serializedVersion: 12
- m_GIWorkflowMode: 1
+ serializedVersion: 13
+ m_BakeOnSceneLoad: 0
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
@@ -67,9 +66,6 @@ LightmapSettings:
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
- m_FinalGather: 0
- m_FinalGatherFiltering: 1
- m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_MixedBakeMode: 2
m_BakeBackend: 1
@@ -104,7 +100,7 @@ NavMeshSettings:
serializedVersion: 2
m_ObjectHideFlags: 0
m_BuildSettings:
- serializedVersion: 2
+ serializedVersion: 3
agentTypeID: 0
agentRadius: 0.5
agentHeight: 2
@@ -117,7 +113,7 @@ NavMeshSettings:
cellSize: 0.16666667
manualTileSize: 0
tileSize: 256
- accuratePlacement: 0
+ buildHeightMesh: 0
maxJobWorkers: 0
preserveTilesOutsideBounds: 0
debug:
@@ -148,9 +144,8 @@ Light:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 37242881}
m_Enabled: 1
- serializedVersion: 10
+ serializedVersion: 11
m_Type: 1
- m_Shape: 0
m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
m_Intensity: 1
m_Range: 10
@@ -200,8 +195,12 @@ Light:
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
m_UseBoundingSphereOverride: 0
m_UseViewFrustumForShadowCasterCull: 1
+ m_ForceVisible: 0
m_ShadowRadius: 0
m_ShadowAngle: 0
+ m_LightUnit: 1
+ m_LuxAtDistance: 1
+ m_EnableSpotReflector: 1
--- !u!4 &37242883
Transform:
m_ObjectHideFlags: 0
@@ -209,13 +208,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 37242881}
+ serializedVersion: 2
m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
m_LocalPosition: {x: 0, y: 3, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
--- !u!224 &42803802 stripped
RectTransform:
@@ -250,9 +249,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 57392470}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &57392472
@@ -272,6 +279,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -312,13 +322,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 57392470}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: -30.5, y: 0.49999994, z: 0}
m_LocalScale: {x: 1, y: 3, z: 62}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &167044830
GameObject:
@@ -396,7 +406,9 @@ Canvas:
m_OverrideSorting: 0
m_OverridePixelPerfect: 0
m_SortingBucketNormalizedSize: 0
+ m_VertexColorAlwaysGammaSpace: 0
m_AdditionalShaderChannelsFlag: 0
+ m_UpdateRectTransformForStandalone: 0
m_SortingLayerID: 0
m_SortingOrder: 0
m_TargetDisplay: 0
@@ -414,7 +426,6 @@ RectTransform:
m_Children:
- {fileID: 1865409449}
m_Father: {fileID: 0}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -497,7 +508,9 @@ Canvas:
m_OverrideSorting: 0
m_OverridePixelPerfect: 0
m_SortingBucketNormalizedSize: 0
+ m_VertexColorAlwaysGammaSpace: 0
m_AdditionalShaderChannelsFlag: 0
+ m_UpdateRectTransformForStandalone: 0
m_SortingLayerID: 0
m_SortingOrder: 0
m_TargetDisplay: 0
@@ -518,7 +531,6 @@ RectTransform:
- {fileID: 1834318148}
- {fileID: 1383741138}
m_Father: {fileID: 0}
- m_RootOrder: 4
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -552,9 +564,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 336568645}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &336568647
@@ -574,6 +594,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -614,13 +637,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 336568645}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: -0.50000006, z: 0}
m_LocalScale: {x: 60, y: 1, z: 60}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &575203307
GameObject:
@@ -662,9 +685,17 @@ Camera:
m_projectionMatrixMode: 1
m_GateFitMode: 2
m_FOVAxisMode: 0
+ m_Iso: 200
+ m_ShutterSpeed: 0.005
+ m_Aperture: 16
+ m_FocusDistance: 10
+ m_FocalLength: 50
+ m_BladeCount: 5
+ m_Curvature: {x: 2, y: 11}
+ m_BarrelClipping: 0.25
+ m_Anamorphism: 0
m_SensorSize: {x: 36, y: 24}
m_LensShift: {x: 0, y: 0}
- m_FocalLength: 50
m_NormalizedViewPortRect:
serializedVersion: 2
x: 0
@@ -698,13 +729,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 575203307}
+ serializedVersion: 2
m_LocalRotation: {x: 0.41890106, y: -0, z: -0, w: 0.9080319}
m_LocalPosition: {x: 0, y: 42, z: -46}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 49.530003, y: 0, z: 0}
--- !u!1 &599972120
GameObject:
@@ -737,7 +768,6 @@ RectTransform:
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1588117328}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 1, y: 1}
@@ -793,9 +823,8 @@ LightingSettings:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name:
- serializedVersion: 4
- m_GIWorkflowMode: 1
- m_EnableBakedLightmaps: 1
+ serializedVersion: 9
+ m_EnableBakedLightmaps: 0
m_EnableRealtimeLightmaps: 0
m_RealtimeEnvironmentLighting: 1
m_BounceScale: 1
@@ -804,6 +833,8 @@ LightingSettings:
m_UsingShadowmask: 1
m_BakeBackend: 1
m_LightmapMaxSize: 1024
+ m_LightmapSizeFixed: 0
+ m_UseMipmapLimits: 1
m_BakeResolution: 40
m_Padding: 2
m_LightmapCompression: 3
@@ -817,13 +848,11 @@ LightingSettings:
m_FilterMode: 1
m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
m_ExportTrainingData: 0
+ m_EnableWorkerProcessBaking: 1
m_TrainingDataDestination: TrainingData
m_RealtimeResolution: 2
m_ForceWhiteAlbedo: 0
m_ForceUpdates: 0
- m_FinalGather: 0
- m_FinalGatherRayCount: 256
- m_FinalGatherFiltering: 1
m_PVRCulling: 1
m_PVRSampling: 1
m_PVRDirectSampleCount: 32
@@ -832,8 +861,8 @@ LightingSettings:
m_PVREnvironmentReferencePointCount: 2048
m_LightProbeSampleCountMultiplier: 4
m_PVRBounces: 2
- m_PVRMinBounces: 1
- m_PVREnvironmentMIS: 1
+ m_PVRMinBounces: 2
+ m_PVREnvironmentImportanceSampling: 1
m_PVRFilteringMode: 1
m_PVRDenoiserTypeDirect: 1
m_PVRDenoiserTypeIndirect: 1
@@ -847,7 +876,7 @@ LightingSettings:
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
m_PVRFilteringAtrousPositionSigmaIndirect: 2
m_PVRFilteringAtrousPositionSigmaAO: 1
- m_PVRTiledBaking: 0
+ m_RespectSceneVisibilityWhenBakingGI: 0
--- !u!1 &1024114717
GameObject:
m_ObjectHideFlags: 0
@@ -878,6 +907,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 593a2fe42fa9d37498c96f9a383b6521, type: 3}
m_Name:
m_EditorClassIdentifier:
+ NetworkManagerExpanded: 0
NetworkConfig:
ProtocolVersion: 0
NetworkTransport: {fileID: 1024114721}
@@ -899,8 +929,12 @@ MonoBehaviour:
NetworkIdRecycleDelay: 120
RpcHashSize: 0
LoadSceneTimeOut: 120
- SpawnTimeout: 1
+ SpawnTimeout: 10
EnableNetworkLogs: 1
+ NetworkTopology: 0
+ UseCMBService: 0
+ AutoSpawnPlayerPrefabClientSide: 1
+ NetworkProfilingMetrics: 1
OldPrefabList: []
RunInBackground: 1
LogLevel: 1
@@ -911,13 +945,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1024114717}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0.000061035156, y: 0.000015258789, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1024114721
MonoBehaviour:
@@ -932,6 +966,8 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
m_ProtocolType: 0
+ m_UseWebSockets: 0
+ m_UseEncryption: 0
m_MaxPacketQueueSize: 128
m_MaxPayloadSize: 6144
m_HeartbeatTimeoutMS: 500
@@ -976,6 +1012,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 83e085235981b734bad565d9a60de47a, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_ObjectToPool: {fileID: 771575417923360811, guid: 29cabf623d47bb345a9bb4140e4397d7,
type: 3}
m_ObjectPoolSize: 15
@@ -987,13 +1024,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1113539278}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0.5, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 5
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1113539281
MonoBehaviour:
@@ -1008,6 +1045,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3000067655
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -1015,6 +1055,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!1 &1332123091
GameObject:
m_ObjectHideFlags: 0
@@ -1038,6 +1080,7 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1332123091}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0.000000059604645, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
@@ -1049,7 +1092,6 @@ Transform:
- {fileID: 57392474}
- {fileID: 1336081255}
m_Father: {fileID: 0}
- m_RootOrder: 6
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1336081251
GameObject:
@@ -1078,9 +1120,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1336081251}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1336081253
@@ -1100,6 +1150,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1140,13 +1193,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1336081251}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 30.5, y: 0.49999994, z: 0}
m_LocalScale: {x: 1, y: 3, z: 62}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 4
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1383741137
GameObject:
@@ -1179,7 +1232,6 @@ RectTransform:
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 290861172}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 1, y: 0}
m_AnchorMax: {x: 1, y: 0}
@@ -1261,7 +1313,6 @@ RectTransform:
m_Children:
- {fileID: 599972121}
m_Father: {fileID: 290861172}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -1422,13 +1473,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1834318145}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: -431, y: -242.5, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 290861172}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1857685343
GameObject:
@@ -1457,9 +1508,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1857685343}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1857685345
@@ -1479,6 +1538,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1519,19 +1581,20 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1857685343}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0.49999994, z: -30.5}
m_LocalScale: {x: 60, y: 3, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1001 &1865409448
PrefabInstance:
m_ObjectHideFlags: 0
serializedVersion: 2
m_Modification:
+ serializedVersion: 3
m_TransformParent: {fileID: 167044834}
m_Modifications:
- target: {fileID: 6633621479308595792, guid: d725b5588e1b956458798319e6541d84,
@@ -1645,6 +1708,9 @@ PrefabInstance:
value: ConnectionModeButtons
objectReference: {fileID: 0}
m_RemovedComponents: []
+ m_RemovedGameObjects: []
+ m_AddedGameObjects: []
+ m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: d725b5588e1b956458798319e6541d84, type: 3}
--- !u!224 &1865409449 stripped
RectTransform:
@@ -1679,9 +1745,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2028091268}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &2028091270
@@ -1701,6 +1775,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1741,13 +1818,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2028091268}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0.49999994, z: 30.5}
m_LocalScale: {x: 60, y: 3, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &2107482020
GameObject:
@@ -1774,13 +1851,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2107482020}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 318.45444, y: 110.697815, z: 216.79077}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 7
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &2107482022
MonoBehaviour:
@@ -1794,6 +1871,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: cb5f3e55f5dd247129d8a4979b80ebbb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_ClientServerToggle: {fileID: 1588117327}
m_TrackSceneEvents: 0
--- !u!114 &2107482023
@@ -1809,6 +1887,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 2806511234
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -1816,11 +1897,14 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!1001 &2848221156282925290
PrefabInstance:
m_ObjectHideFlags: 0
serializedVersion: 2
m_Modification:
+ serializedVersion: 3
m_TransformParent: {fileID: 290861172}
m_Modifications:
- target: {fileID: 2848221156307247792, guid: 3200770c16e3b2b4ebe7f604154faac7,
@@ -1940,4 +2024,19 @@ PrefabInstance:
objectReference: {fileID: 11400000, guid: c10d995498e0c514a853c3506031d3fb,
type: 2}
m_RemovedComponents: []
+ m_RemovedGameObjects: []
+ m_AddedGameObjects: []
+ m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: 3200770c16e3b2b4ebe7f604154faac7, type: 3}
+--- !u!1660057539 &9223372036854775807
+SceneRoots:
+ m_ObjectHideFlags: 0
+ m_Roots:
+ - {fileID: 575203310}
+ - {fileID: 37242883}
+ - {fileID: 1024114720}
+ - {fileID: 167044834}
+ - {fileID: 290861172}
+ - {fileID: 1113539280}
+ - {fileID: 1332123092}
+ - {fileID: 2107482021}
diff --git a/testproject/Assets/Samples/PrefabPool/PrefabPoolOverrideExample.unity b/testproject/Assets/Samples/PrefabPool/PrefabPoolOverrideExample.unity
index 2eb93fca9a..81ef6e79c4 100644
--- a/testproject/Assets/Samples/PrefabPool/PrefabPoolOverrideExample.unity
+++ b/testproject/Assets/Samples/PrefabPool/PrefabPoolOverrideExample.unity
@@ -13,7 +13,7 @@ OcclusionCullingSettings:
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
- serializedVersion: 9
+ serializedVersion: 10
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
@@ -38,13 +38,12 @@ RenderSettings:
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 0}
- m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
m_UseRadianceAmbientProbe: 0
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
- serializedVersion: 12
- m_GIWorkflowMode: 1
+ serializedVersion: 13
+ m_BakeOnSceneLoad: 0
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
@@ -67,9 +66,6 @@ LightmapSettings:
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
- m_FinalGather: 0
- m_FinalGatherFiltering: 1
- m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_MixedBakeMode: 2
m_BakeBackend: 1
@@ -104,7 +100,7 @@ NavMeshSettings:
serializedVersion: 2
m_ObjectHideFlags: 0
m_BuildSettings:
- serializedVersion: 2
+ serializedVersion: 3
agentTypeID: 0
agentRadius: 0.5
agentHeight: 2
@@ -117,7 +113,7 @@ NavMeshSettings:
cellSize: 0.16666667
manualTileSize: 0
tileSize: 256
- accuratePlacement: 0
+ buildHeightMesh: 0
maxJobWorkers: 0
preserveTilesOutsideBounds: 0
debug:
@@ -148,9 +144,8 @@ Light:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 37242881}
m_Enabled: 1
- serializedVersion: 10
+ serializedVersion: 11
m_Type: 1
- m_Shape: 0
m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
m_Intensity: 1
m_Range: 10
@@ -200,8 +195,12 @@ Light:
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
m_UseBoundingSphereOverride: 0
m_UseViewFrustumForShadowCasterCull: 1
+ m_ForceVisible: 0
m_ShadowRadius: 0
m_ShadowAngle: 0
+ m_LightUnit: 1
+ m_LuxAtDistance: 1
+ m_EnableSpotReflector: 1
--- !u!4 &37242883
Transform:
m_ObjectHideFlags: 0
@@ -209,13 +208,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 37242881}
+ serializedVersion: 2
m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
m_LocalPosition: {x: 0, y: 3, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
--- !u!224 &42803802 stripped
RectTransform:
@@ -250,9 +249,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 57392470}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &57392472
@@ -272,6 +279,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -312,13 +322,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 57392470}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: -30.5, y: 0.49999994, z: 0}
m_LocalScale: {x: 1, y: 3, z: 62}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &167044830
GameObject:
@@ -396,7 +406,9 @@ Canvas:
m_OverrideSorting: 0
m_OverridePixelPerfect: 0
m_SortingBucketNormalizedSize: 0
+ m_VertexColorAlwaysGammaSpace: 0
m_AdditionalShaderChannelsFlag: 0
+ m_UpdateRectTransformForStandalone: 0
m_SortingLayerID: 0
m_SortingOrder: 0
m_TargetDisplay: 0
@@ -414,7 +426,6 @@ RectTransform:
m_Children:
- {fileID: 1865409449}
m_Father: {fileID: 0}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -497,7 +508,9 @@ Canvas:
m_OverrideSorting: 0
m_OverridePixelPerfect: 0
m_SortingBucketNormalizedSize: 0
+ m_VertexColorAlwaysGammaSpace: 0
m_AdditionalShaderChannelsFlag: 0
+ m_UpdateRectTransformForStandalone: 0
m_SortingLayerID: 0
m_SortingOrder: 0
m_TargetDisplay: 0
@@ -518,7 +531,6 @@ RectTransform:
- {fileID: 1834318148}
- {fileID: 1383741138}
m_Father: {fileID: 0}
- m_RootOrder: 4
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -552,9 +564,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 336568645}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &336568647
@@ -574,6 +594,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -614,13 +637,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 336568645}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: -0.50000006, z: 0}
m_LocalScale: {x: 60, y: 1, z: 60}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &575203307
GameObject:
@@ -662,9 +685,17 @@ Camera:
m_projectionMatrixMode: 1
m_GateFitMode: 2
m_FOVAxisMode: 0
+ m_Iso: 200
+ m_ShutterSpeed: 0.005
+ m_Aperture: 16
+ m_FocusDistance: 10
+ m_FocalLength: 50
+ m_BladeCount: 5
+ m_Curvature: {x: 2, y: 11}
+ m_BarrelClipping: 0.25
+ m_Anamorphism: 0
m_SensorSize: {x: 36, y: 24}
m_LensShift: {x: 0, y: 0}
- m_FocalLength: 50
m_NormalizedViewPortRect:
serializedVersion: 2
x: 0
@@ -698,13 +729,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 575203307}
+ serializedVersion: 2
m_LocalRotation: {x: 0.41890106, y: -0, z: -0, w: 0.9080319}
m_LocalPosition: {x: 0, y: 42, z: -46}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 49.530003, y: 0, z: 0}
--- !u!1 &599972120
GameObject:
@@ -737,7 +768,6 @@ RectTransform:
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1588117328}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 1, y: 1}
@@ -793,9 +823,8 @@ LightingSettings:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name:
- serializedVersion: 4
- m_GIWorkflowMode: 1
- m_EnableBakedLightmaps: 1
+ serializedVersion: 9
+ m_EnableBakedLightmaps: 0
m_EnableRealtimeLightmaps: 0
m_RealtimeEnvironmentLighting: 1
m_BounceScale: 1
@@ -804,6 +833,8 @@ LightingSettings:
m_UsingShadowmask: 1
m_BakeBackend: 1
m_LightmapMaxSize: 1024
+ m_LightmapSizeFixed: 0
+ m_UseMipmapLimits: 1
m_BakeResolution: 40
m_Padding: 2
m_LightmapCompression: 3
@@ -817,13 +848,11 @@ LightingSettings:
m_FilterMode: 1
m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
m_ExportTrainingData: 0
+ m_EnableWorkerProcessBaking: 1
m_TrainingDataDestination: TrainingData
m_RealtimeResolution: 2
m_ForceWhiteAlbedo: 0
m_ForceUpdates: 0
- m_FinalGather: 0
- m_FinalGatherRayCount: 256
- m_FinalGatherFiltering: 1
m_PVRCulling: 1
m_PVRSampling: 1
m_PVRDirectSampleCount: 32
@@ -832,8 +861,8 @@ LightingSettings:
m_PVREnvironmentReferencePointCount: 2048
m_LightProbeSampleCountMultiplier: 4
m_PVRBounces: 2
- m_PVRMinBounces: 1
- m_PVREnvironmentMIS: 1
+ m_PVRMinBounces: 2
+ m_PVREnvironmentImportanceSampling: 1
m_PVRFilteringMode: 1
m_PVRDenoiserTypeDirect: 1
m_PVRDenoiserTypeIndirect: 1
@@ -847,7 +876,7 @@ LightingSettings:
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
m_PVRFilteringAtrousPositionSigmaIndirect: 2
m_PVRFilteringAtrousPositionSigmaAO: 1
- m_PVRTiledBaking: 0
+ m_RespectSceneVisibilityWhenBakingGI: 0
--- !u!1 &1024114717
GameObject:
m_ObjectHideFlags: 0
@@ -878,6 +907,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 593a2fe42fa9d37498c96f9a383b6521, type: 3}
m_Name:
m_EditorClassIdentifier:
+ NetworkManagerExpanded: 0
NetworkConfig:
ProtocolVersion: 0
NetworkTransport: {fileID: 1024114721}
@@ -898,8 +928,12 @@ MonoBehaviour:
NetworkIdRecycleDelay: 120
RpcHashSize: 0
LoadSceneTimeOut: 120
- SpawnTimeout: 1
+ SpawnTimeout: 10
EnableNetworkLogs: 1
+ NetworkTopology: 0
+ UseCMBService: 0
+ AutoSpawnPlayerPrefabClientSide: 1
+ NetworkProfilingMetrics: 1
OldPrefabList:
- Override: 0
Prefab: {fileID: 771575417923360811, guid: 29cabf623d47bb345a9bb4140e4397d7,
@@ -918,13 +952,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1024114717}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0.000061035156, y: 0.000015258789, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1024114721
MonoBehaviour:
@@ -939,6 +973,8 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
m_ProtocolType: 0
+ m_UseWebSockets: 0
+ m_UseEncryption: 0
m_MaxPacketQueueSize: 128
m_MaxPayloadSize: 6144
m_HeartbeatTimeoutMS: 500
@@ -983,6 +1019,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e75c6dd7d88b8ef47bc652a967fa34eb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_ObjectToOverride: {fileID: 771575417923360811, guid: 29cabf623d47bb345a9bb4140e4397d7,
type: 3}
m_ObjectOverrides:
@@ -999,13 +1036,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1113539278}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0.5, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 5
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1113539281
MonoBehaviour:
@@ -1020,6 +1057,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3569926023
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -1027,6 +1067,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!1 &1332123091
GameObject:
m_ObjectHideFlags: 0
@@ -1050,6 +1092,7 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1332123091}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0.000000059604645, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
@@ -1061,7 +1104,6 @@ Transform:
- {fileID: 57392474}
- {fileID: 1336081255}
m_Father: {fileID: 0}
- m_RootOrder: 6
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1336081251
GameObject:
@@ -1090,9 +1132,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1336081251}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1336081253
@@ -1112,6 +1162,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1152,13 +1205,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1336081251}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 30.5, y: 0.49999994, z: 0}
m_LocalScale: {x: 1, y: 3, z: 62}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 4
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1383741137
GameObject:
@@ -1191,7 +1244,6 @@ RectTransform:
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 290861172}
- m_RootOrder: 3
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 1, y: 0}
m_AnchorMax: {x: 1, y: 0}
@@ -1273,7 +1325,6 @@ RectTransform:
m_Children:
- {fileID: 599972121}
m_Father: {fileID: 290861172}
- m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
m_AnchorMin: {x: 0, y: 0}
m_AnchorMax: {x: 0, y: 0}
@@ -1434,13 +1485,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1834318145}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: -431, y: -242.5, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 290861172}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1857685343
GameObject:
@@ -1469,9 +1520,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1857685343}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &1857685345
@@ -1491,6 +1550,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1531,19 +1593,20 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1857685343}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0.49999994, z: -30.5}
m_LocalScale: {x: 60, y: 3, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 2
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1001 &1865409448
PrefabInstance:
m_ObjectHideFlags: 0
serializedVersion: 2
m_Modification:
+ serializedVersion: 3
m_TransformParent: {fileID: 167044834}
m_Modifications:
- target: {fileID: 6633621479308595792, guid: d725b5588e1b956458798319e6541d84,
@@ -1657,6 +1720,9 @@ PrefabInstance:
value: ConnectionModeButtons
objectReference: {fileID: 0}
m_RemovedComponents: []
+ m_RemovedGameObjects: []
+ m_AddedGameObjects: []
+ m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: d725b5588e1b956458798319e6541d84, type: 3}
--- !u!224 &1865409449 stripped
RectTransform:
@@ -1691,9 +1757,17 @@ BoxCollider:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2028091268}
m_Material: {fileID: 0}
+ m_IncludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_ExcludeLayers:
+ serializedVersion: 2
+ m_Bits: 0
+ m_LayerOverridePriority: 0
m_IsTrigger: 0
+ m_ProvidesContacts: 0
m_Enabled: 1
- serializedVersion: 2
+ serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &2028091270
@@ -1713,6 +1787,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1753,13 +1830,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2028091268}
+ serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0.49999994, z: 30.5}
m_LocalScale: {x: 60, y: 3, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1332123092}
- m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &2107482020
GameObject:
@@ -1786,13 +1863,13 @@ Transform:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 2107482020}
+ serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 318.45444, y: 110.697815, z: 216.79077}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
- m_RootOrder: 7
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &2107482022
MonoBehaviour:
@@ -1806,6 +1883,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: cb5f3e55f5dd247129d8a4979b80ebbb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_ClientServerToggle: {fileID: 1588117327}
m_TrackSceneEvents: 0
--- !u!114 &2107482023
@@ -1821,6 +1899,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 4056472094
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -1828,11 +1909,14 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!1001 &2848221156282925290
PrefabInstance:
m_ObjectHideFlags: 0
serializedVersion: 2
m_Modification:
+ serializedVersion: 3
m_TransformParent: {fileID: 290861172}
m_Modifications:
- target: {fileID: 2848221156307247792, guid: 3200770c16e3b2b4ebe7f604154faac7,
@@ -1952,4 +2036,19 @@ PrefabInstance:
objectReference: {fileID: 11400000, guid: c10d995498e0c514a853c3506031d3fb,
type: 2}
m_RemovedComponents: []
+ m_RemovedGameObjects: []
+ m_AddedGameObjects: []
+ m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: 3200770c16e3b2b4ebe7f604154faac7, type: 3}
+--- !u!1660057539 &9223372036854775807
+SceneRoots:
+ m_ObjectHideFlags: 0
+ m_Roots:
+ - {fileID: 575203310}
+ - {fileID: 37242883}
+ - {fileID: 1024114720}
+ - {fileID: 167044834}
+ - {fileID: 290861172}
+ - {fileID: 1113539280}
+ - {fileID: 1332123092}
+ - {fileID: 2107482021}
diff --git a/testproject/Assets/Scenes/MultiprocessTestScene.unity b/testproject/Assets/Scenes/MultiprocessTestScene.unity
index 8750959c97..f67263407e 100644
--- a/testproject/Assets/Scenes/MultiprocessTestScene.unity
+++ b/testproject/Assets/Scenes/MultiprocessTestScene.unity
@@ -13,7 +13,7 @@ OcclusionCullingSettings:
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
- serializedVersion: 9
+ serializedVersion: 10
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
@@ -38,13 +38,12 @@ RenderSettings:
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 0}
- m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
m_UseRadianceAmbientProbe: 0
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
- serializedVersion: 12
- m_GIWorkflowMode: 1
+ serializedVersion: 13
+ m_BakeOnSceneLoad: 0
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
@@ -67,9 +66,6 @@ LightmapSettings:
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
- m_FinalGather: 0
- m_FinalGatherFiltering: 1
- m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_MixedBakeMode: 2
m_BakeBackend: 1
@@ -148,9 +144,8 @@ Light:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 127222500}
m_Enabled: 1
- serializedVersion: 10
+ serializedVersion: 11
m_Type: 1
- m_Shape: 0
m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
m_Intensity: 1
m_Range: 10
@@ -200,8 +195,12 @@ Light:
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
m_UseBoundingSphereOverride: 0
m_UseViewFrustumForShadowCasterCull: 1
+ m_ForceVisible: 0
m_ShadowRadius: 0
m_ShadowAngle: 0
+ m_LightUnit: 1
+ m_LuxAtDistance: 1
+ m_EnableSpotReflector: 1
--- !u!4 &127222502
Transform:
m_ObjectHideFlags: 0
@@ -224,9 +223,8 @@ LightingSettings:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name:
- serializedVersion: 6
- m_GIWorkflowMode: 1
- m_EnableBakedLightmaps: 1
+ serializedVersion: 9
+ m_EnableBakedLightmaps: 0
m_EnableRealtimeLightmaps: 0
m_RealtimeEnvironmentLighting: 1
m_BounceScale: 1
@@ -235,6 +233,8 @@ LightingSettings:
m_UsingShadowmask: 1
m_BakeBackend: 1
m_LightmapMaxSize: 1024
+ m_LightmapSizeFixed: 0
+ m_UseMipmapLimits: 1
m_BakeResolution: 40
m_Padding: 2
m_LightmapCompression: 3
@@ -248,13 +248,11 @@ LightingSettings:
m_FilterMode: 1
m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
m_ExportTrainingData: 0
+ m_EnableWorkerProcessBaking: 1
m_TrainingDataDestination: TrainingData
m_RealtimeResolution: 2
m_ForceWhiteAlbedo: 0
m_ForceUpdates: 0
- m_FinalGather: 0
- m_FinalGatherRayCount: 256
- m_FinalGatherFiltering: 1
m_PVRCulling: 1
m_PVRSampling: 1
m_PVRDirectSampleCount: 32
@@ -278,8 +276,6 @@ LightingSettings:
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
m_PVRFilteringAtrousPositionSigmaIndirect: 2
m_PVRFilteringAtrousPositionSigmaAO: 1
- m_PVRTiledBaking: 0
- m_NumRaysToShootPerTexel: -1
m_RespectSceneVisibilityWhenBakingGI: 0
--- !u!1 &160940364
GameObject:
@@ -338,6 +334,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -458,6 +457,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -647,6 +649,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -752,6 +757,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -831,6 +839,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 593a2fe42fa9d37498c96f9a383b6521, type: 3}
m_Name:
m_EditorClassIdentifier:
+ NetworkManagerExpanded: 0
NetworkConfig:
ProtocolVersion: 0
NetworkTransport: {fileID: 2027640073}
@@ -851,8 +860,12 @@ MonoBehaviour:
NetworkIdRecycleDelay: 120
RpcHashSize: 0
LoadSceneTimeOut: 120
- SpawnTimeout: 1
+ SpawnTimeout: 10
EnableNetworkLogs: 1
+ NetworkTopology: 0
+ UseCMBService: 0
+ AutoSpawnPlayerPrefabClientSide: 1
+ NetworkProfilingMetrics: 1
OldPrefabList:
- Override: 0
Prefab: {fileID: 9115731988109684252, guid: c2851feb7276442cc86a6f2d1d69ea11,
@@ -935,6 +948,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 2217825759
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -942,6 +958,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!4 &1274245425
Transform:
m_ObjectHideFlags: 0
@@ -1014,6 +1032,8 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
m_ProtocolType: 0
+ m_UseWebSockets: 0
+ m_UseEncryption: 0
m_MaxPacketQueueSize: 128
m_MaxPayloadSize: 4096
m_HeartbeatTimeoutMS: 500
diff --git a/testproject/Assets/Scenes/SampleScene.unity b/testproject/Assets/Scenes/SampleScene.unity
index f5e5a89789..11333fca3d 100644
--- a/testproject/Assets/Scenes/SampleScene.unity
+++ b/testproject/Assets/Scenes/SampleScene.unity
@@ -13,7 +13,7 @@ OcclusionCullingSettings:
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
- serializedVersion: 9
+ serializedVersion: 10
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
@@ -38,13 +38,12 @@ RenderSettings:
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 705507994}
- m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
m_UseRadianceAmbientProbe: 0
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
- serializedVersion: 12
- m_GIWorkflowMode: 0
+ serializedVersion: 13
+ m_BakeOnSceneLoad: 1
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
@@ -67,9 +66,6 @@ LightmapSettings:
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
- m_FinalGather: 0
- m_FinalGatherFiltering: 1
- m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_MixedBakeMode: 2
m_BakeBackend: 1
@@ -97,7 +93,8 @@ LightmapSettings:
m_ExportTrainingData: 0
m_TrainingDataDestination: TrainingData
m_LightProbeSampleCountMultiplier: 4
- m_LightingDataAsset: {fileID: 0}
+ m_LightingDataAsset: {fileID: 112000000, guid: 6c6756b3d6aa50248b97daa6cef80753,
+ type: 2}
m_LightingSettings: {fileID: 633987594}
--- !u!196 &4
NavMeshSettings:
@@ -196,6 +193,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -484,6 +484,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -546,6 +549,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3604669530
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -553,6 +559,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!114 &402668304
MonoBehaviour:
m_ObjectHideFlags: 0
@@ -565,6 +573,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 06b508cdcc0ba48ceaaf392863dcf743, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
GrabDistance: 5
--- !u!114 &402668306
MonoBehaviour:
@@ -578,6 +587,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -595,6 +618,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!1 &403665142
@@ -723,6 +747,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -829,6 +856,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -945,6 +975,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 593a2fe42fa9d37498c96f9a383b6521, type: 3}
m_Name:
m_EditorClassIdentifier:
+ NetworkManagerExpanded: 0
NetworkConfig:
ProtocolVersion: 0
NetworkTransport: {fileID: 620561613}
@@ -965,8 +996,12 @@ MonoBehaviour:
NetworkIdRecycleDelay: 120
RpcHashSize: 0
LoadSceneTimeOut: 120
- SpawnTimeout: 1
+ SpawnTimeout: 10
EnableNetworkLogs: 1
+ NetworkTopology: 0
+ UseCMBService: 0
+ AutoSpawnPlayerPrefabClientSide: 1
+ NetworkProfilingMetrics: 1
OldPrefabList:
- Override: 0
Prefab: {fileID: 8133991607019124060, guid: 421bcf732fe69486d8abecfa5eee63bb,
@@ -1004,6 +1039,8 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
m_ProtocolType: 0
+ m_UseWebSockets: 0
+ m_UseEncryption: 0
m_MaxPacketQueueSize: 128
m_MaxPayloadSize: 6144
m_HeartbeatTimeoutMS: 500
@@ -1165,9 +1202,8 @@ LightingSettings:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name: Settings.lighting
- serializedVersion: 6
- m_GIWorkflowMode: 0
- m_EnableBakedLightmaps: 1
+ serializedVersion: 9
+ m_EnableBakedLightmaps: 0
m_EnableRealtimeLightmaps: 0
m_RealtimeEnvironmentLighting: 1
m_BounceScale: 1
@@ -1176,6 +1212,8 @@ LightingSettings:
m_UsingShadowmask: 1
m_BakeBackend: 1
m_LightmapMaxSize: 1024
+ m_LightmapSizeFixed: 0
+ m_UseMipmapLimits: 1
m_BakeResolution: 40
m_Padding: 2
m_LightmapCompression: 3
@@ -1189,13 +1227,11 @@ LightingSettings:
m_FilterMode: 1
m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
m_ExportTrainingData: 0
+ m_EnableWorkerProcessBaking: 1
m_TrainingDataDestination: TrainingData
m_RealtimeResolution: 2
m_ForceWhiteAlbedo: 0
m_ForceUpdates: 0
- m_FinalGather: 0
- m_FinalGatherRayCount: 256
- m_FinalGatherFiltering: 1
m_PVRCulling: 1
m_PVRSampling: 1
m_PVRDirectSampleCount: 32
@@ -1219,8 +1255,6 @@ LightingSettings:
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
m_PVRFilteringAtrousPositionSigmaIndirect: 2
m_PVRFilteringAtrousPositionSigmaAO: 1
- m_PVRTiledBaking: 0
- m_NumRaysToShootPerTexel: -1
m_RespectSceneVisibilityWhenBakingGI: 0
--- !u!1 &702051983
GameObject:
@@ -1339,9 +1373,8 @@ Light:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 705507993}
m_Enabled: 1
- serializedVersion: 10
+ serializedVersion: 11
m_Type: 1
- m_Shape: 0
m_Color: {r: 1, g: 1, b: 1, a: 1}
m_Intensity: 1
m_Range: 10
@@ -1391,8 +1424,12 @@ Light:
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
m_UseBoundingSphereOverride: 0
m_UseViewFrustumForShadowCasterCull: 1
+ m_ForceVisible: 0
m_ShadowRadius: 0
m_ShadowAngle: 0
+ m_LightUnit: 1
+ m_LuxAtDistance: 1
+ m_EnableSpotReflector: 1
--- !u!4 &705507995
Transform:
m_ObjectHideFlags: 0
@@ -1845,6 +1882,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1945,6 +1985,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -1962,6 +2016,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!114 &963826006
@@ -1977,6 +2032,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3972363333
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -1984,6 +2042,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!65 &963826007
BoxCollider:
m_ObjectHideFlags: 0
@@ -2022,6 +2082,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2406,6 +2469,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 06b508cdcc0ba48ceaaf392863dcf743, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
GrabDistance: 5
--- !u!114 &1397037317
MonoBehaviour:
@@ -2419,6 +2483,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -2436,6 +2514,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!114 &1397037319
@@ -2451,6 +2530,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 1445980162
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -2458,6 +2540,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!54 &1397037320
Rigidbody:
m_ObjectHideFlags: 0
@@ -2523,6 +2607,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2645,6 +2732,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2713,6 +2803,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 06b508cdcc0ba48ceaaf392863dcf743, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
GrabDistance: 5
--- !u!114 &1402467445
MonoBehaviour:
@@ -2739,6 +2830,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 1148320762
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -2746,6 +2840,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!54 &1402467447
Rigidbody:
m_ObjectHideFlags: 0
@@ -2811,6 +2907,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2918,6 +3017,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3039,6 +3141,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3144,6 +3249,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3205,6 +3313,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 2710131580
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -3212,6 +3323,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!114 &1475593096
MonoBehaviour:
m_ObjectHideFlags: 0
@@ -3224,6 +3337,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -3241,6 +3368,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!224 &1536251758 stripped
@@ -3401,6 +3529,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3704,6 +3835,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
diff --git a/testproject/Assets/Scenes/SampleScene/LightingData.asset b/testproject/Assets/Scenes/SampleScene/LightingData.asset
index fd4cd58d9a..dbeab2c8aa 100644
Binary files a/testproject/Assets/Scenes/SampleScene/LightingData.asset and b/testproject/Assets/Scenes/SampleScene/LightingData.asset differ
diff --git a/testproject/Assets/Scenes/SampleScene/ReflectionProbe-0.exr.meta b/testproject/Assets/Scenes/SampleScene/ReflectionProbe-0.exr.meta
index d558288481..ba1375e150 100644
--- a/testproject/Assets/Scenes/SampleScene/ReflectionProbe-0.exr.meta
+++ b/testproject/Assets/Scenes/SampleScene/ReflectionProbe-0.exr.meta
@@ -93,32 +93,6 @@ TextureImporter:
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- - serializedVersion: 4
- buildTarget: WebGL
- maxTextureSize: 2048
- resizeAlgorithm: 0
- textureFormat: -1
- textureCompression: 1
- compressionQuality: 50
- crunchedCompression: 0
- allowsAlphaSplitting: 0
- overridden: 0
- ignorePlatformSupport: 0
- androidETC2FallbackOverride: 0
- forceMaximumCompressionQuality_BC6H_BC7: 0
- - serializedVersion: 4
- buildTarget: WindowsStoreApps
- maxTextureSize: 2048
- resizeAlgorithm: 0
- textureFormat: -1
- textureCompression: 1
- compressionQuality: 50
- crunchedCompression: 0
- allowsAlphaSplitting: 0
- overridden: 0
- ignorePlatformSupport: 0
- androidETC2FallbackOverride: 0
- forceMaximumCompressionQuality_BC6H_BC7: 0
spriteSheet:
serializedVersion: 2
sprites: []
diff --git a/testproject/Assets/Scenes/ZooSam.unity b/testproject/Assets/Scenes/ZooSam.unity
index fa6089ebef..fec7329dd6 100644
--- a/testproject/Assets/Scenes/ZooSam.unity
+++ b/testproject/Assets/Scenes/ZooSam.unity
@@ -13,7 +13,7 @@ OcclusionCullingSettings:
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
- serializedVersion: 9
+ serializedVersion: 10
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
@@ -38,13 +38,12 @@ RenderSettings:
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 705507994}
- m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
m_UseRadianceAmbientProbe: 0
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
- serializedVersion: 12
- m_GIWorkflowMode: 0
+ serializedVersion: 13
+ m_BakeOnSceneLoad: 1
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
@@ -67,9 +66,6 @@ LightmapSettings:
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
- m_FinalGather: 0
- m_FinalGatherFiltering: 1
- m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_MixedBakeMode: 2
m_BakeBackend: 1
@@ -97,7 +93,8 @@ LightmapSettings:
m_ExportTrainingData: 0
m_TrainingDataDestination: TrainingData
m_LightProbeSampleCountMultiplier: 4
- m_LightingDataAsset: {fileID: 0}
+ m_LightingDataAsset: {fileID: 112000000, guid: 4ac3c6a6e77b0234ab114d3c79575b8c,
+ type: 2}
m_LightingSettings: {fileID: 633987594}
--- !u!196 &4
NavMeshSettings:
@@ -196,6 +193,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -301,6 +301,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -407,6 +410,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -513,6 +519,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -619,6 +628,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -725,6 +737,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -831,6 +846,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -937,6 +955,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1043,6 +1064,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1149,6 +1173,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1255,6 +1282,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1323,6 +1353,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -1340,6 +1384,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!114 &108150026
@@ -1354,6 +1399,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 307c40a41954948e7a36bb6b64b4b9cb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_MoveSpeed: 5
m_RotationSpeed: 30
m_RunServerOnly: 1
@@ -1371,6 +1417,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3052257193
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -1378,6 +1427,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!65 &108150028
BoxCollider:
m_ObjectHideFlags: 0
@@ -1416,6 +1467,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1550,6 +1604,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1656,6 +1713,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1762,6 +1822,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1868,6 +1931,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -1974,6 +2040,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2079,6 +2148,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2185,6 +2257,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2291,6 +2366,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2397,6 +2475,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2503,6 +2584,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2609,6 +2693,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2715,6 +2802,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2821,6 +2911,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -2927,6 +3020,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3033,6 +3129,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3139,6 +3238,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3245,6 +3347,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3351,6 +3456,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3457,6 +3565,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3563,6 +3674,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3669,6 +3783,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3781,6 +3898,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 0
@@ -3798,6 +3929,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!114 &240282451
@@ -3812,6 +3944,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 307c40a41954948e7a36bb6b64b4b9cb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_MoveSpeed: -5
m_RotationSpeed: 30
m_RunServerOnly: 1
@@ -3829,6 +3962,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 2979526890
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -3836,6 +3972,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!65 &240282453
BoxCollider:
m_ObjectHideFlags: 0
@@ -3874,6 +4012,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -3996,6 +4137,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4102,6 +4246,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4208,6 +4355,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4314,6 +4464,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4420,6 +4573,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4526,6 +4682,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4616,6 +4775,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4737,6 +4899,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4843,6 +5008,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -4949,6 +5117,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5055,6 +5226,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5161,6 +5335,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5267,6 +5444,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5373,6 +5553,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5479,6 +5662,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5585,6 +5771,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5691,6 +5880,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5797,6 +5989,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -5903,6 +6098,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6009,6 +6207,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6114,6 +6315,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6220,6 +6424,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6326,6 +6533,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6432,6 +6642,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6538,6 +6751,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6736,6 +6952,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6842,6 +7061,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -6948,6 +7170,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -7054,6 +7279,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -7160,6 +7388,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -7266,6 +7497,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -7372,6 +7606,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -7478,6 +7715,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -7541,6 +7781,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 593a2fe42fa9d37498c96f9a383b6521, type: 3}
m_Name:
m_EditorClassIdentifier:
+ NetworkManagerExpanded: 0
NetworkConfig:
ProtocolVersion: 0
NetworkTransport: {fileID: 620561613}
@@ -7563,6 +7804,10 @@ MonoBehaviour:
LoadSceneTimeOut: 120
SpawnTimeout: 20
EnableNetworkLogs: 1
+ NetworkTopology: 0
+ UseCMBService: 0
+ AutoSpawnPlayerPrefabClientSide: 1
+ NetworkProfilingMetrics: 1
OldPrefabList: []
RunInBackground: 1
LogLevel: 1
@@ -7594,6 +7839,8 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
m_ProtocolType: 0
+ m_UseWebSockets: 0
+ m_UseEncryption: 0
m_MaxPacketQueueSize: 128
m_MaxPayloadSize: 6144
m_HeartbeatTimeoutMS: 500
@@ -7816,6 +8063,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -7856,9 +8106,8 @@ LightingSettings:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name: Settings.lighting
- serializedVersion: 6
- m_GIWorkflowMode: 0
- m_EnableBakedLightmaps: 1
+ serializedVersion: 9
+ m_EnableBakedLightmaps: 0
m_EnableRealtimeLightmaps: 0
m_RealtimeEnvironmentLighting: 1
m_BounceScale: 1
@@ -7867,6 +8116,8 @@ LightingSettings:
m_UsingShadowmask: 1
m_BakeBackend: 1
m_LightmapMaxSize: 1024
+ m_LightmapSizeFixed: 0
+ m_UseMipmapLimits: 1
m_BakeResolution: 40
m_Padding: 2
m_LightmapCompression: 3
@@ -7880,13 +8131,11 @@ LightingSettings:
m_FilterMode: 1
m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
m_ExportTrainingData: 0
+ m_EnableWorkerProcessBaking: 1
m_TrainingDataDestination: TrainingData
m_RealtimeResolution: 2
m_ForceWhiteAlbedo: 0
m_ForceUpdates: 0
- m_FinalGather: 0
- m_FinalGatherRayCount: 256
- m_FinalGatherFiltering: 1
m_PVRCulling: 1
m_PVRSampling: 1
m_PVRDirectSampleCount: 32
@@ -7910,8 +8159,6 @@ LightingSettings:
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
m_PVRFilteringAtrousPositionSigmaIndirect: 2
m_PVRFilteringAtrousPositionSigmaAO: 1
- m_PVRTiledBaking: 0
- m_NumRaysToShootPerTexel: -1
m_RespectSceneVisibilityWhenBakingGI: 0
--- !u!1 &644252816
GameObject:
@@ -7986,6 +8233,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8092,6 +8342,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8198,6 +8451,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8304,6 +8560,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8410,6 +8669,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8516,6 +8778,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8622,6 +8887,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8687,6 +8955,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 307c40a41954948e7a36bb6b64b4b9cb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_MoveSpeed: 5
m_RotationSpeed: 30
m_RunServerOnly: 0
@@ -8729,6 +8998,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8850,6 +9122,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -8917,6 +9192,7 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: 307c40a41954948e7a36bb6b64b4b9cb, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
m_MoveSpeed: 5
m_RotationSpeed: 30
m_RunServerOnly: 1
@@ -8934,6 +9210,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3301752843
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -8941,6 +9220,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!114 &678326395
MonoBehaviour:
m_ObjectHideFlags: 0
@@ -8953,6 +9234,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -8970,6 +9265,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 1
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!65 &678326396
@@ -9010,6 +9306,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -9133,6 +9432,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -9239,6 +9541,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -9437,6 +9742,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -9587,9 +9895,8 @@ Light:
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 705507993}
m_Enabled: 1
- serializedVersion: 10
+ serializedVersion: 11
m_Type: 1
- m_Shape: 0
m_Color: {r: 1, g: 1, b: 1, a: 1}
m_Intensity: 1
m_Range: 10
@@ -9639,8 +9946,12 @@ Light:
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
m_UseBoundingSphereOverride: 0
m_UseViewFrustumForShadowCasterCull: 1
+ m_ForceVisible: 0
m_ShadowRadius: 0
m_ShadowAngle: 0
+ m_LightUnit: 1
+ m_LuxAtDistance: 1
+ m_EnableSpotReflector: 1
--- !u!4 &705507995
Transform:
m_ObjectHideFlags: 0
@@ -9729,6 +10040,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -9835,6 +10149,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -9941,6 +10258,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -10047,6 +10367,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -10440,6 +10763,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -10546,6 +10872,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -10652,6 +10981,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -10758,6 +11090,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -10864,6 +11199,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -10970,6 +11308,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11076,6 +11417,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11182,6 +11526,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11288,6 +11635,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11394,6 +11744,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11500,6 +11853,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11606,6 +11962,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11712,6 +12071,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11818,6 +12180,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -11924,6 +12289,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12030,6 +12398,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12204,6 +12575,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12310,6 +12684,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12416,6 +12793,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12522,6 +12902,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12628,6 +13011,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12734,6 +13120,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12840,6 +13229,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -12946,6 +13338,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13052,6 +13447,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13158,6 +13556,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13264,6 +13665,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13370,6 +13774,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13476,6 +13883,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13582,6 +13992,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13688,6 +14101,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13794,6 +14210,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -13900,6 +14319,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14006,6 +14428,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14112,6 +14537,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14218,6 +14646,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14324,6 +14755,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14430,6 +14864,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14536,6 +14973,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14642,6 +15082,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14748,6 +15191,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14854,6 +15300,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -14960,6 +15409,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15066,6 +15518,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15172,6 +15627,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15278,6 +15736,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15384,6 +15845,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15490,6 +15954,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15596,6 +16063,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15702,6 +16172,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15808,6 +16281,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -15914,6 +16390,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16020,6 +16499,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16126,6 +16608,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16232,6 +16717,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16338,6 +16826,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16444,6 +16935,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16550,6 +17044,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16656,6 +17153,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16762,6 +17262,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16868,6 +17371,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -16974,6 +17480,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17080,6 +17589,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17186,6 +17698,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17292,6 +17807,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17398,6 +17916,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17504,6 +18025,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17610,6 +18134,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17716,6 +18243,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17822,6 +18352,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -17928,6 +18461,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18034,6 +18570,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18140,6 +18679,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18246,6 +18788,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18352,6 +18897,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18458,6 +19006,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18564,6 +19115,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18670,6 +19224,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18776,6 +19333,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18882,6 +19442,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -18988,6 +19551,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19094,6 +19660,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19200,6 +19769,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19306,6 +19878,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19412,6 +19987,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19639,6 +20217,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19745,6 +20326,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19851,6 +20435,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -19957,6 +20544,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20063,6 +20653,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20169,6 +20762,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20275,6 +20871,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20381,6 +20980,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20487,6 +21089,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20593,6 +21198,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20699,6 +21307,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20805,6 +21416,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -20911,6 +21525,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21017,6 +21634,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21123,6 +21743,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21229,6 +21852,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21335,6 +21961,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21441,6 +22070,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21547,6 +22179,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21653,6 +22288,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21759,6 +22397,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21865,6 +22506,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -21971,6 +22615,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22077,6 +22724,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22170,6 +22820,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22231,6 +22884,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 795516571
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -22238,6 +22894,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!114 &1495712169
MonoBehaviour:
m_ObjectHideFlags: 0
@@ -22262,6 +22920,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -22279,6 +22951,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!1 &1518464148
@@ -22354,6 +23027,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22460,6 +23136,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22572,6 +23251,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22677,6 +23359,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22783,6 +23468,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22889,6 +23577,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -22995,6 +23686,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23101,6 +23795,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23207,6 +23904,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23313,6 +24013,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23419,6 +24122,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23525,6 +24231,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23631,6 +24340,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23737,6 +24449,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23843,6 +24558,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -23949,6 +24667,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24055,6 +24776,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24161,6 +24885,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24267,6 +24994,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24373,6 +25103,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24479,6 +25212,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24585,6 +25321,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24691,6 +25430,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24797,6 +25539,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -24903,6 +25648,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25009,6 +25757,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25115,6 +25866,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25221,6 +25975,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25327,6 +26084,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25433,6 +26193,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25539,6 +26302,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25645,6 +26411,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25751,6 +26520,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25857,6 +26629,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -25963,6 +26738,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26069,6 +26847,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26175,6 +26956,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26281,6 +27065,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26387,6 +27174,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26493,6 +27283,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26599,6 +27392,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26705,6 +27501,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26811,6 +27610,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -26917,6 +27719,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27023,6 +27828,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27129,6 +27937,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27235,6 +28046,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27341,6 +28155,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27447,6 +28264,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27553,6 +28373,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27659,6 +28482,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -27848,6 +28674,20 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: e96cb6065543e43c4a752faaa1468eb1, type: 3}
m_Name:
m_EditorClassIdentifier:
+ ShowTopMostFoldoutHeaderGroup: 1
+ NetworkTransformExpanded: 0
+ AutoOwnerAuthorityTickOffset: 1
+ PositionInterpolationType: 0
+ RotationInterpolationType: 0
+ ScaleInterpolationType: 0
+ PositionLerpSmoothing: 1
+ PositionMaxInterpolationTime: 0.1
+ RotationLerpSmoothing: 1
+ RotationMaxInterpolationTime: 0.1
+ ScaleLerpSmoothing: 1
+ ScaleMaxInterpolationTime: 0.1
+ AuthorityMode: 0
+ TickSyncChildren: 0
UseUnreliableDeltas: 0
SyncPositionX: 1
SyncPositionY: 1
@@ -27865,6 +28705,7 @@ MonoBehaviour:
UseQuaternionCompression: 0
UseHalfFloatPrecision: 0
InLocalSpace: 0
+ SwitchTransformSpaceWhenParented: 0
Interpolate: 1
SlerpPosition: 0
--- !u!114 &1934616766
@@ -27880,6 +28721,9 @@ MonoBehaviour:
m_Name:
m_EditorClassIdentifier:
GlobalObjectIdHash: 3146719950
+ InScenePlacedSourceGlobalObjectIdHash: 0
+ DeferredDespawnTick: 0
+ Ownership: 1
AlwaysReplicateAsRoot: 0
SynchronizeTransform: 1
ActiveSceneSynchronization: 0
@@ -27887,6 +28731,8 @@ MonoBehaviour:
SpawnWithObservers: 1
DontDestroyWithOwner: 0
AutoObjectParentSync: 1
+ SyncOwnerTransformWhenParented: 1
+ AllowOwnerToParent: 0
--- !u!65 &1934616767
BoxCollider:
m_ObjectHideFlags: 0
@@ -27925,6 +28771,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28048,6 +28897,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28154,6 +29006,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28260,6 +29115,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28366,6 +29224,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28472,6 +29333,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28578,6 +29442,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28684,6 +29551,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28790,6 +29660,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -28896,6 +29769,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29002,6 +29878,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29108,6 +29987,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29214,6 +30096,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29320,6 +30205,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29426,6 +30314,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29532,6 +30423,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29638,6 +30532,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29744,6 +30641,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29850,6 +30750,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -29956,6 +30859,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
@@ -30062,6 +30968,9 @@ MeshRenderer:
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
+ m_RayTracingAccelStructBuildFlagsOverride: 0
+ m_RayTracingAccelStructBuildFlags: 1
+ m_SmallMeshCulling: 1
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
diff --git a/testproject/Assets/Scenes/ZooSam/LightingData.asset b/testproject/Assets/Scenes/ZooSam/LightingData.asset
index 635239ea06..41e9c3859c 100644
Binary files a/testproject/Assets/Scenes/ZooSam/LightingData.asset and b/testproject/Assets/Scenes/ZooSam/LightingData.asset differ
diff --git a/testproject/Assets/Scenes/ZooSam/ReflectionProbe-0.exr.meta b/testproject/Assets/Scenes/ZooSam/ReflectionProbe-0.exr.meta
index 34adcde9d6..32e31b581c 100644
--- a/testproject/Assets/Scenes/ZooSam/ReflectionProbe-0.exr.meta
+++ b/testproject/Assets/Scenes/ZooSam/ReflectionProbe-0.exr.meta
@@ -93,32 +93,6 @@ TextureImporter:
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- - serializedVersion: 4
- buildTarget: WebGL
- maxTextureSize: 2048
- resizeAlgorithm: 0
- textureFormat: -1
- textureCompression: 1
- compressionQuality: 50
- crunchedCompression: 0
- allowsAlphaSplitting: 0
- overridden: 0
- ignorePlatformSupport: 0
- androidETC2FallbackOverride: 0
- forceMaximumCompressionQuality_BC6H_BC7: 0
- - serializedVersion: 4
- buildTarget: WindowsStoreApps
- maxTextureSize: 2048
- resizeAlgorithm: 0
- textureFormat: -1
- textureCompression: 1
- compressionQuality: 50
- crunchedCompression: 0
- allowsAlphaSplitting: 0
- overridden: 0
- ignorePlatformSupport: 0
- androidETC2FallbackOverride: 0
- forceMaximumCompressionQuality_BC6H_BC7: 0
spriteSheet:
serializedVersion: 2
sprites: []
diff --git a/testproject/Assets/Tests/Runtime/NetworkManagerTests.cs b/testproject/Assets/Tests/Runtime/NetworkManagerTests.cs
index 5756f81b85..378b307ce5 100644
--- a/testproject/Assets/Tests/Runtime/NetworkManagerTests.cs
+++ b/testproject/Assets/Tests/Runtime/NetworkManagerTests.cs
@@ -9,9 +9,28 @@
namespace TestProject.RuntimeTests
{
+ public class NetworkManagerTests : NetcodeIntegrationTest
+ {
+ protected override int NumberOfClients => 2;
+
+ [Test]
+ public void ValidateTransportAndClientIds()
+ {
+ var transportId = m_ServerNetworkManager.GetTransportIdFromClientId(m_ServerNetworkManager.LocalClientId);
+ Assert.IsTrue(m_ServerNetworkManager.GetTransportIdFromClientId(m_ServerNetworkManager.LocalClientId) == m_ServerNetworkManager.ConnectionManager.ServerTransportId);
+ Assert.IsTrue(m_ServerNetworkManager.GetClientIdFromTransportId(transportId) == m_ServerNetworkManager.LocalClientId);
+
+ foreach (var client in m_ClientNetworkManagers)
+ {
+ transportId = m_ServerNetworkManager.GetTransportIdFromClientId(client.LocalClientId);
+ Assert.AreEqual(client.LocalClientId, m_ServerNetworkManager.GetClientIdFromTransportId(transportId), "Server and client transport IDs don't match.");
+ }
+ }
+ }
+
[TestFixture(UseSceneManagement.SceneManagementDisabled)]
[TestFixture(UseSceneManagement.SceneManagementEnabled)]
- public class NetworkManagerTests : NetcodeIntegrationTest
+ public class NetworkManagerSceneTests : NetcodeIntegrationTest
{
private const string k_SceneToLoad = "InSceneNetworkObject";
protected override int NumberOfClients => 0;
@@ -33,7 +52,7 @@ public enum UseSceneManagement
private bool m_UseSceneManagement;
- public NetworkManagerTests(UseSceneManagement useSceneManagement)
+ public NetworkManagerSceneTests(UseSceneManagement useSceneManagement)
{
m_UseSceneManagement = useSceneManagement == UseSceneManagement.SceneManagementEnabled;
}
diff --git a/testproject/Assets/Tests/Runtime/NetworkSceneManager/InScenePlacedNetworkObject/InSceneObjectDestroyTests.cs b/testproject/Assets/Tests/Runtime/NetworkSceneManager/InScenePlacedNetworkObject/InSceneObjectDestroyTests.cs
index 489452e6c9..9a01ceb5c1 100644
--- a/testproject/Assets/Tests/Runtime/NetworkSceneManager/InScenePlacedNetworkObject/InSceneObjectDestroyTests.cs
+++ b/testproject/Assets/Tests/Runtime/NetworkSceneManager/InScenePlacedNetworkObject/InSceneObjectDestroyTests.cs
@@ -2,6 +2,7 @@
using System.Linq;
using NUnit.Framework;
using Unity.Netcode;
+using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.TestTools;
diff --git a/testproject/ProjectSettings/Packages/com.unity.services.core/Settings.json b/testproject/ProjectSettings/Packages/com.unity.services.core/Settings.json
new file mode 100644
index 0000000000..e69de29bb2